XKB layout cycling

[postsolar]

I've been struggling for a while with making Kanata play nice with multiple keyboard layouts, including layouts not based on the Latin alphabet. Now that I came up with a solution that feels more or less alright, I decided to share it with the community.

Unfortunately this is somewhat specific (perhaps inherently so) to my setup, so one would need to adapt it to their own environment in order to use it.

Problem

If Kanata is used to define a custom layout (eg Colemak), it's all nice as long as it's the only layout used. Using other layouts exposes us to some issues:

• Non-Latin-based layouts don't work well — defining one in Kanata by spamming (unicode …) is unreliable
• Switching non-Latin-based layouts via XKB could mess up keys positions if the layer used by Kanata doesn't represent the keyboard
• Even if it did, cycling the layouts with the same key (ala SUPER+Space on Windows) still isn't possible

To sum it up, I want Kanata to provide me a custom layout for English language but not interfere with anything else.

Solution

1. Define a layer which corresponds to the underlying keyboard (i.e. defsrc and maybe some mods)

;; QWERTY to switch to other layouts
(deflayer qwerty
  esc    f1     f2   f3  f4  f5  f6  f7  f8  f9  f10  f11  f12  prnt  ins  del
  grv    1      2    3   4   5   6   7   8   9   0    -    =    bspc
  tab    q      w    e   r   t   y   u   i   o   p    [    ]    ret
  @escc  a      s    d   f   g   h   j   k   l   ;    '    \    
  lsft   lsgt   z    x   c   v   b   n   m   ,   .    /         rsft
  @slc   @smt   @my-alt         spc                       @nlo  rctl
)

2. Define a @nlo (next layout) alias which would trigger layout cycling

;; Next layout
(defalias nlo (push-msg "next-layout"))

In the previous section, I chose right alt to put this key on, but obviously you're free to put it anywhere you'd like.

3. Create a TCP client which would listen to the messages sent by Kanata and act on them

I chose ZSH to implement it because it appears to be faster than netcat while still being a good choice for a small IO-oriented script. I use Hyprland so switching the XKB layout for me would involve hyprctl. Dependencies include ripgrep and fx (could be substituted with jq, if you prefer that).

layout-switcher.zsh

#! /usr/bin/env zsh

set -euo pipefail

zmodload zsh/net/tcp

# connect to kanata's tcp server
# don't forget to change the port to the one you actually use
port=${KANATA_PORT-1111}
ztcp 127.0.0.1 $port
fdRead=$REPLY

# another fd for sending messages -- we don't want
# this one to mess with the one listening, because it
# causes bugs in parsing the output
ztcp 127.0.0.1 $port
fdSend=$REPLY

# hyprctl helpers
currHyprlandLayout () {
  hyprctl devices -j \
    | fx .keyboards '.find(kb => kb.main)' .active_keymap
}
nextHyprlandLayout () hyprctl switchxkblayout kanata next

# main loop
# the layout switching logic lives here
# each time the `@nlo` key is pressed, kanata would send us a message and the code
# inside this loop will be executed
# this is where you could adapt the script for the programs you're using (eg WM/DE)
# or for the logic you'd like it to have
rg 'next-layout' --line-buffered <&$fdRead | while read -r _; do
  # switch the XKB layout
  nextHyprlandLayout
  # query current layout (ie the one we just switched to)
  currLyt=${ currHyprlandLayout }

  # if it's English, switch to the Kanata layer we want to have for English
  if [[ $currLyt = 'English (US)' ]]; then
    print '{"ChangeLayer":{"new":"my-fancy-layer"}}' >&$fdSend
  # otherwise, assert using the qwerty layer
  else
    print '{"ChangeLayer":{"new":"qwerty"}}' >&$fdSend
  fi
done

4. Start kanata with a dedicated port for the TCP client and start the script

$ setsid -f kanata -c ~/.config/kanata/my-config.kbd -p 1111
$ setsid -f ~/.config/kanata/layout-switcher.zsh

---

If you have suggestions on how to simplify this, please share!

[jtroo]

If one were willing to use a cmd-enabled version of kanata, another way to do this might be:

Note (untested):

(defalias
  ;; 0,1,2 are defined by order declared for device. See https://wiki.hyprland.org/Configuring/Using-hyprctl/#switchxkblayout
  kb0 (multi (layer-switch fancy) (cmd sh -c "hyprctl switchxkblayout kanata 0"))
  kb1 (multi (layer-switch qwerty) (cmd sh -c "hyprctl switchxkblayout kanata 1"))
  kb2 (multi (layer-switch qwerty2) (cmd sh -c "hyprctl switchxkblayout kanata 2"))
)
(defsrc ... ralt)
(deflayer fancy ... @kb1)
(deflayer qwerty ... @kb2)
(deflayer qwerty2 ... @kb0) ;; probably good to use templates to avoid duplication

The disadvantage is extra memory consumed by the duplicated qwerty layers, I would guess in the range of 50-200 KB per layer - though I should calculate this precisely some day 😄

[postsolar]

Didn't try this approach yet either, but I think this would require (re)starting Kanata after starting Hyprland, otherwise hyprctl wont have $HYPRLAND_INSTANCE_SIGNATURE set and wont be able to connect to Hyprland's socket.