The Tool Desk
Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →In one CPU-only benchmark, cutting the same 950-character script into 22 sentences instead of 12 larger chunks reduced Kokoro’s measured throughput by roughly 8%. Piper showed no detectable slowdown in that same test. The result is real for that setup, but it describes one machine, one script, and one pair of engine versions. It does not establish how the two engines compare in general.
What the test measured
The benchmark, published in 2026 by the handle Obole (the author describes themself as an AI), was run on two ARM Neoverse-N1 cores with no GPU. It used a single 950-character script, processed serially in one session. The script was split in two ways: as 12 whole shots, or as 22 sentences. The published article reports three Kokoro passes and four Piper passes. The full protocol and caveats are in the original benchmark article.
As an Amazon Associate I earn from qualifying purchases.
Because the measurements come from one author on one configuration, treat every figure below as that author’s result for that setup, not as an independent replication.
The numbers
| Engine | Segmentation | Reported throughput range | Median compute time |
|---|---|---|---|
| Kokoro | 12 larger chunks | ×0.93 to ×0.95 | 54.90 seconds |
| Kokoro | 22 sentences | ×0.86 to ×0.87 | 60.03 seconds |
| Piper | 12 larger chunks | ×8.38 to ×8.59 | 6.69 seconds |
| Piper | 22 sentences | ×8.50 to ×8.66 | 6.63 seconds |
The throughput ranges are as the author reported them; the article does not describe a separate baseline for each ratio, so compare the Kokoro rows with each other and the Piper rows with each other rather than reading the ratios across engines.
#1 Best Overall
Kokoro: about 8% slower in the sentence condition
Moving from 12 chunks to 22 sentences moved Kokoro’s throughput from roughly ×0.93–×0.95 to roughly ×0.86–×0.87. That is the basis for the headline’s 8%. The compute-time medians show the same direction: 54.90 seconds for the larger chunks and 60.03 seconds for sentences, a difference of 5.13 seconds.
The author spreads that difference across the extra calls. Going from 12 to 22 segments adds 10 calls, so 5.13 seconds over 10 calls works out to about 0.51 seconds per additional call. The author attributes the gap to fixed per-call cost, which is a reasonable reading of the numbers but still the author’s interpretation for this run.
Piper: no detectable effect in this test
Piper’s throughput ranges overlap between the two conditions: ×8.38–×8.59 for the larger chunks and ×8.50–×8.66 for sentences. Its compute-time medians were 6.69 seconds and 6.63 seconds in the same order. The sentence figure is marginally lower, but the difference is well inside the spread between passes, so the honest reading is “no detectable effect in this test.” That is different from saying Piper’s per-call overhead is zero. A measurement this coarse cannot show a cost that is smaller than its own noise.
Why per-call overhead matters for sentence pipelines
A sentence-level pipeline makes more inference calls than a chunked one, so any fixed cost paid per call is multiplied. At about half a second per call, as measured for Kokoro in this setup, a 22-sentence job pays that tax many more times than a 12-chunk job does. For batch narration this may be irrelevant. For a streaming or interactive system that wants to start playback quickly, the tradeoff between shorter segments and fewer calls is a real design decision.
The reverse also holds. Larger chunks reduce per-call overhead but delay the first audio and can make pauses and prosody less controllable. The benchmark measures the throughput side only; it does not measure latency to first audio.
Corrections to the benchmark
The benchmark repository records a correction. An earlier Kokoro figure was withdrawn because its archived data file was missing and its thread count was not recorded. The replacement runs fix the thread count and archive the passes. Use the corrected measurements and their stated conditions, and do not rely on the withdrawn figure. The raw data and correction history are in the benchmark repository.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Limits of the result
- Text and language: the result comes from one 950-character script. Sentence length, punctuation, and language will change how many calls each approach makes and how long each one takes.
- Voice and model versions: the figures apply to the specific Kokoro and Piper versions and voices used. Updates to either engine can shift them.
- Hardware and threads: two ARM Neoverse-N1 cores without a GPU. Thread configuration is part of the result, which is why the corrected runs fix it.
- Output differences: the two engines did not produce audio of identical duration, so the timing comparison does not hold output length constant.
The test supports one specific claim: fine-grained segmentation can carry a measurable per-call cost on some engines and setups. It does not support a general speed ranking of Kokoro against Piper, and it says nothing about voice quality.
Recommended Free Tools
Chunking is a wrapper decision, not only an engine property
The benchmark’s segmentation was the author’s own pipeline condition. Kokoro’s reference pipeline does its own language-specific text processing. In the reference pipeline source, one path splits input on sentence boundaries, while a non-English path forms chunks of roughly 400 characters, using sentence boundaries where possible. An integration built on Kokoro may therefore call inference at a different granularity than the benchmark did, and its per-call count will depend on the language it processes.
How to run a comparison that matches your deployment
- Use the same text, language, and voice for every engine you compare.
- Run on the same machine with the same runtime and thread settings, and record the thread count.
- Measure at the segmentation granularity you will use in production, not the one a benchmark happened to choose.
- Record throughput, absolute time per call, total compute time, and output duration together, since a faster engine can also produce different audio length.
- Check whether your wrapper’s chunking policy matches the reference pipeline’s behavior for your language before you attribute any difference to the engine.
- Repeat the runs enough times to see the spread. Piper’s overlapping ranges show why a single pass can mislead.
The benchmark is a useful warning about granularity. It is not a verdict on which engine to choose.
The article’s headline is accurate for the setup it describes. Splitting this particular text into 22 sentences cost Kokoro roughly 8% of its measured throughput, about 0.51 seconds per additional call, while Piper’s results did not separate from noise. Anyone choosing between these engines should measure with their own text, voice, and chunking policy.
Source for the reference pipeline and its chunking behavior: hexgrad/kokoro, kokoro/pipeline.py.
Do these 3 things before closing this tab:
1Fix the driver behind crashes, sound loss and screen glitches2Repair Windows errors before they cause bigger problems3Scan for outdated or missing drivers - takes under a minuteQuick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
