Skip home row mods while typing

[argenkiwi]

I though I would share an alternative to #1425 which consists of skipping the home row modifiers while typing:

(defcfg
  process-unmapped-keys yes
)

(defsrc
)

(deftemplate charmod (char mod)
  (switch 
    ((key-timing 3 less-than 250)) $char break
    () (tap-hold-release-timeout 200 500 $char $mod $char) break
  )
)

(deflayermap (main)
  a (t! charmod a lmet)
  s (t! charmod s lsft)
  d (t! charmod d lctl)
  f (t! charmod f lalt)
  j (t! charmod j lalt)
  k (t! charmod k rctl)
  l (t! charmod l rsft)
  ; (t! charmod ; rmet)
  v (t! charmod v ralt)
  m (t! charmod m ralt)
)

In essence, we use switch to check a key-timing condition that evaluates the elapsed time since a key, determined by the key-recency, has been pressed. By setting the key recency to the maximum number of modifiers we will hold at any given time, we make sure our chords work as expected.

I will experiment more with this approach when I am back at work using it in real world scenarios, but early testing looks promising!

UPDATE: I have added a defcfg block and set process-unmapped-keys to yes (see comment below).

[argenkiwi]

A bit if context: I commented on the discussion mentioned above that project keyd has an action overloadi that basically allows you to emit a different key or action depending on whether a symbol or character has been emitted during a specified timeout. @jtroo gave me some pointers on how to achieve this using switch, as seen above. I think the main difference here is that we are dealing with keys instead of characters, which is why it is important to set the correct value for key-recency.

I came across a video about home row modifiers that features Kanata and I could see most comments criticize the tool because the implementation the content creator demonstrates is the most basic one: tap-hold. Hopefully providing good examples of better alternatives will persuade some of those commenting of the quality and power of this piece of software.

[gerhard-h]

early testing looks promising

Agreed :) The simplicty is stunning. I tried it while also getting rid of the time pressure from tap-hold-release-timeout
(by doing this I also disabled all kinds of autorepeat, but I dont use autorepeat for letter keys anyway)

(deftemplate homerowmod ( timeouthold char mod)
  (switch 
    ((key-timing 3 less-than 140)) $char break
    () (tap-hold-release 0 $timeouthold  $char $mod) break
  )
)

I kept my old per-key-timings for $timeouthold, but adjusting the numbers in key-timing 3 less-than 450 took me some time.

Learnings so far:

