TL;DR

Pocket TTS is Kyutai’s new 100M-parameter text-to-speech model, released January 13, 2026 and trending on GitHub this week (2,609 stars gained, 7,379 total). Its selling point is unusual for a modern TTS: it does zero-shot voice cloning from ~5 seconds of audio, entirely on CPU, in ~6x realtime on a MacBook Air M4 — no GPU, no API key, no cloud. Key facts:

  • 100M-parameter streaming language model built on Kyutai’s CALM (Continuous Audio Language Models) framework
  • CPU-only inference — PyTorch 2.5+ CPU wheel is enough, no CUDA required
  • ~200ms first-audio latency, ~6x realtime throughput on a MacBook Air M4, uses only 2 CPU cores
  • Zero-shot voice cloning from a 5-second audio sample, no fine-tuning
  • 6 languages with pretrained models: English, French, German, Spanish, Portuguese, Italian
  • MIT license on code; per-voice licenses listed on the voice card
  • Works in the browser via WebGPU/WASM implementations (kyutai-labs/pocket-tts-js)
  • Python API, CLI, and local HTTP server all shipped in one pip install

If you have been looking at Kokoro-82M and wishing it did on-the-fly voice cloning, or looking at ElevenLabs and wishing you did not need the API bill, Pocket TTS is the interesting middle path this month.

Quick Reference

FieldValue
Repokyutai-labs/pocket-tts
Weights🤗 kyutai/pocket-tts
Try in browserkyutai.org/pocket-tts
Tech reportkyutai.org blog, Jan 13, 2026
PaperarXiv:2509.06926
LicenseMIT (code); voice licenses vary
Params100M
First-audio latency~200ms
Throughput~6x realtime on 2-core CPU (MacBook Air M4)
Languages6 (EN/FR/DE/ES/PT/IT)
RuntimePython 3.10–3.14, PyTorch 2.5+, CPU

What Pocket TTS Actually Is

Kyutai’s earlier TTS releases (Moshi, Delayed Streams Modeling) were impressive but demanding — GPU-only, tuned for full-duplex conversational agents. Pocket TTS is the opposite tradeoff: a stripped-down, streaming-only model designed so that anyone with a laptop can generate cloned voices locally.

The architecture is a streaming autoregressive language model over continuous audio representations — no discrete audio codebook, no separate vocoder step. Instead of predicting audio tokens and decoding them, the model predicts continuous frame embeddings directly, which produces the flat latency profile Kyutai advertises: the model does not need to buffer a full utterance before starting to speak.

There are three ways to use it:

  1. CLI — uvx pocket-tts generate --text "..." writes a WAV file.
  2. Local HTTP server — uvx pocket-tts serve exposes an OpenAI-compatible-ish endpoint on localhost:8000 with a small web UI, keeping the model in memory between requests.
  3. Python library — import TTSModel, call get_state_for_audio_prompt once per voice, then reuse the state for repeated calls.

The voice cloning mechanism is the interesting part. get_state_for_audio_prompt accepts either a preset voice name ("alba", "charles", "eve", ~25 shipped voices), a local .wav file, or a Hugging Face URL like hf://kyutai/tts-voices/expresso/ex01-ex02_default_001_channel2_198s.wav. Under the hood it turns your reference clip into a KV-cache — an “audio prompt” that primes the model. You can serialize this to a .safetensors file with export_model_state, so warm loads are essentially free after the first pass.

Three things pushed Pocket TTS into GitHub Trending Python (2,609 stars this week):

  1. CPU voice cloning was largely absent from the open-source shelf. Kokoro-82M is fast on CPU but ships with fixed voice packs; adding a new voice requires community projects like KokoClone or full fine-tuning. Piper is even faster but does not do zero-shot cloning at all. Pocket TTS fills that specific gap.
  2. The r/LocalLLaMA benchmark thread compared it against Kokoro, Supertonic, and Inflect-Nano on English TTS. Comments called out that “with a good voice sample, Pocket TTS was unambiguously superior” for cloning quality — although raw speed still favored Kokoro for its fixed voices.
  3. The Hacker News thread framed it as the “give your CPU a voice” release. The top comments were less about model quality and more about integrations — Firefox Reader Mode, speech-dispatcher on Linux, macOS say — reinforcing that the interesting use case is on-device narration, not batch content generation.

The pattern is familiar: a model that runs on the hardware you already have, with a genuinely differentiated capability (voice cloning), under a permissive license (MIT). That combination tends to travel far in the local-first community.

