About the Code Typing Test
The Code Typing Test is a browser-based speed and accuracy measurement tool designed specifically for developers. Unlike generic typing tests that use prose, this one uses real code snippets from five programming languages: JavaScript, TypeScript, Python, Go, and Rust.
How it works
Each round works the same way:
- Pick a language and duration. Choose from JavaScript, TypeScript, Python, Go, or Rust. Set your timer to 30, 60, or 120 seconds.
- Preview the snippet. A random snippet from our curated library appears. The full text is visible before you start — no surprises.
- Type. Hit the first key. A 3-second countdown begins. Then the timer starts and every keystroke is tracked. Wrong characters flash red and do not advance — you must type the correct character to move forward.
- Review your results. When time runs out (or you finish the snippet), a results screen shows WPM, accuracy, characters per second, and your fastest and slowest lines.
Why code, not prose
Developers type differently when writing code: punctuation density is higher, symbols like brackets and semicolons are frequent, and whitespace matters. A typing test that measures performance on newspaper excerpts or Lorem Ipsum does not reflect real-world developer typing patterns.
Our snippets are curated from real-world code patterns — array methods, async/await, closures, generics, iterators, pattern matching, structs, channels, and more. The library includes 50+ snippets per language, each 80–250 characters long. Every round draws a random snippet, ensuring variety across sessions.
Developer typing speed benchmarks
Most professional developers type somewhere between 50 and 80 WPM on prose. On code, that figure is typically 20–40% lower because of the dense punctuation, unfamiliar symbol sequences, and the cognitive load of reading ahead in structured syntax. A developer achieving 60+ WPM on real code snippets is performing at a high level.
The Words per minute convention defines one “word” as five characters — a normalization that levels the playing field between short and long words. This test follows that same standard: every five correct characters you type, regardless of what they are, count as one word. A snippet of 150 characters counts as 30 words. A 60-second run in which you type that snippet perfectly yields a 30 WPM score.
These numbers are deliberately comparable across typing tools: 60 WPM on this test maps to the same rate as 60 WPM on any prose typing test that uses the same formula. The difference is what you're typing — not how the math works.
Scoring
WPM
Words Per Minute. Calculated as (correct keystrokes / 5) / minutes. This is the standard industry measure, normalized for code typing where "words" are defined as five-character blocks.
Accuracy
The percentage of correct keystrokes out of all keystrokes. Since incorrect keystrokes do not advance the cursor, accuracy reflects how often you hit a wrong key before correcting it.
CPS
Characters Per Second. Correct characters divided by elapsed seconds. Provides a finer-grained speed metric than WPM.
Personal Best
Stored per-language and per-time-mode in your browser’s localStorage. No account required — your best scores never leave your machine.
Per-character error handling
A deliberate design choice: the cursor does not advance when you type a wrong character. Instead, the character flashes red for 300ms, then returns to its untyped state, waiting for the correct key. This is stricter than conventional typing tests that let you backspace — it forces you to learn the exact key sequence rather than relying on correction. We believe this produces more accurate muscle memory for code.
Privacy
The entire tool runs client-side. No keystrokes, snippets, or results are sent to any server. Your personal best scores are stored in localStorage, accessible only by your browser. There are no cookies, no tracking scripts, and no analytics on this page. See our privacy policy for the full details.
How to improve your score
Developer typing speed is trainable. Most programmers who actively practice improve their WPM score measurably within a few weeks. Here are the patterns that matter most for code specifically:
- Slow down to speed up. Accuracy drives WPM. Every incorrect keystroke is a wasted stroke that does not advance your cursor, so 90% accuracy at 60 WPM is faster than 70% accuracy at 80 WPM. Prioritize hitting the right key over hitting it fast.
- Focus on problem characters. Code is full of symbols that prose typing tests never test: braces, semicolons, angle brackets, underscores, pipes. Identify which symbols slow you down (they'll be your slowest lines) and drill those specifically.
- Consistent rhythm over bursts. Typing a line at a steady 60 WPM is faster than typing it at alternating 100 WPM and 30 WPM. Erratic rhythm causes errors. Practice smooth, even keystrokes.
- Use all fingers. Touch typing with all fingers on home row positions reduces the distance each finger travels per keystroke. If you type mostly with two or three fingers, switching to full touch typing will feel slower at first but pays off within a few weeks.
- Short sessions, not marathons. The 30-second and 60-second modes in this test are not shortcuts — they're intentionally brief. Concentrated practice of 5–10 rounds per session beats unfocused grinding for hours.
Further practice resources
This tool is designed for measurement, not for extended drilling. If you want extended practice aimed specifically at code, one of the best-known resources is typing.io, which provides long-form code typing exercises across many languages. It is particularly useful if you want to build endurance rather than peak speed measurement.
For general typing improvement, any dedicated touch-typing course focused on building accurate muscle memory can translate directly to faster code input. The bottleneck for most developers is symbol accuracy, not letter speed — so any resource that drills symbols and punctuation is especially valuable. After a dedicated practice session elsewhere, come back to this tool to measure whether your WPM on real code snippets has improved.
The snippet library
Each language's snippet library is hand-curated. Snippets are selected to cover the most common code patterns a developer actually writes day to day — not contrived syntax exercises. Below is a sampling of what each library covers:
JavaScript
Arrow functions, closures, array methods (map, filter, reduce, flatMap), async/await, Promises, event emitters, class syntax with private fields, module patterns, debounce/throttle, memoization, destructuring, optional chaining, nullish coalescing, and common utility functions.
TypeScript
Generic types and constraints, discriminated unions, mapped types, conditional types, utility types (Partial, Pick, Omit, Record), interface definitions, enum patterns, type guards, function overloads, and decorator patterns.
Python
List, dict, and set comprehensions, dataclasses, type annotations, context managers, generators, async/await with aiohttp, functools patterns, decorator factories, pathlib, regex, CSV/JSON parsing, and standard library patterns.
Go
Goroutines and channels, sync primitives (WaitGroup, Mutex), context with timeout, HTTP handlers and middleware, generic functions (filter, map, partition), struct methods, interface definitions, error handling patterns, and database interactions.
Rust
Ownership and borrowing patterns, trait definitions and implementations, enum with match expressions, iterators and closures, async/await with tokio, Result and Option chaining, lifetime annotations, struct methods, and common standard library patterns.
Every snippet is 60–280 characters long — long enough to challenge you but short enough to complete within a 30-second round. The library is updated periodically as language patterns evolve.
Keyboard and layout notes
The test works on any keyboard layout. If you use Dvorak, Colemak, Workman, or another layout, the keys you type are what matter — the test does not validate physical key positions. Note that on AZERTY and similar layouts, some symbols in the code snippets may require different key combinations than on QWERTY; this is expected and intended.
Mechanical keyboards and split keyboards do not give you an advantage in WPM terms — accuracy and practice matter far more than hardware. That said, a keyboard with good tactile feedback can reduce typos. Switch choice (linear, tactile, clicky) is a personal preference that affects feel more than measurable accuracy. Key travel and actuation force matter slightly more: heavy switches can slow you down on long runs; ultra-light switches increase accidental keypresses. Most developers settle somewhere in the medium range and notice little difference after a short adaptation period.
Open source
The code for this tool is part of the Elofyn site repository. You can view it on GitHub. The snippet libraries are curated in plain TypeScript data files and are easy to contribute new snippets to.
Why Elofyn built this
We build tools that developers use. The Code Typing Test started as an internal tool during a pairing session where two team members compared their accuracy on Python versus TypeScript. We realized that no typing test measured accuracy on real code — so we built one.
It joins our growing collection of free browser-based utilities alongside Arrow Shift (our daily chain-arrow puzzle) and the broader Elofyn tools suite. Every tool we ship is free, runs client-side, and respects your privacy.