• key-timing 3 must not only account for number of modifiers in shortcuts but also the longest chordsv2 in the homerow
• less-than 450 can be reduced to less-than 140 (that is even less then minimum of all my $timeouthold's) without loosing its functionality. But only now shift becomes responsive enough for me.
• in the past I prefered tap-hold but here tap-hold-release is important (for single mod shortcuts to be responsive)

I will also keep testing this.

[argenkiwi]

Thanks for sharing your learnings! I'll give those tweaks a go when I have a chance.

What I am still not sure about the example is whether process-unmapped-keys needs to be set to yes. I use deflayermap instead of deflayer in my layout, and I tested this on Linux. It did not seem to matter. But maybe it does affect other configurations or platforms.

UPDATE: it appears to be necessary, as the documentation suggests, or at least all keys used for typing (i.e., letters, numbers, symbols and space) should be added to defsrc so they are registered by the key-timing logic.

[argenkiwi]

I was thinking of a potential optimisation I will try tomorrow when I'm back at work: what if we used different key recencies for the modifiers depending on how we roll our chords? For example, if you distribute shift, control and alt in that order on your home row then you could use 1, 2 and 3 as their respective recencies as long as you make sure to roll your fingers over the keys in the same order. My hypothesis is that you could more granularly regulate the time for each key-timing which could improve the usability of shift as a home row modifier while typing, for example.

[TZProgrammer]

I love the approach. Has this been tested in a more programming-focused context, where mod keys might be used more often while intertwined with typing? For example, I commonly find myself pressing the modifier for the symbol layer after a spacebar while programming. Would there be a way to allow home row mods after certain special keys, or would this not be necessary in the first place?

[argenkiwi]

I have a feeling @gerhard-h has spent more time stress-testing this approach than myself (see his recommendations above). In terms of using multiple modifiers, that is the first problem I had to deal with and I addressed it by adjustin the key recency to match the maximum number of modifiers hjttI would need at a given time (that's what the 3 next to key-timing stands for). You may want to adjust the value to your specific needs.

[TZProgrammer]

I went back and noticed the key-timing looked at the third last key. That's a brilliant solution! I had not caught that at first. I will definitely tinker around with this.

[argenkiwi]

From the docs:

The key recency must be in the range 1-8, where 1 is the most recent key that was pressed and 8 is 8th most recent key pressed. Most use cases are expected to use a value of 1 for this parameter, but perhaps you can find a creative use for the other values.

@jtroo must have had a gut feeling it could be put to good use. 😂

[gerhard-h]

I have a feeling @gerhard-h has spent more time stress-testing this approach than myself

I tested my 3timing home row mods approach
versus my fast typing layer aproach (even on a bunch of my old keyboards) and came to the conclusion that both work practically the same.
Pros: 3timing

• easier to implement

Cons: lower case fast typing layer

• get in the way of fast typing all upper case

Pros: fast typing layer

• fixing special/problematic roles can be done with tap-hold-except-keys (wich has fewer sideeffects than fixing with defchords)

(deftemplate homerowmodexcept (timeouttap timeouthold keytap keyhold typinglist)
  (tap-hold-except-keys $timeouttap $timeouthold  (multi $keytap  @.tp)  $keyhold $typinglist) ;; force tap  instead of  hold
)

I only have theses problematic roles on the home row because I don't use QUERTY so I believe most people would prefer 3timing

Edited: here is an article telling #1656 why I prefer fast typing layer in the end.

[argenkiwi]

It has been a week and I am pretty happy with this implementation of home row mods. I had to adjust the time to 250 (I'm no as fast a typist as @gerhard-h) to reduce errors when using modifiers while typing. My monkeytype experience is better now 🐵 ⌨️ and my layout is even stealthier than before 🕵️.

[glehmann]

250 seems to work well for me too, while 450 made me to often wonder why my modifier didn’t fire.

That’s the best hrms implementation I’ve tried so far!

[argenkiwi]

Glad it is working for you. I've updated the post so it says 250 instead so newcomers don't get confused. I originally thought I should add 150ms per key, but it doesn't work that way. I'm still on 250 too.

[vsrivatsan89]

@argenkiwi My keyboard seems send key repetition while I hold down a mod key, how do you prevent that?

[argenkiwi]

Easy, just use tap-hold-release without the -timeout bit. See @gerhard-h's comment and the docs for examples and more details.

[vsrivatsan89]

I see, Thank you

[ldangelo]

I'm wondering if one of you fine folks could help me out. I switched to this homerow mod implementation and its awesome (mostly). I've been trying to modify my homerow mods to send (multi lctl lalt lmet lshift) when e or i is held. Using this implementation the normal homerow mods work fine, i and e print i and e? Any suggestions? Below is my config:

`

(defcfg
process-unmapped-keys yes
)

(defsrc
esc f1 f2 f3 f4 f5 f6 f7 f8 f9 f10 f11 f12
lsgt 1 2 3 4 5 6 7 8 9 0 - = bspc
tab q w e r t y u i o p [ ]
caps a s d f g h j k l ; ' \ ret
lsft grv z x c v b n m , . / rsft
fn lctl lalt lmet spc rmet ralt
)

(deflayer base
;; everything is exactly the same, only the f-row is changed.
;; you can of course change any of the other mappings.
esc 🔅 🔆 ✗ ✗ ✗ ✗ ◀◀ ▶⏸ ▶▶ 🔇 🔉 🔊
lsgt 1 2 3 4 5 6 7 8 9 0 - = bspc
tab q w @e r t y u @i o p [ ]
caps @A @s @d @f g h @j @k @l @; ' \ ret
lsft grv z x c v b n m , . / rsft
fn lctl lalt lmet spc rmet ralt
)

(deflayer nomods
;; everything is exactly the same, only the f-row is changed.
;; you can of course change any of the other mappings.
- - - - - - - - - - - - -
- - - - - - - - - - - - - -
- - - e - - - - i - - - -
- a s d f - - j k l ; - - -
- - - - - - - - - - - - -
- - - - - - -
)

(defvar
;; Note: consider using different time values for your different fingers.
;; For example, your pinkies might be slower to release keys and index
;; fingers faster.
tap-time 200
hold-time 400
slow-hold-time 500)

(deftemplate charmod (char mod)
(switch
((key-timing 3 less-than 450)) $char break
() (tap-hold-release $tap-time $slow-hold-time $char $mod) break
)
)

(defalias
;; hold e or i for hyper key
hyper (multi lctl lalt lmet lshift)
e (t! charmod e (multi lctl lalt lmet lshift))
i (t! charmod i (multi rctl ralt rmet rshift))
a (t! charmod a lctl)
s (t! charmod s lalt)
d (t! charmod d lmet)
f (t! charmod f lsft)
j (t! charmod j rsft)
k (t! charmod k rmet)
l (t! charmod l ralt)
; (t! charmod ; rctl)
)

`

[argenkiwi]

I have tested this configuration on Linux after removing the fn key and replacing @A with @A. I don't use hyper bindings, but I did not get e when holding the key. What OS are you using?

[ldangelo]

I'm on MacOS.

[ldangelo]

my config actually uses @A... Must have been some formatting when I pasted it.

[ldangelo]

Interesting, it seems this configuration works fine on my internal laptop keyboard. Everything but the e & i works on an external keyboard. I have a moergo keyboard that I use at my desk.

[PatrickSutton1]

@argenkiwi I am attempting to use homerow mods with Kanata. After also struggling with the lag and trawling issues, I found your post. This works so much better than the video I found kanata through (I believe a lot of people have pointed out the tap-hold function is a poor way to implement homerow mods).

Anyway, I am running into issues with my media controls on my MacOS. In the actual MacOS settings for the internal keyboard layout, I have selected the settings for these keys to act as media control by default (not a function key i.e F9). However, when I've tried to fix this using your approach, it doesn't seem to work. I'm very new to key remapping etc. and wondered whether you might have some suggestions for your implementation.

See my attempt here:
This includes a working, yet laggy and slow, version of the tap-hold implementation commented out at the bottom.

  process-unmapped-keys yes
)

(defvar
  time_tap  90
  time_hold 110
)

(defsrc
  f1 f2 f3 f4 f5 f6 f7 f8 f9 f10 f11 f12
;;  a s d f h j k l 
)
(deftemplate charmod (char mod)
  (switch
    ((key-timing 3 less-than 250)) $char break
    () (tap-hold-release-timeout 200 250 $char $mod $char) break
  )
)
(deflayermap (main)
  f1 (t! charmod f1 brdown) ;; from here
  f2 (t! charmod f2 brup)
  f3 (t! charmod f3 mctl)
  f4 (t! charmod f4 sls)
  f5 (t! charmod f5 dtn)
  f6 (t! charmod f6 dnd)
  f7 (t! charmod f7 prev)
  f8 (t! charmod f8 pp)
  f9 (t! charmod f9 next)
  f10 (t! charmod f10 mute)
  f11 (t! charmod f11 VolumeDown)
  f12 (t! charmod f12 VolumeUp) ;; to here doesn't work (see below for a working implementation - that is very laggy for homerows but reinstates the function of the media controls perfectly)
  a (t! charmod a lctl)
  s (t! charmod s lalt)
  d (t! charmod d lmet)
  f (t! charmod f lsft)
  j (t! charmod j lctl)
  k (t! charmod k ralt)
  l (t! charmod l rmet)
  ; (t! charmod ; rsft)
)

;;(defalias
;;  f1-mod  (tap-hold $time_tap 1 f1 brdown)
;;  f2-mod  (tap-hold $time_tap 1 f2 brup)
;;  f3-mod  (tap-hold $time_tap 1 f3 mctl)
;;  f4-mod  (tap-hold $time_tap 1 f4 sls)
;;  f5-mod  (tap-hold $time_tap 1 f5 dtn)
;;  f6-mod  (tap-hold $time_tap 1 f6 dnd)
;;  f7-mod  (tap-hold $time_tap 1 f7 prev)
;;  f8-mod  (tap-hold $time_tap 1 f8 pp)
;;  f9-mod  (tap-hold $time_tap 1 f9 next)
;;  f10-mod  (tap-hold $time_tap 1 f10 mute)
;;  f11-mod  (tap-hold $time_tap 1 f11 VolumeDown)
;;  f12-mod  (tap-hold $time_tap 1 f12 VolumeUp)
;;  a-mod (tap-hold $time_tap $time_hold a lctl)
;;  s-mod (tap-hold $time_tap $time_hold s lalt)
;;  d-mod (tap-hold $time_tap $time_hold d lmet)
;;  f-mod (tap-hold $time_tap $time_hold f lsft)
;;  h-mod (tap-hold $time_tap $time_hold h rctl)
;;  j-mod (tap-hold $time_tap $time_hold j ralt)
;;  k-mod (tap-hold $time_tap $time_hold k rmet)
;;  l-mod (tap-hold $time_tap $time_hold l rsft)
;;)
;;
;;(deflayer base
;;      @f1-mod
;;      @f2-mod
;;      @f3-mod
;;      @f4-mod
;;      @f5-mod
;;      @f6-mod
;;      @f7-mod
;;      @f8-mod
;;      @f9-mod
;;      @f10-mod
;;      @f11-mod
;;      @f12-mod
;;      @a-mod
;;      @s-mod
;;      @d-mod
;;      @f-mod
;;      @h-mod
;;      @j-mod
;;      @k-mod
;;      @l-mod
;;)

Any advice would be helpful! P.s apologies if I should've posted this as a separate thread.

Additional info: An example for remapping as I've done above is in #975 and the key-names 'dnd', 'mctl' etc. were added to kanata in #1533

[argenkiwi]

Let me see if I understand correctly: you want the function keys to do their default action or otherwise act as media keys on hold? If that's the case, you should not use the charmod template for that.

charmod takes a character and a modifier. The modifier requires another key, the key to be modified, to be pressed within the timeout. If the timeout elapses and no other key is pressed, the char, not the mod, is what will come out. You could make another template (funmed?) to abstract your solution and simplify your config file, but it looks to me like you are the right thing for your use case otherwise.

UPDATE: now, if all you want is to swap the default of those keys from function to media, I would stick with the MacOS system setting for that. Home row modifiers are meant to be used for what the name implies: having modifiers (e.g., shift, control, option, command) on your home row. You could use it for custom layer modifiers as well, but they are not meant to be used to swap key behaviour.

[januz]

@PatrickSutton1 I had the same problem that media keys weren't working anymore after using this home row mod scheme. I ended up mapping them to their standard (media) function in the base layer and adding a fn layer for using them as F1... keys.

My config below:

;; keys that are not defined in defsrc are processed normally
(defcfg
  process-unmapped-keys yes
)

(defsrc
)

(defvar
  tap-time 200
  hold-time 200
)

(defalias
  hyperl (tap-hold-press $tap-time $hold-time esc (multi lsft lctl lalt lmet))
  hyperr (tap-hold-press $tap-time $hold-time esc (multi lsft lctl lalt lmet))
  tilde  (tap-hold-press $tap-time $hold-time grv (multi lsft lctl lalt))
)

(deftemplate charmod (char mod)
  (switch
    ((key-timing 3 less-than 250)) $char break
    () (tap-hold-release-timeout 200 500 $char $mod $char) break
  )
)

;; base layer
(deflayermap (base)
  ;; home row mods
  a (t! charmod a lctl)
  s (t! charmod s lalt)
  d (t! charmod d lmet)
  f (t! charmod f lsft)
  j (t! charmod j rsft)
  k (t! charmod k rmet)
  l (t! charmod l lalt)
  ; (t! charmod ; rctl)
  v (t! charmod v ralt)
  m (t! charmod m ralt)
  
  ;; left shift to tilde
  lsft @tilde
  
  ;; function keys
  f1  brdown
  f2  brup
  f3  mctl
  f4  sls
  f5  dtn
  f6  dnd
  f7  prev
  f8  pp
  f9  next 
  f10 mute
  f11 voldwn
  f12 volu
  fn  (tap-hold 200 200 fn (layer-toggle fn))

  ;; thumb cluster keys
  rmet ret
  ralt esc
  lmet bspc
  lalt del

  ;; caps/return to escape & hyper when held
  caps @hyperl
  ret  @hyperr

  ;; disable keys to learn new layout
  bspc fn
  lctl fn
  rsft (multi rsft rctl lalt)
)

;; function layer
(deflayermap (fn)
  f1  f1
  f2  f2
  f3  f3
  f4  f4
  f5  f5
  f6  f6
  f7  f7
  f8  f8
  f9  f9
  f10 f10
  f11 f11
  f12 f12
)

[PatrickSutton1]

@argenkiwi @januz Thank you both for your time and replies, and sorry for the late response from me. @januz your solution has worked perfectly!

I didn't realise it was as simple as directly remapping the keys.

Time to get used to using them.

Again, thank you both.

[januz]

@argenkiwi Thanks so much for sharing your configuration. I set up home row keys with it over the weekend and generally am pretty happy with it (besides the general struggle of having to unlearn my years of muscle memory :)).

One thing I'm struggling with though is that I'm one of those people who remap jk/kj to esc in VIM and other places that have VIM mode. Unfortunately, I'm having issues with reliably triggering jk and often produce K (j is rsft and k is rmet as I'm on Mac OS) or no effect.

Is there a way to tweak the config to have the jk combination work? I see that in an alternative home row mod implementation like the advanced example (https://github.com/jtroo/kanata/blob/main/cfg_samples/home-row-mod-advanced.kbd), mods are set up to only work with keys on the opposite side of the keyboard. But this is using tap-hold-release-keys which has a parameter for those exclusions while tap-hold-release-timeout which you use doesn't have this option. Any other idea how I could make jk work again? Thanks so much!

[argenkiwi]

I am not a Vim user but, if what you are after is simultaneously pressing j + k and getting esc, that can be easily achieved with Kanata using chords. If you look into my config, you will see that I do the same but using w + e. Maybe something like this will do the trick for you.

[januz]

Thank you so much! I'll try out chords. I thought that might be the answer but didn't really know where to start so your examples are very much appreciated!!

[willpuckett]

This is such a useful conversation and dramatically improves hrms in kanata. It would be great if it were included (or at least referenced) in home-row-mods-advanced.kbd to help new users get a better experience out of the gate.