Which Open Source Text-to-Speech Model Should You Use?

A voice that sounds convincing in a demo can still be awkward to put into a product. It may pause before every answer, mispronounce an account number, change character halfway through a paragraph, or require a license that does not cover your application. These details matter when the voice becomes part of the interface.

The first choice is the workload. A document reader can prepare audio ahead of playback. A support agent may need to begin speaking before its language model has finished a response. A dubbing pipeline needs control over timing and speaker identity. Each places different demands on text-to-speech, or TTS.

This guide compares official documentation, released model artifacts and published evaluations checked on October 12, 2026. We did not run model inference for this update. It covers open-source models and, separately identified, downloadable models with more restrictive licenses. The aim is to make the technical and licensing differences visible before you commit to a stack.

For an offline reader or an application running on a CPU, begin with the deployment budget: how much memory the application can occupy, which languages it needs, and whether a supplied voice is sufficient. Kokoro, Piper and Pocket TTS expose quite different voice and runtime choices within this category.

For a conversational agent, inspect both sides of streaming. Can the system accept text incrementally? Can it deliver playable audio before the entire sentence or response is complete? Then check how the application cancels generation when the user interrupts. A model demonstration rarely answers all three questions.

For narration, localization or dubbing, pronunciation, consistent identity and editing control may matter more than the first audio packet. Reference cloning, a reusable speaker preset, instruction-based voice design and fine-tuning are different ways of creating a voice. Decide which one your workflow needs.

For multilingual products, write down the actual languages and accents. Test mixed-language names, dates, currencies and abbreviations in context. A model's language count is a description of coverage; it is not a quality score for each language.

For a fixed voice on a CPU, go to the local reader path. For a reusable reference voice, see the GPU service path. For an LLM speaking as it generates, start with the conversational agent path. Check the weight licenses before investing in a commercial prototype.

The tables compare selected releases for local synthesis and reference-voice workflows; additional families and adjacent tools follow below. A checkpoint is a specific set of model weights. M and B in the variant labels mean millions and billions of parameters, not a quality rating. Audio streaming means delivery of audio in pieces; text streaming means accepting text as it arrives. Sentence chunking can provide progressive playback even when the model synthesizes each segment as a whole. The interface column describes the linked reference implementation; another server may expose a different contract.

Language totals come from the linked release documentation. They do not imply equivalent accents, pronunciation accuracy or cloning quality. Base, multilingual and fine-tuned checkpoints within the same family can have different behavior.

GGUF is a model file format used by some local runtimes; BF16 is a 16-bit numeric format. SFT means supervised fine-tuning, while LoRA trains small adapter weights. These describe different parts of deployment and adaptation.

There are at least four things to identify in a local TTS stack: the application code, the TTS weights, the audio codec or vocoder, and any supplied voice recordings. Their licenses can differ. The terms of a commercial hosted API are a separate question again.

The custom-license entries need to be read in full for the intended deployment. In particular, “research use,” “commercial use,” distribution of derived weights and use of generated output are not interchangeable permissions.

Hardware requirements deserve the same precision. The Voxtral model card describes a single GPU with at least 16 GB for its BF16 deployment. VoxCPM2's documentation reports approximately 8 GB VRAM for its reference route. These are model-specific deployment descriptions, not a benchmark against each other or a promise for every server configuration.

Memory also holds intermediate activations, caches, a codec and sometimes another model for processing the reference audio. Batching, text length and concurrent requests can change the footprint. A 4-bit weight file on disk is therefore an incomplete answer to “will this fit on my GPU?”

Qwen3-TTS separates three voice workflows

Qwen3-TTS is a family rather than a single voice API. Base checkpoints condition generation on reference audio. CustomVoice uses supplied speakers, while VoiceDesign creates a voice from a written description. Choosing the wrong checkpoint can leave an application expecting controls that its model does not expose.

Reference conditioning is the prepared representation of a voice sample that guides generation. For a repeated character, the Base examples show reusable voice-clone prompts. That lets the application separate preparation of the reference from generation of each new line. The reference still needs to represent the voice you want; a noisy recording is not an interchangeable substitute for a clean one.

The reference Python example returns completed waveforms. For an LLM that emits text incrementally, check the text-input contract of the serving route as well as when it releases audio.

