DEV Community: Leandro

Keyboard Remapping on Steroids: keyd vs. kanata vs. keydo

Leandro — Tue, 11 Aug 2026 18:28:54 +0000

If you have ever attempted to implement Home Row Mods, create navigation layers, or customise tap-hold behaviours on a standard laptop keyboard without buying a $300 QMK/ZMK programmable split ergonomic keyboard, you know the struggle.

Standard OS-level tools like xmodmap, autohotkey, or basic macOS modifiers often fall short when handling complex layered interactions, sub-millisecond tap-hold detection, or display server transitions (like moving between X11 and Wayland).

Enter software-based daemon remappers. Three of the most prominent tools in this ecosystem are:

rvaiya/keyd — The C-based Linux kernel daemon benchmark.
jtroo/kanata — The cross-platform Rust powerhouse.
argenkiwi/keydo — The Rust-based "keyd, oxidised" alternative bridging ergonomic syntax and multi-platform goals.

In this article, we’ll break down how they compare across architecture, configuration syntax, cross-platform support, and unique capabilities so you can choose the right tool for your setup.

High-Level Overview

Here is a bird's-eye comparison of the three projects:

Feature / Aspect	keyd (`rvaiya/keyd`)	kanata (`jtroo/kanata`)	keydo (`argenkiwi/keydo`)
Language	C	Rust	Rust
Primary Platform	Linux (Kernel level: evdev/uinput)	Cross-Platform (Linux, macOS, Windows)	Multi-Platform Vision (Linux, macOS)
Configuration Style	INI / Declarative (`/etc/keyd/`)	Lisp / S-expressions (`.kbd`)	INI / Keyd-inspired Syntax
Philosophy	Minimalist, UNIX-way, sub-1ms speed	Feature-maximalist, highly customizable	Clean INI simplicity + Rust safety/portability
Live Reloading	Yes (`keyd reload`)	Yes (automatic file watch)	Yes
Application Remapping	Native IPC / app-specific bindings	External integration via TCP / scripts	In development
Complexity Curve	Very low (easy to learn in 5 mins)	Moderate to high (steep initial syntax)	Low (intuitive keyd-style syntax)

1. keyd (`rvaiya/keyd`) — The Linux Benchmark

What is it?

keyd is a system-wide key remapping daemon for Linux written in C. It operates at the kernel level via evdev and uinput. Because it hooks into Linux's input subsystem below the display server layer, your custom keybindings work identically across X11, Wayland compositors (Sway, Hyprland, GNOME), and even pure virtual consoles (TTYs).

Key Strengths

Unbeatable Performance & Low Overhead: Hand-tuned C loop executing input transformations in under 1 millisecond with near-zero memory footprint.
Intuitive INI Configuration: The syntax is dead simple. Creating a navigation layer or overloading Caps Lock takes seconds.
First-Class Modifiers & Composite Layers: Supports syntax like [control+alt] or modifier-blended layers out of the box without complex boilerplate.
Application-Aware Remapping: Ships with an IPC client mechanism allowing context-sensitive layers dependent on the focused window (e.g., terminal vs. browser).

Drawbacks

Linux Only: Deeply tied to Linux kernel primitives (/dev/input/evdev, /dev/uinput). It cannot run natively on macOS or Windows.

2. kanata (`jtroo/kanata`) — The Cross-Platform Powerhouse

What is it?

kanata is a cross-platform keyboard remapper written in Rust. Born out of the desire to bring advanced QMK/Kinesis-style firmware logic to software remappers, Kanata runs seamlessly on Linux, macOS, and Windows.

Key Strengths

True Cross-Platform Consistency: Use the exact same core remapping logic and Home Row Mod timings whether you are on your Linux workstation, MacBook, or Windows gaming rig.
Granular Tap-Hold Customization: Offers fine-grained primitives like tap-hold-press, tap-hold-release, chord groups, leader key sequences, and Unicode output macros.
Extensibility & Interprocess Communication: Includes an optional TCP server so external scripts or status bars (Polybar, Waybar, SketchyBar) can listen to active layer states or trigger layer shifts dynamically.
Active Community Ecosystem: Widely adopted in the ergonomic keyboard community (e.g., used by projects like Kenkyo).

Drawbacks

Lisp Syntax Learning Curve: Config files use S-expressions (defsrc, deflayer, defalias). For users unfamiliar with Lisp or Scheme formatting, reading and debugging nested parens can be daunting initially.

