huggingface/speech-to-speechPublic

Build voice agents with open-source models

AI summary: A framework for building entirely voice-driven AI applications with incredibly low latency.

Stars
13.7K
+47 today
Forks
1.7K
Watchers
80
Open issues
31
Open PRs
33
Contributors
~82
Commits
1.8K
Branches
52

PythonApache-2.0Created Aug 7, 2024Last push 2d agoLatest release v1.1.0+61 stars this week+224 this month

Quick answers

What is speech-to-speech?
A framework for building entirely voice-driven AI applications with incredibly low latency.
What does speech-to-speech do?
Speech-to-speech provides a highly optimized, modular framework for building real-time, voice-driven conversational AI agents. It effectively pipes audio input directly through state-of-the-art automatic speech recognition (ASR) models, processes the text via Large Language Models, and immediately synthesizes the response using advanced text-to-speech (TTS) engines. The framework is heavily engineered to minimize latency at every step, utilizing streaming generation and aggressive caching to create interactions that feel as natural as human conversation. It abstracts the immense complexity of managing audio buffers and model pipelines into a simple, deployable architecture.
Who is speech-to-speech for?
AI developers and engineers building real-time conversational applications who require absolute control over the entire speech pipeline and extremely low latency. It is essential for those building interactive voice assistants where response time is critical. The open architecture allows for fine-tuning and swapping out individual components of the speech pipeline.
How do I get started with speech-to-speech?
pip install speech-to-speech && speech-to-speech serve
How popular is speech-to-speech on GitHub?
huggingface/speech-to-speech has 13,741 stars and 1,698 forks on GitHub, and gained 61 stars in the last 7 days.
What license does speech-to-speech use?
huggingface/speech-to-speech is released under the Apache-2.0 license.

Star history

since Jul 29, 2026
05K10KJul 2026Sep 2026Oct 2026Nov 2026
13.7K stars as of Nov 19, 2026. Measured daily since Jul 29, 2026; GitHub no longer exposes earlier star timestamps.

Update history

1 recorded
  • Oct 25, 2026New release v1.1.0 (previously v1.0.0).

Contribution activity

commits per day, last 52 weeks
NovDecJanFebMarAprMayJunJulAugSepOctNovMonWedFri2025-11-23: 0 commits2025-11-24: 0 commits2025-11-25: 0 commits2025-11-26: 0 commits2025-11-27: 0 commits2025-11-28: 0 commits2025-11-29: 0 commits2025-11-30: 0 commits2025-12-01: 0 commits2025-12-02: 0 commits2025-12-03: 0 commits2025-12-04: 0 commits2025-12-05: 0 commits2025-12-06: 0 commits2025-12-07: 0 commits2025-12-08: 0 commits2025-12-09: 0 commits2025-12-10: 0 commits2025-12-11: 0 commits2025-12-12: 0 commits2025-12-13: 0 commits2025-12-14: 0 commits2025-12-15: 0 commits2025-12-16: 0 commits2025-12-17: 0 commits2025-12-18: 0 commits2025-12-19: 0 commits2025-12-20: 0 commits2025-12-21: 0 commits2025-12-22: 0 commits2025-12-23: 0 commits2025-12-24: 0 commits2025-12-25: 0 commits2025-12-26: 0 commits2025-12-27: 0 commits2025-12-28: 0 commits2025-12-29: 0 commits2025-12-30: 0 commits2025-12-31: 0 commits2026-01-01: 0 commits2026-01-02: 0 commits2026-01-03: 0 commits2026-01-04: 0 commits2026-01-05: 0 commits2026-01-06: 0 commits2026-01-07: 0 commits2026-01-08: 0 commits2026-01-09: 0 commits2026-01-10: 0 commits2026-01-11: 0 commits2026-01-12: 0 commits2026-01-13: 0 commits2026-01-14: 0 commits2026-01-15: 0 commits2026-01-16: 0 commits2026-01-17: 0 commits2026-01-18: 0 commits2026-01-19: 0 commits2026-01-20: 0 commits2026-01-21: 0 commits2026-01-22: 0 commits2026-01-23: 0 commits2026-01-24: 0 commits2026-01-25: 0 commits2026-01-26: 0 commits2026-01-27: 0 commits2026-01-28: 0 commits2026-01-29: 0 commits2026-01-30: 0 commits2026-01-31: 0 commits2026-02-01: 0 commits2026-02-02: 0 commits2026-02-03: 0 commits2026-02-04: 0 commits2026-02-05: 1 commit2026-02-06: 5 commits2026-02-07: 0 commits2026-02-08: 0 commits2026-02-09: 2 commits2026-02-10: 2 commits2026-02-11: 0 commits2026-02-12: 2 commits2026-02-13: 4 commits2026-02-14: 0 commits2026-02-15: 0 commits2026-02-16: 2 commits2026-02-17: 2 commits2026-02-18: 9 commits2026-02-19: 1 commit2026-02-20: 7 commits2026-02-21: 0 commits2026-02-22: 0 commits2026-02-23: 23 commits2026-02-24: 12 commits2026-02-25: 0 commits2026-02-26: 0 commits2026-02-27: 0 commits2026-02-28: 0 commits2026-03-01: 0 commits2026-03-02: 0 commits2026-03-03: 5 commits2026-03-04: 0 commits2026-03-05: 12 commits2026-03-06: 5 commits2026-03-07: 0 commits2026-03-08: 0 commits2026-03-09: 5 commits2026-03-10: 0 commits2026-03-11: 8 commits2026-03-12: 11 commits2026-03-13: 1 commit2026-03-14: 0 commits2026-03-15: 0 commits2026-03-16: 0 commits2026-03-17: 0 commits2026-03-18: 0 commits2026-03-19: 0 commits2026-03-20: 4 commits2026-03-21: 0 commits2026-03-22: 0 commits2026-03-23: 2 commits2026-03-24: 2 commits2026-03-25: 0 commits2026-03-26: 0 commits2026-03-27: 0 commits2026-03-28: 0 commits2026-03-29: 0 commits2026-03-30: 0 commits2026-03-31: 0 commits2026-04-01: 0 commits2026-04-02: 0 commits2026-04-03: 0 commits2026-04-04: 0 commits2026-04-05: 0 commits2026-04-06: 0 commits2026-04-07: 3 commits2026-04-08: 1 commit2026-04-09: 0 commits2026-04-10: 2 commits2026-04-11: 0 commits2026-04-12: 0 commits2026-04-13: 0 commits2026-04-14: 1 commit2026-04-15: 5 commits2026-04-16: 11 commits2026-04-17: 3 commits2026-04-18: 0 commits2026-04-19: 0 commits2026-04-20: 3 commits2026-04-21: 1 commit2026-04-22: 2 commits2026-04-23: 2 commits2026-04-24: 1 commit2026-04-25: 0 commits2026-04-26: 0 commits2026-04-27: 1 commit2026-04-28: 1 commit2026-04-29: 3 commits2026-04-30: 9 commits2026-05-01: 2 commits2026-05-02: 0 commits2026-05-03: 0 commits2026-05-04: 21 commits2026-05-05: 9 commits2026-05-06: 0 commits2026-05-07: 3 commits2026-05-08: 19 commits2026-05-09: 0 commits2026-05-10: 0 commits2026-05-11: 0 commits2026-05-12: 0 commits2026-05-13: 0 commits2026-05-14: 0 commits2026-05-15: 0 commits2026-05-16: 0 commits2026-05-17: 0 commits2026-05-18: 0 commits2026-05-19: 0 commits2026-05-20: 1 commit2026-05-21: 0 commits2026-05-22: 0 commits2026-05-23: 0 commits2026-05-24: 0 commits2026-05-25: 0 commits2026-05-26: 5 commits2026-05-27: 11 commits2026-05-28: 4 commits2026-05-29: 1 commit2026-05-30: 1 commit2026-05-31: 0 commits2026-06-01: 0 commits2026-06-02: 0 commits2026-06-03: 0 commits2026-06-04: 1 commit2026-06-05: 3 commits2026-06-06: 1 commit2026-06-07: 0 commits2026-06-08: 1 commit2026-06-09: 14 commits2026-06-10: 1 commit2026-06-11: 3 commits2026-06-12: 1 commit2026-06-13: 0 commits2026-06-14: 0 commits2026-06-15: 0 commits2026-06-16: 0 commits2026-06-17: 0 commits2026-06-18: 1 commit2026-06-19: 0 commits2026-06-20: 0 commits2026-06-21: 0 commits2026-06-22: 1 commit2026-06-23: 1 commit2026-06-24: 0 commits2026-06-25: 0 commits2026-06-26: 1 commit2026-06-27: 0 commits2026-06-28: 0 commits2026-06-29: 2 commits2026-06-30: 1 commit2026-07-01: 1 commit2026-07-02: 0 commits2026-07-03: 10 commits2026-07-04: 0 commits2026-07-05: 0 commits2026-07-06: 0 commits2026-07-07: 1 commit2026-07-08: 0 commits2026-07-09: 1 commit2026-07-10: 1 commit2026-07-11: 0 commits2026-07-12: 3 commits2026-07-13: 9 commits2026-07-14: 0 commits2026-07-15: 7 commits2026-07-16: 0 commits2026-07-17: 3 commits2026-07-18: 0 commits2026-07-19: 0 commits2026-07-20: 1 commit2026-07-21: 0 commits2026-07-22: 0 commits2026-07-23: 0 commits2026-07-24: 0 commits2026-07-25: 0 commits2026-07-26: 0 commits2026-07-27: 0 commits2026-07-28: 5 commits2026-07-29: 6 commits2026-07-30: 11 commits2026-07-31: 11 commits2026-08-01: 1 commit2026-08-02: 4 commits2026-08-03: 6 commits2026-08-04: 14 commits2026-08-05: 11 commits2026-08-06: 32 commits2026-08-07: 17 commits2026-08-08: 8 commits2026-08-09: 20 commits2026-08-10: 13 commits2026-08-11: 28 commits2026-08-12: 16 commits2026-08-13: 9 commits2026-08-14: 0 commits2026-08-15: 0 commits2026-08-16: 2 commits2026-08-17: 12 commits2026-08-18: 8 commits2026-08-19: 11 commits2026-08-20: 10 commits2026-08-21: 6 commits2026-08-22: 0 commits2026-08-23: 1 commit2026-08-24: 5 commits2026-08-25: 5 commits2026-08-26: 3 commits2026-08-27: 5 commits2026-08-28: 8 commits2026-08-29: 0 commits2026-08-30: 1 commit2026-08-31: 0 commits2026-09-01: 2 commits2026-09-02: 1 commit2026-09-03: 5 commits2026-09-04: 3 commits2026-09-05: 21 commits2026-09-06: 9 commits2026-09-07: 3 commits2026-09-08: 7 commits2026-09-09: 0 commits2026-09-10: 0 commits2026-09-11: 0 commits2026-09-12: 0 commits2026-09-13: 0 commits2026-09-14: 2 commits2026-09-15: 0 commits2026-09-16: 2 commits2026-09-17: 0 commits2026-09-18: 3 commits2026-09-19: 2 commits2026-09-20: 0 commits2026-09-21: 4 commits2026-09-22: 24 commits2026-09-23: 13 commits2026-09-24: 17 commits2026-09-25: 14 commits2026-09-26: 2 commits2026-09-27: 3 commits2026-09-28: 14 commits2026-09-29: 17 commits2026-09-30: 17 commits2026-10-01: 5 commits2026-10-02: 7 commits2026-10-03: 5 commits2026-10-04: 10 commits2026-10-05: 6 commits2026-10-06: 18 commits2026-10-07: 12 commits2026-10-08: 19 commits2026-10-09: 28 commits2026-10-10: 4 commits2026-10-11: 2 commits2026-10-12: 14 commits2026-10-13: 12 commits2026-10-14: 3 commits2026-10-15: 7 commits2026-10-16: 8 commits2026-10-17: 1 commit2026-10-18: 2 commits2026-10-19: 13 commits2026-10-20: 21 commits2026-10-21: 2 commits2026-10-22: 6 commits2026-10-23: 2 commits2026-10-24: 2 commits2026-10-25: 0 commits2026-10-26: 8 commits2026-10-27: 1 commit2026-10-28: 1 commit2026-10-29: 7 commits2026-10-30: 10 commits2026-10-31: 2 commits2026-11-01: 0 commits2026-11-02: 3 commits2026-11-03: 15 commits2026-11-04: 3 commits2026-11-05: 17 commits2026-11-06: 19 commits2026-11-07: 1 commit2026-11-08: 0 commits2026-11-09: 0 commits2026-11-10: 12 commits2026-11-11: 0 commits2026-11-12: 2 commits2026-11-13: 3 commits2026-11-14: 0 commits2026-11-15: 0 commits2026-11-16: 0 commits2026-11-17: 0 commits2026-11-18: 0 commits2026-11-19: 0 commits2026-11-20: 0 commits2026-11-21: 0 commits
1,109 commits in the last yearLessMore

