Open-Weight Text to Speech Models in 2026: The XTTS Successors

XTTS-v2 was the default answer to "which open TTS should I use" for about two years, and it stopped being the right answer somewhere in 2025. The company behind it is gone, its weights were never commercially licensable, and a dozen models have since passed it on quality, latency, or both. This is a field survey as of July 2026: what the current open-weight text to speech models actually do, what hardware they need, and which ones you can legally ship.

Why XTTS stopped being the default

XTTS offered 17 languages and few-second zero-shot cloning at a point when almost nothing else open did both. The catch was always the license: the code in the Coqui TTS library is MPL-2.0, but the XTTS-v2 checkpoint ships under the Coqui Public Model License, which is a non-commercial license. That was survivable while Coqui the company existed and sold commercial terms. It no longer is. The upstream repository is unmaintained, and the license URL the model card points at, coqui.ai/cpml, now returns a 404. The practical reading in 2026 is that XTTS-v2 weights are non-commercial with no path to clearance, because there is nobody left to clear them with.

The code kept moving anyway. The community fork at idiap/coqui-ai-TTS describes itself as a fork of the original unmaintained repository, is still MPL-2.0, and is what most people install if they still want XTTS. But the model itself has aged: it is autoregressive, and its cloning stability is behind what a 2026 model does with the same few seconds of reference audio.

Everything below is a candidate replacement, and the first thing to sort them by is not quality. It is whether they clone voices at all.

The split that actually matters: fixed voices versus zero-shot

Open TTS in 2026 divides cleanly into two product categories that get lumped together and should not be.

Fixed-voice models ship a bank of pretrained speakers and let you pick one. They are small, fast, deterministic, and boring in the good way. Nothing about them is a deepfake risk, so nothing about them needs consent tooling. Kokoro, Piper, and MeloTTS live here.

Zero-shot cloning models take a reference clip and produce speech in that voice. They are bigger, slower, non-deterministic, and every one of them is a liability surface. Zonos, Chatterbox, F5-TTS, MaskGCT, Llasa, and NeuTTS Air live here.

If your product is a screen reader, a Home Assistant announcement, a documentation narrator, or an IVR tree, you want the first category and you should stop reading comparison threads that only benchmark the second.

Kokoro is the model that changed the default

Kokoro-82M is 82 million parameters, Apache-2.0, and it is the single most consequential open TTS release of the last two years, mostly because of what it proved about scale. Its v1.0 release landed on 27 January 2025 with 54 voices across 8 languages, outputting 24 kHz audio. The architecture is a decoder-only descendant of StyleTTS 2 with an ISTFTNet vocoder: no diffusion, no encoder in the release. The model card is unusually candid about cost. It was trained exclusively on permissive and non-copyrighted audio, a few hundred hours of it, for about $1,000 across roughly 1,000 hours of A100 80GB time.

That combination is the point. A model you can retrain for four figures, on data you can defend, with genuinely Apache weights, and it still holds its own against models a hundred times its size in public listening comparisons. Treat those arena rankings as directional rather than precise: they move week to week and the confidence intervals overlap heavily mid-table.

It does not clone voices. That is a feature for most deployments.

The deployment story is where 82 million parameters stops being a stat and starts being an architecture decision. The community ONNX exports run 326 MB at fp32, 163 MB at fp16, about 92 MB for the straight 8-bit quantization, and 86 MB for the mixed q8f16 build. An 86 MB model runs in a browser tab, on a Raspberry Pi, or inside a mobile app without a server round trip. kokoro-onnx shipped 0.5.0 on 30 January 2026, and there is a v1.1-zh variant, also Apache-2.0 and still 82M, carrying 103 voices for Mandarin-heavy workloads.

pip install kokoro>=0.9.4 soundfile

from kokoro import KPipeline
import soundfile as sf

pipeline = KPipeline(lang_code='a')  # 'a' = American English
generator = pipeline("Ship the boring model.", voice='af_heart')

