Part of AI Tools & Automation — automating real work with local AI models.
09_kokoro_benchmark.py · 10 runs per text length · Kokoro 0.9.4 on CPU · AMD PRO W7900 workstation · Windows 11.
Turning text into natural speech no longer needs a cloud API. With local text-to-speech on Windows 11, you generate audio on your own hardware, keep every recording private, and pay nothing per character. This article covers three local engines, then measures the fastest one — Kokoro — with real numbers.
The three engines cover different needs. One is built for raw speed, and two add voice cloning from a short reference. Knowing which to reach for saves a lot of trial and error.
- Local TTS keeps voice data private and removes per-character cloud fees.
- Kokoro synthesised speech at 3.5–4.6× real-time on CPU — no GPU needed.
- For voice cloning from a reference clip, use XTTS-v2 or F5-TTS instead.
- Pick the engine by the job: Kokoro for speed, XTTS-v2 for multilingual cloning.
Why run text-to-speech locally?
Privacy is the first reason. Cloning a voice or narrating internal content means handling audio you do not want on someone else’s server. A local engine keeps every sample on your machine. Cost is the second reason: cloud TTS bills per character, so an audiobook or a batch of narration adds up fast, while a local model is free after setup.
Control is the third reason. You choose the voice, the speed, and the engine, and nothing changes underneath you because a provider updated its API. The trade-off is that you install and manage the models yourself, which this article walks through.
Three paths to local TTS
Each engine occupies a different point on the speed-versus-flexibility scale. The table summarises where each one fits.
| Engine | Strength | Voice cloning | Best for |
|---|---|---|---|
| Kokoro | Very fast, tiny, CPU-friendly | No (preset voices) | High-volume narration, real-time apps |
| XTTS-v2 (Coqui) | Multilingual, clones from a clip | Yes | Cloning a specific voice in many languages |
| F5-TTS | High-quality English, zero-shot | Yes | Best-quality English cloning |
Kokoro TTS — the fast path
Kokoro is a small, open TTS model that runs comfortably on a CPU. It ships a set of natural preset voices and needs no GPU, which makes it the right default for volume work. Installation is two packages:
pip install kokoro soundfileSynthesising speech is a few lines. The pipeline yields audio chunks, which you concatenate and save as a WAV:
import numpy as np, soundfile as sf
from kokoro import KPipeline
pipe = KPipeline(lang_code="a") # American English
text = "Local text to speech runs entirely on your own machine."
audio = np.concatenate([a for _, _, a in pipe(text, voice="af_heart")])
sf.write("output.wav", audio, 24000)Kokoro speed — real benchmark
The benchmark synthesised three text lengths, ten times each, and measured the real-time factor (RTF): audio seconds divided by synthesis seconds. Higher is faster, and anything above 1× beats real-time.
Free ebook
Free AI Video, Generated Locally
Working scripts and measured benchmarks. Free.
No spam. Unsubscribe at any time.
| Text length | Audio produced | Synthesis time | RTF |
|---|---|---|---|
| Short (~12 words) | 4.15 s | 0.90 s | 4.62× |
| Medium (~40 words) | 12.4 s | 3.19 s | 3.88× |
| Long (~90 words) | 28.5 s | 8.07 s | 3.53× |
Kokoro produced audio 3.5 to 4.6 times faster than real-time, entirely on the CPU. Short prompts ran fastest because fixed overhead weighs more on tiny inputs, and the rate settled around 3.5× on longer text. In practice, that means an hour of narration synthesises in roughly fifteen minutes, without touching the GPU.
One honest note on quality. This benchmark reports speed, not a mean opinion score (MOS), because MOS requires human listeners rating naturalness. Kokoro’s preset voices sound clean and natural to most ears, but a fair quality number would need a listening panel, not a synthetic figure.
Turning an article into an audiobook
The speed only matters if it scales, and it does. Split a long document into paragraphs, synthesise each, and concatenate the audio. Because Kokoro runs several times faster than real-time, even a book-length text finishes quickly on the CPU.
import numpy as np, soundfile as sf
from kokoro import KPipeline
pipe = KPipeline(lang_code="a")
paragraphs = open("article.txt", encoding="utf-8").read().split("nn")
chunks = []
for para in paragraphs:
if para.strip():
chunks.append(np.concatenate([a for _, _, a in pipe(para, voice="af_heart")]))
sf.write("audiobook.wav", np.concatenate(chunks), 24000)Feeding paragraph by paragraph keeps memory low and lets you insert short pauses between sections. The same loop turns newsletters, documentation, or blog posts into audio versions, which is a fast way to add an accessibility option to any content.
Choosing voices and adjusting pace
Kokoro ships several preset voices, named by language and speaker, such as af_heart or am_michael. Swapping the voice is a one-word change in the call, so you can A/B two narrators without touching the rest of the pipeline. For pacing, split long sentences and add brief silences between paragraphs, which reads more naturally than a single unbroken stream.
A practical tip: keep numbers and abbreviations spelled out in the source text when clarity matters. TTS engines pronounce “3.5x” and “e.g.” unpredictably, so writing “three and a half times” or “for example” in the input removes the guesswork and produces cleaner audio.
Voice cloning with XTTS-v2
Kokoro does not clone voices. When you need a specific person’s voice, XTTS-v2 from Coqui is the multilingual option. It clones from a short reference clip — around ten seconds of clean audio — and speaks many languages.
from TTS.api import TTS
tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2")
tts.tts_to_file(
text="This sentence is spoken in a cloned voice.",
speaker_wav="reference_voice.wav", # ~10 s of the target voice
language="en",
file_path="cloned.wav",
)Keep the reference recording clean: one speaker, no background noise, and a normal speaking pace. The quality of the clone follows the quality of that clip more than any other setting.
F5-TTS — best-quality English cloning
F5-TTS is a newer, zero-shot engine focused on high-quality English. It also clones from a reference, and many listeners rate its naturalness above XTTS-v2 for English. It runs from a command-line inference tool:
pip install f5-tts
f5-tts_infer-cli --model F5TTS_v1_Base
--ref_audio reference_voice.wav
--gen_text "High quality English speech from a short reference."Choose F5-TTS when English quality is the priority and XTTS-v2 when you need breadth across languages. For pure throughput with preset voices, neither beats Kokoro.
Choosing an engine
Match the engine to the task. For audiobooks, IVR prompts, or any high-volume narration with a fixed voice, Kokoro wins on speed and simplicity. For cloning a specific voice across languages, use XTTS-v2. For the most natural English clone, try F5-TTS. Many pipelines use two: Kokoro for bulk narration and one cloning engine for the moments that need a particular voice.
Real-world use cases
- Audiobooks and narration: turn long documents into audio at several times real-time.
- Accessibility: add a private, offline screen-reader voice to your own tools.
- Voice assistants: generate spoken replies locally, with no network round trip.
- Localisation: clone one voice and speak it across languages with XTTS-v2.
Frequently asked questions
Does Kokoro need a GPU?
No. It ran at 3.5–4.6× real-time on the CPU in this test. A GPU can help for very large batches, but it is not required for smooth, faster-than-real-time synthesis.
Can Kokoro clone my voice?
No. Kokoro uses preset voices. For cloning from a reference clip, use XTTS-v2 or F5-TTS instead.
How much audio can I generate per hour?
At roughly 3.5× real-time, about three and a half hours of speech per hour of compute on CPU — and more on shorter prompts, where Kokoro reaches 4.6×.
Which languages are supported?
Kokoro focuses on a set of high-quality preset voices, while XTTS-v2 is the multilingual choice for cloning across many languages. Pick XTTS-v2 when you need broad language coverage.
Is the audio ever uploaded anywhere?
No. Every engine here runs locally, so reference clips and generated audio stay on your machine from start to finish.
Summary
Local text-to-speech on Windows 11 is fast, private, and free to run. Kokoro synthesised speech at 3.5–4.6× real-time on the CPU alone, which makes it ideal for high-volume narration. When you need to clone a specific voice, XTTS-v2 covers many languages and F5-TTS leads on English quality. Reproduce the Kokoro numbers with the script: 09_kokoro_benchmark.py.
Companion code — every script and benchmark from this series lives in one repository: github.com/bestin-it/qwen-local-ai-scripts.
Free ebook
Free AI Video, Generated Locally
Run Wan 2.1 in ComfyUI on your own GPU — the scripts I use, measured times, sample clips. No cloud, no API keys.
No spam. Unsubscribe at any time.
Leave a Reply