How to Run Pocket TTS Small Models on CPU: 18M, 7M and 1.9M Voice-Cloning TTS

Kyutai’s Pocket TTS 4.0 adds six small English text-to-speech models, and the headline is that the 18.2M-parameter one matches the quality of the original ~100M Pocket TTS while running about 3.5x faster on a single CPU thread (9.9x vs 2.8x real time in Kyutai’s table). If you want local speech output with voice cloning in a CLI tool, a voice agent, an accessibility app, or a cheap server, you can now get it from a model under 20M parameters that needs no GPU. This guide walks through install, choosing between the 18M, 7M and 1.9M models, generating speech, cloning a voice, running the local HTTP server, and using the new no-Python binary.

Everything below comes from Kyutai’s blog post on the small models (October 20, 2026), the v4.0.0 release notes, the project README and the CLI docs. We also ran each command on a cloud box (8 vCPU Intel Xeon, Linux, Python 3.13.5, torch 2.14.1+cpu, pocket-tts 4.0.0) on October 21, 2026 (Beijing time), and we call out what we saw where it matters.

Key facts (official sources, October 2026):

  • New models: english_18m_2026-10, english_7m_2026-10, english_2m_2026-10, each with a _refl variant that adds reward fine-tuning. The 2M models are marked experimental.
  • Sizes (decoder included): 18.2M, 6.9M and 1.9M parameters.
  • Speed (Kyutai, 1 CPU thread): 9.9x, 12.6x and 25x real time, vs 2.8x for the ~100M Pocket TTS.
  • Install: pip install pocket-tts (Python 3.10 to 3.14, PyTorch 2.5+, no GPU build needed). Select a model with --language.
  • New in 4.0: standalone pocket-tts binaries for Linux, macOS and Windows that need neither Python nor PyTorch.
  • Licenses: code MIT; model weights CC-BY-4.0 on Hugging Face. Voice cloning weights are behind a Hugging Face terms click-through.

For more local-model walkthroughs, start from the 7minai homepage. If you need a bigger TTS with natural-language style control and paralinguistic tags, compare with running Ming-3.0-tts locally.

What changed in Pocket TTS 4.0

Pocket TTS launched as a ~100M-parameter TTS with voice cloning that runs faster than real time on a laptop CPU using two cores. The October 2026 work, written up by Kyutai’s Manu Orsini as “The tiny TTS was actually 10x too big,” distills that system down much further. Kyutai started from a ~300M-parameter teacher and shrank all the parts that run at inference time:

  • The backbone (the transformer that reads text and the voice prompt) was cut step by step, with a retraining pass by distillation after every cut. The blog reports that cutting gradually beat a single big cut or a cold start.
  • The sampling head went from a 9M-parameter flow model to a 0.84M one-step head on the 18.2M and 6.9M models, and to a 0.10M head on the 1.9M model.
  • The audio decoder, which runs on every frame, went from the 10.3M-parameter Mimi decoder to a 2.6M decoder (18.2M and 6.9M models) and a 1.0M decoder (1.9M model).

The _refl variants add an optional reward fine-tuning stage. Kyutai says it raises UTMOS (an automatic naturalness score on a 1 to 5 scale) by 0.04 to 0.06 without hurting word error rate, but warns that this kind of tuning can reward-hack: on an internal model it narrowed the pitch range by about 0.4 semitones, making the voice a little more monotone.

Choose a model: 18M, 7M or 1.9M

Kyutai evaluated voice cloning on LibriSpeech test-clean (1,127 sentences), averaging three seeds. WER is the word error rate of a speech recognizer listening to the output (lower is better), UTMOS estimates naturalness (higher is better), and SIM is speaker similarity to the voice prompt.

Model (--language)ParamsWERUTMOSSIMCPU speed, 1 thread
Original Pocket TTS~100M0.92%4.3640.9232.8x real time
english_18m_2026-1018.2M0.85%4.3390.9189.9x
english_18m_refl_2026-1018.2M0.82%4.4000.9179.9x
english_7m_2026-106.9M0.90%4.3560.91412.6x
english_7m_refl_2026-106.9M0.89%4.3950.91312.6x
english_2m_2026-101.9M1.72%3.9060.91025x
english_2m_refl_2026-101.9M1.27%4.0120.91025x

Source: Kyutai blog.

