---
title: "KittenTTS on a Mac: Run the Tiny 25 MB Voice Model"
description: "Run KittenTTS on a Mac, check the size claims and eight voices, see the English-only limits, and decide when a bigger local model such as Kokoro fits better."
canonical: "https://www.murmurtts.com/blog/kitten-tts-mac-guide"
---
[Murmur](https://www.murmurtts.com/)/[Blog](https://www.murmurtts.com/blog)/Guide

Guide

# KittenTTS on a Mac: Run the Tiny 25 MB Voice Model

Run KittenTTS on a Mac: what the sub-25 MB nano model can and cannot do, its eight voices, the Apache-2.0 and Stellon licenses, and when to use Kokoro.

![](https://www.murmurtts.com/murmur-icon.webp)Murmur·November 13, 2026·11 min read[Buy $49](https://murmur-licenses.tarunyadav9761.workers.dev/checkout)[Download free for Apple Silicon (3-day Pro trial)](https://murmur-updates.tarunyadav9761.workers.dev/download/latest)Intel Mac? [Download here](https://murmur-updates.tarunyadav9761.workers.dev/download/intel).Not sure? Apple menu > About This Mac shows your chip.

Free plan with Kokoro voices, 3,000 characters a day · 3-day Pro trial, then $49 once

On this page

What KittenTTS actually is todayThe size claims, read from the sourceRunning KittenTTS on a Mac, step by stepWhat tiny models do well, and where they stop being enoughKittenTTS vs Kokoro, and when to step upShould you run KittenTTS yourself?What can go wrongFrequently asked questions

[Back to the journal](https://www.murmurtts.com/blog)

Short answer: KittenTTS is an open source text to speech library whose small ONNX models are among the lightest you can run locally: the nano build is a 15 million parameter model that the repository lists at about 25 MB and the older nano card describes as under 25 MB. It runs on CPU without a GPU, offers eight English voices and adjustable speed, and the repository code is Apache-2.0, while the newer KittenTTS 2 weights use a separate Stellon Labs community license. One thing to know before you start: **Murmur does not run KittenTTS.** Murmur is a separate macOS app that bundles Kokoro. This guide explains what KittenTTS is, how to run it on an Apple Silicon Mac, and when a tiny model stops being enough.

The project has moved on since the first release. The README now leads with KittenTTS 2, a 1.7B parameter speech language model with voice cloning and expression tags, and keeps the original lightweight models as a documented alternative. The tiny model that most searches are about is the legacy ONNX family, which is what this guide focuses on. If a page or a video describes a sub-25 MB KittenTTS, it usually means the nano model.

## What KittenTTS actually is today

KittenTTS is a Python library published by KittenML. The repository README describes it as an open source library that runs on CPU, and the README and ONNX docs list ONNX as the runtime for the small models. The legacy family ranges from 15 million to 80 million parameters, which the project's own [lightweight ONNX models page](https://github.com/KittenML/KittenTTS/blob/main/docs/onnx-models.md) puts at 25 to 80 MB on disk. These models run efficiently on CPU without a GPU, which the project frames as the right choice for edge deployment and for anything that cannot carry a PyTorch stack. They offer eight voices and adjustable speech speed, and no voice cloning or expression control.

The newer KittenTTS 2 is a different animal: a 1.7B parameter model with in-context voice cloning from 5 to 30 seconds of audio, 47 built in voices, expression markup, and 20 listed languages. The README says it loads through the same constructor as the small models. Both facts matter for a purchasing or project decision, because the small model and the large model solve different problems even though they share a package name.

## The size claims, read from the source

Sizes below are copied from the repository README and the model cards, not measured. Two points to keep: the download includes more than the weights (the runtime and its dependencies add to it), and the default install also pulls PyTorch for KittenTTS 2, which is large relative to these models. The project's own docs suggest installing with `--no-deps` alongside onnxruntime, phonemizer, soundfile, numpy and huggingface_hub if you only want the small models.

| Model | Parameters | Size as listed | What it offers |
| --- | --- | --- | --- |
| kitten-tts-2 | 1.7B | 506 MiB (emb4) / 947 MiB default | 47 voices, cloning, expression, 10 to 20 languages (the docs differ) |
| kitten-tts-mini-0.8 | 80M | about 79 to 80 MB | 8 voices, ONNX, CPU, speed control |
| kitten-tts-micro-0.8 | 40M | 41 MB | 8 voices, ONNX, CPU, speed control |
| kitten-tts-nano-0.8 (fp32) | 15M | 56 MB | 8 voices, ONNX, CPU, speed control |
| kitten-tts-nano-0.8-int8 | 15M | about 25 MB | 8 voices, ONNX, CPU, speed control |

The eight legacy voices are named Bella, Jasper, Luna, Bruno, Rosie, Hugo, Kiki and Leo, and the documentation lists that exact set. The README notes these are the same speakers used in KittenTTS 2, so code written against the ONNX models keeps working. If you specifically want the smallest possible English voice model for a small app or an offline utility, the int8 nano is the target.

## Running KittenTTS on a Mac, step by step

The README lists Python 3.9 or later and the ONNX page lists Python 3.8 or later, but the package metadata (pyproject.toml and setup.py) requires Python 3.10 or later, and pip enforces that even with --no-deps. There is no separate macOS installer and no Homebrew formula mentioned in the pages I read. You are running a Python package. On an Apple Silicon Mac that means one CPU path in practice, because the repository documents CPU, CUDA and vLLM backends and I did not find Apple MPS guidance in the README or the ONNX page. Treat Metal acceleration as unverified and plan around CPU.

1. Open Terminal and make an isolated environment so this package cannot disturb other Python tools: python3 -m venv kitten-env, then source kitten-env/bin/activate.
2. Install the package. The README's current instruction is pip install kittenml. For the small models alone, install with --no-deps plus onnxruntime, espeakng_loader, phonemizer, soundfile, numpy and huggingface_hub, which the docs list as sufficient.
3. In Python, construct the model by its Hugging Face id, for example KittenTTS("KittenML/kitten-tts-nano-0.8-int8") for the tiny build or kitten-tts-mini-0.8 for more capacity.
4. Call generate with a voice name and the text, then write the returned array at the model sample rate of 24000 with soundfile. The docs show the exact call shape.
5. Use the voice list from the model itself rather than hardcoding names, and try speed=1.2 or speed=0.9 to nudge pacing.
6. Keep inputs short. The README has a long-text and streaming section, and it describes KittenTTS 2. The ONNX docs for the small models say nothing about long inputs, so test a full script before you trust a small model with one.

Before you invest hours, audition the eight voices against your own script. Voice suit matters more than parameter count at this size. The [Kokoro voices list guide](https://www.murmurtts.com/blog/kokoro-voices-list-guide) shows the kind of per voice audition sheet that makes this comparison quick, and the same method works for KittenTTS.

## What tiny models do well, and where they stop being enough

A 15 million parameter model is a compression of speech, and compression has a cost. On short, plain, English sentences a well trained tiny model can sound surprisingly usable, and that is the entire pitch of this family. The trouble starts at the edges: unusual proper nouns, long sentences, lists, and any text where the normalizer has to make a judgment. The KittenTTS 2 expression docs describe a case where bracket punctuation destabilised the model on a parenthetical list, and say unknown bracketed spans are rewritten into plain comma separated text. That note is about KittenTTS 2, not the small ONNX models. That is a useful reminder that a tiny model's behavior is tuned to its training distribution, not to your document.

- Short lines and UI prompts: a good fit, and the disk and memory footprint is tiny.
- Fixed English narration of a few sentences: workable, especially with speed adjusted.
- Long form scripts: not documented for the small models, so try a full script before you commit to them.
- Voice cloning or emotion: not available in the legacy models at all.
- Non-English text: the legacy eight voice set is English. Multilingual support is documented for KittenTTS 2, not the small ONNX models.
- Pronunciation control over names and jargon: minimal, since the documented knobs are voice, speed and text cleaning.

This is not a knock. If your job is a 25 MB offline voice that reads short English prompts on modest hardware, the small model does exactly that. The honest boundary is that it is a small English reader, not a production narration engine.

## KittenTTS vs Kokoro, and when to step up

Kokoro is the natural next rung for many people, and it is the model Murmur bundles, so the comparison is practical rather than academic. Kokoro is roughly 82M parameters, which the murmur model catalog describes as fast, lightweight TTS with more than ten built in voices, covering English US and UK, Spanish, Japanese, Chinese, French, Hindi, Italian and Portuguese. That is a clear step up in language coverage from eight English voices, while staying small enough to run locally on a Mac. The [Kokoro TTS on Mac guide](https://www.murmurtts.com/blog/kokoro-tts-mac-guide) covers that model in detail. It is not the same trade as KittenTTS 2, which buys cloning and expression with a much larger download.

| Situation | Reasonable choice |
| --- | --- |
| You need the smallest possible English voice file for a tiny app | Run KittenTTS nano yourself |
| You want eight English voices with no GPU and a documented Python API | Run KittenTTS mini or nano yourself |
| You want several languages and more voices without a 1.7B download | Kokoro, which Murmur bundles |
| You want voice cloning or expression tags | KittenTTS 2 on your own machine, or one of the shipped Murmur models if it fits your job |
| You want a Mac app with a voice library and no Python setup | Murmur, whose free plan runs Kokoro on scripts up to 1,500 characters |
| You need Windows, iPhone or Android | Neither Murmur nor this guide; Murmur is a Mac app only (macOS 15 or later) |

If Python is the obstacle rather than the model, the [no Python local TTS on Mac](https://www.murmurtts.com/blog/no-python-local-tts-mac) guide walks through the app first route. Murmur needs an Apple Silicon or Intel Mac running macOS 15 or later, runs models locally with no per character fees and no upload, and costs $49 one-time with a free plan and a 3-day Pro trial, plus a 7-day refund policy. It is worth naming plainly that Murmur is the wrong tool if you need Windows or a browser app, and KittenTTS is the wrong tool if you need cloning or non-English narration from the small models.

## Should you run KittenTTS yourself?

- Yes if you are comfortable with a terminal, a virtual environment and a Python script that loads an ONNX model.
- Yes if you want to embed a very small English voice model in another program, which is the edge deployment case the docs name.
- No if you need a Mac app with a voice library, click to listen, and no dependencies to manage.
- No if your script is long form, multilingual, or needs cloning and emotion.
- Try it if you are curious, because the download is small and the trial cost is your time.

## What can go wrong

- The default install pulls PyTorch for KittenTTS 2, so a large dependency arrives even if you only want the 25 MB model. Use a virtual environment and the --no-deps route the docs describe.
- Python version and dependency conflicts are the usual failure. The prose docs say 3.8 or 3.9, but the package itself requires Python 3.10 or later, and the python3 that ships with macOS may be older, so run python3 --version before installing.
- Memory: the README's prerequisites for KittenTTS 2 mention a CPU with about 6 GB of RAM; the small ONNX models are far lighter but still load a runtime.
- Long text in a single call is not documented for the small models, so split long scripts and listen to the result. Chunk on sentence boundaries.
- Streaming is chunk level, not token level, and the first chunk still pays its own generation time, so it is not live microphone streaming.
- In KittenTTS 2, unknown bracketed text is rewritten before synthesis, and the docs warn that bracket punctuation can destabilise the model.
- English only for the legacy eight voices. Multilingual behavior is documented for KittenTTS 2, and even there the docs warn that a single reference clip per language makes the non-English voices more fragile and that the normalizer is English tuned.

License is the last thing to check before shipping anything. The repository code is Apache-2.0, and the legacy ONNX model cards I opened carry Apache-2.0 as well. KittenTTS 2 is different: its Hugging Face card says license: other and points to the Stellon Labs Community License. That license allows research, non-commercial and limited commercial use free of charge, but commercial users must register with Stellon Labs, the commercial grant ends once you or your affiliates pass US$1,000,000 in annual revenue or in total funding, you must show "Powered by Stellon Labs" and keep its notice when you distribute it, and you may not use the model or its outputs to distill it into another model. The README is explicit that the models are licensed separately from the code and that terms may differ, and it names the Stellon Labs Community License for the KittenTTS 2 weights. So if you plan to commercialise output from the small models, read the specific card you downloaded and keep the record. The [best local TTS models roundup](https://www.murmurtts.com/blog/best-local-tts-models-2026) is a good second opinion on where these fits sit in a wider shortlist.

## Frequently asked questions

## Sources

- [KittenML/KittenTTS README (features, models, install, CPU notes, license)](https://github.com/KittenML/KittenTTS)Accessed 2026-10-19
- [KittenTTS docs: lightweight ONNX models, eight voices, speed control](https://github.com/KittenML/KittenTTS/blob/main/docs/onnx-models.md)Accessed 2026-10-19
- [KittenTTS docs: voices and expression, languages, known limitations](https://github.com/KittenML/KittenTTS/blob/main/docs/voices-and-expression.md)Accessed 2026-10-19
- [Hugging Face model card: KittenML/kitten-tts-nano-0.8-int8 (15M, about 25 MB)](https://huggingface.co/KittenML/kitten-tts-nano-0.8-int8)Accessed 2026-10-19
- [Hugging Face model card: KittenML/kitten-tts-nano-0.1 (under 25 MB)](https://huggingface.co/KittenML/kitten-tts-nano-0.1)Accessed 2026-10-19

## Want a voice library without the Python setup?

Murmur is a local voice studio for Apple Silicon and Intel Macs running macOS 15 or later. Kokoro is bundled, so the free plan runs short scripts with no Python, no per character fees and no uploads. The full app is $49 one-time, with a free plan and a 3-day Pro trial, and a 7-day refund policy.

[Buy Murmur · $49](https://murmur-licenses.tarunyadav9761.workers.dev/checkout)[Download free for Apple Silicon (3-day Pro trial)](https://murmur-updates.tarunyadav9761.workers.dev/download/latest)Intel Mac? [Download here](https://murmur-updates.tarunyadav9761.workers.dev/download/intel).Not sure? Apple menu > About This Mac shows your chip.

macOS 15+ · Apple Silicon and Intel Macs · Windows beta · 7-day refund policy

Made for your Mac

## Less reading. More making.

[Buy $49](https://murmur-licenses.tarunyadav9761.workers.dev/checkout)[Download free for Apple Silicon (3-day Pro trial)](https://murmur-updates.tarunyadav9761.workers.dev/download/latest)Intel Mac? [Download here](https://murmur-updates.tarunyadav9761.workers.dev/download/intel).Not sure? Apple menu > About This Mac shows your chip.[Explore Murmur](https://www.murmurtts.com/#product)