for i, (gs, ps, audio) in enumerate(generator):
    sf.write(f'{i}.wav', audio, 24000)

Piper is still the right answer for embedded, with a license asterisk

Piper is VITS trained per-voice and exported to ONNX, with espeak-ng embedded for phonemization. Every voice is two files, a .onnx and a .onnx.json config, in low, medium, and high quality tiers. It was built to hit real time on a Raspberry Pi 4 and it does. Home Assistant and the NVDA screen reader both ship it.

Two things changed and you need to know both. First, rhasspy/piper was archived read-only on 6 October 2025, with its README pointing at OHF-Voice/piper1-gpl under the Open Home Foundation as the successor. That line has shipped steadily since, through v1.4.2 in April 2026 and v1.6.0 in July 2026. Second, and more importantly, the license flipped: the archived repository is MIT, the successor is GPL-3.0, which is what the "gpl" in the new name is telling you. If you were linking Piper into a proprietary binary on the strength of the old MIT terms, that assumption does not carry to current releases. The voice checkpoints carry their own per-voice licenses and are mostly permissive, but the inference code is now copyleft.

pip install piper-tts

MeloTTS is the other honest fixed-voice option: MIT licensed, explicitly built to be fast enough for CPU real-time inference, and better than Piper on English prosody, though it covers only English, Spanish, French, Chinese, Japanese, and Korean.

The cloning tier, model by model

Zonos from Zyphra had the most interesting year. Zonos-v0.1 shipped in two variants, a plain transformer and a hybrid interleaving Mamba2 and transformer layers, trained on more than 200,000 hours of varied multilingual speech, with espeak phonemization feeding DAC token prediction. Apache-2.0, 44 kHz native output, five languages (English, Japanese, Chinese, French, German), cloning from a 10 to 30 second sample. Zyphra quotes a real-time factor of about 2x on an RTX 4090 and asks for a 3000-series or newer NVIDIA GPU with 6 GB or more of VRAM.

ZONOS2 landed on 12 June 2026 and is a different animal: a sparse mixture of experts with 900 million active parameters out of 8 billion total, Apache-2.0, 44.1 kHz output via DAC, trained on more than six million hours. Zyphra reports 4x the real-time throughput of the previous model, credited both to the MoE routing and to dropping the dependence on classifier-free guidance, which had been doubling the effective batch. It generates up to a minute of multilingual and code-switched audio in one pass and exposes two modes, "stable" for clean output and "expressive" for cloning naturalness and fidelity. Speaker conditioning moved to a new ECAPA-TDNN embedding that Zyphra says carries 20x the bandwidth of the old one. The model card lists 40 languages across three support tiers, while Zyphra's own eval set covers 9 languages on clean audio and 17 in the wild. It is the most capable fully-Apache cloning model available right now.

Chatterbox from Resemble AI is the pragmatic choice. MIT license, top to bottom, no weight-license asterisk. The multilingual V3 model is 500M parameters across 23 or more languages including Arabic, Hebrew, Hindi, Swahili, and Malay, which is unusually wide coverage for an open model. The documented examples clone from a roughly ten second reference clip, and Resemble bills it as the first open source TTS with an emotion exaggeration control, tuned via exaggeration alongside cfg_weight. There are now smaller variants: Chatterbox-Turbo at 350M, which collapses a ten step decoder into one step, and Chatterbox-Nano at 110M, which the repo clocks at 3x faster than real time on eight CPU cores.

Chatterbox also watermarks. Every generated file carries Resemble's Perth perceptual watermark, which the project says survives MP3 compression and common audio editing. Treat that as a feature if you are shipping to enterprise buyers who ask about provenance, and as something to disclose if you are not.

pip install chatterbox-tts

