3 Local TTS Models: Piper vs Kokoro vs XTTS v2

Short answer

On 15 hand-curated English sentences (5 short, 5 medium, 5 long with URLs, numbers, and edge cases), the published wisdom that "bigger is better" did not survive the speed test, and did not survive the intelligibility test either. The smallest model in the test produced audio 19x faster than real-time and tied for the lowest mean word error rate. The largest model, the one with voice cloning and 460 million parameters, was slower than real-time on every sentence and had the highest mean WER on long inputs. [Measured]

Piper Medium (20 M params, MIT, 60 MB on disk): 0.43 s median per sentence, 0.052 real-time factor, 3.5% mean WER.
Kokoro 82M (Apache 2.0, 310 MB model + 28 MB voices): 4.33 s median, 0.456 RTF, 3.1% mean WER.
XTTS v2 (460 M params, CPML non-commercial, 2 GB model): 19.86 s median, 2.730 RTF, 6.6% mean WER.

XTTS v2 is the only engine that is slower than real-time on a 24 GB Mac. It is also the engine with the worst intelligibility on long sentences. The 19x-faster Piper is not the "fast and dirty" tradeoff the model size would suggest — its WER is within 0.4 percentage points of Kokoro's on the same sentences.

Why I tested this

I write articles on local LLMs, RAG, and Apple Silicon inference. I do not write TTS articles because the 2026 local TTS space is dominated by three engines with very different stories: Piper, the tiny ONNX engine that runs on a Raspberry Pi; Kokoro, the 82 M Apache-2.0 model that went viral in early 2025; and XTTS v2, the 460 M voice-cloning model from Coqui. The benchmarks I have read online are mostly on RTX 4090 or M5 Max, and they are mostly qualitative — "Piper is fast, Kokoro sounds better, XTTS clones voices". I had a 24 GB Mac and a slow weekend, so I ran the same 15 sentences through all three and asked Whisper to transcribe the output. The numbers are the numbers.

The setup

Three local TTS engines, all run on the same M2 24 GB Mac, on the same 15 sentences, with the same voice when the engine supports it (Piper: lessac-medium, Kokoro: af_bella, XTTS v2: cloned from a Kokoro output of one of the test sentences).

Engine	Params	Disk size	License	Voice used
Piper Medium	20 M	60 MB	MIT (commercial OK)	`en_US-lessac-medium`
Kokoro 82M v1.0 int8	82 M	338 MB	Apache 2.0 (commercial OK)	`af_bella` (American English, female)
XTTS v2	460 M	~2.0 GB	CPML (non-commercial)	cloned from 17 s Kokoro output

The 15 sentences are hand-written, not copied from any benchmark:

5 short (5-10 words): "The quick brown fox jumps over the lazy dog.", "Press the red button to stop the machine.", and three more.
5 medium (15-25 words): "Local text to speech systems have improved dramatically in the last two years, with several small open-weight models now matching cloud quality.", and four more.
5 long (34-52 words, with numbers, URLs, and edge cases): "If you visit https://hardnumbers.dev/articles/3-local-vision-models-moondream-vs-gemma-3-vs-qwen2-5-vl, you will find a comparison of three local vision models tested on the same fifteen photos, with the same prompt, and scored against a single reference caption for each image.", and four more.

The full sentence set, the per-sentence WAV files, and the per-sentence transcriptions are in the experiments repo linked at the bottom.

The headline numbers

Engine	Median wall (s)	Median RTF	Mean WER	Median RSS (MB)
Piper (20M)	0.43	0.052	3.5%	1,086
Kokoro (82M)	4.33	0.456	3.1%	1,109
XTTS v2 (460M)	19.86	2.730	6.6%	(peak during 50 s inference)

RTF (real-time factor) is generation time divided by audio duration. Below 1.0 means the engine produces audio faster than it plays. Piper is 19x faster than real-time. Kokoro is 2.2x faster than real-time. XTTS v2 takes 2.7 seconds to produce 1 second of audio on a 24 GB Mac.