3. keydo (`argenkiwi/keydo`) — The "Keyd, Oxidised" Alternative

What is it?

keydo, created by Leandro (argenkiwi) (author of the Kenkyo ergonomic ANSI layout), is an open-source project described as "Keyd, oxidised". It was started to solve a specific pain point: lovers of keyd's clean, intuitive INI configuration file format wanted those same ergonomics on platforms beyond Linux without having to convert everything to Kanata's S-expression syntax.

Key Strengths

The Best of Both Worlds: Combines the human-readable, minimal INI configuration design of keyd with the memory safety, concurrency, and cross-platform potential of Rust.
Familiar Mental Model for keyd Users: If you already have a keyd setup or prefer readable key = overload(control, esc) directives over nested Lisp macros, keydo offers an approachable path.
Designed with Ergonomic Workflows in Mind: Born from hands-on experimentation with home row modifiers, custom chords, and thumb-shift patterns on standard ANSI boards.

Drawbacks

Newer Project: Compared to the battle-tested keyd (C) and kanata (Rust), keydo is younger and under active development, so some niche features or edge-case platform drivers may still be maturing.

Configuration Comparison: A Practical Example

To see how these tools differ in practice, let's look at how you configure a classic ergonomic pattern:

Goal: Turn Caps Lock into Escape when tapped, and Control when held. When holding Caps Lock, press j, k, h, l for arrow navigation.

`keyd` (`/etc/keyd/default.conf`)


ini
[ids]
*

[main]
capslock = overload(nav, esc)

[nav:C]
h = left
j = down
k = up
l = right

Stop Reaching for the Arrow Keys: An Intro to the Kenkyo Keyboard Layout

Leandro — Mon, 10 Aug 2026 20:33:50 +0000

Every developer knows the subtle tax of context-switching in your physical environment. You’re deep in the flow state, writing code, when you need to select a word three lines up or trigger an Escape key in Vim or your IDE. Your right hand leaves the home row, reaches across the desk to the arrow keys or navigation cluster, makes the adjustment, and travels back to reset your home-row positioning.

Do that hundreds of times a day, and it adds up to physical strain and micro-interruptions to your concentration.

Split ergonomic ortholinear keyboards (like the Moonlander, Glove80, or Corne) solve this using layers and home-row modifiers. But what if you could get 90% of those ergonomic powers on the standard ANSI keyboard on your laptop without buying new hardware or ruining your regular typing habits?

Enter Kenkyo.

What is Kenkyo?

Named after the Japanese word for humility or modesty (謙虚), Kenkyo is a open-source, software-based layered keyboard layout. True to its name, its core design philosophy is to stay completely out of your way until you need it.

Unlike custom layouts that force you to re-learn where letters sit (like Dvorak or Colemak), Kenkyo retains standard QWERTY typing for basic input. It simply supercharges your keyboard through software overlays like Kanata (cross-platform) or Keyd (Linux).

With Kenkyo, you can access 100% of standard keyboard functionality using just 31 keys, keeping your hands centered on the home row at all times.

Core Philosophy & Key Features

Kenkyo is built on four developer-friendly principles:

Hardware Agnostic: Works on any standard ANSI built-in laptop keyboard or external desktop board.
Progressive Learning: You don't have to go all-in on day one. Your standard typing muscle memory remains intact; you opt into shortcut layers at your own pace.
Composability: Combines established power-user paradigms like SpaceFn (holding Space triggers a navigation layer) and Home Row Modifiers.
Zero Motion Overhead: Keeps navigation, function keys, symbols, and modifier chords directly under your fingertips.

How It Works: The Layers

Kenkyo relies on a few intuitive layers toggled by holding down specific keys.

1. Main Layer (Home Row Modifiers)

Instead of twisting your pinkies to reach Ctrl, Alt, Shift, or Cmd/Super, Kenkyo turns your home row keys into modifiers when held down:

Left Hand: A (Meta/Cmd), S (Alt), D (Shift), F (Ctrl)
Right Hand: J (Ctrl), K (Shift), L (Alt), ; (Meta/Cmd)

Tapping the key types the letter normally; holding it acts as the modifier.

2. Extend Layer (Navigation & Editing)

Hold down the Spacebar to activate the Extend Layer:

Right Hand: Becomes your complete navigation cluster. Arrow keys, Home, End, Page Up, and Page Down sit under HJKL / IJKM positions. Editing keys like Backspace, Delete, Enter, and Tab are right next to them.
Left Hand: Media controls (Volume Up/Down, Mute, Play/Pause).