How to read this as a builder:

  • Start with english_18m_refl_2026-10. It has the best WER and UTMOS in the table, including better numbers than the original 100M model, at more than three times the single-thread speed.
  • Use english_7m_refl_2026-10 when CPU is tight, for example many concurrent voices on one server or a small ARM board. Quality is close to the 18M model on these metrics.
  • Treat the 1.9M models as experiments. WER roughly doubles compared with the 18M model and UTMOS drops below 4.1. They are interesting for very constrained devices, and Kyutai labels them experimental in the release notes.
  • These are English-only. The small models are all english_*. For French, German, Portuguese, Italian, Spanish or Dutch, keep using the existing language models (french, german, and so on), which are larger.

The default english model is still the larger one (the docs say english is the same model as english_2026-09_2), so you have to pass --language explicitly to get the small models.

Step 1: Install Pocket TTS without the CUDA download

Pocket TTS supports Python 3.10, 3.11, 3.12, 3.13 and 3.14 and needs PyTorch 2.5 or newer. It does not need a GPU build of PyTorch.

On Linux, plain pip install pocket-tts pulls the CUDA build of PyTorch from PyPI, which the README says adds several gigabytes (roughly 3 GB instead of 200 MB with torch 2.13). Use the PyTorch CPU index instead:

python3 -m venv .venv
source .venv/bin/activate
pip install pocket-tts --extra-index-url https://download.pytorch.org/whl/cpu

On our test box this installed pocket-tts 4.0.0 with torch 2.14.1+cpu. On macOS and Windows the default PyTorch wheels are already CPU-only, so pip install pocket-tts is fine.

If you prefer not to install anything permanently, uvx runs it in a throwaway environment:

uvx --index https://download.pytorch.org/whl/cpu pocket-tts generate --language english_18m_2026-10

For a uv project, the README gives this pyproject.toml snippet to pin the CPU index:

[[tool.uv.index]]
name = "pytorch-cpu"
url = "https://download.pytorch.org/whl/cpu"
explicit = true

[tool.uv.sources]
torch = [{ index = "pytorch-cpu" }]

Step 2: Generate your first file with a small model

pocket-tts generate \
  --language english_7m_2026-10 \
  --voice alba \
  --text "Pocket TTS small models run on a laptop CPU." \
  --output-path ./out7m.wav

The first run downloads the tokenizer and weights from Hugging Face; later runs use the cache. The output is always a WAV file at 24 kHz, mono, 16-bit PCM (we confirmed 24,000 Hz, 1 channel, 2-byte samples on our output). If you leave out --output-path, it writes ./tts_output.wav.

The CLI prints timing after each run. On our 8-vCPU box, that command reported Generated: 3280 ms of audio in 369 ms so 8.89x faster than real-time. That is a single short clip on a shared cloud VM, so treat it as a sanity check rather than a benchmark; Kyutai’s 12.6x figure for this model is measured on one thread with a long eval set.

The built-in voices from the README work with the released models. English ones include alba, anna, azelma, bill_boerst, caro_davy, charles, cosette, eponine, eve, fantine, george, jane, jean, javert, marius, mary, michael, paul, peter_yearsley, stuart_bell and vera. Voice licenses are listed on the kyutai/tts-voices page.

Useful generation flags

From the generate docs:

  • --temperature (default 0.3): higher is more expressive, for example --temperature 1.0.
  • --sampler-decode-steps (default 1): more steps for quality tuning, for example --sampler-decode-steps 5 --temperature 0.5.
  • --eos-threshold (default -4.0): a smaller value finishes earlier.
  • --frames-after-eos: frames to keep after end of speech; each frame is 80 ms.
  • --quantize: int8 quantization (see Step 6).
  • --quiet / -q: no log output.

Step 3: Clone a voice (and unlock the gated weights)

Pass any audio file, URL or hf:// path to --voice and Pocket TTS clones it:

pocket-tts generate \
  --language english_18m_refl_2026-10 \
  --voice ./my_voice.wav \
  --text "This is my cloned voice running on a CPU."

This is where most people hit the first error. On our box, built-in voices like alba and marius worked with no Hugging Face login, but cloning from a WAV failed with:

ValueError: We could not download the weights for the model with voice cloning,
... go to https://huggingface.co/kyutai/pocket-tts and accept the terms,
then make sure you're logged in locally with `uvx hf auth login`.