Mean WER is computed by transcribing every generated WAV with Whisper small.en and computing word error rate against the reference sentence. Kokoro wins mean WER by 0.4 percentage points. XTTS v2 is nearly 2x worse on mean WER than the other two.

Why Piper wins on speed

Piper is 9x faster than Kokoro and 30-60x faster than XTTS v2 on the same sentence. The reason is the architecture:

Piper is a VITS-based ONNX model with 20 M parameters. Every layer is small enough to fit in L2 cache on Apple Silicon, the decoder is fully parallel, and the model is shipped as a pre-compiled ONNX graph that the ONNX Runtime executes without Python overhead. A 9-word sentence runs in 110 ms; a 52-word sentence runs in 990 ms. The throughput scales linearly with sentence length because the per-character decode cost is roughly constant.
Kokoro is a 4x larger model (82 M) with a more sophisticated prosody pipeline. The first inference call includes a 2-3 s ONNX session warmup that does not show up in subsequent calls. Per-sentence wall time is roughly 0.5 + 0.18 * (character count) seconds. The fixed overhead is the limiter for short sentences; the per-character cost is the limiter for long ones.
XTTS v2 is a 23x larger model (460 M) with a transformer-based decoder and a 250-character limit per chunk. The Coqui TTS Python wrapper has substantial per-call overhead (model state setup, speaker embedding extraction, vocoder warmup), and the autoregressive decoder produces 80 tokens per second at best on M2. A 46-word sentence takes 49 seconds. Long sentences that exceed 250 characters trigger a chunking warning and are processed in two passes, which doubles the wall time for sentences in the 30-50 word range.

The 20x gap between Piper and XTTS v2 is not a software-inefficiency problem. It is the cost of voice cloning, which requires a transformer over the speaker embedding on every forward pass. Piper and Kokoro skip that pass because they ship fixed voices.

Why XTTS v2 has the worst mean WER

XTTS v2's mean WER (6.6%) is roughly 2x the mean WER of Piper (3.5%) and Kokoro (3.1%). The breakdown matters:

Short sentences (5-10 words): all three engines score 0% WER. Short utterances are easy; there is nowhere for a phoneme to go wrong.
Medium sentences (15-25 words): Piper 0% WER on all 5, Kokoro 0% WER on all 5, XTTS v2 4.2% WER on one sentence (med_04) and 0% on the other four. The XTTS failure is on a sentence with the phrase "in randomized order to control for thermal throttling" — the word "throttling" was transcribed as "falling" or dropped entirely.
Long sentences (34-52 words): Piper 4-25% WER, Kokoro 0-29% WER, XTTS v2 7-31% WER. The worst-case for all three is the same sentence, long_02, which contains the URL https://hardnumbers.dev/articles/3-local-vision-models-moondream-vs-gemma-3-vs-qwen2-5-vl. URL pronunciation is uniformly hard. XTTS v2 is the worst on this sentence because its 250-character chunking splits mid-URL and re-derives the speaker embedding at the boundary, which appears to drop the "hardnumbers" segment entirely (Whisper transcribes it as "ITTPS, hard numbers, ID Eve articles").

The voice cloning is also the failure mode. XTTS v2 takes a 6-second reference clip and conditions every output on a derived speaker embedding. The reference I provided was a 17-second Kokoro output, but XTTS v2 only takes the first 6 seconds, which is a single sentence from a different sentence (the Kokoro "af_bella" voice on the long_01 sentence). The resulting voice is identifiable as female and American but noticeably different from af_bella itself, and the speaker conditioning adds noise to the decoder that the fixed-voice models do not have.

I would expect a hand-picked 6-second reference clip (not auto-clipped from a longer output) to improve XTTS v2's intelligibility, possibly to the point of tying with Kokoro. I did not test that. The point of the benchmark is what you get with the default reference setup; voice cloning users who care about quality will spend more time on the reference clip.

Why all three fail on URLs and numbers

Looking at the per-sentence transcriptions, the failure modes cluster:

