Chapter 05b: Local Models — Best for Czech

• The ř phoneme (a raised alveolar trill) — unique to Czech, frequently mangled.
• Dense consonant clusters (e.g., zmrzl, čtvrtek, scvrnkls) and syllabic r/l.
• Diacritics (háčky and čárky: č š ž ř ě ů á í é ó ú ý) that change both pronunciation and meaning.
• Long vs. short vowels are phonemic — getting vowel length wrong sounds foreign.
• Numbers, dates, abbreviations, and foreign loanwords (English brand names) are routinely mispronounced unless the model has a Czech text-normalization front-end, which most local models do not have.

The upshot: a model's "supports Czech" claim is necessary but not sufficient. The amount of Czech training data and the quality of the text front-end matter more than the headline language count. This is why we grade Czech explicitly below rather than trusting the language list.

1. Piper — the lightweight Czech default

What it is. Piper is a fast, fully local, CPU-first neural TTS based on a VITS-style architecture, originally from the Rhasspy/Home Assistant world. It is the single easiest "real neural voice, runs anywhere, no GPU" option, and it has a genuine Czech voice.

Maintenance status (2026). The project moved from rhasspy/piper to OHF-Voice/piper1-gpl (the "piper1" rewrite, GPL-licensed, cleaner Python API). The pip package is still piper-tts. The huge voice library lives on Hugging Face at rhasspy/piper-voices and the older .onnx + .onnx.json voice files remain compatible with the new runtime.

The Czech voice: cs_CZ-jirka

There is essentially one Czech voice family in the official library:

Voice files live under rhasspy/piper-voices at the path cs/cs_CZ/jirka/medium/ (and /low/). Each voice is two files you must keep together:

• cs_CZ-jirka-medium.onnx (the model)
• cs_CZ-jirka-medium.onnx.json (the config / phoneme map)

Install and run (Python)

python -m venv .venv && source .venv/bin/activate
pip install piper-tts

# Download the Czech voice straight from Hugging Face
python -m piper.download_voices cs_CZ-jirka-medium
# (older CLI: python -m piper.download cs_CZ-jirka-medium)

# piper_cs.py — read Czech text to a WAV file, CPU only
import wave
from piper import PiperVoice

voice = PiperVoice.load("cs_CZ-jirka-medium.onnx")  # picks up the .json automatically

text = "Dobrý den. Toto je ukázka českého hlasu generovaného lokálně na vašem počítači."
with wave.open("out_cs.wav", "wb") as wav:
    voice.synthesize_wav(text, wav)
print("Wrote out_cs.wav")

Or straight from the shell (works for English too — just swap the voice):

echo "Dnes je krásný den a chci si přečíst svůj text nahlas." \
  | piper -m cs_CZ-jirka-medium.onnx -f out.wav

For English in the same project, grab a strong English voice like en_US-lessac-medium or en_US-amy-medium the same way — Piper handles both languages cleanly through the same API, which makes it attractive as a single dependency for EN+CS.

Czech quality grade: C+ / B− (intelligible, clearly synthetic)

Honest assessment for Czech specifically:

• Intelligibility: good. You can comfortably listen to paragraphs.
• Naturalness: clearly TTS — flat prosody, robotic-ish cadence on longer sentences, occasional wrong stress.
• Known pronunciation problems: there is a dedicated community project, sptsfn/piper-czech-tts, that exists specifically because the stock cs_CZ-jirka voice mispronounces words. It adds pronunciation fixes and can read PDFs directly. The existence of this project is itself the honest signal: the base Czech voice has real, recurring G2P errors (foreign words, numbers, some clusters).
• No voice choice: one speaker, male ("Jirka"). No female stock Czech voice in the official library.

Hardware: trivial. Runs faster-than-real-time on a modern laptop CPU; no GPU, no Python-heavy ML stack. RAM footprint is small (well under 1 GB). This is the reason to keep Piper around even if you choose XTTS for quality: it's the dependable, cheap, offline fallback that ships anywhere (including ARM/Raspberry Pi).

When to pick Piper for Czech: you need offline, CPU-only, low-latency, or embedded; you can tolerate "clearly a robot but a decent robot"; or you want one tiny library that does both EN and CS.

2. XTTS-v2 — the best natural local Czech (via cloning)

