TL;DR

Kitten TTS (KittenML/KittenTTS) became famous in August 2025 as the “25MB CPU-only” text-to-speech model. Its new flagship, KittenTTS 2, is a very different thing: a 1.7-billion-parameter speech language model with ternary (1.58-bit) weights that clones a voice from 5–30 seconds of audio, ships 47 built-in voices and accepts emotion tags like [joyful] and <laugh>. The small ONNX models (15M–80M parameters) are still in the same package.

Facts as of October 19, 2026:

  • 16,173 GitHub stars, 962 forks; on GitHub Trending this week.
  • 91 open issues (issues only, not pull requests).
  • Code license: Apache 2.0. KittenTTS 2 weights: the Stellon Labs Community License, which is not open source (details below). The legacy ONNX weights on Hugging Face are tagged Apache 2.0.
  • Python package: kittenml 0.9.4 on PyPI (October 6, 2026). The last GitHub release tag is still 0.8.1 from February, so watch PyPI, not the Releases page.
  • KittenTTS 2 appeared on Hugging Face on September 30, 2026, and shows 36,377 downloads there.

Not run by us: our hands-on lab (a throwaway GitHub Actions container) could not start today because GitHub refused the job over a billing limit on the account. Everything below comes from the README, the docs folder, the Hugging Face model card, the license text and the public issue tracker. We did not install kittenml or generate any audio.

Our verdict: KittenTTS 2 is one of the more interesting local voice-cloning models of the year, and its authors document its weak spots honestly. But it is no longer the tiny, permissive CPU toy the stars were earned for: the Python package is “for demo only” by its own docs, real-time CPU speed depends on a weeks-old C++ fork, and the weights license ends your free commercial grant at $1M of revenue or funding. Use it for personal projects. For a product, read the license — or use the legacy ONNX models, still Apache 2.0.

Two products under one name

The confusing part of Kitten TTS is that KittenTTS(...) now loads two unrelated model families. Which one you get depends only on the repository ID you pass.

Legacy ONNX models (0.8)KittenTTS 2
Size15M–80M params, 25–80 MB1.7B params, ~950 MB default download
ArchitecturePhoneme-to-waveform, ONNXLanguage model writing audio codec tokens + vocoder
Voices847 built-in + cloning
CloningNoYes, 5–30 s reference
Expression tagsNoYes (beta)
RuntimeONNX Runtime, espeak phonemizerPyTorch (or vLLM, or C++ fork)
Weights licenseApache 2.0Stellon Labs Community License
HardwareCPU, edge devicesCUDA GPU with ~8 GB free, or CPU with ~6 GB RAM

The four ONNX checkpoints are kitten-tts-mini-0.8 (80M), kitten-tts-micro-0.8 (40M), kitten-tts-nano-0.8 (15M) and an int8 nano at 25 MB. These are the models the August 2025 Show HN (1,003 points, 361 comments) and the March 2026 follow-up (561 points, 181 comments) were about. The int8 nano alone shows 176,603 downloads on Hugging Face. The eight 0.8 voices also exist in KittenTTS 2, so code that names a voice keeps working.

How KittenTTS 2 works

Per the architecture doc, KittenTTS 2 is “not a phoneme-to-waveform model” but a language model over a vocabulary shared by text and audio. It writes S3 audio codec tokens, and a two-stage decoder (flow to mel spectrogram, then vocoder) turns them into 24 kHz audio. Voice identity enters by two routes: a speaker embedding and the reference clip itself as codec tokens in the prompt.

The size trick is in the weights. Inside every 128-wide group, each linear weight is exactly one of {-scale, 0, +scale}. Stored as bf16 that wastes 16 bits on three states, so the project packs five trits per byte (1.6 bits per weight). That takes the language model checkpoint from 3.47 GB to 0.95 GB losslessly — the project says unpacking reproduces the tensors bit-for-bit and the audio is bit-identical.

There are three weight choices:

weights=On disk (model card)Quality
"packed" (default)954 MBLossless
"emb4"469 MBLossy: 4-bit token embedding
"full"3,469 MBPlain bf16

The emb4 saving is almost entirely the 324M-parameter token embedding, which is not ternary. The model card reports it costs “roughly a tenth of a point of perplexity on internal evaluations”.

decoder="student_w4" swaps the 459 MB flow for a 39 MB 4-bit student. The decoders doc is blunt: it is not meaningfully faster (quantization shrinks storage, not arithmetic) and quality is lower (mel L1 0.250 vs 0.168). Pick it for footprint only.

Install and first commands

The README’s install really is one line:

pip install kittenml

