Moonshine Outscores Whisper Large v3 With 245 Million Parameters, on a CPU

Pete Warden's team packed speech to text, TTS, voice cloning, and intent recognition into one MIT-licensed library that runs from laptops down to microcontrollers. The benchmark fine print matters, and the repo prints it itself.

The most accurate open speech recognition model you can run on a laptop right now is 245 million parameters. Whisper Large v3, the model everyone treats as the accuracy ceiling for open ASR, is 1.5 billion. And on the benchmark table in Moonshine's README, the small model wins: 6.65% word error rate against Whisper's 7.44%, while returning a finished transcript in 107 milliseconds on a MacBook CPU where Whisper takes 11.3 seconds.

A model a sixth the size, beating the ceiling, a hundred times faster, with no GPU. Numbers like that usually mean somebody's benchmark is doing sneaky work. Here the story is better than that, and more honest: the speed comes from an architectural bet, the accuracy edge is real but narrow, and the repo's own maintainers flag exactly where their comparison is opinionated. That combination is why this is currently the top repo on the trending board, and why it's worth your attention if you've ever wired a voice interface to a cloud API and watched the latency and the bill grow together.

Moonshine comes from Moonshine AI, the company Pete Warden runs (it rebranded from Useful Sensors). Warden spent years on Google's TensorFlow team making models run on tiny hardware, and this project reads like the thing that whole career was building toward.

The bet: transcribe while the user is still talking

Whisper processes audio in fixed windows. You hand it a chunk, it thinks, it hands back text. That design is excellent for transcribing podcasts after the fact and bad for conversation, because a voice interface lives or dies on the gap between when you stop talking and when something happens.

Moonshine's second-generation models are streaming: they do the work during the speech, not after it. By the time you finish a sentence, most of the transcript already exists, so the "latency" you experience is just the final correction pass. That's the mechanism behind the 107ms number, and it's also the honest asterisk on it. The README says directly that its benchmark is "a pretty opinionated" comparison: it measures Moonshine's streaming time-to-final-transcript against Whisper's full batch transcription time, runs Whisper through CPU-only faster-whisper, and leaves GPU-accelerated Whisper implementations out entirely. The maintainers aren't claiming Whisper is bad at offline processing. They're claiming batch is the wrong shape for live voice, and for that argument the comparison is fair.

The accuracy claim stands on more neutral ground: on Hugging Face's OpenASR leaderboard, Moonshine's Medium Streaming model posts a lower English word error rate than any Whisper model OpenAI ships. The full ladder from the README's table, measured on their benchmark:

Model	WER	Parameters	MacBook Pro	Raspberry Pi 5
Moonshine Medium Streaming	6.65%	245M	107ms	802ms
Whisper Large v3	7.44%	1.5B	11,286ms	N/A
Moonshine Small Streaming	7.84%	123M	73ms	527ms
Whisper Small	8.59%	244M	1,940ms	10,397ms
Moonshine Tiny Streaming	12.00%	34M	34ms	237ms

Look at the Raspberry Pi column. Sub-second final transcripts, at accuracy that beats Whisper Small, on a $80 computer. That's the row that changes what you can build.

It's a voice stack, not a model

The repo's real ambition shows in what shipped around the ASR. One library, one API, covering transcription, text to speech, voice cloning, speaker diarization, command recognition, and what they call conversational agents, with the same code running on Python, iOS, Android, macOS, Linux, Windows, and Raspberry Pi, plus 1MB micro models for microcontrollers and DSPs.

