Skip to content
Projects

tronghieuit/tiny-tts has 640 GitHub stars and 67 forks. GitHot measured 0 stars in 24 hours. Last checked 2026-11-16 04:22 UTC. Last push 2026-04-10.

How these counts are measured

What you can do

  • Parameters - ~1.6M - 50M–200M+
  • Checkpoint size - ~3.4 MB (ONNX FP16) - 200 MB–1 GB+
  • Sample rate - 44.1 kHz - 22.05–44.1 kHz
  • End-to-end - Yes - Often requires separate vocoder

Measured star growth

in 24h
0
in 7 days
Update delayed
in 15 days
Update delayed
in 1 month
Update delayed

Net star changes over overlapping periods, not daily totals. Missing measurements are left blank. Stars measure attention, not software quality.

About

The Smallest English TTS Model with only 1M parameters

Developer Tools

README.md

Original

TinyTTS

TinyTTS

Ultra-lightweight English Text-to-Speech — only 1.6M parameters, ~3.4 MB ONNX

PyPI PyPI Downloads npm npm Downloads Open in Spaces


Highlights

TinyTTS is an end-to-end text-to-speech model that delivers natural-sounding speech with a fraction of the resources required by conventional TTS systems.

Metric TinyTTS Typical TTS Models
Parameters ~1.6M 50M–200M+
Checkpoint size ~3.4 MB (ONNX FP16) 200 MB–1 GB+
Sample rate 44.1 kHz 22.05–44.1 kHz
End-to-end Yes Often requires separate vocoder

With only 1.6 million parameters and an ONNX model of just ~3.4 MB (FP16), TinyTTS runs comfortably on CPU-only machines, edge devices, and embedded systems — making real-time speech synthesis accessible without a GPU.

Installation

Python (PyPI)

pip install tiny-tts

PyPI: https://pypi.org/project/tiny-tts/

Or install from source:

git clone https://github.com/tronghieuit/tiny-tts.git
cd tiny-tts
pip install -e .

After installing, the tiny-tts command is available globally:

tiny-tts --checkpoint G.pth --text "Hello world" --device cuda

Node.js (npm)

npm install tiny-tts

npm: https://www.npmjs.com/package/tiny-tts

Pure Node.js inference via ONNX Runtime — zero Python dependency. The ONNX model (~6 MB) is auto-downloaded from HuggingFace on first use.

Dependencies (Python, source install only)

pip install torch torchaudio soundfile g2p-en transformers numba

Quick Start

Basic inference

tiny-tts \
  --text "The weather is nice today, and I feel very relaxed." \
  --checkpoint G.pth \
  --output output.wav \
  --speaker MALE \
  --speed 1.0 \
  --device cuda

CPU inference

tiny-tts \
  --text "The weather is nice today, and I feel very relaxed." \
  --checkpoint G.pth \
  --device cpu

Output files are saved to infer_outputs/.


Python API

You can easily use TinyTTS directly in your Python code:

from tiny_tts import TinyTTS

# Initialize the TTS model (auto-detects device and downloads default checkpoint if missing)
tts = TinyTTS()
# OR specify a custom checkpoint: tts = TinyTTS(checkpoint_path="...")

# Synthesize a single sentence
tts.speak("Hello, this is a test of the Python API.", output_path="hello.wav")

# Adjust speech speed (1.0=normal, 1.5=faster, 0.7=slower)
tts.speak("This is faster speech.", output_path="fast.wav", speed=1.5)
tts.speak("This is slower speech.", output_path="slow.wav", speed=0.7)

# Synthesize a long paragraph (5 sentences)
paragraph = (
    "TinyTTS is an ultra-lightweight text-to-speech model. "
    "It has only one point six million parameters, which makes it extremely fast. "
    "You can run it easily on your local CPU without a dedicated graphics card. "
    "The audio quality remains surprisingly clear despite the small model size. "
    "I hope you enjoy building exciting applications with it!"
)
tts.speak(paragraph, output_path="paragraph.wav")

Inference Benchmarks

Benchmarked on real hardware with the sentence:
"The weather is nice today, and I feel very relaxed." (~4.9s of audio at 44.1kHz)

  • CPU: Intel Core (laptop, no GPU)
  • PyTorch: 2.5.1+cu121
  • Model: 1.62M parameters
Backend Synthesis Time Audio RTFx
ONNX Runtime (CPU) 92 ms 4.88s ~53x 🚀
PyTorch (CPU) 272 ms 4.88s ~18x

RTFx = Audio Duration ÷ Synthesis Time (higher = faster).
With only 1.62M params, TinyTTS synthesizes ~5s of 44.1kHz audio in 92ms via ONNX — approximately 53× real-time on a laptop CPU.


Comparison with Other TTS Engines

All numbers are CPU-only inference benchmarked on the same machine (Intel Core laptop, no GPU).
Text: "The weather is nice today, and I feel very relaxed."
Protocol: 5 warm-up runs + 20 timed runs (median). Model load time excluded.

