On 18 November 2026, Tiny Voca is a 4.5-million-parameter English text-to-speech model with a documented 21.4 MB ONNX export and an 8.7 MB Q4_0 GGUF file. Its ONNX route is verified; a working Tiny Voca GGUF runtime is not yet documented publicly.
At a glance
- Tiny Voca publishes two fixed American English voices, F2 and M2, at 24 kHz mono output.
- The model card reports about 70× real-time synthesis on four CPU threads.
- The smallest published Tiny Voca download is the 8.7 MB Q4_0 GGUF variant.
- The ONNX graph accepts phoneme IDs and produces waveform audio, with one utterance limited to 512 tokens or 32 seconds.
- Zyphra ZONOS3-Mini targets a different job: it lists 43 languages and voice cloning, but its published backbone GGUF is 0.7 GB.
Which local runtime is actually verified?
Tiny Voca has one clear local deployment path: ONNX Runtime. The model card publishes a float32 ONNX file, identifies it as opset 17, and provides Python inference code using onnxruntime. It also says the same graph runs in onnxruntime-web through WebAssembly, making a browser application a documented option.
ONNX Runtime’s web documentation lists browser deployment options including WebAssembly, WebGPU and WebNN. Tiny Voca’s own instructions specifically support the WebAssembly route. That distinction matters: a browser fit is verified, but a claim about GPU acceleration is not supplied for this model.
The model page carries a GGUF tag and hosts several GGUF variants. But it does not provide a Tiny Voca command for llama.cpp, Ollama, LM Studio, or another GGUF application. GGUF is a file format, not proof that every runtime understands this speech model’s architecture and inputs.
Which Tiny Voca file should you download?
The choice is mainly between documented runtime support and storage size. Tiny Voca’s published file list places the ONNX export at 21.4 MB, while the smallest listed GGUF file is 8.7 MB. A smaller file can reduce download and storage needs, but it is not automatically the safer integration choice.
| Concrete option | Exact published size | Runtime status | Best fit | Evidence tier |
|---|---|---|---|---|
| Q4_0 GGUF | 8.7 MB | GGUF file published; Tiny Voca runnable command not published | Storage-first experiments where you can validate the runtime yourself | Primary: model card size Runtime gap remains |
| Q8_0 GGUF | 10.9 MB | GGUF file published; Tiny Voca runnable command not published | A higher-size GGUF option for testing compatible community tooling | Primary: model card size Runtime gap remains |
| F16 GGUF | 14.9 MB | GGUF file published; Tiny Voca runnable command not published | Format testing where reduced precision is not your first priority | Primary: model card size Runtime gap remains |
| PyTorch checkpoint | 18.2 MB | Official Python package instructions published | Python projects that can install the project package and phonemizer | Primary: model card instructions |
| ONNX export | 21.4 MB | Official ONNX Runtime example published | Browser, desktop or service integration with a defined interface | Primary: model card instructions |
File sizes are published download figures. They are not measured RAM requirements, and no Tiny Voca hardware-memory test is publicly specified.

