Kitten TTS: 25MB Text-to-Speech That Runs on Any CPU (Even a Raspberry Pi)

Kitten TTS is a family of Apache-2.0 text-to-speech models from 15M to 80M parameters — the smallest ships as a 25MB ONNX file — that run entirely on CPU with 8 voices at 24kHz. One pip command installs it; on our M3 Pro laptop CPU the 56MB nano model generated speech at ~21x realtime, and even the largest 80M mini ran at ~4.4x. No GPU, no API key, no cloud, $0.

Our concrete recommendation: install kitten-tts-nano-0.8-fp32 (56MB) — in our tests it was the fastest of the four models, not just the smallest useful one. Reach for mini (80M) when output quality matters more than speed, and treat the famous 25MB int8 build as a disk-space play, because on our hardware it was actually slower than fp32. If your target is a Raspberry Pi, this is one of the rare AI tools with an official Adafruit guide behind it.

The rest of this page is everything we verified by actually running it: exact install commands, benchmark numbers for all four models, the Raspberry Pi picture, and the three install failures you are most likely to hit — including one that crashes Python with no traceback.

---

What Kitten TTS Is {#what-it-is}

Kitten TTS is an open-source TTS project by KittenML that went from a single 15M-parameter preview to a four-model family within a year, collecting roughly 15K GitHub stars along the way (August 2026). It is built on the StyleTTS 2 architecture, per the acknowledgements on the official model cards.

The project's short history matters because it tells you what you are adopting:

• August 2025: launch as a "Show HN: Kitten TTS – 25MB CPU-Only, Open-Source TTS Model" — 1,003 points on Hacker News. A 15M-parameter model you could ship in a Docker layer without noticing was a genuinely new thing.
• March 2026: a second front-page thread, "Show HN: Three new Kitten TTS models – smallest less than 25MB" (561 points), announcing the current 0.8 generation: mini (80M), micro (40M), and a retrained nano (15M).
• Along the way: Adafruit published an official Raspberry Pi learning guide, and a Rust implementation with a CLI and API server (second-state/kitten_tts_rs, 311 stars) appeared for people who want the model without the Python stack.

Two front-page HN launches a year apart plus an Adafruit guide is a decent signal that this is not abandonware — which, for a young project, is the thing to check before you build on it. Where it sits in the wider landscape: our best local TTS models roundup covers the full field; Kitten TTS occupies the "smallest hardware floor" corner of it.

---

The Four Models {#model-lineup}

There are four builds in the 0.8 generation, from a 25MB int8 nano to an 80MB mini — all output 24kHz audio and all share the same 8 voices. The lineup, as listed in the official README (August 2026):

(Source: KittenML/KittenTTS README on GitHub. Download counts suggest real adoption — the mini card alone showed ~28K downloads in the previous month when we checked.)

Every model exposes the same eight voices — we confirmed the list from the loaded model's available_voices attribute: Bella, Jasper, Luna, Bruno, Rosie, Hugo, Kiki, and Leo. There is no voice cloning; you pick from these eight.

One thing the model cards do not claim: multilingual support. Everything documented — voices, examples, demos — is English. Treat Kitten TTS as English-only until the project says otherwise.

---

Install in Five Minutes {#install}

One pip command installs everything, but use Python 3.10–3.12 — the current wheel would not resolve on Python 3.14 in our testing. The commands below are what we actually ran, on macOS (Apple Silicon), August 2026:

# Python 3.12 recommended — see gotcha #1 below
python3.12 -m venv kitten
source kitten/bin/activate

# The official install path is the release wheel, not PyPI:
pip install https://github.com/KittenML/KittenTTS/releases/download/0.8.1/kittentts-0.8.1-py3-none-any.whl soundfile

That URL comes straight from the project README (version 0.8.1 as of August 2026 — check the repo's releases page if you are reading this later). soundfile is for writing WAV output.

Budget for the download: our fresh virtual environment measured 956MB after install. The 25MB model headline does not include PyTorch, spaCy, onnxruntime, and the phonemizer stack the package depends on. On Linux it can be worse — commenters in the March 2026 HN thread reported ~756MiB in the best case, ~3GB with CPU-only torch, and 7.1GB when pip pulled CUDA builds — an issue the author acknowledged as a bug. If pip starts downloading NVIDIA packages on a CPU-only Linux box, install the CPU wheel of torch first:

pip install torch --index-url https://download.pytorch.org/whl/cpu

Model weights themselves download automatically from Hugging Face on first use, so the first KittenTTS(...) call needs network; after that it is fully offline.

---

First Words: Quickstart {#quickstart}

Five lines of Python produce a WAV file; the model loads in about 3 seconds once cached. This is the README's example, which ran unmodified for us (we swapped in the nano model):

from kittentts import KittenTTS

model = KittenTTS("KittenML/kitten-tts-nano-0.8-fp32")

audio = model.generate(
    "Local text to speech has finally gotten small enough to run anywhere.",
    voice="Jasper",
)

import soundfile as sf
sf.write("output.wav", audio, 24000)  # 24kHz output

Play it with aplay output.wav on Linux (that is what Adafruit's Pi guide uses) or afplay output.wav on macOS.

Two practical notes from running this a few dozen times. First, model loading — not generation — dominates short scripts: roughly 3 seconds to instantiate from local cache in our runs. If you are building anything interactive, load once and keep the object alive. Second, voice choice is free to experiment with: loop over model.available_voices and generate the same sentence with each; the whole experiment takes seconds at these speeds.

---

Our CPU Benchmarks {#benchmarks}

Measured on an Apple M3 Pro (CPU only, no GPU involved): nano-fp32 was fastest at ~21x realtime, and the surprise result is that the 25MB int8 model is slower than the 56MB fp32 one. We generated a fixed ~40-word paragraph with each model, after a warmup run, and compared generation time to the duration of the audio produced:

(Our own measurements, August 2026, kittentts 0.8.1 / onnxruntime 1.28, Python 3.12. Single-paragraph methodology, reproduced within ~10% across two runs — treat as indicative, not lab-grade.)

The int8 result is worth dwelling on because it inverts the intuition people bring from LLM quantization. On this CPU, int8 dequantization overhead cost more than the memory savings bought: fp32 nano was ~2.4x faster. Quantization here buys you disk and RAM footprint, not speed. Pick int8 for a storage-starved edge device; pick fp32 for everything else.

For calibration against other hardware, two attributed data points from the launch Hacker News thread: a commenter benchmarked the launch-era model at ~5x realtime on an Intel i9-14900HX, and another measured ~1x realtime on an Intel Celeron N4020 (with a ~6-second model load), one of the weakest x86 CPUs sold this decade. Commenters also reported no speedup from a discrete GPU — the package has no GPU path, which for this use case is fine.

What do these speeds mean in practice? At ~21x realtime, narrating this entire article (~13 minutes of audio) would take about 40 seconds of compute. Long-form generation — audiobooks, article narration, announcement queues — is trivially batchable on hardware you already own.

---

Raspberry Pi Setup {#raspberry-pi}

Kitten TTS runs on a Raspberry Pi 4 or 5, and you do not have to take our word for it — Adafruit maintains an official learning guide, "Speech Synthesis On Raspberry Pi with KittenTTS." Their guide walks through a Pi with a Voice Bonnet speaker hat, installs the package into a venv, and ends with a genuinely useful demo: an offline weather announcer that reads National Weather Service forecasts aloud — no API keys, no cloud TTS bill.

The honest performance picture: neither Adafruit nor the KittenTTS project publishes Pi real-time-factor numbers, and we have not run it on a Pi ourselves. The best available anchor is that HN-reported ~1x realtime on a Celeron N4020; a Pi 5's Cortex-A76 cores are in a broadly similar performance class, so expect the nano models to land around realtime on a Pi 5, slower on a Pi 4 — Adafruit says only that the Pi 5 is faster. That is our estimate, clearly labeled as one. Around realtime is perfectly usable for a voice assistant that speaks a sentence or two; it is tedious for generating an hour of audio.

Three Pi-specific notes:

• Use a Pi 4/5 with standard Raspberry Pi OS. The ~1GB Python dependency stack (torch, spaCy) makes Pi Zero-class boards a non-starter for the official package. For truly minimal hardware, the Rust port (second-state/kitten_tts_rs — 311 stars, CLI plus API server) skips Python entirely.
• Watch the version skew. Adafruit's guide was written against the launch-era 0.1 wheel and old voice names (expr-voice-2-f style). The concepts transfer; the model IDs and voices in this article are the current ones. This project moves fast enough that any tutorial — including ours — deserves a cross-check against the README.
• A Pi that talks pairs naturally with a Pi that thinks. We run small LLMs on the same board in our Raspberry Pi 5 LLM guide, and the full listen-think-speak pattern is covered in our local voice assistant build — swap Kitten TTS in for the speaking part. If your edge target is a phone instead, see running LLMs on a phone.

---

Three Install Gotchas {#gotchas}

All three of these bit us or the community in real installs; two have one-line fixes.

1. Python 3.14 breaks dependency resolution. On Python 3.14, pip failed for us with Could not find a version that satisfies the requirement misaki>=0.9.4 — the G2P library the 0.8.1 wheel depends on does not resolve there yet. Recreating the venv with Python 3.12 fixed it immediately. The README says Python 3.8+; in practice, stick to 3.10–3.12.

2. A hard crash mentioning phontab. In one fresh venv on macOS, instantiating the model killed the Python process outright — no traceback, just Error processing file '.../phontab': No such file or directory. That is espeak-ng (the phonemizer underneath) looking for its data files in the venv root instead of inside the bundled espeakng_loader package. Symlinking the data files to where it looks fixed it for us:

ln -s "$(python -c 'import espeakng_loader; print(espeakng_loader.get_data_path())')"/* "$VIRTUAL_ENV/"

If you hit a phontab error, that one-liner is the workaround; most installs never see it.

3. Multi-gigabyte installs on Linux. Covered above: pip pulling CUDA torch for a CPU-only model. Install the CPU torch wheel first and the footprint drops to under a gigabyte.

---

Where It Fits vs Piper and Kokoro {#vs-piper-kokoro}

Kitten TTS is the smallest-footprint option with expressive voices; Piper is the more mature Pi incumbent; Kokoro (the 82M hexgrad/Kokoro-82M) is the quality pick among small models. Choosing between them is mostly about which constraint binds:

• Choose Kitten TTS when model size is the constraint and you want more expressive prosody than classic lightweight TTS at a comparable weight class — or when you specifically want the setup Adafruit documents for the Pi. It is the youngest of the three, which cuts both ways: rapid improvement, moving APIs.
• Choose Piper when you need the boring, proven answer on embedded Linux: it has years of deployment in Home Assistant setups, broad language coverage, and lean native tooling rather than a torch-and-spaCy Python stack. It remains our default recommendation for production Pi voice output.
• Choose Kokoro when quality-per-parameter is the metric. At 82M parameters it plays in the same size band as Kitten's mini, and its output is the benchmark small models get compared against — the launch HN thread's consensus on Kitten TTS was "impressive for the size," which is exactly the right framing. Kokoro is also the default voice in several popular self-hosted TTS servers.

None of these three does voice cloning. If you want to narrate in a specific voice — including your own — that is a different weight class entirely; see the options in our local TTS roundup. And if the input side of your pipeline is speech too, Faster-Whisper is the matching CPU-friendly transcription piece.

---

Honest Limitations {#limitations}

Kitten TTS is genuinely impressive for its size — and "for its size" is doing real work in that sentence. What we would want you to know before building on it:

• English only. No multilingual support is documented anywhere in the repo or model cards as of August 2026. Piper covers dozens of languages; Kitten covers one.
• Eight fixed voices, no cloning. You cannot add voices or clone one.
• Quality trails the size classes above it. Nobody should choose Kitten over Kokoro, XTTS-class models, or cloud TTS on output quality alone. The launch-thread verdict — sounds OK, remarkable that it comes from 15M parameters — matched our listening. The mini model narrows the gap; it does not close it.
• The 25MB headline is the model, not the install. ~1GB of Python dependencies in practice (our measurement). The Rust port is the escape hatch.
• Young project, moving fast. Version 0.1 to 0.8.1 inside a year, with voice names and model IDs changing along the way — which silently broke earlier tutorials, Adafruit's included. Pin your versions in anything you deploy.
• 24kHz mono output. Fine for speech; it is not studio-grade audio, and there are no knobs for emotion or style control beyond voice choice.

None of these are dealbreakers for what the project actually is: the lowest-friction way to give any CPU-having device a voice, for free, offline.

---

Sources {#sources}

• KittenML/KittenTTS on GitHub — model table, install command, voice list, quickstart code, Apache-2.0 license, star count (read August 2026)
• KittenML/kitten-tts-mini-0.8 on Hugging Face — StyleTTS 2 acknowledgement, license, download counts
• Hacker News: launch thread, August 2025 (1,003 points) — i9-14900HX and Celeron N4020 performance reports, install-size reports, author responses
• Hacker News: "Three new Kitten TTS models" (561 points) — 0.8-generation announcement
• Adafruit: Speech Synthesis On Raspberry Pi with KittenTTS — Pi 4/5 support, Voice Bonnet setup, weather-announcer project
• second-state/kitten_tts_rs — Rust CLI/API-server port (star count via GitHub API, August 2026)
• Benchmark table: our own measurements on an Apple M3 Pro, August 2026 (kittentts 0.8.1, onnxruntime 1.28, Python 3.12). Every command in this guide was run before it was published; third-party numbers are attributed inline.

---

FAQ {#faq}