It seems that space+click is not meta+click when space+click is used in the following configuration. I noticed this because I tried to move (meta+leftclick) and resize (meta+rightclick) the swaywm window and could not.

$ keyd --version
keyd v2.3.0-rc (6581f36)
$

space = timeout(overload(meta, space), 1000, space)

keyd virtual device     xxxx:xxxx       space down
keyd virtual device     xxxx:xxxx       space up

Due to a glitch in the AUR, I have not been able to update to the latest version. https://aur.archlinux.org/packages/keyd-git Sorry if this has been resolved.

I've setup a = macro(compose a ") in /etc/keyd/default.conf and it mostly works as expected. However when used with a qt application which has a qcompleter active, that is it's showing a popup below a text input for example, the macro no longer works. Instead of inserting ä the individual characters a, " are inserted. I am guessing qt captures the keyboard when it shows the popup or some such.

I'd like to propose an expiration mechanism for oneshot, say oneshot2(layer, timeout) for the sake of discussion, which behaves like oneshot but only if the next key is pressed within timeout ms. The naming is suboptimal, as the two at the end usually signals the ability to supply a macro to be executed (and who knows if at some point a use case warranting the introduction of oneshot2(layer, macro) will be found), but I couldn't come up with something better except the more cumbersome layer_timeout.

Repeated calls to oneshot2() with the same layer argument should reset the timer to the last supplied timeout, while any other action activating or deactivating a layer with a currently attached timer should remove this timer. Also, from an implementation perspective, it is probably a good idea to only allow a single expiring layer at a time, i.e. calling oneshot2() while a layer different from the one given as argument has an active timer would deactivate this other layer.

This would address the following use cases:

1. Self-deactivating (nested) leader keys

The oneshot2() action would allow a user to change his mind after pressing the corresponding key. Currently, “cancelling” a oneshot action without visible consequences necessitates an additional keypress (typically some modifier key).

More concretely, I would like to toggle some layer by tapping shift twice, i.e.

[main]
leftshift = overload(shift,oneshot(shift))

[shift]
leftshift = toggle(layerA)

[layerA]

leftshift = toggle(layerA)

After testing it for a while, I temporarily removed this functionality as it often happened that I tapped shift because I wanted to start some sentence and then changed my mind. When I then wanted to continue to type and hence pressed shift again, layerA would activate, which was a bit annoying. If oneshot(shift) could be replaced with oneshot2(shift, 500), this problem would not occur.

2. Automatically activate an expiring navigation layer while moving a trackpoint or physical mouse (QMK has a similar feature for keyboards with a builtin trackpoint/mouse, which I find very useful)

Usually, after moving the mouse one has to click somewhere. If keyd would be able to activate an expiring navigation layer (typically with the mouse buttons on the home row) while moving a trackpoint or external mouse, one could replace the physical mouse buttons by proper keyboard buttons without the need to use some additional modifier press or explicitly activating a layer.

