Pocket-TTS: The Lightweight Text-to-Speech Engine That Runs Entirely on Your CPU — 6,700+ GitHub Stars

Why Pocket-TTS Is Trending on GitHub Right Now

Text-to-speech has traditionally been a GPU-hungry, cloud-dependent beast. Services like ElevenLabs, Google Cloud TTS, and Amazon Polly deliver excellent quality — but they come with API costs, latency overhead, data privacy concerns, and vendor lock-in. For indie developers, embedded systems, and privacy-sensitive applications, those trade-offs are often unacceptable.

Enter Pocket-TTS, an open-source project by Kyutai Labs that flips the script entirely. With over 6,700 GitHub stars and 655 stars gained in a single day, it has become one of the fastest-growing TTS projects in the open-source ecosystem. The core promise is disarmingly simple: professional-grade speech synthesis that runs on nothing but a CPU.

Whether you are building a voice assistant for a Raspberry Pi, adding narration to a mobile app, prototyping an AI agent that speaks, or creating an accessible screen reader, Pocket-TTS removes every infrastructure barrier. No GPU. No API keys. No monthly bills. Just Python, a terminal, and a few lines of code.

Under the Hood: Architecture and Performance

Pocket-TTS is built on a compact transformer architecture with only 100 million parameters — small enough to load in seconds, yet expressive enough to produce natural-sounding speech. Here are the headline performance numbers straight from the Kyutai Labs benchmarks:

• First audio chunk latency: ~200 milliseconds
• Throughput: ~6x real-time on a MacBook Air M4 CPU
• CPU utilization: Only 2 cores
• Streaming: Full audio streaming support — start playing before generation completes
• Long text: Handles infinitely long inputs without memory overflow

The model uses PyTorch 2.5+ under the hood but does not require the GPU variant. The Kyutai team actually tested GPU execution and found no meaningful speedup over CPU — the model is so small and optimized that CPU inference is already saturating the pipeline. This is a remarkable engineering achievement and a testament to thoughtful model design.

Audio streaming is particularly important for real-time applications. Pocket-TTS generates audio chunks incrementally, meaning your application can begin playback while the rest of the text is still being synthesized. For conversational AI agents, chatbots, and live narration tools, this is the difference between a responsive experience and an awkward silence.

Getting Started: Installation and First Words

Getting Pocket-TTS running takes less than a minute. The recommended approach uses uv, the fast Python package manager, but pip works just fine:

# Install with uv (recommended — isolated environment, instant setup)
uvx pocket-tts generate

# Or install with pip
pip install pocket-tts
pocket-tts generate

The generate command produces a tts_output.wav file with the default voice and default text. To customize:

# Choose a voice and custom text
pocket-tts generate --voice alba --text "Hello world, welcome to Pocket-TTS."

# Run in a different language
pocket-tts generate --language french --voice estelle --text "Bonjour le monde."

# Higher quality Italian (24-layer variant)
pocket-tts generate --language italian_24l --voice giovanni --text "Ciao mondo."

For interactive testing with multiple voices, the local web server is ideal:

pocket-tts serve
# Navigate to http://localhost:8000

The server keeps the model in memory between requests, making it significantly faster than the CLI for iterative testing. This is also the recommended setup for integrating Pocket-TTS into a web application backend.

The Python API: Full Programmatic Control

For developers who want to embed TTS directly into their applications, Pocket-TTS exposes a clean, well-documented Python API:

from pocket_tts import TTSModel
import scipy.io.wavfile

# Load the model (do this once at startup)
tts_model = TTSModel.load_model()

# Load a voice state (keep in memory for reuse)
voice_state = tts_model.get_state_for_audio_prompt("alba")

# Generate audio
audio = tts_model.generate_audio(voice_state, "Hello world, this is a test.")

# Save to WAV file
scipy.io.wavfile.write("output.wav", tts_model.sample_rate, audio.numpy())

Performance tip: both load_model() and get_state_for_audio_prompt() are relatively expensive operations. For production use, load the model and voice states once at startup and reuse them across requests. You can keep multiple voice states in memory simultaneously for multi-voice applications.

For even faster voice loading, export voice states to safetensors format:

