Mehdi Chaid

Mira

2026-01-01T00:00:00+00:00

gatekeeper

2025-07-11T00:00:00+00:00

chartlab

2025-04-30T00:00:00+00:00

devtool

2025-02-14T00:00:00+00:00

Some more convenient tools for W11

2024-12-13T00:00:00+00:00

There's quite a lot of very convenient features on most Linux DEs that are just not in Windows by default, so I'm showing here some of the useful ones I've found on W11.</p>

WinCompose</h2>
For writing code, I prefer using the classic US keyboard layout, but I also often need french letters and symbols for writing messages. Unfortunately, I'm not a fan of the french layout for writing code, as some of the very useful symbols like / and {} are a pain to type. I'm also not very fond of swapping keyboard layouts all the time.</p>
Most Linux distributions ship with something called `ComposeKey</code> by default that lets you type accent letters and much more, by composing them together. For example, é</code> can be written by pressing a compose key (that you set in your settings) followed by e</code> and '</code>. It's quite intuitive and you don't have to remember where each of the letters is on a french layout, which isn't always obvious.</p>`
`Well, Windows does not have Compose Key by default, but there's a really nice software on GitHub</a> that brings back that functionality. I've been using it for over 7 years, it's great.</p>`

Windhawk</h2>
Continuing the Microsoft tradition of making new Windows releases shittier than the previous ones, they removed
some useful features from W10 when W11 shipped.</p>
The right click contextual menu was dumbed down a lot for
"clarity", the taskbar is not locked to the bottom, can't be put as a topbar anymore, and it's always stuck on
your main monitor. Personally, I prefer having it on the top of my secondary monitor, to make it easy to watch the
time and the open apps.</p>
Recently, I found a new marketplace for Windows utilities called WindHawk</a>.
You can develop mods (basically dlls) that can be loaded to bring new features or restore old ones. It's a use at your
own risk kind of software though, because although Windhawk itself is opensource, I'm not sure how vested each of the
marketplace modules are, although the source code for them is available for them. The ones I've been using are:</p>

Classic context menu on Windows 11</li>
Primary taskbar on secondary monitor</li>
Taskbar on top for Windows 11</li>
</ul>
More AHK scripts</h2>
I mentioned AHK scripts in the linux workspaces in W11 note</a>, where I use it to swap desktops.
It can do a lot more, like launching apps with shorcuts, so here's a few examples I use. You can also use it to
launch a terminal at a specific File Explorer location, I'm leaving an example here.</p>
#b:: ; Win + B => Firefox
{
  Run "firefox.exe"
}

#q:: ; Win + Q => Wezterm
{
  OpenAndFocusWindow("C:\Program Files\WezTerm\wezterm-gui.exe")
}

#+q:: ; Win + Shift + Q => Wezterm open at location
{
  path := GetExplorerPath()
  if path {
    ; Always launch a new instance with the specific path
    Run('"C:\Program Files\WezTerm\wezterm-gui.exe" start --cwd "' path '"')
    ; Wait for the new window and activate it
    if WinWait("ahk_exe wezterm-gui.exe", , 2) {  ; Wait up to 2 seconds
      WinActivate("ahk_exe wezterm-gui.exe")
    }
  } else {
    OpenAndFocusWindow("C:\Program Files\WezTerm\wezterm-gui.exe")
  }
}

; ==================
; UTILITY FUNCTIONS
; ==================

