My Preference for Compact Keyboards

By Sam Smith | Published: June 28, 2026

As a software engineer, my professional life revolves around typing. Between my career and my personal hobbies, I spend a vast majority of my waking hours stationed in front of a computer screen. Consequently, I've spent a significant amount of time optimizing my input method, eventually settling on "small" keyboards as my daily drivers.

The Evolution of My Setup

My journey into the world of custom peripherals wasn't immediate. It began with a highly experimental DIY project: the Atreus.

The Atreus Experiment

Building the Atreus was a gritty, hands-on process. I utilized a school laser cutter to create a chassis from clear acrylic sheets. The internals were a chaotic mix of:

• Hand-wired keys
• Manually soldered diodes
• A microcontroller board
• An excessive amount of hot glue

Because I opted for the cheapest blank keycaps available, the learning curve was steep. Eventually, the board became my primary tool ended up in a drawer. At the time, I played a lot of DotA, and the compact layout made gaming frustrating, leading me back to a standard 60% board.

Transitioning to the Corne

In 2020, two things happened: I discovered the Corne (a 42-key split keyboard) and I landed my first professional software engineering role. The new job provided the perfect justification for an upgrade.

I salvaged the switches and caps from my old Atreus, but since custom PCBs had become more affordable, I opted for a professional circuit board. I also created a minimalist case consisting of a top and bottom plate (essentially PCBs without the circuitry), leaving the sides open.

Why the Corne Wins

The Corne stuck with me for reasons that were both physical and lifestyle-based. My interest in DotA waned, and the ergonomic benefits of a split design became undeniable.

The Philosophy of Layers

The most frequent criticism I encounter regarding small boards is:

"I'm a programmer; I can't sacrifice access to function keys or special symbols."

To me, this logic is inverted. The goal should be to keep the most frequently used keys as close to the home row as possible to minimize hand travel.

Example: The Clojure Bracket

Since I began working with Clojure last year, I use the opening bracket ( constantly.

• Standard Keyboard: Hold Shift (pinky) $\rightarrow$ reach two rows up to the 9 key.
• Corne Keyboard: Hold lower (left thumb) $\rightarrow$ press o (right ring finger), which is only one row from home.

Example: Function Keys

Instead of stretching my entire hand three rows upward to hit a function key, I simply trigger the raise layer, bringing those keys directly under my fingers.

// Conceptual Layer Logic
if (key_pressed == RAISE_LAYER) {
    map_key(HOME_ROW, FUNCTION_KEYS);
} else if (key_pressed == LOWER_LAYER) {
    map_key(HOME_ROW, SYMBOLS);
}

Trade-offs and Extremes

Of course, there is a downside: the learning curve.

1. Accessibility: Standard keyboards are designed for ease of discovery; if you need a key, you can see it and hit it.
2. Efficiency: Small keyboards prioritize speed and ergonomics for those willing to memorize the layout.

Some enthusiasts push this even further by using 36-key boards (removing the outer column to save the pinkies) or implementing home row modifiers. While I haven't gone that far, I find 42 keys to be the ideal balance. It provides the ergonomic benefits I crave without making me unable to use a "normal" keyboard when necessary.

Final Thoughts

The naming convention for keyboards is based on the total key count relative to a full-sized board (which has $\approx 100$ keys). The percentage is roughly:

$\text{Keyboard \%} \approx \frac{\text{Actual Keys}}{\text{Full Size Keys}} \times 100$

While I don't spend my days entering data into spreadsheets, I recognize that some people truly need a numpad. However, for those users, I would suggest a separate dedicated numpad rather than returning to a massive, inefficient full-sized board.