Signals and awards

derived from tracked data
  • Widely adopted

    13,741 stars

  • Very active

    1,109 commits in 52 weeks

  • Permissive license

    Apache-2.0

  • Continuous integration

    Automated checks passing

  • Repeat trending

    19 trending appearances

What speech-to-speech does

Speech-to-speech provides a highly optimized, modular framework for building real-time, voice-driven conversational AI agents. It effectively pipes audio input directly through state-of-the-art automatic speech recognition (ASR) models, processes the text via Large Language Models, and immediately synthesizes the response using advanced text-to-speech (TTS) engines. The framework is heavily engineered to minimize latency at every step, utilizing streaming generation and aggressive caching to create interactions that feel as natural as human conversation. It abstracts the immense complexity of managing audio buffers and model pipelines into a simple, deployable architecture.

AI developers and engineers building real-time conversational applications who require absolute control over the entire speech pipeline and extremely low latency. It is essential for those building interactive voice assistants where response time is critical. The open architecture allows for fine-tuning and swapping out individual components of the speech pipeline.

  • Modular pipeline: Seamlessly integrates completely interchangeable ASR, LLM, and TTS models to customize the agent's specific capabilities.
  • Ultra-low latency: Employs advanced streaming techniques and highly optimized audio buffering to heavily reduce conversational delay.
  • VAD integration: Actively utilizes Voice Activity Detection to precisely know when the user starts and stops speaking in real-time.
  • Multilingual support: Natively handles rapid cross-lingual conversations by leveraging highly advanced translation and multilingual speech models.
  • WebSocket streaming: Provides a highly robust WebSocket architecture to continuously stream audio data back and forth from the client.

Where teams use it

Interactive tutoring

Developers building a highly responsive language learning application where users practice pronunciation with a real-time AI conversationalist.

Voice assistants

Engineers deploying custom, low-latency smart home assistants utilizing specialized domain knowledge without relying on commercial APIs.

Accessibility tools

Creating extremely fast, voice-driven interfaces for users with mobility impairments to completely control complex software applications.

Automated translation

Building real-time translation tools that instantly listen to one language and speak the exact response back in another.

Getting started: pip install speech-to-speech && speech-to-speech serve

README

main branch
 

Speech To Speech: Build voice agents with open-source models

GitHub Trending: #1 Repository of the Day

PyPI Python License

A low-latency voice agent built from open models that runs entirely on your computer. One command starts a conversation: no API key, no cloud service.

The default pipeline is Silero VAD → Parakeet TDT → Qwen3.5-4B → Qwen3-TTS, and every stage is swappable. The server speaks the OpenAI Realtime protocol over WebSocket and WebRTC, so apps built for OpenAI's Realtime API can point at your own machine instead.

This pipeline runs in production as the conversation backend for thousands of Reachy Mini robots.

Switching an OpenAI Realtime client endpoint from hosted OpenAI to a self-hosted speech-to-speech server

Quickstart

Use CPython 3.11–3.14 (3.11 recommended):

python3 -m venv .venv
source .venv/bin/activate
pip install speech-to-speech
speech-to-speech local

Then talk: speak, pause, and the assistant answers through your speakers. Stop with Ctrl+C. The first run downloads the models, so give it a few minutes. On speakers, add --echo-cancellation so the assistant does not hear itself and you can still interrupt it by voice; headphones don't need it. See echo cancellation for requirements and limits.

By default, local and talk show final user transcripts and streaming assistant replies once, hiding backend transcript copies, routine logs, tool details, and protocol events. User messages are yellow and assistant replies are green in a color-capable terminal. Startup shows Loading models…, followed by Ready — start speaking. once the audio devices are running and the session is configured. Routine model-loading output is hidden; startup failures show their diagnostics. Runtime warnings and errors remain visible.

For diagnostic output, add --verbose:

speech-to-speech local --verbose

Use --verbose --log_level debug for more detailed local logs. Raw event output (local --local_audio_print_json or talk --print-json) also enables diagnostic output.

On Ubuntu, first install the audio libraries with sudo apt-get install libportaudio2 libsndfile1. The default Linux Qwen3-TTS wheel targets CUDA 12.8 and Ubuntu 24.04; see the CUDA note for other systems. On Windows, activate the environment with .venv\Scripts\Activate.ps1.

The default installation has the following CI coverage:

Platform Supported CPython versions Checks
Linux 3.11, 3.12, 3.13, 3.14 Full test suite and installed package smoke test
Apple Silicon macOS 3.11, 3.12, 3.13, 3.14 Installed package smoke test

Optional model backends can have narrower Python requirements. Windows is not covered by this compatibility matrix. Python 3.10 is no longer supported following its end of life on October 1, 2026.

Kokoro is optional on every platform. On macOS, its Misaki dependency requires Python <3.13, so use Python 3.11 or 3.12 with speech-to-speech[kokoro]. The default Qwen3-TTS backend does not require Misaki. Python 3.15 is not yet supported on any platform: ONNX Runtime lacks CPython 3.15 wheels, and the pinned macOS PyTorch release also lacks them. Newer Python versions will be added after the default dependencies and CI checks pass; the package's requires-python lower bound does not promise compatibility with future Python releases.

The command picks local models for your platform:

Platform LLM Plan for
Apple Silicon Mac Qwen3.5-4B 4-bit via MLX LM 16 GB of unified memory
Linux / Windows with NVIDIA Qwen3.5-4B via Transformers 24 GB of VRAM
Other machines Qwen3.5-4B via Transformers on CPU Slow replies

Speech recognition and synthesis run locally too. After the first run, everything works offline. To use another model, a llama.cpp server, or a hosted provider, see LLM backends.

Connect your own app

local runs a server and a microphone client in one process. To run only the server:

speech-to-speech serve

It listens at ws://127.0.0.1:8765/v1/realtime. Connect with:

  • the packaged audio client: speech-to-speech talk --url ws://127.0.0.1:8765/v1/realtime
  • the browser demo
  • any client using the core OpenAI Realtime events; the OpenAI Agents SDK is tested over both transports (see Realtime API)
  • LiveKit Agents, as the agent's realtime model

Index

How it works