Installation

The path of least resistance is uv, because it isolates the audio dependency graph automatically:

# One-off run, no install
uvx pocket-tts generate --text "Hello, world."

# Persistent install
uv add pocket-tts

The plain-pip route also works if you already have PyTorch 2.5+ in your environment:

pip install pocket-tts

Requirements are surprisingly modern: Python 3.10 through 3.14 (yes, 3.14 wheels ship), PyTorch 2.5+, and specifically the CPU build of PyTorch — you do not need CUDA installed. If you already have the CUDA wheel installed for other work, Pocket TTS will still run; it just will not use the GPU.

Basic Generation

The default CLI call:

uvx pocket-tts generate \
  --text "Pocket TTS runs on your CPU with two cores and about 200 milliseconds of latency." \
  --voice alba \
  --output out.wav

You will see something like RTF: 0.17 | first-audio: 214ms | total: 3.4s in the log — real-time factor below 1.0 means the model generates faster than the audio plays.

For a different language, pass --language:

uvx pocket-tts generate --language french --voice estelle \
  --text "Bonjour, ceci est un test."

Non-English languages ship in two sizes. The default is a smaller model tuned for speed; the _24l variants (e.g., italian_24l) are 24-layer variants trading throughput for higher naturalness. On a laptop CPU, the difference is roughly 2x slower, still faster than realtime.

Voice Cloning From a Recording

This is the reason to pick Pocket TTS over Kokoro or Piper. Point --voice at any WAV file:

uvx pocket-tts generate \
  --voice ./my-voice-sample.wav \
  --text "This is my cloned voice reading text aloud."

The first call is slow — the model has to encode the reference audio into an audio-prompt KV-cache. Every subsequent call with the same voice file will re-encode it unless you export the state first. That is what export-voice is for:

uvx pocket-tts export-voice \
  --voice ./my-voice-sample.wav \
  --output ./my-voice.safetensors

Then, in Python:

from pocket_tts import TTSModel
import scipy.io.wavfile

model = TTSModel.load_model()

# Cold load once — takes a few seconds
voice_state = model.get_state_for_audio_prompt("./my-voice.safetensors")

# Every subsequent call is ~200ms to first audio
audio = model.generate_audio(voice_state, "First sentence.")
scipy.io.wavfile.write("out1.wav", model.sample_rate, audio.numpy())

audio = model.generate_audio(voice_state, "Second sentence.")
scipy.io.wavfile.write("out2.wav", model.sample_rate, audio.numpy())

Kyutai explicitly recommends cleaning your reference sample before cloning — Adobe Podcast Enhance or similar — because the model reproduces the acoustic conditions of the sample, not just the voice. If your reference has a hum or a reverb tail, so will the output.

The reference clip does not need to match the target language. Cross-lingual cloning — feed a French speaker’s voice, generate English — works, though prosody tends to inherit the source language’s rhythm.

Running It As a Local Server

For interactive use or integrating with other tools, pocket-tts serve is easier than repeated CLI calls because the model stays warm in RAM:

uvx pocket-tts serve --port 8000

That gives you a small web UI at http://localhost:8000 and an HTTP endpoint. You can wire it up to a Firefox Reader-Mode-style workflow, a note-taking app that reads notes aloud, or an accessibility tool. Several people on the HN thread mentioned integrating with speech-dispatcher on Linux to swap out espeak-ng as the system TTS backend.

Voice Cloning Quality: What The Benchmarks Say

Kyutai’s own technical report publishes Objective MOS and speaker-similarity numbers, but the more useful data is from the r/LocalLLaMA benchmark by Vector Machines, which compared Pocket TTS against Kokoro, Supertonic, and Inflect-Nano on the same English text with the same 5-second reference clips.

Rough summary of that comparison (subjective, but consistent across commenters):

  • Cloning quality: Pocket TTS > Supertonic > Inflect-Nano > Kokoro (Kokoro does not do zero-shot cloning natively; the comparison used community forks).
  • Fixed-voice quality: Kokoro ≥ Pocket TTS. Kokoro’s shipped voice packs remain the gold standard for canned English narration.
  • CPU speed: Kokoro > Pocket TTS. Kokoro is roughly a decade of order-of-magnitude engineering effort ahead on raw throughput.
  • Language coverage: Kokoro (8 languages via Kokoro-82M) > Pocket TTS (6 languages) > Supertonic (English only).

