Kyutai Pocket TTS 2026: MIT Voice Cloning on a CPU, From One WAV File

By AIFoss · 10 min read
pocket-ttskyutaittsvoice-cloningselfhostedfoss

TL;DR: Pocket TTS is Kyutai’s 100M-parameter text-to-speech model that runs entirely on CPU — about 6x real-time on a MacBook Air M4 — and clones a voice from a plain WAV file, all under a clean MIT license. Quality lands below big GPU models, but for an always-on, private voice on hardware you already own, nothing this small comes close.

Pocket TTSKokoro-82MMOSS-TTS 1.5
Best forCPU voice cloning, always-on assistantsFast fixed voices on CPUHighest cloning quality, GPU owners
Hardware2 CPU cores, no GPU benefitCPU or GPU~8GB VRAM GPU
Voice cloningYes — any WAV referenceNo — preset voice packs onlyYes
LicenseMIT (code + weights)Apache 2.0Apache 2.0
The catchQuality ceiling below GPU models; no pause controlCan’t clone your own voiceNeeds a real GPU, heavier setup

Honest take: if you want your voice (or any specific voice) speaking locally on a machine without a GPU, Pocket TTS is the default choice in 2026. If you just need a pleasant preset voice, Kokoro is fine; if you own a 12GB+ GPU and want the best cloning fidelity, run MOSS-TTS 1.5 instead.

Zero-shot voice cloning used to be a GPU feature. XTTS wanted CUDA, MOSS-TTS wants around 8GB of VRAM, and most of the 2025-generation cloning models assume you have a graphics card doing nothing. Kyutai — the French non-profit lab behind the Moshi real-time voice model — went the other way: Pocket TTS is a 100M-parameter model built to saturate two CPU cores and nothing more. The repo sits at roughly 8.6k GitHub stars as of August 2026, and the pitch is simple: hand it a WAV file of someone talking, and it speaks any text in that voice, on the same laptop you’re reading this on.

This guide covers install, first generation, voice cloning from your own sample, the performance numbers that matter, and where Pocket TTS genuinely loses to the alternatives.

What Pocket TTS is

Pocket TTS is a Python package (with the model weights on Hugging Face at kyutai/pocket-tts) that does streaming text-to-speech with zero-shot voice cloning. Three design decisions define it:

  • 100M parameters. That’s small enough that the model is compute-bound on almost nothing. Kyutai reports that running it on a GPU gives no meaningful speedup over CPU — the model is simply too lean to benefit.
  • Streaming-first. You get the first audio chunk in roughly 200ms, which is what makes it usable for interactive assistants rather than just batch narration.
  • Voice-as-state. A reference voice is processed once into a model state, which you can export to a safetensors file and reload instantly later. Cloning isn’t a fine-tune; it’s a prompt.

License check, since that’s the first question for this audience: the GitHub repo (kyutai-labs/pocket-tts) carries a plain MIT license, and the weights are distributed openly on Hugging Face. No revenue caps, no attribution clauses, no non-commercial rider. That puts it in the cleanest license tier we track in our open-source LLM license shootout — rarer than it should be for voice cloning models, where restrictive terms are common.

Supported languages: English, French, German, Portuguese, Italian, and Spanish.

Install and first run

The package is on PyPI:

pip install pocket-tts
# or, with uv:
uv add pocket-tts

The fastest way to hear it is the CLI — with uv installed you don’t even need a persistent environment:

uvx pocket-tts generate

That pulls the weights from Hugging Face on first run and synthesizes with a default voice. In Python, the whole API is four lines:

from pocket_tts import TTSModel

tts_model = TTSModel.load_model()
voice_state = tts_model.get_state_for_audio_prompt("alba")
audio = tts_model.generate_audio(voice_state, "Hello world, this is a test.")

"alba" is one of the pre-made voices from Kyutai’s catalog. The get_state_for_audio_prompt / generate_audio split matters: the expensive-ish part (processing the voice) happens once, and every generation after that reuses the state.

Cloning a voice from your own WAV

This is the feature that earned Pocket TTS its attention. To clone, you pass a plain WAV file instead of a catalog name — on the CLI, the --voice flag accepts a path to any WAV file; in Python, you point get_state_for_audio_prompt at your sample.

Three practical rules from Kyutai’s own guidance and community testing:

  1. Clean audio in, clean audio out. The model reproduces the recording quality of your sample, not just the voice. Background hum, room echo, and phone-mic compression all come through in the output. Record close to the mic in a quiet room, or denoise the sample first.
  2. Length: more than the minimum helps. The viral claim is cloning from 5 seconds, and short clips do work — but community testing consistently finds 10–20 second references produce a noticeably more stable clone than 3–5 second ones. If you control the recording, read two or three sentences naturally.
  3. Export the state. Once a voice sounds right, save it:
voice_state = tts_model.get_state_for_audio_prompt("my_voice.wav")
# export to safetensors for instant loading later

The repo supports exporting voice states to safetensors files — loading one later is fast because it’s essentially just reading a KV cache from disk. For a home assistant setup, this means you process each household voice once and ship the states around like config files.

