Pocket TTS: I cloned my voice on a 2019 CPU, no GPU and no cloud

I have had the same problem for a while: I need synthetic speech in Spanish, of decent quality, and I do not want to pay per generated second or send anyone’s voice to somebody else’s server. I tried Pocket TTS, from Kyutai, and the summary is short: 209 MB, runs on CPU, clones a voice from 25 seconds of reference, and can be used in a commercial product with attribution to Kyutai.

I installed it on an old server with a 2019 Intel i5-9400F, six cores and no GPU. It worked. These are the real metrics I measured, the step-by-step install, and my unvarnished take.

What it is and what makes it different

Almost every good voice model assumes a GPU. Pocket TTS assumes the opposite: it is a small model, around 100 million parameters, meant to run anywhere. What is striking is what it keeps while being that small: zero-shot voice cloning, meaning you hand it a reference audio and it synthesizes with that timbre without any prior training.

It ships built-in voices per language (lola for Spanish, alba by default), weak ones at that, plus multilingual support. And the license helps: the weights are CC-BY-4.0 and the code Apache-2.0. You can use it in a commercial product without asking permission, on condition of attributing Kyutai.

Installation

The best part: there is no real installation. With uv on the machine, it runs directly.

# 1. uv, if you do not have it
curl -LsSf https://astral.sh/uv/install.sh | sh

# 2. generate audio (downloads the model the first time)
uvx pocket-tts generate \
  --text "Hello, this is a speech synthesis test." \
  --language spanish \
  --output-path output.wav

That is all. The first run downloads ~209 MB into the Hugging Face cache and later ones are instant in that respect.

To clone a voice, you point it at a reference audio file:

uvx pocket-tts generate \
  --text "Now I speak with the reference voice." \
  --language spanish \
  --voice my_voice.wav \
  --output-path cloned.wav

And if you are going to reuse the same voice many times, it is worth precomputing it once:

uvx pocket-tts export-voice my_voice.wav --output my_voice.safetensors

It also ships a server:

uvx pocket-tts serve   # local FastAPI API

Two stumbles you will hit

1. Intel Mac. On an Intel Mac it fails to install: PyTorch no longer publishes wheels for macosx_x86_64 in the versions the package requires. I ran it on Linux x86_64 and that was that. On Apple Silicon there is no problem.
2. Gated model. The voice-cloning weights sit behind a terms acceptance on Hugging Face. If you do not accept, the download fails with an unhelpful error (could not download weights for voice cloning). You accept once on the model’s page and carry on.

The metrics, measured by me

All of this on the i5-9400F, six cores, no GPU, with a phrase of about 15 words and a 25-second voice reference:

1. Built-in Spanish voice1.34×8.5 seconds of compute for 6.4 of audio.
2. Clone + int8 quantization1.45×9.7 seconds of compute for 6.7 of audio. Quantizing did not speed it up.
3. Clone of my voice1.55×9.5 seconds of compute for 6.1 of audio. Cloning costs 16% over the stock voice.

Measured on a 2019 i5, no GPU. Below 1.0 the model would generate faster than the audio plays.

How to read it: a factor of 1.34× means it takes 34% longer than the duration of the audio it produces. A minute of speech comes out in a little over a minute of compute.

And here is the interesting part. I repeated the test with a long paragraph (the one in the audio above) and the result changes completely:

With long text it generates faster than real time: 54 seconds of audio in under 24 of compute. What weighed on the short phrase was startup (loading the model and preparing the voice), which amortizes as soon as the text grows.

Two honest observations:

• Fixed cost dominates on short phrases. If your case is brief, one-off responses, startup kills you. If it is narration, the model has plenty of headroom on a six-year-old CPU.
• int8 quantization sped up nothing. It came out practically the same (a hair worse in absolute compute, even). That makes sense: in a model this small the bottleneck is not where quantization helps. It is for memory, not speed.

The same text, two engines, with real gates

Comparing TTS “by ear” is useless. I used an agnostic text: 134 words of popular science about the octopus, with numbers written out, a question, and hard words like haemocyanin. I applied the same gates I use in production: transcribe what was generated with Whisper and measure the WER (how far it drifts from what I asked for), plus the audio metrics.

The polished version

