Kokoro 82M: A Small TTS Model With a Big Voice

Most text-to-speech problems aren't about the voice. They're about everything around it. The narration has to come back fast enough that a user doesn't stare at a spinner, it has to sound like a person and not a GPS from 2009, and it has to run thousands of times a day without anyone thinking about it. Big expressive voice models are wonderful at the second part. They're often overkill for the first and third.

Kokoro 82M is the opposite bet. It's an open text-to-speech model from hexgrad with 82 million parameters, which is tiny by current standards, and it still sounds good enough that people keep searching for it by name. Small is the feature here, not the compromise. This post covers what Kokoro 82M actually is, where a small TTS model beats a big one, how to get clean results from it, and where you should reach for something heavier instead.

What Kokoro 82M Actually Is

Start with the spec, because it explains everything else. According to hexgrad's model card, Kokoro is an open-weight TTS model with 82 million parameters, built on the StyleTTS 2 architecture with an ISTFTNet vocoder. There's no diffusion step, and hexgrad has released only the decoder. It's released under the Apache 2.0 license, which is about as permissive as model licenses get, so it fits commercial projects as comfortably as weekend experiments.

The training story is unusually transparent too. hexgrad says the model was trained on a few hundred hours of permissive or non-copyrighted audio: public domain recordings, Apache and MIT licensed audio, and synthetic speech. The first public version, v0.19, landed on December 25, 2024, and v1.0 followed on January 27, 2025, expanding the release from one language and ten voices to eight languages and 54 voices.

The model card's own pitch is that Kokoro delivers quality comparable to larger models while being significantly faster. That's a claim worth testing on your own scripts, and the rest of this post is about how to do exactly that.

Why a Small TTS Model Wins More Often Than You'd Think

Here's the uncomfortable truth about voice in products: most of the speech your app generates is boring. Order confirmations. Article read-alouds. Onboarding tips. Accessibility narration for a dashboard. Nobody needs a model that can whisper, sob and switch accents mid-sentence for that. They need clear, natural, consistent speech that comes back quickly and doesn't fall over at volume.

That's the job Kokoro 82M was built for. A model this size is fast by nature, which matters most in places where latency is the product: a reading app that starts speaking the moment you tap play, an in-game helper that answers without a pause, a real-time audio feature in a web app. Speed also changes how you work. When a generation comes back almost immediately, you stop treating voice as a precious render and start treating it like any other API response you can regenerate at will.

The second argument is predictability. A compact model with a fixed set of preset voices does one thing and does it the same way every time. For product teams that's a gift. The voice that read your first tutorial is the same voice that reads the hundredth one, and you never have to explain to support why the narrator suddenly sounds annoyed.

Kokoro 82M on each::labs: The Inputs

On each::labs, Kokoro runs behind the same API as every other model in the catalog, and the request is refreshingly short. There are three inputs, and that's the whole surface.

text is the script. It's the only required field, and long text is automatically split into smaller chunks before synthesis, so you can pass a full article without writing your own splitter. voice picks one of 11 preset English voices. speed is a multiplier where 1 is natural pace, 0.5 is half speed and 2.0 is double.

A minimal request looks like this:

{
  "model": "kokoro-82m",
  "input": {
    "text": "Your order is on its way. It should arrive on Thursday afternoon.",
    "voice": "af_bella",
    "speed": 1
  }
}

That's it. No sample rate, no emotion tags, no prompt engineering. If you've been fighting a voice model with forty parameters, this will feel almost suspicious.

Pick the Voice Before You Write the Script

The voice names follow a simple code. The first letter is the accent (a for American English, b for British English), the second is the gender (f or m), and the rest is the name. On each::labs you get af (the default), af_bella, af_sarah, af_nicole, af_sky, am_adam, am_michael, bf_emma, bf_isabella, bm_george and bm_lewis.

They are not equal, and hexgrad says so openly. Its voice notes for the current release grade each voice on quality, and they spread wide: af_bella sits at the top with an A minus, bf_emma and af_nicole land around B minus, and some voices that had only minutes of training data grade far lower. The endpoint on each::labs uses its own voice set, so treat those grades as a hint, not a verdict. Still, the lesson holds. Don't pick a voice because you like the name. Run the same two paragraphs of your real copy through every voice, listen on the speakers your users will actually have (a phone speaker, the earbuds that came in the box), and keep the one that survives.

Then lock it. Brand consistency in audio is like brand consistency in a logo: it only works if nobody improvises. Put the chosen voice id in config, not in a prompt someone will tweak later.

Write for the Ear, Not the Page

Kokoro doesn't take style instructions, so all of your control lives in the text itself. That sounds limiting. In practice it's the oldest skill in audio production: write the way people talk, and the voice follows.

