# KittenTTS 2: Voice Cloning at 1.7B Parameters, and the License You Need to Read First
The original KittenTTS built a loyal following by being the opposite of everything it is now: 25-80MB models, no GPU required, Apache 2.0 license, simple API. KittenTTS 2 from Stellon Labs keeps the name but abandons almost everything else. It's a **1.7-billion-parameter speech language model with in-context voice cloning from five seconds of audio, 47 built-in voices, and expression controls**. The model weights are no longer Apache 2.0.
For personal projects and research, the capability improvement is genuine. For production use, the license is the thing you need to read before writing a single line of integration code.
## What actually changed
Original KittenTTS models ranged from 15M to 80M parameters and fit into 25-80MB. KittenTTS 2 is 1.7B parameters. The default download is the ternary quantized checkpoint at 947MB (910MB for the language model, 37MB for the decoder), which is the version most users should use. A full BF16 version exists at 3.47GB. A lighter `emb4` variant cuts the download roughly in half.
The two biggest capability gains are voice cloning and multilingual support. The original had eight built-in voices and no cloning. KittenTTS 2 ships 47 built-in voices including nine non-English, and can clone any speaker from a 5-30 second reference clip with no fine-tuning.
The architecture is a two-stage pipeline.
**Stage 1 (Speech Language Model):** Takes your text and a reference audio clip, outputs audio tokens. The 1.7B parameter model analyzes the voice prompt's phonetic properties, pitch, and timbre, then generates codec tokens representing the target speech.
**Stage 2 (Decoder/Vocoder):** Converts audio tokens to a waveform. KittenTTS 2 uses its own built-in S3 meanflow decoder (not an external dependency) to produce 24kHz audio.
Unlike the original, which pulled in Whisper for transcription, KittenTTS 2 handles voice cloning through its speaker embedding model directly. No Hugging Face login is required; all weights ship in the model's own repository.
## Installation and basic usage
KittenTTS 2 requires Python 3.10+. Create a virtual environment first:
```command
python -m venv kitten_env
```
```command
source kitten_env/bin/activate
```
Install the package:
```command
pip install kittenml
```
The first run downloads the model weights automatically from Hugging Face. Basic speech generation with a built-in voice:
```python
[label generate.py]
from kittenml import KittenTTS
import soundfile as sf
m = KittenTTS("KittenML/kitten-tts-2")
audio = m.generate("This is a test of KittenTTS 2.", voice="Bruno")
sf.write("output.wav", audio, m.sample_rate)
```
Voice cloning from a reference file:
```python
[label clone.py]
from kittenml import KittenTTS
import soundfile as sf
m = KittenTTS("KittenML/kitten-tts-2")
audio = m.generate(
"This is my own voice, cloned.",
reference="my_voice.wav"
)
sf.write("cloned.wav", audio, m.sample_rate)
```
The reference audio feeds the model through two independent routes: a speaker embedding through the model's projection head, and the clip itself as codec tokens in the prompt. This dual-path approach means voice identity is preserved even when one route produces a weak signal.
Expression control is an experimental feature. You can prefix text with emotion tags and insert non-speech sounds:
```python
[label emotion.py]
text = "[joyful] We actually won, can you believe it! I can hardly believe it."
audio = m.generate(text, reference="sample.wav")
```
Emotion control results are inconsistent in the current release and should be treated as a beta feature.
## Performance on non-NVIDIA hardware
The Python package's device selection checks for CUDA first. If no NVIDIA GPU is detected, it falls back to CPU. This means Apple Silicon Macs run everything on CPU despite having capable GPU hardware.
The GitHub README claims real-time generation on CPU; the model card notes CPU generation can be 2-3x slower than real-time depending on the system. Performance varies significantly by hardware. On an Apple Silicon Mac, generation for a short sentence takes several seconds. NVIDIA GPU owners should see substantially better throughput.
For Apple Silicon users who want hardware acceleration, the audio.cpp runtime (via `0xShug0/audio.cpp`) provides a GGUF-format version with Metal backend support that doesn't have the CUDA-only fallback issue of the Python package.
## The license: what you can and cannot do
The `kittenml` Python package is Apache 2.0. The model weights are under the Stellon Labs Community License. This distinction matters.
The key terms:
**Revocable grant.** Your right to use the model can be terminated at Stellon Labs' discretion. This is unusual and introduces uncertainty for any long-term project built on these weights.
**Commercial use cutoffs.** The free commercial grant ends the moment you or your affiliates exceed $1,000,000 USD in annual revenue or $1,000,000 USD in total cumulative funding. Most funded startups cross one of these thresholds before reaching meaningful scale.
**Registration required.** To use the model commercially below those thresholds, you must register with Stellon Labs by contacting them. This isn't automatic.
**Attribution required.** Applications must display "Powered by Stellon Labs" prominently.
**External Acceptable Use Policy.** The license references an AUP that is not included in the license text. You must contact Stellon Labs to read it. You are legally bound by terms you cannot easily review.
For hobbyists, researchers, and very early-stage projects: the license is workable. For funded startups or established businesses: you need a commercial agreement with Stellon Labs before shipping anything.
## When to use it and when to look elsewhere
KittenTTS 2 is worth evaluating if you need local voice cloning with no API calls, you're working on a personal or research project without commercial constraints, privacy is a hard requirement (all audio stays on device), or you want to prototype before committing to a hosted service.
It's the wrong choice if you need real-time performance on Apple Silicon or AMD hardware, your project involves a funded company, you require a permissive open-source license, or you can't accommodate the 1-3.5GB model footprint depending on which checkpoint you use.
For production applications with commercial requirements, ElevenLabs and similar hosted services have clear commercial licensing. For fully open-weight alternatives, VoxCPM2 (Apache 2.0, also 2B parameters) is the closest comparison, and Chatterbox from Resemble AI (also Apache 2.0) covers similar ground. The [KittenML GitHub repository](https://github.com/KittenML/KittenTTS) and [Hugging Face model page](https://huggingface.co/KittenML/kitten-tts-2) have the full documentation, license text, and available weight variants.