The audio above comes raw out of the model, and that is how it has to be judged. But nobody publishes the raw take. This is the same file run through the master I use in production: high-pass filter, presence lift at 2.8 kHz, gentle compression and normalization to −16 LUFS with true peak at −1.5 dBTP.

It improves a lot. Mastering does not fix the words it swallowed, which are the model’s doing, but it does fix the low volume and the lack of body, which was half of the initial bad impression.

The results

How to read this

WER is the hard verdict. 13.4% against 3.7% means Pocket swallows or deforms roughly one word in seven, while Qwen misses one in twenty-seven. Whisper transcribed 129 words from Pocket’s audio against the original 134: it skipped five. For publishable narration, that margin does not pass; for a prototype or an internal tool, it does.

Speed goes the opposite way to expectations. Pocket on a 2019 CPU was nearly twice as fast as Qwen with a dedicated GPU: 0.48× against 0.91×. A model 21 times smaller more than makes up for the missing accelerator.

Pocket’s audio comes out rawer. −23.5 LUFS is low, it needs mastering before publishing, and its 28.8% silence reveals long, erratic pauses, while Qwen holds a 16% much closer to natural speech. On the other hand Pocket’s true peak (−3.3 dBTP) leaves headroom to process, and Qwen’s (−0.4 dBTP) sits dangerously at the edge of clipping.

The spectral centroid is nearly identical (1493 vs 1522 Hz): both reproduce the same timbre from the reference voice. Cloning works in both; what differs is the execution.

I also tried the Spanish voice the model already ships (lola, no reference). It sounds flat with odd diction: faster, because it skips processing the sample, but I would not publish it. If you are going to use Pocket TTS, clone a voice.

My conclusion from the test

Qwen3-TTS wins where it matters for publishing: fidelity to the script and natural rhythm. Pocket TTS wins on speed, size and where it can run. It is not a technical tie: it is choosing between the best you can have with a GPU and what you get without one.

My take

What I liked:

• It runs anywhere. 209 MB and a CPU. You can put it in a 1 GB container and deploy it on the cheapest VPS you have. No GPU queue, no quota, no per-second bill.
• Privacy does not depend on trusting anyone. The reference voice never leaves your machine. When you work with a specific person’s voice, that stops being a detail.
• Commercial use allowed, with attribution. The weights are CC-BY-4.0 and the code Apache-2.0: the only asterisk is citing the source.
• Zero-shot that works. 25 seconds of clean reference and the timbre is recognizable. Nothing to train.

What I did not:

• The quality is not production grade for a brand voice. It is clear and intelligible, but it lacks the fine prosody and emotion control of a commercial service. If your content lives on the voice moving people, it shows.
• No explicit emotional control. There are no emotion tags or style instructions. You get temperature and little else.
• Spanish is not its strongest language. It works, but naturalness drops next to English.

My conclusion: Pocket TTS does not compete on quality. It competes on where it can run, which is a different category.

Compared with what I already use

• ElevenLabs: the best quality and emotional control on the market, by a distance. But it is cloud, you pay per credit and your reference audio travels. I still use it for voices that go public.
• Qwen3-TTS: much better naturalness in Spanish and with emotion per beat, but it needs a GPU and considerably more disk. It is my workhorse when a GPU is available.
• RVC: it does not do TTS, it does voice conversion. It needs 10–15 minutes of real audio and prior training. A different tool for a different problem, and it usually goes after a TTS, not in its place.
• Suno: not competition either, it generates music with sung vocals. Excellent for songs, useless for narrating your own text in a specific voice.

Pocket TTS replaces none of them. It fills a gap none of them covered: I need speech right here, on this modest machine, without paying and without uploading anything.

When would I use it?

• Prototypes and script tests, where burning credits makes no sense.
• Internal tools and automations that talk.
• Any case with sensitive data where uploading the voice to a third party is not an option.
• High volume without urgency: leaving it generating in batches on a machine you already have.

I would not use it for a channel’s main voice, or anywhere the emotional performance carries the content. For that I keep paying.

Sources

• kyutai/pocket-tts on Hugging Face. The model card, where the weights’ CC-BY-4.0 license and the real file size per language come from.
• delayed-streams-modeling, Kyutai Labs. The inference code, under Apache-2.0, and the delayed-streaming method it rests on.