3. Fumbol Layer (Numbers, Symbols & F-Keys)

Hold V or M (or trigger it from the Extend Layer) to transform your home row into a high-speed number pad and function bar:

Numbers: Arranged conveniently along the home row.
F-Keys: F1–F10 mapped across the top row, with F11–F12 on the bottom.
Math Chords: Built-in fast chords for common math operations (-, +, =, /, *).

Ergonomic "Chords"

To eliminate far-reaching key stretches altogether, Kenkyo introduces two-key simultaneous "chords" for high-frequency actions:

W + E → Escape (Vim users rejoice!)
I + O → Backspace
X + C → Tab
, + . → Enter

Getting Started in 5 Minutes

Setting up Kenkyo is straightforward since it runs as an invisible software daemon in the background.

Step 1: Choose Your Driver

Windows, macOS, Linux: Kanata
Linux (Alternative): Keyd

Step 2: Install the Configuration

Clone the Kenkyo repository:

git clone https://github.com/argenkiwi/kenkyo.git

Copy the corresponding configuration file (kanata.kbd or keyd/default.conf) to your software's config folder (e.g., ~/.config/kanata/ or /etc/keyd/default.conf).
Start the daemon service.

That’s it! You can now start using SpaceFn navigation immediately. If you ever feel stuck, releasing held keys instantly drops you back into regular QWERTY typing.

Why Give It a Try?

If you've been curious about the productivity and health benefits of layered, ergonomic typing but aren't ready to invest in custom split hardware or completely rewire your muscle memory, Kenkyo offers the perfect middle ground.

Check out the full repository, documentation, and keymaps on GitHub:
👉 github.com/argenkiwi/kenkyo

Have you experimented with layered keyboard layouts or Home Row Modifiers in your dev workflow? Drop your thoughts in the comments below!

Automated plagiarism is a thing. I posted an article about Thumb Chords on this platform and I found out it quickly popped up on a site called PromptCube with different phrasing but same content and structure. The Internet as we know it is dying.

Leandro — Thu, 06 Aug 2026 01:51:23 +0000

Automated plagiarism is a thing. I published an article about Thumb Chords in this platform and it popped up in a dodgy site called PromptCube with different phasing but same content and structure. The Internet as we know it is dying.

Leandro — Thu, 06 Aug 2026 01:50:10 +0000

Thumb Chords

Leandro — Sun, 26 Jul 2026 22:55:40 +0000

I have been experimenting with a pattern I call Thumb Chord that consists of pressing a thumb key (the space-bar on a standard keyboard) and a home row key (A to ; on an QWERTY keyboard) simultaneously to form a chord which outputs a modifier, like shift or control.

Here is a minimal layout definition, based on keyd's configuration format, to illustrate the pattern:

[ids]

*

[main]

d+space = oneshot(shift)
k+space = oneshot(shift)

When combined with the one-shot modifiers pattern, tapping the chord will modify the next key tapped and deactivate immediately after. Alternatively, if the user released only the home row key while keeping the thumb key down, the modifier would remain active, anchored to the thumb key until it was released. This allows typists to, for example, capitalize a full word without having to hold the physical shift key with the little fingers or having to enable caps-lock.

The goal of this pattern is to achieve ergonomic modifiers while maintaining error proneness to a minimum. The pattern can be used in combination with or as an alternative to home row modifiers.

The advantage of using chords (or combos) is that they do not rely on additional timing calculations. The only requirement is that the key-down events for the keys involved occur within a short time window, usually of 50 milliseconds, which ensures pressing the keys simultaneously has been intended as a chord.

The main caveat of chords it that the activation threshold needs to be below the fastest key-roll to or from the thumb-key, which is particularly relevant when using the space-bar for the pattern. To measure these, I put together a tool that also captures WPM, which will likely correlate with the results.

Some of the relevant properties of the pattern I have identified are:

If HRMs are used, the motor memory for their placement can be retained when learning this pattern.
It allows for easy anchoring of a modifier onto a thumb key or the space-bar, which facilitates the use of fingers of both hands while holding the modifier.
It enables the use of one-shot modifiers without the need to use additional dedicated physical (thumb?) keys.

I have been experimenting with a variant of LLM Wiki based on the Zettelkasten note-taking methodology that encourages your AI agent to read notes before each iteration and take notes after, which can be source-controlled.

Leandro — Wed, 15 Jul 2026 18:39:05 +0000

Zettelkasten as a note-taking method for AI agents