What it is. XTTS-v2 is Coqui's multilingual, voice-cloning TTS. It officially lists 17 languages including Czech (cs), and it clones a target voice from a short reference clip (~6+ seconds). For local Czech, this is the highest naturalness you can realistically get for free — but you almost always need to give it a Czech reference voice to make it sound genuinely Czech rather than "an accented multilingual model reading Czech."

Status / how to install (2026). Coqui (the company) shut down in early 2024, but the model is open and the code lives on through the idiap/coqui-ai-TTS fork. Install the maintained package — note it's coqui-tts, not the old TTS:

pip install coqui-tts        # the maintained idiap fork
# model auto-downloads on first use (~1.8 GB) to your HF cache

Run XTTS-v2 in Czech with a cloned voice

# xtts_cs.py — natural Czech via voice cloning
import torch
from TTS.api import TTS   # package is coqui-tts, import path is still TTS

device = "cuda" if torch.cuda.is_available() else "cpu"
tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to(device)

tts.tts_to_file(
    text="Dobrý den, vítejte. Tohle je text předčítaný přirozeným českým hlasem.",
    file_path="out_cs_xtts.wav",
    speaker_wav="czech_reference.wav",   # 6–20 s of a CZECH speaker
    language="cs",                       # <-- Czech
)

How to get a good Czech result — the cloning recipe (this is the important part)

The single biggest lever for natural Czech is the reference clip. Do this:

1. Use a native Czech speaker as the reference. This is non-negotiable for natural Czech. If you clone an English speaker and set language="cs", you get Czech words with a foreign mouth — unnatural. A Czech reference voice anchors the phonetics and prosody to Czech.
2. Clip length 6–20 seconds, clean, mono, 22.05 kHz or higher, no background music, no reverb, one speaker only. Quality of this clip caps your output quality.
3. Content of the clip should contain Czech-specific sounds (ř, long vowels, clusters) so the model has them to imitate.
4. Where to get a legal Czech reference: record yourself or a willing Czech speaker (best — and you own it); or use a permissively-licensed Czech speech corpus (e.g. Common Voice Czech, public-domain Czech audiobooks from LibriVox/Czech sources). Do not clone a real person's voice without consent — both ethically and, increasingly, legally.
5. Pre-compute the speaker latents once if you'll synthesize a lot, so you don't re-encode the reference every call (see the xtts.get_conditioning_latents() API in the model docs) — big speed win for a reading app.

Czech quality grade: B / B+ with a good Czech reference; B− without

• With a clean native-Czech reference: this is the most natural free local Czech available in 2026. Prosody and timbre are good; the ř and clusters are usually handled; it reads paragraphs convincingly.
• Caveats (be honest): Czech was not one of XTTS's highest-resource languages (English/Spanish/etc. got more data), so you will hit occasional mispronunciations — especially numbers, dates, abbreviations, and English loanwords, because XTTS has no Czech text-normalization front-end. You may need to pre-normalize text (spell out numbers in Czech, expand abbreviations) yourself before sending it.
• Determinism: output varies slightly run-to-run; set seeds / pin parameters if you need reproducibility.
• No official Czech fine-tunes are widely published — the base model's built-in Czech plus your reference clip is the realistic path. (You can fine-tune XTTS on Czech audio for a step up, but that needs 12 GB+ VRAM and a dataset, which is beyond "near-free/easy.")

Hardware:

When to pick XTTS for Czech: you want the most natural local Czech, you have a GPU (or can tolerate batch CPU rendering), and you can supply a clean Czech reference clip. This is the recommended quality option for the reader's goal.

3. Meta MMS-TTS — the trivially-installable Czech VITS

What it is. Part of Meta's Massively Multilingual Speech project (1,100+ languages). The Czech model is facebook/mms-tts-ces (ces = ISO 639-3 for Czech), a VITS single-speaker model you can run directly through Hugging Face transformers with no special TTS framework.

pip install transformers torch scipy

# mms_cs.py — Czech TTS via Hugging Face transformers
import torch, scipy.io.wavfile
from transformers import VitsModel, AutoTokenizer

model = VitsModel.from_pretrained("facebook/mms-tts-ces")
tok = AutoTokenizer.from_pretrained("facebook/mms-tts-ces")