No Hugging Face login is needed; every weight is in an ungated repository. The catch is what that one line pulls in. The kittenml 0.9.4 package depends on torch, torchaudio, transformers, diffusers, librosa, hydra-core, s3tokenizer, onnxruntime and more. On Linux, a plain pip install will fetch the CUDA build of PyTorch, which is several gigabytes. If you only want CPU, install CPU PyTorch from the PyTorch index first.

Basic KittenTTS 2 usage, from the README:

from kittenml import KittenTTS
import soundfile as sf

m = KittenTTS("KittenML/kitten-tts-2")

audio = m.generate("One day, a little girl named Lily found a needle in her room.",
                   voice="Bruno")
sf.write("output.wav", audio, m.sample_rate)

Voice cloning is the same method with reference= instead of voice=:

audio = m.generate("This is my own voice, cloned.", reference="my_voice.wav")

# Supplying the transcript skips the Whisper pass
audio = m.generate("This is my own voice.", reference="my_voice.wav",
                   reference_text="what is actually said in the clip")

Without reference_text the package loads Whisper; the vLLM doc reports cloning that way used up to 11.5 GiB of VRAM.

Expression markup:

audio = m.generate(
    "[joyful] We actually won the grant <laugh> I can (((hardly))) believe it!",
    voice="Kiki",
    preset="expressive",
)

Ten emotions, ten vocal events and (((emphasis))) spans are recognized — per the voices doc, the ten most common of each in training data that holds 2,684 emotion values. Anything else in brackets is rewritten to plain text, because “the model destabilises on bracket punctuation it was not trained to read”. The project calls emotion support “early beta”.

If you only want the small models, skip the PyTorch stack. The ONNX doc says installing kittenml with --no-deps alongside onnxruntime, espeakng_loader, phonemizer, soundfile, numpy and huggingface_hub is enough:

pip install --no-deps kittenml
pip install onnxruntime espeakng_loader phonemizer soundfile numpy huggingface_hub
from kittenml import KittenTTS
model = KittenTTS("KittenML/kitten-tts-nano-0.8-int8")
model.generate_to_file("Hello, world.", "output.wav", voice="Luna", speed=1.1)

“Runs real time on a CPU” — read the fine print

The README’s feature list says KittenTTS 2 “runs real time on a CPU”. Three other places in the project’s own docs narrow that claim:

  1. The API reference says of the device argument: “this Python package is for demo only, and not optimized for speed. For real-time performance on CPU, please refer to our optimized cpu inference repo.”
  2. That repo, kitten-tts-2-cpp, is a llama.cpp fork created on October 1, 2026, with 7 stars today. You build it yourself (C++20, CMake, CPU LibTorch). Its README lists its own limits: a batch CLI with no streaming, cloning needs an offline Python preparation step plus a transcript, and its TQ2_1 weight format cannot be loaded by stock llama.cpp. It is labelled beta, as is its kitten_tts_cpp Python binding.

The project does not publish CPU timing numbers that we could find. The only hard performance figures are for GPUs. On an A100, the README reports a 936-character passage yielded its first 21 seconds of audio after 17 seconds and finished 54 seconds of audio in 42 seconds. On an RTX 3060 (12 GB), the vLLM doc reports median end-to-end times of 6.01 s (PyTorch) and 2.05 s (vLLM) for a 61-character sentence, and 56.77 s versus 17.56 s for a 680-character input. vLLM’s synthesis took 0.44–0.48 seconds per second of output audio.

Read together: with the default PyTorch backend, a mid-range NVIDIA GPU took six seconds for one short sentence. A Better Stack guide also reports the Python package checks only for CUDA, so Apple Silicon Macs fall back to CPU. If “real time on a laptop” is your requirement, plan on the C++ fork and verify it on your hardware.

Streaming (generate_stream) is chunk-level: a chunk of roughly 380 characters is generated and vocoded in full before it is yielded, so short text does not stream at all. The README says so itself.

Cloning quality: what the project measures

The README gives speaker-similarity numbers for its own voices: a generated clip scores 0.49–0.72 against its own reference and 0.01–0.18 against the other voices, and cloning an unseen recording scored 0.81 against that recording. That is one figure, not a multi-speaker benchmark, and there is no comparison with other cloning models. #160 reports that a 30-second reference with 1–2 second pauses produced output with the voice “stopping frequently”. Use a clean, continuous reference.

Languages: check before you rely on it

The README names 20 languages, but the model card is more specific: nine non-English voices are named after a language (Arabic, Chinese, French, German, Hindi, Italian, Portuguese, Russian, Spanish), and “the voice is what carries the accent”. The English-tuned normalizer “will mangle numbers and dates in other languages”, so pass normalize=False:

m.generate("Guten Morgen. Ich wünsche dir einen wunderschönen Tag.",
           voice="German", normalize=False)

