Function keys productivity trick (opens in new tab)

~/.config/i3/config:

  # emacsclient
  set $em_daemon ~/.local/bin/em

  # make a quick launcher for specific things I do all the time
  bindsym $mod+o mode "spotlight"

  mode "spotlight" {
       ## specific files in a new emacs buffer
       # dired in home
       bindsym d exec $em_daemon ~/; mode "default"
       # ibuffer
       bindsym e exec $em_daemon --eval "(ibuffer)"; mode "default" #
       # guaranteed new scratch buffer
       bindsym s exec $em_daemon --eval '(switch-to-buffer (format-time-string "%d %b %Y %H:%M:%S"))'; mode "default"

       ## common binaries
       bindsym f exec firefox ; mode "default"
       bindsym h exec --no-startup-id zeal ; mode "default"
       bindsym j exec --no-startup-id ~/.local/share/JetBrains/Toolbox/bin/jetbrains-toolbox ; mode "default"
       bindsym m exec --no-startup-id mendeley ; mode "default"
       bindsym k exec --no-startup-id keepassxc ; mode "default"
       ## special launchers
       # ipython
       bindsym i exec zsh -c '$alacritty -e ~/.local/pipx/venvs/ipython/bin/ipython'; mode "default"
       # app switcher
       bindsym a exec "rofi -show window -show-icons -theme gruvbox-dark-hard.rasi"; mode "default"
       ## just in case we did this by mistake
       bindsym Escape mode "default"
  }

I couldn't disagree more.

My mental sanity depends on some fixed beliefs. One of those is that every key sequence not involving the Win key is sent to and handled by the application in focus. Including F-keys, which many applications expect, in any case. Ex: F2=edit cell, F9=recalculate in Excel.

Global actions handled by the SO or DE must involve Win. Ex: Win+L lock screen.

And yes, Redmond-imposed Alt-Tab is an abomination: it should have been Win+Tab since the beginning.

The workflow you're proposing could be easily achieved with Win+ a carefully chosen letter. Benefits: 1. the letter is easier to remember; 2. You have 20-something free slots instead of 12 (excluding the ones that are already taken for standard actions like L for lock); 3. Most probably your fingers are already there and you have muscles memory of where the letters are; 4. Consistent, expected behavior of where keys are sent to.

In this kind of discussion people often focus solely on frequent actions, but there is one class of action that should have priority for the limited keys: the infrequent urgent. That is, tasks that don't happen that often, but when they do they are very urgent. For me the best example is the sound volume controls, I don't change sound volume nearly as often as I alternate between apps, but when I need to change the sound volume I need it right now, so that is what I'm using my F-keys for.

No, you're using the computer wrong. See, you should use a tiling window manager with several workspaces and shortcuts without having to look at your keyboard, e.g. Meta+4 to go to workspace 4 where you have your chat apps.

Windows users can do this by pressing Win+digit with open apps or apps you have pinned on the task bar.

Linux Mint, as with many other windows shortcuts, has this also

> You're using function keys wrong

You are using computers wrong.

Apple is the only one that lacks this. Windows and most linux WM have this for at least 20 years!

windows you just use WIN+[1,2,3,4...] to alternate between your quick launch apps.

Linux obviously you have a myriad of options. Including the top comment here now about using virtual desktops which is even better than application (but you can mix them too!)

And all that while still keeping your Fkeys functionality on each application!

The time I was forced to use a Mac for development was the time my productivity was lowest and frustration highest.

I'm fully convinced that Macs exist only because managers (and wanna be managers) make those decisions. Not to mention i've worked on employeer provided apple, dell, hp, lenovos... macs were the only ones i had to send to IT with failing keyboards, dead screens, etc.

While talking of function keys—

My greatest annoyance with keyboards is that Fn keys (as found to one side of the left Ctrl/Control key; ubiquitous on laptops and common on other keyboards) are always implemented in firmware, and simply don’t do anything with most of the keys, but implement them in such a way that I can’t either.