The fix is exactly what the message says:

  1. Open huggingface.co/kyutai/pocket-tts, sign in and accept the terms. (The Hugging Face API lists the repo as gated with automatic approval.)
  2. Log in locally so downloads carry your token:
uvx hf auth login
  1. Re-run the generate command.

Two tips from the README on clone quality:

  • Clean the sample first. The audio quality of the prompt is reproduced, so noise and room echo carry into the output. Kyutai suggests running it through a speech enhancer before use.
  • Only use voices you have consent for. The README’s prohibited-use section explicitly bans voice impersonation or cloning without explicit and lawful consent, and presenting generated audio as genuine recordings of real people.

Step 4: Export a voice once, load it instantly

Processing an audio prompt is relatively slow. export-voice converts it to a .safetensors file (it stores the model’s KV cache for that prompt), which loads almost instantly:

pocket-tts export-voice --language english_18m_2026-10 ./my_voice.wav ./my_voice.safetensors

pocket-tts generate \
  --language english_18m_2026-10 \
  --voice ./my_voice.safetensors \
  --text "Loaded from an exported voice."

Only the first 30 seconds of the audio file are processed, and export-voice also accepts http(s):// and hf:// sources. Export with the same --language you will generate with, since the file is that model’s cached state. Like cloning, export needs the gated weights from Step 3; without them it fails with the same ValueError on our box.

Step 5: Run a local TTS server

For anything interactive, keep the model in memory with serve:

pocket-tts serve --language english_7m_refl_2026-10 --port 8000

It binds to localhost:8000 by default (--host and --port change that). Open http://localhost:8000 for a web UI, or call the HTTP endpoint. /tts takes a multipart form with:

  • text (required),
  • voice_url: a built-in voice name like marius, or an http://, https:// or hf:// URL,
  • voice_wav: an uploaded audio file to clone.

voice_url and voice_wav are mutually exclusive. The response is streamed audio/wav.

# Built-in voice
curl -X POST http://localhost:8000/tts \
  -F "text=Hello from the local Pocket TTS server." \
  -F "voice_url=marius" \
  -o hello.wav

# Clone from an uploaded file (needs the gated weights)
curl -X POST http://localhost:8000/tts \
  -F "text=Same server, my voice." \
  -F "voice_wav=@./my_voice.wav" \
  -o mine.wav

The first curl returned HTTP 200 and a 128 KB WAV on our box with the 7M model. To change the voice used when a request names none, start the server with --default-voice, which accepts a built-in name, a WAV, an exported .safetensors, or a URL:

pocket-tts serve --language english_18m_refl_2026-10 --default-voice ./my_voice.safetensors

The default voice is loaded at startup, so a bad path fails immediately instead of on the first request. Because the stream starts before the whole sentence is synthesized, this endpoint is a good fit for a voice agent. If you are wiring speech into an agent loop, our guide to building a non-blocking voice agent with Google ADK covers the turn-taking side.

Step 6: Squeeze more speed with int8 quantization

pocket-tts generate --language english_18m_2026-10 --quantize --text "Quantized run."
pocket-tts serve --language english_18m_2026-10 --quantize

Kyutai’s quantization doc reports, for the original ~100M model, runtime memory dropping from 450 MB to 234 MB and a 1.27x speedup on an x86 GitHub Actions runner, with no measurable WER change. Kyutai has not published separate quantization numbers for the new small models, so measure on your own hardware.

One gotcha we saw: on our box the log said Using quantization backend: torch.ao, the deprecated fallback, even with torch 2.14, because the optional torchao package was not installed. The doc says torchao is the faster backend and that the old fallback is about 16% slower than baseline on ARM. Install it with:

pip install 'pocket-tts[quantize]'

Quantization is CPU-only; calling it on a model moved to CUDA raises NotImplementedError.

Step 7: Use it from Python

TTSModel.load_model() takes the same language names as the CLI:

from pocket_tts import TTSModel
import scipy.io.wavfile

tts_model = TTSModel.load_model(language="english_18m_refl_2026-10")
voice_state = tts_model.get_state_for_audio_prompt("alba")  # or "./my_voice.wav" / "./my_voice.safetensors"
audio = tts_model.generate_audio(voice_state, "Testing the 18M flagship from Python.")
scipy.io.wavfile.write("py18.wav", tts_model.sample_rate, audio.numpy())