Leandro — Mon, 06 Jul 2026 18:10:44 +0000

I wanted to give AmblerTS, my Deno/TypeScript state-machine framework, the ability to record non-obvious learnings that would otherwise require significant context to reconstruct across sessions.

I turned to the classic note-taking methodology developed by the German sociologist Niklas Luhmann: the Zettelkasten (German for slip box). The methodology is elegantly simple: take atomic notes, link them explicitly to related ones, and organise them so they can be retrieved precisely when they become relevant again.

The Concept

The idea translates naturally to agentic coding:

Describe the protocol in an AGENTS.md file, a convention that coding agents like Gemini and Claude read as project-level instructions.
Implement a lightweight abstraction using AmblerTS itself, a unified azk walk that supports the full set of operations: search, create, get, update, link and delete.
The agent searches for relevant notes before working on a prompt, then feeds any new learnings back into the slip box when done.

The result is a notes folder with Markdown files for notes and a local, git-ignored SQLite database that accumulate project-specific metadata (design decisions, gotchas, constraints) accessible to any coding agent that works on the repository. Search blends FTS5 keyword matching with optional semantic re-ranking via embeddings (degrading gracefully to keyword-only when no local embeddings host is available).

Current Implementation

The implementation is intentionally minimal, enough to validate the idea. A single deno task azk <subcommand> command exposes all six operations:

deno task azk search "<query>"
echo '{"title":"...","body":"...","tags":["..."]}' | deno task zettel create
deno task azk get <id>
echo '{"body":"..."}' | deno task zettel update <id>
deno task azk delete <id>
deno task azk link <fromId> <toId> "<relation>"

What's Next

A few variants I have in mind:

• User-level note store: a single knowledge base spanning all coding agent activity across projects, backed by a user-level AGENTS.md and a shared command, rather than one database per repository.
• Hybrid Markdown + SQLite storage, keeping notes as version-controlled Markdown files with SQLite used purely as a search index. Whether that adds value likely depends on the development process: projects with meaningful git history and code review may benefit from diffable notes; others probably won't.

──────

AmblerTS is open source. You can explore the implementation and try the Zettelkasten-RAG setup at https://github.com/argenkiwi/ambler-ts.

From ANSI to Ergo: Remapping the Transition

Leandro — Fri, 26 Jun 2026 19:09:16 +0000

A common story in the mechanical keyboard community goes like this: someone starts suffering from repetitive strain injury (RSI) or general hand pain and decides to transition to an ergonomic keyboard. To make the transition easier, they look for a large layout with plenty of keys. However, once the keyboard arrives, they realize the learning curve is steep. Frustrated, they ask for help in forums, convince themselves they bought the wrong board, and buy another one. Those who don't quit often end up with an expensive collection of ornamental keyboards.

I wanted to avoid this trap. Instead of buying a series of physical keyboards until I found the one, I learned what features my ideal keyboard should have. I settled on the following: a 34-key, column-staggered, split ergonomic keyboard layout.

Next, I needed to find a way to reduce the number of keys I was using on my ANSI keyboard to 34 or less by:

Identifying which keys were truly redundant or unnecessary.
Efficiently mapping the remaining keys using a layered system.

But didn't I need a programmable keyboard for that?

Bridging the Gap in Software

That’s when I discovered KMonad: a powerful tool that allows you to reprogram any keyboard at the software/OS level. This enabled me to test and refine a 34-key layout directly on my standard ANSI keyboard before purchasing any ergonomic hardware.

Introducing Kenkyo (謙虚)

Through this software-first approach, I open-sourced my custom layout under the name Kenkyo (which means humility in Japanese). I chose this name as a contrast to the dominant Miryoku (allure in Japanese) layout.

While Miryoku is highly custom and fully featured, Kenkyo aims to be a simple, non-disruptive, software-driven bridge that allows standard ANSI keyboard users to gradually transition to a layered 34-key workflow.

Over time, I migrated my setup to more modern and lightweight alternatives:

keyd: A highly efficient keyboard remapping daemon for Linux.
Kanata: A cross-platform remapper focused on advanced features like tap-hold, home row mods, and custom combos.

By remapping the keyboard in software first, I was able to build muscle memory. By the time I received my first ergonomic keyboard I could be productive with it right away. To this day, I still use software for my layout, which allows me to switch between my ergo and laptop keyboards painlessly.

The age of forks

Leandro — Wed, 10 Jun 2026 18:58:15 +0000