from pocket_tts import TTSModel, export_model_state

model = TTSModel.load_model()

# Export voice state for instant loading later
voice = model.get_state_for_audio_prompt("my_voice.wav")
export_model_state(voice, "./my_voice.safetensors")

# Later: near-instant load — just reads the KV cache from disk
voice_fast = model.get_state_for_audio_prompt("./my_voice.safetensors")
audio = model.generate_audio(voice_fast, "This loaded instantly.")

Voice Cloning: Your Voice in Three Lines

One of Pocket-TTS's most compelling features is voice cloning from a single audio sample. Provide any WAV file — a podcast clip, a recording, a voice memo — and the model will synthesize new speech in that voice:

# Clone a voice from any WAV file
pocket-tts generate --voice ./my_recording.wav --text "This sounds like me."

In Python:

voice_state = tts_model.get_state_for_audio_prompt("./my_recording.wav")
audio = tts_model.generate_audio(voice_state, "Any text in your cloned voice.")

Kyutai recommends cleaning your audio sample with Adobe's free podcast enhancer before cloning, because the model reproduces the audio quality of the input — including background noise and artifacts.

The built-in voice catalog includes 25+ pre-made voices across English, French, German, Portuguese, Italian, and Spanish. Voices range from casual conversational tones to formal narration styles, covering a wide spectrum of use cases.

Multi-Language Support and Extensibility

Pocket-TTS ships with first-class support for six languages:

• English (default, 18+ voices)
• French (voice: estelle)
• German (voice: juergen)
• Portuguese (voice: rafael)
• Italian (voice: giovanni)
• Spanish (voice: lola)

Non-English languages also offer 24-layer variants for higher quality at the cost of slower inference. Select them with the _24l suffix: --language italian_24l. The Kyutai team has indicated that additional languages will be added in future releases, and the architecture is designed to accommodate new language models without breaking existing integrations.

Real-World Example: Building a Voice-Enabled AI Agent

Let us walk through a practical scenario: building an AI coding assistant that reads its responses aloud using Pocket-TTS as the speech engine. This is exactly the kind of lightweight, local-first setup that Pocket-TTS was designed for.

from pocket_tts import TTSModel
import scipy.io.wavfile
import sounddevice as sd
import numpy as np

# Initialize once at startup
model = TTSModel.load_model()
voice = model.get_state_for_audio_prompt("alba")

def speak(text: str):
    """Generate and play speech in real-time."""
    audio = model.generate_audio(voice, text)
    audio_np = audio.numpy().astype(np.float32) / 32768.0
    sd.play(audio_np, samplerate=model.sample_rate)
    sd.wait()

# Your AI agent logic
def ai_response(user_query: str) -> str:
    # ... your LLM call here ...
    return "The function you need is called merge_sort. It uses a divide and conquer strategy."

# Speak the response
response = ai_response("How does merge sort work?")
speak(response)

This setup runs entirely locally — no API keys, no network calls for TTS, no per-request costs. The 200ms first-chunk latency means the user hears speech almost immediately after the AI finishes thinking. For edge devices, kiosk applications, or privacy-sensitive environments, this architecture is ideal.

Another powerful use case: browser-based TTS. The Pocket-TTS community has built multiple WebAssembly ports that run entirely client-side. Projects like wasm-pocket-tts, pocket-tts-onnx-export, and Candle/WASM port enable speech synthesis directly in the browser — no server, no API, no latency beyond the user's own hardware.

The Thriving Ecosystem: 30+ Community Projects

Perhaps the most impressive aspect of Pocket-TTS is the ecosystem it has spawned. In just months, the community has built integrations for nearly every platform imaginable:

• Home Assistant: Wyoming protocol Docker container for smart home voice output
• Unity 6: Direct integration for game developers
• ComfyUI: Lightweight TTS node for AI art workflows
• Discord: Multi-voice TTS bot for servers
• macOS native app: Core ML optimized, signed and notarized
• Raspberry Pi & embedded boards: Via sherpa-onnx with 12 language bindings
• C++: Single-file PocketTTS.cpp with CLI, HTTP server, and FFI
• C#/.NET: TorchSharp port for enterprise applications
• OpenAI-compatible server: Drop-in replacement for OpenAI TTS API
• Hogwarts Legacy mod: Talk to any character in their original voice