CosyVoice3 connects text streaming with audio generation

The CosyVoice repository includes inference, training and deployment workflows. For a new implementation, the released Fun-CosyVoice3-0.5B-2512 checkpoint is the relevant starting point in this comparison; older CosyVoice2 results belong to that older model.

Its text-in/audio-out streaming is particularly relevant when text comes from an LLM a little at a time. The application must still decide when to release text to synthesis and how much audio to buffer. Waiting for a complete paragraph can erase the benefit of a streaming model; cutting every few characters can leave too little context for natural phrasing.

Reference cloning, instruction control and language support should be evaluated together. A voice that works well on an English reference may need a different prompt or a language-matched reference for another deployment.

Chatterbox varies substantially by checkpoint

Chatterbox's release table distinguishes Multilingual V3, Turbo and Nano. V3 is the multilingual 500M variant. Turbo is a 350M English model; Nano is the smaller 110M English option with a documented CPU path. Treating all three as “Chatterbox supports 23+ languages on CPU” would merge separate claims.

In the multilingual example, V3 requires t3_model="v3"; omitting the selector loads the older V2 checkpoint. Pin this setting when comparing releases.

Turbo and Nano support paralinguistic tags such as laughter. These are useful controls for a scripted experience, but an application accepting generated text should decide which tags it allows through. A support agent reading an error message needs different behavior from an entertainment character.

The implementation also integrates Perth audio watermarking. Watermarking is a property to understand in the output pipeline; it does not by itself establish consent to clone a speaker or guarantee that every downstream transformation preserves detection.

Kokoro, Pocket and Piper make different local tradeoffs

Kokoro's 82M model combines a small model with a supplied voice library. Its documented pipeline converts text into phonemes—the sounds to pronounce—and yields generated segments. This makes voice selection and pronunciation handling concrete integration tasks. Arbitrary reference-audio cloning is not the interface described by that pipeline.

Pocket TTS accepts a supplied voice or an audio file as a reference, and exposes a local server as well as a generation command. Its CPU-oriented approach is useful to investigate when the application needs cloning without a dedicated GPU service. The current repository lists seven languages and additional, larger variants for some of them; check the exact language model before transferring an English performance claim to another language.

Piper is an engine-and-voice-model approach. Choosing a voice means selecting its model, language and license. That can be a straightforward interface for an offline reader with a fixed speaker, while a product that lets every user upload a new reference voice has a different requirement.

VoxCPM2 uses a continuous acoustic representation

VoxCPM2 describes its speech generation as tokenizer-free: it models continuous acoustic representations rather than relying on discrete speech tokens in the same way as codec-token language models. The released 2B model supports reference cloning, voice design and streaming audio.

Its deployment documentation is also a useful reminder that a model and its runtime are separate decisions. Standard PyTorch, optimized serving and a community Metal/GGUF port have different operating characteristics. If Apple Silicon is the target, assess that port and artifact directly instead of applying a CUDA result to it.

Downloadable models with additional license conditions

Fish Audio S2 Pro combines slow and fast autoregressive components and exposes expressive controls across a broad set of languages. Its research license requires separate written permission for commercial use. A public download does not settle whether a production service is covered.

IndexTTS-2.5 is relevant to workflows that need explicit emotion, pronunciation and duration controls. The current release describes five languages and a duration factor. Use the capabilities of this release rather than promises or benchmark rows from IndexTTS2. Its Bilibili license includes organization thresholds and restrictions on using the model or derivatives to improve other AI models, with stated exceptions. The reference Python implementation can yield completed text segments with stream_return=True; this is different from accepting an unfinished text stream.

Voxtral TTS offers a 4B checkpoint with nine-language coverage and a documented vLLM-Omni route. The local weights are CC-BY-NC-4.0. Mistral's hosted service is a separate way to access the model, with its own commercial terms.

These systems belong in a technical comparison because their capabilities overlap with permissively licensed models. Keeping their terms visible helps the reader distinguish a research experiment from a deployable commercial plan.

F5-TTS uses flow matching, while XTTS-v2 documents a GPT-based speech-generation stack and reference voice cloning. Architectural labels help explain their generation paths, but they do not establish which voice a listener will prefer or which application will respond sooner.