URLs: https://hardnumbers.dev/articles/... becomes "ITTPS, hard numbers, ID Eve articles" across all three engines. The character-by-character pronunciation of a URL is not what any of these models are trained for; they are trained on natural text. The fix is either to spell out URLs in the prompt (which costs user time) or to use a TTS engine specifically trained on technical content.
Dates and times: "2026-09-04" becomes "2026-944" in XTTS v2, "2026-09-04" stays correct in Piper and Kokoro. "14:30 UTC" is fine in all three. The XTTS v2 failure is a tokenizer issue specific to the Coqui text normalizer.
Numbers: "14 billion" and "9.3 gigabytes" come out correct in all three. "1.8x" comes out correct in Piper and Kokoro but is dropped in XTTS v2. The simple-digit cases work everywhere; the abbreviations and unit-suffixed cases are where the failure mode lives.

If you are using any of these engines for narration that includes URLs, dates, or technical specs, the right pipeline is to expand the abbreviations in the input before sending it to TTS. The model will not save you.

How to reproduce this

# 1. Set up the 3.13 venv for Piper + Kokoro + Whisper
python3 -m venv /tmp/tts-m2-venv
/tmp/tts-m2-venv/bin/pip install piper-tts kokoro-onnx soundfile openai-whisper
brew install ffmpeg

# 2. Set up the 3.11 venv for XTTS v2 (Coqui TTS caps at Python 3.12)
uv venv --python 3.11 /tmp/tts-xtts-venv
/tmp/tts-xtts-venv/bin/python3 -m pip install "TTS==0.22.0" "transformers<4.40" "torch<2.5"

# 3. Build the test sentence set
git clone https://github.com/Pitambarmahato/hardnumbers-experiments
cd hardnumbers-experiments/tts-m2

# 4. Run Piper + Kokoro
/tmp/tts-m2-venv/bin/python3 src/benchmark_piper_kokoro.py

# 5. Run XTTS v2 (in a separate terminal, because of the venv split)
COQUI_TOS_AGREED=1 /tmp/tts-xtts-venv/bin/python3 src/benchmark_xtts.py

# 6. Score with Whisper transcription WER
/tmp/tts-m2-venv/bin/python3 src/score.py

The full per-sentence timings, the WAV outputs, the transcriptions, and the per-engine WER scores are all in results/ in the experiments repo.

What I did not test

Multilingual. All 15 sentences are English. XTTS v2 is the only engine in the test that is explicitly multilingual (17 languages per the model card); Kokoro ships English-first with Chinese and Japanese voices; Piper is per-language. On non-English content, the ranking might change.
Voice cloning quality. I used an auto-clipped 6-second reference from a Kokoro output. A hand-picked reference would likely improve XTTS v2's WER. I did not test how much.
Long-form synthesis (multi-paragraph). The longest test sentence is 52 words. A 500-word chapter would expose memory and streaming behavior I did not measure. Piper is the only engine in the test that supports streaming output; Kokoro and XTTS v2 produce a single buffer per call.
Other engines. I did not test F5-TTS, StyleTTS 2, MeloTTS, or Parler-TTS Mini. F5-TTS is the other interesting voice-cloning model in 2026 and would be the natural next addition to this comparison.
GPU vs CPU. All three engines ran on CPU (Apple Metal). On an RTX 4090, XTTS v2 would likely become the fastest engine on the list and might overtake Piper; I did not test.
Prosody and naturalness. WER measures intelligibility, not how human the voice sounds. A blind A/B preference test would be the right methodology for that. I did not run one.

What this means for you

If you want the fastest local TTS engine on a 24 GB Mac and you do not need voice cloning, use Piper. It is 19x faster than real-time, 9x faster than Kokoro, and within 0.4 percentage points of Kokoro on mean WER. The voice is more robotic than Kokoro but intelligible on every sentence I tested. The MIT license makes it safe for commercial use.

If you want the best quality per second and you are willing to give up voice cloning, use Kokoro. It is 2.2x faster than real-time, the lowest mean WER of the three engines, and Apache 2.0 licensed for commercial use. The fixed-voice catalog (54 voices) is enough for most use cases without voice cloning.

