Kokoro vs XTTS-v2: Choosing a Local Text-to-Speech Model in 2026

Introduction

Hosted text-to-speech is easy to start with and awkward to keep. Per-character pricing turns a long audiobook or a nightly podcast generation job into a line item, terms of service restrict what you can do with cloned voices, and sending internal documents to a third-party API is a non-starter for some teams. Running a model locally removes those constraints and replaces them with new ones: GPU or CPU budget, voice quality that varies by language, licensing that is stricter than it looks, and a Python dependency chain that can break on a minor version bump.

Two open-weight models come up most often in that decision. Hexgrad's Kokoro-82M is a small model, 82 million parameters, released under the Apache 2.0 license, that produces natural English speech from a fixed set of preset voices and runs comfortably on modest hardware. Coqui's XTTS-v2 is a larger multilingual model that can clone a voice from a short reference recording. They sit at different points on the tradeoff between footprint, flexibility, and legal clarity, and the right choice depends mostly on whether you need cloning and whether the output is commercial.

This article compares them on architecture, voice control, languages, speed, licensing, and operations, and provides a script that synthesizes the same text with both and reports real-time factor on your own machine. It contains no pre-measured speed or quality scores. Speed depends on your hardware and quality is subjective, so the only trustworthy numbers are the ones you measure. Verify language lists and license terms against the model cards for the version you download, because both change.

Architectural Breakdown & Core Mechanics

Kokoro: a compact StyleTTS 2-derived model

Kokoro is built on ideas from StyleTTS 2 and uses an ISTFTNet-style vocoder, with a model size small enough to run in real time on CPU for short passages and far faster than real time on a consumer GPU. Text first passes through a grapheme-to-phoneme stage (the reference package uses the misaki library, with espeak-ng as a fallback for some languages), then the acoustic model produces audio at 24 kHz conditioned on a voice embedding. Voices are small preset files with names such as af_heart (the prefix encodes language region and gender), and you choose one per request. You can blend voices by combining their embeddings, but you cannot give it an arbitrary reference clip and ask it to imitate that speaker.

The practical effect is predictability. The same text and voice produce consistent output, memory use is low, and there is no zero-shot cloning surface to misuse. The limitation is the same: you get the voices that ship with the model.

XTTS-v2: autoregressive generation with speaker conditioning

XTTS-v2 is a multilingual text-to-speech model from Coqui built around an autoregressive transformer that predicts discrete audio tokens, followed by a decoder and vocoder that turn tokens into 24 kHz waveform. A speaker encoder processes a reference clip, roughly six seconds or more, into conditioning latents, which is how cloning works without per-speaker training. It supports around 17 languages according to its model card and offers streaming inference.

Autoregressive token generation costs more per second of audio than Kokoro's design, and the model is sensitive to input length: long passages need to be split into sentences or short chunks, and quality can degrade or repeat on very long inputs. Coqui the company wound down in early 2024; the Python package is now maintained by a community fork published as coqui-tts (Idiap). Pin the package version and keep a copy of the model files you validated.

Licensing is a real architectural constraint

Kokoro's weights are Apache 2.0, which allows commercial use. XTTS-v2 is distributed under the Coqui Public Model License (CPML), which restricts commercial use. For a product you sell, a monetized video channel, or a paid audiobook, read the license text with counsel. This single factor eliminates XTTS-v2 from many commercial plans before voice quality enters the discussion. Voice cloning also carries consent obligations: only clone voices you own or have written permission to use.

Comparative Benchmarks & Evaluation Matrix

The matrix compares documented properties. Speed and quality cells say how to evaluate rather than quoting numbers, because the figures vary with hardware, precision, and text, and we did not measure them here.

Who should not use these: if you need studio-grade expressive voices in many languages or a licensed cloned voice with legal indemnity, a hosted service such as ElevenLabs is the safer route, and its pricing page on the catalog entry is worth checking against your volume. If you need real-time conversation with sub-second latency on a laptop CPU, test Kokoro first and measure time to first audio, because total synthesis time and first-chunk latency are different numbers.

Step-by-Step Implementation Recipe

The script synthesizes the same text with each model and prints real-time factor (synthesis seconds divided by audio seconds; below 1.0 means faster than real time). It is meant to be run on your hardware. The Python APIs below match the projects' documented usage at the time of writing, but both packages change, so pin versions and consult their READMEs if a call fails.

Install system and Python dependencies first:

# Linux example; use your platform's package manager for espeak-ng

sudo apt-get install -y espeak-ng ffmpeg

python -m venv .venv && source .venv/bin/activate

pip install "kokoro>=0.9.2" soundfile      # Kokoro (Apache 2.0)

pip install coqui-tts                       # community-maintained XTTS-v2 runtime (model license is CPML)

