Typing Trainer & Typer

Two ways to practice touch typing. Both compile from Rust to WebAssembly and run entirely in your browser — no server, no tracking, no excuses.

Why Touch Typing Still Matters

You spend hours a day at a keyboard. Even modest improvements in speed and accuracy compound into weeks of saved time per year. Yet most people never practice deliberately — they just keep reinforcing the same bad habits.

These trainers give you a focused, distraction-free environment to build real muscle memory. No accounts, no gamification treadmills, no ads. Just you, a text, and a keyboard.

Two Renderers, One Goal

Typing Trainer (DOM) Recommended

The classic variant. Draws the practice line on a 2D canvas and keeps every statistic in the DOM. A tiny download that starts instantly, works everywhere — no GPU, no WebGL — and its live WPM, timer and error rate update as you type.

  • Your keyboard, drawn as your own — Mac, Windows or Linux
  • Interactive map — the next key and the finger to use light up (switchable)
  • Error heatmap — the keys you miss stay marked between sessions
  • Weak-key drills — practice text built from your own misses
  • A guided course — ten-finger typing from scratch, 17 lessons, a pair of keys at a time
  • Piano mode — the board becomes a playable piano, with sound, and six public-domain tunes to learn
  • Finger training — pick whole fingers or single keys and drill exactly those
  • Live WPM, accuracy and a personal-best history
  • Custom text input — paste your own material
  • Opens on the drill you last chose, and steps its controls aside while you type

Typer (WebGL / egui) Experimental

Experimental. It paints its entire interface on a WebGL canvas, so every control is egui's rather than the page's — no native focus ring, no text selection, no screen-reader tree — and it downloads roughly fifty times as much WASM to do it. Reach for the Typing Trainer; this one exists to show the same Rust running natively and in a browser.

The GPU-accelerated variant. Renders to a WebGL canvas via egui and eframe. The same exercise and the same statistics, but the entire UI — text, cursor, stats, keyboard map — is re-tessellated and drawn by the GPU on every keystroke.

  • Your keyboard, drawn as your own — painted natively by the GPU
  • Interactive map with the same finger cues (switchable)
  • Error heatmap and weak-key drills, from the same practice record
  • The same guided course and finger training, from the same shared model
  • Live WPM, accuracy and a personal-best history
  • Cross-platform: the same Rust code runs as a native desktop app

How It Works

  1. Open either trainer — no install, no signup
  2. Real words appear — a fifty-word Lorem Ipsum, about a minute at 60 WPM. Start typing to begin the session
  3. Press Piano and the keyboard map becomes a piano you can play. Every key prints the letter that sounds it, the two letter rows are two octaves with their sharps on the row above — the layout trackers and DAWs use — and the notes are synthesised, not downloaded, so it stays a small page. Pick one of six public-domain tunes and the next key lights up exactly as the next letter does when you are typing
  4. Never touch-typed before? Press Course. It starts on F and J — the two keys with the bumps, under your index fingers — and adds a pair at a time, keeping everything you have already learned in play. The next lesson unlocks when you finish one at 95% accuracy, which is what every course that gates at all gates on; speed comes later on its own. Seventeen lessons cover the home row, the top row, the bottom row, then the digits and the rest, and your place is remembered
  5. Already know the layout? Open Keys and take the first preset: F G H J, the home keys under your index fingers — where every typing course begins. Add a finger at a time, or pick individual keys; the drill is dealt from your choice the moment you make it
  6. The keyboard map lights up the next key — and the finger to strike it with; mistakes are flagged immediately
  7. Both trainers track words-per-minute, elapsed time and error rate as you go, and print a WPM / accuracy / time summary when you finish (or press Esc)
  8. The controls fade while a run is under way, so what is left is the line, the board and the figures. Move the mouse, or finish, and they come straight back
  9. Adjust text length, spacing, or paste your own text and go again — your settings, your key selection and the drill you were on are all remembered for the next visit
  10. Keys you miss stay marked on the board, and one button builds a drill out of exactly those keys — which is how practice turns into progress
  11. Press Shift+? at any time for the full shortcut list, spelled for the keyboard you are actually on

Side by Side

Typing Trainer Typer
Rendering 2D canvas, stats in the DOM WebGL 2.0 canvas (egui)
Language Rust → WASM Rust → WASM
Live stats WPM, timer, error rate + finish summary WPM, timer, error rate + finish summary
Keyboard map Interactive SVG — next key + finger light up Interactive, GPU-painted — next key + finger light up
Keyboard shown Yours — Mac, Windows or Linux Yours — Mac, Windows or Linux
Error heatmap Per key, across sessions Per key, across sessions
Weak-key drills
Status Recommended Experimental
Piano mode Playable board, sound, 6 tunes
Guided course 17 lessons, F J outward The same 17 lessons
Finger & key training Finger chips, per-key chips, 4 presets The same, from the shared model
Remembers your drill Reopens on your last choice Reopens on your last choice
Focus while typing Controls fade, stay clickable Controls fade, stay clickable
Personal best & history Last 20 runs Last 20 runs
Custom text
Settings persist (browser build)
Runs native Browser only Desktop app (macOS build) + browser
Accessibility Stats and controls in the DOM, text on canvas Everything on canvas (egui screen-reader support)
Download size ~90 KB of WASM ~5 MB of WASM (~2 MB compressed)
GPU required No WebGL 2.0

Which One Should You Use?

For everyday practice: the DOM Typing Trainer. It is the snappier one where it counts. Its WASM is roughly a fiftieth of Typer's download, so it is interactive the moment the page paints — no WebGL context to create, no font atlas to rasterize. It then repaints one small 2D canvas per frame while every statistic is ordinary DOM text, rather than re-tessellating an entire UI, and its controls are real form elements — crisp at any zoom level, reachable by keyboard, and readable to screen readers.

Typer is experimental, and the reason to open it is curiosity rather than practice: it is the same trainer as a native desktop app (identical Rust code, no browser at all), and a full immediate-mode GPU UI running in a tab. Once its WASM is loaded it renders frame-perfectly. The costs are real, though — a multi-megabyte download, a WebGL 2.0 requirement, and an interface egui paints itself, so it is neither as crisp nor as reachable as the page's own controls. Learn to type in the Typing Trainer.

Under the Hood

Both trainers are written in Rust and compiled to WebAssembly. The renderers are two independent implementations — one against a 2D canvas and the DOM, one against a GPU-rendered immediate-mode UI — but they share one Rust core for everything that must agree: the WPM, accuracy and stopwatch formulas, and the keyboard model (layout, finger zones, and the character-to-key mapping that decides what lights up, including the opposite hand's Shift for shifted characters).

The keyboard map itself is that shared table rendered twice: the DOM trainer embeds an SVG generated from it (a test pins the page to the generator's exact output, so the two can never drift), while Typer paints the same table directly with egui — which also let it retire an embedded 110 KB SVG and the whole SVG-rasterizer dependency from its WASM.

Where they differ is in the drill itself: Typer stores the exercise as ASCII bytes for O(1) random access, while the DOM trainer keeps a Rust string and walks it by character, so it can practice text the ANSI keyboard has no key for. In both, lorem ipsum words are shuffled per session, so you never practice the same sequence twice.

Your practice record — per-key accuracy and the last twenty runs — is a few hundred bytes in your browser's own storage. It never leaves the machine, there is no account to make, and nothing is uploaded. Recording a keystroke costs one array increment; the record is written once when a run ends, because browser storage is synchronous and has no business running between two key presses.

Start Practicing

Pick a renderer and start typing. No signup, no install, no tracking.

DOM Trainer WebGL Typer