The takeaway is that if you know your voice roster ahead of time and it fits inside Kokoro’s shipped voice packs, Kokoro is the pragmatic pick. If you want ad-hoc cloning from a fresh sample without setting up a training pipeline, Pocket TTS is the better tool.

Honest Limitations

A model this small has real tradeoffs. From the HN and r/LocalLLaMA threads and my own testing, these are the ones worth calling out:

  • Zero-shot voice cloning has a ceiling. As one HN commenter put it: “Zero shot voice clones have never been very good. Fine-tuned models hit natural speaker similarity and prosody in a way zero shot models can’t emulate.” Pocket TTS is impressive for a 100M CPU model, not impressive vs. a fine-tuned 400M-param model on GPU.
  • English is clearly the primary language. The 24-layer variants for FR/DE/ES/PT/IT help, but there is no official Japanese, Korean, or Chinese support, and adding more languages requires retraining — no LoRA path published.
  • No official fine-tuning code. You can play with the audio-prompt KV-cache, but there is no supported way to permanently teach the model a new voice or accent from a longer dataset. This is a known limitation the maintainers have acknowledged in issues.
  • License nuance on voices. The code is MIT, but each shipped voice on kyutai/tts-voices has its own license (some are CC-BY, some are from VCTK). If you ship a product using a specific preset voice, read that voice’s card.
  • Prosody control is limited. Unlike VoxCPM2 or F5-TTS, there is no “controllable cloning” mode where you can inject "speak faster, more cheerful" style prompts. You get the reference voice’s style, take it or leave it.
  • The reference-audio prompt reproduces acoustic conditions. If your recording has room reverb, the cloned voice will sound like it is in that room. Denoise first.

When To Pick Pocket TTS vs Alternatives

Use caseBest choice
On-device voice cloning from a fresh samplePocket TTS
Highest-quality English narration with fixed voicesKokoro-82M
Multilingual with 30+ languagesVoxCPM2 or XTTS-v2
Real-time on Raspberry Pi 5Piper
Zero-shot cloning with prosody controlVoxCPM2 (needs GPU)
Cross-lingual cloningPocket TTS or VoxCPM2
ElevenLabs-level polishElevenLabs (there is no OSS parity yet)

For most local-first, “I want to read my notes back to me in my own voice” use cases, Pocket TTS is now the top pick under permissive license.

FAQ

How does Pocket TTS compare to Kokoro on CPU?

Kokoro-82M is faster and has higher-quality fixed voices, but does not do native zero-shot voice cloning — you can only use its shipped voice packs unless you fine-tune. Pocket TTS is slightly slower and slightly larger (100M vs 82M params), but clones a voice from ~5 seconds of audio on the fly. If you know your voices ahead of time, use Kokoro. If you want ad-hoc cloning, use Pocket TTS.

Does Pocket TTS need a GPU?

No. It runs on the CPU-only PyTorch build. On a MacBook Air M4 it hits ~6x realtime using only 2 CPU cores. On older laptops (5+ years) it will still run at ~1x realtime or better. A GPU is not just optional — it is unused; Pocket TTS is CPU-only by design.

What languages does Pocket TTS support?

Six: English, French, German, Spanish, Portuguese, and Italian. English is the primary language; the other five have both a fast default variant and a slower higher-quality 24-layer variant. There is no official support for Asian languages (Japanese, Korean, Chinese) or Arabic yet. Cross-lingual voice cloning — using a French speaker’s voice to say English text — works, though prosody follows the source language’s rhythm.

Cloning your own voice or a voice you have permission to use is legal in most jurisdictions. Cloning someone else’s voice without consent is subject to a rapidly-evolving legal landscape (Tennessee’s ELVIS Act, EU AI Act, and various US state laws). Kyutai’s model card and README both include a prohibited-use section against non-consensual cloning. Read Kyutai’s ethics statement and check local law before deploying.

Can Pocket TTS run in a browser?

Yes. Kyutai maintains pocket-tts-js, a WebAssembly/WebGPU implementation that runs the model client-side in a browser tab. Try it at kyutai.org/pocket-tts. This is one of the more compelling demos — the entire model fits in browser memory and produces streaming audio without any server call after the initial download.

How does Pocket TTS compare to ElevenLabs?

ElevenLabs is still ahead on absolute voice quality, prosody control, and language coverage. Pocket TTS is dramatically ahead on cost ($0 vs $22/month minimum), privacy (fully local vs cloud API), and latency for short generations. For production narration, ElevenLabs is the safer pick today. For agent-embedded, local, always-on TTS, Pocket TTS is the pragmatic choice.

Sources