lab / chord-fn-row  ·  see also fn-row-rethink  ·  supersedes alt-fn-row (the Alt-based variant, rejected: it costs Alt+Space)

CapsLock+Space[number row] — F1–F12

Using the two-trigger chord as the layer selector instead of Alt. Full edge-case audit and blast radius. Nothing implemented yet.

CapsLockX 2.0 · branch beta Rust core + Windows adapter 2026-09-04

Notation

A gesture is a timeline, not a set of keys — and every bug in this document lives on a press or release edge. So the notation makes those edges explicit: (…) groups keys, [ is the moment the group goes down, ] is the moment it comes back up, and a bare key name in between is a tap.

The vocabulary, applied

The three modes, written down

Your question — whether a locked session behaves exactly like a held trigger — has a precise answer in the code, and the notation turns out to say it neatly. on_key_event step 4 gates on is_clx_active(), which is true for both CM_FN and CM_CLX, so a non-trigger key is dispatched through the identical path either way.

One more consequence worth stating plainly: in locked mode space. both types a space and closes the lock, because Space is a trigger and is consumed by step 3 before the module dispatch of step 4 ever sees it.

When does each part fire?

The bracket is not a trigger condition. A key in the body acts on its own key-down, the moment it is struck — modules.on_key_down is called from step 4 of on_key_event, long before anything is released. Only the closing bracket waits.

Typed plainly: (s+c). taps the chord, (s+c)[ 1 ] is the proposed F1, (s|c)[ h ] is any ordinary CLX binding, capslock[ alt[ space[ 1 ] ] ] is the T1 failure, and clx[ on its own is locked mode. All ASCII — this has to survive being typed into CLAUDE.md, a commit message, a Rust doc comment and the HUD.

1What the chord does today

Traced through rs/core/src/engine.rs and rs/core/src/state.rs. Two surprises are hiding in here.

// engine.rs :: clx_dn — chord is detected from prior_key, and locks immediately
let chord = (code == CapsLock && prior == Space) || (code == Space && prior == CapsLock);
if chord {
    self.state.enter_clx_mode();          // <- LOCKS on key-DOWN, before any digit
    self.store_trigger(code);
    self.fn_acted.store(true, ...);       // <- so release never re-evaluates
    return false;
}

// state.rs :: the mode bits
enter_fn_mode()  { mode |= CM_FN;  mode &= !CM_CLX; }   // <- pressing a trigger CLEARS the lock
enter_clx_mode() { mode |= CM_CLX; }                    // <- always sets; never toggles

2Proposed mapping & gesture grammar

3L · Lock-toggle collision

4T · Trigger & ordering

5K · Keys & layout

6M · Modifiers & rollover

7C · Collisions with existing bindings

8E · Ergonomics & discoverability

9P · Platform & plumbing

10Alt variant vs chord variant

11Recommended solution

The one behavioural rule that makes it work

Implementation plan

Shape of the gesture logic

// engine.rs :: clx_dn — chord from held_keys, and NO eager lock
let other = if code == CapsLock { Space } else { CapsLock };
let chord = matches!(code, CapsLock | Space) && self.held_keys.lock().unwrap().contains(&other);
if chord {
    self.state.set_chord_active(true);
    self.state.set_chord_was_locked(self.state.is_clx_locked());  // L6
    self.state.enter_fn_mode();       // active, but NOT latched
    self.store_trigger(code);
    self.fn_acted.store(true, ...);   // suppresses the native Space/CapsLock tap
    return false;                     // never bypass -> Alt+Space rule untouched
}

// engine.rs :: clx_up — decide the lock on release of the LAST trigger
if self.state.chord_active() && !self.other_trigger_still_held(code) {
    if self.state.chord_acted() {
        self.state.restore_pre_chord_lock();   // chord was consumed -> no toggle
    } else {
        self.toggle_clx_lock();                // clean chord tap -> real toggle
    }
    self.state.set_chord_active(false);
}

12Decisions I need from you

13Verification matrix