TL;DR
tiny-voca (n4ze3m/tiny-voca) is an English text-to-speech model with 4,537,291 parameters: an 18.2 MB float32 checkpoint that includes its own waveform generator. It has two fixed American English voices, F2 (female) and M2 (male), outputs 24 kHz mono audio, and runs in PyTorch, ONNX Runtime, ONNX Runtime Web (in the browser), llama.cpp, plain JavaScript and, through community ports, on an ESP32-S3 microcontroller. Muhammed Nazeem trained it from scratch on 17.6 hours of synthetic speech, and says the whole project cost $9.56 of rented GPU time.
Facts as of November 19, 2026:
- 757 GitHub stars, 96 forks, created November 14, 2026
- Apache-2.0 for code and weights; CC BY 4.0 for the dataset
- 0 open issues (1 closed); no tagged releases yet, the package is at version 0.2.0 in
pyproject.toml - More than 20 community forks for other languages (German, Italian, Turkish, Korean, Japanese, Polish, Spanish, French, Portuguese, Arabic, Hindi, Bengali and more) listed in the README after five days
Not run by us: our hands-on lab (a throwaway GitHub Actions container) could not start on November 19, 2026 because GitHub refused the job over a billing limit on the account. Everything below comes from the repository, the model card, the design docs, the llama.cpp docs and independent write-ups. We did not install tiny-voca or generate audio with it, so we cannot tell you how its numbers, dates and prices sound.
Our verdict: tiny-voca is the best-documented small TTS model we have read this year. Its most interesting idea is that the model needs no neural vocoder: a 25,862-parameter source-filter head turns the network’s predictions into sound. That is why it fits in 18 MB and runs far faster than real time on a laptop CPU. The cost is a voice that the author himself calls “slightly synthetic”, two voices only, no cloning, and no variation between readings. Pick it for a browser tab, a kiosk, a phone app or a microcontroller where one clear English voice is enough. Pick something larger for audiobooks.
What problem tiny-voca solves
Most open TTS models that sound good are big. KittenTTS 2 Mini and Kokoro are both 82M parameters. That is small next to a speech language model, but it is still tens of megabytes of weights and a runtime that takes a real chunk of a phone’s memory.
tiny-voca asks a narrower question: how small can an English voice be if you only need one or two of them, and you design the whole stack around that? The answer is about 20 times smaller than Kokoro. On the hardware side, the README claims “about 70x real time on four CPU threads”. One independent reviewer, Satyajit Ghana, measured 91 to 107x real time through PyTorch on four threads of a six-core Intel i7-6850K, about 45x on one thread, and 65 to 72x through the ONNX graph. Those are his numbers on his machine, not ours.
How it works: no neural vocoder
The architecture, from the project’s model notes, has two halves.
The front half is FastSpeech 2 at a small width. Text becomes phonemes with stress marks. A 4-block transformer encoder reads them, a duration predictor gives each phoneme a length in frames, and two frame-level transformers (2 and 5 blocks) predict pitch, voicing and energy, then the filter parameters. Every block uses 192 channels, 4 heads and rotary position embeddings. Durations, pitch and energy are predicted explicitly, so the model is not autoregressive: the same text always produces the same speech.
The back half is old-school signal processing with learned controls. Instead of a HiFi-GAN-style vocoder, which is usually most of a TTS model’s weight, tiny-voca builds a band-limited pulse train at the predicted pitch plus a noise signal. Each is shaped by a time-varying filter whose cepstrum the network predicts once per frame (256 samples, 10.7 ms at 24 kHz). The parameter table makes the trade obvious:
| Component | Parameters |
|---|---|
| Embeddings (phoneme, stress, voice) | 16,704 |
| Text encoder | 1,588,864 |
| Duration and pause predictor | 123,906 |
| Frame transformer A, prosody head | 795,971 |
| Frame transformer B | 1,985,984 |
| Source-filter waveform head | 25,862 |
| Total at inference | 4,537,291 |
Ghana’s write-up points out the downside: a pulse-plus-noise source cannot produce creaky voice or irregular glottal pulses, which is part of why the result can sound synthetic.
Where the voices came from
No person was recorded. Both voices were designed from text prompts with Qwen3-TTS VoiceDesign (the F2 prompt asked for “an adult American woman in her mid twenties”). Qwen3-TTS 1.7B Base then read the dataset in those two voices. Whisper small.en screened every clip and rejected any over 15% word error rate. Forced alignment with facebook/wav2vec2-lv-60-espeak-cv-ft labelled phoneme durations.
The dataset has 17,371 clips (19.1 hours); the training split is 16,018 clips and 17.6 hours. The sentences come from LibriTTS-R transcripts, Mozilla Common Voice and project templates for numbers, dates, money, names and questions. Training took 104,737 steps and 7.7 hours on one RTX 4090.
Two consequences follow, and the model card states both. First, the voices belong to nobody, which matters if you ship a product and do not want to argue about whose voice it is. Second, “the model cannot be more natural than the model that generated it.” tiny-voca is a student of Qwen3-TTS. Its ceiling is the teacher.
Install and first commands
The README quick start, for Python 3.10 or later:
git clone https://github.com/n4ze3m/tiny-voca.git
cd tiny-voca
pip install -e ".[own]"
hf download n4ze3m/tiny-voca --local-dir weights
export DIZIONE_DATA=weights/phonemizer
python -m tiny_voca.infer \
--checkpoint weights/tiny-voca.pt \
--voice F2 \
--text "Hello! This is tiny voca." \
--output hello.wav
The [own] extra installs dizione, the author’s own phonemizer. Earlier checkpoints used eSpeak NG (GPL-3.0); the released one does not, so the stack stays Apache-2.0. Options: --voice F2|M2, --speed, --pitch-shift, --pitch-range, and --text-file.
Long text works: speak_text in infer.py splits text into sentences (not after “Dr.” or inside numbers), cuts overlong sentences at commas, joins the audio and keeps the peak at or below 0.99. If nothing can be pronounced (Russian or Chinese input, say), it exits with “tiny-voca only reads English for now” and writes no file.
ONNX, with no PyTorch
The model card ships a 21.4 MB ONNX export (opset 17). The graph takes phoneme IDs and stress values and returns the waveform:
import numpy as np
import onnxruntime as ort
import soundfile as sf
import dizione # needs DIZIONE_DATA=tiny-voca/phonemizer
phones = dizione.phonemize("Hello! This is tiny voca.")
one = lambda value: np.array([value], dtype=np.float32)
session = ort.InferenceSession("tiny-voca/onnx/model.onnx")
audio, durations = session.run(None, {
"tokens": np.array([phones.ids], dtype=np.int64),
"stress": np.array([phones.stress], dtype=np.int64),
"voice": np.array([0], dtype=np.int64), # 0 = F2, 1 = M2
"speed": one(1.0),
"pitch_shift": one(0.0),
"pitch_range": one(1.0),
})
audio = audio[0]
audio = audio * min(1.0, 0.99 / np.abs(audio).max()) # the model can peak above 1.0
sf.write("hello.wav", audio, 24000)
Two details the card is honest about: one call handles up to 512 tokens and 32 seconds, so you split long text yourself; and about one sentence in twenty peaks a little above 1.0, which clips when saved as 16-bit samples unless you scale it as above.
llama.cpp and plain JavaScript
llama.cpp now supports tiny-voca through llama-tts and the OpenAI-compatible /v1/audio/speech endpoint of llama-server, from GGUF files:
llama-tts -m tiny-voca.gguf \
-mm mmproj-tiny-voca.gguf \
-p "Hello! The meeting moved to 3:30 pm." \
--tts-voice F2 \
--output out.wav
The llama.cpp port moves dizione’s rules into the model’s chat template, so numbers, dates, units and web addresses are normalized without Python.
The repo’s js/ folder has the model and phonemizer in plain JavaScript with no npm packages, reading one 8 MB GGUF file: node js/say.mjs "Hello! This is tiny voca." --voice M2 --output hello.wav. The project reports 9.7x real time for Node 24 and 13.4x for Bun 1.3 on one thread of an Apple M5.
The phonemizer is half the product
For a model this small, the text front end decides most of what a listener hears as an error. dizione handles numbers, dates, money, units, abbreviations and chat words; it picks between homographs such as “read” (present) and “read” (past) from context; and a small model guesses words that are not in its CMUdict-based dictionary. Its README claims about 4,400 sentences per second with NumPy only and 5.4 MB of data.
Ghana’s review checked one rule against the code: dizione reads “RTX 4090” as “forty ninety”, where Kitten’s front end read it as “four thousand and ninety”. You can also write a pronunciation inline, Say {HH AH0 L OW1} to everyone, or pass overrides.
dizione’s README is also blunt about the weak spot: “About one unknown word in three has an error. Foreign names are the worst.” If your app reads product names, people’s names or anything non-English mixed into English, budget time for an override list.
The quality numbers, read carefully
The model card reports Whisper small.en word error rates of 0.6% on 8 validation clips, 0.9% on 8 test clips and 0.0% on 16 new sentences, and calls them “a sanity check, not a benchmark”. No formal listening test has been run.
The stronger evidence is the Hugging Face Open TTS Leaderboard. According to the snapshot quoted on the model card (November 16, 2026, v1.6.3, English, no voice cloning, 50 ranked models), the M2 voice ranks 8th by average WER at 0.733% with a UTMOS22 of 4.34, and F2 ranks 13th at 0.773% and 4.43. Models just above M2 include phonon-31m-en (41M) and Inflect Micro v3 (12M); LFM3-Audio-2B (2.05B) sits just below F2.
What that does not tell you: WER measures whether a speech recognizer understood the words, not whether a person enjoys listening. UTMOS22 is a predicted naturalness score, and tiny-voca’s M2 scores lower on it than most of its neighbours. The author has said himself that he “never created Voca to compete with other models or top a benchmark.” Treat the leaderboard as proof that it is intelligible, not that it sounds as good as Kokoro.
Community reaction
The r/LocalLLaMA launch thread on November 14 got about 70 points and 32 comments, according to a dev.to roundup. Nazeem wrote plainly: “I made it with Qwen3-TTS, so the model can’t sound better than that.”
The stronger signal is the forks. Within five days people trained versions for more than 20 languages and ported the model to Rust, Core ML, an ESP32-S3 and a Mac app. A cheap, repeatable recipe is what makes it spread.
Honest limitations
- English only, two fixed voices, no cloning. For other languages you need a community fork, each with its own quality and license terms (the Japanese one uses a character voice under that voice’s own terms).
- The F2 voice sounds younger than intended. The author says so and plans a more mature voice.
- No variation. There is no prosody sampling, so the same text is read the same way every time. Fine for a kiosk or notifications; noticeable across an audiobook chapter.
- Slightly synthetic sound. The source-filter design is the reason the model is tiny, and also the reason it cannot match a neural vocoder on breathiness and texture.
- Foreign names and odd spellings are often wrong. This sits in the phonemizer, not the network.
- No streaming yet. The browser demo plays each sentence as soon as it is ready, which covers many real-time uses.
- Thin evaluation. 32 clips of self-reported WER plus a leaderboard snapshot. No listening test.
- A five-day-old project. No tagged releases and no production track record yet.
How it compares
| tiny-voca | KittenTTS 2 Mini | Kokoro-82M | |
|---|---|---|---|
| Parameters | 4.5M | 82M | 82M |
| Download | 18 MB fp32 (8.7 MB GGUF q4_0) | 83 MB int8 ONNX | ~327 MB fp32 |
| Languages | English (forks for 20+) | 16 | several |
| Voice cloning | No | No | No |
| Vocoder | Source-filter, 26k params | ISTFTNet | ISTFTNet |
| License | Apache-2.0 | Apache-2.0 | Apache-2.0 |
Kitten and Kokoro figures come from Ghana’s roundup. For many languages or voices, take a Kokoro-family model. For cloning, look at Pocket TTS or VoxCPM2. For one English voice in the smallest footprint, tiny-voca is in a class of its own.
FAQ
Is tiny-voca free for commercial use?
Yes. Code and weights are Apache-2.0, the dataset is CC BY 4.0, and the released checkpoint no longer depends on GPL-licensed eSpeak NG. The voices were generated from text descriptions, so no real speaker’s likeness is involved. Community language forks have their own licenses; check each one.
Does tiny-voca need a GPU?
No. It was trained on a GPU, but inference is designed for CPUs. The project reports about 70x real time on four CPU threads, and an independent reviewer measured roughly 45x on a single thread. It also runs in a browser through ONNX Runtime Web; try the demo.
Can tiny-voca clone my voice?
No. It has exactly two built-in voices, F2 and M2. To get a new voice you would train your own model with the published recipe: design a voice with a large TTS model, generate a few hours of audio, and train. The author’s full project cost $9.56 of GPU time, including failed attempts.
Can I use tiny-voca with an OpenAI-compatible API?
Yes, through llama.cpp. llama-server exposes /v1/audio/speech and supports tiny-voca from the ggml-org GGUF files, with --tts-voice F2 or M2 and a speed parameter from 0.25 to 4.
How does it handle numbers, dates and prices?
Through the dizione phonemizer, which has rules for numbers, money, times, dates, units, phone numbers and abbreviations. The model card’s own samples include “The meeting moved to 3:30 pm on March 14th”. We could not listen to our own test sentences because our lab was down, so try your hardest text in the browser demo before you commit.
Verdict
tiny-voca does one thing and documents every step of it: a clear, intelligible English voice in 18 MB, with an open dataset and a recipe anyone can repeat for about ten dollars. The source-filter design pays off in size and speed, and the ecosystem that appeared in five days shows the recipe is the real product. Its limits are just as clear: two voices, no cloning, identical readings, and a sound that will not pass for human. For notifications, accessibility, offline assistants and anything in a browser tab or on small hardware, it is the first model we would try. For long-form narration, use something bigger.
Sources
- n4ze3m/tiny-voca on GitHub: README, stars, license, issues, community list
- tiny-voca model and data notes
- tiny-voca model card on Hugging Face: files, ONNX usage, evaluation, leaderboard snapshot, limitations
- tiny-voca dataset
- dizione phonemizer
- tiny-voca plain-JavaScript build
- llama.cpp TTS docs: tiny-voca
- Open TTS Leaderboard v1.6.3
- tiny-voca browser demo
- Satyajit Ghana: Three small TTS models
- r/LocalLLaMA launch thread
- Sub-10M TTS Models Are Everywhere (dev.to)