On our box this produced 74,880 samples at 24 kHz (about 3.1 seconds of audio) in about 0.37 seconds of generation time. load_model(...) also accepts quantize=True, temp, sampler_decode_steps and eos_threshold.

Load the model and voice states once and keep them in memory: the README notes that load_model() and get_state_for_audio_prompt() are the slow calls. To save a voice from Python, use export_model_state(model_state, "./some_voice.safetensors").

Step 8: Skip Python entirely with the standalone binary

Each release now ships a pocket-tts binary for Linux and macOS (x86 and ARM) and Windows (x86) that needs neither Python nor PyTorch. It is a Rust port built on xn-ptts, uses the same commands and options as the Python CLI, and shares the Hugging Face cache with it.

# Download the archive for your platform from the release page, then:
tar xzf pocket-tts-*-x86_64-unknown-linux-gnu.tar.gz
./pocket-tts-*/pocket-tts generate --language english_7m_2026-10 --voice marius --text "Hello from the Rust binary."

Grab it from the v4.0.0 release page, which also includes a SHA256SUMS file to verify the download. Two things we noticed when we tried it on October 21, 2026:

  • The archives attached to the v4.0.0 release are named pocket-tts-3.3.0-... and the binary prints pocket-tts 3.3.0 for --version. Despite that, it ran --language english_7m_2026-10 without complaint, so the small-model support is in there.
  • It was fast: Generated: 1840 ms of audio in 85 ms so 21.65x faster than real-time on our box for a short sentence with the 7M model.

Limits from the README: the binary runs on CPU only, cannot load training checkpoints (--checkpoint), and its audio is not bit-identical to the Python package because the sampling noise differs.

Troubleshooting

“We could not download the weights for the model with voice cloning.” Accept the terms on kyutai/pocket-tts and run uvx hf auth login (Step 3). Built-in voices keep working without this.

The install pulled gigabytes of nvidia-* packages. You installed from plain PyPI on Linux. Recreate the environment with --extra-index-url https://download.pytorch.org/whl/cpu.

ValueError: Cannot specify both config and language. The two options can’t be combined. Use --language for Kyutai’s released models and --config for community or custom weights.

My cloned voice sounds noisy or echoey. The prompt’s audio quality is reproduced. Clean the sample, keep it to clear speech, and remember only the first 30 seconds are used by export-voice.

Odd output around dashes or curly apostrophes. v4.0.0 includes a change that rewrites dashes and curly apostrophes the models never saw in training, so make sure you are on 4.0.0 (pip show pocket-tts).

I can’t add pauses with silence in the text. That is listed as an unsupported feature in the README. Split the text and concatenate audio instead.

Unauthenticated Hugging Face warning. The log warns about unauthenticated requests and suggests setting HF_TOKEN for higher rate limits. It did not stop any of our downloads; set HF_TOKEN or log in (Step 3) if you hit rate limits.

FAQ

Is the 18M model really as good as the 100M one? On Kyutai’s LibriSpeech voice-cloning eval, english_18m_refl_2026-10 has lower WER (0.82% vs 0.92%) and higher UTMOS (4.400 vs 4.364), with slightly lower speaker similarity (0.917 vs 0.923). These are automatic metrics, so listen to your own voices before switching production traffic.

Does it need a GPU? No. It is designed for CPU. GPU use is not officially supported; the README notes TTSModel is a regular nn.Module you can move yourself, and that the serve command always runs on CPU.

Can I use it commercially? The code is MIT. The weights on Hugging Face are tagged CC-BY-4.0, which allows commercial use with attribution. Check each built-in voice’s license on kyutai/tts-voices and follow the README’s prohibited-use rules.

What about other languages? The small models are English-only. Other languages use the existing models, and the README lists community-trained models (for example Czech, Hindi, Japanese, Chinese and Korean) that you load with --config hf://....

Can it run in the browser or on a phone? Kyutai doesn’t officially support it yet, but the README links community ports, including WebAssembly builds, ONNX exports, sherpa-onnx bindings and a LiteRT build for Android GPUs.

What if I need speech recognition, not synthesis? Pocket TTS only generates speech. On Apple devices, see How to Use Apple SpeechAnalyzer for the transcription side.

Sources