If you specifically need voice cloning and you have a high-quality 6-second reference clip, use XTTS v2. It is 2.7x slower than real-time on a 24 GB Mac, which rules it out for any interactive use, but it is the only engine in the test that can produce a custom voice from a reference. Use a hand-picked reference, not an auto-clipped one, and expect to spend time on the reference-quality trade.

If you are picking a TTS engine for a new project, do not generalize from this benchmark. Run your own sentences, your own voice, and your own evaluation. The published comparisons are mostly on RTX 4090 or M5 Max; the M2 24 GB numbers are different.

This article, the benchmark code, the 15-sentence test set, the per-sentence WAV files, the Whisper transcriptions, and the WER scores are all in the experiments repo. If you re-run on a different corpus or with a different reference clip, please open a PR with the results — the goal of Hard Numbers is to make every claim falsifiable.

Code: github.com/Pitambarmahato/hardnumbers-experiments/tree/main/tts-m2
Results JSON: same repo, tts-m2/results/
This article: hardnumbers.dev/articles/3-local-tts-models-piper-vs-kokoro-vs-xtts-v2

FAQ

Which local TTS model should I use on a 24GB Mac?

Piper if you want speed and do not need voice cloning; Kokoro if you want the best intelligibility at 2.2x real-time and do not need voice cloning; XTTS v2 if you need voice cloning and have a high-quality 6-second reference clip. Avoid XTTS v2 on M2 for any interactive use — at 2.7x slower than real-time, every UI that calls it will feel laggy. [Measured, Inferred]

Is XTTS v2 the best open-weight TTS model in 2026?

On voice cloning quality, yes — XTTS v2 is the only engine in this test that can clone a voice from a 6-second reference, and on a GPU the speed gap to Piper closes. On a 24 GB Mac without a discrete GPU, XTTS v2 is slower than real-time and has the highest mean WER on long sentences. The "best" depends on your hardware and on whether voice cloning is the requirement. [Measured, Documented]

How do you measure TTS quality?

Word error rate (WER) is the most common objective measure. Take the WAV output of the TTS engine, transcribe it with an automatic speech recognition model (Whisper small.en is the standard reference), and compare the transcription word-by-word against the original text. WER measures intelligibility (did the TTS say the right thing), not naturalness (did it sound human). A blind A/B preference test is the right methodology for naturalness. The published "this engine sounds better" claims are almost always preference-test results, not WER results. [Documented]

Why is Kokoro so much faster than XTTS v2 on a Mac?

Kokoro is 5.6x smaller than XTTS v2 (82M vs 460M params) and uses a fully feed-forward architecture that ONNX Runtime can execute as a single optimized graph. XTTS v2 uses a transformer decoder with a speaker-conditioning path that has to run for every output. On a GPU the difference is smaller because the GPU can parallelize the transformer; on a CPU (which is what Apple Silicon uses for ONNX inference unless you specifically build with Metal), the size and architecture cost dominates. [Measured, Inferred]

Can I use these TTS models commercially?

Piper is MIT licensed and commercial-safe. Kokoro is Apache 2.0 and commercial-safe. XTTS v2 is CPML (Coqui Public Model License), which is non-commercial. If you need voice cloning and commercial use, look at XTTS v2's fork Coqui Studio (commercial license) or a different model like F5-TTS (CC-BY-NC, also non-commercial) or Piper with a custom voice trained on your data. [Documented]

What about voice cloning quality on the other engines?

Piper does not support voice cloning — it ships fixed voices per language. Kokoro does not support voice cloning either — it has 54 fixed voices. XTTS v2 is the only one in the test with a voice cloning path. If voice cloning is a hard requirement, the realistic open-weights options in 2026 are XTTS v2 (non-commercial), F5-TTS (non-commercial), and OpenVoice (commercial-restricted). For commercial voice cloning on local hardware, fine-tuning a Piper voice on your data is the cleanest path. [Documented]