OpenAndFocusWindow(cmd, winTitle := "", timeout := 500) {
    ; If no specific title provided, use the executable name
    if (winTitle = "")
        winTitle := "ahk_exe " . StrSplit(cmd, "\")[-1]

    if WinExist(winTitle) {
        ToggleWindow(winTitle)
    } else {
      Run(cmd)
      if WinWait(winTitle, , timeout) {
        ToggleWindow(winTitle)
      }
    }
}

ToggleWindow(winTitle) {
  if WinActive(winTitle) && WinGetMinMax(winTitle) != -1 {
      WinMinimize(winTitle)
  } else {
    WinActivate(winTitle)
  } 
}

GetExplorerPath() {
    hwnd := GetActiveExplorerHWND()
    if !hwnd {
        return
    }

    ; Retrieve the file path from the active Explorer window
    shellWindows := ComObject("Shell.Application").Windows
    for window in shellWindows {
        try {
            if window.hwnd == hwnd
                return window.Document.Folder.Self.Path
        } catch {
            continue
        }
    }
    return ""
}

GetActiveExplorerHWND() {
    ; Check for active Explorer window and return its hwnd
    activeWindow := WinActive("ahk_class CabinetWClass") 
                 || WinActive("ahk_class ExploreWClass")
    return activeWindow ? WinExist("A") : ""
}
</code></pre>
Winget</h2>
Although not as widespread as apt</code>, pacman</code>, yum</code>, etc, Windows have had package managers
for a while, such as Chocolatey</code> and Scoop</code>. Well, they also have an official one called
winget</code> now. It doesn't have all the packages the popular ones have but being the official manager,
it's catching up fast.</p>
I prefer managing my apps through a terminal personally, so winget is convenient
and it ships by default with W11.</p>

Linux workspaces in W11

2023-05-07T00:00:00+00:00

The issue</h2>
I've been using a bunch of different Linux desktop environments and windows managers over the past few years, from Gnome, KDE to bspwm and i3. However, I often have to develop on Windows as well for game development or work, and one thing that's been icking me is its attrocious multi-desktop support.</p>
In any of the different DEs and WMs I've used, it's been pretty easy to create multiple workspaces and assign keybinds in a config files for swapping between workspaces, sending apps to a different workspace, and assigning apps to a default workspace.</p>
On Windows, it's a different story. Workspaces are static, and switching between them is done with the `Ctrl</code> + Win</code> + ←</code> or →</code> keybinds (and there's this slow transition animation between workspace).</p>`

Basic solution</h2>
As far as I'm aware, there's no easy way to override the default keybinds for changing
workspaces, and I'm not aware of any keybind to send apps to different workspaces other
than Win</code> + Tab</code> and manually dragging them there.</p>

A convenient tool for scripting solutions like that for Windows is
Autohotkey</a>, which I've been using for a while for all
my scripting needs on Windows. It's well documented and easy to use. I used to have
an old fashioned way of doing things for workspace management, where I'd have a counter
for which desktop I'm in, and when I press Win</code> + Num</code> it would activate the default
windows shortcuts a number of times to reach the desired desktop. Something like that:</p>
#Requires AutoHotkey v2.0

currentDesktop := 1
totalDesktops := 4  ; Adjust to however many desktops you have

#1:: SwitchToDesktop(1)
#2:: SwitchToDesktop(2)
#3:: SwitchToDesktop(3)
#4:: SwitchToDesktop(4)

SwitchToDesktop(target) {
    global currentDesktop
    if (target = currentDesktop || target > totalDesktops)
        return

    if (target > currentDesktop) {
        loop (target - currentDesktop)
            Send "^#{Right}"
    } else {
        loop (currentDesktop - target)
            Send "^#{Left}"
    }

    currentDesktop := target
}
</code></pre>
The issue is that it's kind of hacky. AHK does not have a direct way of accessing virtual
desktops, and the API for them on Windows is... There's also no easy way to send apps to
virtual desktops with shortcuts.</p>
A better way</h2>
Recently, I came across this repository</a>.
It's a DLL for accessing the virtual desktops API easily in AHK (and there's binding for Rust as well!).
With this, I was able to update my scripts to directly go to the right desktop, skip the pesky slow animation
and even add keybinds to send apps to a desktop of my choice:</p>
#Requires AutoHotkey v2.0
SetWorkingDir(A_ScriptDir)

; =================
; VIRTUAL DESKTOPS
; =================

VDA_PATH := A_ScriptDir . "\virtual_desktop_accessor.dll"
hVirtualDesktopAccessor := DllCall("LoadLibrary", "Str", VDA_PATH, "Ptr")

if (hVirtualDesktopAccessor = 0) {
  MsgBox("Failed to load virtual_desktop_accessor.dll")
  ExitApp
}

GetDesktopCountProc := DllCall("GetProcAddress", "Ptr", hVirtualDesktopAccessor, 
                               "AStr", "GetDesktopCount", "Ptr")
GoToDesktopNumberProc := DllCall("GetProcAddress", "Ptr", hVirtualDesktopAccessor, 
                                 "AStr", "GoToDesktopNumber", "Ptr")
GetCurrentDesktopNumberProc := DllCall("GetProcAddress", "Ptr", hVirtualDesktopAccessor, 
                                       "AStr", "GetCurrentDesktopNumber", "Ptr")
MoveWindowToDesktopNumberProc := DllCall("GetProcAddress", "Ptr", hVirtualDesktopAccessor, 
                                         "AStr", "MoveWindowToDesktopNumber", "Ptr")

ActivateWindowUnderMouse() {
  MouseGetPos ,, &winID
  if winID {
    WinActivate(winID)
  }
}

GetDesktopCount() {
    global GetDesktopCountProc
    count := DllCall(GetDesktopCountProc, "Int")
    return count
}

GoToDesktopNumber(num) {
    global GoToDesktopNumberProc
    DllCall(GoToDesktopNumberProc, "Int", num, "Int")
    Sleep(50)
    ActivateWindowUnderMouse()
    return 
}

MoveCurrentWindowToDesktop(number) {
    global MoveWindowToDesktopNumberProc, GoToDesktopNumberProc
    activeHwnd := WinGetID("A")
    DllCall(MoveWindowToDesktopNumberProc, "Ptr", activeHwnd, "Int", number, "Int")
    DllCall(GoToDesktopNumberProc, "Int", number, "Int")
}

MoveOrGotoDesktopNumber(num) {
    ; If user is holding down Mouse left button, move the current window also
    if (GetKeyState("LButton")) {
        MoveCurrentWindowToDesktop(num)
    } else {
        GoToDesktopNumber(num)
    }
    return
}

; ========================
; VIRTUAL DESKTOP BINDINGS
; ========================

Loop 5 { ; Win + 1-5, can go up to 9 if needed
    n := A_Index - 1
    Hotkey("#" . A_Index, (*) => MoveOrGotoDesktopNumber(n))
}
</code></pre>
& voilà, Linux WMs shorcuts are now restored on Windows 11!</p>



On the fly access to PassGen
2016-09-17T00:00:00+00:00
In the previous article</a>, we made a small python script to generate a custom password with a given algorithm.</p>
The problem is, having to manually cd</code> into the script directory, run it and copy the output can be painful. Running the algorithm in your head or a piece of paper would be even more troublesome, although it is a good fallback scenario and one of the main strength of this approach: You don't have to remember the password, just the salt and the algorithm. The brain is better at recalling patterns than unreadable strings anyway.</p>
The solution</h2>
The idea here is that we need a small application, accessible anywhere in your device, that will take your salt and domain name as input and paste the password in the correct field for you, while keeping the previous status of your clipboard. After all, hoarding your password in your clipboard could be dangerous: Imagine you paste it in a chatbox later on!</p>
The app we'll build will look somehow like this:</p>

UI</h2>
For the UI, let's keep things simple: We'll use a library called zenipy</a>, a gtk-based dialog generator for python.</p>
First, let's install it:</p>
pip install zenipy
</code></pre>
I personally prefer keeping things contained withing virtual environnements, so I'll install it as follow:</p>
python -m venv env
source env/bin/activate
pip install zenipy
</code></pre>
You'll also need python3-gi</code>:</p>
pip install python3-gi
</code></pre>
Then, let's import zenipy at the top of our script. Since we're dealing with password, we'll use the password module instead of the regular text input.</p>
from zenipy import password
</code></pre>
Now, replace the input()</code> with zenipy's password()</code> method to prompt the password field to the user (a.k.a yours truly).</p>
service = password("Service")
salt = password("Salt")
</code></pre>
Run that, you get:</p>

Prompt from anywhere</h2>
The last step would be to make a shell script to run that python script, get the output, put it into the clipboard, paste the later in the password field and finally, restore the previous state of the clipboard.</p>
All of it could technically be done within our little python script with a library called pyperclip</a>, but I'm experienting issues related to the latest version of Ubuntu with this library.</p>
I'll cover both the python approach and the shell one.</p>
Python way</h2>
Install pyperclip:</p>
pip install pyperclip
</code></pre>
Then add the following code at the end of our PassGen script:</p>
old_clip = pyperclip.paste()

pyperclip.copy(password)

pyperclip.paste()

pyperclip.copy(old_clip)
</code></pre>
We save the previous state of the clipboard, copy the generated password, paste it and restore the old content of the clipboard.</p>
Shell way</h2>
Using shell, we can achieve the same result just as easily with xclip and xdotool, covered in a previous tutorial</a>:</p>
oldclip=`xclip -sel c -o`
temp=`/path/to/python /path/to/example.py`
echo $temp | xclip -sel c
sleep 0.5
xdotool key ctrl+shift+v
echo $oldclip | xclip -sel c 
</code></pre>
This code saves the previous clipboard state, run the PassGen script and paste the result where our cursor is. Then it restores the CTRL+C CTRL+V machine to its old glory, saving us the troubles of pasting passwords where undesired :)</p>
Now make this script runnable and you're ready to rock!</p>
chmod +x example.sh
</code></pre>
Accessing the script</h2>
Follow the guide at the end of the Bash Script for Token Pasting</a> tutorial to assign a keyboard shortcut to your script, and you'll be rocking this:</p>

End words</h2>
This concludes our little password generation adventure. We covered how to run a python script on demand from a custom keyboard shortcut, how to make a password generation script and how to make a small GUI to access it from anywhere, anytime you need it on your machine.</p>


Password generator with Python
2016-09-16T00:00:00+00:00
In the last article</a>, we covered the basics of bash scripting for pasting a 2FA token on demand. We'll now take this process a few steps further by adding support for password generation.</p>
What will we build?</h2>
We'll build today a prompt that, when called, will take as input a salt as well as a domain name, and output a unique password that works for you.</p>

How is it useful?</h2>
Consider this:</p>

You have a weak and meaningful password, that will be quite easy to bypass, but at least you can remember it.</li>
You have a long and strong password, that might prove harder to guess, but good luck remembering it.</li>
</ul>
Either way, any password can be hacked and it's always much safer to activate 2FA on your accounts.</p>
Now let's say you go with the second option and have a password with all the recommended criterias. Mixture of upper/lower cases, numbers, symbols, etc... You name it. Truth is, it might end up not as safe as expected, since you'll likely end up forgetting it and saving your password in some sort of safekeep. Maybe a text file, a password manager or some other form of way to have it under your hand when necessary.</p>
You're now at risk of exposing it, rendering the whole "stronger/longer password" process virtually worthless if it leaks.</p>
I was kind of thinking about that a few years ago and came up with another solution: A strong password that can still be remembered.</p>
The trick is, our brain is much better at keeping patterns in mind than unreadable strings. Instead of trying to recall a sentence, come up with an algorithm that will map an input to a password, given a set of rules that you define.</p>
Password generation</h2>
So how are we generating such password with an algorithm? That's pretty much up to you to decide how to encode your safe code, I'll give an example of one way of doing it. This process will take two inputs: A salt that's unique to you and a domain name, unique to the application you're login in to. You could choose to change that to a username, a special thing about each app, etc. We'll keep things simple for now.</p>
The salt will be composed of 4 numbers that you'll choose. Like a pin, it's the part you'll keep in mind and help making your password safe even if someone find your algorithm.</p>
The domain name will be a lowercase string with max length of 8. It will be responsible of providing a unique password for each website, while still making it easy for you to fetch it in case you forget the password.</p>
All you have to do is to remember the salt and the process, then you input your domain name and it will give you the unique password. With that in mind, I recommend you to use more than one salt for every app :)</p>
The algorithm</h2>
As I said, we'll keep the algorithm easy since it's only for demo purposes. I encourage you to come up with your own for personal use.</p>
The process will consist on four steps:</p>

Every vowel will be replaced by a given symbol:</li>
</ol>
vowels = {
    'a' : '!',
    'e' : '@',
    'i' : '#',
    'o' : '$',
    'u' : '%'
}
</code></pre>
I simply sorted the vowels alphabetically and mapped each one to the symbols in the US keymap, in order.</p>

Every recurring consonnant up to five times will be replaced by a given symbol:</li>
</ol>
recurring = {
    2 : '^',
    3 : '&',
    4 : '*',
    5 : '(',
}
</code></pre>
Again, US keymapping from where we stopped at the first step.</p>


We'll put a figure of the salt every three characters, and append the remaining ones at the end.</p>
</li>

Finally, every first character after a second number will be upper-cased, the rest will be lower-cased.</p>
</li>
</ol>
from collections import defaultdict 

# Your hashmaps here
[...]

def hash_word(input_word, salt_part):
    generated_word = ""
    appearance = defaultdict(int)
    figure = 0
    next_upper = 0

    for idx, c in enumerate(input_word.lower()):
        if idx % 3 == 0:
            generated_word += salt_part[figure]
            figure += 1
            next_upper += 1

        appearance[c] += 1

        if c in vowels:
            generated_word += vowels[c]
            continue
        
        if appearance[c] > 1 and appearance[c] < 6:
            generated_word += recurring[appearance[c]]
            continue
        
        if next_upper == 2:
            generated_word += c.upper()
            next_upper = 0
            continue

        generated_word += c
    
    if figure < len(salt_part):
        generated_word += salt_part[figure :]

    return generated_word
</code></pre>
All that's left is to call the function with the right input and the password is yours.</p>
if __name__ == "__main__":
    service = input("Service\n")
    salt = input("Salt\n")

    password = hash_word(service[:8], salt[:4])

    print(password)
</code></pre>
Result:</p>

Next steps</h2>
Feel free to adapt that example to your liking and use it for personal use. Tune it your way the best way you think, as long as you can remember it :)</p>
The next step in this little adventure will be to make a small desktop app that triggers on a certain key combo to fetch the password on demand — covered in the next article</a>.</p>


Bash script for token pasting
2016-08-27T00:00:00+00:00
Do you have two factor authentification activated on GitHub yet? You most definitely should. 2FA really helps making your account secure and you will regret not having it on your account the day someone get a hold of your password.</p>
Problem with 2FA</h2>
Let's assume you have taken a moment to setup 2FA on your account. You're now on your terminal trying to push some changes. You do a git push</code> and are asked to enter your username and password. Problem is: There's no field for your 2FA code.</p>
A possible solution is to go in your developer settings, select the Personal Access Token</em> tab and generate a new token.</p>
Personal access token</h2>
This token is a long hash that you can use in place of your password, which you can also restrain the level of freedom with your account. It acts like an OAuth token and can be used instead of your password over HTTPS. Such token can be restricted to pull a private repo, push, invite people to a repository, etc.</p>
The thing is, once one is generated, you have to save it and use it everytime you need to login, it won't be visible on your developer settings anymore for you to copy over from an other computer.</p>
Accessing the token</h2>
So now, you have the token saved in a text file for example, and everytime you try to login in your github account from a terminal or over HTTPS, you will need to open that text file, copy the token and then paste it on the password field in place of your password.</p>
Surely there is a way to make this whole process faster? That was the question haunting my mind when I was faced with this situation.</p>
The solution</h2>
I have been exploring various solutions, including messing Compose keys and other keyboard based options, and I knew what I wanted: A custom keyboard shortcut that will fetch the personal access token and paste it into the field when prompted.</p>
Being on ubuntu right now, I will use linux tools to achieve that goal. Note that a very similar process to what I'm about to describe is also available on OSX.</p>
The process</h2>
The solution is composed of many steps:</p>

Have the token saved on a text file.</li>
A special shortcut will fetch that token.</li>
The token is copied to the clipboard.</li>
It is then pasted into the password prompt.</li>
The old content of the clipboard is restored.</li>
</ol>
Step 1 is pretty straight forward. You get your token, save it into a file and close the file.</p>
Next, you'd want a script that will read that file and save its content in your clipboard. For linux, xclip</a>, a command line interface to the X11 clipboard, will do just fine.</p>
Create a token_accessor.sh</code> script and paste the following:</p>
xclip -sel c < /path/to/script/token_accessor.txt
</code></pre>
-sel</code> will tell xclip which X selection to use, in this case the c</code> clipboard option. Other options are p</code> for primary and s</code> for secondary. The <</code> will get the content of the token_accessor.sh</code> and write it in the selection.</p>
You now have the token saved on your clipboard. The next step is to paste it into the password field. We could do it manually by pressing ctrl</code> + shift</code> + v</code> but we might as well have the script do it for us.</p>
Auto-pasting</h2>
To get that, we'll need the script to be able to execute keyboard commands. xdotool</a> is perfect for that.</p>
sudo apt install xdotool
</code></pre>
We can now use it in our shell script as follow:</p>
sleep 0.5
xdotool key ctrl+shift+v
</code></pre>
sleep 0.5</code> is needed to let xclip finish executing. Then, we tell xdotool</code> to input the key combo ctrl</code>+shift</code>+v</code> for us.</p>
Here we go, you no longer have to open the file holding your token everytime you want to connect to GitHub over HTTPS.</p>
Restore the previous clipboard</h2>
We want to do that for two reasons:</p>

You usually don't want your token (aka password) on your clipboard and paste it in the wrong field, thus exposing it.</li>
You don't need the token on your clipboard at all time since the shortcut is pasting it anyway and chances are, it's overwritting what you had before that might be more useful for you.</li>
</ul>
Let's change the script to that:</p>
oldpw=`xclip -sel c -o`
xclip -sel c < /path/to/script/token_accessor.txt
sleep 0.5
xdotool key ctrl+shift+v
echo $oldpw | xclip -sel c 
</code></pre>
The first line saves the content of your current clipboard into oldpw</code>. Then at the end, we restore our clipboard from the same variable.</p>
Mac's OSX also have pbcopy</code> and pbpaste</code> to achieve a very similar result.</p>
Setup the keyboard shortcut</h2>
Now, the only thing left is to actually have a shortcut to execute that script.</p>
First, make it executable:</p>
chmod +x token_accessor.sh
</code></pre>
Then, depending on your system, you want to set a shortcut to execute the script. Navigate to Settings</code> -> Devices</code> -> Keyboard</code> and add a new shortcut with the following command:</p>
bash /path/to/script/token_accessor.sh
</code></pre>
Here we go, you can now enjoy a quick access to your token when needed!</p>
Next steps</h2>
Looking forward, we could use a similar script to paste a password of your choice into a field and keep the same behavior. Obviously, we don't want an actual password to be saved as is in a non secure text file. For that reason, we'll cover in the next article</a> how to generate passwords on the fly when using the script.</p>

Mehdi Chaid

Mira

gatekeeper

chartlab

devtool

Some more convenient tools for W11

Linux workspaces in W11

On the fly access to PassGen

Prompt from anywhere</h2> The last step would be to make a shell script to run that python script, get the output, put it into the clipboard, paste the later in the password field and finally, restore the previous state of the clipboard.</p>

Password generator with Python

What will we build?</h2> We'll build today a prompt that, when called, will take as input a salt as well as a domain name, and output a unique password that works for you.</p> How is it useful?</h2> Consider this:</p>

How is it useful?</h2> Consider this:</p>

The algorithm</h2> As I said, we'll keep the algorithm easy since it's only for demo purposes. I encourage you to come up with your own for personal use.</p> The process will consist on four steps:</p>

Bash script for token pasting