Keep sentences short enough to say in one breath. Spell out the things a reader would expand in their head. Punctuation does the directing: a full stop gives a clear pause, a comma a small one, and a question mark changes the melody. Compare these two inputs for a fitness app:

Workout 3/5: 45s on, 15s off x 8. Go!

Workout three of five. Forty-five seconds on, fifteen seconds off. Eight rounds. Ready? Go.

The first one is fine on a screen and awkward out loud. The second one sounds like a coach. Same information, completely different result, and the model didn't change at all.

Length matters more than most people expect. hexgrad's notes say the voices perform best in a "goldilocks range" of roughly 100 to 200 tokens, that very short inputs of under 10 to 20 tokens get weaker, and that long passages above roughly 400 tokens can start to sound rushed. each::labs splits long text for you, but you'll still get better narration if you hand it paragraph-sized pieces on purpose and stitch the audio together, rather than throwing one giant wall of text at it.

Fix the tricky words before they reach the model, too. Unusual names, acronyms, numbers with units and mixed-language words are where any TTS voice trips, so write "twenty twenty-six" if the year must sound a certain way, spell product names phonetically when you need to, and keep a short list of words your pipeline always rewrites.

Where Teams Actually Use Kokoro 82M

The pattern is clear once you look for it: anywhere speech is high-volume, functional and English, a small model earns its place.

A content team turns every published article into a listen-along version. The script is the article, cleaned up for the ear (no "see the table below", no raw URLs), split by paragraph and voiced with one house voice. A product team adds spoken onboarding to a mobile app, a dozen short lines that need to sound warm and consistent across releases. An education startup voices thousands of vocabulary cards and comprehension questions, where speed and consistency matter far more than drama. A game studio prototypes NPC dialogue with placeholder voices, so writers can hear scenes long before casting real actors.

Kokoro also slots neatly into bigger pipelines. Generate the narration first, then pair it with visuals: a talking avatar through a photo-to-talking-video lipsync flow, or a voiceover laid under a product clip. Because every step is a model call on the same platform, you can chain them in an each::labs flow instead of gluing three integrations together.

Kokoro 82M vs Bigger Voices on each::labs

Picking a TTS model is a question of what the line has to do. Kokoro 82M is the right call when you need clean English narration with preset voices and want it fast and predictable. It's the wrong call when the voice has to perform, or when it has to speak anything but English: the 11 voices on each::labs are American and British English, so a Turkish, Spanish or Japanese product should start with a multilingual model.

If you need emotion and fine control, MiniMax Speech 2.8 Turbo takes an explicit emotion setting (happy, sad, surprised and more), pitch shifts, inline pause markers and pronunciation overrides, plus language boosts for a long list of languages. If you're building interactive characters, Inworld TTS 1.5 is designed for low latency and real-time use, with mini and max variants, a set of named voices and timestamp output you can use to sync captions or mouth movement. And if you need a specific person's voice, XTTS v2 clones a voice from a short sample and speaks it in a wide set of languages, including Turkish, Arabic and Polish.

The smart setup isn't loyalty to one of them. It's routing: Kokoro for the bulk narration, an expressive model for the lines that carry emotion, a cloning model when the brief says "it has to sound like our founder". You can browse the whole lineup on the text-to-voice models page and switch between them with a model id change.

Getting Started

The fastest way to know whether Kokoro 82M fits is a ten-minute test. Take three real pieces of your copy: one short UI line, one paragraph of narration and one awkward sentence full of numbers and names. Run them through four or five voices on the Kokoro 82M model page, listen on a phone, and pick a winner. If it holds up, wire it in with the same API key you use for image and video. If one of the lines needed more emotion than Kokoro could give, you've just learned which line to route to a bigger voice, which is the whole point of having more than one model in reach. For more background on how voice models differ, see our primer on AI voice generators.

Frequently Asked Questions

Is Kokoro 82M good enough for production text-to-speech?

For clear, functional English narration, yes, and its size is the reason. The model is fast, consistent and released under Apache 2.0. Pick a strong voice, feed it paragraph-length text, and it handles read-alouds, onboarding and educational audio well. Reach for a larger model only when lines need acting.

Which Kokoro 82M voice should I use?

Let your copy decide. hexgrad's own notes rate af_bella as the strongest voice in the current release, with bf_emma and af_nicole close behind, but grades shift between releases and scripts. Run the same real paragraph through several voices on each::labs, listen on a phone speaker and lock the winner in config.

Can Kokoro 82M clone a voice?

No. Kokoro ships preset voices only. For a custom or cloned voice, use XTTS v2 on each::labs, which works from a short audio sample, and keep Kokoro for the high-volume narration around it.

Does Kokoro 82M handle long text?

It does on each::labs, which splits long input into smaller chunks automatically. Quality is still best when each piece is roughly 100 to 200 tokens, so sending paragraph-sized chunks yourself gives you more natural pacing than one huge block.