It has become relatively cheap now to take an existing open source project with a permissive license, fork it and tailor it to your needs. At the same time, the internet is saturated with new projects generated with coding agents and our attention span cannot grow.

I am sure I am not alone having the following experience: there is an open source project I love, but it is missing one or 2 features that should be straight forward to implement. I create feature requests, but the author has no time to even look into them or deems them as the wrong fit or direction for the project. I create a minimal pull request with the aid of a coding agent, as I am not versed on the programming language used for the project, but the PR stays on with no signs of being reviewed anytime soon and will likely be rejected due to the use of AI. Of course, the easiest thing to do now is to simply use the fork of the project I put together for the pull-request.

But why stop there? Now I have added MacOS support for a C application that was targeting Linux exclusively and I am even porting it to Rust just so I can learn the language while I iterate over it. I tried sharing the initiative with others, but there is too much noise for anyone to pay attention. How many forests will be burnt so we can reinvent the wheel over and over? I am honestly not sure of how to feel about the direction in which software engineering is going. So many conflicting feelings.

Home-Bottom Row Modifier Clusters

Leandro — Sat, 30 May 2026 20:29:46 +0000

In the world of custom keyboard layouts, one of the biggest challenges is balancing accessibility with speed. The traditional ANSI layout forces your pinkies and thumbs to reach for distant modifier keys like Ctrl, Alt, and Shift. While "Home Row Modifiers" (HRM) have long been a popular solution, the Kenkyo
layout takes this a step further with Home-Bottom Row Modifier Clusters.

This post explains how we use Kanata to turn the home and bottom rows of a standard keyboard into a high-performance modifier engine.

The Concept: Overloading the Letters

At its core, Kenkyo uses modifier overloads on standard letter keys. Instead of reaching for a physical Shift key, you simply hold a letter on your home row.

In our kanata.kbd, we use a template called charmod. This leverages Kanata's tap-hold-release-timeout logic, but with a special twist we call flowtap:

(deftemplate flowtap (flow tap)
  (switch 
    ((key-timing $streak-count less-than $streak-time)) $flow break
    () $tap break
  )
)

The flowtap logic detects if you are in a "typing streak." If you are typing fast, the keys behave as normal letters to prevent accidental modifier "misfires." If you pause or type a single key, the hold-to-modify behavior is activated.

The Clusters: Home and Bottom Row Synergy

While standard HRM puts modifiers on A S D F and J K L ;, Kenkyo clusters them across the home and bottom rows to reduce finger strain and enable advanced combinations.

Left Hand Cluster (`mhbl`)

Home Row: s (Alt), d (Shift), f (Ctrl)
Bottom Row: x (AltGr/RAlt), v (Fumbol Layer)

Right Hand Cluster (`mhbr`)

Home Row: j (Ctrl), k (Shift), l (Alt)
Bottom Row: m (Fumbol Layer), . (AltGr/RAlt)

By involving the bottom row, we create "clusters" where your fingers can easily rock between a standard modifier (like Shift) and a layer toggle (like Fumbol).

Replacing Physical Keys

On a standard ANSI keyboard, a combination like Ctrl + Shift + T requires awkward contortions. In Kenkyo, this is achieved by holding f (Ctrl) and d (Shift) with your left hand, and tapping t. Your hands never leave the home position.

We even use Chords (pressing two keys simultaneously) to trigger common actions:

w + e = Esc
i + o = Backspace
j + k = Enter

The One-Shot Advantage: Typing at Speed

One of the most powerful features of the Kenkyo clusters is the use of One-Shot Modifiers.

A One-Shot modifier (or "sticky key") stays active only for the next keypress. In Kenkyo, we trigger these using chords within our clusters:

d + k (simultaneous tap) = One-Shot Shift
x + . = One-Shot AltGr
v + m = One-Shot Fumbol Layer

Why One-Shots?

Maintain Rhythm: When typing at speed, holding a key down breaks your "tapping" rhythm. One-shots allow you to treat modifiers as just another tap in the sequence.
Reduced Fatigue: You don't have to maintain tension on a key while reaching for another.
Misfire Prevention: Since the modifier is only active for one key, you don't accidentally "hold" it into the next word.

Advanced Multi-Mod Chords

For power users, clusters allow for complex multi-modifier one-shots that would be nearly impossible on a standard layout. For example, in Kenkyo:

x + d = One-Shot AltGr + Shift
x + d + v = One-Shot AltGr + Shift + Fumbol Layer

