human-tps: Measure Your Typing Speed in Tokens Per Second with a Real Tokenizer

A Joke Taken All the Way to Production

In the local LLM community, t/s (tokens per second) is practically the metric everyone obsesses over. To squeeze out a few more tokens on limited hardware, enthusiasts endlessly tinker with quantization, batch sizes, and inference frameworks.

Recently, one Reddit user decided to flip the script entirely — if optimizing models is so exhausting, why not measure human token generation speed instead? He built a web-based tool called human-tps that lets you benchmark yourself like a language model, measuring how many tokens per second you can "output."

His original comment says it all: "Finally found a model I can run at full precision on my hardware: myself." This self-deprecating quip lands perfectly for anyone who's ever wrestled with consumer-grade GPUs trying to get a local LLM running.

What It Actually Does

The tool itself isn't complicated, but there's one detail that shows genuine thought went into it: it uses real tokenizers, not a simple character or word count. This means it measures how fast your input text gets split into tokens — the same way LLMs count them — making the comparison actually meaningful.

The author clocked himself at around 2 t/s. That sounds slow, but he threw in a few comparisons:

• According to the site's data, this speed beats running a 70B model on a laptop CPU;
• But compared to an 8B model running on an RTX 4090, humans are roughly 76x slower.

In other words, the "inference speed" of a human brain plus two hands can technically outperform some extremely constrained hardware setups — but against a modern high-end GPU running a small model, there's no contest. This absurd yet intuitive comparison is exactly what makes the project fun.

Why This Joke Hits Home

The local LLM community is perpetually haunted by performance anxiety: not enough VRAM? Quantize. Quantization hurts quality? Find a workaround. t/s not high enough? Switch inference engines. Waiting for a model to finish generating is, in itself, a kind of torment.

human-tps takes this serious performance discourse and applies it to humans, creating a perfectly calibrated comedic contrast. The author is blunt about the use case: "If you want something to do while waiting for an LLM to respond, give this a try." — a little toy to fill the waiting gaps, while poking fun at your own "hardware specs."

The tool also supports sharing your score, adding a light social layer. The author half-jokes: "Who knows, maybe I'll get famous from this." This kind of lightweight, shareable, meme-friendly design is exactly why projects like this tend to go viral in tech communities.

Serious Craft Behind a Silly Idea

Even though it's fundamentally a joke, the decision to use real tokenizers reveals that the author wasn't being sloppy. Tokenization logic varies across models — a stretch of English text can be split into far more tokens than there are words, and the handling of Chinese characters, code, and punctuation differs significantly. Using a real tokenizer is what puts "human t/s" and "model t/s" on the same comparable footing.

From that angle, human-tps feels more like an "inside-joke visualizer" for local LLM enthusiasts: it solves no real problem, but it takes a pain point everyone in the community instantly recognizes and turns it into something interactive and shareable.

Closing Thoughts

Projects like this won't change the technical landscape, but they perfectly reflect the culture of the local LLM community — obsessively squeezing every last drop of performance from hardware, while still being able to laugh at that very obsession. If you spend your days staring anxiously at t/s numbers, go check out human-tps and see how fast this "full-precision model" of yours actually runs.