How to create shortcuts and macros in Windows with Keypirinha, Launchy and mechanical keyboards

If you use your PC daily and are tired of always opening the same programs, create shortcuts and macros in Windows Using tools like Keypirinha, Launchy, or your keyboard's own software can be a game-changer. Going from multiple clicks to launching everything with a single key or a well-thought-out combination is a massive leap in convenience.

The problem is that, when you're coming from keyboards like Logitech or Razer With its super-polished software, jumping into a mechanical keyboard like a Keychron with VIA, QMK or custom launchers It can be challenging: different concepts, firmware limitations, shortcuts that sometimes work and sometimes don't… Here you'll see, step by step, how to set up a reliable macro system to open programs, what to do when Windows shortcuts fail, and how to use launchers like Keypirinha or Launchy to keep everything under control.

From gaming keyboards to mechanical keyboards: why macros change so much

Someone who comes from a keyboard like that Logitech G11 with its 18 extra keys And three profiles know how convenient it is to press a dedicated button and open a game, an app, or a script Without thinking. In Logitech's software (and Razer's too), you simply choose a key, assign it a an .exe file or a command with parameters And that's it: the keyboard takes care of everything.

When you switch to a mechanical keyboard like Keychron Q6 Max or V6 MaxThe situation changes. Many models use firmware based on QMK or VIA, or Keychron Launcher itself, and macros are managed differently there: instead of telling the key "run this .exe", most of the time you record keystroke sequences that simulate what you would do manually.

This makes functions that were once straightforward (opening a program with a click) less obvious processes: shortcuts that call up shortcuts, combinations that open the Run window and type a path, or even trigger the Windows search box. If this difference isn't fully understood, one might encounter macros that Sometimes they launch the app, and sometimes they do nothing..

Furthermore, many users encounter another problem: some Keychron keyboards do not cooperate with VIA immediatelyThis forces you to use Keychron Launcher or flash QMK firmware, which further complicates the learning curve and makes creating good macros seem more difficult than it actually is.

Shortcuts, Windows shortcuts, and why macros fail

One of the first ideas that are usually tried to create quick access to programs It's the typical Windows one: create a shortcutOpen its properties and assign it a key combination (for example, Ctrl + Alt + number). Then, try to make the mechanical keyboard execute that combination using a macro.

It sounds good on paper, but in practice chaos ensues: sometimes the shortcut works and opens the application, other times The shortcut does absolutely nothing.It doesn't matter if the shortcut is on the desktop or in a specific folder on the disk: the behavior remains inconsistent, and that's precisely what we don't want in a macro.

Combinations such as have been tested Right Ctrl + AltGr + 1 from the numeric keypad Or, using Left Ctrl + Num Lock, with more than ten different attempts, the typical result is infuriating: maybe the app opens once and then never again. It's not a reliable foundation for automating workflows, especially if you want a keyboard that works "like the old gaming keyboards."

That's why many users dismiss this method: relying on shortcuts with keyboard shortcuts Windows It is fragile, unpredictable, and also forces you to fill the desktop with icons that only exist for the macro to work, something that many people find inconvenient or simply unacceptable.

Ideally, the keyboard software, as with Logitech or Razer, would allow you to directly assign an .exe file to a key and forget about it. But with Keychron and other QMK/VIA-based keyboards, what you'll find in most guides is something else entirely: forward key combinations to shortcutsinstead of running commands real from the macro level itself.

Use the Windows Run dialog box as a "bridge" for your macros

Given the lack of a native option to associate .exe files with keys, a very practical alternative is to rely on the Windows Run dialog box (Win + R)The idea is quite simple: you use the macro to simulate pressing Win + R, typing a path or command, and then pressing Enter. It's what you would do manually, but compressed into a single action.

A typical example would be to build a macro like this in Keychron Launcher or VIA: {+KC_RGUI}{+KC_R}C:\path to my program.exeThat sequence should translate to "press the right Windows key + R, type the path to the executable." The problem is that, if left like that, typing errors often occur within the Run dialog box.