F5-TTS is flow matching over a diffusion transformer, and its design contribution is subtraction: no duration model, no separate text encoder, no phoneme alignment. It infills character sequences directly. The paper reports an inference real-time factor of 0.15 for a model trained on a public 100K hour multilingual dataset. The repository's own benchmark table is more granular: 0.1467 for the offline PyTorch path at 16 function evaluations on a single L20, dropping to 0.0394 in client-server mode at concurrency 2. The v1 base checkpoint landed on 12 March 2025 and the package is on the 1.1.x line as of July 2026. Code is MIT. The weights are not, and that is the whole problem, covered below.

MaskGCT is the non-autoregressive outlier. Two stages: text to semantic tokens, then semantic to acoustic tokens, both masked and generated in parallel rather than left to right, with no explicit alignment between text and speech supervision and no phone-level duration prediction. It was trained on the English and Chinese halves of Emilia, 50K hours each for 100K total. Because it is fully parallel it is fast per utterance, but it needs the whole text up front, which rules it out for streaming.

Llasa is the brute-force approach: take an instruction-tuned LLaMA (Llama-3.2-3B for the 3B model, Llama-3.1-8B for the 8B) and extend the vocabulary with speech tokens from XCodec2, whose single codebook holds 65,536 entries. HKUST Audio trained it on 250,000 hours of Chinese and English speech. The 3B model is the sweet spot and it is genuinely good at expressive Mandarin. Its license is the catch, and it is covered below.

NeuTTS Air is the interesting CPU-native entry: roughly 0.7B parameters total on a Qwen 0.5B backbone, paired with Neuphonic's single-codebook NeuCodec, Apache-2.0, published in GGUF at Q4 and Q8 so it runs through llama.cpp with no PyTorch in the loop. Neuphonic targets real-time generation on mid-range devices, explicitly phones, laptops, and Raspberry Pis, and asks for 3 to 15 seconds of clean mono reference audio for cloning.

Streaming latency is a different problem than throughput

Most of the models above are utterance-level: you hand them complete text, they hand you a complete waveform. Real-time factor tells you throughput, not responsiveness. For a voice agent the number that matters is time to first audio byte after the first token of text arrives, and that requires an architecture that can start speaking before it has heard the end of the sentence.

Kyutai TTS is the model built for exactly this. Its delayed streams modeling framework interleaves the text and audio streams with a fixed offset, 1.28 seconds between them, so generation proceeds incrementally as text arrives. The en/fr checkpoint is 1.8B parameters, a 1B backbone plus a 600M depth transformer, and its model card quotes a throughput of 75x generated audio per unit of compute time after classifier-free-guidance distillation removed the need to double the batch. The production claim in the repository is concrete: a single L40S GPU serving 64 simultaneous connections at a real-time factor of 3x.

The engineering around it is unusually serious for a research release. Three backends ship: PyTorch (MIT) for experimentation, a Rust moshi-server (Apache-2.0) for production, and MLX for Apple Silicon. The weights are CC-BY-4.0.

# PyTorch, streams to your speakers as it generates
echo "Hey, how are you?" | python scripts/tts_pytorch.py - -

# Production Rust worker
moshi-server worker --config configs/config-tts.toml

# Apple Silicon, 8-bit quantized
echo "Hey, how are you?" | python scripts/tts_mlx.py - - --quantize 8

Kyutai made one deliberate design choice that will decide whether you can use it: rather than watermarking output, they restricted voice conditioning to pre-computed embeddings from their own tts-voices repository. You cannot point it at an arbitrary reference clip. If your use case is a fixed set of product voices, that restriction costs you nothing. If your use case is user-supplied voices, Kyutai is off the table entirely.

Orpheus is the other streaming-first option: a speech LLM from Canopy Labs built on a Llama-3.2-3B backbone, Apache-2.0, with the base model trained over 100k hours of English. It reports roughly 200 ms streaming latency, dropping to about 100 ms with input streaming, and smaller checkpoints at 1B, 400M, and 150M are on the roadmap for constrained devices.

