Building a Ferris Sweep and Relearning How to Type

I built a Ferris Sweep, a small split keyboard with 34 keys. Two halves, a few thumb keys, and considerably fewer places to hide a shortcut.

Learning to type on that would have been a reasonable project on its own. Different key positions, separate hands, layers instead of a number row. Plenty to get used to.

So naturally, I also changed from QWERTY to Colemak-DH at the same time.

Because learning to use a split keyboard apparently wasn’t hard enough. I needed to fight roughly thirty years of muscle memory as well.

Two halves, thirty-four keys

The Sweep is a variant of the Ferris that uses separate controller boards. Each hand gets three rows of five finger keys, plus two thumb keys: seventeen keys per side.

The columns are staggered vertically, rather than the rows being staggered sideways like a conventional keyboard. The two halves can be positioned independently, instead of both hands having to meet around one fixed slab of keys.

That physical freedom was part of the appeal. So was being able to define what the keys actually do.

The missing keys are the more obvious part, though. There is no dedicated number row, no separate arrow cluster, and no big collection of modifiers around the edges.

Thirty-four keys sounds like a constraint because it is one. The interesting part is deciding where the remaining functions belong.

Some assembly required. Possibly twice.

I used Kailh Choc White switches and standard low-profile blank keycaps. The blanks did not come with homing keys, so I 3D-printed two to give my fingers a way to find their starting positions without looking down.

That seemed particularly useful when there were no legends to look at anyway.

The controller part of the build went less smoothly.

First, I bought wireless controllers when I wanted a wired keyboard. Then I soldered the controllers directly to the PCB instead of using headers.

Not my best moment.

Trying to undo that decision by desoldering them damaged the PCB traces, so I had to order more boards.

Also not my best moment.

Headers would have made the controllers removable. Direct soldering made changing my mind a much more physical operation, and the PCB lost that argument.

There were two jobs here: build a keyboard that sends the right key events, then become someone who presses the right keys. I had managed to make the first one harder before even starting the second.

A layout I can change in code

My firmware uses QMK, with the layout defined in keymap.c. That makes the keyboard part of the project rather than a finished object whose behaviour I have to accept. Letters, symbols, navigation, and modifier behaviour are all things I can change in code.

It also means I can make a perfectly functioning keyboard that I personally cannot use very well yet. A successful build and a successful transition are separate milestones.

Changing the alphabet at the same time

Colemak-DH rearranges the letters with comfortable finger movement as its design goal, including moving D and H away from the centre-column positions used by standard Colemak.

Here is the base layer from my keymap:

Q W F P B     J L U Y '
A R S T G     M N E I O
Z X C D V     K H , . /

    Space Nav     Sym Shift

That looks fairly manageable as a diagram. It becomes more ambitious when the diagram has to replace something my hands have been doing automatically for decades.

I do not normally think “the next letter is T, and T lives here”. I think about a sentence or a line of code, and the typing happens underneath it.

Changing the layout drags that background process into the foreground. The thing I want to write is ready. The machinery for getting it onto the screen is now asking questions.

The split adds a physical change at the same time. A familiar movement no longer has the same destination, and a familiar destination no longer necessarily contains the same letter.

The sensible approach would have been to get comfortable with the Sweep on QWERTY, then change the letter layout. I chose to combine them. Efficient scheduling, if the schedule is for making typing difficult.

S and R were the biggest hurdle at the start. Those two were particularly good at reminding me that knowing the new layout and actually typing on it were separate things. My fingers had a very established opinion about where they belonged.

The keys haven’t disappeared; they have moved into layers

The keymap has four layers:

Layer	How I reach it	What lives there
Base	No layer key held	Colemak-DH letters and punctuation
Symbols	Hold the symbol thumb key	Brackets, operators, punctuation and modifiers
Navigation	Hold the navigation thumb key	Arrows, editing keys, Mac shortcuts and media controls
Numbers	Hold both layer keys	Digits, function keys and modifiers

The four thumb keys are Space, Navigation, Symbols, and Shift. The two layer keys are dedicated holds. I am not asking a letter key to decide whether I meant to type a character or activate a layer.

Holding both layer keys activates the numbers layer. That lets two thumb keys reach three additional layers without needing another physical key.

The layers also change some very ordinary habits. Backspace is on the navigation layer, at the right-hand outer home-row position. Enter is on that layer too, at the bottom-right position.

Even correcting a typing mistake needs a new movement. Which is convenient when the rest of the project creates so many opportunities to practise correcting typing mistakes.

A keyboard for writing code still needs brackets