The pipeline is a cascade of four components, each running in its own thread and connected by queues:

  1. Voice Activity Detection (VAD): Silero VAD detects speech boundaries and turn-taking.
  2. Speech to Text (STT): transcribes the user's turn, with optional live partial transcripts.
  3. Language Model (LLM): generates the response, streaming text and tool calls.
  4. Text to Speech (TTS): synthesizes audio and streams it back to the client.

Every stage has multiple interchangeable backends, selected via CLI flags. The code is designed for easy modification, with a focus on models available through Transformers and the Hugging Face Hub.

Optional speech-to-viseme extraction adds timed mouth shapes for avatar and robot clients after TTS. Enable it with --enable_visemes; see the viseme guide for client events and timing.

Installation

pip install speech-to-speech (see the Quickstart) includes everything the default pipeline needs:

  • Silero VAD and Parakeet TDT for listening
  • Qwen3.5-4B for replies: MLX LM on macOS, Transformers elsewhere
  • Qwen3-TTS for speech: mlx-audio on Apple Silicon, GGML elsewhere
  • the local audio client and the Realtime server

Platform-specific dependencies are resolved automatically.

See the configuration guide for reusable blocks, named pipelines, environment references, and explicit Python startup. The Mac example runs fully locally on Apple Silicon. From a repository checkout, run its audio client and server together, or start only the server:

speech-to-speech local -f example_configs/mac.yaml
speech-to-speech serve -f example_configs/mac.yaml --name mac

local runs one selected pipeline with the packaged loopback audio client. talk -f example_configs/mac.yaml uses only the file's client settings. Configured server startup currently supports one named definition per invocation; its num_pipelines controls the number of isolated instances. Existing Python interfaces, CLI commands, and flat JSON configuration remain available.

CUDA Note for Qwen3-TTS

On Linux, the Qwen3-TTS GGML backend comes from faster-qwen3-tts[ggml]. Its default qwentts-cpp-python wheel on PyPI targets CUDA 12.8 and manylinux_2_39 (for example, Ubuntu 24.04). If your CUDA runtime or glibc is older, install the matching wheel from the Hugging Face wheelhouse before installing speech-to-speech:

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

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

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

pip install speech-to-speech

On DGX Spark (Linux ARM64, CUDA 13), the default CUDA 12 wheel can fail with libcudart.so.12 missing. From the repository root, sync dependencies, then install the CUDA 13 ARM64 wheel and launch with --no-sync as shown below. Plain uv run or uv sync can replace this wheel; reinstall it after syncing.

uv sync
uv pip install --python .venv/bin/python --no-deps \
  "https://huggingface.co/datasets/andito/qwentts-cpp-python-wheels/resolve/main/whl/cu130/qwentts_cpp_python-0.5.0%2Bcu130-py3-none-manylinux_2_39_aarch64.whl"
uv run --no-sync speech-to-speech serve

To use the previous CUDA-graphs implementation instead of GGML, pass --qwen3_tts_backend torch.

Optional Components

Optional components are installed with pip extras:

pip install "speech-to-speech[kokoro]"          # Kokoro-82M TTS (macOS: Python 3.11–3.12)
pip install "speech-to-speech[kitten]"          # KittenTTS
pip install "speech-to-speech[pocket]"          # Pocket TTS
pip install "speech-to-speech[phonon]"          # Phonon TTS (checkpoint supplied separately)
pip install "speech-to-speech[chattts]"         # ChatTTS
pip install "speech-to-speech[omnivoice]"       # OmniVoice TTS (CUDA, Intel XPU, or Apple Silicon)
pip install "speech-to-speech[faster-whisper]"  # Faster Whisper STT
pip install "speech-to-speech[whisper-mlx]"     # Lightning Whisper MLX STT on macOS
pip install "speech-to-speech[paraformer]"      # Paraformer STT through FunASR
pip install "speech-to-speech[fireredvad]"      # FireRed streaming VAD
pip install "speech-to-speech[nemo]"            # Parakeet Unified, Nemotron, and Orukeet STT through NeMo
pip install "speech-to-speech[mlx-lm]"          # mlx-vlm support for vision models on macOS

Deprecated implementations, including MeloTTS, live in archive/ and are no longer wired into the CLI.

Note on DeepFilterNet: DeepFilterNet, used for optional audio enhancement in VAD, requires numpy<2 and conflicts with Pocket TTS, which requires numpy>=2. Install it manually only in environments where you are not using Pocket TTS.

From Source

To work on the code, install Git and uv, then run:

git clone https://github.com/huggingface/speech-to-speech.git
cd speech-to-speech
uv sync --python 3.11
source .venv/bin/activate

This installs the package in editable mode. With the environment activated, use the same speech-to-speech commands shown above.

Supported Components

Component Backend Platforms Install
VAD Silero VAD all built-in
VAD FireRed Stream-VAD CUDA / CPU fireredvad
STT Parakeet TDT (default) CUDA / CPU through nano-parakeet, Apple Silicon through MLX built-in
STT Parakeet Unified CUDA / CPU nemo
STT Nemotron Speech Streaming CUDA / CPU nemo
STT Nemotron Streaming Farsi, selected with --stt nemotron-streaming --nemotron_streaming_model_name mehdi-hf/nemotron-asr-streaming-farsi CUDA / CPU nemo, NeMo >=3.0, Python >=3.11
STT Orukeet CUDA / CPU nemo
STT Whisper through Transformers CUDA / CPU built-in
STT Faster Whisper CUDA / CPU faster-whisper
STT Lightning Whisper MLX Apple Silicon whisper-mlx
STT MLX Audio Whisper Apple Silicon built-in on macOS
STT Paraformer CUDA / CPU paraformer
STT Qwen3-ASR through Transformers CUDA / CPU, Apple Silicon built-in
STT OpenAI-compatible /v1/audio/transcriptions endpoint local or remote HTTP server built-in
STT OpenAI Realtime transcription hosted or compatible WebSocket server built-in
STT vLLM Realtime transcription (experimental) local or remote vLLM server built-in
LLM mlx-lm (default on macOS) Apple Silicon built-in on macOS
LLM Transformers (default elsewhere) supported accelerators / CPU built-in
LLM OpenAI-compatible API (responses-api, chat-completions) optional hosted providers or self-hosted servers built-in
TTS Qwen3-TTS (default) GGML / CUDA on Linux, mlx-audio on macOS built-in
TTS Kokoro-82M CUDA / CPU, Apple Silicon kokoro (macOS: Python 3.11–3.12)
TTS KittenTTS CPU kitten
TTS Pocket TTS CPU / CUDA pocket
TTS Phonon CPU (including Apple Silicon) phonon
TTS ChatTTS CUDA / CPU chattts
TTS OmniVoice CUDA / Intel XPU / Apple Silicon omnivoice
TTS MMS TTS CUDA / CPU built-in
TTS OpenAI-compatible /v1/audio/speech endpoint local or remote HTTP server built-in
TTS Fish Audio Drama-3 (--tts drama3) SGLang Omni on a local or remote GPU host built-in client
TTS MiniMax hosted HTTP streaming built-in

Optional streaming speaker diarization adds speaker labels to transcribed turns. Enable it with --diarization after installing the supporting Transformers build; the linked guide has the current model revision and setup while the merged Transformers PR #49056 is awaiting a package release.

Select implementations with --stt, --llm_backend, and --tts. The CLI constructs configuration only for the selected backends; known options for inactive backends remain accepted for compatibility but are ignored with a warning. JSON configuration may likewise include extra inactive-backend keys, which are ignored. Run speech-to-speech serve -h for the defaults, or pass selectors before -h to see another combination's backend-specific flags (for example, speech-to-speech serve --stt mlx-audio-whisper -h).

For client-only TTS serving with vLLM-Omni or another compatible server, see OpenAI-compatible TTS.

For client-only speech recognition with vLLM, OpenAI's hosted Transcription API, or another compatible server, see OpenAI-compatible STT. For native incremental audio and partial transcripts, see stateful streaming STT.

Commands

Command Behavior Use it when
serve Runs the pipeline server over OpenAI Realtime WebSocket and WebRTC. You are building an app or device against the API.
talk --url <full-realtime-url> Runs the packaged microphone/speaker client. You want to talk to an existing Realtime server.
local Composes serve and talk in-process over loopback. You want to run the server and talk to it from one command.

serve binds to 127.0.0.1 by default; pass --host 0.0.0.0 explicitly for network exposure. local always binds to loopback and connects the same packaged client at ws://127.0.0.1:<port>/v1/realtime.

The command only decides how the server and client run. Where replies are generated is set by --llm_backend, which is local by default for every command.

The packaged local client buffers 196 ms of received audio when using the OpenAI-compatible TTS backend, which absorbs short delivery gaps from HTTP speech inference. Other local backends and talk start playback immediately by default. Use --playback-buffer-ms <milliseconds> to override either default: a larger value resists stuttering but delays the start of each response, while a smaller value starts sooner but is more sensitive to jitter. This setting only controls the packaged Python client's speakers; browser and other Realtime clients manage their own playback buffers.

By default, user speech interrupts the assistant: the server cancels the response and the packaged client drops the audio it has queued. Pass talk --no-interrupt-response or local --local_audio_interrupt_response false to let the reply finish. The microphone stays open and your speech is still transcribed, unlike --block-mic-during-playback, which stops sending microphone audio. talk --vad-threshold <0-1> and local --local_audio_vad_threshold <0-1> set the session VAD threshold; without them the server's --thresh applies. A higher threshold can reduce false triggers in a noisy room, but it cannot tell your voice apart from other people talking nearby. See Interruption Handling for the session fields other clients send.

