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

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.

See all audio models →

What to Read Next

Sources