tiny-voca English Text-to-Speech Model: 4GB+ VRAM, File List

Sample outputs are available on the model card.
At a Glance
| Item | Value |
|---|---|
| Repository | n4ze3m/tiny-voca |
| Published | 2026-11-15 |
| License | apache-2.0 |
| Formats | GGUF / ONNX |
| Source type | Primary source (the publisher itself) |
Values determined by this site’s code when the information was collected. Dates are JST.
Overview
n4ze3m has released “tiny-voca", a lightweight English text-to-speech (TTS) model. This model generates audio waveforms from input English text and supports two voice types: a female voice “F2" and a male voice “M2".
The entire model, including the waveform generator, is designed to be extremely compact with 4.5M (approximately 4.5 million) parameters. It was trained from scratch using approximately 18 hours of synthesized audio data and is reported to operate at about 70x faster than real-time on 4 CPU threads.
Specifications
The main specifications and details of tiny-voca listed in the documentation are as follows:
- Parameter count: 4,537,291 (total model), with 25,862 for the waveform generation part
- Architecture: Transformer Encoder (4 blocks), Duration Predictor, frame-level Transformer (2 blocks and 5 blocks), Source-Filter Synthesizer
- Block specifications: 192 channels, 4 heads, and Rotary Position Embeddings (RoPE) across all blocks
- Speech synthesis method: Uses a source-filter synthesizer with time-varying filters and pulse train/noise signals instead of a neural vocoder (256 samples per frame, 10.7 ms)
- Output specifications: 24 kHz mono audio
- Supported languages: English (American English)
- Voice types: Two types, F2 (female voice) and M2 (male voice)
- Input format: Text (converted to phoneme IDs and stress values by dizione)
- Training data: Approximately 18 hours of synthesized audio created with Qwen3-TTS VoiceDesign and generated by Qwen3-TTS 1.7B Base (no recordings of real speakers used). Phoneme alignment uses
facebook/wav2vec2-lv-60-espeak-cv-ft - Pretrained weights: None (trained from scratch)
- License: Apache-2.0
Performance and Quality
The model card publishes evaluation results where generated synthetic speech was transcribed using the speech recognition model “Whisper small.en" to measure the Word Error Rate (WER). Scores from recordings of the same sentences are also included as reference values.
| Sentences | Clips | WER, tiny-voca | WER, recordings |
|---|---|---|---|
| Validation | 8 | 0.6% | 0.6% |
| Test | 8 | 0.9% | 0.9% |
| New sentences, not in the dataset | 16 | 0.0% |
WER (word-level transcription error rate) indicates that lower numbers are more accurate and superior. The WER for tiny-voca’s synthesized speech is 0.6% on the validation set and 0.9% on the test set, showing error rates as low as the reference recordings. Additionally, the WER on new sentences not included in the training dataset was measured at 0.0%.
However, the publisher explains that these evaluation sets are small-scale and intended for sanity checks, and do not constitute official benchmarks or formal listening tests. Limitations are also mentioned in the model card, such as the speech being clear yet retaining a slightly synthetic quality, and the F2 voice sounding younger than intended.
Strengths and Use Cases
tiny-voca is suited for English text-to-speech in environments with restricted computing resources or where high processing speed is required. Capable of high-speed inference at about 70x real-time on a 4-thread CPU, it is envisioned for use in lightweight execution environments such as smartphones and web browsers (WebAssembly environments via onnxruntime-web).
The model’s strong use cases and functional features include:
- Two American English voices: Two stationary voices are available: female voice “F2" and male voice “M2".
- Automatic long-text splitting: Supports audio generation up to a maximum of 512 tokens and up to 32 seconds per utterance. Even when long text is input, a mechanism is provided to split the text into clauses, generate them, and finally concatenate and save the result.
- Audio control parameters: Speech speed (
speed), pitch shift amount (pitch-shift), and pitch variation range (pitch-range) can be flexibly modified. Specifying 0.058 for pitch shift allows adjustments of approximately one semitone.
On the other hand, functional limitations and points to keep in mind traded off for lightweightness are also presented:
- Supported language and voice limitations: Supports only English, and does not support voice addition or voice cloning features.
- Fixed intonation: Because intonation (prosody) sampling is not performed, the exact same audio is always generated from the identical text.
- Dependency on trailing punctuation: Inputting text without terminal punctuation such as a period can cause the last word to be cut off. Symbols like a period must be placed at the end of sentences.
- Pronunciation accuracy: Foreign personal names and irregularly spelled words may be misread. Furthermore, the reading accuracy of numbers, abbreviations, and homophones depends on the behavior of the phonemizer (dizione).
- Non-streaming generation: Does not support streaming playback output of audio.
Hardware Requirements
Estimated requirements (calculated by Local Model Watch)
| Your VRAM | Quantization | File size | Est. memory needed |
|---|---|---|---|
| 4GB (laptop iGPU / phone class) | Q4_0 | 0.0GB | 0.0GB |
Memory estimates add a 20% runtime overhead (KV cache, etc.) to the actual size of the distributed files. Actual usage varies with context length, batch size and inference engine. These figures are computed by this site from file sizes, not published by the model’s authors. Compare with other models in our VRAM quick reference. What the quantization names mean: glossary.
Can You Run It Locally?
The publisher distributes this model as GGUF / ONNX.
License — apache-2.0 (Commercial use allowed): Permits commercial use, modification and redistribution. Redistribution requires including the license and stating changes; includes a patent grant.
Compiled by this site’s code from the published formats and the license field. License summaries are not legal advice — check the publisher’s original terms before relying on them.
Distributed Files
Weight files published in n4ze3m/tiny-voca, listed by this site from the Hugging Face API. Sizes are the actual file sizes.
| File | Size |
|---|---|
gguf/tiny-voca-f16.gguf |
15MB |
gguf/tiny-voca-orig.gguf |
24MB |
gguf/tiny-voca-q4_0.gguf |
9MB |
gguf/tiny-voca-q8_0.gguf |
11MB |
onnx/model.onnx |
21MB |
tiny-voca.pt |
18MB |
How to Get It
tiny-voca is available on the Hugging Face repository (n4ze3m/tiny-voca). No prior access requests or license agreement procedures are required for use (no gated settings), and anyone can download and use it.
As distribution formats, PyTorch checkpoints (tiny-voca.pt) and ONNX format files (onnx/model.onnx) are provided.
Running with PyTorch
When using in a PyTorch environment, install the phonemizer library dizione and the tiny-voca package, then perform inference with the following steps:
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
Running with ONNX
When using the ONNX model, use onnxruntime and dizione. After converting text into phoneme IDs (tokens) and stress values (stress) using dizione, pass them to the session to obtain the audio waveform.
import numpy as np
import onnxruntime as ort
import soundfile as sf
import dizione # Requires setting 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()) # Scaling to prevent audio distortion
sf.write("hello.wav", audio, 24000)
Note that the generated audio waveform may occasionally have amplitude peak values exceeding 1.0 at a rate of about one in 20 sentences, so it is recommended to appropriately adjust the amplitude (preventing clipping) before saving the file as shown in the sample code above. Additionally, the ONNX model also runs in WebAssembly environments (onnxruntime-web) and outputs audio waveforms almost identical to the PyTorch version (peak amplitude difference within 0.6%).
Other Models for the Same Task
Recent audio models covered by Local Model Watch, newest first. Grouped by the task each publisher declares on Hugging Face (pipeline_tag); the smallest VRAM tier is this site’s estimate.
- TTS-V5 Chinese TTS Model: 4GB+ VRAM, File List (4GB)
- TTS-V4 Chinese Text-to-Speech Model: 8GB+ VRAM, File List (1.9B, 8GB)
- TTS-V3 Phone-Dialogue Specialized TTS Model: 8GB+ VRAM, File List (1.9B)
- higgs-audio-v3-stt-GGUF Speech-to-Text Model: 4GB+ VRAM, File List (2.7B, 4GB)
What to Read Next
- Find models by VRAM (This model runs from the 4GB tier) → Other models that run on a 8GB GPU
- What Q4_0 mean and where to get this model → GGUF format guide and models / ONNX format guide and models / Quantization and model-format glossary
- How to read WER → Benchmark glossary