Moving the letters is only part of the problem for a developer. A layout has to work for (), {}, [], operators, slashes, and the shortcuts used to move around an editor.

The symbol layer puts the opening brackets on the left and their closing partners on the right. The home row has operators such as -, *, =, and _, with more punctuation below.

I like that the arrangement is something I can explain. It gives me a structure to learn instead of a bag of special characters scattered around wherever there was room.

The navigation layer is built around the Mac. It has arrows, beginning and end of line, previous and next tab, browser back and forward, desktop switching, and media controls.

It is easy to focus on the alphabet when looking at an alternative layout. But being able to move through a document, select text, switch applications, and repair a mistake matters just as much when using it for real work.

Typing a word is one skill. Getting around the computer without thinking about the keyboard is a much larger collection of habits.

Modifiers without holding a small chord forever

The firmware also includes one-shot modifiers for Shift, Control, Option, and Command.

The idea is simple: tap a modifier, and it applies to the next key. Hold it, and it behaves like an ordinary held modifier. Multiple modifiers can be queued together.

The implementation in this keymap does not rely on a timer for the queued modifier. It tracks whether the modifier has been used. Pressing a layer key cancels a pending one-shot, so the cancellation behaviour is explicit too.

That is useful on a small board where modifiers do not all have permanent keys around the edges. It also adds another habit to learn: a shortcut can be a sequence rather than fingers holding down a chord.

There is similar logic for application switching. The window-swap key keeps Command active while repeated taps send Tab, then releases it when another key is used. The language-switch key uses the same mechanism with Control-Space.

None of this helps me remember where T is. But once the letter turns up, I have several ways to modify it.

Future me, October 2026: French has accents

June me already had enough to learn. Future me would like to point out that I also write in French, and knowing where E lives does not tell me how to type é.

So I added accent combos to the firmware. Press two keys together on the base layer, and the keyboard produces an accented character instead of the two ordinary characters. Another set of gestures to learn. Obviously.

The pairs use keys in the same column, one above or below the other. The idea is to keep the accent chords distinct from the usual movements between letters:

Combo	Result
E + ,	é
E + U	è
A + Z	à
S + C	ç
I + .	Circumflex dead key, then a vowel for â, ê, î, ô or û
O + /	Grave-accent dead key, then a vowel for à, è or ù

The firmware sends the Option shortcuts for the macOS US input layout. Some combos produce the whole character; the two dead-key combos set up the accent and wait for the next vowel. Shift handles capitals, with the vowel shifted when using a dead key.

This makes the accents available without dedicating more physical keys to them. It also means learning that two keys together sometimes make one character, while another pair needs a vowel afterwards.

Thirty years of QWERTY, a split, layers, one-shot modifiers, and now accent chords. At this point, typing a French sentence is getting dangerously close to playing an instrument.

One more update for June me: the Sweep is now my daily keyboard. I’m still not as fast as I was on QWERTY, but it’s getting there. This is no longer just a keyboard I built; it’s the one I actually use.

Several hours of bigrams later

I spent quite a few hours practising bigrams on Ngram Type and words on keybr.

That distinction matters. Memorizing where each letter lives gives me a map. Practising pairs and words is how I work on the movements between them. S and R do not arrive politely on their own in normal writing; they turn up in the middle of something my hands think they already know how to type.

The blank keycaps do not offer much assistance with the alphabet. The two printed homing keys help me find the starting position, but the rest still has to come from practice.

There is something fairly humbling about spending hours deliberately training an activity that has been happening in the background for thirty years. I spend my working day using a keyboard. That did not stop a new arrangement of letters from making it feel unfamiliar.

The part that cannot be flashed

The firmware is quite good at doing exactly what it is told. Muscle memory is less interested in the new specification.

That is the frustrating part of changing something so familiar. The layout can make sense on paper while the old movement still arrives first. Understanding where a letter lives and reaching for it automatically are different things.

Having the keymap in code makes it tempting to move a troublesome key whenever it feels awkward. But every change also gives my hands another thing to relearn. There is a difference between fixing a layout problem and editing the map because I haven’t learned it yet.

The split and the letter layout are separate changes too, even though I decided to learn them together. Positioning the halves, learning the columns, remembering a layer, and finding a letter are different jobs. They just happen to compete for attention while I am trying to write one sentence.

This is what I enjoy about the project, despite the self-inflicted difficulty. I get to build the hardware, describe its behaviour in code, and discover how much of using a computer normally happens without conscious thought.

Thirty-four keys are enough to express the layout. Thirty years of habits take a little more convincing.

I can flash the keyboard. Unfortunately, I still have to train the operator.