My laptop’s keyboard has one Fn key, and 82 others.¹ I can only use Fn with 20 of them—one is legitimately handled in firmware², one does nothing³, two emit combos⁴, and 16 emit distinct key codes. The remaining 62 keys? They just get passed through as though I weren’t holding down the Fn key.

I really wish I could use that Fn key just as a regular additional modifier. I use Super+[hjkl] in my tiling window manager, why can’t I use Fn+[hjkl] instead if I want to?

Yes, I know that shifting it all from firmware to driver would cause inconvenience in some situations. Look, perhaps we could at least begin by adding a key code for Fn when it’s tapped by itself or with any of the 62 keys. I dunno, Hyper or something (is Hyper a thing at that level? or is there some other extra modifier available?). That’s sufficiently pragmatic, right?

—⁂—

¹ Asus Zephyrus G15 (2021), GA503QM. I included the power button as one of the 82 keys, as I use it that way: I have XF86PowerOff switch to a Sway/i3 mode where pressing it again shuts down, r reboots, h hibernates, &c. It’s fun being like most projectors with their “press the power button again to show you actually meant it”. But you know my favourite key on the keyboard? XF86AudioMicMute. Really not looking forward to the inevitable day when I get a laptop without one again.

² Fn+Super disables/enables the Super key. Windows things. Wish I could disable this feature, because just occasionally I accidentally trigger it, and I will never want it.

³ As far as I can tell, Fn+Space just gets swallowed. evtest on the appropriate /dev/input/event* file doesn’t show anything being emitted.

⁴ Fn+F6 = Super+Shift+S, and Fn+F9 = Super+P, because those are standard Windows shortcuts. I don’t get why they did it this way, though they’re both very common, given how much more interesting stuff they’ve done than most others. Mostly I’m just grumbling about duplicates because I already want Super+P to do something else, so now Fn+F9 is a dead weight, though I would otherwise have used it.

Can people hit their function keys without looking at the keyboard? Sure, hitting F5 to go to your terminal is less keystrokes than e.g. Cmd+tab+tab, but I can't hit anything in the function row without glancing down at my keyboard. And I put a lot of value in looking at my keyboard as little as possible

For my Gnomies, the Run-or-raise extension [0] is stellar. It does exactly what it says: you bind a key combo to a launcher command, and optionally define a windowname or wm_class query to check for the existence of the program before it's launched. If it's running it's raised, if it's not then it's run. It has options for the window behaviour after toggling, optionally minimising the programs etc.

I can't rate it highly enough. It helped me finally step away from my decade-long i3wm-adhd addition, where everything else failed.

[0]: https://github.com/CZ-NIC/run-or-raise

So, let's say F2 does something important in an open app (e.g. "Rename file" in Explorer) - does that mean it would not work anymore?

Or am I missing something obvious?

This is not too different to how I've been using tiling window managers for the last decade.

There 9 or 10 virtual desktops which are accessed with WIN+1-0.

1 is for shells, 2 is the IDE, 3/4 are browsers, 6 is administrative stuff, usually a root shell, 0 is for zoom, 5,7,8 are less defined or just "whatever doesn't fit". In addition I'm using the multi-monitor switching from xmonad in i3 (i.e. if I have [1] on the left and [2] on the right screen, when I activate [1] while on the right one, they switch places, if I activate [3], then it will replace [2] and [1] stays on the left one).

It sounds very pedantic but I don't even have to think when context switching and it's made my life a lot easier. Interestingly it doesn't work as well on my private computer because (to no one's surprise) I am using many more GUI tools and do different things when not working.

For the macOS folks, I prefer rcmd to accomplish the same thing with less cognitive overhead: https://lowtechguys.com/rcmd/

If macOS didn't added a very annoying fade-out/fade-in delay when switching Spaces, you could simply use them with maximized apps and hotkeys for switching them. Another design mistake from Apple.