This allows you to access deep symbols in the Fumbol layer with a single, coordinated "pinch" or "swipe" of the fingers, keeping your typing fluid and your hands relaxed.

The Home-Bottom Row Modifier Cluster isn't just about saving space—it's about re-imagining the keyboard as a tool where every key is exactly where you need it to be, exactly when you need it.

Porting existing code to Ambler TS

Leandro — Tue, 19 May 2026 19:39:19 +0000

The quickest way to port code from a Git repository into Ambler TS is to include it as a Git submodule and leverage Ambler's agentic skills. We'll use the PocketFlow cookbook as an example.

Project Setup

Create a project folder
Initialize git
Add PocketFlow (or a Git repository of your choosing) as a submodule.
Install the Ambler TS skills

mkdir port
cd port
git init
git submodule add https://github.com/The-Pocket/PocketFlow.git
npx skills add argenkiwi/ambler-ts

Initialize Ambler

Use a coding agent (like Claude or Pi) and invoke the ambler-walk skill:

/ambler-init .

Port Code

Invoke the ambler-walk skill and provide the path to what you want to port:

/ambler-walk create chat walk from @PocketFlow/cookbook/pocketflow-chat

The agent will automatically:

Analyze the source logic.
Create the necessary Nodes in nodes/.
Scaffold a Spec in specs/.
Wire everything into a Walk in walks/.

Test Run

Once the agent finishes, verify the port:

deno test nodes/tests/
deno task <walk-name>

I hope the next generations of gaming consoles are designed to also be your household's LLM hosts so you can use the GPU and unified memory for something useful during work hours.

Leandro — Tue, 19 May 2026 16:37:27 +0000

DEV Community: Leandro

Keyboard Remapping on Steroids: keyd vs. kanata vs. keydo

High-Level Overview

1. keyd (rvaiya/keyd) — The Linux Benchmark

What is it?

Key Strengths

Drawbacks

2. kanata (jtroo/kanata) — The Cross-Platform Powerhouse

What is it?

Key Strengths

Drawbacks

3. keydo (argenkiwi/keydo) — The "Keyd, Oxidised" Alternative

What is it?

Key Strengths

Drawbacks

Configuration Comparison: A Practical Example

keyd (/etc/keyd/default.conf)

Stop Reaching for the Arrow Keys: An Intro to the Kenkyo Keyboard Layout

What is Kenkyo?

Core Philosophy & Key Features

How It Works: The Layers

1. Main Layer (Home Row Modifiers)

2. Extend Layer (Navigation & Editing)

3. Fumbol Layer (Numbers, Symbols & F-Keys)

Ergonomic "Chords"

Getting Started in 5 Minutes

Step 1: Choose Your Driver

Step 2: Install the Configuration

Why Give It a Try?

Automated plagiarism is a thing. I posted an article about Thumb Chords on this platform and I found out it quickly popped up on a site called PromptCube with different phrasing but same content and structure. The Internet as we know it is dying.

Automated plagiarism is a thing. I published an article about Thumb Chords in this platform and it popped up in a dodgy site called PromptCube with different phasing but same content and structure. The Internet as we know it is dying.

Thumb Chords

I have been experimenting with a variant of LLM Wiki based on the Zettelkasten note-taking methodology that encourages your AI agent to read notes before each iteration and take notes after, which can be source-controlled.

Zettelkasten as a note-taking method for AI agents

The Concept

Current Implementation

What's Next

From ANSI to Ergo: Remapping the Transition

Bridging the Gap in Software

Introducing Kenkyo (謙虚)

The age of forks

Home-Bottom Row Modifier Clusters

The Concept: Overloading the Letters

The Clusters: Home and Bottom Row Synergy

Left Hand Cluster (mhbl)

Right Hand Cluster (mhbr)

Replacing Physical Keys

The One-Shot Advantage: Typing at Speed

Why One-Shots?

Advanced Multi-Mod Chords

Porting existing code to Ambler TS

Project Setup

Initialize Ambler

Port Code

Test Run

I hope the next generations of gaming consoles are designed to also be your household's LLM hosts so you can use the GPU and unified memory for something useful during work hours.

1. keyd (`rvaiya/keyd`) — The Linux Benchmark

2. kanata (`jtroo/kanata`) — The Cross-Platform Powerhouse

3. keydo (`argenkiwi/keydo`) — The "Keyd, Oxidised" Alternative

`keyd` (`/etc/keyd/default.conf`)

Left Hand Cluster (`mhbl`)

Right Hand Cluster (`mhbr`)