The practical comparison starts with the inputs. For F5, use the reference-audio and reference-text workflow expected by the selected implementation. For XTTS, inspect its speaker-conditioning and streaming APIs. For CosyVoice3, include text streaming and the serving layer in the comparison. Keep the test text, reference speaker and target language consistent where the interfaces permit it.

Fine-tuning is another distinct comparison. A zero-shot sample says little about the amount of data, training stability or control available after adaptation. Evaluate the released training workflow, supported checkpoint and output rights together. The F5 pretrained weights and XTTS model license both have non-commercial conditions, even though associated source code is available.

Existing applications do not need a model change simply because a newer name appears. A useful migration test is whether the candidate improves a specific failure: pronunciation, first-audio delay, a missing language, voice consistency or an operational constraint. Keep the working system as a baseline and compare the entire inference path.

NeuTTS deserves a closer look for local speech generation. Air, Nano and 2E differ in model size, voice inputs and licensing. Air uses Apache-2.0; Nano and 2E use the NeuTTS Open License with a revenue-related condition. The 2E model's fixed speakers and emotion controls should not be described as the same cloning workflow as Air.

MOSS-TTS also groups distinct models under one project: the main TTS, Local Transformer, Realtime and Nano variants target different inference and control requirements. A single aggregate row listing every family feature would obscure the choice a developer actually has to make.

For dialogue-oriented generation, Dia2 provides an English model family with audio-prefix conditioning. Its model-level streaming design and the availability of a ready-to-integrate server are separate facts. VibeVoice Realtime 0.5B is another specific streaming checkpoint; do not substitute documentation for VibeVoice ASR or historical TTS releases.

GLM-TTS documents reference cloning and streaming inference. Its release notes distinguish available model weights from planned RL-optimized weights. That distinction matters when reproducing a result attributed to the broader research project.

Higgs TTS 3 has custom research and non-commercial terms, with an additional creator grant for certain content published on the creator's own channels. That grant is not a general license to operate a commercial TTS API. OmniVoice advertises coverage of more than 600 languages, while its model card specifies non-commercial pretrained weights. Broad coverage is a reason to test a needed language, not evidence of equal quality across the list.

GPT-SoVITS includes few-shot and zero-shot workflows and a set of pretrained components. OpenVoice V2 separates voice characteristics from a base speech-generation pipeline. In both cases, inspect the full stack rather than treating a repository-level license or feature list as a description of every dependency.

Supertonic remains an example of compact ONNX-based deployment, but its repository is archived. Maintenance status belongs in the evaluation alongside model quality and runtime support.

Finally, RVC changes a voice in existing audio, whereas Whisper recognizes speech. They can participate in audio workflows, but neither is a direct text-to-speech replacement. Our speech-to-text overview covers the input side of a voice application.

Consider an LLM producing the sentence, “Your booking is confirmed for Thursday.” A TTS integration can wait for the whole answer, send one sentence at a time, or pass text incrementally as the LLM generates it. Those policies give the speech model different amounts of context and start synthesis at different moments.

Audio output introduces another boundary. The server may return a completed file, yield chunks from an ongoing generation, or divide completed sentence-level generations into transport packets. Hearing packets arrive does not tell you which policy produced them.

For a voice agent, measure from the user's experience. Time to first audio should specify when the clock starts and when the first playable sound is available. Then inspect gaps between chunks, buffering and cancellation. A fast first packet followed by a long pause is still an uncomfortable conversation.

Real-time factor, using the convention in this article, is generation time divided by generated audio duration. An illustrative six-second recording produced in two seconds has an RTF of 0.33. It can finish faster than playback, but that alone says nothing about whether the first sound arrives after 100 milliseconds or after both seconds. Some tools report the reciprocal as a speed multiplier, so check the formula before comparing columns.

The model is only one contributor to voice-agent delay. Turn detection, speech recognition, retrieval, LLM generation, transport and playback buffering all matter. Modal's published voice-agent walkthrough is useful because it describes that larger pipeline, including Kokoro and Pipecat, rather than presenting a TTS number as the whole conversation.

Different evaluations answer different questions. WER measures disagreement between a transcript and recognized words; speaker similarity measures an embedding relationship; a listener preference test measures which sample people choose under that test's conditions. None is a substitute for all the others.