This breadth of community adoption signals something important: developers have been waiting for a TTS solution that is truly local, truly open, and truly lightweight. Pocket-TTS fills that gap.

Key Benefits of Pocket-TTS

• Zero GPU required — runs entirely on CPU, including low-power devices like Raspberry Pi
• Blazing fast — ~200ms to first audio chunk, 6x real-time throughput
• Tiny footprint — only 100M parameters, uses just 2 CPU cores
• One-line install — pip install pocket-tts or uvx pocket-tts generate
• Voice cloning — clone any voice from a single WAV sample
• 6 languages — English, French, German, Portuguese, Italian, Spanish with more coming
• Audio streaming — play audio while generation is still in progress
• Browser-ready — multiple WebAssembly/ONNX ports for client-side synthesis
• Unlimited text length — handles infinitely long inputs without memory issues
• Open source — fully open with active community and 30+ ecosystem projects
• No API costs — run unlimited generations locally for free
• Privacy-first — all processing stays on your machine, no data leaves your device

How Pocket-TTS Compares to Cloud TTS Services

Feature	Pocket-TTS	Cloud TTS (ElevenLabs, Google, etc.)
GPU Required	No	Server-side (hidden from user)
Cost per request	Free	$0.001–$0.03 per 1K chars
Privacy	100% local	Data sent to cloud
Voice cloning	From any WAV file	Platform-specific, often paid
Offline capable	Yes	No
Browser support	Via WASM/ONNX ports	Via Web Audio API + server

Cloud services still win on raw voice quality and emotional expressiveness for premium use cases. But for the vast majority of developer applications — prototyping, accessibility tools, internal tools, edge devices, and privacy-sensitive deployments — Pocket-TTS offers a compelling, cost-free alternative.

Frequently Asked Questions

Is Pocket-TTS really free to use?

Yes, Pocket-TTS is fully open source and free to use. There are no API fees, no subscription costs, and no usage limits. You install it locally and generate as much speech as you need. The only cost is your own hardware, and since it runs on CPU, that cost is minimal.

What hardware do I need to run Pocket-TTS?

Pocket-TTS runs on any modern CPU. It has been benchmarked at 6x real-time speed on a MacBook Air M4 using only 2 CPU cores. It works on laptops, desktops, Raspberry Pis, embedded boards, and even in the browser via WebAssembly. No GPU is required or even beneficial — the model is so small that CPU inference is already optimal.

How good is the voice cloning quality?

Voice cloning quality depends heavily on the input sample. Kyutai Labs recommends using clean, high-quality audio recordings and suggests running samples through Adobe's free podcast enhancer before cloning. The model reproduces the audio characteristics of the input, including background noise, so cleaner inputs produce cleaner outputs. For professional use cases, the quality is impressive; for casual use, even phone recordings work reasonably well.

Can I use Pocket-TTS in a commercial product?

Pocket-TTS is open source, but you should review the specific license terms on the GitHub repository and the voice license page on Hugging Face. Individual voices may have different licenses. The model itself is available for research and commercial use, but always verify compliance with the latest terms.

Does Pocket-TTS support languages beyond the six listed?

Currently, Pocket-TTS supports English, French, German, Portuguese, Italian, and Spanish. The Kyutai team has stated that additional languages will be added in future releases. The architecture is designed to accommodate new language models, and the community is actively contributing language extensions. Non-English languages also offer higher-quality 24-layer variants for those willing to trade some speed for fidelity.

How does Pocket-TTS compare to Coqui TTS or Bark?

Pocket-TTS is significantly lighter than both Coqui TTS and Bark. While Coqui TTS offers more models and Bark provides more expressive emotional range, both are heavier and often require GPU for acceptable latency. Pocket-TTS is purpose-built for CPU efficiency: 100M parameters, 200ms latency, 2 cores. If your priority is speed, low resource usage, and local deployment, Pocket-TTS is the clear winner. If you need maximum expressiveness or niche model architectures, Coqui and Bark remain strong alternatives.