The packaged client can opt in to local Python tools with talk --tool-module <module> or local --tool-module <module>. The module contract, programmatic API, and web-search examples (Serper, or keyless You.com) are documented in Tool calling design.

Migrating from --mode

--mode is deprecated and will stop working soon. During this migration window, speech-to-speech --mode realtime runs speech-to-speech serve, and speech-to-speech --mode local runs speech-to-speech local; both print a warning. All other mode values have been removed and exit with guidance to use the new commands.

Local Mac

On macOS, local and serve already run all three models through MLX. The optional --mac-optimal-settings preset also makes MPS the default device for supported components. It only sets defaults: explicit --device, component-device flags such as --qwen3_tts_device, and --stt, --llm_backend, --model_name, and --tts all win.

--tts pocket, --tts phonon, --tts kokoro, --tts omnivoice, and --tts kitten are also valid on macOS.

To compare the MLX quantization variants locally:

python scripts/benchmark_tts.py \
    --handlers qwen3 \
    --iterations 3 \
    --qwen3_mlx_quantizations bf16 4bit 6bit 8bit

Docker

Install the NVIDIA Container Toolkit, then:

docker compose up

The compose file starts a llama.cpp server with Gemma 4 and the Realtime server, exposing ports 8080 and 8765.

Realtime API

The server logs per-response STT, LLM, first TTS audio, and speech-to-audio durations for supported backends, including vLLM-backed STT and TTS. Tool-assisted replies also report total LLM time and the number of model rounds. See the response latency guide for the coverage matrix and measurement boundaries.

Realtime mode supports the OpenAI Realtime protocol over WebSocket and WebRTC, with live transcription and low-latency turn-taking. WebSocket clients connect at /v1/realtime:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8765/v1",
    websocket_base_url="ws://localhost:8765/v1",
    api_key="not-needed",
)

with client.realtime.connect(model="local") as conn:
    conn.send(
        {
            "type": "session.update",
            "session": {
                "type": "realtime",
                "instructions": "You are a helpful assistant.",
                "audio": {
                    "input": {
                        "turn_detection": {
                            "type": "server_vad",
                            "interrupt_response": True,
                        }
                    }
                },
            },
        }
    )

    for event in conn:
        print(event.type)

The server implements the core Realtime event set: input_audio_buffer.append, session.update, conversation.item.create, conversation.item.truncate, response.create, and response.cancel inbound; speech start/stop, streaming transcription, audio deltas, tool calls, and response.done outbound. CI connects pinned @openai/agents RealtimeSession instances through the SDK's stock WebSocket and WebRTC transports. This is a tested core subset, not a claim of full OpenAI Realtime API equivalence. The event matrix, architecture, and design details live in the Realtime Engine README.

LLM Proxy

With --enable_llm_proxy, the realtime server also exposes the remote LLM it is configured with as a plain OpenAI compatible endpoint, so a client can run side tasks (summaries, titles, background agents) with tools and streaming, fully concurrent with the voice conversation and never interrupted by new speech:

  • POST /v1/chat/completions when running --llm_backend chat-completions
  • POST /v1/responses when running --llm_backend responses-api

The server performs no authentication and no throttling of its own. Enable the proxy only on a trusted network, or deploy the server behind a gateway that owns access control. The s2s-endpoint compute replica is such a gateway: it opens these paths only to clients that created their session with an HF token, checks the API key against that token, and applies a rate limit per user. Point the stock OpenAI SDK at whichever host you talk to; this server ignores the API key (a gateway in front decides what it must be):

from openai import OpenAI

llm = OpenAI(base_url="http://localhost:8765/v1", api_key="unused")
completion = llm.chat.completions.create(
    model="anything",  # ignored: the server forces its configured --model_name
    messages=[{"role": "user", "content": "Summarize the conversation so far: ..."}],
)

Requests are stateless (send the full message list each time) and are proxied to the configured upstream with the key held by the server, which never reaches clients. The model field is always overwritten with the server configured --model_name. The proxy is off by default, requires a remote backend (chat-completions or responses-api), and answers 501 with the reason otherwise.

LLM Backends

By default the LLM runs inside the speech process. You can swap the model, run it in a separate server, or hand it to a hosted provider:

Where the LLM runs Backend
In process on Apple Silicon (default) mlx-lm
In process elsewhere (default) transformers
A separate server on your hardware (llama.cpp, vLLM, ...) responses-api or chat-completions
A hosted provider responses-api or chat-completions

Changing the local model

Pass --model_name, using an MLX conversion on Mac and a Transformers checkpoint elsewhere:

speech-to-speech local --model_name mlx-community/Qwen3.5-9B-4bit   # Apple Silicon
speech-to-speech local --model_name Qwen/Qwen3.5-9B                 # Linux / Windows

Transformers picks an available accelerator and falls back to CPU. --llm_device overrides the LLM's device; --device overrides every stage. Generation options such as --llm_gen_max_new_tokens are in the LLM guide.

Combining with llama.cpp

Serve the LLM with llama.cpp and connect speech-to-speech through its local Responses API. This works on Apple Silicon or Linux/NVIDIA. Install llama.cpp with brew install llama.cpp on macOS or use a CUDA build on NVIDIA.

With the default speech models, budget 24 GB of unified memory on Mac or 16 GB of VRAM on NVIDIA; about 8 GB of that goes to the speech pipeline.

Terminal 1 — start the LLM and leave it running:

llama-server \
    -hf ggml-org/gemma-4-E4B-it-GGUF:Q4_0 \
    --alias local-gemma \
    --host 127.0.0.1 --port 8080 \
    -ngl all -np 1 -c 8192 -fa on \
    --no-mmproj \
    --reasoning off

Terminal 2 — activate your Python environment and connect the speech pipeline to that LLM:

speech-to-speech local \
    --llm_backend responses-api \
    --model_name local-gemma \
    --responses_api_base_url http://127.0.0.1:8080/v1 \
    --responses_api_api_key ""

The Q4_0 weights are about 4.6 GB. The example uses one 8k context and disables reasoning for faster replies; --no-mmproj skips the image/audio projector because STT supplies text. To try another GGUF model, change -hf and keep --alias and --model_name matched.

Local speech with a hosted LLM

Select an API backend to move only the LLM to a provider. For OpenAI:

export OPENAI_API_KEY=...
speech-to-speech local --llm_backend responses-api

This uses gpt-5.6-terra with reasoning effort none. Speech recognition and synthesis stay local, so your audio never leaves your computer; transcribed text and conversation history go to the provider.

Two API backends share the same --responses_api_* connection flags:

  • --llm_backend responses-api targets /v1/responses.
  • --llm_backend chat-completions targets /v1/chat/completions.

Responses API Backend

Works with any provider or server that implements the OpenAI Responses API. Point --responses_api_base_url at the endpoint and set --model_name accordingly:

Provider / server --responses_api_base_url --responses_api_api_key
OpenAI omit, uses OpenAI default $OPENAI_API_KEY
HF Inference Providers https://router.huggingface.co/v1 $HF_TOKEN
OpenRouter https://openrouter.ai/api/v1 $OPENROUTER_API_KEY
vLLM http://localhost:8000/v1 omit or any string
llama.cpp http://127.0.0.1:8080/v1 empty string
# OpenAI
speech-to-speech local \
    --llm_backend responses-api \
    --model_name "gpt-4o-mini" \
    --responses_api_api_key "$OPENAI_API_KEY" \
    --responses_api_stream \
    --enable_live_transcription
# HF Inference Providers: Qwen3.5-9B via Together
speech-to-speech local \
    --llm_backend responses-api \
    --model_name "Qwen/Qwen3.5-9B:together" \
    --responses_api_base_url "https://router.huggingface.co/v1" \
    --responses_api_api_key "$HF_TOKEN" \
    --responses_api_stream \
    --enable_live_transcription
# HF Inference Providers: GPT-oss-20B via Groq
speech-to-speech serve \
    --llm_backend responses-api \
    --model_name "openai/gpt-oss-20b:groq" \
    --responses_api_base_url "https://router.huggingface.co/v1" \
    --responses_api_api_key "$HF_TOKEN" \
    --responses_api_stream \
    --enable_live_transcription

Chat Completions Backend

Identical configuration to responses-api, reusing the same --responses_api_* connection flags, but talks to /v1/chat/completions instead of /v1/responses. Prefer it when:

  • the provider ignores chat_template_kwargs.enable_thinking on the Responses path and needs a reasoning_effort knob to suppress reasoning, or
  • the server's Responses streaming tool-call path is unreliable, while its Chat Completions tool-call streaming is solid. This is useful for some vLLM builds; see #312.

Add --responses_api_reasoning_effort none to disable reasoning on providers where the chat-template flag has no effect:

# vLLM serving a Qwen model with tool calling
speech-to-speech serve \
    --llm_backend chat-completions \
    --model_name "Qwen/Qwen3.5-4B" \
    --responses_api_base_url "http://localhost:8000/v1" \
    --responses_api_stream
# Gemma 4 31B via the HF router on Cerebras, with reasoning disabled for low voice latency
speech-to-speech serve \
    --llm_backend chat-completions \
    --model_name "google/gemma-4-31B-it:cerebras" \
    --responses_api_base_url "https://router.huggingface.co/v1" \
    --responses_api_api_key "$HF_TOKEN" \
    --responses_api_reasoning_effort none \
    --responses_api_stream

Direct Audio Input (No STT)

Use --stt none --llm_backend chat-completions to send each completed VAD audio segment directly to an audio-input model. Direct audio mode is not supported with --llm_backend responses-api: a model may accept audio through /v1/chat/completions without supporting /v1/responses, including OpenAI's gpt-audio-1.5.