The obvious note on ethics and law: a tool that clones any voice from a few seconds of audio is a tool that clones any voice. Cloning someone’s voice without consent ranges from rude to illegal depending on jurisdiction and use. Keep it to your own voice or voices you have permission to use.

Performance: what “runs on CPU” actually means

The numbers Kyutai publishes, which line up with community reports:

  • ~6x real-time on a MacBook Air M4 — one minute of speech takes about ten seconds to generate. On an Apple MacBook Air M4, that’s fanless, silent synthesis.
  • ~200ms to first audio chunk, which is the number that matters for conversational use.
  • Two CPU cores. The model doesn’t scale past that, which is good news: it runs alongside your other workloads instead of monopolizing the box. Any recent desktop CPU — a Ryzen 9 7950X is overkill — stays comfortably above real-time, and reports of usable speeds extend down to mini-PC and SBC-class hardware.
  • Quantization exists but is CPU-only. TTSModel.load_model(quantize=True) shrinks the footprint further; the flag only works on CPU, which is fine because that’s where you’re running it anyway.

There’s also a C++ path: audio.cpp ships a PocketTTS backend that benchmarks 3.22x faster than the Python reference implementation (confirmed upstream in the Pocket TTS issue tracker). If you want this in a no-Python pipeline, our audio.cpp setup guide covers the build.

How it compares

vs Kokoro-82M: Kokoro is the other famous small CPU TTS — 82M parameters, Apache 2.0, excellent preset voices. But Kokoro works from pre-built voice packs; it cannot clone an arbitrary voice from a sample. If a good generic voice is all you need, Kokoro remains a great pick. The moment you want a specific voice, Pocket TTS is the only one of the two that can do it.

vs MOSS-TTS 1.5: MOSS clones with higher fidelity and more expressive prosody — it’s a much bigger model — but it wants around 8GB of VRAM and a PyTorch GPU stack. We reviewed it in our MOSS-TTS 1.5 review. If you have the GPU and quality is the priority (audiobook narration, voice-over), MOSS wins. No local GPU but still want to experiment with the big model? A cheap RunPod instance covers occasional batch jobs without buying hardware.

vs Coqui XTTS: the former default answer for local cloning. The original company shut down in early 2024; the code lives on in community forks, but the XTTS weights carry a non-commercial license and the stack is heavy. In 2026 it’s hard to recommend starting there when an MIT-licensed model does cloning on CPU.

vs piper: piper is still the right choice for embedded boards where even 100M parameters is too much — but it has no cloning and a lower quality ceiling.

When NOT to use Pocket TTS

  • You need broadcast-quality narration. The quality ceiling of a 100M model is real. For audiobooks or published voice-over, use MOSS-TTS on a GPU.
  • You need fine pause control. Pocket TTS currently doesn’t support inserting silence via the text input to create pauses — a real limitation for scripted narration with deliberate pacing.
  • You need languages outside the six supported. No Chinese, Japanese, or Korean as of August 2026.
  • You only need one nice generic voice. Kokoro’s presets are excellent and the model is even smaller.

Where it fits in a self-hosted stack

Pocket TTS slots naturally as the speech output stage of a local voice pipeline: pair it with faster-whisper for input and a local LLM for the middle, as in the HuggingFace speech-to-speech pipeline we covered — the TTS stage there is swappable, and a CPU-only model frees your entire GPU for the LLM. That’s the practical win: on a single-GPU home server, every gigabyte of VRAM the TTS doesn’t use is VRAM your LLM keeps. For the hardware side of always-on assistant boxes, see the GPU-accelerated TTS alternatives guide at runaihome.com.

FAQ

Does Pocket TTS really clone a voice from 5 seconds of audio? Yes, it works from very short samples — but treat 5 seconds as the floor, not the target. A clean 10–20 second reference produces a noticeably more stable and accurate clone. Recording quality matters as much as length: the model reproduces the acoustics of your sample.

Can I use Pocket TTS commercially? Yes. The code is MIT-licensed and the weights are openly distributed on Hugging Face under the same permissive terms — no revenue caps or attribution requirements. The usual caveat: commercial use of a cloned voice still requires rights to that voice, which is a consent and publicity-law question, not a software-license one.

Do I need a GPU at all? No, and it wouldn’t help — Kyutai reports no speedup from GPU inference because the model is too small to be GPU-bound. It saturates about two CPU cores and reaches ~6x real-time on a laptop-class chip. This is one of the few modern AI models where the correct hardware answer is “whatever you already have.”

Sources

  • Apple MacBook Air M4 — the reference machine for Kyutai’s 6x real-time benchmark; fanless Pocket TTS.
  • AMD Ryzen 9 7950X — far more CPU than Pocket TTS needs, with headroom to run your LLM stack beside it.

Was this article helpful?

What self-hosting actually costs

Real cost breakdowns for self-hosted AI: hardware floors, power, maintenance hours, and the honest comparison against paying for it. No spam, unsubscribe anytime.