Our calculation starts with those published weight-file sizes, not with a benchmark. The 8.7 MB Q4_0 file sets a bare storage floor for that variant. Actual memory use will be higher because an application also needs runtime code, audio buffers, the phonemizer, and temporary working memory.
What does Tiny Voca’s speed claim mean?
Tiny Voca’s author reports synthesis at about 70 times real time on four CPU threads. In plain terms, one second of speech should take far less than one second to generate in that stated setup. The claim does not name the CPU, operating system, audio length, or timing method.
That makes the number useful as a sign that local CPU use is plausible, not as a purchasing benchmark. It does not establish latency on a phone, a Raspberry Pi, a browser tab, or a low-power laptop. It also does not describe first-run loading time.
The model has a practical per-call ceiling. The published interface accepts one utterance of up to 512 tokens or 32 seconds, then asks applications to split longer text into sentences. Tokens here mean phoneme symbols, the speech-sound units the model reads, rather than the words a reader sees.
How good is the speech, and what is not measured?
Tiny Voca’s evaluation section reports word error rates of 0.6% on validation clips and 0.9% on test clips after transcription by Whisper small.en. The author explicitly calls these tiny sets a sanity check, not a benchmark. The reported recordings scored the same on the two named internal sets.
The same page includes a 16 November 2026 Open TTS Leaderboard snapshot. Those are useful signals about intelligibility, but they do not prove every listener will prefer the voices.
Most importantly, no formal listening test is published. Tiny Voca’s own limitations say its speech can sound slightly synthetic, F2 sounds younger than intended, and prosody is deterministic. Prosody means the rhythm, stress and pitch movement that make speech sound expressive.
Can Tiny Voca replace ZONOS3-Mini?
No, not if you need voice cloning or broad language coverage. Zyphra ZONOS3-Mini lists 43 languages and a voice-cloning tag, while Tiny Voca is English-only with two fixed voices. They solve different deployment problems despite both publishing GGUF files.
The file-size gap is equally large. Zyphra’s published ZONOS3-Mini backbone GGUF files are 0.7 GB, while Tiny Voca’s smallest Q4_0 GGUF is 8.7 MB. By our calculation from those published files, the Tiny Voca download is the appropriate starting point when device storage and distribution size matter more than language range or cloning.
ZONOS3-Mini also provides direct llama.cpp and Ollama examples on its model page. That is evidence Tiny Voca does not yet match: the Tiny Voca page publishes GGUF weights, but not a matching GGUF execution recipe. Do not infer runtime parity from a shared extension.
Why does quantization not settle the choice?
Quantization stores model numbers with fewer bits, usually reducing file size and memory pressure. Google’s explanation of Q4_0 describes it as a common lower-precision format used with local inference tools. It does not certify Tiny Voca’s audio quality in Q4_0.
That is the missing experiment for this release. Tiny Voca publishes the Q4_0, Q8_0 and F16 GGUF sizes, but it does not publish an intelligibility comparison, listening test, or speed comparison between those variants. The smallest file is a practical download choice, not a documented sound-quality winner.
Do not use training-hardware examples as a proxy for inference needs. Google’s Gemma fine-tuning guide uses an NVIDIA T4 with 16 GB for a different model-training task. Tiny Voca’s published local inference claims do not require that kind of hardware statement.
How does Tiny Voca turn text into sound?
Tiny Voca does not send ordinary written text directly through the ONNX graph. The related Dizione project supplies the English text-to-phoneme stage, which converts writing into speech sounds and stress values. The ONNX graph then receives those IDs, plus a voice choice, speed, pitch shift and pitch range.
The Tiny Voca architecture description says it uses a source-filter waveform synthesizer rather than a neural vocoder. In simple terms, it builds speech from a pitched pulse or noise source shaped by predicted filters. The waveform head has 25,862 parameters within the model’s 4,537,291 total.
The project was created quickly and with synthetic training speech. Its repository record says the project was created on 14 November 2026 and had no published release by 18 November. That explains both the unusually small footprint and the still-developing deployment ecosystem.
What should you actually do?
Choose Tiny Voca if you need an English-only, two-voice local narrator and you can accept a fixed voice. Start with the ONNX export, because its inputs, outputs and runtime example are documented. Use it for product demos, offline reading tools, embedded help text, or browser experiments where a small download matters.
- Choose ONNX first if you need a working implementation now.
- Choose the 8.7 MB Q4_0 GGUF only for evaluation until you have confirmed the exact local runtime handles Tiny Voca correctly.
- Choose ZONOS3-Mini instead if voice cloning or multilingual output matters more than a very small model file.
- Test names, numbers and abbreviations before shipping, because the project flags unusual spellings and foreign names as weak points.
- Split long text by sentence to stay inside Tiny Voca’s published utterance limit.
What we could not verify?
No public Tiny Voca benchmark identifies the CPU behind the 70× real-time claim. No official comparison measures Q4_0, Q8_0 and F16 speech quality, latency, or memory use. The project maintainer could settle those questions with reproducible scripts, named hardware and paired audio tests.
A 18 November repository update mentions a Core ML port in a community list, but does not publish a Tiny Voca conversion guide or compatibility matrix. Apple’s Core ML documentation identifies the target platform, not the status of this particular model. A public model package and a runnable example would settle Apple-device support.
Finally, the published GGUF files do not establish which local GGUF applications support Tiny Voca. A tested command, supported runtime version and sample audio from the maintainer would turn that promising format option into a verified deployment route.
Sources
- n4ze3m/tiny-voca model card on Hugging Face
- Zyphra/ZONOS3-Mini model card on Hugging Face
- Tiny Voca repository commit record
- Dizione repository commit record
- ONNX Runtime web documentation
- Google on quantization-aware-trained Gemma 3 models
- Google Gemma full fine-tuning guide
- Apple Core ML documentation
