Pocket TTS is Kyutai's answer to a question most TTS projects ignore: what if generating speech required no GPU at all? It is a 100M-parameter text-to-speech model and Python package designed to run efficiently on ordinary CPUs — about 6x faster than real time on a MacBook Air M4 while using only 2 CPU cores, with roughly 200ms latency to the first audio chunk. Released by the Paris-based open-science lab behind Moshi and the Mimi codec, the MIT-licensed repository has accumulated over 7,600 GitHub stars, making it one of the most popular speech projects of the year. ## Small Enough to Ship Anywhere The entire premise is deployment friction. Installing Pocket TTS is `pip install pocket-tts` (or a one-shot `uvx pocket-tts generate`); it needs PyTorch 2.5+, but explicitly not the GPU build, and supports Python 3.10 through 3.14. At 100M parameters the model is two orders of magnitude smaller than the LLM-based TTS stacks that dominate leaderboards, which is what makes CPU-only, always-available speech synthesis realistic inside desktop apps, CLI tools, embedded assistants, and CI pipelines. There are even community implementations that run the model client-side in the browser, and the official demo on kyutai.org runs without any installation. ## Streaming, Long Inputs, and Voice Cloning Despite the size, the feature set is not toy-grade. Audio streams as it generates, so playback can start after ~200ms rather than after the full utterance. Text input length is effectively unlimited — the model handles infinitely long inputs by design, which matters for reading articles or documents aloud. Voice cloning works from a plain WAV file passed as the `--voice` argument, with a catalog of pre-made voices hosted on Hugging Face and an `export-voice` command that converts a reference clip into a safetensors embedding for near-instant loading (it just restores a KV cache from disk). Kyutai documents per-voice licensing transparently in its tts-voices repository. ## Multi-Language With Size Options Pocket TTS speaks English, French, German, Portuguese, Italian, and Spanish. Non-English languages ship in two variants: the default lightweight model and larger 24-layer versions (e.g. `--language italian_24l`) that trade speed for quality. The CLI covers three workflows — `generate` for one-shot synthesis, `serve` for a local HTTP server with a web UI that keeps the model warm between requests, and `export-voice` for the fast-loading voice embeddings. ## A Clean Python API The library API is deliberately simple: load a model, build a voice state from an audio prompt, and call `generate_audio` to get a PCM tensor. Voice states are reusable and multiple can be held in memory simultaneously, which makes multi-speaker applications straightforward. The design (documented alongside a tech report and paper) descends from Kyutai's delayed-streams modeling work, the same lineage as its production STT/TTS models. ## Trade-offs and Limitations A 100M-parameter model cannot match the naturalness or expressiveness of multi-billion-parameter systems like VibeVoice or CosyVoice 3 — Pocket TTS optimizes for footprint and latency, not maximum fidelity. Language coverage is six European languages, far from the hundreds that multilingual models offer. Cloning quality faithfully reproduces the reference clip's audio quality, so noisy samples need cleanup first. And while CPU inference is the headline, that also means it does not exploit a GPU when one is available. ## Who Should Use This Pocket TTS is ideal for developers embedding speech into applications where a GPU dependency is a dealbreaker: desktop utilities, accessibility tools, offline assistants, edge devices, and server workloads where GPU capacity is reserved for LLMs. For hobbyists it is the fastest path from `pip install` to spoken audio available today, and the MIT license plus Kyutai's open-science track record make it a safe foundation to build on.