You must explicitly set --model_name to a model that accepts audio: the API backends' default gpt-5.6-terra accepts text and image input, but not audio. Check the provider's model documentation and endpoint support before enabling this mode. For OpenAI, see the GPT-5.6 Terra model card and audio-input guide.

speech-to-speech serve \
    --stt none \
    --llm_backend chat-completions \
    --model_name "YOUR_AUDIO_CAPABLE_MODEL" \
    --responses_api_base_url "https://provider.example/v1" \
    --responses_api_api_key "$PROVIDER_API_KEY"

OpenAI-compatible servers represent input audio differently. Use --responses_api_audio_content_type input_audio (the default) for embedded WAV base64, or --responses_api_audio_content_type audio_url for a base64 data URL.

For a fully local audio-input model on Apple Silicon, see the Gemma 4 12B example.

Offline Operation

The pipeline can run without internet access after the dependencies and model assets for the selected components are installed locally. Before disconnecting, start the exact configuration once while online so it can cache the STT, LLM, TTS, Silero VAD, NLTK, and Smart Turn resources it needs.

After that first run, set HF_HUB_OFFLINE=1 to skip Hugging Face Hub requests:

HF_HUB_OFFLINE=1 speech-to-speech local

For the llama.cpp configuration, keep the LLM server running and pass the same LLM flags:

HF_HUB_OFFLINE=1 speech-to-speech serve \
    --llm_backend responses-api \
    --model_name local-gemma \
    --responses_api_base_url "http://127.0.0.1:8080/v1" \
    --responses_api_api_key ""

Hosted LLMs still need a connection.

Smart Turn uses a separate ONNX checkpoint. A cached checkpoint works with HF_HUB_OFFLINE=1; for an explicit, cache-independent setup, pass --smart_turn_model_path /path/to/smart-turn-v3.2-cpu.onnx. If the checkpoint is not available, pass --no_smart_turn to disable Smart Turn.

Multi-Language Support

Language coverage depends on the STT and TTS backends you pick, not on the pipeline itself:

Component Backend Languages
STT Parakeet TDT (default) 25 European languages
STT Whisper / Whisper MLX / Faster Whisper Broad multilingual coverage, depending on the selected Whisper checkpoint
STT Paraformer Depends on the selected FunASR checkpoint; the default is Chinese-oriented
TTS Qwen3-TTS (default) Multilingual, with --qwen3_tts_language auto by default
TTS Kokoro Multiple language/voice mappings, depending on backend availability
TTS KittenTTS English
TTS ChatTTS English and Chinese
TTS MMS TTS Broad multilingual coverage through MMS checkpoints
TTS OmniVoice 600+ languages; voice cloning, design, and automatic voice selection
TTS Supertonic 32 languages
TTS Pocket TTS English, French, German, Portuguese, Italian, Spanish
TTS OpenAI-compatible /v1/audio/speech endpoint Depends on the connected TTS server/model

Make sure the STT, LLM, and TTS you pair all cover your target language(s). By default, the language code sent to TTS comes from the user's transcription. Qwen3-TTS keeps its configured auto behavior by default. Add --detect_llm_output_language to detect the language of each assistant text chunk instead and send that code to TTS. This helps when the assistant replies in a different language from the user. The Lingua detector is loaded and warmed when the pipeline starts, so detection does not wait for the full reply. Short text (under 20 characters for most languages, or under four CJK characters) and ambiguous text use the last detected assistant language for that response. If there is none yet, TTS receives no language code and uses its own automatic or default behavior; this avoids delaying speech to collect more text. A TTS backend must support the detected language to use it. When a Realtime session selects a language with session.audio.input.transcription.language, STT keeps that language, but TTS receives the confidently detected assistant language instead. The first spoken text of each response decides; if it is too short or ambiguous, the whole response uses the session's selected language. If the active TTS backend cannot speak the detected language, that response uses the session's selected language.

For Parakeet TDT, the decoder chooses the transcription language automatically. --parakeet_tdt_language remains accepted for compatibility with existing commands, but setting it to a code such as de does not constrain decoding. The reported language is inferred with Lingua from the finished transcription when possible. Text shorter than 20 characters is not classified, and inconclusive or failed detection reports an unknown language rather than the configured or previous code. --language belongs to the Whisper backends; it does not control Parakeet. For Whisper and Whisper MLX, use --language auto to detect each turn, or a code such as --language zh to fix the language. Other STT backends have their own language flags; see the STT component guide.

To encourage replies in the user's detected language, add --enable_lang_prompt. It appends a per-turn instruction such as "Please reply to my message in French." The flag is off by default and works independently of --detect_llm_output_language. Qwen3-TTS uses --qwen3_tts_language auto by default: it infers language from text unless assistant language detection or a session selection supplies a supported code. Set --qwen3_tts_language german, for example, to force synthesis in German.

Automatic detection with Parakeet and a language instruction for the LLM:

speech-to-speech serve \
    --stt parakeet-tdt \
    --enable_lang_prompt \
    --detect_llm_output_language \
    --qwen3_tts_language auto

A single non-English language, Chinese in this example:

speech-to-speech serve \
    --stt whisper-mlx \
    --stt_model_name large-v3 \
    --language zh

Both commands also work with --mac-optimal-settings; explicit --stt flags override the defaults it sets.

OmniVoice

OmniVoice provides voice cloning, voice design, and automatic voice selection across 600+ languages. Install its opt-in dependencies and provide a reference clip plus its transcript for voice cloning. This example uses CUDA on Linux or Windows; use --omnivoice_device mps on Apple Silicon, --omnivoice_device xpu with an Intel XPU-enabled PyTorch installation, or --omnivoice_device npu with an Ascend torch_npu installation:

pip install "speech-to-speech[omnivoice]"
speech-to-speech serve \
    --tts omnivoice \
    --omnivoice_device cuda \
    --omnivoice_ref_audio /path/to/reference.wav \
    --omnivoice_ref_text "Transcript of the reference clip."

The handler converts OmniVoice's completed 24 kHz float output into the pipeline's 16 kHz int16 blocks. OmniVoice does not currently expose incremental audio through generate(), so the first block is available only after the full utterance has been synthesized. See the TTS component guide for saved prompts, voice design, devices, latency, and all backend flags.

The omnivoice extra is supported on Linux, Windows, and macOS. On non-macOS platforms, both OmniVoice and the built-in Qwen3 backend share Transformers 5 through faster-qwen3-tts>=0.4.0, so installing this extra keeps the default Qwen3 path available. Linux uses Qwen3's GGML extra by default; see the CUDA note if its CUDA 12.8 / manylinux_2_39 native wheel does not match your host.

Warning

OmniVoice's code is Apache-2.0, but its pretrained weights are CC-BY-NC and are not licensed for commercial use. Use voice cloning only with authorization and consent; do not use it for impersonation, fraud, scams, or other illegal or unethical activity.

Pocket TTS

Pocket TTS from Kyutai Labs provides streaming TTS with voice cloning:

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

Available voice presets: alba, marius, javert, jean, fantine, cosette, eponine, azelma. Custom voice files and Hugging Face paths also work.

Pocket TTS Farsi v2

Select mehdi-hf/pocket-tts-farsi-v2 with --pocket_tts_model_name. The handler normalizes Persian spelling, expands numbers, and converts assistant text to phonemes with mehdi-hf/Homo-GE2PE-Persian-HF before synthesis. Both models download on first use.

The released Pocket TTS package does not support this model's phoneme frontend flags yet. Install the author's fork after the pocket extra. This command pins an inspected commit for reproducibility:

pip install "speech-to-speech[pocket]"
pip install "pocket-tts @ git+https://github.com/mallahyari/pocket-tts@3807c204babb5fe54be8fe18a362a58315e870d6"
speech-to-speech serve \
    --tts pocket \
    --pocket_tts_model_name mehdi-hf/pocket-tts-farsi-v2 \
    --pocket_tts_voice /voices/persian-reference.wav \
    --pocket_tts_device cpu

Use a Persian reference recording as a local audio file or Hugging Face audio URL. Preset voice states such as jean are incompatible with these weights. The handler uses the first five seconds of the recording. It splits text at sentence boundaries before phoneme conversion, adds a 0.25-second pause between sentences, and limits synthesis chunks to 18 tokens. It keeps ezafe-linked words together and rejects a linked phrase that exceeds the budget. Oversized G2P inputs raise an error rather than lose text. Configure the LLM to respond in Persian. This model choice stays fixed for the session and does not switch languages based on STT detection.

Farsi synthesis bypasses the fork's orthographic sentence splitter so that ? remains a glottal-stop phoneme. It uses an EOS threshold of -2 and zero extra frames after EOS. --pocket_tts_temperature overrides the model's default of 0.3; --pocket_tts_eos_threshold overrides -2. Each phoneme chunk is buffered before playback. Silent, non-finite, or length-capped output is retried once, then reported as an error. This adds one chunk's generation time before the first audio block, but avoids playing a failed attempt. PCM conversion clips peaks instead of wrapping, and downsampling preserves filter history across playback blocks.

To check the handler with actual weights from a source checkout, run:

python scripts/check_pocket_tts_farsi.py --output-dir /tmp/pocket-tts-farsi-check

The check downloads the TTS and G2P models and the author's Persian reference samples/prompt_short_sentence.wav. It uses seed 42 and temperature 0.3. It synthesizes a greeting, a sentence with a Persian number, and a two-sentence reply. It checks PCM block format, non-silent output, and response completion, then saves WAVs and timing measurements. Listen to the WAVs to assess pronunciation. Use --voice /voices/reference.wav to test your own recording. The check saves native 24 kHz audio by default. Pass --sample-rate 16000 to compare with the pipeline's current 16 kHz playback output. The server and local playback path still assume 16 kHz, so changing only --pocket_tts_sample_rate to 24000 does not enable native-rate playback.