Charmstone [1] is a different take from everything mentioned here (I'm the developer).

The idea is to use your spatial memory to switch/launch apps faster than anything else that I've found, with a smaller learning curve and less memorization.

You can use keyboard shortcuts with the arrow keys, modifier keys + cursor movement, or a trackpad gesture.

[1] https://charmstone.app

I've recently bought an Elgato Stream Deck*[0] (programmable 15-key LED macro-pad) and would strongly recommend it. Simply: define an icon, define a shell script/app/site and press a button to execute.

It natively supports 'profiles' for contextual actions if a given application is active, and 'folders', to extend the actions available given the 15 key limitation.

I believe there's also a SDK + plugin infrastructure which lets you define live-updating icons, but I haven't given this a try.

[0] https://www.elgato.com/en/stream-deck-mk2

* EDIT to differentiate from Steam Deck

Another way of doing this is assign Hyper key to Caps Lock with Karabiner and then use that to set up hyper+X shortcuts to different or macros using Hammerspoon.

So e.g. I have hyper+a for Alacritty, hyper+b for Browser etc.

I think this workflow is interesting and the title unfortunately clickbait-ish. We can read about things we find interesting without claiming X is better.

No. My function keys are used for things I do more often, like change color profiles, toggle a single app into dark mode, etc.

My favorite trick is not the function keys but other "useless" keys: like Caps is remapped to be Esc (when released before another key is pressed) or Control (when used in conjunction with another key: act as a modifier), my 2 shifts and 2 alt do their normal modifier function (when used in conjunction with another key) but when used by themselves act as PageUp/PageDown Home/End

Going up 2 pages up in the browser? Shift Shift. Top of the page? Alt. Bottom? The other Alt.

For the Control keys, as I don't need that many I've experimented with a few remapping, but BackSpace/Delete are very handy.

Going to the previous page in the browser? Alt+Control.

I’ve tried _so_ many different desktop workflows (including writing two custom window managers!), and I’ve finally settled for the exact same workflow - F -keys bound to my most common apps, all fullscreened. It becomes muscle memory within two weeks, and it’s faster than anything else I’ve tried by a mile. I use Thor for MacOS if anyone wants to replicate it, it’s a no-fuss version of the author’s setup.

If I ever do need to see two things side-by-side, I’ve also got Rectangle for window positioning. A single cmd+caps lock+H/J/K/L for left-half/restore/maximise/right-half is all I’ve found is necessary.

Karabiner has already been mentioned here but I'll add that goku (https://github.com/yqrashawn/GokuRakuJoudo) is THE way to setup Karabiner and it can be hard to overcome the extremely verbose and unergonomic default json config of Karabiner otherwise. Goku also makes it trivial to add shortcuts which are activated by quickly pressing one key while another is held. I use this for the kind of launch mode described in the OP. eg. w + e = editor (Intellij), w + r = chrome, w + f = firefox.. The drawback to these shortcuts is that they can unintentionally be activated when regularly typing since we don't always release a key before pressing the next. That's only happened seldomly for me though since "w" isn't a frequently used letter and I've set the shortcut activation window pretty low so the w + <key> key has to be pressed essentially immediately after w.

Similarly, I use q + w for previous tab, q + e for next tab, and s+d to open the clipboard history from Alfred

I like my hands resting near the bottom of the keyboard, so Cmd-tab is very quick as it is within reach and does not require using my eyes. To use those function keys I’d have to look at the keyboard, which feels like a waste of time.

Though I’d rather have function keys back instead of the touchbar, as changing volume/brightness now requires looking at the keyboard as well as a certain precision/dexterity.

Edit: formatting.

I bind mine to virtual desktops, but I have the same applications on each desktop all time, so the workflow is quite similar.

All the apps I use the most are open most of the time. I can just use cmd+tab to switch between them quickly.

To each their own, but this feels unnecessary to me in my own personal workflow. I've never thought to myself "boy I wish I could open one specific app, that wasn't already open, with a single keystroke"

Alfred workflow instructions in case you don't wish to use Keyboard Maestro for this:

https://ldstephens.medium.com/launch-your-favorite-mac-apps-...

A better "hack" for linux users: Linux supports a "digital-only" modifier called "Hyper". You can use Xmodmap to set a key as hyper on press, and set Hyper-F[X] to whatever functions you wish to.

Alternatively, use a keyboard with QMK, or install a dedicated application like KMonad.

Eh..?

Don't get me wrong - if it works for you or OP, great! Keep doing it. I use Sway and KDE depending on what tickles my fancy.

For application launching, I just use Alt+Space and type the first few letters of what I want. My frequent flyers get assigned to Meta+Alt+Letter.

- Krunner / Rofi - Alt+Space (Meta+D was a bit contorted for me) - Meta+Enter - Konsole (KDE) / Kitty (Sway) - Meta+Shift+<1-0> - move active window to desktop - Meta+1-0 - switch to desktop #1-#10

A lot of apps use F-keys so it's not a good fit for me. When possible, I like to map custom shortcuts for various applications using F-keys.. not use it as an application launcher.

For example: With Dolphin, I've gotten used to F2 for renaming (Windows holdover), F3 for split file view, F4 for terminal, F5 for refresh

Kate or VS Code, I tend to map F5 to Build/Run/Debug.

I can't hit Fn keys reliably without looking. Instead I mapped switching to my common programs to `fn+h/j/k/l` and other closeby keys (firefox = fn+h, vscode = fn+j, etc). My right-hand fingers are already on hjkl anyway, it's much much faster for me :)

