Kokoro Proves the Best Small TTS Model Is Not a Language Model

One of the most downloaded small TTS models is not a language model at all. We profiled where its time goes and why your first sound arrives late.

SnackOnAI Engineering | Senior AI Systems Researcher | Technical Deep Dive | October 23, 2026

The promise: by the end of this issue you will understand how Kokoro gets broadcast quality narration out of 82 million parameters and about $1,000 of training compute, where its compute actually goes, and when its design makes it the wrong choice.

The fence: we cover the kokoro inference library, the Kokoro-82M model card and voice list, the misaki G2P engine, and the two papers it builds on: StyleTTS 2 and iSTFTNet. We skip training code (not released) and the Chinese v1.1 variant except in passing; quality judgments come from the model card and community reports.

Kokoro-82M is an open weight TTS model by the developer hexgrad, released as v1.0 on January 27, 2025, under Apache 2.0. You give it text and pick a preset voice; it returns 24 kHz audio. There is no voice cloning: the 54 voices are fixed.

Around it sits a large ecosystem: kokoro.js for the browser, community ONNX exports, an OpenAI compatible FastAPI server, and TensorRT builds. The model card even warns that look alike "kokoro" domains are unaffiliated and likely scams, which tells you how popular it got.

Kokoro is a parallel synthesizer. It reads the whole utterance, predicts a duration for every phoneme, expands the phonemes into a time grid, and decodes all frames in one forward pass. No step depends on a previous output.

Caption: Everything above the decoder is bookkeeping for time. The decoder, 65% of the parameters, turns a fixed grid of frames into audio in one shot.

Four design decisions do the work.

One: explicit durations instead of attention alignment. Autoregressive TTS learns alignment implicitly and can skip or repeat words. Kokoro predicts integer frame counts per phoneme, then builds a hard alignment matrix. Words cannot be skipped, and speed control is a division: duration / speed.

Two: phonemes, not text. misaki converts text to IPA with dictionaries, spaCy part of speech tags for homographs, and an espeak-ng fallback. You can override pronunciation inline: [Kokoro](/kˈOkəɹO/). The model's vocabulary is just 178 symbols.

Three: style as a vector, not a prompt. StyleTTS 2 samples style with a diffusion model; Kokoro drops the diffusion and ships precomputed style vectors. Each voice file stores one 256 number vector per utterance length, half for timbre (fed to the decoder), half for prosody (fed to the duration and pitch predictors). Voices mix by averaging: voice="af_bella,af_sky".

Four: an iSTFT vocoder. Instead of upsampling all the way to waveform samples with convolutions, iSTFTNet upsamples 60x, predicts a small spectrum (11 frequency bins of magnitude and phase), and lets an inverse STFT do the last 5x. That removes the most expensive late convolution layers.

First, the real API, from the README.

Caption: Chunks are your unit of latency. For espeak languages like Hindi, the pipeline warns that automatic chunking is not implemented, so split on newlines yourself or long text is truncated at 510 phonemes.

Second, the core of inference, from kokoro/model.py. This is the whole trick of non autoregressive TTS in ten lines.

Caption: Duration is a sum of 50 sigmoids, so each phoneme lasts at most 50 frames (1.25 s). After this, every frame is known in advance and the decoder can run them all in parallel.

Third, our profiler. The Hugging Face weights are blocked from our sandbox, so we built KModel from the published config.json with random weights (identical shapes, so identical compute) and timed each stage, fixing durations at 3 frames (75 ms) per phoneme, a normal English speaking rate.

Caption: The language understanding part (PL-BERT) is 1% to 5% of runtime. Kokoro's cost is almost entirely the vocoder, and it grows with seconds of audio, not with text.

Input: a 150 phoneme English paragraph (about two sentences) with voice af_heart, on 2 vCPUs of a 2.8 GHz cloud Xeon, plain PyTorch.

Step one, G2P. misaki produces IPA, looking up a gold and silver lexicon first and falling back to espeak-ng for unknown words.