The model weights use CC-BY-NC-4.0 and are for non-commercial use.

Phonon TTS

Phonon from Gradium streams speech locally through the Rust-backed ptts Python runtime. Install the optional extra:

pip install "speech-to-speech[phonon]"
speech-to-speech local --mac-optimal-settings --tts phonon

The default checkpoint is gradium/phonon-31m-en, a public English model under Apache-2.0. It downloads on first use without a Hugging Face login. --phonon_tts_model_name accepts another Hub repo or a local checkpoint directory, which must include its matching config.json, tokenizer.json, q8 model.q8.gguf, and voice embeddings. Besides the checkpoint's own voices, Phonon offers the Phonon voice catalog voices in the checkpoint's languages (37 for English). A catalog voice downloads on first use. Use --phonon_tts_voice VOICE_NAME to select one; omitting it uses the checkpoint's default. Keep private checkpoints outside the repository.

local --tts phonon lets you cycle through these voices using the terminal's left/right or up/down arrows. The selected voice is displayed immediately and applied after the current reply finishes, preserving the conversation. This requires an interactive macOS or Linux terminal. The standalone talk client can opt in with --voices Zoey Harper Easton and select its initial voice with --voice Zoey.

Phonon uses four native CPU threads by default, which performed better than the runtime's twelve-thread default on an Apple M3 Pro in local testing. Use --phonon_tts_num_threads N to tune it at startup; the setting is shared by all Phonon pipelines in the process.

Phonon ends each utterance with a long quiet tail, which adds a pause between sentence-streamed chunks. --phonon_tts_max_trailing_silence_ms 120 shortens that tail toward a 120 ms target (minimum setting 40); omitting it, the default, preserves native audio. Audio below -60 dBFS RMS in 10 ms windows counts as quiet. Leading audio and internal pauses are kept. At most one second is removed per utterance, so a tail more than one second over the target stays longer than it. Speech is not delayed: only quiet audio beyond the target is held, until speech resumes or the utterance ends. Very quiet voices may need native audio.

Phonon runs on CPU even when STT or the LLM uses a GPU. Native audio is resampled to the pipeline's 16 kHz PCM16 output, and interruption closes the native stream. --phonon_tts_language fixes text normalization at startup; use en (the default), fr, de, es, pt, or none. Session language changes are restricted to that configured language. See the TTS component guide for installation and checkpoint options.

The Phonon 40M checkpoints, such as gradium/phonon-40m-en, are gated and use CC BY-NC 4.0, so they are for non-commercial use. To use one, accept its terms on Hugging Face, set HF_TOKEN or run hf auth login, and pass --phonon_tts_model_name gradium/phonon-40m-en.

CLI Reference

References for pipeline CLI arguments live in the arguments classes and in speech-to-speech serve -h. Client arguments are listed by speech-to-speech talk -h.

Module-Level Parameters

See ModuleArguments. It allows setting:

  • a common --device, if every part should run on the same device
  • macOS model/device defaults (--mac-optimal-settings)
  • STT implementation (--stt)
  • LLM backend (--llm_backend: transformers, mlx-lm, responses-api, or chat-completions)
  • TTS implementation (--tts)
  • logging level
  • transcript logging (--log_transcripts)
  • realtime pipeline pool size (--num_pipelines)
  • PyTorch CPU thread count (--torch_num_threads)

Logs are content-free by default: transcript-bearing records report a character count rather than the text, because logs are commonly retained by service managers, containers and hosted log aggregators. Pass --log_transcripts to include full user and assistant transcripts when debugging STT, LLM, TTS or Realtime behaviour; it logs a warning at startup because enabling it writes conversation content wherever those logs are collected. The talk client takes the same flag, as --log-transcripts or --log_transcripts.

--torch_num_threads N sets PyTorch's CPU intra-op thread count (torch.set_num_threads) for the whole process. It is unset by default, which keeps the current behaviour: Silero VAD sets PyTorch to a single thread when it loads, and that single thread also applies to every other PyTorch model on the CPU. If your STT runs on the CPU, you can trade some Silero speed for faster transcription:

speech-to-speech serve --stt parakeet-tdt --device cpu --torch_num_threads 8

The setting is shared: Silero and the CPU STT use the same thread count, and more threads can slow Silero down, so measure the complete pipeline when choosing a value. It only affects PyTorch; ONNX Runtime, MLX and other non-PyTorch backends keep their own thread settings. In a YAML configuration, set it under runtime as torch_num_threads. See the torch.set_num_threads documentation.

VAD Parameters

See VADHandlerArguments. Notable options:

  • --thresh: threshold value to trigger voice activity detection.
  • --min_speech_ms: minimum duration of detected voice activity to be considered speech.
  • --min_speech_continuation_ms: sustain-bar hysteresis threshold for speech that continues a reopenable soft-ended, uncommitted turn within the reopen window. The default and recommended pairing is --min_speech_ms 384 --min_speech_continuation_ms 192.
  • --min_silence_ms: minimum length of silence intervals for segmenting speech. Default is 64 ms.
  • --short_segment_merge_ms: optional merge window for stitching adjacent VAD segments that are each shorter than --min_speech_ms.
  • --speculative_reopen_ms: delay response commitment for 800 ms after a soft-ended turn so immediately resumed speech can reopen it.
  • --unanswered_reopen_ms: sanity cap on how long a soft-ended speculative turn that has not yet received any assistant output stays reopenable. With Smart Turn enabled, this is clamped to at least --smart_turn_max_wait_ms so a turn remains reopenable for its full grace.

Smart Turn endpointing

Smart Turn v3.2 can validate Silero's end-of-speech decisions using the content and prosody of the current turn. Silero finalizes the segment and STT/LLM work may begin speculatively. Complete turns start processing immediately and use --speculative_reopen_ms (800 ms by default) before committing output. Incomplete turns wait --smart_turn_incomplete_delay_ms (600 ms by default) before starting STT/LLM work, while their output remains gated by --smart_turn_max_wait_ms (2 seconds by default). If speech resumes during either delay, the existing turn is reopened as a newer revision, the accumulated audio is re-emitted, and work from the previous revision is discarded before it reaches the user.

The turn tracker owns the conversation order and the LISTENING, SOFT_ENDED, ANSWERING, and CLOSED states. VAD supplies speech boundaries and Smart Turn timing; the tracker decides whether resumed speech reopens the current turn. The unanswered reopen cap uses streamed-audio time, so a push-to-talk pause with no audio does not advance it. Processing and output holds use wall-clock deadlines. Starting a newer turn drops older work that has not committed; accepted output can finish.

Each response belongs to the input supplied to generation. The server records that ownership on conversation items and accepted tool calls. A tool follow-up keeps its originating input's turn. If a user message follows the tool call, the follow-up answers that message's turn; if a newer turn closed without one, it moves to that turn, so a late tool result is still spoken. Client input without a speech-turn association stays untagged. A response cannot borrow the identity of speech still being recorded. These input records do not control turn state, reopening, or deadlines.

The server holds input_audio_buffer.speech_stopped and the final transcription while a turn can still reopen. Resumed speech keeps the same open item and live transcription deltas continue. Once the turn commits, the client receives one stop, an input-buffer commitment, the created user item, and one final transcript, so its user-turn history matches the model's. If transcription fails, the server sends the stop and failure after the reopen grace ends.

The base package includes the quantized CPU runtime and enables Smart Turn by default:

pip install speech-to-speech
speech-to-speech serve

The latest supported v3.2 CPU checkpoint downloads from the Hugging Face Hub on first use. Pass --smart_turn_model_path /path/to/model.onnx to use a local model, or --no_smart_turn to disable Smart Turn. Smart Turn is enabled by default for server sessions and the packaged local client.

Tune the completion cutoff with --smart_turn_threshold (default 0.5). A higher threshold makes ambiguous pauses more likely to use the longer speculative response grace.

STT, LLM, and TTS Parameters

model_name, torch_dtype, and device are exposed for each STT, LLM, and TTS implementation. STT and TTS parameters use the handler prefix, for example --stt_model_name or --qwen3_tts_device. LLM model selection and chat settings are shared across backends via unprefixed flags, for example --model_name and --chat_size; backend-specific flags use the responses_api_ prefix for the responses-api and chat-completions backends and the llm_ prefix for local backends.

For example:

# Local transformers/mlx-lm backend
--model_name google/gemma-2b-it

# OpenAI-compatible backend
--llm_backend responses-api --model_name deepseek-chat --responses_api_base_url h

(README truncated)

View on GitHub

Recent activity

commits and pull requests

Releases and announcements

