Three small TTS models: Kokoro's graph in int8, 2.9B parameters on a CPU, and a voice trained on no recordings
mdjsonmcp2026-11-16 · 23 min · tts · speech · small-models · on-device · synthetic-data · quantization
A 2:42 narrated explainer, drawn in code. Every number and picture in it is this article's own; the sources are below.
› transcript
This voice is a model with four and a half million parameters. And it was trained without a single recording of a person. Hi, I'm Ravel. Three text to speech models came out this week, all called small. They mean different things by it. Start with tiny voca. Its waveform begins as a pulse train, one click per vocal fold cycle, at the pitch the network predicts. Beside it, plain noise, for breath and hiss. Every ten point seven milliseconds the network predicts a filter for each source, as a cepstrum. Filter both, add them, and you have speech. The whole synthesizer is twenty-five thousand eight hundred and sixty-two parameters. The two voices began as sentences describing them, rendered by a bigger model, Qwen three T T S. That teacher read every sentence in both voices. Whisper checked each clip, and failures were made again or dropped. An aligner timed every phoneme. Then tiny voca trained from scratch, in under eight hours on one GPU. No person in the data. But the teacher, Whisper and the aligner all learned from people. The whole project cost under ten dollars of GPU time. Making the data cost more than training. Kitten T T S two Mini has Kokoro's exact configuration. Phonemes go through a small BERT, then a prosody predictor. A voice is just a file, a table of style vectors with one row per input length. The decoder makes the waveform. It is two thirds of the model, stored as int eight, eighty-two point seven megabytes. Tontaube is two point nine billion parameters in four transformers, one per codebook. The first decides the words and the timing. Three smaller ones add acoustic detail. The second refinement is smaller again. In four bits, each frame still reads every one of them. And the third is the smallest. About one point two gigabytes of weights per eighty milliseconds. Real time needs about fifteen gigabytes a second from memory, before any arithmetic. That is the floor, not the whole bill. Then I ran all three on one old six-core CPU. tiny voca made speech over a hundred times faster than real time, Kitten about three times, and Tontaube under half. On a GPU, Tontaube reached about five times. Small can mean parameters, bytes or bits. Check which one before you ship it. A filtered buzz, Kokoro at one byte a weight, and a big model your CPU has to keep up with. Every source is in the full article. I'm Ravel. Bye!
Why read this
Solidtop 85%Three small TTS releases checked against their own files: what each architecture is, what small costs, and what a synthetic-only voice really means.
- Original analysis
- Runs on a laptop CPU
- Concrete numbers to act on
Speech & audioPractitioner roundup
How this was scored
- Is it new?
- 1 of 3: An incremental tweak
- Can I trust it?
- 2 of 3: Measures key facts from files, code or configs
- Can I run it?
- 2 of 3: Open code or weights with real limits
- Will I understand it?
- 2 of 3: Mechanism from first principles with figures
- Can I act on it?
- 2 of 3: A concrete recipe, numbers or comparison
- Will it last?
- 1 of 3: Relevant for months
- Does it affect many?
- 1 of 3: A specialist community
- Only here?
- 2 of 3: A teardown or measurement few others did
Score 59 of 100, ranked 462 of 748 rated articles. Each question is answered 0–3 by hand, and a 3 is rare. How articles are scored
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: 82M parameters, 16 languages, 118 voices, an 82.7 MB int8 ONNX file, no PyTorch needed. TeksEdge posted 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: "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.
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 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 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 (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. 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
.onnxis 82,711,386 bytes). - 118 voices: 118 voice packs under 73 names.
- No PyTorch needed: true of the ONNX graph. But the
kittenmlpackage'ssetup.pyinstallstorch>=2.6,torchaudio,transformers,diffusersand 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 and Qwen Audio 3.0 TTS. It comes from Fritz and Jonathan Cremer in Berlin, with a TontaubeV1 technical report, full-precision weights, the int4 release the post is about, and an inference server.

Speech as four rows of codes
Speech is encoded by DualCodec 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.

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.pypins 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.jsondefines 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:

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's package is about 3,300 lines of Python, and the model card gives the parameter count to the unit, 4,537,291.
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, , 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 at. - 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 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, its generation scripts and every rejected clip. Step through it:
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.

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:
The rest checks out against the card:
- 4.5M parameters: 4,537,291 at inference.
- 18 MB:
tiny-voca.ptis 18.2 MB of float32. The ONNX export is 21.4 MB, and the GGUF builds go down to 8.7 MB atq4_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 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.
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.
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 for distilling the same Kokoro architecture Kitten uses down to 8M parameters, Pocket TTS with drifting for a 100M on-device model with a one-step sampler, Breeze TTS 2 for another Qwen3-backbone codec model, and 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.