inputs = tok("Toto je český hlas z modelu Meta MMS.", return_tensors="pt")
with torch.no_grad():
    wave = model(**inputs).waveform

scipy.io.wavfile.write("out_mms_cs.wav",
                       rate=model.config.sampling_rate,
                       data=wave.squeeze().cpu().numpy())

Czech quality grade: C / C+ (functional, single voice, plain)

• Pros: dead-simple install (just transformers), no separate runtime, decent intelligibility, runs on CPU.
• Cons: single fixed speaker (no choice, no cloning), flat/plain prosody, no Czech text normalization (numbers/abbreviations suffer), and VITS's stochastic duration predictor means non-deterministic output. Generally a notch below Piper's cs_CZ-jirka-medium on naturalness, but it's a useful sanity-check baseline and a fully transformers-native option if you're already in that ecosystem.

Hardware: light. CPU is fine; a GPU just speeds it up. Sub-1 GB model.

When to pick MMS: you're already on transformers, want a no-framework Czech baseline, or need a quick A/B against Piper.

4. eSpeak-NG — the robotic Czech baseline (and the phonemizer underneath everything)

What it is. eSpeak-NG is a tiny formant-synthesis engine supporting 100+ languages including Czech (cs). It is not neural. It sounds unmistakably robotic — a classic 1990s computer voice — but it is instant, microscopic, and runs literally anywhere.

# Debian/Ubuntu
sudo apt-get install espeak-ng
# macOS
brew install espeak-ng

espeak-ng -v cs "Toto je robotický český hlas z programu eSpeak NG." -w out_espeak_cs.wav

Czech quality grade: D (intelligible, very robotic)