6 total
  1. v1.1.0v1.1.0Oct 24, 2026

    # speech-to-speech v1.1.0 This release adds a native CPU text-to-speech backend, more speech, diarization and voice-activity backends, per-session language selection, turn-latency reporting, and YAML configuration. These notes cover changes since v1.0.0. ## Highlights - **Phonon: local streaming speech on CPU.** Gradium's Phonon runs through the Rust-backed `ptts` runtime, with no PyTorch, and streams 16 kHz audio with interruption support: ```bash pip install "speech-to-speech[phonon]" speech-to-speech local --tts phonon ``` The default checkpoint, `gradium/phonon-40m-en`, is gated: accept its terms on Hugging Face, then run `hf auth login` or set `HF_TOKEN`. Its weights are CC BY-NC 4.0 (non-commercial); the Apache-2.0 `gradium/phonon-31m-en` is available with `--phonon_tts_model_name`. Voices come from the checkpoint and the Phonon voice catalog. In `local`, the arrow keys switch voices between replies. - **More speech backends.** New STT backends: Parakeet Unified, Nemotron streaming (including Persian), SenseVoice, and Orukeet. New TTS backends: KittenTTS on CPU, MiniMax, and streaming Drama-3. Pocket TTS supports its Farsi v2 weights, and Omni

  2. v1.0.0v1.0.0Sep 6, 2026

    # speech-to-speech v1.0.0 The first major release brings a single Realtime engine, explicit server and microphone-client commands, more speech backends, and improved conversation lifecycle handling. These notes cover changes since v0.2.12. ## Highlights - **Three commands: `serve`, `talk`, and `local`.** Run the Realtime server, connect the packaged microphone/speaker client, or start both in one terminal. The client also supports local tool execution with `--tool-module`. - **More speech backends.** Add Qwen3-ASR speech recognition, OpenAI-compatible STT and TTS endpoints, stateful OpenAI Realtime transcription, experimental vLLM Realtime transcription, and optional OmniVoice and Supertonic TTS. - **More reliable realtime conversations.** Improve ordered text, audio, and tool-call output; transcript and content-part events; interrupted responses; remote-request cancellation; and session cleanup. The browser demo uses the OpenAI Agents SDK, with integration tests for its WebSocket and WebRTC transports against the implemented core Realtime event set. - **Updated Apple Silicon setup.** Refresh the MLX dependencies and default to the 4-bit `mlx-community/Qwen3-4B

  3. v0.2.12v0.2.12Aug 5, 2026

    `speech-to-speech` 0.2.12 is the final planned release in the 0.2.x line before the next round of larger changes. It brings smarter turn-taking, WebRTC support, direct audio input for audio-capable LLMs, more complete OpenAI Realtime protocol behavior, and a significantly improved browser demo. ### Highlights - **Smarter endpointing with Smart Turn v3.2.** Realtime mode now enables the quantized CPU Smart Turn model by default to distinguish completed turns from mid-thought pauses while speculative STT and LLM work continues. Use `--no_smart_turn` to retain Silero-only endpointing. ([#192](https://github.com/huggingface/speech-to-speech/pull/192)) - **WebRTC transport for the OpenAI Realtime API.** Install the new `webrtc` extra to use SDP negotiation at `POST /v1/realtime/calls`, RTP audio, and the `oai-events` data channel alongside the existing WebSocket transport. Both transports share the same pipeline pool, event dispatch, cancellation, and interruption behavior. ([#352](https://github.com/huggingface/speech-to-speech/pull/352)) - **Direct audio input for audio-capable LLMs.** Run with `--stt none`, the Chat Completions backend, and an explicitly selected a

  4. v0.2.11v0.2.11Aug 3, 2026

    ## What's Changed * Bump the actions group with 2 updates by @dependabot[bot] in https://github.com/huggingface/speech-to-speech/pull/316 * Support text-only and out-of-band (conversation=none) responses by @A-Mahla in https://github.com/huggingface/speech-to-speech/pull/318 * Emit assistant transcript for fresh response when discard guard is stuck by @A-Mahla in https://github.com/huggingface/speech-to-speech/pull/321 * Add chat-completions LLM backend (OpenAI /v1/chat/completions) by @A-Mahla in https://github.com/huggingface/speech-to-speech/pull/322 * Default Qwen3 TTS to GGML by @andimarafioti in https://github.com/huggingface/speech-to-speech/pull/325 * Fix two mid-generation conversation races (tool call & image) by @A-Mahla in https://github.com/huggingface/speech-to-speech/pull/326 * Defer client conversation items during an active response by @A-Mahla in https://github.com/huggingface/speech-to-speech/pull/327 * Update HF router Gemma chat completions example by @andimarafioti in https://github.com/huggingface/speech-to-speech/pull/328 * Refresh README docs by @andimarafioti in https://github.com/huggingface/speech-to-speech/pull/330 * chore: remove deprecated melo option

  5. v0.2.10v0.2.10Jun 11, 2026

    ## What's Changed * Add --num_pipelines pool for concurrent realtime sessions by @A-Mahla in https://github.com/huggingface/speech-to-speech/pull/282 * Add speculative turn revisions by @andimarafioti in https://github.com/huggingface/speech-to-speech/pull/255 * Bump the actions group with 5 updates by @dependabot[bot] in https://github.com/huggingface/speech-to-speech/pull/293 * Normalize Qwen3-TTS language aliases by @kamjin3086 in https://github.com/huggingface/speech-to-speech/pull/300 * [codex] Fix TTS benchmark input message by @andimarafioti in https://github.com/huggingface/speech-to-speech/pull/303 * Bump the actions group with 2 updates by @dependabot[bot] in https://github.com/huggingface/speech-to-speech/pull/301 * Fix Paraformer progressive transcription events by @kamjin3086 in https://github.com/huggingface/speech-to-speech/pull/299 * Improve speculative VAD reopen and continuation handling by @andimarafioti in https://github.com/huggingface/speech-to-speech/pull/307 * Fix tool-only realtime response completion by @andimarafioti in https://github.com/huggingface/speech-to-speech/pull/306 * Shorten voice prompt and improve tool lead-ins by @andimarafioti in https://gi

Code frequency

additions and deletions
+22.8K-22.8KWeek of 2025-11-23: +0 linesWeek of 2025-11-23: -0 linesWeek of 2025-11-30: +0 linesWeek of 2025-11-30: -0 linesWeek of 2025-12-07: +0 linesWeek of 2025-12-07: -0 linesWeek of 2025-12-14: +0 linesWeek of 2025-12-14: -0 linesWeek of 2025-12-21: +0 linesWeek of 2025-12-21: -0 linesWeek of 2025-12-28: +0 linesWeek of 2025-12-28: -0 linesWeek of 2026-01-04: +0 linesWeek of 2026-01-04: -0 linesWeek of 2026-01-11: +0 linesWeek of 2026-01-11: -0 linesWeek of 2026-01-18: +0 linesWeek of 2026-01-18: -0 linesWeek of 2026-01-25: +0 linesWeek of 2026-01-25: -0 linesWeek of 2026-02-01: +2,646 linesWeek of 2026-02-01: -442 linesWeek of 2026-02-08: +1,154 linesWeek of 2026-02-08: -65 linesWeek of 2026-02-15: +1,389 linesWeek of 2026-02-15: -188 linesWeek of 2026-02-22: +1,001 linesWeek of 2026-02-22: -846 linesWeek of 2026-03-01: +691 linesWeek of 2026-03-01: -1,032 linesWeek of 2026-03-08: +596 linesWeek of 2026-03-08: -566 linesWeek of 2026-03-15: +382 linesWeek of 2026-03-15: -48 linesWeek of 2026-03-22: +194 linesWeek of 2026-03-22: -55 linesWeek of 2026-03-29: +0 linesWeek of 2026-03-29: -0 linesWeek of 2026-04-05: +8,035 linesWeek of 2026-04-05: -978 linesWeek of 2026-04-12: +2,380 linesWeek of 2026-04-12: -1,202 linesWeek of 2026-04-19: +14,391 linesWeek of 2026-04-19: -12,898 linesWeek of 2026-04-26: +2,872 linesWeek of 2026-04-26: -627 linesWeek of 2026-05-03: +5,545 linesWeek of 2026-05-03: -2,026 linesWeek of 2026-05-10: +0 linesWeek of 2026-05-10: -0 linesWeek of 2026-05-17: +1,074 linesWeek of 2026-05-17: -157 linesWeek of 2026-05-24: +2,669 linesWeek of 2026-05-24: -643 linesWeek of 2026-05-31: +793 linesWeek of 2026-05-31: -55 linesWeek of 2026-06-07: +1,885 linesWeek of 2026-06-07: -760 linesWeek of 2026-06-14: +1,093 linesWeek of 2026-06-14: -155 linesWeek of 2026-06-21: +1,635 linesWeek of 2026-06-21: -510 linesWeek of 2026-06-28: +1,079 linesWeek of 2026-06-28: -653 linesWeek of 2026-07-05: +8,275 linesWeek of 2026-07-05: -13 linesWeek of 2026-07-12: +1,865 linesWeek of 2026-07-12: -744 linesWeek of 2026-07-19: +2,634 linesWeek of 2026-07-19: -201 linesWeek of 2026-07-26: +6,096 linesWeek of 2026-07-26: -985 linesWeek of 2026-08-02: +11,057 linesWeek of 2026-08-02: -7,551 linesWeek of 2026-08-09: +20,001 linesWeek of 2026-08-09: -9,867 linesWeek of 2026-08-16: +8,108 linesWeek of 2026-08-16: -1,563 linesWeek of 2026-08-23: +5,452 linesWeek of 2026-08-23: -1,099 linesWeek of 2026-08-30: +6,822 linesWeek of 2026-08-30: -2,320 linesWeek of 2026-09-06: +1,338 linesWeek of 2026-09-06: -693 linesWeek of 2026-09-13: +952 linesWeek of 2026-09-13: -122 linesWeek of 2026-09-20: +12,513 linesWeek of 2026-09-20: -1,303 linesWeek of 2026-09-27: +6,861 linesWeek of 2026-09-27: -2,123 linesWeek of 2026-10-04: +22,848 linesWeek of 2026-10-04: -12,044 linesWeek of 2026-10-11: +6,505 linesWeek of 2026-10-11: -1,646 linesWeek of 2026-10-18: +5,520 linesWeek of 2026-10-18: -1,618 linesWeek of 2026-10-25: +2,093 linesWeek of 2026-10-25: -1,045 linesWeek of 2026-11-01: +11,060 linesWeek of 2026-11-01: -4,102 linesWeek of 2026-11-08: +2,937 linesWeek of 2026-11-08: -798 linesWeek of 2026-11-15: +0 linesWeek of 2026-11-15: -0 linesNov 23, 2025Nov 15, 2026
+194.4K lines added, -73.7K removed over the last year.

