Touch typing that measures itself honestly.

Learn it, then prove it.

The app opens on two tabs. One teaches, one measures. Both share the same engine, so the numbers mean the same thing in each.

One command.

The image is nginx plus a folder of static files. Nothing to compile, nothing to install, no runtime dependency.

# clone and start
git clone https://github.com/bhagesh-h/tt.git
cd tt
docker compose up -d

Then open localhost:8080. Change the port with TT_PORT=9000 docker compose up -d.

# without compose
docker build -t tt .
docker run --rm -p 8080:80 tt

No Docker? Every script is a plain classic script with relative paths, so app/index.html opens straight off disk. Some browsers refuse localStorage on file://; when that happens tt keeps your settings in memory for the session and says so in the settings window.

Everything is one keystroke away.

Just start typing. The clock begins on your first key, not on a countdown. There is no start button and nothing to click before you begin.

Race someone on identical text

Every run has a seed. Leave the box empty for a fresh one each time, or type one to pin it. copy challenge on the results screen gives you a link that reproduces the exact words:

https://bhagesh-h.github.io/tt/app/#m=time&v=30&s=k7q2mp&l=english1k&p=0&n=0

Anyone opening it types the same words in the same order. Test recipes deliberately exclude the keyboard layout, so a QWERTY player and a Colemak player race exactly the same text.

Written in key positions, not letters.

Lessons name a physical key, never a character. That one decision means the whole course works on every layout without a second tree, and the finger being trained is the same in every column below.

• Home row first. Every reach starts and ends there, so the eight anchors must be automatic before anything else moves.
• Two new keys at a time, one per hand. More than two and the drill stops being about the new keys.
• Words as soon as words are possible. Once the unlocked set can spell them, the generator filters a 1,000-word list down to that set, so you type flask and gash, not fdjk sldg forever.
• Shift trains the opposite-hand rule. The left-shift lesson capitalises only right-hand letters, so it cannot be completed with the wrong hand.
• Fluency is its own unit. Bigrams, trigrams, same-finger sequences, alternating-hand words, speed bursts, and an adaptive drill weighted by the keys you actually get wrong.

Speed alone is a bad number.

Typing fast at 88% accuracy is not a skill worth rewarding. Someone still has to re-read and fix the text. So accuracy is cubed, and the score is built on top of that.

• wpm: correct characters / 5 / minutes. A word is five characters, space included.
• accuracy: correct keystrokes over all keystrokes, judged the moment the key goes down. Fixing a mistake does not un-make it.
• consistency: the coefficient of variation of your per-second speed, squashed through 100 × (1 − tanh(cv + cv³/3 + cv⁵/5)). Small wobble barely costs; stop-start typing collapses it.
• difficulty: computed from the text itself: capitals, punctuation, digits, symbols, word length. Plain prose sits near 0.97, a symbol-heavy code drill approaches 1.5.
• KSPC: keystrokes per character produced. 1.0 is perfect economy; 1.30 means a third of the work was undoing.

The part that is easy to get quietly wrong.

Every reported number comes from one artefact: the keystroke log. Nothing is sampled live, so nothing depends on frame rate or on how busy the browser was.

• Monotonic only. Wall-clock time is never used to measure a duration.
• The event's own timestamp. KeyboardEvent.timeStamp is when the key actually fired, not when JavaScript got round to it. Implausible values fall back to performance.now().
• t₀ is your first keystroke, not the render, not a timer, not a countdown.
• The clock never accumulates. Elapsed is always recomputed as now − t₀ − paused.
• Nothing past the buzzer counts. A keystroke whose own timestamp is beyond the deadline is discarded, and the run ends at exactly the configured duration.
• Losing focus pauses the clock, because you cannot type into an unfocused window. Paused time is excluded and reported separately, and a long pause voids the record.

Pastel, and entirely yours.

Six themes, red green and blue in dark and light, plus one you build yourself. The keyboard stays a plain monochrome layout display with shallow 3D keycaps, so it never competes with the text above it.

• Typed text colour: a row of presets plus an eyedropper for any colour at all. This is the colour grey turns when you get it right.
• Fonts: 16 stacks, flagged in the picker if they are not installed here, with a size slider capped against the viewport so it can never overflow.
• Keyboard: presses and clicks light up in grey-white and hold ~110ms, so a fast burst still reads as separate keys. Finger colouring is available, off by default.
• No webfonts. Families resolve against what your machine already has, so the image stays small and works with no network at all.

Practising a new layout? Turn on remap input and tt reads the physical key you pressed and translates it through the layout you picked, so there is no need to change your operating system's keyboard settings.