index-tts vs KittenTTS: cloning a voice on a GPU against eight fixed voices on a CPU

One reference clip against eight named voices

index-tts is built around one mechanism: it clones a voice from a single reference audio clip and then speaks new text in that timbre. You supply a short recording, the model learns the voice from it, and every subsequent synthesis uses it. The repository publishes that path across four model generations, from IndexTTS-1.0 through 1.5, 2 and 2.5, with weights on HuggingFace and ModelScope and a demo page for each.

KittenTTS takes the opposite approach and offers a fixed set. It ships eight named voices, Bella, Jasper, Luna, Bruno, Rosie, Hugo, Kiki and Leo, and you select one by name when you call generate. There is no reference audio and no cloning path in the open-source library. The models are ONNX files of 15 million to 80 million parameters, from a 25 MB int8 build up to an 80 MB mini build.

That difference shows up in the first hour of work rather than in a benchmark. With index-tts you prepare a recording, check that it is clean and free of background noise, and accept that output quality depends on how good that recording is. With KittenTTS you pick a name and start generating. If your product needs the user's own voice or a specific brand voice, index-tts is the one that can produce it from the open-source path; in KittenTTS, custom voices exist only as a commercial engagement, not as a feature in the library.

Five languages with pronunciation control against English read-aloud

IndexTTS-2.5 supports Chinese, English, Japanese, Spanish and Arabic, and the README highlights improved controllability of Chinese Pinyin, English CMU phonemes and Japanese Kana alongside fine-grained emotion control. Speaking speed is a separate dial: duration_factor spans 0.5x to 2.0x duration. The point of a phoneme or Pinyin override is that you can fix a name the model would otherwise mispronounce, which matters the moment the text contains product names, colleagues or place names. A voice you cannot pronounce correctly is not usable for reading a script aloud.

KittenTTS covers English only, and the roadmap still lists multilingual text-to-speech as unreleased. What it has instead is a text preprocessing layer. The function normalize_text expands numbers, currencies, units and abbreviations, and the README shows it rewriting a doctor's name, a sum of money and a clock time into spelled-out words. That is a different class of problem from index-tts. KittenTTS deals with what a string contains before it reaches the model; index-tts deals with how a particular language sounds and how a specific word is pronounced.

The practical split is therefore language and control, not quality. A Mandarin, Japanese or Arabic narration job needs index-tts because KittenTTS cannot speak those languages at all. An English utility that reads stored text aloud, with no special names to get right, can skip index-tts entirely and avoid its hardware and licence.

Getting index-tts and KittenTTS installed

Installing index-tts starts from a source checkout. You clone the repository, install uv because the project says a reliable installation depends on it, and run uv sync --all-extras, which creates a .venv with the right Python and every dependency. The README notes that example audio files are fetched on demand from HuggingFace or ModelScope the first time the WebUI starts, so Git LFS is no longer required, and it points at mirrors for readers in China. One point worth checking early, in our analysis of index-tts: the version in pyproject still reads 2.0.0 while the release notes announce v2.5.0, so a fresh install may not be the release you think it is.

KittenTTS is a wheel and two calls. You need Python 3.8 or later, then install the release artefact, import KittenTTS from the kittentts package, load a model from the Hugging Face Hub with KittenTTS("KittenML/kitten-tts-mini-0.8"), and call generate with a voice name, writing the result out at 24000 samples per second with soundfile. A GPU is optional and lives behind a separate requirements file and a backend argument.

The documented API has two details a reader should notice. The generate function lists a default voice of expr-voice-5-m, which is not one of the eight names the same README prints from available_voices, so pass a voice explicitly. And clean_text defaults to False in generate but True in generate_to_file, meaning the same sentence can be normalised in one path and left alone in the other.

Hardware, deployment and what each costs to run

The hardware gap is the widest one. index-tts is a GPU model, and our analysis lists a CUDA 12.8 environment as a prerequisite for adopting it, along with a reference clip. Its weights come from HuggingFace or ModelScope, and the 2.5 release notes point at a vLLM recipe for production deployment, which tells you how the maintainers expect the model to be served at scale. Inference got faster relative to IndexTTS-2, but the deployment shape is a GPU service that someone has to size and keep running.

KittenTTS is built the other way round. It is ONNX-based and runs efficiently without a GPU, the model weights are between 25 MB and 80 MB on disk, and the library is imported into your own process rather than deployed as a service. Models are pulled from the Hugging Face Hub with a cache_dir you control, so a machine with a small disk can hold one variant rather than the whole set. Concurrency is whatever your application process count allows, and there is no separate server to operate.

There is a third consideration that neither project addresses for you: what happens on a machine with no accelerator and no appetite for a 5 GB download. KittenTTS answers that in one line. index-tts answers it with a smaller footprint on some configurations, but it still assumes a CUDA toolchain.

Where each one falls short

index-tts has three specific weaknesses. The first is the licence. The repository carries a custom licence that GitHub cannot classify, so an automated compliance check reports it as other, and our analysis points at the DISCLAIMER and LICENSE files as the place to confirm that your use of a cloned voice is permitted. A company that ships cloned voices to customers has to read those files rather than trust a label. The second is the version skew between the pyproject metadata and the announced release, which means you should confirm what you actually installed before building on it. The third is the CUDA requirement, which rules out a laptop, a small VM and anything without a recent NVIDIA driver.

KittenTTS has its own set. The README labels it a developer preview and says the APIs may change between releases, so code written against it needs revisiting when you upgrade. The roadmap still lists multilingual text-to-speech as unreleased, which closes off every non-English use. The README also warns that some users have reported issues with the kitten-tts-nano-0.8-int8 model, and our analysis advises verifying that variant on your own text and falling back to kitten-tts-micro-0.8 if it fails. There is no cloning, no emotion control, no phoneme control and no pronunciation overrides. And while the repository was pushed on 2026-10-16, the newest release tag is 0.8.1 from 2026-02-24, which tells you the code moves faster than the releases are cut.

Licence, maintenance and the choice by scenario

Licence is the clearest separator here. KittenTTS is Apache-2.0, which most companies have already approved and which carries an express patent grant. index-tts is a custom licence with no standard identifier, so a company that runs an open-source allowlist has to make a manual decision about it, and the decision turns on what the DISCLAIMER and LICENSE files say about cloned voices and about redistribution.

Maintenance is a tie. Neither repository is archived. index-tts's last push was on 2026-09-29 and it released v2.5.0 on 2026-08-13. KittenTTS's last push was on 2026-10-16 while its newest release stayed at 0.8.1 from February 2026, a pattern consistent with a project that keeps developing while telling users the API can still change.

Choose by what the output has to be. If the voice belongs to a person or a brand, if the script can be in Chinese, Japanese, Spanish or Arabic, or if a name in the script must be pronounced the way the owner of that name says it, index-tts is the only one of the two that can do the job. If the requirement is English speech produced on a CPU, inside an existing application, from weights small enough to ship on a device, KittenTTS is the better fit and the licence question disappears.

Bottom line

Choose index-tts when the voice has to be cloned and the script is multilingual; choose KittenTTS when you need English speech from a CPU with no GPU in the loop. Before committing to index-tts, read the LICENSE and DISCLAIMER files, confirm your CUDA toolkit meets 12.8 and check which version the installer actually pulls; before committing to KittenTTS, generate a paragraph of your own text with kitten-tts-nano-0.8-int8 and fall back to kitten-tts-micro-0.8 if the output comes out wrong.

Sources

1. index-tts/index-tts repository
2. index-tts/index-tts README
3. KittenML/KittenTTS repository
4. KittenML/KittenTTS README