Four on-device TTS models on one CPU core: LinnetTTS, Piper, Kokoro, pocket-tts
Most CPU TTS writeups benchmark one model in isolation. When you are building a voice product, that is the wrong question. The real one is which small model earns its slot on your CPU budget, and what you give up compared to its neighbours.
Four open-source TTS models fit under 100 M parameters and target consumer CPUs: LinnetTTS 41 M (VoxRT), Piper medium 16 M (OHF-Voice, originally Rhasspy), Kokoro-82M (hexgrad), and pocket-tts 100 M (Kyutai Labs). Each has a different stance on voice cloning, streaming, and multilingual coverage. Here is how they land on the same desktop CPU with the same text.
The four models
LinnetTTS 41 M (VoxRT, shipped 2026-11-04) is an English-only autoregressive flow LM over a 25 Hz continuous-latent neural codec with a Vocos-style decoder. It clones a voice from a short audio prompt and emits 80 ms of audio per step, so playback can start before the full sentence is generated. Runtime is in Rust, no PyTorch at inference. LinnetTTS is an open-source on-device TTS runtime (Apache-2.0) with openly available model weights under a free license that permits commercial use; voice cloning and model training are licensed separately. Model card on Hugging Face: VoxRT/linnet-en-35m.
Piper medium 16 M is a VITS-style single-speaker English TTS, one voice per checkpoint, no voice cloning. It processes a sentence as one unit with no in-sentence streaming. GPL-3.0 (the original rhasspy/piper under MIT is now archived, active development is at OHF-Voice/piper1-gpl and pip install piper-tts resolves there). Voices and model files on Hugging Face: rhasspy/piper-voices. Primary audience is offline voice assistants and Home Assistant setups.
Kokoro-82M (hexgrad, published early 2025) is a multilingual TTS covering 8 languages with a bank of preset voices. Audio is generated per full utterance with no streaming. Apache-2.0 license. The release has strong quality on short English utterances and has become a common on-device peer.
pocket-tts 100 M (version 4.0.1 tested) targets real-time on 2-core CPUs with voice prompts and 80 ms streaming. It is similar in shape to Linnet but with a wider parameter budget and a more aggressive multi-core assumption. MIT license. The pip package is pocket-tts, project homepage at kyutai.org/pocket-tts. An English model is used here, with 7 languages available as separate models.
Methodology
Same hardware for all four: a desktop Core i9-13900K running Linux (WSL2) with processes pinned to performance cores via taskset. One-thread runs use one core, four-thread runs use four physical cores. The same three English test texts go through each model via its own Python package (pip install linnet-tts, piper-tts, kokoro-onnx, pocket-tts). Peak RSS is ru_maxrss of the Python process, interpreter and framework included, so these are process-level memory numbers, not raw model-weight sizes on disk.
One caveat the numbers hide: pocket-tts is designed to run across two cores and reports RTF on two cores. Linnet, Piper, and Kokoro are reported on one core. I kept both configurations because squashing pocket-tts to one core underreports the design intent.
Speed and memory only. Audio quality is not measured here. You will need to listen to decide that for yourself.
The numbers
| Model | RTF 1-core | RTF 4-core | Peak RSS | First audio | Streaming | Voice cloning | Languages |
|---|---|---|---|---|---|---|---|
| Piper medium 16 M | 5.8% | 2.1% | 503 MB | 180 ms | no | no | 1 |
| LinnetTTS 41 M | 10.6% | 3.4% | 187 MB | 87 ms | 80 ms steps | yes | 1 |
| pocket-tts 4.0.1 (100 M) | n/a | 24.1% | 968 MB | 71 ms | 80 ms steps | yes | 1 (7 separate) |
| Kokoro-82M | 51.7% | 17.2% | 1246 MB | 1.5 s | no | no | 8 |
Piper is the fastest here, partly because it is also the smallest and has the simplest decoding path (no voice prompts, no streaming). LinnetTTS is second fastest and the smallest in RSS by a wide margin. pocket-tts hits its design point on 2 cores at 23.8% RTF, and adding more cores barely moves the number (24.1% on four), so plan the budget around 2 cores. It also has the lowest first-audio latency at 71 ms, 16 ms ahead of LinnetTTS at 87 ms. Kokoro is the slowest in this group with 1.2 GB resident, which is the price its multilingual bank of voices pays.
What to pick and when
Pick Piper if you need a single English voice, no cloning, no in-sentence streaming, and the smallest install on disk (.onnx 64 MB for the medium voice). This is the right call for a static TTS backend on constrained devices, including small Raspberry Pis, where extras are overhead you do not need.
Pick LinnetTTS if you need voice cloning from a short prompt, 80 ms streaming so playback starts before the sentence ends, and a smaller resident footprint (187 MB vs 968 MB for pocket-tts, mostly a Rust-vs-PyTorch runtime difference as noted in Known limits). The trade is English only and a hybrid license (Apache code, Linnet Weights License for weights).
Pick pocket-tts if your target is a laptop or desktop with at least 2 performance cores available, you want voice prompts, and you accept around 1 GB of process memory. Fully permissive under MIT if license matters to you.
Pick Kokoro if you need more than one language. It is the only one here with 8-language coverage. The cost is the highest memory and the slowest speed, and no in-sentence streaming.
Rule of thumb for single-English on CPU: Piper if no cloning, Linnet if cloning. For multilingual CPU: Kokoro, with pocket-tts as an alternate when English-only is enough and memory is not tight.
Known limits of this benchmark
Three things this does not tell you. First, audio quality is not scored. Mean opinion scores on a shared test set would need a listening study, which is a different write-up. Second, this is one desktop CPU. Phones and Raspberry Pis will reorder the ranking because the models respond differently to thermal and memory pressure. Third, each model was run through its own Python package, so the numbers include whatever overhead each library imposes. For Piper and Kokoro that is ONNX Runtime, for pocket-tts it is PyTorch, for Linnet it is a thin Rust-backed wrapper. Much of the RSS gap between models is the runtime itself, not the model weights. Raw model-weight files on disk tell a different story: Piper 64 MB, Linnet 83 MB fp16, pocket-tts 236 MB, Kokoro 326 MB.
Run it yourself
The code, Rust runtime, and benchmark script are at github.com/VoxRT/LinnetTTS. If you want to hear Linnet alongside the other three on the same text, the Compare tab on the demo Space runs all four side by side. Model card and weights are at huggingface.co/VoxRT/linnet-en-35m.
Your turn
Which of these four is sitting in your product right now, and did the switch to a smaller model buy you what you expected, or did you trade quality for speed in a way that bit you later?