The Escapement Steps One Character at a Time

The Olympic SM9’s escapement mechanism does exactly one thing per keystroke: advances the carriage one character width, then locks. Press a key, get one step. No pre-computation of where the line will wrap. No look-ahead. The carriage doesn’t know what you’re about to type — it just responds to the current input and waits.

This is a generator. Not metaphorically — mechanically. A generator yields one value, updates internal state, and suspends until the next request. The escapement yields one position, updates the column counter (a literal rack of teeth against a spring-loaded pawl), and suspends until the next keystroke.

Kotlin’s sequence builder captures this pattern directly:

fun typewriter(text: String, margin: Int = 40) = sequence {
    var col = 0
    for (ch in text) {
        if (ch == ' ' && col >= margin) {
            yield('\n')  // carriage return
            col = 0
        } else {
            yield(ch)
            col++
        }
    }
}

fun main() {
    val draft = "The quick brown fox jumps over the lazy dog and keeps going"
    typewriter(draft, 25).forEach(::print)
}

Output:

The quick brown fox jumps
over the lazy dog and
keeps going

The sequence is lazy — nothing happens until you iterate. Each yield suspends the coroutine, just like the escapement pawl catching the next tooth.

Forth handles this differently. No coroutines, no closures — just explicit state and a loop that processes one character per cycle:

VARIABLE COL  40 CONSTANT MARGIN
: CR-RESET   CR 0 COL ! ;
: ADVANCE    1 COL +!  COL @ MARGIN > IF CR-RESET THEN ;
: TCHAR      ( ch -- ) DUP BL = COL @ MARGIN 5 - > AND IF DROP CR-RESET ELSE EMIT ADVANCE THEN ;
: TYPEWRITE  ( addr len -- ) 0 COL !  OVER + SWAP DO I C@ TCHAR LOOP ;

S" The quick brown fox jumps over the lazy dog" TYPEWRITE

Same idea, inside-out. The state that Kotlin hides inside a suspended coroutine frame, Forth exposes as COL — a global variable you can inspect mid-line if you want to. The Kotlin version is safer; the Forth version lets you poke the escapement with your finger.

Generators appeared in CLU (1975) and Icon (1977), but they entered mainstream consciousness with Python 2.2 in 2001. Kotlin’s sequence builder arrived in 2016, directly descended from C#‘s yield return.

The SM9’s escapement was designed in 1964. Same pattern, different substrate.