Supported TTS Backends in Hugging Face Speech-to-Speech and Installation Guide

The Hugging Face speech-to-speech repository supports five TTS backends: chatTTS, facebookMMS, pocket, kokoro, and qwen3, with installation available through pip extras or built-in dependencies depending on the backend.

The huggingface/speech-to-speech framework implements its TTS layer as a registry pattern that maps backend names to concrete handler implementations. Each backend extends BaseHandler[TTSIn, TTSOut] and is registered in src/speech_to_speech/backend_registry.py with its configuration class, factory function, and optional pip extra dependency. This architecture lets you swap TTS engines via a single CLI flag while maintaining consistent input/output contracts.

Complete List of Supported TTS Backends

The TTS_BACKENDS registry (lines 10–12 of backend_registry.py) defines five production-ready backends:

Backend	Handler File	Pip Extra	Hardware Support	Description
chatTTS	src/speech_to_speech/TTS/chatTTS_handler.py	chattts	CUDA, CPU	Fast neural TTS with stochastic speaker sampling
facebookMMS	src/speech_to_speech/TTS/facebookmms_handler.py	(none)	CUDA, CPU	Multilingual synthesis via 🤗 Transformers
pocket	src/speech_to_speech/TTS/pocket_tts_handler.py	pocket	CPU, CUDA	Streaming TTS with voice cloning capabilities
kokoro	src/speech_to_speech/TTS/kokoro_handler.py	kokoro	CUDA, CPU, Apple Silicon	Lightweight 82M-parameter multilingual model
qwen3	src/speech_to_speech/TTS/qwen3_tts_handler.py	(see below)	GGML (Linux), MLX (macOS)	Multilingual with multiple quantization backends

The select_backend function in backend_registry.py parses your --tts <name> selection into a BackendSelection object, which create_backend_handler then instantiates at runtime.

Installation Commands for Each TTS Backend

Built-in Backends (No Extra Required)

Two backends ship with the core package:

• facebookMMS — Depends only on transformers, installed automatically
• qwen3 (GGML on Linux, MLX on macOS) — Platform-specific wheels pulled automatically

# Core installation covers facebookMMS and Qwen3 defaults

pip install speech-to-speech

Optional Backends (Pip Extras Required)

Three backends need explicit extras to pull their native dependencies:

# chatTTS - ChatTTS library with CUDA/CPU support

pip install "speech-to-speech[chattts]"

# pocket - Pocket TTS with voice cloning stack

pip install "speech-to-speech[pocket]"

# kokoro - Kokoro-82M + MLX support for Apple Silicon

pip install "speech-to-speech[kokoro]"

Special Case: Qwen3 Linux GGML with Custom CUDA

If your CUDA runtime version differs from the default wheel, pre-install a matching wheel before the core package. As documented in src/speech_to_speech/TTS/README.md (lines 100–107):

# Example: CUDA 13.0 runtime

pip install "qwentts-cpp-python==0.3.1+cu130" \
  -f https://huggingface.co/datasets/andito/qwentts-cpp-python-wheels/tree/main/whl/cu130

# Then install speech-to-speech normally

pip install speech-to-speech

CLI Quick-Start Examples

Each backend exposes backend-specific arguments. Here are minimal working commands:

chatTTS

pip install "speech-to-speech[chattts]"

speech-to-speech serve \
  --tts chatTTS \
  --chat_tts_device cuda \
  --chat_tts_stream true

facebookMMS

# No extra installation needed

speech-to-speech serve \
  --tts facebookMMS \
  --facebook_mms_device cuda \
  --tts_language en

pocket

pip install "speech-to-speech[pocket]"

speech-to-speech serve \
  --tts pocket \
  --pocket_tts_voice jean \
  --pocket_tts_device cpu

kokoro

pip install "speech-to-speech[kokoro]"

speech-to-speech serve \
  --tts kokoro \
  --kokoro_device auto \
  --kokoro_voice bm_fable \
  --kokoro_lang_code b

qwen3

# Linux (GGML backend, default)

speech-to-speech serve \
  --tts qwen3 \
  --qwen3_tts_model_name Qwen/Qwen3-TTS-12Hz-1.7B-CustomVoice \
  --qwen3_tts_device cuda \
  --qwen3_tts_backend ggml

# Or use torch backend for CUDA graphs

# --qwen3_tts_backend torch

# macOS (MLX backend, automatic on Apple Silicon)

speech-to-speech serve \
  --tts qwen3 \
  --qwen3_tts_model_name Qwen/Qwen3-TTS-12Hz-1.7B-CustomVoice

Key Source Files

Understanding the implementation helps when debugging or extending:

• src/speech_to_speech/backend_registry.py — Defines TTS_BACKENDS registry and create_backend_handler factory
• src/speech_to_speech/TTS/chatTTS_handler.py — ChatTTS integration with speaker sampling
• src/speech_to_speech/TTS/facebookmms_handler.py — MMS TTS via Transformers pipeline
• src/speech_to_speech/TTS/pocket_tts_handler.py — Streaming TTS with voice cloning
• src/speech_to_speech/TTS/kokoro_handler.py — Kokoro-82M model wrapper
• src/speech_to_speech/TTS/qwen3_tts_handler.py — Multi-backend Qwen3 (GGML/torch/MLX)
• src/speech_to_speech/TTS/README.md — Backend-specific documentation and Linux GGML notes

Summary

• Five TTS backends are supported: chatTTS, facebookMMS, pocket, kokoro, qwen3
• Registry location: src/speech_to_speech/backend_registry.py maps names to handlers via BackendSpec
• Installation: Core package covers facebookMMS and qwen3; extras needed for chattts, pocket, kokoro
• Platform specifics: Qwen3 uses GGML on Linux, MLX on macOS; custom CUDA wheels may be required for GGML
• Selection: Use --tts <name> with backend-specific flags for device, voice, and streaming options

Frequently Asked Questions

What is the default TTS backend if I don't specify one?

The repository does not set a universal default—you must specify --tts <backend> when running speech-to-speech serve. If omitted, the CLI will raise a validation error. The select_backend function in backend_registry.py requires an explicit backend name to resolve the correct BackendSelection.

Can I use multiple TTS backends simultaneously in one server instance?

No. The current architecture in backend_registry.py supports single-backend selection per process. Each handler consumes significant GPU/CPU resources, and the create_backend_handler factory instantiates exactly one TTS handler. For multi-backend deployments, run separate server instances with different --tts flags.

Why does qwen3 require special installation steps on Linux?

Qwen3's GGML backend relies on native C++ bindings through qwentts-cpp-python, which distributes platform-specific wheels. The default wheel targets a specific CUDA version. If your NVIDIA driver/CUDA runtime differs, you must manually install a matching wheel from the community wheel index before installing speech-to-speech, as documented in src/speech_to_speech/TTS/README.md lines 100–107.

Do all backends support streaming audio output?

No. Streaming support varies by implementation:

• chatTTS — Supports streaming via --chat_tts_stream true
• pocket — Designed for streaming by default
• facebookMMS, kokoro, qwen3 — Generate complete utterances before audio playback

Check each handler's setup and process methods in their respective files for streaming capabilities.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}