Is there a keyboard-oriented window manager that doesn't require memorizing what keys do what?

What I envision is having one master key combination to pull up a panel or overlay of some sort, which displays which key I press next to go to a certain place, or do a certain action. So there's just one thing to memorize.

Sort of like how vimium works in browser, where you press 'f', and each clickable gets a little label. (But preferably not randomly assigned)

The memorizing-most-commonly-used-50-keyboard-combination thing really doesn't work for me, whether it's home row or function keys. I mean, I still have to look at the little pictures for stove knobs after years of using the same stove, and that's just four knobs.

I have a Stream Deck that I set up to change the LCD's based on what the current in focus application is. I also have a button on each of the custom screens that gets me to the "Main Macro" pad.

I strongly recommend them for programming.

They save me so much time.

For MacOS there is Hammerspoon, that provides immensely powerful scripting, but can merely open and close the apps, too.

  -- ~/.hammerspoon/init.lua
  function define_shortcut(appName, key, mod)
    hs.hotkey.bind(mod, key, function()
      hs.application.enableSpotlightForNameSearches(true)
      local app = hs.application.find(appName)
      if app and app:isFrontmost() then
        app:hide()
      else
        hs.application.open(appName)
      end
    end)
  end

  define_shortcut("Alacritty", "F1", {})
  define_shortcut("Firefox", "F2", {})

Personally I’ve been using a similar approach for over a decade where I have 9 desktops on my Mac most of which have fixed windows on them eg 1 for a file explorer, 2 for mail, 3 for browser, 4 and 5 for IDEs, 6 for related tooling, 7 for notes and maybe another browser window, 8 for music, and 9 for chat windows and I switch between them with Ctrl+<number>. On top of all of them desktops I can Ctrl+Space the terminal (Quake style, Warp now, used to be iTerm) and Alt+Space for Raycast (used to be Alfred). This was I rarely if ever need to Cmd+Tab since everything is fixed in place most of the time.