The TTS side is smartly assembled rather than invented: it integrates Kokoro (an 82M-parameter open-weight TTS that sounds far better than its size), Piper voices across many languages, and ZipVoice for zero-shot voice cloning from a short audio clip. Where a licensing obstacle appeared (the standard phonemizer's license), they wrote their own grapheme-to-phoneme module from scratch and MIT-licensed it with the rest.

The API design deserves a mention because it's what makes the whole thing approachable. You don't poll a model; you attach listeners to a transcriber and receive events: a line of speech started, its text changed, the line completed. The intent layer works the same way, except you register a phrase like "turn on the lights" and it fires on semantic matches, so "could you switch the lights on" triggers it too. Ten lines of Python gets you a microphone-to-intent loop with no account, no API key, and no audio leaving the machine.

For multilingual work, they made an interesting contrarian call: instead of one model that handles a hundred languages the way Whisper does, they train separate monolingual models (Arabic, Japanese, Korean, Spanish, Ukrainian, Vietnamese, Chinese so far). Their Flavors of Moonshine paper argues a model focused on one language beats a multilingual model of the same size by a wide margin. For an edge model, where every parameter costs latency, that tradeoff makes sense.

The repo stats look like real adoption rather than a momentum spike: 8.7k stars, 476 forks, 484 commits, MIT license, with shipping sample apps for every platform.

Put this into practice

The ten-minute version, on any machine with Python and a mic:

1. pip install moonshine-voice, then run live mic transcription with the bundled CLI: moonshine-voice mic --language en. The Tiny English model ships in the package, so this first test needs nothing downloaded.
2. Wire up the event loop yourself. Create a MicTranscriber, add a listener class with an on_line_completed method, call start(), and print what arrives. The Getting Started Colab mirrors this if you'd rather not touch your local environment yet.
3. Step up to the Medium Streaming model for accuracy. Larger models download on first use from Moonshine's servers and cache locally, so budget one slow first run.
4. Try the intent recognizer (moonshine-voice intent) before you reach for an LLM. If your voice feature is "a dozen commands, spoken naturally," semantic phrase matching on-device may be the whole product, with zero tokens spent. There's a TTS subcommand too: moonshine-voice tts --language en_us --text "Hello world".

The thing that will trip you up: transcripts are per-session. Every start() begins a fresh document, so copy out anything you need before restarting a session.

Real effort estimate: a working live-transcription prototype is an afternoon. A polished voice interface is still real product work, because turn-taking, barge-in, and error recovery are design problems no library solves for you.

Honest limitations

The headline benchmark is the project's own. It's published with methodology and the caveats are stated in the README, which I respect, but streaming-versus-batch is a comparison the streaming side always wins, and nobody independent has reproduced the latency table. Treat the OpenASR leaderboard WER as the trustworthy number and the speed ratios as directionally true.

The accuracy edge is narrow. 6.65% against 7.44% is a real win at a sixth the parameters, but it's not a different class of transcription. If you're happy with a hosted API's accuracy today, Moonshine's argument is latency, privacy, and cost, not a transcript you'll visibly notice improving.

English gets the flagship. The top-end Medium Streaming model is English; other languages get smaller monolingual models covering seven languages so far, against Whisper's dozens. If your product needs broad language coverage now, Whisper's multilingual reach still wins.

"On-device" has a footnote: only the Tiny model is embedded. Bigger models and most TTS voices download from Moonshine's servers on first use, then cache. Air-gapped deployments need to stage those files deliberately.

And the box includes voice cloning, which means your compliance story now includes voice cloning. ZipVoice will imitate a speaker from a short clip. That's a legitimate feature with obvious abuse potential, and if you ship it inside your product, consent handling is your problem, not the library's.

Where this points

Voice keeps showing up as the interface agents are growing into, and until now the assumption baked into that trend was a round trip to somebody's API. Moonshine is the strongest evidence yet that the assumption is optional: state-of-the-art accuracy now fits in the corner of a CPU, and the whole input side of a voice agent can live where the microphone is.

The open question is whether the rest of the pipeline follows. Ears on-device, brain in the cloud is a strange hybrid, and the latency Moonshine saves you can be spent waiting on the LLM anyway. Try the ten-minute demo, put a stopwatch on your full loop, and see where your bottleneck actually lives. If you ship something on a Pi with this, I genuinely want to hear how far you pushed it.

Sources: moonshine-ai/moonshine on GitHub, Hugging Face OpenASR leaderboard, Moonshine paper, Flavors of Moonshine paper, Pete Warden's blog.