One of the first obstacles is handling quotation marks in paths with spaces. Without quotation marks, the path is "broken," and Windows only interprets part of it. The user intuits that it should look something like this: "C:\path to my program.exe"But at first he finds that the macro editor itself does not allow him to modify the code: the macro fields appear in gray and cannot be touched.

After unlinking the macro from the active profile and reconnecting the keyboard and software, you can edit the sequence and add quotation marks, key releases, and small delays to make the macro stable. It's precisely at this point that you need to fine-tune it: if the macro doesn't control the timings well, the text will arrive cut or mixed and the Execute won't know what to do.

A slightly more elaborate example that was tested was: {+KC_RGUI}{+KC_R}{-KC_R}{-KC_RGUI}»C:\path to\my\program.exe»{+KC_ENT}{-KC_ENT}On paper it works fine: open Run, release the keys, type the path in quotation marks, press Enter. In practice, a small time delay was enough for only part of the string or a jumble of characters to appear in the Run dialog box.

Adding delays to the macro: the key to preventing letters from being "eaten".

The way to turn that unstable macro into something truly robust was as simple as adding a small delay between opening Execute and writing the pathThat is, give Windows a few milliseconds to display the box before you start typing.

An improved version of the macro would look something like this, for example: {+KC_RGUI}{+KC_R}{-KC_R}{-KC_RGUI}{50}C:\path to\my\program.exe{+KC_ENT}{-KC_ENT}The number "50" represents a delay of 50 ms. It's small, but enough for the system to have time to open the Run window and receive the rest of the keystrokes without loss.

With that adjustment, the macro becomes much more reliable: you open Run, type the full path, and Windows launches the program without any problems. The only aesthetic drawback is that, working this way, the The Run window appears briefly every time you fire the macro, something that for some users is a minor detail and for others can be annoying.

Anyway, Functionally, it behaves similarly to direct combinations of Logitech and Razer.However, with that intermediate step visible. Those seeking only efficiency are usually satisfied, although there's always the nagging feeling of not having a "clean" association between key and executable.

However, there's another limitation to keep in mind: each complex macro you add takes up memory space in the keyboard's firmware. See typical messages Flash (1.44KB) 7.07% This suggests that with around 10 or 15 long macros, you might be approaching the limit. This is something to keep in mind if you plan to set up a "command center" with dozens of different access points.

Macros in VIA: structure, typical problems and how to interpret them

When you work with keyboards compatible with VIA or QMKMacros are stored internally in a structured format (usually JSON or similar), even though they may appear unreadable at first glance. An example of macro exported It might look like this:

,,,,,,,,,,,],[],[],[],[],[],[],[],[],[],[],[],[]]

Although it may not seem like it, that structure is quite logical: each entry describes when Press a key (2) and when it is released (3), associated with a readable name ("left alt") and a keyboard code (KC_LALT, KC_R, etc.). In the example, you can see that the macro presses Alt + R, then types the letters "c", "m", "d" and finally presses Enter.

The purpose of this macro is that, when the assigned key is pressed (for example, a button called "Circle" on the keyboard), the Alt + R combination is triggered, "cmd" is typed, and the command prompt is opened. symbol of the systemHowever, the observed behavior was that He just seemed to be pressing Enter. And nothing more, which indicates that something in the way the macro was played or the window focus was captured was not working properly.

These inconsistencies are common if the macro runs when the Windows focus is somewhere other than expected (a browser, a search box, another pop-up window, etc.). Ultimately, what the macro does is send keys "blindly" to the active focus, so if you don't know where they'll land, unexpected errors are likely.

Hence the importance of choosing the right method: you want your macro to be able to You absolutely must open the tool or program you need....without depending on which window you're currently in. That's why many users are abandoning Alt + letters, or even Win + search, and instead rely on the Run command or a dedicated launcher.