Step two, style. The pipeline picks row 149 of the voice pack, a 256 number vector tuned for utterances of that length.

Step three, durations. At about 3 frames per phoneme, 150 phonemes become 450 frames, 11.2 seconds of speech.

Step four, decode. The decoder turns 450 frames into 270,000 samples in one pass. Total time 6.7 s, of which 95% is the decoder.

Output: 11.2 seconds of audio, but nothing plays until 6.7 seconds have passed, because the chunk is generated as a whole.

Caption: The same model spans 0.9x to 50x depending on runtime. Parallel decoding is why GPUs help Kokoro far more than they help autoregressive CPU models.

Why it works. Most TTS failures (skipped words, repeated phrases, runaway generations) come from implicit alignment in autoregressive models. Kokoro removes alignment as a learning problem: durations are explicit, the grid is fixed, and the decoder only has to render. That makes an 82M model stable enough for audiobooks, and parallel enough to saturate a GPU. Training on a few hundred hours of carefully curated audio, including synthetic speech from commercial TTS providers, gave consistent, clean target voices for about $1,000 of compute.

What it trades away.

Insight One: Kokoro is a vocoder with a small front end attached. "82M parameters" invites comparison with tiny language models, but the language part is the smallest piece. PL-BERT runs 12 layers with one shared ALBERT weight set of just 6.3M parameters and takes 1% to 5% of CPU time in our profile. The decoder holds 65% of parameters and 89% to 98% of time. If you want Kokoro faster on CPU, quantizing or pruning the text side buys almost nothing. The convolutional decoder is the whole game.

Insight Two: "faster on CPU" depends on what you measure. Community comparisons often call Kokoro faster than streaming models like Pocket TTS. On the same 2 vCPU machine in plain PyTorch, we measured Kokoro at 1.7x real time and Pocket TTS at 1.9x, close enough that runtime choices decide the winner. The bigger difference is latency shape: Pocket TTS plays its first 80 ms after one frame, while Kokoro plays nothing until the full chunk is rendered. For voice agents, choose chunk size first and model second.

Two very different small TTS designs, Kokoro (parallel, duration based) and Pocket TTS (autoregressive, continuous latents), hit the same wall: the waveform decoder. In our Kokoro profile it takes 95% of runtime for a normal paragraph. The next big win in on device speech will come from cheaper vocoders, not smarter text models.

Think about how a choir director might prepare a song. Before anyone sings, the director marks on the sheet music exactly how long each syllable lasts, where the pitch rises and falls, and how loud each part should be. Once that plan is written down, the whole choir can sing the entire piece at once.

Kokoro works the same way. First, it turns your text into speech sounds, the small units like "k" and "oh" that make up words. Then it decides how long each sound should last and how high or low the voice should go. Only after that full plan exists does it produce the actual audio, all in one go.

This makes it very reliable. It does not lose its place or repeat words, a common problem with other AI voices. It is also small and cheap: it was trained for about a thousand dollars and can run on a regular computer.

The catch is waiting. Because Kokoro creates a whole passage at once, you hear nothing until that passage is finished. On a powerful graphics card that wait is tiny, but on a basic laptop it can be several seconds. And most of the work is not understanding your words; it is the final step of turning the plan into actual sound waves.

Kokoro showed that a small team with $1,000 of compute, careful data, and an unglamorous architecture could ship the voice that a large share of local agents and apps now use. Its strengths come from refusing to be a language model: explicit durations, fixed voices, one parallel pass. Its weaknesses come from the same place: no cloning, all or nothing chunks, and a decoder that eats nearly all the compute. Use Kokoro for narration, batch generation, and GPU servers. For interactive CPU voice agents, measure time to first audio before you commit.

If you have paid time left on an individual Granola plan, we'll match it with a Wispr Flow subscription that includes Notetaker and dictation, and add bonus time, up to 12 months total. Sign in or create a Wispr account and submit proof of your plan to check eligibility.

Try Notetaker Free