ENGINE Params TTFA (ms) TOTAL (s) AUDIO (s) RTFx 🔊
TinyTTS (ONNX) 1.6M 86 0.092 4.88 ~53x 🚀 ▶
Piper (ONNX, 22kHz) ~63M 114 0.112 2.91 ~26x ▶
TinyTTS (PyTorch) 1.6M 295 0.272 4.88 ~18x ▶
KittenTTS nano ~10M 298 0.286 4.87 ~17x ▶
Supertonic (2-step) ~82M 260 0.249 3.69 ~15x ▶
Pocket-TTS 100M 1055 0.928 3.68 ~4x ▶
Kokoro ONNX 82M 943 0.933 3.16 ~3x ▶
KittenTTS mini ~25M 1965 2.047 4.17 ~2x ▶

TTFA = Time To First Audio. RTFx = Audio Duration ÷ Synthesis Time (higher = faster).
⚠️ Output sample rates differ: Piper 22kHz, KittenTTS 24kHz, TinyTTS/Supertonic 44.1kHz.
TinyTTS achieves the best speed-to-size ratio: only 1.6M params / 3.4 MB ONNX yet ~53× real-time at 44.1kHz.

CPU vs GPU vs ONNX Summary

Backend          | Synthesis Time | Audio  | RTFx
-----------------|----------------|--------|----------
CPU (ONNX)       | 0.092 s        | 4.88s  | ~53x 🚀
CPU (PyTorch)    | 0.272 s        | 4.88s  | ~18x
GPU (CUDA, est.) | ~0.015 s       | 4.88s  | ~325x

ONNX Runtime is the recommended backend for CPU deployment — it provides ~3× speedup over PyTorch eager mode by fusing ops and eliminating Python dispatch overhead.

Run benchmarks yourself

python benchmark.py

Compares TinyTTS (PyTorch + ONNX) against Piper, Kokoro, KittenTTS, Pocket-TTS and Supertonic on CPU.


CLI Arguments

Argument Short Default Description
--text -t "The weather is nice today..." Text to synthesize
--checkpoint -c (optional) Path to G.pth. Auto-downloads if omitted.
--output -o output.wav Output audio filename
--speaker -s MALE Speaker ID
--speed 1.0 Speech speed (1.0=normal, 1.5=faster, 0.7=slower)
--device cuda Device: cuda or cpu

Project Structure

tiny-tts/
├── infer.py                  # Main inference script
├── TinyTTS.png               # Project logo
├── setup.py                  # Package setup (pip install)
├── pyproject.toml            # Build configuration
├── G.pth              # Pre-trained checkpoint (FP16: ~17 MB)
├── tinytts_fp16.onnx         # ONNX FP16 model (~3.4 MB)
├── models/
│   └── synthesizer.py        # Model definition
├── nn/
│   ├── attentions.py         # Attention layers
│   ├── modules.py            # Neural network modules
│   ├── commons.py            # Utility functions
│   └── transforms.py         # Flow transforms
├── text/
│   ├── english.py            # English G2P pipeline
│   ├── symbols.py            # Phoneme symbol tables
│   ├── cmudict.rep           # CMU Pronouncing Dictionary
│   └── english_utils/        # Text normalization
├── alignment/
│   └── core.py               # Viterbi alignment
└── utils/
    └── config.py             # Model hyperparameters

Node.js API

const TinyTTS = require('tiny-tts');

const tts = new TinyTTS();
await tts.speak('Hello world!', 'output.wav');

// With options
await tts.speak('Fast speech test.', {
  output: 'fast.wav',
  speaker: 'MALE',
  speed: 1.5
});

await tts.dispose();

CLI (Node.js)

npx tiny-tts "Hello world" -o hello.wav

Python vs Node.js G2P Comparison

Both the Python (PyPI) and Node.js (npm) packages share the same ONNX model and CMU pronunciation dictionary (123,463 entries). The G2P (Grapheme-to-Phoneme) pipelines were tested on 542 diverse sentences spanning everyday conversation, academic/scientific text, technical vocabulary, tongue twisters, and complex compound sentences.

Python (PyPI) Node.js (npm)
G2P backend BERT tokenizer + g2p_en + full CMU dict Apostrophe-aware split + neural G2P + full CMU dict
CMU dict entries ~123K (NLTK cmudict + syllable boundaries) 123K (merged NLTK + cmudict.rep)
Unknown word fallback g2p_en neural model (GRU seq2seq) Ported g2p_en neural model (identical weights)
Model PyTorch / ONNX ONNX only
Phone ID match rate — 100% exact match (542/542 sentences) ✅

Since v5.0.0, the Node.js package includes a pure-JS port of the g2p_en neural G2P model (GRU encoder-decoder, ~4.4 MB weights), achieving 100% phoneme-level match with the Python implementation across all 542 test sentences.


TODO

  • Public source code for training
  • Add more English speakers
  • Add ultra-lightweight zero-shot voice cloning
  • Release an even smaller model version while maintaining high accuracy

Links


License

Licensed under the Apache License, Version 2.0.


Star History