Vibeleaderboard
Index / tool
Visit github.com
Category
AI Tools
Rank
Pricing
Open Source
Type
TOOL
Use case
Models: Train & Run · Design & Media
Interfaces
CLI
Latest release
v4.0.1
Date

About

A 100M-parameter text-to-speech model from Kyutai Labs that synthesises speech entirely on CPU — about 6x faster than real time on a MacBook Air M4, with roughly 200ms to the first audio chunk on two cores. It covers English, French, German, Spanish, Italian and Portuguese, clones a voice from a reference clip, and streams output so input text can be arbitrarily long. It ships as a pip-installable CLI, a Python library and a local web server, and does not need the GPU build of PyTorch.

What it does

Kyutai's small speech generator turns typed sentences into a spoken WAV recording on an ordinary laptop processor. You pick one of roughly two dozen bundled speakers or hand it a short recording of someone, and it imitates that person. Audio comes out in pieces while it is still being produced, so playback can begin before the whole passage is finished. Seven languages ship as separate model choices, including Dutch, and the same package runs as a terminal command, an importable module, or a small browser page served from your own machine.

Why it's ranked here

Few open speech models make local generation this cheap to adopt. The weights are small, the code carries MIT permission text, and the maintainers publish measured numbers instead of adjectives: about 200ms before the first sound, and int8 quantization cutting runtime memory from 450 MB to 234 MB with a 1.27x speedup on an x86 CI runner. Training code is now public, continuous integration runs type checks and tests on Python 3.10 and 3.14, and the API surface is documented. For anyone who wants private, offline narration without a hosted service, it is a strong default.

What's good

The server is careful in ways that matter in practice. If a listener disconnects, generation stops instead of finishing for nobody. A broken default voice fails at startup rather than on the first request. Cloned voices can be saved once to a compact file and reloaded almost instantly, skipping the slow audio encoding step. Quantization picks the faster backend automatically and the docs report no measurable change in word error rate. The README is also honest about hardware: GPU help is absent on Apple Silicon but gave about 2.6x on a cloud machine with a T4 card.

Tradeoffs

On Linux, a plain install pulls the CUDA build of PyTorch, roughly 3 GB instead of 200 MB, unless you point at the CPU package index. GPU use is not officially supported in the library and needs manual moves of the model and output. The larger 24-layer variants for non-English languages are labelled previews, not distilled and not final. Quantization on ARM with older PyTorch (2.5 to 2.9) runs about 16% slower than no quantization. Cloning reproduces the quality of your sample, noise included, and the bundled voices carry their own separate licenses.

How to use it well

Best fit: developers who need local narration, voice prompts in an app, or offline read-aloud without sending text to a vendor. Keep the model and voice states loaded in memory, since loading both is slow, and run the local server when trying several voices so the model stays warm. Export any cloned voice once and reuse the saved file. Turn on quantization on x86, or on ARM only with PyTorch 2.10 or newer. Clean reference clips before cloning. It does not cover speech recognition or batched high-throughput serving; it runs one request at a time with batch size one.

Technical notes+

The CLI is a Typer app (pocket_tts/main.py, entry point pocket_tts.main:cli_app in pyproject.toml) exposing generate, serve and export-voice. The FastAPI /tts endpoint streams chunked audio/wav by running generate_audio_stream in a worker thread feeding a Queue, and sets a threading.Event on client disconnect to halt generation. voice_url must be http(s)://, hf:// or a predefined voice name. CORS allows localhost:3000 and kyutai.org origins. pocket_tts/default_parameters.py sets temperature 0.3, one sampler decode step, EOS threshold -4.0 and MAX_TOKEN_PER_CHUNK 50. pocket_tts/quantization.py applies dynamic int8 to attention and FFN layers via torchao, falling back to torch.ao (QNNPACK on ARM, FBGEMM on x86); flow_net and the Mimi decoder stay float32 (docs/quantization.md).

Observed

License
MIT permission text (LICENSE)
Language
Python, requires >=3.10,<3.15 (pyproject.toml)
Packaging
PyPI package pocket-tts with a pocket-tts console script (pyproject.toml)
Interfaces
CLI (generate, serve, export-voice), Python library, local FastAPI HTTP server with web UI (pocket_tts/main.py)
Optional extras
audio (soundfile) and quantize (torchao) in pyproject.toml
Platform
Runs on CPU by default; GPU use is not officially supported (README.md)
CI
pre-commit, ty type checks and pytest on Python 3.10 and 3.14 (.github/workflows/run-tests.yml)
Voice storage
Voice states export to and load from safetensors files (Python API docs)

Read from README.md, pyproject.toml, LICENSE, pocket_tts/main.py, pocket_tts/default_parameters.py, pocket_tts/quantization.py, docs/quantization.md, docs/API Reference/python-api.md, docs/CLI Commands/serve.md, .github/workflows/run-tests.yml.

Tags

ttstext-to-speechvoice-cloningcpu-inferenceon-devicestreamingpython

Tech Stack

PythonDocker

Comments (0)

No comments yet

Editorially curated, with community endorsements as a secondary signal. Corrections welcome.