The "trick" of shortcuts in C:\Windows for more reliable macros

A very interesting approach to making macros with VIA or Keychron Launcher more reliable is to take advantage of how the internal workings of the run windowWhen you type text there, Windows doesn't perform a generic search, but rather checks specific system paths, and one of the main ones is precisely C:\Windows.

The idea is as simple as it is effective: instead of writing a long path to the executable, you create a program shortcut within C:\Windows and give it a short, easy name (for example, "VSCode" for Visual Studio Code). From then on, if you open Run and type VSCode, Windows will find the shortcut in that folder and launch the program without any problems.

The macro you need then boils down to something like: {KC_LGUI,KC_R}shortcut_nameWith the option enabled to send Enter at the end of the macro, press Win + R to open Run, type the shortcut name, and press Enter. This is much shorter than a full path like C:\Program Files\…

Additionally, the Run command It does not distinguish between upper and lower caseSo you don't have to worry at all about how you named the shortcut, just make sure it's clear and doesn't conflict with anything else on the system. This is a particularly useful trick for programs that initially caused problems when trying to open them from macros (Visual Studio Code was a major culprit in many cases).

This method has one small condition: you may need administrator permission To place shortcuts within C:\Windows, not all Microsoft applications require it (some are already specially registered and open by name without any workaround). But for other third-party programs, it's a very clean solution.

Keypirinha and Launchy: launchers that multiply your shortcuts

Beyond the Run window and keyboard macros, there are dedicated tools such as Keypirinha or LaunchyDesigned specifically to open programs, documents, or execute commands ultra-fast, they're like a "supercharged search" focused on productivity.

Keypirinha is a very light and powerful thrower that is almost entirely controllable. with the keyboard and through commandsYou can assign global shortcuts, create custom configurations, define aliases for programs, launch scripts, open specific folders, and more. Integrating it with your macros means that a single keystroke can open Keypirinha and, with a few letters, launch whatever you need.

Launchy, for its part, is a classic among application launchers. It indexes shortcuts and programs, and allows you to use a global key combination (like Alt + Space) to bring up a box where you type the app's name and open it instantly. It's less "geeky" to configure than Keypirinha, but it more than adequately fulfills the need for quick access to the entire system.

The magic happens when you combine these tools with your mechanical keyboard: instead of creating a complex macro that writes endless paths, you can create a very simple macro that just does call Keypirinha or LaunchyFrom there, the launcher takes care of everything, and you just focus on typing the program's name or alias.

This also has a major advantage over overloading the keyboard's firmware: Macros are reduced to a few keys (open launcher, maybe type a short alias) and leave the heavy logic to the system software side, which doesn't have the strict memory limit that the keyboard's flash memory does.

Microsoft PowerToys and Keyboard Manager: another option for shortcuts

A rather useful discovery for Windows 10 and 11 users is microsoft power toysA set of advanced tools created by Microsoft itself. Among them is "Keyboard Manager," which allows you to do very interesting things with shortcuts and keys.

With Keyboard Manager you can redirect key combinations to other combinations, or remap individual keys. This includes the ability to create shortcuts that launch programs without directly relying on the keyboard's firmware, which is especially valuable if your model has a strict macro limit or if its software (like Keychron Launcher) falls short.

The idea would be to create a global shortcut in PowerToys that opens a specific application, and then configure your keyboard so that fire that shortcut.That way, if you change your keyboard in the future or your current keyboard no longer accepts macros, your key combinations will continue to work as long as you have PowerToys installed and active.

In the specific case of some Keychron users, PowerToys remained as plan BSince macros using "Run" worked well in Keychron Launcher, it didn't seem essential to make the switch, but it remains an option to explore as soon as firmware limitations start to become a problem.

PowerToys' great advantage is that the entire operating system understands those globally remapped shortcuts, without depending on which application has the focus, which reduces many of the typical problems of macros that send keystrokes "blindly".