Polish and Greek are open requests (#159, #157).

The license, in plain words

The kittenml code is Apache 2.0. The KittenTTS 2 weights are under the Stellon Labs Community License. The README itself warns: “do not assume the code’s license extends to the weights.” What the license text says:

  • Research and non-commercial use (including personal hobby use and evaluation) is free.
  • Commercial use is free only if you register with Stellon Labs, and only while you and your affiliates stay under $1M in annual revenue and under $1M in total cumulative funding. Cross either line and the license terminates; you need a separate deal.
  • If you distribute the model or a product using it, you must ship the license, include a notice file, and display “Powered by Stellon Labs” prominently.
  • You may not use the model or its outputs to train, distill or improve another model (fine-tunes and LoRAs of this model are allowed).
  • The grant is revocable, and you must follow an acceptable-use policy that is “available by contacting us” rather than published with the license.

The funding clause is the one that bites: a startup with a $1.5M seed round and no revenue is already outside the free commercial grant. The pyannote speaker-embedding model in speaker/ is MIT, and the legacy ONNX weights are Apache 2.0, so the original small models remain the safe choice for commercial products.

Community reaction

The original release earned real goodwill: users reported it running on a Raspberry Pi 4 (#43) and built an Android TTS engine on it (#56). KittenTTS 2 got a cooler reading — Better Stack titled its guide “the License You Need to Read First”, and one YouTube review was called “The Tiny TTS Everyone Loved Isn’t Tiny Anymore”. Reviewers call the capability jump genuine; the complaint is that the name now covers different size, hardware and license trade-offs.

The newest issues are useful as a defect list. Three filed on October 18 concern the English text normalizer: “10km” becomes “tenkm” (#168), “$1.00” becomes “one dollars” (#167), and a bare “10:00” time fuses into the next word (#166). #163 reports that <laugh> is spoken as a word even with the docs example. #158 reports a Windows UnicodeDecodeError and an import crash with CPU-only PyTorch.

Honest limitations

  • No published CPU numbers. “Real time on a CPU” depends on a beta C++ fork you compile yourself.
  • Heavy install. The default pip install pulls full PyTorch, even for the 25 MB model.
  • Not open weights in the usual sense. Revenue and funding caps, registration, attribution, a no-distillation clause and an unpublished AUP.
  • Open English normalization bugs (units, currency, times); pre-normalize critical text.
  • Long text must be chunked. The README says the model “truncates or drifts into repetition” on a whole script in one pass; the package chunks automatically.
  • Voice cloning is a misuse risk. Five seconds of someone’s audio is enough. Get consent.
  • Fast-moving packaging. Five PyPI releases between September 29 and October 6; pin your version.

FAQ

Does KittenTTS 2 really run on a CPU?

It runs on CPU with about 6 GB of RAM, but the project says real-time CPU speed needs the separate kitten-tts-2-cpp fork; its API docs call the Python package “for demo only”. No CPU benchmark is published.

Is KittenTTS still 25 MB?

The legacy models are: kitten-tts-nano-0.8-int8 is 25 MB and the mini model is 80 MB. KittenTTS 2, the new default in the README, is about 950 MB (469 MB with weights="emb4"). Both load through the same KittenTTS(...) constructor.

Can I use KittenTTS 2 commercially?

Only if you register with Stellon Labs, stay under $1M annual revenue and $1M total funding, and display “Powered by Stellon Labs”. The older ONNX models are Apache 2.0 with none of these terms.

How much audio do I need to clone a voice?

The README says 5–30 seconds of a single speaker, with no fine-tuning. Supply reference_text (the transcript) to skip the Whisper pass. Use a clip without long pauses — users report pauses in the reference carry into the output.

Which languages does KittenTTS 2 support?

English plus language-named voices for Arabic, Chinese, French, German, Hindi, Italian, Portuguese, Russian and Spanish; the README lists 20 languages in total. Turn off the English-tuned normalizer (normalize=False) for non-English text.

How does it compare with Kokoro or Piper?

Kokoro and Piper are small phoneme-based models without zero-shot cloning; they compete with the legacy Kitten ONNX models. For open-licensed cloning, Better Stack points to VoxCPM2 and Resemble AI’s Chatterbox (both Apache 2.0).

Verdict

KittenTTS 2 is technically impressive: lossless ternary packing gets a 1.7B speech model under a gigabyte, and the docs admit trade-offs most model cards hide. For a hobby voice assistant or a cloning prototype on a GPU box, it is worth an afternoon.

But judge it as a new model, not the 25 MB Kitten TTS you remember. It needs real hardware or a beta C++ build, and the weights license is built to turn any successful company into a paying customer. If you need a tiny, permissively licensed CPU voice, the legacy kitten-tts-nano-0.8-int8 is still the reason this repo has 16,000 stars — and it is still in the box.

Sources