The Seed-TTS evaluation repository publishes objective test data and scripts for WER and similarity. Its English and Mandarin setup is useful for understanding those measures; a result on that test set does not establish performance on Polish product names or a multilingual call-center script.

Artificial Analysis separates a Controlled Voice Arena, using shared reference voices, from a Provider Voice Arena using provider-supplied voices. That distinction helps separate preference for a particular voice from preference for the model's delivery. Its performance measurements concern the tested endpoints, not an arbitrary local deployment of their weights.

TTSDS2 evaluates multiple aspects of generated speech with a multilingual methodology. EmergentTTS-Eval, published by Boson AI, offers challenge categories such as pronunciation and expressive behavior. The latter's model-based judging and its publisher are part of the context for interpreting its results.

Published speed figures need a deployment passport. For example, F5-TTS's runtime documentation compares implementation paths under a specified GPU setup. The Voxtral model card gives hardware, input and concurrency details and explicitly converts its script's inverted RTF convention. These are useful experiments to read in their own conditions. Combining their fastest rows into a new cross-model leaderboard would lose those conditions.

A local CPU reader

Start with a supplied voice and short, representative text. Kokoro's Python example shows the text frontend, voice selection and waveform output. Piper offers an engine with separate voice models. When reference cloning is required, Pocket's local CLI and server provide a documented route to investigate.

Measure the CPU application while its other work is running. Include model load time, resident memory, synthesis time and playback continuity. Decide whether voices can be downloaded during setup or whether all assets must ship with the application. Check that the selected voice's license covers redistribution if you bundle it.

Keep generated segments associated with their text. If the reader skips to another paragraph, discard or cancel the queued audio for the old position. Fast synthesis does not remove that application-level requirement.

A GPU service for a reusable reference voice

Use a consented reference recording and the transcript expected by the selected model. Qwen's clone examples demonstrate reusable conditioning, and VoxCPM exposes cloning and streaming workflows with additional runtime options.

Cache prepared conditioning only within an access boundary appropriate to that voice. Record the checkpoint revision, precision and runtime so that a deployment update does not silently replace the evaluated system. Benchmark a single request before increasing concurrency; queueing can dominate the user experience even when isolated synthesis is quick.

If adaptation requires training, use model-specific recipes. LoRA is a way to reduce the number of trainable parameters, not a guarantee that a TTS project supports it or that a given dataset is sufficient. Our PEFT guide explains the general method; the TTS project's own training code defines the implementation.

A conversational voice agent

Use a serving route with the required input and output streaming contract, then connect it to turn detection, the LLM's text stream and the client's audio buffer. CosyVoice provides relevant streaming workflows; the Modal and Pipecat example provides a concrete application architecture.

Track each spoken turn with an identifier. When the user interrupts, stop accepting audio for the old turn, cancel generation if the server supports it, and clear stale playback buffers. Otherwise an apparently cancelled answer can resume after the user's next question.

Measure the time from the end of the user's speech to the first audible response, as well as the TTS component's own latency. Test slow LLM output, network jitter and overlapping requests. This separates a model problem from a buffering, scheduling or transport problem.

Follow each linked project's environment requirements and pin the version used for evaluation.

Collect the things the product actually says: names, addresses, account identifiers, currencies, error messages, questions, long explanations and short confirmations. Add the languages and accents that matter to its users. Keep ordinary samples as well as difficult ones, so that a challenge set does not become the only measure of quality.

For a support assistant, a small illustrative prompt set could contain “Your reference is AB-2047,” “The appointment is on 03/04,” and “Please open the .env.local file.” Decide the intended reading before testing. A date with two valid regional interpretations cannot reveal a pronunciation error until the product's convention is specified.

Use the same test texts across candidates and record the exact voice selection or reference input for each. If one system accepts a longer reference than another, document the difference. Separate cold starts from warm requests and test the concurrency the service is expected to sustain.

Listen for omitted words, repetitions, strange pauses, unstable identity and incorrect names. Automatic transcription can flag likely failures, but an ASR model can also make errors. Have a person inspect consequential cases instead of assuming every transcript mismatch came from the synthesizer.