Then run the comparison. Provide a short reference recording you have permission to use as reference.wav for XTTS-v2 (about six to ten seconds of clean speech).

import csv

import re

import time

import numpy as np

import soundfile as sf

import torch

TEXT = (

"The quarterly report is ready. Revenue grew in three of four regions, "

"and support tickets fell for the second month in a row. "

"Please review the appendix before Thursday's meeting."

)

REFERENCE_WAV = "reference.wav"  # only use a voice you own or have written permission to clone

SAMPLE_RATE = 24000

def split_sentences(text: str) -> list[str]:

parts = re.split(r"(?<=[.!?])\s+", text.strip())

return [p for p in parts if p]

def run_kokoro(text: str) -> np.ndarray:

from kokoro import KPipeline

pipeline = KPipeline(lang_code="a")  # 'a' = American English

chunks = []

for _, _, audio in pipeline(text, voice="af_heart"):

chunks.append(np.asarray(audio, dtype=np.float32))

return np.concatenate(chunks)

def run_xtts(text: str) -> np.ndarray:

from TTS.api import TTS

device = "cuda" if torch.cuda.is_available() else "cpu"

tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to(device)

chunks = []

for sentence in split_sentences(text):  # XTTS works best on short chunks

wav = tts.tts(text=sentence, speaker_wav=REFERENCE_WAV, language="en")

chunks.append(np.asarray(wav, dtype=np.float32))

chunks.append(np.zeros(int(0.15 * SAMPLE_RATE), dtype=np.float32))  # short pause

return np.concatenate(chunks)

def timed(name: str, fn):

start = time.perf_counter()

audio = fn(TEXT)

elapsed = time.perf_counter() - start

seconds = len(audio) / SAMPLE_RATE

sf.write(f"out_{name}.wav", audio, SAMPLE_RATE)

return {

"model": name,

"synthesis_s": round(elapsed, 2),

"audio_s": round(seconds, 2),

"real_time_factor": round(elapsed / seconds, 3),

"device": "cuda" if torch.cuda.is_available() else "cpu",

}

if __name__ == "__main__":

rows = [timed("kokoro", run_kokoro), timed("xtts_v2", run_xtts)]

with open("tts_results.csv", "w", newline="") as f:

writer = csv.DictWriter(f, fieldnames=rows[0].keys())

writer.writeheader()

writer.writerows(rows)

for row in rows:

print(row)

Two cautions on reading the output. The first call includes model download and load time, so run the script twice, or load models outside the timed section, before trusting the numbers. And RTF on a short sample says little about long-form jobs, so repeat with a few thousand words of your real content. For quality, listen with headphones to the same three paragraphs from both outputs, and have a second person do a blind comparison. Pay attention to names, numbers, and acronyms, which expose phonemizer weaknesses faster than prose.

Strategic Catalog Integrations

• To build a spoken assistant, pair a recognizer with a synthesizer. The LocalVoice Assistant project is a reference for a local voice loop, and OpenAI Whisper or the Whisper large-v3 turbo model handles the speech-to-text side.
• To generate the script that gets narrated, run a local language model through Ollama so the whole pipeline stays offline.
• Serving TTS to other services usually means an HTTP API. The FastAPI and Pydantic v2 rules give an editor ruleset for typed request validation, and the Docker and Kubernetes DevOps rules cover container hardening for a GPU service.
• For talking-head video that needs lip-synced voiceover, HeyGen is a hosted option to compare against a local pipeline.
• To understand the signal-processing basics behind vocoders and spectrograms, the Audio and Speech Processing course is a structured starting point.
• When you wire this into an automation, the Node.js automation script developer prompt and the senior code reviewer prompt help draft and review the glue code.

Frequently Asked Questions (FAQ)

Is Kokoro TTS better than XTTS-v2?

It depends on the requirement. Kokoro is smaller, faster to run, deterministic for a fixed voice, and Apache 2.0 licensed, which makes it the default for commercial narration. XTTS-v2 can clone a voice from a reference clip, which Kokoro cannot, but it is heavier and carries a non-commercial license. Judge naturalness by listening to your own text.

Can I use XTTS-v2 for commercial projects?

The model is distributed under the Coqui Public Model License, which restricts commercial use. Because Coqui the company has shut down, there is no vendor to ask for a commercial agreement, so confirm the current terms with counsel or choose a model with a permissive license.

Does Kokoro run on CPU without a GPU?

Yes, the model is small enough for CPU inference, which is a main reason people adopt it. Throughput depends on your processor, thread settings, and text length, so run the script above and read the real-time factor before planning a batch job.

How long should the reference audio be for voice cloning?

XTTS-v2's documentation points to a clip of roughly six seconds or longer. Clean, single-speaker audio with no music or room echo matters more than extra length. Always have the speaker's permission to clone their voice.