A TTS that fits in your CPU (and pocket)
A lightweight text-to-speech (TTS) application designed to run efficiently on CPUs. Forget about the hassle of using GPUs and web APIs serving TTS models. With Kyutai's Pocket TTS, generating audio is just a pip install and a function call away.
Supports Python 3.10, 3.11, 3.12, 3.13 and 3.14. Requires PyTorch 2.5+. Does not require the gpu version of PyTorch.
Demo | GitHub Repository | Hugging Face Model Card | ⚙️ Tech report | Paper | Documentation
[!NOTE] New (August 2026): We've released the training code! Check out
training/to start training your own models. Open a PR to add your model to the Models trained by the community section.
Additional languages may be added in the future.
Navigate to the Kyutai website to try it out directly in your browser. You can input text, select different voices, and generate speech without any installation.
generate commandYou can use pocket-tts directly from the command line. We recommend using
uv as it installs any dependencies on the fly in an isolated environment (uv installation instructions here).
You can also use pip install pocket-tts to install it manually.
On Linux, see CPU-only installation to avoid pulling in the CUDA build of PyTorch.
This will generate a wav file ./tts_output.wav saying the default text with the default voice, and display some speed statistics.
uvx pocket-tts generate
# or if you installed it manually with pip:
pocket-tts generate
Modify the voice with --voice and the text with --text. We provide a small catalog of voices.
Choose a pretrained language model with --language when running generate, export-voice, or serve (default: english). Non-english languages have also biggers 24 layers variants that are higher quality but slower. You can select them by using for example --language italian_24l.
The --config option accepts a local YAML path, an https:// URL, or an hf:// path (e.g. hf://<repo_id>/<path>[@revision]) for custom weights.
You can take a look at this page which details the licenses for each voice.
The --voice argument can also take a plain wav file as input for voice cloning.
You can use your own or check out our voice repository.
We recommend cleaning the sample before using it with Pocket TTS, because the audio quality of the sample is also reproduced.
Feel free to check out the generate documentation for more details and examples.
For trying multiple voices and prompts quickly, prefer using the serve command.
serve commandYou can also run a local server to generate audio via HTTP requests.
uvx pocket-tts serve
# or if you installed it manually with pip:
pocket-tts serve
Navigate to http://localhost:8000 to try the web interface, it's faster than the command line as the model is kept in memory between requests.
You can check out the serve documentation for more details and examples.
export-voice commandProcessing an audio file (e.g., a .wav or .mp3) for voice cloning is relatively slow, but loading a safetensors file -- a voice embedding converted from an audio file -- is very fast. You can use the export-voice command to do this conversion. See the export-voice documentation for more details and examples.
You can try out the Python library on Colab here.
Install the package with
pip install pocket-tts
# or
uv add pocket-tts
On Linux, PyPI serves the CUDA build of PyTorch by default, so pip install pocket-tts also
downloads the nvidia-* CUDA runtime wheels, even though pocket-tts runs on CPU. This adds
several gigabytes to the install (with torch 2.13, roughly 3 GB instead of 200 MB). Installing
from the PyTorch CPU index pulls the CPU build and no NVIDIA packages:
pip install pocket-tts --extra-index-url https://download.pytorch.org/whl/cpu
To run the CLI without installing, pass the same index to uvx:
uvx --index https://download.pytorch.org/whl/cpu pocket-tts generate
With uv, declare the index explicitly in your project:
[[tool.uv.index]]
name = "pytorch-cpu"
url = "https://download.pytorch.org/whl/cpu"
explicit = true
[tool.uv.sources]
torch = [{ index = "pytorch-cpu" }]
This is not needed on macOS or Windows, where the default PyTorch wheels are already CPU-only.
You can use this package as a simple Python library to generate audio from text.
from pocket_tts import TTSModel
import scipy.io.wavfile
tts_model = TTSModel.load_model()
voice_state = tts_model.get_state_for_audio_prompt(
"alba" # One of the pre-made voices, see above
# You can also use any voice file you have locally or from Hugging Face:
# "./some_audio.wav"
# or "hf://kyutai/tts-voices/expresso/ex01-ex02_default_001_channel2_198s.wav"
)
audio = tts_model.generate_audio(voice_state, "Hello world, this is a test.")
# Audio is a 1D torch tensor containing PCM data.
scipy.io.wavfile.write("output.wav", tts_model.sample_rate, audio.numpy())
You can have multiple voice states around if
you have multiple voices you want to use. load_model()
and get_state_for_audio_prompt() are relatively slow operations,
so we recommend to keep the model and voice states in memory if you can.
For faster voice loading, you can export voice states to safetensors files:
from pocket_tts import TTSModel, export_model_state
model = TTSModel.load_model()
# Export a voice state for fast loading later
model_state = model.get_state_for_audio_prompt("some_voice.wav")
export_model_state(model_state, "./some_voice.safetensors")
# Later, load it quickly, this is quite fast as it's just reading the kvcache
# from disk and doesn't do any others computations.
model_state_copy = model.get_state_for_audio_prompt("./some_voice.safetensors")
audio = model.generate_audio(model_state_copy, "Hello world!")
You can check out the Python API documentation for more details and examples.
Pocket TTS is designed to run on CPU, and on hardware with strong single-thread CPU performance (e.g. Apple Silicon) we did not observe a GPU speedup, notably because we use a batch size of 1 and a very small model. However, this turns out to be hardware-dependent: measured on a cloud x86 VM (4 vCPUs) with a Tesla T4, moving the model to GPU gave a consistent ~2.6x speedup over CPU (RTF ~2.3-2.5x on CPU vs. ~6.28x on GPU, for both short and long input text). If your CPU is thread-limited or otherwise weaker than a modern laptop chip, it's worth trying the GPU.
This is not officially supported (there is no device argument on TTSModel.load_model()), but
since TTSModel is a regular nn.Module you can move it yourself:
tts_model = TTSModel.load_model()
tts_model.to("cuda")
...
audio = tts_model.generate_audio(voice_state, "Hello world, this is a test.")
# generate_audio() returns a tensor on the same device as the model, so on GPU you need
# to move it back to CPU before calling .numpy():
scipy.io.wavfile.write("output.wav", tts_model.sample_rate, audio.detach().cpu().numpy())
A few things to be aware of if you want to use the GPU:
generate CLI command has a --device option (defaults to cpu, documented in the
CLI reference — note that page's own description ("you may not
get a speedup by using a gpu since it's a small model") is what this section is correcting, based
on the T4 measurements above); the serve command and the Docker image do not expose any device
option and will always run on CPU.pip install pocket-tts / uv add pocket-tts install whatever torch build is current on
PyPI, which may require a newer CUDA version than your driver supportsNo open issues yet, or sync has not completed.