thokr: a terminal typing test that keeps a history of your results
✨ sleek typing tui with visualized results and historical logging
At a glance
- What is it?
- thokr is a Rust terminal user interface for typing practice, with three English word lists, sentence mode, custom prompts, a ghost caret to race against and a log.csv that accumulates every finished test. It suits people who live in the terminal and want their typing history to stay as a local file rather than in a web account.
- Who is it for?
- thokr fits someone who wants typing practice inside the terminal, wants the results kept as a plain CSV they own, and does not need a browser, an account or a leaderboard. It does not fit a learner of another language, because the roadmap says multi-language support is not shipped and explains that accented characters could not be entered correctly in raw mode, and it does not fit someone who wants a community leaderboard or detailed per keystroke statistics.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository received new commits within the last day.
- What is it written in?
- Mainly Rust, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on October 23, 2026, and from our analysis. They are not legal advice.
Editorial analysis
Typing practice that lives entirely in your terminal
thokr describes itself as a sleek typing tui with visualized results and historical logging, and it is written in Rust. The idea is a typing test that runs where you already work, without a browser tab, an account or a network round trip.
The visual layer is a terminal user interface rather than a line editor. The README ships a demo recording, and the acknowledgements name the projects the author looked at, including monkeytype, tui-rs and ttyper. The first of those is the web typing test most people picture, and thokr borrows the idea of a measured test with results at the end, but not the browser context.
What makes the tool more than a toy is the third element in its tagline, historical logging. Every completed test appends a row to a CSV file, so the history is a data file you own, in a format a spreadsheet or a small script can read. For someone who wants to see whether their speed is improving over months, that matters more than the animation does.
The project is MIT licensed, the crate is published on crates.io, and the version in the repository manifest is 0.6.0. The most recent GitHub releases are v0.6.0 on 2026-10-12 and v0.5.0 on 2026-06-12, with the previous one, v0.4.1, dating from 2022-06-13, and the last push to the repository was on 2026-10-15.
The command line surface: words, sentences, seconds and your own text
Everything is configured through flags, and the help output lists the full set.
-w, --number-of-words <NUMBER_OF_WORDS>
number of words to use in test [default: 15]
-f, --full-sentences <NUMBER_OF_SENTENCES>
number of sentences to use in test
-s, --number-of-secs <NUMBER_OF_SECS>
number of seconds to run test
-p, --prompt <PROMPT>
custom prompt to use
-l, --supported-language <SUPPORTED_LANGUAGE>
language to pull words from [default: english] [possible values: english, english1k, english10k]
--pace <PACE>
ghost caret pacing at this WPM to race againstThe defaults produce a short burst: 15 words taken from the 200 most common English words. The flag names are explicit about what each one does, and the examples table in the README maps commands to results, including the combination of a word count with a time limit, which is described as a hard stop.
| `thokr` | 50 of the 200 most common english words |
| `thokr -w 100` | 100 of the 200 most common English words |
| `thokr -w 100 -l english1k` | 100 of the 1000 most common English words |
| `thokr -w 10 -s 5` | 10 of the 200 most common English words (hard stop at 5 seconds) |Two of these deserve a closer look. The `-f` flag for full sentences overrides the word settings, so a sentence test and a word test are different modes rather than a mixture. And the `-p` flag takes a custom prompt, with the example piping a file into it through the shell, which turns thokr into a typing trainer for any text you have on disk.
The `--pace` option adds a ghost caret that moves at a chosen words per minute, so you can race a fixed target rather than your own past. The README also documents the two in-test keys: left arrow to start over, right arrow for a new prompt, the latter only when you did not supply your own.
Three English word lists, and why other languages are not shipped
The supported language table is short, and deliberately so.
| name | description |
| :----------- | ------------------------------: |
| `english` | 200 most common English words |
| `english1k` | 1000 most common English words |
| `english10k` | 10000 most common English words |The three lists differ only in size, which means the difficulty knob is vocabulary size rather than punctuation, numbers or capitalisation. A test on `english` is a familiar-words test, and moving to `english10k` pushes you into less frequent vocabulary.
The roadmap explains why no other language is available, and the explanation is the most technical part of the README. The author decided not to launch with languages other than English because of rendering issues when trying to input characters with accents, describing the symptom as being unable to properly input the character in raw mode, with a link to the crossterm documentation for raw mode. The stated reason for fixing it before shipping more languages is that the experience felt jarring, and the author asks for help by opening a bug report with details and replication steps.
That is a specific, checkable limitation rather than a vague omission, and it is worth judging the project on: a typing trainer for people who type accented characters, which is a large share of European writers, is not usable today. It is also an ordinary terminal problem rather than a flaw in the design, so the fix is plausibly a matter of input handling in the crossterm layer.
log.csv: the history lands in a per-platform config folder
The logging behaviour is simple and specific. On completion of a test, a row describing the results is appended to a `log.csv` file in a platform-specific folder, which the README says lets you track your progress over time.
| Linux | `$XDG_CONFIG_HOME/thokr` or `$HOME/.config/thokr` | /home/colby/.config/thokr |
| macOS | `$HOME/Library/Application Support/thokr` | /Users/colby/Library/Application Support/thokr |
| Windows | `{FOLDERID_RoamingAppData}\thokr\config` | C:\Users\colby\AppData\Roaming\thokr\config |The macOS path follows the platform convention rather than the XDG one, and the Windows path uses a separate `config` subfolder, so a script that reads results needs to know the platform.
Two properties of this design are worth stating. The file is plain CSV with a row per test, so any analysis of your own progress is a small script away and does not require a vendor dashboard. And the file lives in your user configuration directory, which means it survives a reinstall of the tool and it is not tied to any account, because thokr has no account system at all.
The README does not document the exact column set of the CSV, the units used for speed, or whether there is a way to reset or rotate the file, so anyone planning to parse it should look at the file itself before writing a script against it.
Installing from crates.io, a Homebrew tap or the AUR
There are three documented install paths, and the choice of package manager tells you which platforms are first class.
$ cargo install thokr$ brew install jrnxf/tap/thokrThe Cargo install is the most direct route for anyone with a Rust toolchain. The Homebrew route points at the maintainer's own tap, `jrnxf/tap`, and the README explains a detail that matters for CI: the formula builds thokr from source, so it needs a Rust toolchain, and Homebrew installs one for you.
On Arch Linux the answer is the AUR, with a package named `thokr-git`, which is the rolling package that tracks the repository rather than a tagged release.
The release process is documented too. The README states that publishing a release publishes the crate and then updates the formula in the `jrnxf/homebrew-tap` repository automatically, so the two channels stay in step without a manual formula bump. Contributors are pointed at a fork, branch, commit, rebase and pull request sequence, and the open issues are where proposed features and known issues are listed.
The `thokr -h` command is the reference for the full option set, and the README is explicit that detailed usage comes from there rather than from a separate manual page.
What the manifest says about the implementation
The Cargo manifest is short enough to read in full, and it explains the shape of the program.
[package]
name = "thokr"
description = "sleek typing tui with visualized results and historical logging"
version = "0.6.0"
readme = "README.md"
repository = "https://github.com/jrnxf/thokr.git"
homepage = "https://github.com/jrnxf/thokr"
license = "MIT"
authors = ["Colby Thomas <[email protected]>"]
edition = "2024"
rust-version = "1.88"The dependency list is exactly what a terminal typing test needs and nothing more.
[dependencies]
cgisf_lib = "0.1.3"
chrono = { version = "0.4.45", default-features = false, features = ["clock"] }
clap = { version = "4.6", features = ["derive"] }
directories = "6.0"
rand = "0.8.5"
ratatui = { version = "0.30.2", default-features = false, features = ["crossterm", "layout-cache"] }`ratatui` with the crossterm backend is the rendering layer, `clap` with derive is the argument parser, `chrono` with only the clock feature supplies timestamps for the log rows, `rand` picks the words, and `directories` is the library that knows where the platform configuration folder is, which is why the log path differs per operating system without any hardcoded paths in the source.
The release profile is tuned for a distributable binary, and the manifest also declares a dev dependency on `insta`, the snapshot testing crate, which is how the interface rendering is probably checked.
[profile.release]
lto = true
codegen-units = 1
strip = trueLink time optimisation, a single codegen unit and stripped symbols together make for a small, fast binary, which matters for a tool you launch dozens of times a day. The package excludes `.github`, log files, `plans` and `assets` from the published crate, so the demo recording does not ship to users.
The alternative, and where thokr is the wrong choice
The obvious alternative is a browser based typing test of the kind the README links as an inspiration, and the difference in approach is not cosmetic. A web tester runs in a browser tab, typically offers account based history stored on a server, and usually adds a leaderboard and a community of other test takers. thokr runs in a terminal, stores no account anywhere, and writes a CSV into your own configuration folder that you can delete or back up like any other file.
That difference makes thokr better in one specific way and worse in others. It is better for anyone who wants their typing data to stay local and readable, who works in a terminal environment such as over SSH, and who does not want to maintain a browser profile. It is worse for anyone who wants a leaderboard to compare against other people, per keystroke error analysis, or a web interface that runs on a machine with no terminal.
There are other cases where it is the wrong tool. A person learning a non-English language cannot use it yet, and the roadmap's raw mode explanation is the reason. A team that wants typing metrics shipped into a dashboard pipeline will find that the README does not describe a stable schema for the log file, so they would be parsing an undocumented CSV.
And the scope of the project is narrow by design. It is a single binary with six dependencies and one author, distributed under the MIT licence, with the crate published on crates.io and a Homebrew formula maintained in a separate tap repository. The MIT licence means the code can be reused and modified with attribution and preservation of the notice, and the repository also states that the licence text is in `LICENSE.md`.
Given that the last push was on 2026-10-15 and two releases landed in 2026, the project is being worked on, and the open issues are the place to see what is planned next.
Editorial conclusion
thokr fits someone who wants typing practice inside the terminal, wants the results kept as a plain CSV they own, and does not need a browser, an account or a leaderboard. It does not fit a learner of another language, because the roadmap says multi-language support is not shipped and explains that accented characters could not be entered correctly in raw mode, and it does not fit someone who wants a community leaderboard or detailed per keystroke statistics. Verify first that the word list you want is one of english, english1k or english10k, then check the log.csv location for your platform before you start, since the file is appended to on every completed test.
Frequently asked questions
How do I install thokr?
You can install it with `cargo install thokr` from crates.io, with `brew install jrnxf/tap/thokr` from the maintainer's Homebrew tap, or by installing `thokr-git` from the AUR on Arch Linux. The Homebrew formula builds thokr from source, so it needs a Rust toolchain.
Which word lists does thokr use?
Three English lists are available: `english` with the 200 most common English words, `english1k` with 1000, and `english10k` with 10000. You select one with the `-l` or `--supported-language` flag.
Where does thokr store my typing history?
Each completed test appends a row to a `log.csv` file in a platform-specific folder: `$XDG_CONFIG_HOME/thokr` or `$HOME/.config/thokr` on Linux, `$HOME/Library/Application Support/thokr` on macOS, and `{FOLDERID_RoamingAppData}\thokr\config` on Windows.
Can I type my own text in thokr?
Yes, the `-p` or `--prompt` flag takes a custom prompt, and the README gives the example `thokr -p "$(cat foo.txt)"`. The right arrow key gives a new prompt only when you did not supply your own.
Does thokr support languages other than English?
Not yet. The roadmap says multi-language support is not shipped because of rendering issues with accented characters in raw mode, and the author is looking for help reproducing that input problem.
What does the --pace flag do in thokr?
It sets the words per minute of a ghost caret that you race against during the test. The README example is `thokr --pace 60`, which uses the 15 most common words with a ghost caret moving at 60 wpm.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/jrnxf-thokr)Was this useful?