# Three small TTS models: Kokoro's graph in int8, 2.9B parameters on a CPU, and a voice trained on no recordings

> Satyajit Ghana — Head of Engineering @ Inkers Technology
> canonical: https://ai.satyajit.si/articles/tiny-tts-roundup
> date: 2026-11-16
> tags: tts, speech, small-models, on-device, synthetic-data, quantization

Three text-to-speech models crossed my feed within a day of each other, and every one of them sold itself as small.

A Japanese account [posted Kitten TTS 2 Mini](https://x.com/aiaicreate/status/2121793930358563024): 82M parameters, 16 languages, 118 voices, an 82.7 MB int8 ONNX file, no PyTorch needed. [TeksEdge posted](https://x.com/TeksEdge/status/2121756314682708184) a "1.8GB Local AI model" that clones voices and narrates whole audiobooks on a Ryzen CPU: TontaubeV1.1, with the link in a reply. And Muhammed Nazeem [posted tiny-voca](https://x.com/n4ze3m/status/2121799813679419515): "a text-to-speech model that has never heard a real human voice. 4.5M parameters. 18 MB. Runs on a CPU."

Small means three different things there. For Kitten it means bytes: a model the size of Kokoro, stored at one byte per weight. For Tontaube it means 4-bit: a 2.9B-parameter speech language model squeezed until a desktop CPU can almost keep up. For tiny-voca it means parameters, honestly few of them, and a waveform generator that is barely a neural network at all. I read each one's config, safetensors headers, inference code and card, checked the posts against them, and then ran all three on the same five texts on one machine.

<SizeLadder />

Switch the ladder to bytes per parameter and the three strategies separate. tiny-voca ships fp32, four bytes a weight, because at 4.5M weights nobody cares. Kitten and Paradee ship int8 at about one byte. Tontaube lands at 0.62 bytes, int4 layers averaged with int8 heads, embedding tables and two extra checkpoints. The last tab is my measured speed on one CPU. Click a highlighted row to see where its parameters sit.

## Kitten TTS 2 Mini is Kokoro's graph, retrained

The [model card](https://huggingface.co/KittenML/kitten-tts-2-mini) never says what the network is. The `config.json` does. Its `architecture` block reads `hidden_dim 512`, `n_layer 3`, `n_token 178`, `style_dim 128`, `max_dur 50`, an ALBERT with hidden size 768 and 12 layers sharing one group, and an `istftnet` decoder with upsample rates `[10, 6]`, `gen_istft_n_fft 20` and hop 5. I put it next to [Kokoro-82M's](https://huggingface.co/hexgrad/Kokoro-82M) `config.json` and every one of those values matches. The safetensors header agrees: 548 float32 tensors, 81,763,410 elements, a 327,115,192-byte file against Kokoro's 327,212,226-byte `.pth`. The class names in [KittenML's package](https://github.com/KittenML/KittenTTS) (`ProsodyPredictor`, `AdainResBlk1d`, `DurationEncoder`, and a comment that the style encoders, the diffusion model and the discriminators were left out because synthesis reads the style from the voice pack) are StyleTTS 2's.

So this is the architecture the site already took apart in [Paradee](/articles/paradee-tiny-tts). Phonemes (from a normaliser, the misaki lexicon, CMUdict and a 0.75M-parameter BART for unknown words; espeak-ng for other languages) go through PL-BERT and a text encoder. A prosody predictor, conditioned on a style vector, gives each phoneme its frames, pitch and energy. The ISTFTNet decoder predicts a short-time spectrum and an inverse STFT makes the 24 kHz waveform. The header's grouping shows where the weight is: 53,276,190 parameters in the decoder, 16,194,612 in the prosody predictor, 6,686,208 in PL-BERT and 5,606,400 in the text encoder. Two thirds of an "82M TTS model" is its vocoder.

### What a voice is here

There is no speaker encoder at inference. A voice is a float32 array of shape `[510, 256]` in `voices_<lang>.npz`, and the code picks the row matching the chunk's phoneme count: two 128-dimensional style vectors, one for the decoder and one for the prosody predictor. That is Kokoro's design too.

That changes what "118 voices" means. I counted the `voices` block of the config: 118 entries, 73 distinct names. English has 11 voices, and nine of those characters appear again in German, Spanish, Italian, Portuguese and Russian, each with its own pack. The other languages get "Female 1" and "Male 2"; Turkish gets two voices, both female.

The card says the English voices "carry the names of the same characters in KittenTTS 2," the company's 1.7B voice-cloning speech language model. The KittenTTS 2 repository's `voices.json` does list `55_somber_historian_female` as Eleanor, `63_rumbling_blues_musician_male` as Otis, and so on, each with an 11-second reference clip. That hints the Mini's English voices were learned from the big model's speech, the same teacher-student pattern as tiny-voca. The card does not say so, and I found no statement anywhere of what the Mini was trained on.

### The int8 part is done carefully

The config's `quantization` field reads "int8, symmetric, per output channel (DequantizeLinear)", float32 activations, and "post-training quantization + quantization-aware distillation from the fp32 model." The package's docs give the reasoning. Dynamic int8 activation quantization (`MatMulInteger`, `ConvInteger`), which the older Kitten 0.8 models used, "was measured and rejected: on these vocoders it gives audible spectral error and non-finite audio on part of the inputs." So every weight is stored as int8 and expanded to float32 before the arithmetic. The text side and the prosody predictor were then distilled through the exact int8 rounding the graph uses, then the decoder, so the shipped weights are the ones that were trained. The docs claim the same Whisper character error rate as fp32 and a speaker-embedding similarity of about 0.999, though the Mini's card carries no per-model numbers.

Weight-only int8 suits a vocoder, whose activations carry phase; phase errors are what Paradee's author chased as a buzz. Rounding weights still moves the output, hence the distillation through the rounding.

### Checking the post

- 82M parameters, 16 languages, 24 kHz, an 82.7 MB int8 ONNX file: all hold (81,763,410 parameters; the `.onnx` is 82,711,386 bytes).
- 118 voices: 118 voice packs under 73 names.
- No PyTorch needed: true of the ONNX graph. But the `kittenml` package's `setup.py` installs `torch>=2.6`, `torchaudio`, `transformers`, `diffusers` and spaCy, because one package also serves the 1.7B KittenTTS 2. To deploy without PyTorch you carry the graph, vocab, voice pack and front end yourself.
- Licence: Apache-2.0, models, voice packs and G2P files included.

The Mini's siblings, Nano (17M) and Pico (7.2M), ship one model per language for eight languages; the Mini is one graph for all 16.

## TontaubeV1.1: four transformers, one per codebook

Tontaube is a different kind of model, a speech language model in the family the site covered with [Breeze TTS 2](/articles/breeze-tts-2) and [Qwen Audio 3.0 TTS](/articles/qwen-audio-3-tts). It comes from Fritz and Jonathan Cremer in Berlin, with a [TontaubeV1 technical report](https://tontaube.ai/papers/tontaube-v1-technical-report.pdf), [full-precision weights](https://huggingface.co/TontaubeAI/TontaubeV1.1), the [int4 release](https://huggingface.co/TontaubeAI/TontaubeV1.1-int4) the post is about, and an [inference server](https://github.com/craitech/tontaube).

<Figure
  src="https://media.thesatyajit.com/ai/articles/tiny-tts-roundup/tontaube-post.jpg?v=b7c4e7b954f172bd"
  alt="A screenshot of the TontaubeV1.1-int4 Hugging Face page: a purple bird logo, and text saying it is the 4-bit release of TontaubeV1.1, a 1.8 GB download, that loads in about 4 GiB of GPU memory and peaks at about 6.5 GiB, and also runs on x86-64 Linux CPUs with AVX2, FMA and F16C."
  caption="The model card as the post showed it. The 1.8 GB is the Tontaube weights; the inference server fetches three more models on first start (TeksEdge's post on X, image 1)."
/>

### Speech as four rows of codes

Speech is encoded by [DualCodec](https://www.isca-archive.org/interspeech_2025/li25e_interspeech.html) at 12.5 Hz: eight residual vector-quantized streams, one code each every 80 ms. The first, quantized from w2v-BERT 2.0 features, carries phonetic content and timing (16,384 entries); each of the others encodes what the streams before it missed (4,096 entries). Tontaube keeps the semantic stream and three acoustic ones, 625 bit/s.

Most codec language models either interleave the codebooks into one stream or give the residuals to one small shared module. Tontaube gives each codebook its own model:

| stage | predicts | backbone | blocks | width | stored parameters |
|---|---|---|---:|---:|---:|
| CB0 | semantic codes, and therefore duration | Qwen3-1.7B | 28 | 2,048 | 1,854,352,386 |
| CB1 | first acoustic refinement | Qwen3-0.6B, truncated | 16 | 1,024 | 448,960,512 |
| CB2 | second | Qwen3-0.6B, truncated | 8 | 1,024 | 327,307,264 |
| CB3 | third | Qwen3-0.6B, truncated | 4 | 1,024 | 268,577,792 |

I summed every tensor in the four full-precision safetensors headers and got 2,899,197,954, the server README's figure, so "2.9B" holds. CB0 reads the text and writes semantic codes until it emits an end token. That length, L, is the utterance's duration, fixed once. CB1, CB2 and CB3 then each write exactly L codes for their row, conditioned on the text and every completed row below them, at temperature zero by default. No stage ever revises a lower one. The bet is that prosody is settled in the semantic stream, so that is where 64% of the parameters go.

<Figure
  src="https://media.thesatyajit.com/ai/articles/tiny-tts-roundup/fig-positions.png?v=1a4c1dd403c0cd84"
  alt="Two panels plotting serialized sequence index against logical RoPE position. Panel (a), CB0 generating an internal chunk: the voice prompt, then the system tag and previous text, a T0 marker, current text, a T1 marker, short future text, then a PAD, the previous chunk's semantic codes, an A0 marker and the current codes being generated, ending at marker A1. The text and audio blocks jump back down to share the same position range. Panel (b), CB3: prompt streams P0 to P3 side by side at positions 1 to lP, then the text, then complete rows C0, C1 and C2 each opened by a PAD at the same positions, then C3 being generated."
  caption="Where each token sits in time rather than in the sequence. In (a) the previous text and the previous audio share positions, and the paired markers re-align them; in (b) every completed row starts at the same position as the row being generated (TontaubeV1 technical report, Figure 1)."
/>

Three details make this work for long text.

- **One character, one token.** Pronunciation is learned over a few hundred well-observed character IDs instead of tens of thousands of sparse subwords. The report's price: digits are characters too, so it asks for "1984" already spelled out, by a separate Qwen3-1.7B verbalizer that needs a GPU and is off by default.
- **Positions by time, not by order.** In the flattened input, frame 10 of the semantic row and frame 10 of an acoustic row can sit hundreds of tokens apart. Tontaube gives them the same RoPE coordinate, so their relative offset is zero, and text shares that timeline. Paired `<|text_split|>` and `<|audio_split|>` markers re-align text and audio at each chunk boundary.
- **Bounded context.** Text is cut into chunks of at most 350 characters. CB0 sees the previous chunk, the current one and up to 50 characters of the next. The acoustic stages carry no state across chunks, so voice drift cannot build up through them.

DualCodec's decoder is not causal, so Tontaube decodes overlapping windows, re-encodes them with VibeVoice's acoustic tokenizer and decodes the stable interiors with VibeVoice's causal decoder. A non-causal codec streams without retraining, at the cost of running a second codec.

### What runs on a CPU, and why it is about real time

The int4 bundle quantizes the transformer layers with GPTQ at 4 bits in groups of 64, keeps the last layer's MLP down-projection and the audio heads at 8 bits, and the CPU path runs hand-written AVX2 kernels (`app/native/lm_kernels.cpp`) that keep weights packed and quantize activations to int16. Decoding one token means reading every weight of the model once, so the speed limit is memory bandwidth, and the int4 headers say how much has to move. I summed the packed layers and heads: 876.5 MB for CB0 (798.6 MB of layers, 77.9 MB of head), 164.6 MB for CB1, 93.9 MB for CB2 and 58.5 MB for CB3. That comes to 1,193.6 MB of weights per 80 ms frame if every stage decodes its frame on its own.

For real time that is 12.5 frames a second, so about 14.9 GB/s of weight traffic before DualCodec, VibeVoice or the attention over the KV cache. CB0 alone is 11 GB/s, and within one stream it cannot be batched, since each semantic code depends on the last. Dual-channel DDR4-3200 peaks at 51.2 GB/s on paper. The README's line, "Speed is bound by memory bandwidth: a 12-core desktop CPU with dual-channel DDR4 synthesizes at about real time," is consistent with that arithmetic.

Bandwidth is the floor, though, not the whole bill. On beast2's i7-6850K, six Broadwell-E cores from 2016, Tontaube ran at 0.45x real time across five texts (a real-time factor of 2.22), and 0.43x on a 75-second passage. That platform has four memory channels, so bandwidth should not be the wall; on six older cores the int4 arithmetic is. Its peak resident memory was 8,072 MB.

### Checking the post

- 2.9B parameters: 2,899,197,954.
- 1.8 GB of 4-bit GPTQ weights: the int4 repository is 1,793,973,074 bytes. But the server's `model_sources.py` pins three more downloads that run on first start: `amphion/dualcodec` (336 MB), `facebook/w2v-bert-2.0` (2,322 MB, which encodes the reference voice's semantic stream) and two VibeVoice-1.5B shards (3,433 MB) from which it extracts the acoustic tokenizer. That is about 7.9 GB before the first word, plus 0.44 GB for a MossFormer2 post-filter that is on by default on a GPU. VibeVoice can be switched off, at the cost of streaming.
- Voice cloning from 5 to 60 seconds, long-form generation, style controls: documented. The README lists five sliders; `cb0/controls.json` defines seven.
- 4 GB of VRAM loaded, 6.5 GB peak: on the 3090 I saw 4,192 MiB above the idle baseline once loaded and 5,764 MiB at peak. That holds.
- RTX 5090 at about 13x real time for one request and 21 to 23x batched: the card and README say exactly that.
- Ryzen 9 5900X at about 1x and RTX 3090 at 6 to 7x: I found neither in either model card, the server README, the report or the repository; the README's CPU line names a 12-core desktop CPU with dual-channel DDR4, not the chip. I measured the 3090 myself: 5.3x across five texts and 6.25x on the longest, with the server's defaults (a MossFormer2 post-filter that upsamples to 48 kHz, and a CTC guard that regenerates pieces whose text it can't find). So 6 to 7x is fair for long text. I have no 5900X.
- "Open weights, custom community license": the licence is not open source, and its terms matter. Research and noncommercial use is free. Commercial use is free while your group's revenue is below EUR 200,000 and requires a "Powered by TontaubeV1" attribution. Offering the model to others as a speech-generation service "always needs a commercial license, whatever your revenue."

The training data gets one sentence in the report: about 200,000 hours of paired speech and text in seven languages, "predominantly from public-domain audiobook recordings and openly released speech corpora," with no further detail.

The evaluation is the V1 model's, not V1.1's, and the card says so. It is an order-balanced pairwise test with Gemini 3.1 Pro Preview judging prosody and correctness on 400 PG-19 passages:

<Figure
  src="https://media.thesatyajit.com/ai/articles/tiny-tts-roundup/fig-judge.png?v=fd9618e25fcd21d4"
  alt="Two dot-and-whisker panels, prosody and correctness, with TontaubeV1 preference scores against four systems. Prosody: ElevenLabs Flash v2.5 50.1%, Fish Audio S2 Pro 82.1%, Gradium API April 2026 86.2%, Cartesia Sonic 3 82.3%. Correctness: 48.9%, 49.6%, 54.6% and 60.8%, with tie rates between 61.8% and 80.2%."
  caption="TontaubeV1, not V1.1, against four systems, judged by Gemini over 800 order-balanced calls per pair. 50% is parity. Tontaube used a cloned reference while ElevenLabs, Gradium and Cartesia used stock voices, which the authors say may favour Tontaube (TontaubeV1.1-int4 model card, evaluation figure)."
/>

That caveat is the authors' own, and it matters: a reference recorded as a good audiobook read carries a good audiobook read into the output. On the Seed-TTS English set the report gives 1.66% WER with Whisper large-v3, a cleaner number to hold it to.

## tiny-voca: what "never heard a real human voice" means

tiny-voca is small enough to read completely: the [repository](https://github.com/n4ze3m/tiny-voca)'s package is about 3,300 lines of Python, and the [model card](https://huggingface.co/n4ze3m/tiny-voca) gives the parameter count to the unit, 4,537,291.

<Video
  src="https://ai.satyajit.si/articles/tiny-tts-roundup/clip1"
  poster="https://media.thesatyajit.com/ai/articles/tiny-tts-roundup/clip1-poster.jpg?v=1706e3b2045bd27e"
  alt="A dark screen with the tiny-voca wordmark and a waveform that lights up in orange as it plays, above a caption of the sentence being spoken: first 'Hi! I'm tiny voca, a text to speech model with just 4.5 million parameters' in the F2 voice, then 'The whole model is 18 megabytes, and it runs 70 times faster than real time on a CPU' in the M2 voice."
  caption="The launch video's first 15 seconds, muted here; each line in it was spoken by tiny-voca itself. The samples below have the audio (video from @n4ze3m's post on X)."
/>

### A FastSpeech 2 front, a source-filter back

The front half is FastSpeech 2 at a small width. Phonemes and their stress marks (from dizione, the author's own phonemizer) go into a 4-block transformer encoder. A duration predictor gives each phoneme a length in frames of 256 samples (10.7 ms at 24 kHz). The encoder states are repeated by those durations, and two frame-level transformers follow: one of 2 blocks that predicts pitch, voicing and energy, and one of 5 blocks that predicts the parameters of the waveform generator. Everything is 192 channels, 4 heads and rotary positions.

The back half is what makes 4.5M parameters possible. There is no neural vocoder. `SourceFilter` in `model.py` synthesises speech the way a 1970s vocoder did, with learned controls:

- A band-limited pulse train at the predicted pitch, computed in closed form as the sum of all harmonics below 0.47 of the sample rate, $\frac{\sin((K + \tfrac12)\theta)}{2\sin(\theta/2)} - \tfrac12$, with the top harmonic faded in and out so the signal stays continuous while pitch glides.
- White noise for the unvoiced parts: breath, `s`, `f`, the release of a `t`.
- Each is shaped by a filter that changes over time. Once per frame, a linear head predicts a cepstrum: 80 causal coefficients and 16 anti-causal ones for the harmonic branch (a minimum-phase vocal tract plus a maximum-phase part for the glottal pulse), 32 for the noise branch. The cepstrum becomes a complex frequency response through $H = \exp(\mathrm{FFT}(c))$ and multiplies the source's short-time spectrum.

The two linear heads that do all this have 25,862 parameters together. The rest of the network decides what the spectral envelope should be every 10.7 ms; turning that into samples is fixed signal processing. It is also why the card admits the voice "can sound slightly synthetic": a pulse-plus-noise source cannot express creaky voice or irregular glottal pulses.

### Where the voices came from

The training data is synthetic, and the pipeline is published in full: the [dataset](https://huggingface.co/datasets/n4ze3m/tiny-voca), its generation scripts and every rejected clip. Step through it:

<SyntheticCorpus />

The two voices began as sentences (F2: "an adult American woman in her mid twenties with a bright, clear, slightly higher-pitched voice"), rendered by Qwen3-TTS 1.7B VoiceDesign into 12-second reference clips. Qwen3-TTS 1.7B Base then read 8,984 sentences in both voices, 17,968 readings by my sum. Whisper small.en screened every clip; failures over 15% word error rate were regenerated, and 597 that failed twice were dropped, leaving 17,371 clips and 19.1 hours. That is the post's "19 hours". The model card's 17.6 hours is the training split after forced alignment with `facebook/wav2vec2-lv-60-espeak-cv-ft`, which accepted 17,326 of the 17,371 clips.

Now tick "where recorded speech entered" in the widget. The claim is precise and true about tiny-voca's weights: no recording of any person is in its training data, and it has no pretrained components. But every stage that decides what tiny-voca learns ran through a model trained on recorded human speech. The teacher made every waveform, Whisper decided which waveforms were correct, and the aligner decided how long each phoneme lasts. tiny-voca never heard a person. It learned from a model that heard many. The card says so: "the model cannot be more natural than the model that generated it." What the route buys is concrete: voices that belong to nobody, Apache-2.0 weights, a CC BY 4.0 dataset, and a recipe anyone with a voice-design model and ten dollars can repeat.

<Figure
  src="https://media.thesatyajit.com/ai/articles/tiny-tts-roundup/fig-cost.png?v=27d77f6dbf735bb2"
  alt="A bar chart titled 'tiny-voca: what it cost to make (total $9.56, one rented RTX 4090)'. Training the final model: $2.89, 7.7 GPU hours. First 11.5 hours of audio: $1.68, about 4.5 GPU hours. Second audio batch, alignment, failed tries and tests: $4.42, 11.8 GPU hours. Disk and network: $0.57."
  caption="The whole project's GPU bill. Generating and checking data cost more than training the model (tiny-voca model card, cost figure)."
/>

### The phonemizer, and the rest of the post

The thread's third post says the phonemizer "reads numbers, dates and money from context. 'RTX 4090' becomes 'forty ninety'." dizione's `normalize.py` has that rule, with the comment `# RTX 4070, ISO 9001` next to a branch that reads a four-digit model number as two pairs. Its README claims about 4,400 sentences a second with only NumPy. The second clip in the thread shows the point of it:

<Video
  src="https://ai.satyajit.si/articles/tiny-tts-roundup/clip2"
  poster="https://media.thesatyajit.com/ai/articles/tiny-tts-roundup/clip2-poster.jpg?v=5f5b949765b6f55d"
  alt="Two panels in sequence. First, a ChatGPT voice panel labelled 'skips the >' playing the text 'I think 67 > 66.' Then the tiny-voca browser demo labelled 'reads the >' with the same text, the Speak button pressed and an audio player appearing."
  caption="The symbol test from the thread: the same sentence with a greater-than sign, which the comparison skips and tiny-voca reads. Muted here; the claim is in the labels (video from @n4ze3m's post on X)."
/>

The rest checks out against the card:

- 4.5M parameters: 4,537,291 at inference.
- 18 MB: `tiny-voca.pt` is 18.2 MB of float32. The ONNX export is 21.4 MB, and the GGUF builds go down to 8.7 MB at `q4_0`.
- Runs on a CPU, about 70x real time on four threads: I measured 66.5x through the ONNX graph on four threads and 104.6x through PyTorch, 44.2x on one thread. The same ONNX file runs in the browser, which the [demo](https://tiny-voca.n4ze3m.com) does.
- \$9.56 in total, \$2.89 of it for the final 7.7-hour training run: the card's chart above. The post rounds the training share to "~\$3."
- Everything open: code, weights, dataset and recipe are all published, and the GitHub README gives the four commands that rebuild the model.

The evaluation is thin, and the card says so: Whisper small.en WER on 8 validation clips, 8 test clips and 16 new sentences, called "a sanity check, not a benchmark." There is no listening test. It is English only, two voices, no cloning, no streaming and no sampling.

## Same texts, one machine

One script, run on beast2: an Intel i7-6850K (6 cores, AVX2), 125 GB of RAM and an RTX 3090. Every model read the same five texts: a question, a number sentence, a 300-character passage, a names sentence and a 1,200-character passage. Times are end to end from text after a warm-up, the median of three runs except the long passage. Voices: Kitten's Eleanor, tiny-voca's F2, Tontaube's built-in voice with a fixed seed.

| model and path | threads | passage, x real time | long passage, x real time | peak RSS |
|---|---:|---:|---:|---:|
| tiny-voca, PyTorch CPU | 4 | 91.3 | 106.9 | 697 MB |
| tiny-voca, PyTorch CPU | 1 | 44.8 | 45.1 | 696 MB |
| tiny-voca, ONNX CPU | 4 | 72.2 | 65.1 | 734 MB |
| Kitten TTS 2 Mini, int8 ONNX CPU | 6 | 3.4 | 3.3 | 1,855 MB |
| Kitten TTS 2 Mini, int8 ONNX CPU | 1 | 1.2 | 1.2 | 1,851 MB |
| Kitten TTS 2 Mini, fp32 PyTorch CPU | 6 | 3.1 | 2.9 | 2,717 MB |
| TontaubeV1.1-int4, CPU | 6 | 0.5 | 0.43 | 8,072 MB |
| tiny-voca, PyTorch on the 3090 | | 325.2 | 301.3 | |
| Kitten TTS 2 Mini, PyTorch on the 3090 | | 105.5 | 72.9 | |
| TontaubeV1.1-int4, on the 3090 | | 5.1 | 6.25 | |

About 540 MB of each small-model RSS is the Python process before the model loads (PyTorch imported). Kitten's int8 graph is barely faster than its fp32 PyTorch weights here (3.3x against 2.9x on the long passage). With every weight expanded to float32 before the arithmetic, int8 buys the file size, not speed. One thread still runs it at 1.2x.

Whisper small.en got every word of all five Kitten clips. tiny-voca's long passage came back with one inserted word, and every short-passage clip from tiny-voca and Tontaube came back with "beams" for "beam", which I put down to Whisper or a soft final consonant. Tontaube dropped "you're" to "you" in the names sentence, and in the long passage it said "a small wooden crate" twice, the repetition its own card warns autoregressive generation can make. Its CTC guard, which retries pieces that skip text, does not catch a repeat. These are five texts per model, a sanity check like tiny-voca's own, not a benchmark.

The number sentence is a test of front ends. Every model's audio transcribed back to the original digits, so Whisper cannot tell how each read "RTX 4090". The phonemizers can. dizione turned it into "rtx forty ninety", as the post says, and "\$4,090" into "four thousand ninety dollars". Kitten's front end read "RTX 4090" as "four thousand and ninety". Tontaube got the raw digits, against its report's advice, and the transcript came back digit-perfect anyway.

<SameText />

I also cloned tiny-voca's synthetic F2 reference with Tontaube, a voice that never belonged to anyone, read by a model that never heard it before. That clip is in the run's output; I did not measure how close it is to F2, so I leave it out here.

The publishers' own clips, for comparison. Kitten TTS 2 Mini's card ships none.

<CardSamples />

## Which one I would use

If I needed many languages on a CPU with no server, I would take **Kitten TTS 2 Mini**. It is Kokoro's architecture in one 83 MB graph, 3.3x real time on six old cores, with an Apache licence. I would still want to know its training data before shipping it, and the card does not say.

If I needed one clean English voice inside a browser tab or on a phone, I would take **tiny-voca**, or more likely its recipe. A 26k-parameter synthesizer at a hundred times real time, and a \$10 recipe for a voice that belongs to nobody. Its ceiling is the teacher and the source-filter model.

**Tontaube** is the only one of the three that clones a voice and is built for whole chapters, and it is the only one that isn't small. It is a 2.9B-parameter model with three more models behind it, about 8 GB on disk, under half real time on the 6-core CPU I tried and about 5x on a 3090. The licence is free below EUR 200,000 of revenue and never free for a TTS service. For an audiobook rendered overnight on my own machine, that is fine. For anything I would sell, I would read the licence twice.

Related reading: [Paradee](/articles/paradee-tiny-tts) for distilling the same Kokoro architecture Kitten uses down to 8M parameters, [Pocket TTS with drifting](/articles/pocket-tts-drifting) for a 100M on-device model with a one-step sampler, [Breeze TTS 2](/articles/breeze-tts-2) for another Qwen3-backbone codec model, and [Nar TTS](/articles/nar-tts).

## Sources, and what I did not run

Read: the three X posts and their threads through the fxtwitter mirror; every model card; `config.json` for Kitten TTS 2 Mini and Kokoro-82M; the safetensors headers, by HTTP range request, of `kitten_tts_2_mini.safetensors`, the four full-precision TontaubeV1.1 checkpoints and the four int4 bundles; KittenML's `kittenml` package (git `d13d8c9`, identical to the 0.9.8 wheel apart from a Dockerfile), Tontaube's server at tag `v1.1.0` (`ef254ca`) and the TontaubeV1 technical report; tiny-voca at `62e2ade`, dizione at `8cd889e` and the tiny-voca dataset card, `voices.json` and generation scripts. The parameter totals, component groupings, byte counts and the bandwidth arithmetic are mine from those files. The judge results, the Seed-TTS WER, the 5090 speeds and tiny-voca's own WERs are the publishers'. Everything in the "Same texts, one machine" section, and the measured lines in the claim lists, came from one script run on beast2 (i7-6850K, RTX 3090) with `kittenml` 0.9.8, tiny-voca `62e2ade` and Tontaube `v1.1.0`, transcribed with Whisper small.en.