linux user (kde, cinnamon, etc.). I have been using ctl-f1,ctl-f2, etc to switch between virtual desktops since about 2000. Each virtual desktop is labeled like 'email', 'docs', 'browser', 'editor', 'sql' etc. At each desktop I can alt-tab between a couple of apps, say IDEA and a terminal, or SquirrelSQL and a terminal. So I navigate apps by first selecting the correct desktop and then possibly alt tabbing a little bit. That works well for me and I think probably a lot of users since it's the default behavior after install.

Is it okay to use them for what they are actually useful for? F3 = repeat search, F5 = refresh, etc, etc, all context dependent, of course, but that is a good thing. Mac people I do not understand.

I use Karabiner-Elements and Hammerspoon to map caps lock to a "hyper" key, so browser is hyper+b, text editor is hyper+t, terminal is hyper+s, notes/tasks (Obsidian) is hyper+k, etc.

You can do something similar (albeit less fancy) without using any 3rd party applications on macOS.

1. Open Automator.app and create a Quick action.

2. Drag "Launch Application" to the workflow and choose an application to open. Save it.

3. Open Preferences -> Shortcuts -> Services and assign a keyboard shortcut to your action. Unfortunately, macOS will not let you assign many combinations. The other annoying thing is that running the shortcut is not instantaneous, there seems to be a noticeable delay before the action executes.

You know, the CTRL-Fn combinations are usually mapped to virtual workspaces on Linux, what is much more powerful than applications and give you the same kind of speedup.

Who organizes things around application anyway, instead of windows?

Anyway, no, it's bad to remap the Fn keys. They have been used to fast intra-application navigation since they appeared, and they are still in wide use. (Does the author not use application shortcuts?) Combining them with another key is just obvious.

I use my function keys for other things within programs.

I use Alfred on macOS to quickly launch various apps and actions using the launcher hotkey plus a few chars. I don't have a problem with my workflow, and it syncs between my Macs.

I am doing similar with Albert on Linux, with the goal of someday moving back to Linux full-time.

At this point, I have a vast collection of workflows and snippet completions and I feel like my experience is pretty optimized for my tasks, but you do you.

This kind of use case should have been what the Touch Bar supported.

I was actually excited when the Touch Bar came out because I though I would finally be able to just have named buttons, even click-through menus, instead of having to memorize what f1-f12 did on a given app.

Imagine if instead of “ok, f1 opens my [some application], I just need to memorize that” you could just add a button that says [some application]”.

Sadly the support for the Touch Bar was pretty middling to poor.

The function keys are too far away for such frequent operations, so it's much better to map apps to regular alpha keys (some can also have a mnemonic benefit like 'f' for File manager) with a modifier, e.g., CapsLock or even Space (though these would need to be behind a tiny delay not to interfere with typing), with a proper keyboard remapping app like Karabiner

My favorite function key trick is to first move the number keys into a “virtual numpad” and then move the function keys down onto the unused number row. That way the function keys are easy to reach without looking and always available without conflicting with the laptop’s media/utility keys.

This is exactly why I like to use a gaming keyboard with extra programmable function keys off to the left side. All the flexibility without having to override any default functionality that the standard keys might have.

Edit: Also, dedicated media keys and a volume control wheel/knob are a must!

I use the same concept in Emacs/EXWM to launch/jump/bury X11 and native buffers, + mod.+keys for extras like F5 run notmuch, C-F5 access unread tag directly, M-F5 compose a new message etc.

That's why I damn HATE the disappearance of classic MANY-keys keyboards...