For everything else, streaming is a wrapper problem rather than a model property. sherpa-onnx is Apache-2.0 and runs VITS, Matcha, Piper, and Kokoro voices through ONNX Runtime on desktop, mobile, and WebAssembly. Chunk the text yourself and playback starts before synthesis finishes, at the cost of losing cross-chunk prosody.

CPU versus GPU, honestly

The CPU tier is real now and it was not two years ago. Kokoro quantized through ONNX Runtime is under 100 MB and runs comfortably ahead of real time on ordinary laptop cores. MeloTTS advertises CPU real-time inference. Piper was designed for a Raspberry Pi 4. NeuTTS Air brings zero-shot cloning to the CPU tier via GGUF, and Chatterbox-Nano at 110M hits 3x real time on eight cores. If your requirement is "narrate this document offline," you do not need a GPU in 2026.

The GPU tier is where cloning fidelity lives. Zonos-v0.1 wants 6 GB minimum on a 3000-series or newer card. Llasa at 3B needs real VRAM and at 8B needs serious VRAM. ZONOS2 at 8B total parameters is not a laptop model even with only 900M active, because MoE saves compute and not memory. F5-TTS at DiT scale is benchmarked by its own authors on a datacenter card, and that is roughly the floor for a good experience.

The uncomfortable middle is batch serving. One L40S carrying 64 streaming connections is a genuinely different cost structure from a 2x-real-time cloning model serving one user per GPU. Pick the architecture that matches your concurrency, not the one that wins the listening test.

Language coverage is still lopsided

English and Mandarin have everything. Everything else is a negotiation.

Kokoro covers 8 languages with 54 voices, plus a Chinese-focused v1.1-zh with 103. Chatterbox Multilingual V3 covers 23 or more, the widest single-model coverage among permissively licensed options. Kyutai TTS is English and French only. Llasa is Chinese and English. MaskGCT trained on Emilia's 50K English and 50K Chinese hours. Zonos-v0.1 shipped five languages, and ZONOS2 claims 40 across three support tiers, a much bigger jump than a version number usually implies.

Piper is the outlier and the reason it survives: it has by far the widest raw language list, because each voice is an independently trained small VITS model rather than a shared multilingual checkpoint. The tradeoff is no cross-lingual transfer, no code-switching, and wildly variable quality between community-contributed voices. For a low-resource language, a mediocre Piper voice that exists beats an excellent Chatterbox voice that does not.

Under most of this sits espeak-ng, which supplies phonemization for Piper, Zonos, and Kokoro's fallback path. Its coverage is the real floor on what languages the ecosystem can address at all.

The licensing split nobody warns you about

Here is the trap that catches more teams than any technical limitation: in open TTS, the code license and the weights license are usually different, and the README quotes the code license.

Model	Size	Zero-shot clone	Code license	Weights license	CPU viable
Kokoro-82M	82M	No	Apache-2.0	Apache-2.0	Yes, 86 to 92 MB quantized
Piper	per-voice VITS	No	GPL-3.0, was MIT	per-voice, mostly permissive	Yes, Pi 4 target
MeloTTS	small VITS	No	MIT	MIT	Yes, CPU real time
Chatterbox ML V3	500M	Yes, ~10s clip	MIT	MIT	Nano variant only
ZONOS2	900M active / 8B total	Yes	Apache-2.0	Apache-2.0	No
Zonos-v0.1	transformer or hybrid	Yes, 10 to 30s	Apache-2.0	Apache-2.0	No, 6 GB VRAM
Kyutai TTS en/fr	1.8B	Preset embeddings only	MIT and Apache-2.0	CC-BY-4.0	No
Orpheus	3B	Yes	Apache-2.0	Apache-2.0	No
NeuTTS Air	~0.7B	Yes, 3 to 15s	Apache-2.0	Apache-2.0	Yes, GGUF Q4
F5-TTS	DiT, flow matching	Yes	MIT	CC-BY-NC-4.0	No
MaskGCT	two-stage NAR	Yes	Amphion, permissive	CC-BY-NC-4.0	No
Llasa	1B / 3B / 8B	Yes	open repo	CC-BY-NC-4.0	No
OpenAudio S1-mini	0.5B	Yes	Apache-2.0	CC-BY-NC-SA-4.0	No
Higgs Audio v2	3B class	Yes	Apache-2.0	tagged "other", read the file	No
XTTS-v2	not published	Yes	MPL-2.0	CPML, orphaned	No

