komokana VS fzf

kanata[1] and komokana[2].

kanata is basically like QMK for any keyboard without the firmware requirement. I use kanata with my trusty old iMac keyboard which is to this day my favourite keyboard of all time. But now I have all the cool QMK-style layers with it.

So that is awesome on its own, but where it gets even better for me, and this is where the seconds have really added up to hours, is that I wrote another piece of software which programmatically changes layers on kanata whenever a different window is focused in my tiling window manager.

This has honestly changed -everything- for me. I no longer have to waste keys on my keyboard to switch layers, I no longer have to -think- about switching layers, I just focus another window with alt+hjkl and whatever keyboard layer I expect for any given application is automatically applied. Definitely one of those "you can never go back" experiences for me.

[1]: https://github.com/jtroo/kanata

[2]: https://github.com/LGUG2Z/komokana

I have an Ergodox EZ sitting collecting dust these days. I got a great deal of use out of it and before long I was compiling my own firmware and making use of various advanced QMK features that were not available through the online visual layer configuration tool.

The keyboard has great build quality, the customer service is great (I got a free replacement for the right half after an issue with one of the keys), the ortholinear layout isn't that difficult to get used to, but ultimately the issue for me was that my hands aren't big enough to use the keyboard comfortably or to type as accurately as I'd like / as I'm used to typing.

I'm now back on my Apple Magic Keyboard and happier than ever, though with a few tweaks and improvements taken from my time using the Ergodox EZ.

I am now using kanata[1] which allows me to have multiple QMK-style layers on my regular old keyboard. This is already a huge step up from my pre-Ergodox days! I also like that I can have my layer configurations version controlled in a plain old git/dotfiles repo.

Since the layers are handled at the software level, I wrote my own integration with kanata, called komokana[2] to switch keyboard layers programmatically based on different state events emitted from my tiling window manager[3].

What that means in practice is that my keyboard can automatically switch to an app-specific layer when that app's window is focused, or to a workspace specific layer, or to a browser tab-specific layer, or really just switch on any event emitted by the window manager or any specific window manager state.

For me, this is really the killer feature of my setup now, and one that I don't think would be anywhere near as easy to implement with QMK which sits at the hardware level.

[1]: https://github.com/jtroo/kanata

[2]: https://github.com/LGUG2Z/komokana

[3]: https://github.com/LGUG2Z/komorebi

Hello friends! You may know me from my previous posts about my tiling window manager and my automatic keyboard layer switcher (or maybe even my harebrained attempts to get Helix to behave more like Vim!)

With all of these pieces now in place, I am very happy to introduce komokana. an automatic application-aware keyboard layer switcher for Windows.

In addition, I think bash's `operate-and-get-next` can be very helpful. When you go back through your shell history, you can hit Ctrl+o instead of enter and it will execute the command then put the next one in your history on the command line, and keep track of where you are in your history. This way, you can rerun a bunch of commands by going to the first one and Ctrl+o till you are done. And you can edit those commands and hit Ctrl+o and still go to the next previously run command.

Note: fzf's history search feature breaks this. https://github.com/junegunn/fzf/issues/2399

fzf : https://github.com/junegunn/fzf

Those are the most used aliases in my gitconfig.

"git fza" shows a list of modified/new files in an fzf window, and you can select each file with tab plus arrow keys. When you hit enter, those files are fed into "git add". Needs fzf: https://github.com/junegunn/fzf

"git gone" removes local branches that don't exist on the remote.

"git root" prints out the root of the repo. You can alias it to "cd $(git root)", and zip back to the repo root from a deep directory structure. This one is less useful now for me since I started using zoxide to jump around. https://github.com/ajeetdsouza/zoxide

> my history is so noisy I had to find another way

The fzf search syntax can help, if you become familiar with it. It is also supported in atuin [2].

[1]: https://github.com/junegunn/fzf#search-syntax

[2]: https://docs.atuin.sh/configuration/config/#fuzzy-search-syn...

You call it with `n` and get an interactive fuzzy search for your directories. If you do `n ` instead, it’ll start the find with `` already filled in (and if there’s only one match, jump to it directly). The `ls` is optional but I find that I like having the contents visible as soon as I change a directory.

I’m also including iCloud Drive but excluding the Library directory as that is too noisy. I have a separate `nl` function which searches just inside `~/Library` for when I need it, as well as other specialised `n` functions that search inside specific places that I need a lot.

¹ https://github.com/sharkdp/fd

² https://github.com/junegunn/fzf

View on GitHub

I do find the history pager stuff interesting, but ultimately not of tremendous use for me. I rebound all my history search stuff to use fzf[1] (via a fish plugin for such[2]), and so haven't been aware of the issues

[1] https://github.com/junegunn/fzf

[2] https://github.com/PatrickF1/fzf.fish

You can also use fzf with ripgrep to great effect:

[1]: https://github.com/junegunn/fzf/blob/master/ADVANCED.md#usin...