For a compact evaluation record, retain:

• Checkpoint and revision, runtime version, device, precision and codec.
• Test text, intended pronunciation, language, selected voice and reference conditions.
• First-audio timing, total generation time, audio duration and failures.
• Memory under the chosen load, queueing and concurrency.
• Listener judgments and examples of errors, with the original audio.

Define the acceptance criteria before comparing results. A product can tolerate a slightly less expressive voice while rejecting any skipped account number. Another can prepare audio overnight but requires an editor to control every character's delivery. These are different engineering decisions, and the evaluation should preserve that difference.

Which TTS models can run on a CPU?

Pocket TTS, Piper, Kokoro and Chatterbox Nano have relevant local routes. CPU compatibility does not establish real-time performance on every processor. Check the runtime, voice or language variant, number of threads and the application's competing workload.

Can F5-TTS and XTTS be used commercially?

The F5 pretrained weights use CC-BY-NC-4.0, while XTTS-v2's model license has non-commercial conditions. A permissive code license, a fine-tune or a third-party wrapper does not automatically remove restrictions on the underlying weights. Check any separately offered commercial permission and the exact artifact involved.

Is audio streaming the same as streaming text input?

No. A service can stream audio after receiving a complete paragraph. Text-in streaming accepts an unfinished text sequence, which is relevant when an LLM is still generating. CosyVoice's documentation explicitly discusses this distinction through its streaming workflows. Verify the interface of the deployed server, not just the model family's description.

How much reference audio does voice cloning need?

Use the guidance for the exact model and mode. XTTS-v2's card describes cloning with a short recording, but that is not a universal rule for every system. Speech clarity, background noise, emotional style and language affect the usefulness of a reference. More audio does not automatically make it better.

Does the reference audio need a transcript?

Some workflows use a matching transcript, while others extract speaker conditioning without one. Qwen's Base example distinguishes conditioning modes, and F5's inference guidance explains its reference workflow. If transcription is automatic, inspect it before judging the TTS output.

How can I fix names, numbers and abbreviations?

First make the intended reading explicit in preprocessing. Where supported, use the model's phoneme or pronunciation controls: Kokoro uses a phoneme frontend, while IndexTTS-2.5 documents pronunciation controls. Keep the displayed text separate from its spoken form when expanding a code or date.

Does support for a language guarantee the right accent?

No. Language coverage, a speaker's accent and cross-language voice cloning describe different properties. OmniVoice's usage notes discuss the effect of reference language on generated pronunciation. Evaluate the actual accent and terminology with speakers of the target language.

Can these models run on Apple Silicon?

Some projects document CPU, MPS or community Metal routes, but those are not interchangeable. VoxCPM's deployment section distinguishes its runtime options. Check the entire stack, including the audio decoder and any preprocessing model, along with supported precision. A successful CPU fallback is not evidence of GPU acceleration.

Why does VRAM use exceed the size of the weights?

Inference also needs activations, caches and temporary buffers, and a TTS service may load a separate codec, vocoder or reference processor. Batch size and concurrent requests change the footprint. Use deployment guidance such as the Voxtral model card, then measure the complete service at the intended load.

Is low RTF enough for a live voice agent?

It is one requirement, not a complete latency measurement. The application still needs an acceptable first-audio delay, continuous playback and cancellation. The Modal voice-agent walkthrough shows why turn detection, retrieval, LLM output and transport belong in the same assessment.

When should I fine-tune rather than change the reference?

First determine whether the failure concerns the reference recording, text normalization, voice control or the underlying model's coverage. Fine-tuning adds data preparation, training and maintenance. Use a supported recipe, such as VoxCPM's adaptation workflows, and evaluate held-out text rather than only the training examples.

How do I keep a voice consistent across a long document?

Reuse the same voice identity or prepared reference conditioning, keep generation settings stable, and split text at meaningful boundaries. Qwen's reusable clone-prompt examples illustrate conditioning reuse. Listen across joins: consistent timbre does not guarantee consistent pacing, emotion or loudness.

Are voice conversion and speech recognition TTS alternatives?

RVC transforms an existing voice recording. Whisper turns speech into text. A TTS system generates speech from text. A larger application can combine them, but their inputs, outputs and evaluation criteria differ.