Introduction

Developer Muhammed Nazeem (n4ze3m on Hugging Face and GitHub) has released tiny-voca, a 4.5M-parameter English text-to-speech model with two voices. The whole model weighs 18 MB, and that includes the part that makes the waveform. The model card went up on November 14 (about 23:46 MYT), with the code and training recipe on GitHub a few minutes later. Everything is open: the weights and code are Apache-2.0, and the 17.6-hour training dataset is CC BY 4.0. The card says it runs about 70x faster than real time on four CPU threads, and you can try it right now in a browser demo that runs the model locally with ONNX Runtime Web.

The interesting part isn't only the size. Most small TTS models still run a neural vocoder at the end. tiny-voca uses a source-filter synthesizer instead: a pitch-driven pulse train and a noise signal, each shaped by a filter that the network predicts. That waveform head is only 25,862 parameters.

What Shipped

  • Model: tiny-voca by Muhammed Nazeem. It has 4,537,291 parameters and was trained from scratch, with no pretrained weights inside.
  • Voices: two fixed American English voices, F2 (female) and M2 (male).
  • Output: 24 kHz mono, up to 512 phoneme tokens or 32 s per call. Split longer text into sentences.
  • Controls: --speed, --pitch-shift and --pitch-range at inference time.
  • Files: tiny-voca.pt (18.2 MB, PyTorch float32), onnx/model.onnx (21.4 MB, opset 17) and the data files for the author's dizione phonemizer.
  • Runtimes: PyTorch, ONNX Runtime and ONNX Runtime Web (WebAssembly). According to the card, browser output matches PyTorch to within 0.6% of peak amplitude.
  • License: Apache-2.0 for code and weights, CC BY 4.0 for the dataset. The phonemizer files carry CMU Pronouncing Dictionary licenses.

How It Works

  • Front end: dizione turns text into phonemes, each with a stress value (none, primary or secondary).
  • Acoustic model: a 4-block transformer encoder reads the phonemes, and a duration predictor decides how long each one lasts. Two frame-level transformers (2 and 5 blocks) then predict pitch, voicing and energy, plus the synthesizer's parameters. Every block uses 192 channels, 4 heads and rotary position embeddings.
  • No neural vocoder: a band-limited pulse train at the predicted pitch and a noise signal pass through time-varying filters. The network predicts their cepstrum once per 256-sample frame (10.7 ms). The design borrows ideas from FastSpeech 2, DDSP and the neural homomorphic vocoder, but uses none of their code or weights.
  • Training: 104,737 steps on one RTX 4090 in 7.7 hours, using multi-resolution spectral losses plus a HiFi-GAN-style adversarial loss after step 8,000. The repo ships the full prepare → annotate → train → evaluate pipeline.
  • Fully synthetic data: both voices were designed from text descriptions with Qwen3-TTS VoiceDesign, and all 16,018 clips were generated with Qwen3-TTS 1.7B Base. No real speaker was recorded. That's handy for licensing, but it also sets a hard ceiling (see the caveats below).

Early Numbers

  • Author's sanity check: Whisper small.en WER of 0.6% on validation, 0.9% on test and 0.0% on 16 new sentences, matching the WER of the source recordings. The sets are tiny, and the card says plainly that this is a sanity check, not a benchmark, and that no listening test has been run.
  • Independent bench: one TTS benchmarker
    and measured 110–221x real time on a Ryzen 9950X3D CPU (on more threads than the card's four), with UTMOS around 4.40.

Where to Run It Today

  • Browser: open the tiny-voca demo, type a line and pick F2 or M2. It runs on your own machine, with no server inference.
  • Local (PyTorch):

pip install git+https://github.com/n4ze3m/dizione git+https://github.com/n4ze3m/tiny-voca
hf download n4ze3m/tiny-voca --local-dir tiny-voca
export DIZIONE_DATA=tiny-voca/phonemizer
python -m tiny_voca.infer --checkpoint tiny-voca/tiny-voca.pt \
  --voice F2 --text "Hello! This is tiny voca." --output hello.wav

  • Apps and the web: use onnx/model.onnx with onnxruntime or onnxruntime-web. It takes phoneme ids, stress values, a voice index (0 = F2, 1 = M2), speed and two pitch controls, and returns the waveform plus per-token durations. Those durations are useful for captions or lip-sync timing.
  • Train your own: the web demo source is in web/ and the training scripts are in the repo. At under 8 GPU-hours, you can realistically train a custom two-voice model on one consumer card.

Caveats

  • English only, two voices, no cloning. It isn't a voice-cloning or multilingual model.
  • It can't beat its teacher. It's trained entirely on Qwen3-TTS output, so it can only be as natural as Qwen3-TTS. The author admits it can sound slightly synthetic.
  • Deterministic reads. The same text always comes out the same way, because there's no prosody sampling.
  • Front-end limits. Foreign names, odd spellings, numbers, abbreviations and homographs depend on the phonemizer and are often misread.
  • No streaming yet.
  • Crowded lane. Tiny CPU TTS has been busy this month. Compare it with Kitten TTS 2, Kyutai Pocket TTS 4.0 and LeoKani TTS 7M before you commit. What sets tiny-voca apart is the open dataset and recipe and the vocoder-free design.
  • Brand-new. At release it had a handful of likes, zero downloads and no paper. Every number here comes from the card or one early tester.

Conclusion

tiny-voca is a neat proof that you don't need a neural vocoder to get clear speech out of a model smaller than most phone wallpapers. A 26K-parameter source-filter head, an 18 MB checkpoint and a browser demo that runs locally make it a natural fit for offline narration in web games, accessibility read-aloud, kiosks and other embedded voice UIs. Having the full dataset and recipe open matters just as much, because anyone can now train their own small voice in an afternoon on a single 4090. Try the demo with a tricky line full of numbers and names first, so you hear its limits before you ship it.

—Anabel ♡