Commits per week

last 52 weeks
970Week of 2025-11-23: 0 commitsWeek of 2025-11-30: 0 commitsWeek of 2025-12-07: 0 commitsWeek of 2025-12-14: 0 commitsWeek of 2025-12-21: 0 commitsWeek of 2025-12-28: 0 commitsWeek of 2026-01-04: 0 commitsWeek of 2026-01-11: 0 commitsWeek of 2026-01-18: 0 commitsWeek of 2026-01-25: 0 commitsWeek of 2026-02-01: 6 commitsWeek of 2026-02-08: 10 commitsWeek of 2026-02-15: 21 commitsWeek of 2026-02-22: 35 commitsWeek of 2026-03-01: 22 commitsWeek of 2026-03-08: 25 commitsWeek of 2026-03-15: 4 commitsWeek of 2026-03-22: 4 commitsWeek of 2026-03-29: 0 commitsWeek of 2026-04-05: 6 commitsWeek of 2026-04-12: 20 commitsWeek of 2026-04-19: 9 commitsWeek of 2026-04-26: 16 commitsWeek of 2026-05-03: 52 commitsWeek of 2026-05-10: 0 commitsWeek of 2026-05-17: 1 commitsWeek of 2026-05-24: 22 commitsWeek of 2026-05-31: 5 commitsWeek of 2026-06-07: 20 commitsWeek of 2026-06-14: 1 commitsWeek of 2026-06-21: 3 commitsWeek of 2026-06-28: 14 commitsWeek of 2026-07-05: 3 commitsWeek of 2026-07-12: 22 commitsWeek of 2026-07-19: 1 commitsWeek of 2026-07-26: 34 commitsWeek of 2026-08-02: 92 commitsWeek of 2026-08-09: 86 commitsWeek of 2026-08-16: 49 commitsWeek of 2026-08-23: 27 commitsWeek of 2026-08-30: 33 commitsWeek of 2026-09-06: 19 commitsWeek of 2026-09-13: 9 commitsWeek of 2026-09-20: 74 commitsWeek of 2026-09-27: 68 commitsWeek of 2026-10-04: 97 commitsWeek of 2026-10-11: 47 commitsWeek of 2026-10-18: 48 commitsWeek of 2026-10-25: 29 commitsWeek of 2026-11-01: 58 commitsWeek of 2026-11-08: 17 commitsWeek of 2026-11-15: 0 commitsNov 23, 2025Nov 15, 2026
1.1K commits in the last 52 weeks.

When work happens

weekday and hour
SunMonTueWedThuFriSat036912151821Sun 0:00 — 10 commitsSun 1:00 — 0 commitsSun 2:00 — 2 commitsSun 3:00 — 1 commitsSun 4:00 — 1 commitsSun 5:00 — 1 commitsSun 6:00 — 0 commitsSun 7:00 — 0 commitsSun 8:00 — 2 commitsSun 9:00 — 1 commitsSun 10:00 — 3 commitsSun 11:00 — 7 commitsSun 12:00 — 5 commitsSun 13:00 — 3 commitsSun 14:00 — 1 commitsSun 15:00 — 1 commitsSun 16:00 — 1 commitsSun 17:00 — 2 commitsSun 18:00 — 3 commitsSun 19:00 — 7 commitsSun 20:00 — 5 commitsSun 21:00 — 5 commitsSun 22:00 — 0 commitsSun 23:00 — 1 commitsMon 0:00 — 8 commitsMon 1:00 — 2 commitsMon 2:00 — 0 commitsMon 3:00 — 1 commitsMon 4:00 — 0 commitsMon 5:00 — 0 commitsMon 6:00 — 4 commitsMon 7:00 — 3 commitsMon 8:00 — 1 commitsMon 9:00 — 2 commitsMon 10:00 — 10 commitsMon 11:00 — 16 commitsMon 12:00 — 25 commitsMon 13:00 — 10 commitsMon 14:00 — 21 commitsMon 15:00 — 26 commitsMon 16:00 — 12 commitsMon 17:00 — 16 commitsMon 18:00 — 4 commitsMon 19:00 — 4 commitsMon 20:00 — 2 commitsMon 21:00 — 10 commitsMon 22:00 — 13 commitsMon 23:00 — 12 commitsTue 0:00 — 3 commitsTue 1:00 — 0 commitsTue 2:00 — 2 commitsTue 3:00 — 1 commitsTue 4:00 — 3 commitsTue 5:00 — 1 commitsTue 6:00 — 0 commitsTue 7:00 — 4 commitsTue 8:00 — 7 commitsTue 9:00 — 10 commitsTue 10:00 — 12 commitsTue 11:00 — 35 commitsTue 12:00 — 23 commitsTue 13:00 — 16 commitsTue 14:00 — 29 commitsTue 15:00 — 28 commitsTue 16:00 — 25 commitsTue 17:00 — 28 commitsTue 18:00 — 9 commitsTue 19:00 — 14 commitsTue 20:00 — 8 commitsTue 21:00 — 9 commitsTue 22:00 — 17 commitsTue 23:00 — 7 commitsWed 0:00 — 1 commitsWed 1:00 — 5 commitsWed 2:00 — 1 commitsWed 3:00 — 2 commitsWed 4:00 — 0 commitsWed 5:00 — 0 commitsWed 6:00 — 0 commitsWed 7:00 — 1 commitsWed 8:00 — 3 commitsWed 9:00 — 6 commitsWed 10:00 — 8 commitsWed 11:00 — 16 commitsWed 12:00 — 6 commitsWed 13:00 — 11 commitsWed 14:00 — 26 commitsWed 15:00 — 30 commitsWed 16:00 — 21 commitsWed 17:00 — 16 commitsWed 18:00 — 8 commitsWed 19:00 — 3 commitsWed 20:00 — 8 commitsWed 21:00 — 13 commitsWed 22:00 — 4 commitsWed 23:00 — 7 commitsThu 0:00 — 5 commitsThu 1:00 — 0 commitsThu 2:00 — 2 commitsThu 3:00 — 1 commitsThu 4:00 — 0 commitsThu 5:00 — 0 commitsThu 6:00 — 2 commitsThu 7:00 — 3 commitsThu 8:00 — 2 commitsThu 9:00 — 8 commitsThu 10:00 — 23 commitsThu 11:00 — 17 commitsThu 12:00 — 19 commitsThu 13:00 — 17 commitsThu 14:00 — 21 commitsThu 15:00 — 16 commitsThu 16:00 — 15 commitsThu 17:00 — 21 commitsThu 18:00 — 7 commitsThu 19:00 — 7 commitsThu 20:00 — 6 commitsThu 21:00 — 14 commitsThu 22:00 — 27 commitsThu 23:00 — 12 commitsFri 0:00 — 2 commitsFri 1:00 — 0 commitsFri 2:00 — 0 commitsFri 3:00 — 0 commitsFri 4:00 — 0 commitsFri 5:00 — 0 commitsFri 6:00 — 0 commitsFri 7:00 — 0 commitsFri 8:00 — 7 commitsFri 9:00 — 10 commitsFri 10:00 — 12 commitsFri 11:00 — 23 commitsFri 12:00 — 23 commitsFri 13:00 — 17 commitsFri 14:00 — 14 commitsFri 15:00 — 22 commitsFri 16:00 — 31 commitsFri 17:00 — 16 commitsFri 18:00 — 8 commitsFri 19:00 — 2 commitsFri 20:00 — 4 commitsFri 21:00 — 8 commitsFri 22:00 — 8 commitsFri 23:00 — 21 commitsSat 0:00 — 2 commitsSat 1:00 — 0 commitsSat 2:00 — 0 commitsSat 3:00 — 0 commitsSat 4:00 — 0 commitsSat 5:00 — 0 commitsSat 6:00 — 0 commitsSat 7:00 — 0 commitsSat 8:00 — 3 commitsSat 9:00 — 1 commitsSat 10:00 — 1 commitsSat 11:00 — 4 commitsSat 12:00 — 1 commitsSat 13:00 — 1 commitsSat 14:00 — 4 commitsSat 15:00 — 4 commitsSat 16:00 — 7 commitsSat 17:00 — 5 commitsSat 18:00 — 2 commitsSat 19:00 — 3 commitsSat 20:00 — 3 commitsSat 21:00 — 0 commitsSat 22:00 — 5 commitsSat 23:00 — 7 commits
Commit volume by weekday and hour (UTC). Larger dots mean more commits.
DateListRankStars gained
Aug 13, 2026monthly#13+6,181
Aug 12, 2026monthly#13+6,181
Aug 11, 2026monthly#14+6,179
Aug 10, 2026monthly#14+6,184
Aug 9, 2026monthly#15+6,143
Aug 8, 2026monthly#7+6,147
Aug 7, 2026monthly#6+6,090
Aug 6, 2026monthly#6+5,874
Aug 5, 2026monthly#7+5,734
Aug 4, 2026monthly#8+5,579
Aug 3, 2026daily#7+442
Aug 3, 2026monthly#10+5,497
Aug 2, 2026monthly#9+4,740
Aug 2, 2026daily#7+442
Aug 1, 2026daily#1+628