Of course, for this functionality one would need to enable calling actions via IPC in addition (which is planned to be implemented if I'm not mistaken), so that some script could monitor for mouse move uevents and issue the corresponding oneshot2() call.

Genesis: #278, #31, and #84.

Presently the only support for time based disambiguation of tap/hold is in the form of the timeout action, which allows the user to specify a time that the bound key must be depressed before being interpreted as being held. Crucially the key is unambiguously interpreted as a tap if an intervening keystroke occurs before the timeout has expired.

While this is useful for overloading keys which are commonly struck in isolation (e.g space), it does not account for keys struck in quick succession, which must allow for the possibility of interleaved events.

Specifically, an attempt to type <a> <b> (tapping behaviour), can produce any of:

1. <a down> <b down> <b up> <a up>
2. <a down> <b down> <a up> <b up>

3. <a down> <a up> <b down> <b up> 

while the attempt to type <a>+<b> (a 'hold'), can produce:

<a down> <b down> <b up> <a up> (1)
<a down> <b down> <a up> <b up> (2)

Proposal:

To distinguish between the two possible interpretations, we introduce a new variant of overload: overload2(<layer>, <action>, <timeout>) (called timeout3 in #278)

The binding is resolved immediately after either:

a. The timeout expires (<layer>) or b. The bound key is released (<action>)

This differs from timeout in that intervening key strokes are ignored (achieved by queueing them). This comes at the cost of additional visual latency, but potentially allows for commonly struck keys, to serve a dual purpose.

The proposed behaviour appears to be equivalent to QMK's default tap/hold feature.

I mistakenly thought I'd encountered an error state via #47. Thank you to the @rvaiya for the help there. I'm opening this new ticket to discuss what I actually want to achieve, so I can be clearer and potentially get better advice :)

I'm trying to make Linux shortcuts behave like Mac OS:

• I have a Win (Meta) key that can be used for application switching, e.g. Meta-Tab and Meta-Shift-Tab
• I have an Alt key to the left of the spacebar where Cmd normally is, so I'm thinking of Alt as the "do everything" modifier, like Cmd is in Mac OS.
• When I press Alt-C I want to simulate the Linux system-wide "Copy" shortcut key: Ctrl-Insert
• When I press Alt-V I want to simulate the Linux system-wide "Paste" shortcut key: Shift-Insert
• When I press and hold Alt, followed by any sequence of Tab or Grave (tilde) I want to simulate Meta-Tab (for each Tab press/release) or Meta-Shift-Tab (for each Grave press/release), until Alt is released. (In this "held" state, after an initial Tab or Grave has been pressed, it's ok--maybe even desirable?--to do nothing when C or V are pressed, even though technically Alt is also being pressed and that could be considered an Alt-C or Alt-V sequence).

How can I achieve this "dual nature" Alt key in keyd?

(Note: the important part here is that once we enter the "app switching" state, the Alt key cannot be released, or else the app switcher will be shut off and lose its state)

Application bindings set for Lorien in ~/.config/app.conf don't work when keyd-application-mapper is running, even though the window is detected. Lorien was installed from the AUR package lorien-bin. When a Lorien window is in focus, it shows up in keyd-application-mapper's logs as Active window: lorien|lorien-v0-4-0.

Here's my configs:

~/.config/keyd/app.conf:

[alacritty]
extend.i = S-pagedown
extend.o = S-pageup

[alacritty|htop]
extend.i = pagedown
extend.o = pageup

[lorien]
extend+shift.b = C-y

[ids]
*

# Colemak-DH (Curl+Angle mods)
[main]
esc = overload(switch, capslock)
capslock = overload(extend, esc)
rightmeta = compose
rightcontrol = rightcontrol
rightshift = rightshift
e = f
r = p
t = b
y = j
u = l
i = u
o = y
p = ;
s = r
d = s
f = t
h = m
j = n
k = e
l = i
; = o
z = x
x = c
c = d
b = z
n = k
m = h

[qwerty]
esc = overload(switch, capslock)
capslock = overload(extend, esc)
rightmeta = compose
rightcontrol = rightcontrol
rightshift = rightshift
e = e
r = r
t = t
y = y
u = u
i = i
o = o
p = p
s = s
d = d
f = f
h = h
j = j
k = k
l = l
; = ;
z = z
x = x
c = c
b = b
n = n
m = m

[noCapsLayer]
capslock = esc

[extend:C]
j = left
k = down
l = up
; = right
1 = f1
2 = f2
3 = f3
4 = f4
5 = f5
6 = f6
7 = f7
8 = f8
9 = f9
0 = f10
- = f11
= = f12
m = home
/ = end
i = pagedown
o = pageup
f = backspace
r = delete
s = layer(alt)
d = layer(shift)
space = layer(control)
g = enter

[extend+control]
s = layer(alt)
d = layer(shift)

[extend+shift]
space = layer(control)
s = layer(alt)

[extend+alt]
d = layer(shift)
space = layer(control)

[extend+control+shift]
s = layer(alt)

[extend+control+alt]
d = layer(shift)

[extend+shift+alt]
space = layer(control)

[extend+control+shift+alt]

[switch]
q = toggle(qwerty)
w = toggle(noCapsLayer)

First of all, thank you VERY much for this great program which finally allowed me to escape the xkb custom layout hell (with all its quirks and limitations).

I have one rather important (at least for me) feature request: When overloading a key, there is no way to avoid the tapping action once the key has been pressed. For example, when mapping the space cadet shift (tapping the shift keys yields parentheses), if one intends to type something after ending a sentence and presses shift out of habit but then needs to think a bit about which word to actually type, there is no way to release shift again without parentheses appearing. Another example is the alt key, which brings up a menu in common browsers. If the alt key is overloaded, there is no way to bring up this menu.

As a way out, one could implement a simple timer (one second should be a good default) which starts after an overloaded key has been pressed, only executing the tapping action if the key is released while the timer is still running. This timer should be enabled by default in my opinion (maybe globally configurable), as I can't imagine anybody who wants to tap a key to hold it one second or longer. Alternatively (or in addition), it could be added as a fourth argument to the overload action.

Thanks a lot in advance!

I have Microsoft Ergonomic Keyboard. It's a good keyboard, but contains two strange and useless keys between right alt and right control: "microsoft office" and "smile".

(photo from microsoft.com).

When the "microsoft office" key is pressed it produces four keys: control, shift, alt and meta.

> sudo systemctl stop keyd && sudo keyd -m
Microsoft Microsoft Ergonomic Keyboard  045e:082c   leftcontrol down
Microsoft Microsoft Ergonomic Keyboard  045e:082c   leftshift down
Microsoft Microsoft Ergonomic Keyboard  045e:082c   leftalt down
Microsoft Microsoft Ergonomic Keyboard  045e:082c   leftmeta down

When the "smile" key is pressed it produces five keys, like "microsoft office" but with additional space key.

> sudo systemctl stop keyd && sudo keyd -m
Microsoft Microsoft Ergonomic Keyboard  045e:082c   leftcontrol down
Microsoft Microsoft Ergonomic Keyboard  045e:082c   leftshift down
Microsoft Microsoft Ergonomic Keyboard  045e:082c   leftalt down
Microsoft Microsoft Ergonomic Keyboard  045e:082c   leftmeta down
Microsoft Microsoft Ergonomic Keyboard  045e:082c   space down

I just want to bind "microsoft office" to meta, with something like this:

[main]
leftcontrol-leftshift-leftalt-leftmeta = layer(meta)

Can I achive this in the current version? E.g. with some layer configuration. Is there a more direct way to do this planned in future releases?

First of all: as a user with a QMK keyboard that also has to regularly type on a laptop your keyd is a blessing.

As a diehard vim guy I quickly was able to translate the most important stuff of my qmk setup to keyd:

# Turns capslock into an escape key when pressed and a control key when held.
capslock = overload(C, esc)

# Remaps the escape key to capslock
# esc = capslock

# space when tapped, spacefn when held
space = overload(spacefn, space)
tab = overload(tabfn, tab)

[spacefn]
h = left
j = down
k = up
l = right

[tabfn]
h = home
j = pagedown
k = pageup
l = end

• caps as ctrl/esc works like a charm, bye xcape
• initial tests with SpaceFn and TabFn work: nice, bye xmodmap+setxkbmap

Then I started to write an email and realizedthatthespace keyddoesnt work asreliable :/ My typing speed is non-spectacular (75-80 wpm according to monkeytype.com) but a space doesnt come through two thirds of the time.

Is there anything I can do to make this more accurate? Did I configure something wrong?

I started experimenting with home row mods again, this time on QMK using its fine tuning options and was finally able to get a usable configuration.

The crux for me (as I type rather fast) is to only enable the modifier behaviour if the overloaded key has been held for a certain amount of time (independently of other pressed keys). Unfortunately, I don't think that this is currently possible on keyd using a combination of overload() and timeout() (please correct me if I'm wrong).

To explain better what I mean, let's assume that the f key should output an f if tapped and act as shift if held while another key is pressed.

The event sequence when I want to input J is then

1. f down
2. j down
3. f up
4. j up

which is problematic as those precise events are regularly generated as well upon entering fj.

To disambiguate, one would need to examine how long the f key has been held down and then apply the mod if some threshold has been exceeded.

I thought about an overload2(layer, action, tap_time) action, which only shifts the layer if the key is held down for at least tap_time ms (independently of whether other keys are pressed before the key is released).

An implementation of this could be to waits for tap_time ms upon key press, buffering all occuring key events during that time. If at any point a keyup event of the overloaded key is seen, execute action and then process the buffered key events on the current layer. If tap_time expired without such a keyup event, process the buffered (and all other incoming) key events on layer until the keyup event occurs.

For the same reasons as in my other recent feature request, overload2 might not be the best name for this and a more user friendly way would simply be to allow tap_time as an optional argument (otherwise applying a default which the user could modify in the [globals] section).

First of all: Super cool project, I love it! Unfortunately as soon I start keyd my Logitech Mouse using the Unifing Wireless Receiver does not work anymore until I stop it again.

I need my keyboard indicator to turn on when one particular layer is on.

As far as i understand layer_indicator can only turn on when any layer is active. Can i make layer_indicator turn indicator on only on one certain layer? If not, i think i can try to turn on/off numlock when layer is on/off just for the indicator, but it's such a poor fix. Is there other way around? Thank you.

When i run keyd 2.4.2 with the following config:

[ids] *

or:

[ids] *

[main] \ = \

The \ key produces #

When i run it with: [ids] *

[main] \ = ?

It produces ?

I'm puzzled about this behavior. How do i get a \?

Hi, thanks for a very useful tool.

I'm wondering if I could have an action that toggles two layers at once and also run a macro. Use case is as such: I have a nav layer that maps a whole bunch of keys to ctrl and alt actions, for use with programs such as firefox and slack. A few of these actions focus on text entry boxes. I would like to implement 'modes', so that if I type 't', it opens a new tab with C-t, and also removes the nav layer, and also adds in a new layer with one change: the enter key re-enters nav 'mode'. Simply toggling a second layer doesn't remove the nav layer, and so I can't enter text properly. Swap would be useful here if the changes were permanent instead of only while holding the key.

clearm is what I'm currently using but I'd love to have more precise control over which layers are active at any given time.

I've read through the manpages and issues enough to understand that layers aren't intended to have any kind of priority, and that's fine. I'd just like to be able to toggle two or perhaps even more layers at once along with a macro so I can build up modal workflows. Also would be nice if clear accepted multiple layers, again with a macro.

Thanks again, this might eventually allow me to ditch qmk and the like!!

I'm trying to map right alt + hjkl to arrow keys with this configuration (stored in /etc/keyd/default.conf):

[ids]
*

[rightalt]
h = left
j = down
k = up
l = right

However, keyd doesn't pick it up, althoughthe configuration is read by keyd (as per output of journalctl). keyd -m shows that right alt + hjkl key combinations are still producing h, j, k, l keystrokes, not arrows as desired.

OS: Ubuntu 22.04 keyd version: 2.4.2 (compiled from the git tag)

Keep in mind that I'm using Gnome Tweaks too to remap Caps to escape an Meta to Win (if it can have an impact on keyd).

Am I missing something?

Keyd is amazing, I use karabiner on macos, keyd is perfect replacement for karabiner on linux, keyd is more faster and friendly. but karabiner able to use different profile to handle different device, so I have a hhkb keyboard that layout has litter different with standard keyboard layout, so how to map different keys for different keyboards.