The single upstream cause of most of the NC entries is the Emilia dataset. Emilia is 101.7k hours of in-the-wild speech released under CC-BY-NC-4.0, and it is the training corpus for F5-TTS, MaskGCT, and a long tail of others. The NonCommercial term propagates to the checkpoints. F5-TTS gets described as commercial-friendly constantly because its code is MIT; the maintainers are explicit that the published weights are CC-BY-NC because of Emilia.

Llasa reaches the same place by a different road. The 3B and 8B model cards both carry cc-by-nc-4.0, and the stated reason is ethics and privacy rather than data provenance. Attribution is fine, derivatives and fine-tunes are fine, commercial deployment is not. Read the license tag on the specific checkpoint rather than trusting a summary, including this one.

OpenAudio S1-mini is the same pattern with a longer tail: a 0.5B distillation of the 4B S1 model, with weights under CC-BY-NC-SA-4.0, so even non-commercial derivatives have to carry the same terms forward.

Higgs Audio v2 from Boson AI is the case that proves the rule about reading past the repository badge. The repo is Apache-2.0. The v2 generation checkpoint is tagged other on Hugging Face with a separate LICENSE file, and the v3 line ships under a named Boson research and non-commercial license. Apache code, non-Apache weights, again.

There is a way out and it is starting to work. Emilia-YODAS adds 113.9k hours under plain CC-BY-4.0, and Emilia-Large combines both for 215.6k, so a model trained only on the YODAS half can ship permissive weights. Kokoro took the other route, training on a few hundred hours of clean permissive audio and accepting the ceiling that implies. ZONOS2 and Orpheus are both Apache-2.0 on code and weights. The commercially clear tier is genuinely populated now, which was not true in 2024.

One more footnote: StyleTTS 2 is MIT, but the README makes using the pre-trained checkpoints conditional on telling listeners the speech is synthesized unless you have permission to use the voice. That is a repository term rather than a license clause, and it is a reasonable one.

How to choose

Work down this list and stop at the first match.

If you need a fixed set of voices and might ever run without a GPU, use Kokoro. Apache weights, under 100 MB quantized, no cloning surface to defend, and quality that beats what a 2023 GPU model produced.

If you need an unusual language or you are shipping to a Raspberry Pi, use Piper, and check that GPL-3.0 works for your distribution model before you build on it.

If you need zero-shot cloning and you are shipping commercially, the shortlist is Chatterbox (MIT top to bottom, 23 or more languages, watermarked), ZONOS2 (Apache, best fidelity, 8B total parameters), or NeuTTS Air (Apache, CPU, GGUF). Everything else in the cloning tier is non-commercial by weights license regardless of what the code license says.

If you are building a voice agent where response latency is the product, Kyutai TTS or Orpheus, and accept that Kyutai will not let you use arbitrary reference voices.

If you are doing research or a personal project, F5-TTS, MaskGCT, and Llasa are all excellent and the NC terms do not bind you.

What to watch over the next two quarters: whether the fully-permissive corpora hold up. Emilia-YODAS is the first credible commercial-clean corpus at scale, and if the next generation of cloning models trains on it exclusively, the license split that defines this entire landscape simply disappears. The other thing to watch is whether MoE routing keeps working for audio. ZONOS2 is the first serious sparse TTS model, and 4x throughput at 900M active parameters is the kind of result that gets copied fast.