Local Open TTS Models: Common Pitfalls and Fixes

The trap that eats the most time in local TTS in 2026 is not audio quality but silent failure. The model runs without errors, yet the output is truncated, the pronunciation breaks, or the voice shifts mid-way. Notably, XTTS truncates audio after 250 characters with just a one-line warning, Kokoro's pronunciation breaks without espeak-ng, and pip install TTS installs an already-abandoned repository. And before all of that: license comes before audio quality - the best-sounding models ship under non-commercial licenses you can't deploy in a paid product. This guide walks the TTS-specific traps as symptom -> cause -> fix, with numbers.

In plain terms: local TTS is like a great restaurant with no sign. The food (quality) is excellent, but they don't post the opening hours (250-char limit), skip the allergen labels (espeak-ng, sample rate), and some are stamped "private guests only" (non-commercial license). Walk in on taste alone and you'll get burned.

Why is the audio cut off or the pronunciation broken?

Usually XTTS's 250-char hard cap, a missing espeak-ng, or a sample-rate mismatch. XTTS logs only a "character limit of 250" warning when input exceeds 250 chars and quietly truncates the audio - it's a warning, not an error, so it's easy to miss. It also has internal token limits, so chunking long text is mandatory: split into sentence chunks under 250 chars and concatenate the WAVs (use split_sentences for manual control). Second, Kokoro phonemizes via espeak-ng, so without that system package installation breaks or pronunciation garbles - install espeak-ng first, and add misaki[ja] for Japanese, misaki[zh] for Chinese. Third, a sample-rate mismatch produces chipmunk (high-pitched) or slowed voices - Kokoro outputs 24kHz, so always pass 24000 to your file writer and resample downstream (16kHz telephony, 48kHz video) explicitly.

Why does the voice change over a long passage?

Because generating each chunk independently lets random sampling drift the timbre. Chunking under 250 chars fixes truncation, but in long projects (audiobooks, multi-file exports) timbre and pronunciation drift a little at every chunk boundary. Two things reduce it: (1) a fixed seed (e.g., 42) to reset the random state before each chunk - seeds are supported in Qwen3, XTTS, and F5-TTS, and -1 disables. (2) larger chunks (fewer boundaries = fewer chances to drift) plus one voice ID per project. And one more install trap: pip install TTS (what 90% of tutorials say) installs Coqui's original repo - the company shut down in early 2024, is pinned to Python 3.11, and throws a RuntimeError on 3.12. Instead install the idiap fork coqui-tts (PyPI) - it has prebuilt wheels for macOS/Windows/Linux and is maintained. On newer PyTorch you also need a torch.load security patch.

What can you actually use in a commercial product?

The better a model sounds, the more likely it's non-commercial, so for commercial you check the license before the audio. XTTS v2 (CPML), F5-TTS (CC-BY-NC), open Fish Speech (CC-BY-NC-SA), and IndexTTS-2 are all non-commercial (personal/demo). The commercial-safe options are Kokoro, Chatterbox, Bark, Orpheus (Apache/MIT). Piper's original (MIT) was archived in October 2025 and moved to a GPL fork (copyleft - mind closed-source embedding), so verify. And training-data licenses and consent are a separate layer - voice cloning is restricted in some jurisdictions, so check the model card's data terms before shipping. Don't over-provision hardware: Kokoro runs in <2GB and even on CPU, while XTTS wants 4-6GB GPU at ~4x real-time. Finally, "beat ElevenLabs (65-66%)" numbers are all maker-run benchmarks, so given that the best open model (Sesame CSM 4.7 MOS) is within 0.1-0.3 of ElevenLabs (4.8), A/B on your own language and text.

So what's a safe local TTS setup?

The key is license first, then stop the silent failures.

• License: commercial = Kokoro, Chatterbox (Apache/MIT); personal/demo, XTTS/F5 are fine too. Verify data terms and consent.
• Silent-failure prevention: XTTS chunk <250 chars, Kokoro espeak-ng + 24kHz, and install coqui-tts (idiap fork). Don't trust a tutorial's pip install TTS.
• Long-form/quality: fixed seed + larger chunks + one voice ID to pin the timbre. Kokoro's <2GB is plenty. Benchmarks are often self-run, so A/B in your own language, then lock it in.

Related reading: 오픈 음성 클로닝 파이프라인 — 우리는 이렇게 운영한다, 오픈 음성 클로닝, 우리는 이렇게 운영한다 — 파이프라인 회고

Related reading: 로컬 음성합성(TTS) 오픈모델, 직접 돌려본 속도·품질·라이선스, 로컬 음성합성(TTS) 오픈모델 — VRAM·RAM 요구량 실측

Reference links

• Kokoro-82M (lightweight TTS, Apache)
• coqui-tts (idiap maintained fork)
• Chatterbox (Resemble AI, MIT)
• F5-TTS (flow-matching cloning)
• espeak-ng (phonemization system dependency)

Note: figures like the 250-char cap, sample rate (24kHz), seed (42), VRAM (Kokoro <2GB, XTTS 4-6GB), RTF (~4x), MOS (4.7 vs 4.8), and preference rates (65-66%) are 2026 public and maker-run benchmarks that vary by model, language, reference audio, and version (not permanent; many self-run). Licenses differ by variant (e.g., Piper's GPL fork) and laws differ by jurisdiction, so verify the model card and local rules before commercial use. Packages and dependencies change across versions (e.g., the coqui-ai/TTS shutdown), so validate your install path. TTS practice moves fast, so this is reviewed quarterly.