In the discussion of standards, standardisation, and reserving specific keystrokes for specific contexts (applications, OS / windowing system, increasing Web browser (an increasingly inadequate description), etc., we have ... an embarrassment of riches. Or something like that.

The first standardisation within a GUI context I'm aware of was the Common User Access system on IBM PCs. That grew out of the early PC era within which different programs had their own idiosyncratic command-key conventions, several of which are listed in the Wikipedia article on the topic:

<https://en.wikipedia.org/wiki/IBM_Common_User_Access>

This still wasn't the first such standard. IBM already had fairly standardised function-key conventions under MVS and TSO/ISPF. The Unix world inherited emacs functions from ITS (as a set of macros over the TECO editor), vi keybindings, and a number of other conventions. Emacs commands have been incorporated into Readline, and are generally available on bash and similar shells.

There was a revision of CUA under Windows (whose name / initialism I forget), as well as a set of interface guidelines for Apple's classic Macintosh, as well as MacOS / OS X). Within the Linux world, GNOME and KDE offer the HIG, Human Interface Guidelines.

And various X11 window managers offer their own shortcuts and hotkeys (I've long used and extended a set for WindowMaker, for my own use, which incorporate some of the ideas in the submitted article).

There's also the browser environment, in which there are often conflicts: browser-versus-OS (window manager / GUI shell), browser-versus-webapps (e.g., a site's own specific keybindings), and browser-versus-extensions, such as, say, Vimperator, which provides a vi/vim-like keybinding interface to major browsers.

A key problem is that once a standard does emerge, interface conventions change, often profoundly. And independent evolved systems (e.g., Emacs, VIM, CUA, MS Windows, Apple Mac, ...) have a rather stubborn persistence measured in decades. Moving from mainframes to minis to PCs to GUIs and over the past decade to both mobile/touch- and Web-based applications, and arguably voice-based (Siri, Google, Alexa, Cortana, ...) are further confounding standards. Given that the user-base of smartphones / tablets is now roughly 10x that of desktop-based systems, design principles for smartphones seem to be driving desktop conventions, regardless of suitedness to task.

You can use Win+[number on the row key] on Windows to do this, no configuration required. The number corresponds to the position of an app on the taskbar. You can pin apps to the task bar to make sure they are always in the same position.

I remap the useless caps lock to AltGr and then customize the whole keyboard. Mostly for unicode characters, but some shortcuts too—especially those F keys. I'm using Linux and do it with xkb. Can write a blog article if anyone is interested.

I do this using Win+1,2,3,4,etc on Windows and Gnome 3. I believe this has been a feature since Windows 7. It's one of the first features I look for when trying out a new Linux desktop environment since it's so convenient.

Gnome assigns SUPER+NUM to the applications in the sidebar by default. You can change the applications or their order visually and the keyboard shortcut is highly accessible.

It's one of the well thought features that makes me stick with it.

I honestly had to glance down at my keyboard to see if it had function keys.

I map the function keys to virtual desktops, but same idea. And CAPLOCK to Alfred to select apps. Super easy on Mac, and difficult to do on Linux, the main reason I don't like Linux desktops. To each their own.

In macOS, just CMD-<space>,t-e<enter> will give me a terminal.

So many keys, you say. Well, it takes me probably 1/10 the time to hit fn-F1.

Also, no extra app, Chrome is just CMD-<space>,c-h<enter>.

Another solution to this problem is to get a standalone numpad and assign the keys as hotkeys. Lots of macro apps allow different functions to be assigned to specific keyboards.

Looking forward to try it out! Sounds like a great thing!

Would be nice to have a usb keypad and perhaps a little oled screen in each keycap to implement this… my function keys are pretty overloaded with stuff now.

I really want my keyboard brightness key back. The M-series MacBooks have Siri and … something else I don’t use instead of keyboard brightness.

The best productivity hack is to get a keyboard with programmable QMK firmware and remap the keys however/wherever you want.

Basically, your applications are pinned to positions on a task bar, and that task bar is made of a row of physical buttons.

I just use rofi and type what I want to launch. I dont really see the need for all this.

f1 key in its default 'help' function is so remarkably useless, i just remap it to Enter. and then, remap tilde to to Left and Caps Lock to Right, and you've got a neat little navigation block on the left side of the keyboard.

Or... put them on your Dock?

To all of the "No, youre using computers wrong" responses all I can say is they did declare that they are a web developer...