Chapter 05a: Local Models — Best for English

1. Kokoro-82M — the efficiency champion (start here)

What it is. An 82-million-parameter TTS model from "hexgrad," built on a StyleTTS-2-derived architecture. It is astonishingly small for its quality and has repeatedly ranked near the top of open-source models in the TTS-Arena blind-listening leaderboard despite having far fewer parameters and less training data than competitors.

License. Apache 2.0 — for both code and weights. This is the cleanest license in this entire chapter. You can ship Kokoro in a commercial product with no fees and no non-commercial trap. For the reader's "free / near-free, ship it" goal, this matters enormously.

Hardware. This is the headline: Kokoro runs comfortably on CPU and Apple Silicon, faster than real-time. No GPU required. The kokoro-onnx runtime generates speech well above real-time on a modern laptop CPU, and the mlx-audio package gives native Apple-Silicon acceleration on M-series Macs. On any consumer GPU it is effectively instant. RAM footprint is tiny (the model is well under 350 MB).

Speed. Sub-real-time on CPU; on GPU the RTF is a small fraction (think generating minutes of audio per second). For a read-aloud feature on a laptop, this is the only model in the list you can take for granted.

Voices & cloning. Kokoro ships a set of pre-built voices (American/British English voices like af_heart, af_bella, am_michael, plus British and several other languages' voices). It does not do arbitrary zero-shot voice cloning from a reference clip — you pick from the bundled voice packs (which can be blended). For "read my text in a pleasant standard voice," that's exactly enough; for "read it in my cloned voice," look at F5-TTS / Chatterbox / XTTS instead.

English quality. Excellent for the size — clean, natural, well-paced narration. It is not the most expressive model (less dramatic range than Orpheus or Chatterbox), but it is consistent, artifact-light, and rarely embarrasses itself on long text — ideal traits for reading documents.

Czech status. Kokoro is multilingual-ish via phoneme packs and exposes lang codes, but Czech is not a first-class, well-supported language and Czech quality is unverified/weak. Treat Kokoro as an English (and a handful of major languages) model. See 05b.

Install + hello world (pip route):

pip install kokoro soundfile
# Phonemizer backend (Linux/WSL):
sudo apt-get install -y espeak-ng
# macOS: brew install espeak-ng

from kokoro import KPipeline
import soundfile as sf

pipeline = KPipeline(lang_code='a')          # 'a' = American English, 'b' = British
text = "Hello — this is Kokoro reading your text aloud. It runs on a plain laptop CPU."

# Kokoro yields audio in chunks; concatenate or write per chunk.
for i, (graphemes, phonemes, audio) in enumerate(pipeline(text, voice='af_heart')):
    sf.write(f'kokoro_{i}.wav', audio, 24000)

CPU/ONNX route (no PyTorch, smallest footprint):

pip install kokoro-onnx soundfile
# Download kokoro-v*.onnx and voices-*.bin from the kokoro-onnx releases page first.

import soundfile as sf
from kokoro_onnx import Kokoro

kokoro = Kokoro("kokoro-v1.0.onnx", "voices-v1.0.bin")
samples, sr = kokoro.create("Hello from the ONNX runtime.", voice="af_heart", speed=1.0, lang="en-us")
sf.write("kokoro_onnx.wav", samples, sr)

Verdict: For the reader's English + free + runs-anywhere requirement, Kokoro is the default recommendation. Apache-2.0, CPU-friendly, genuinely natural. Its only real limits are no zero-shot cloning and weak Czech.

2. F5-TTS — best free zero-shot voice cloning (with a license asterisk)

What it is. A non-autoregressive flow-matching TTS using a Diffusion Transformer (the paper's title: "A Fairytaler that Fakes Fluent and Faithful Speech with Flow Matching"). It does zero-shot voice cloning from a few seconds of reference audio plus its transcript, and the English output is among the best-sounding open clones available.

License — read carefully. The code is MIT, but the released checkpoints were trained on the Emilia dataset, which is CC BY-NC 4.0 (non-commercial). In practice that means the pretrained weights carry a non-commercial cloud over commercial deployment. For a personal/free project this is fine; for a product you sell, this is a real legal blocker unless you retrain on permissively licensed data. Do not skip this.

Hardware. F5-TTS effectively wants a GPU. It runs on CPU but slowly (long generations become impractical). A GPU with ~8–12 GB VRAM is a comfortable target; it works on less for short clips. On Apple Silicon it can run via PyTorch MPS but expect modest speed.

Speed. On a modern GPU, RTF is roughly ~0.15–0.3 (several times faster than real-time) for typical sentences; diffusion sampling steps trade speed for quality. On CPU, RTF climbs well above 1 — not ideal for interactive read-aloud.

Voices & cloning. Pure zero-shot cloning — give it ref.wav + the reference transcript and it speaks your gen_text in that voice. Quality of the clone depends heavily on clean reference audio. No bundled "stock" voices in the Kokoro sense; you supply the voice.

English quality. Very high — natural prosody and convincing timbre transfer. It is one of the strongest open models for "clone this narrator and read my book in their voice." It can occasionally hallucinate or repeat on awkward inputs (a known flow-matching failure mode), so add normalization/chunking for long documents.

Czech status. The base English checkpoint is English-centric; community fine-tunes exist for some languages (e.g., a Spanish-F5), but Czech support is not official and is unverified. See 05b.

Install + hello world:

conda create -n f5-tts python=3.10 -y && conda activate f5-tts
pip install f5-tts

# CLI (simplest):
f5-tts_infer-cli \
  --model F5TTS_v1_Base \
  --ref_audio "ref.wav" \
  --ref_text "This is the transcript of the reference clip." \
  --gen_text "Now read my text in this cloned voice." \
  --output_dir out/

# Python API:
from f5_tts.api import F5TTS
f5 = F5TTS()   # downloads the base checkpoint on first run
wav, sr, _ = f5.infer(
    ref_file="ref.wav",
    ref_text="This is the transcript of the reference clip.",
    gen_text="Now read my text in this cloned voice.",
    file_wave="f5_out.wav",
)

Verdict: Best free local cloning for English — but the non-commercial weights make it a personal-project pick, not a ship-it-commercially pick, unless you retrain.

3. Orpheus-3B — most expressive / human-like (needs a GPU)

What it is. An LLM-based TTS from Canopy Labs built on a Llama-3B backbone. It targets the most human-sounding, emotionally expressive speech in the open-source field, with inline emotion tags and zero-shot cloning. There's a finetuned voice set (tara, leah, jess, leo, dan, mia, zac, zoe) plus a pretrained base.

License. Apache 2.0 — clean for commercial use (a big advantage over F5-TTS). Verify the specific checkpoint card, but the project is Apache-licensed.

Hardware. This is a 3-billion-parameter LLM, so it needs a GPU. Plan for roughly ~10–16 GB VRAM at fp16 (less with quantized GGUF builds via the community orpheus-tts-local + llama.cpp route). It is not a CPU/laptop model in its full form; the quantized local builds make it possible on smaller hardware but with quality/speed trade-offs.

Speed. Designed for low-latency streaming (~200 ms time-to-first-audio claims via vLLM). Throughput is good on a capable GPU; on weak hardware it is sluggish.

Voices & cloning. Named finetuned voices + zero-shot cloning, plus emotion tags embedded in text:

<laugh> <chuckle> <sigh> <cough> <sniffle> <groan> <yawn> <gasp>

English quality. Among the most lifelike and emotive open models — great for expressive narration, characters, and dialogue where you want laughs/sighs/breathing. For dry document read-aloud it can be more expressive than necessary, but it's a top pick when "sounds real and alive" is the priority and you have a GPU.

Czech status. English-first. Multilingual research releases have appeared, but Czech is unverified. See 05b.

Install + hello world (GPU / vLLM route):

pip install orpheus-speech   # pulls vLLM; CUDA GPU expected

from orpheus_tts import OrpheusModel
import wave

model = OrpheusModel(model_name="canopylabs/orpheus-3b-0.1-ft")
tokens = model.generate_speech(
    prompt="Hello <chuckle> this is Orpheus reading your text with real emotion.",
    voice="tara",
)
with wave.open("orpheus.wav", "wb") as wf:
    wf.setnchannels(1); wf.setsampwidth(2); wf.setframerate(24000)
    for chunk in tokens:
        wf.writeframes(chunk)

For low-VRAM machines, see the community orpheus-tts-local project, which runs quantized GGUF weights through an LM server (LM Studio / llama.cpp) and decodes audio tokens with SNAC.

Verdict: Most human/emotive English and a clean Apache-2.0 license — but it is a GPU model. If you have the VRAM and want expressiveness, this is the prestige pick.

4. Chatterbox — best "ElevenLabs-killer" claim, emotion dial, MIT (English; multilingual variant)

What it is. Resemble AI's open-source SoTA TTS (~0.5B, Llama-backed), with zero-shot cloning, a unique exaggeration / emotion-intensity control, and built-in Perth watermarking. Resemble's own blind tests claimed listeners preferred Chatterbox over ElevenLabs roughly 64% of the time (vendor-run, so treat as marketing-flavored, but it is genuinely strong). A separate Chatterbox Multilingual (23 languages) variant was later released.

License. MIT — for both code and weights, which makes Chatterbox one of the few commercially clean, high-quality, clone-capable models here. This is a meaningful edge over F5-TTS.

Hardware. Prefers a GPU (CUDA). At ~0.5B it is far lighter than Orpheus — a ~6–8 GB VRAM card is comfortable; smaller works for short clips. CPU inference is possible but slow; an Apple-Silicon MPS path exists with moderate performance. A streaming variant (chatterbox-streaming) reduces latency.

Speed. On a decent GPU it is fast enough for interactive use (sub-real-time). On CPU it is not a good read-aloud experience for long text.

Voices & cloning. Zero-shot cloning from a reference clip, plus the exaggeration and cfg_weight dials to push emotional intensity up or calm delivery down — a genuinely useful knob for read-aloud tone.

English quality. Top tier among open models — natural, expressive, and the exaggeration control lets you tune between flat-and-clear (good for documents) and dramatic (good for stories). The Perth watermark is inaudible but present (relevant for provenance/compliance).

Czech status. The original Chatterbox (May 2025) is English-only. The newer Chatterbox Multilingual (v2, Sept 2025) supports 23 languages — Arabic, Danish, German, Greek, English, Spanish, Finnish, French, Hebrew, Hindi, Italian, Japanese, Korean, Malay, Dutch, Norwegian, Polish, Portuguese, Russian, Swedish, Swahili, Turkish, Chinese — and Czech is NOT in that set. So Chatterbox, despite being one of the best models here, does not cover the reader's Czech requirement. It covers Polish and Russian (Slavic neighbors) but not Czech. See 05b.

Install + hello world:

pip install chatterbox-tts

import torchaudio as ta
from chatterbox.tts import ChatterboxTTS

model = ChatterboxTTS.from_pretrained(device="cuda")   # "mps" on Apple Silicon, "cpu" otherwise
wav = model.generate(
    "Hello, this is Chatterbox reading your text.",
    audio_prompt_path="ref.wav",   # optional: clone a voice
    exaggeration=0.5,              # 0 = flat, higher = more emotive
    cfg_weight=0.5,
)
ta.save("chatterbox.wav", wav, model.sr)

Verdict: Best MIT-licensed, clone-capable, expressive English model — the strongest "ship it commercially" pick when you have a GPU. The emotion dial is the differentiator.

5. StyleTTS 2 — research-grade quality, fiddlier to run

What it is. The 2023 model ("Towards Human-Level Text-to-Speech through Style Diffusion and Adversarial Training") that set the open-source quality bar and whose architecture Kokoro descends from. It reports CMOS results that surpass human recordings on single-speaker LJSpeech and match human on multi-speaker VCTK, with strong zero-shot adaptation on LibriTTS.

License. MIT (code and the released models). Commercially clean — though check individual fine-tuned checkpoints' data licenses if you use third-party voices.

Hardware. Lighter than the LLM-based models; runs on modest GPUs (~4–8 GB VRAM) and is workable on CPU for short clips (slower). It is not as plug-and-play as Kokoro: the repo expects you to wire up phonemizer, models, and config, so the setup is the friction point, not the hardware.

Speed. Fast on GPU (it's a comparatively small, non-LLM model). RTF well under 1 on GPU.

Voices & cloning. Pre-trained single/multi-speaker checkpoints plus zero-shot style/voice adaptation from reference audio. Style diffusion lets you sample varied deliveries.

English quality. Outstanding — still among the most natural-sounding open English TTS for clean inputs. In practice, Kokoro packages StyleTTS-2-class quality with vastly easier installation, which is why most builders now reach for Kokoro unless they specifically need StyleTTS 2's cloning/style controls or want to fine-tune.

Czech status. English/standard-dataset focused; no first-class Czech support, would require training your own. See 05b.

Install + hello world (source route):

git clone https://github.com/yl4579/StyleTTS2.git
cd StyleTTS2
pip install -r requirements.txt
sudo apt-get install -y espeak-ng       # phonemizer backend
# Download a pretrained checkpoint (e.g., LibriTTS) into Models/ per the README.

# StyleTTS 2 has no single one-liner API; inference goes through the repo's
# notebook/utils (load config + model, phonemize text, run the diffusion sampler).
# See Demo/Inference_LibriTTS.ipynb in the repo for the canonical minimal example.

Verdict: Top quality, MIT, but high setup friction. For most readers, Kokoro is the easier on-ramp to the same lineage; reach for StyleTTS 2 directly only if you need its cloning/style features or plan to fine-tune.

6. XTTS-v2 — the one with real, official Czech (but non-commercial license)

What it is. Coqui's multilingual voice-cloning model. Coqui (the company) shut down in early 2024, but the model lives on and the codebase is maintained as the Idiap coqui-tts fork. XTTS-v2 clones a voice from ~6 seconds of reference audio and supports cross-language cloning.

Why it's in an "English" chapter. Because it is the most relevant bridge to the reader's Czech requirement: XTTS-v2 officially lists Czech among its 17 languages (English, Spanish, French, German, Italian, Portuguese, Polish, Turkish, Russian, Dutch, Czech, Arabic, Chinese, Japanese, Hungarian, Korean, Hindi). Its English is good (not class-leading vs. 2025 models), but its native Czech support is rare and valuable — covered properly in 05b.

License — the catch. Coqui Public Model License (CPML), which is non-commercial. Like F5-TTS, this makes XTTS-v2 fine for personal/free use but a blocker for a paid product. Note the distinction: the code fork is Mozilla-style permissive, but the XTTS-v2 weights are CPML non-commercial.

Hardware. Runs on GPU comfortably (~4–6 GB VRAM) and on CPU acceptably for short-to-medium text (slower but usable — better CPU behavior than the LLM-based models). Apple-Silicon CPU works; MPS support is partial.

Speed. Sub-real-time on GPU; on CPU expect roughly real-time-ish for short clips, slower for long passages. Reasonable for a read-aloud feature on a modest machine.

Voices & cloning. Zero-shot cloning from ~6 s reference, in any of the supported languages, with cross-lingual transfer (clone an English voice, read Czech text). 24 kHz output.

English quality. Solid and natural, though the 2025 generation (Chatterbox/Orpheus/F5) generally edges it on raw English realism. Where XTTS-v2 wins is breadth + official Czech.

Install + hello world:

pip install coqui-tts          # maintained Idiap fork (use this, not the archived 'TTS')

from TTS.api import TTS

tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to("cuda")  # or .to("cpu")
tts.tts_to_file(
    text="Hello — and this same voice can also read Czech.",
    speaker_wav="ref.wav",     # ~6+ seconds of clean reference audio
    language="en",             # use "cs" for Czech
    file_path="xtts_en.wav",
)

Verdict: The local model to beat for Czech, and a competent English cloner — but non-commercial weights. For the reader's bilingual, free, personal case it's a front-runner; for a commercial bilingual product the license forces a different plan.

Head-to-head: English read-aloud comparison

RTF and VRAM figures are approximate and hardware-dependent; treat them as planning guidance, not guarantees.

Decision shortcuts for the reader's English need

• "I want it free, natural, and to run on my laptop with no GPU, and I might sell the product." → Kokoro-82M. Apache-2.0, CPU/Apple-Silicon, genuinely natural. The single best fit for the stated sweet spot — as long as you can live without zero-shot cloning and don't need Czech from this model.
• "I want to clone a specific narrator's voice for English and it's a personal/free project." → F5-TTS (best free clone quality) — but non-commercial weights.
• "I want to clone a voice AND ship commercially, and I have a GPU." → Chatterbox (MIT, expressive, emotion dial).
• "I want the most human, emotive English and I have a beefy GPU." → Orpheus-3B (Apache-2.0, but VRAM-hungry).
• "I need English and Czech from one local model, personal use." → XTTS-v2 (official Czech; non-commercial license).
• StyleTTS 2 is the research-grade quality reference, but Kokoro usually delivers the same lineage with far less setup pain.

A note on long-document read-aloud (all models)

For reading your texts — paragraphs, documents, articles — every model above needs a text pipeline around it, not just raw inference:

1. Normalize text (expand numbers, abbreviations, dates, symbols) before synthesis — TTS models read "$5" or "Dr." inconsistently.
2. Chunk by sentence/paragraph and synthesize per chunk, then concatenate. This avoids long-context drift (especially with F5-TTS / Orpheus, which can repeat or hallucinate on very long inputs) and lets you stream audio as it's produced.
3. Add a small silence between chunks for natural pacing.
4. Cache generated audio keyed by (text-hash, voice, settings) so re-reads are instant and free.

These four steps matter more for perceived quality than the choice between two close models.

Key Takeaways

• Kokoro-82M is the default English pick for the reader's brief: Apache-2.0 (commercial-safe), runs faster-than-real-time on plain CPU and Apple Silicon, no GPU needed, and sounds genuinely natural. Its limits are no zero-shot cloning and weak Czech.
• License is as decisive as quality. Kokoro (Apache-2.0), Orpheus (Apache-2.0), Chatterbox (MIT), and StyleTTS 2 (MIT) are commercially clean. F5-TTS weights and XTTS-v2 weights are non-commercial — fine for a personal/free project, blockers for a paid product.
• For voice cloning: F5-TTS = best free English clone (NC weights); Chatterbox = best commercially-licensed clone with an emotion-intensity dial; XTTS-v2 = easiest cross-lingual clone and the only one with official Czech.
• Orpheus-3B is the most lifelike/emotive but is a 3B LLM that needs a GPU (~10–16 GB); not a laptop model in full form.
• GPU vs CPU reality: Kokoro and XTTS-v2 are CPU-viable; StyleTTS 2 is CPU-ok for short clips; F5-TTS, Chatterbox, and Orpheus really want a GPU for usable read-aloud speed.
• Czech is weak across the board here — only XTTS-v2 has official Czech. Chatterbox Multilingual's 23 languages do not include Czech (it has Polish/Russian, but not Czech); the rest are English-first with no verified Czech. English-grade these models freely; for Czech, XTTS-v2 is the local front-runner — defer to chapter 05b before committing.
• Wrap any model in a text pipeline (normalize → chunk → concat → cache) — it improves long-document read-aloud more than swapping between two close models.

Key References

• hexgrad. Kokoro-82M (Hugging Face model card). 2024–2025. https://huggingface.co/hexgrad/Kokoro-82M — Apache-2.0 license, 82M params, voice list, multilingual notes.
• hexgrad. kokoro (GitHub). 2025. https://github.com/hexgrad/kokoro — pip package, KPipeline usage, language codes.
• thewh1teagle. kokoro-onnx (GitHub). 2025. https://github.com/thewh1teagle/kokoro-onnx — CPU/ONNX runtime, faster-than-real-time inference on laptops.
• Blaizzy. mlx-audio (GitHub). 2025. https://github.com/Blaizzy/mlx-audio — native Apple-Silicon (MLX) acceleration for Kokoro and others.
• SWivid. F5-TTS (GitHub) and Chen et al., F5-TTS: A Fairytaler that Fakes Fluent and Faithful Speech with Flow Matching, arXiv:2410.06885. 2024. https://github.com/SWivid/F5-TTS / https://arxiv.org/abs/2410.06885 — flow-matching cloning, MIT code, Emilia (CC BY-NC) weights, install/CLI.
• Canopy Labs. Orpheus-TTS (GitHub) and orpheus-3b-0.1-ft (HF card). 2025. https://github.com/canopyai/Orpheus-TTS / https://huggingface.co/canopylabs/orpheus-3b-0.1-ft — Llama-3B backbone, Apache-2.0, emotion tags, named voices, vLLM streaming.
• isaiahbjork. orpheus-tts-local (GitHub). 2025. https://github.com/isaiahbjork/orpheus-tts-local — quantized GGUF/llama.cpp route for lower-VRAM machines.
• Resemble AI. chatterbox (GitHub) and chatterbox model card (HF). 2025. https://github.com/resemble-ai/chatterbox / https://huggingface.co/resemble-ai/chatterbox — MIT, ~0.5B, exaggeration control, Perth watermark, ElevenLabs preference claim.
• Resemble AI. Chatterbox Multilingual — Open Source Text-to-Speech. 2025. https://www.resemble.ai/learn/models/chatterbox-multilingual — 23-language variant (Sept 2025); language list confirms Czech is NOT supported (Polish/Russian are).
• yl4579. StyleTTS2 (GitHub) and Li et al., arXiv:2306.07691. 2023. https://github.com/yl4579/StyleTTS2 / https://arxiv.org/abs/2306.07691 — MIT, human-level CMOS on LJSpeech/VCTK, style diffusion, zero-shot adaptation.
• Coqui / Idiap. XTTS-v2 (HF card) and coqui-ai-TTS fork (GitHub). 2023–2025. https://huggingface.co/coqui/XTTS-v2 / https://github.com/idiap/coqui-ai-TTS — 17 languages incl. Czech, ~6 s cloning, CPML non-commercial license, maintained fork.
• BentoML. Comparing Open-Source Text-to-Speech Models (2025). 2025. https://www.bentoml.com/blog/comparing-open-source-text-to-speech-models — cross-model comparison of quality, deployment, and performance.
• TTS-AGI. TTS Arena / TTS Arena V2 (Hugging Face Spaces). 2024–2025. https://huggingface.co/spaces/TTS-AGI/TTS-Arena — community blind-listening Elo leaderboard placing Kokoro, StyleTTS 2, and others against proprietary models.