The benchmark results are in, and the numbers tell a story that’s both boring and revolutionary. Pocket TTS is the slowest model in the field. Its Mean RTF of 0.714 puts it dead last against every competitor tested. If you’re optimizing purely for speed, you’d pick Supertonic 3 at 2 steps (0.121 RTF) and never look back.
But here’s the thing: speed isn’t the point. And that’s exactly why Pocket TTS is the most interesting text-to-speech model to drop this year.
The Architecture That Breaks the Mold
Pocket TTS isn’t another acoustic-model-plus-vocoder setup. Kyutai built it as a ~100M parameter streaming language model that generates audio tokens over their Mimi neural codec, then decodes to 24kHz. Think of it as an autoregressive LLM, but for audio. Token by token.
This architectural choice has two immediate consequences that matter for anyone building real-time voice applications:
-
Latency is flat across text lengths. Its RTF stays between 0.69 and 0.76 whether you feed it 12 characters or 1,712 characters. No fixed overhead to amortize. Compare that with Kokoro PyTorch, which climbs from 0.49 on tiny text to 0.83 on long text. Pocket TTS doesn’t care how much you give it.
-
It streams. The model generates audio tokens sequentially, which means you can start playing audio before the model has finished processing the entire input. For interactive applications, voice assistants, real-time dubbing, live captioning, this is the difference between a usable product and a frustrating one.
This isn’t just a different implementation. It’s a fundamentally different paradigm from the acoustic-model-plus-vocoder approach that’s dominated TTS for years. And it comes with tradeoffs that matter.
The Benchmark That Tells the Real Story
The numbers from a comprehensive benchmark of 180 timed runs across 36 audio samples tell a nuanced story. Here’s the full table:
| Config | Mean RTF | UTMOS MOS | Params | License |
|---|---|---|---|---|
| Supertonic 3 (2-step) | 0.121 | 1.53 | ~99M | OpenRAIL-M |
| Inflect-Nano-v1 | 0.145 | 3.48* | 4.6M | Apache 2.0 |
| Supertonic 3 (5-step) | 0.240 | 4.32 | ~99M | OpenRAIL-M |
| Kokoro 82M (ONNX) | 0.641 | 4.44 | 82M | Apache 2.0 |
| Kokoro 82M (PyTorch) | 0.665 | 4.46 | 82M | Apache 2.0 |
| Pocket TTS | 0.714 | 4.10 | ~100M | MIT |
Hardware: Intel Xeon 8272CL, 4 cores, 16GB RAM, no GPU. UTMOS is utmos22_strong, an objective MOS predictor.
Pocket TTS sits at the bottom of the speed chart with a 0.714 RTF. But that number hides the real story.
Why Latency Flatness Matters More Than Speed
Traditional TTS models have a fixed startup cost. They need to process the entire input before generating any output. This means short utterances get penalized by overhead, and long utterances suffer from memory constraints.
Pocket TTS’s flat latency profile means it’s equally good (or equally bad, depending on your perspective) at every text length. For interactive applications where input length varies wildly, think voice assistants, real-time translation, or dynamic narration, this consistency is more valuable than raw speed on short texts.
The streaming capability is the killer feature here. Most TTS models require you to wait for the entire audio to be generated before you can play a single syllable. Pocket TTS can start outputting audio almost immediately, token by token. For latency-sensitive applications, this changes the game entirely.
The Voice Cloning That Changes Everything
Here’s where Pocket TTS separates itself from the pack: zero-shot voice cloning from 5 seconds of audio. On CPU. Under MIT license.
Hand it a 5-second reference clip of any voice, and it speaks in that voice. Accent, timbre, pacing, even the mic character of the reference. No fine-tuning. No GPU. No cloud API calls.
None of the other CPU-friendly models can do this. Kokoro and Inflect-Nano ship fixed voice sets. Supertonic is the same. If you want a user-supplied voice on a CPU box, Pocket TTS is currently in a category of one.
This isn’t just a nice-to-have feature. It fundamentally changes what’s possible with local TTS. Imagine:
– Accessibility tools that can speak in a user’s own voice from a short recording
– Game NPCs that can be voiced by any player in seconds
– Content creators who can generate narration in any voice without cloud costs
– Privacy-sensitive applications that never send audio data to a server
The Benchmark Reality Check
The benchmark results tell a nuanced story. Pocket TTS scores a 4.10 on UTMOS MOS, which puts it behind Kokoro 82M (4.44-4.46) and Supertonic 3 at 5 steps (4.32), but ahead of Inflect-Nano (3.48) and Supertonic at 2 steps (1.53).
But here’s the thing about those UTMOS scores: they’re not the whole picture. The Inflect-Nano asterisk is telling. UTMOS gave it a 3.48, but to the ear it’s buzzy and robotic. This is a known UTMOS failure mode where it over-rates small HiFi-GAN vocoders for being clean rather than natural. Objective metrics are useful, but they’re not a substitute for listening.
The benchmark also revealed a hard ~15 second output cap on Inflect-Nano that inflated its RTF on long inputs. Real-world constraints that benchmarks don’t always capture.
The Voice Cloning That Changes the Game
This is the headline feature, and it’s worth understanding why it matters. Pocket TTS can clone a voice from a 5-second reference clip. Accent, timbre, pacing, even the mic character. No fine-tuning. No GPU. MIT license.
None of the other CPU-friendly models can do this at all. Kokoro and Inflect-Nano ship fixed voice sets. Supertonic is the same. If you want a user-supplied voice on a CPU box, Pocket TTS is currently in a category of one.
The implications are significant:
– Accessibility: Tools that can speak in a user’s own voice from a short recording
– Gaming: NPCs that can be voiced by any player in seconds
– Content creation: Narration in any voice without cloud costs
– Privacy: Sensitive applications that never send audio data to a server
One developer on Reddit noted they’ve been “very happy with the voice cloning results” so far, calling it “not Omnivoice, but for its size, I haven’t found anything else that comes close.” That’s the key qualifier: for its size. At ~100M parameters running on CPU, the fact that it works at all is remarkable.
The Practical Tradeoffs
The benchmark results give us clear guidance for different use cases:
- Need voice cloning on CPU? Pocket TTS, no other option in this field
- Fixed voice, highest quality? Kokoro 82M
- Latency-critical with acceptable quality? Supertonic 3 at 5 steps
- Tiny footprint for short utterances? Inflect-Nano-v1, if you can live with the buzz and the 15s cap
- Prototyping only? Supertonic 3 at 2 steps
Pocket TTS isn’t the fastest or the highest quality. But it’s the only model that offers voice cloning on CPU, and that’s a feature that changes the calculus for many applications.
The Installation Experience That Actually Matters
One of the most underrated aspects of Pocket TTS is the installation experience. It’s genuinely painless: pip install pocket-tts, no CUDA build, no HuggingFace-repo-plus-sys.path wiring. Downloads weights on first load. The least fussy of the six models tested.
This matters more than most developers give it credit for. The friction of getting a model running is often the biggest barrier to adoption. Pocket TTS removes that friction entirely.
The License That Makes It Practical
The MIT license is a big deal. Kokoro is Apache 2.0 (also great). Supertonic is OpenRAIL-M with commercial restrictions. Pocket TTS being MIT means you can do essentially whatever with it commercially.
For startups and independent developers, this is the difference between “can I use this?” and “I need to talk to legal first.” The MIT license removes ambiguity and friction from the adoption process.
Where It Fits in the Broader Landscape
Pocket TTS is part of the broader movement toward local AI inference that’s reshaping how we think about AI deployment. The idea that you can run a capable TTS model with voice cloning on a CPU, without any cloud dependency, is a significant shift.
But it’s not without its limitations. The 0.714 RTF means it’s not suitable for real-time applications where sub-100ms latency is required. For those use cases, you’d want to look at a similar analysis of streaming TTS latency claims to understand the tradeoffs.
The Installation Experience That Actually Matters
One of the most refreshing aspects of Pocket TTS is the installation experience. It’s genuinely painless: pip install pocket-tts, no CUDA build, no HuggingFace-repo-plus-sys.path wiring. Downloads weights on first load. The least fussy of the six models tested.
This matters more than most developers give it credit for. The friction of getting a model running is often the biggest barrier to adoption. Pocket TTS removes that friction entirely.
The License That Makes It Practical
The MIT license is a big deal. Kokoro is Apache 2.0 (also great). Supertonic is OpenRAIL-M with commercial restrictions. Pocket TTS being MIT means you can do essentially whatever with it commercially.
For startups and independent developers, this is the difference between “can I use this?” and “I need to talk to legal first.” The MIT license removes ambiguity and friction from the adoption process.
The Reality Check
Before you get too excited, let’s be clear about what Pocket TTS isn’t. It’s not a replacement for cloud-based TTS services like ElevenLabs or OpenAI’s TTS. Those models are larger, faster, and higher quality. But they require GPUs and cloud infrastructure.
Pocket TTS is for the edge. It’s for applications where you can’t or won’t send audio data to a cloud server. It’s for offline use cases. It’s for privacy-sensitive applications. It’s for developers who want to experiment without burning GPU credits.
The voice cloning quality is good, but it’s not perfect. The benchmark used a preset voice (alba) for fair comparison, and the cloning capability wasn’t benchmarked against models that don’t have it. Early reports suggest it handles accented English well, but non-English and singing voices remain untested territory.
The Verdict
Pocket TTS is the slowest model in the benchmark. It’s also the most interesting. The streaming architecture, flat latency profile, and zero-shot voice cloning on CPU create a combination that no other model in this space offers.
The MIT license removes commercial friction. The painless installation removes technical friction. The voice cloning capability opens use cases that were previously impossible on CPU hardware.
If you’re building anything that needs voice cloning on local hardware, Pocket TTS is currently in a category of one. For everything else, the established players still have advantages. But the direction is clear: the future of TTS is streaming, local, and open.
The benchmark data and all 36 WAV samples are available for anyone who wants to a reality check on Pocket TTS’s actual performance. The numbers don’t lie, but they also don’t tell the whole story. Sometimes the most interesting model isn’t the fastest or the highest quality, it’s the one that opens a door that was previously locked.