• It will say Czech correctly-ish (Czech's phonetic orthography helps G2P), but no one will mistake it for natural. For a "read my texts naturally" goal, this is not the answer.
• Why it still matters: eSpeak-NG is the G2P (grapheme-to-phoneme) backbone used by many neural systems, including most Piper voices, to convert text into phonemes. So even when you use Piper for natural Czech, eSpeak-NG (or its phonemizer) is quietly doing the Czech text→phoneme step. Keep it installed.

Hardware: negligible. Runs on a microcontroller-class device.

When to pick eSpeak for Czech: accessibility fallback, extreme resource constraints, or as a phonemizer dependency — not for naturalness.

5. What does NOT work for Czech (so you don't waste time)

This is the part most "best local TTS 2026" lists won't tell you, and it's the reader's hard filter:

The pattern: the buzziest 2025–2026 local models are English-first and leave you stranded in Czech. The list that actually serves natural Czech is short: XTTS-v2, Piper, MMS, eSpeak.

Recommended local Czech setup

For the reader's goal — natural EN+CS, free/local, technical user with Docker:

Tier 1 — Best natural (needs a GPU):

• XTTS-v2 via coqui-tts for Czech and English, with a clean native-Czech reference clip you record yourself (and an English reference for EN).
• Pre-compute speaker latents; pre-normalize Czech numbers/abbreviations before synthesis.
• Run it behind a tiny FastAPI service (or a community XTTS API server image) so your app calls POST /tts and gets a WAV — same interface as a cloud API, but free and private.
• Expect ~6–8 GB VRAM for comfortable near-real-time; CPU works for batch rendering of articles to audio.

Tier 2 — Lightweight / no-GPU fallback (ships anywhere):

• Piper cs_CZ-jirka-medium for Czech and en_US-lessac-medium (or en_US-amy-medium) for English.
• One small pip dependency, CPU-only, faster-than-real-time, trivial to Dockerize.
• Accept "clearly synthetic but clear." Optionally layer the sptsfn/piper-czech-tts pronunciation fixes if you hit recurring mispronunciations.

Practical hybrid (what I'd actually ship): Piper as the always-available default (instant, offline, zero cost), with an XTTS-v2 "high-quality render" path for content you want to sound genuinely natural (e.g., a "listen" button that renders once and caches the MP3). Cache aggressively — generate each piece of text to audio once and store it; this makes even CPU XTTS practical and keeps everything free.

Text-normalization tip (applies to all local CS models): none of these have a strong Czech front-end. Before synthesis, expand numbers to Czech words, spell out abbreviations and units, and consider a small dictionary for English brand names. This single preprocessing step does more for perceived Czech naturalness than swapping models.

Key Takeaways

• Most hyped 2026 local TTS models do NOT support Czech (Kokoro, MeloTTS, Dia, Sesame, Chatterbox, and Fish/OpenAudio is unconfirmed). The usable Czech list is short: XTTS-v2, Piper, MMS-TTS, eSpeak-NG.
• Best natural local Czech = XTTS-v2 + a native-Czech reference clip (voice cloning), via the maintained coqui-tts (idiap) fork. Grade ~B/B+. Needs ~6–8 GB VRAM for comfort; CPU works for batch rendering. Reference-clip quality is the dominant quality lever; never clone a real person without consent.
• Best lightweight/CPU Czech = Piper cs_CZ-jirka-medium (pip install piper-tts, voice from rhasspy/piper-voices). One male voice, two tiers, grade ~C+/B−, known pronunciation quirks (hence the sptsfn/piper-czech-tts fix-up project). Runs faster-than-real-time, no GPU, and does English equally easily.
• Meta facebook/mms-tts-ces is the easiest install (pure transformers, VITS, single speaker), grade ~C — a fine baseline, a notch below Piper.
• eSpeak-NG cs is robotic (grade D) — not for "natural," but it's the phonemizer backbone under Piper and worth keeping installed.
• No local Czech model has a real Czech text front-end — pre-normalize numbers/abbreviations/loanwords yourself; this matters more than model choice for perceived naturalness.
• Recommended shipping pattern: Piper as the instant offline default + an XTTS-v2 "high-quality render & cache" path for content you want to sound truly natural. Both are free.

Key References

• OHF-Voice. piper1-gpl (GitHub). 2025–2026. https://github.com/OHF-Voice/piper1-gpl — current maintained Piper runtime, install (pip install piper-tts), Python API, and VOICES.md.
• Rhasspy. piper-voices (Hugging Face). 2024–2026. https://huggingface.co/rhasspy/piper-voices — official voice library; Czech voice at cs/cs_CZ/jirka/{low,medium} (.onnx + .onnx.json).
• Rhasspy. cs_CZ-jirka-medium voice — Discussion #487 (GitHub). 2024. https://github.com/rhasspy/piper/discussions/487 — origin/notes on the community-contributed Czech voice.
• sptsfn. piper-czech-tts (GitHub). 2024–2025. https://github.com/sptsfn/piper-czech-tts — project that fixes cs_CZ-jirka mispronunciations and reads PDFs; evidence of the base voice's Czech G2P limits.
• Coqui / idiap. coqui-ai-TTS — maintained fork (GitHub). 2024–2026. https://github.com/idiap/coqui-ai-TTS — pip install coqui-tts; XTTS-v2 usage, languages, and training recipes.
• Coqui. XTTS-v2 (Hugging Face). 2023–2026. https://huggingface.co/coqui/XTTS-v2 — model card listing 17 languages incl. Czech (cs), ~6s cloning, cross-language synthesis.
• Meta AI. facebook/mms-tts-ces (Hugging Face). 2023–2026. https://huggingface.co/facebook/mms-tts-ces — Czech VITS single-speaker model from the MMS project; transformers VitsModel usage.
• Hugging Face. MMS / VITS model docs (Transformers). 2024–2026. https://huggingface.co/docs/transformers/model_doc/vits — how to run VITS/MMS TTS in transformers, including the stochastic (non-deterministic) duration predictor.
• eSpeak-NG. espeak-ng (GitHub). 2024–2026. https://github.com/espeak-ng/espeak-ng — formant synthesizer with Czech (cs) support; widely used as the G2P/phonemizer backbone for neural TTS incl. Piper.
• Hexgrad. Kokoro-82M (Hugging Face). 2025. https://huggingface.co/hexgrad/Kokoro-82M — supported-language list (no Czech), confirming exclusion for this reader's filter.
• MyShell. MeloTTS (GitHub). 2024–2025. https://github.com/myshell-ai/MeloTTS — supported languages (EN/ES/FR/ZH/JA/KO), confirming no Czech.
• FishAudio. fish-speech / OpenAudio (GitHub). 2025–2026. https://github.com/fishaudio/fish-speech — language coverage; Czech not officially listed/confirmed.