🤗 Hugging Face   |   🤖 ModelScope   |   📑 Blog   |   📑 Paper  
🖥️ Hugging Face Demo   |    🖥️ ModelScope Demo   |   💬 WeChat (微信)   |   🫨 Discord   |   📑 API

⚡ NEW: Production-Optimized Inference
This implementation includes 5 advanced GPU optimizations (Flash Attention 2, torch.compile, TF32, cuDNN benchmark, BFloat16) for up to 40% faster inference compared to baseline. Expected RTF: 0.65-0.70 on RTX 3090 (54% faster than real-time). See OPTIMIZATION_GUIDE.md for details.

This repository provides an OpenAI-compatible FastAPI server for Qwen3-TTS, enabling drop-in replacement for OpenAI's TTS API endpoints. Built on top of the powerful Qwen3-TTS model series developed by the Qwen team at Alibaba Cloud, it offers comprehensive support for voice clone, voice design, ultra-high-quality human-like speech generation, and natural language-based voice control.

• 🎯 OpenAI API Compatible - Drop-in replacement for POST /v1/audio/speech
• ⚡ Multiple Backends - Choose between official, optimized, or vLLM-Omni backend for optimal performance
• 🌐 Multi-language Support - 10+ languages (Chinese, English, Japanese, Korean, German, French, Russian, Portuguese, Spanish, Italian)
• 🎨 Multiple Voice Options - 9 premium voices with various gender, age, and dialect combinations
• 📊 Multiple Audio Formats - MP3, Opus, AAC, FLAC, WAV, PCM
• ⚡ GPU-Accelerated - Optimized for CUDA/GPU and CPU deployments
• 🔧 Text Sanitization - Advanced text preprocessing for URLs, emails, special characters
• 🐳 Docker Ready - Multi-stage Dockerfile with GPU and CPU variants
• 🖥️ Web Interface - Dark-themed interactive demo UI
• 🎙️ Voice Studio - Comprehensive UI for creating, managing, and exporting voice profiles
• 🔄 Real-Time Streaming - True token-by-token PCM streaming (optimized backend)
• 🗂️ Voice Library - Persistent saved-voice profiles via clone:ProfileName voice prefix
• 🏎️ torch.compile + CUDA Graphs - Optional compiled inference with warmup (optimized backend)
• 🔁 Voice Prompt Caching - Cached speaker embeddings for repeat voice-clone requests

This implementation supports multiple backend engines:

• Optimized Backend (TTS_BACKEND=optimized): Dynamic model switching, real-time PCM streaming, torch.compile/CUDA graphs, voice prompt caching, and voice library support. Reads model config from ~/qwen3-tts/config.yaml. Recommended for high-throughput production deployments and voice agents.
• Official Backend: Uses the official Qwen3-TTS Python implementation with GPU/CPU auto-detect. Recommended for most users.
• vLLM-Omni Backend: Uses vLLM-Omni for optimized inference. Requires Python 3.12 and a dedicated Docker image. See VLLM_BACKEND_STATUS.md for details.
• PyTorch CPU Backend: CPU-optimized PyTorch with threading tuning and optional IPEX support. Recommended for CPU-only systems. See CPU_BACKEND_GUIDE.md for details.
• OpenVINO Backend: Experimental Intel CPU/NPU acceleration. Requires manual model export. Use PyTorch CPU backend for reliable CPU inference.

*OpenVINO may only accelerate parts of the pipeline

Performance comparison with Flash Attention 2 optimization on NVIDIA RTX 3090 (24GB VRAM). RTF = Real-Time Factor (lower is better, <1.0 means faster than real-time).

Key Findings:

• ✅ Flash Attention 2 improves Official backend by 10%
• ⚠️ Flash Attention 2 degrades vLLM-Omni by 8% (optimization conflict)
• 🏆 Official + Flash Attn 2 is the fastest and most reliable configuration

• Model: Qwen3-TTS-12Hz-1.7B-CustomVoice
• GPU: NVIDIA GeForce RTX 3090 (24GB VRAM)
• Test Method: 1 cold run + 5 warm runs per prompt
• Docker Images: Built with Flash Attention 2

Production Recommendation: Use Official backend with Flash Attention 2 for best performance (RTF 0.87, ~15% faster than real-time).

See BENCHMARK_RESULTS.md for full details.

The official backend includes several production-ready optimizations for maximum inference speed:

Combined Effect: ~25-35% speedup over baseline (expected RTF: 0.65-0.70)

⚠️ Note: torch.compile() and cuDNN benchmarking require warmup. First 2-3 requests may be slower (~10-30s) while optimizations initialize.

📖 See OPTIMIZATION_GUIDE.md for detailed information about each optimization, how to enable/disable them, and troubleshooting tips.

from openai import OpenAI

# Point to your local Qwen3-TTS server
client = OpenAI(
    base_url="http://localhost:8880/v1",
    api_key="not-needed"  # API key not required for local server
)

# Generate speech
response = client.audio.speech.create(
    model="qwen3-tts",
    voice="Vivian",  # Or: Ryan, Serena, Dylan, Eric, Aiden, etc.
    input="Hello! This is Qwen3-TTS speaking with an OpenAI-compatible API.",
    response_format="mp3",  # Options: mp3, opus, aac, flac, wav, pcm
    speed=1.0  # 0.25 to 4.0
)

response.stream_to_file("output.mp3")

You can force a specific language by using language-suffixed model names. This overrides any language parameter passed from the client (useful for integration with open-webui):

# Force Spanish output regardless of language parameter
response = client.audio.speech.create(
    model="tts-1-es",  # Spanish
    voice="Vivian",
    input="Hola! Este es Qwen3-TTS."
)

# Force French output
response = client.audio.speech.create(
    model="tts-1-hd-fr",  # French (HD quality)
    voice="Vivian",
    input="Bonjour! Ceci est Qwen3-TTS."
)

Supported Language Codes:

• tts-1-en or tts-1-hd-en - English
• tts-1-zh or tts-1-hd-zh - Chinese
• tts-1-ja or tts-1-hd-ja - Japanese
• tts-1-ko or tts-1-hd-ko - Korean
• tts-1-de or tts-1-hd-de - German
• tts-1-fr or tts-1-hd-fr - French
• tts-1-es or tts-1-hd-es - Spanish
• tts-1-ru or tts-1-hd-ru - Russian
• tts-1-pt or tts-1-hd-pt - Portuguese
• tts-1-it or tts-1-hd-it - Italian

When using these language-specific models, any language parameter in the request will be ignored, ensuring consistent output in the specified language.

After starting the server, visit http://localhost:8880 for an interactive web demo:

The Voice Studio is a comprehensive Gradio-based UI that allows you to create, manage, and export reusable voice profiles. It supports three primary workflows:

• CustomVoice - Use preset voices with style instructions
• VoiceDesign - Create custom voices using natural language descriptions
• Base - Clone voices from audio samples (with or without transcripts)

Features:

• 🎙️ Create and save voice profiles locally
• 🎨 Preview generated audio before saving
• 📦 Export profiles as ZIP archives
• 🎮 Interactive playground for testing saved profiles
• 🔄 Manage your voice library (view, load, delete profiles)

Option 1: Integrated with API Server

Mount the Voice Studio directly in the API server by setting an environment variable:

export ENABLE_VOICE_STUDIO=true
python -m api.main

Then visit http://localhost:8880/voice-studio

Option 2: Standalone Mode

Run the Voice Studio as a separate service (on port 7860 by default):

# Run directly from repository (recommended for development)
python gradio_voice_studio.py

# With custom settings
python gradio_voice_studio.py --base-url http://localhost:8880 --library-dir ./my_voices --port 7860

# If installed via pip install (not editable -e mode)
qwen-tts-voice-studio

Development Note: When developing with pip install -e . (editable mode), the qwen-tts-voice-studio command may not work due to setuptools limitations with py-modules in editable installs. In this case, use python gradio_voice_studio.py directly. For production or end-user installs with pip install ., the command will work correctly.

The Voice Studio will automatically connect to your running Qwen3-TTS API server to generate audio. Make sure the API server is running before using the Voice Studio.

The optimized backend (TTS_BACKEND=optimized) delivers the best performance for GPU deployments:

• Real-time streaming — true token-by-token PCM chunks via stream_generate_custom_voice / stream_generate_voice_clone, not post-generation chunking.
• torch.compile + CUDA graphs — compiled decoder with captured CUDA graphs; configurable compile mode (max-autotune recommended for production).
• Voice prompt caching — the speaker embedding for each voice-library profile is built once and reused, saving ~0.7 s per repeated clone request.
• Dynamic model switching — automatically switches between CustomVoice and Base models within the same server process (no restart needed).
• GPU keepalive — optional periodic matmul (GPU_KEEPALIVE_INTERVAL=15) prevents AMD DPM idle downclocking that would otherwise spike TTFB.

1. Copy config.yaml to ~/qwen3-tts/config.yaml (or set TTS_CONFIG env var):

   cp config.yaml ~/qwen3-tts/config.yaml

2. Edit config.yaml to point to your local model paths:

   default_model: 0.6B-CustomVoice
   models:
     0.6B-CustomVoice:
       hf_id: /path/to/Qwen3-TTS-12Hz-0.6B-CustomVoice
       type: customvoice

3. Start the server:

   TTS_BACKEND=optimized python -m api.main

import httpx, sounddevice as sd, numpy as np

with httpx.stream("POST", "http://localhost:8880/v1/audio/speech",
                  json={"input": "Hello world!", "voice": "Vivian",
                        "model": "tts-1", "stream": True,
                        "response_format": "pcm"}) as r:
    audio = np.frombuffer(b"".join(r.iter_bytes()), dtype=np.float32)
    sd.play(audio, 24000)
    sd.wait()

Save voice profiles to disk and reuse them with the clone:ProfileName prefix. The server loads the reference audio once, caches the speaker embedding, and automatically switches to the Base model for cloning.

$VOICE_LIBRARY_DIR/profiles/
└── alice/
    ├── meta.json           # profile metadata
    └── reference.wav       # reference audio (5–20 s, clean speech)

{
    "name": "Alice",
    "profile_id": "alice",
    "ref_audio_filename": "reference.wav",
    "ref_text": "Optional transcript of the reference audio.",
    "x_vector_only_mode": false,
    "language": "English"
}

from openai import OpenAI

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

# Non-streaming
response = client.audio.speech.create(
    model="tts-1",
    voice="clone:Alice",
    input="This is Alice speaking.",
)
response.stream_to_file("alice.mp3")

# Real-time streaming (optimized backend)
with client.audio.speech.with_streaming_response.create(
    model="tts-1",
    voice="clone:Alice",
    input="This is Alice speaking with streaming.",
    extra_body={"stream": True, "response_format": "pcm"},
) as r:
    r.stream_to_file("alice.pcm")

Profiles also appear in the /v1/voices endpoint response with a clone: prefix.

See docs/voice-library.md for full documentation.

# Create a fresh conda environment
conda create -n qwen3-tts python=3.12 -y
conda activate qwen3-tts

# Install the package with API dependencies
pip install -e ".[api]"

# Optional: Install FlashAttention 2 for better performance
pip install -U flash-attn --no-build-isolation

# Start the API server
python -m api.main
# Or use the convenience script
./start_server.sh

The server will start on http://0.0.0.0:8880 by default.

Environment Variables:

• HOST - Server host (default: 0.0.0.0)
• PORT - Server port (default: 8880)
• WORKERS - Number of workers (default: 1)
• CORS_ORIGINS - CORS origins (default: *)
• TTS_BACKEND - Backend engine: optimized, official, vllm_omni, pytorch, openvino (default: official)
• TTS_MODEL_NAME - Override default model (optional; not used by the optimized backend)
• TTS_WARMUP_ON_START - Warm up backend on startup with 3 staged requests: true or false (default: false)
• TTS_MAX_CONCURRENT - Max concurrent synthesis requests handled per API process (default: 1)
• TTS_CONFIG - Path to the YAML config file (default: ~/qwen3-tts/config.yaml, optimized backend only)
• ENABLE_VOICE_STUDIO - Mount Voice Studio at /voice-studio: true or false (default: false)
• VOICE_LIBRARY_DIR - Directory for voice library profiles (default: ./voice_library)
• GPU_KEEPALIVE_INTERVAL - Seconds between keepalive GPU matmuls; prevents AMD idle downclocking (default: 0 = disabled; recommended: 15 for AMD ROCm)

Backend Selection:

# Use official backend (default)
export TTS_BACKEND=official
python -m api.main

# Use vLLM-Omni backend for faster inference
export TTS_BACKEND=vllm_omni
export TTS_WARMUP_ON_START=true
pip install -e ".[vllm]"  # Install vLLM first
python -m api.main

For detailed vLLM-Omni setup and configuration, see docs/vllm-backend.md.

Official Backend (Default):

# Build and run with GPU support
docker build -t qwen3-tts-api .
docker run --gpus all -p 8880:8880 qwen3-tts-api

# Or use Docker Compose for easier management
docker-compose up qwen3-tts-gpu

vLLM-Omni Backend (Faster):

# Build vLLM-enabled image
docker build -t qwen3-tts-api:vllm --target vllm-production .
docker run --gpus all -p 8880:8880 \
  -e TTS_BACKEND=vllm_omni \
  -e TTS_WARMUP_ON_START=true \
  qwen3-tts-api:vllm

# Or use Docker Compose
docker-compose --profile vllm up qwen3-tts-vllm

# Build CPU-only variant
docker build -t qwen3-tts-api-cpu --target cpu-base .
docker run -p 8880:8880 qwen3-tts-api-cpu

# Or use Docker Compose
docker-compose --profile cpu up qwen3-tts-cpu

The docker-compose.yml includes GPU and CPU configurations with both backends:

# Official backend with GPU (default)
docker-compose up qwen3-tts-gpu

# vLLM-Omni backend with GPU (faster)
docker-compose --profile vllm up qwen3-tts-vllm

# CPU-only (uses profile)
docker-compose --profile cpu up qwen3-tts-cpu

# Run in background
docker-compose up -d qwen3-tts-gpu

# View logs
docker-compose logs -f qwen3-tts-gpu

# Stop services
docker-compose down

Model Cache: Models are cached in ~/.cache/huggingface and automatically mounted as a volume for persistence.

For systems without a GPU (e.g., Intel i5-1240P), use the optimized CPU backend:

# Set environment variables
export TTS_BACKEND=pytorch
export TTS_MODEL_ID=Qwen/Qwen3-TTS-12Hz-0.6B-Base  # Smaller model for CPU
export TTS_DEVICE=cpu
export TTS_DTYPE=float32
export TTS_ATTN=sdpa
export CPU_THREADS=12          # Adjust for your CPU cores
export CPU_INTEROP=2

# Optional: Enable Intel Extension for PyTorch (Intel CPUs only)
export USE_IPEX=true

# Start the server
python -m api.main

# Build and run CPU-optimized container
docker build -t qwen3-tts-api-cpu --target cpu-base .
docker run -p 8880:8880 \
  -e TTS_BACKEND=pytorch \
  -e TTS_MODEL_ID=Qwen/Qwen3-TTS-12Hz-0.6B-Base \
  -e CPU_THREADS=12 \
  qwen3-tts-api-cpu

• Model: Qwen3-TTS-12Hz-0.6B-Base
• RTF: ~2.5-3.0 (PyTorch CPU) or ~2.0-2.5 (with IPEX)
• First request: ~30-45s (model loading)
• Subsequent requests: ~2-3s per request

📖 See CPU_BACKEND_GUIDE.md for complete CPU deployment guide, performance tuning, and troubleshooting.

• POST /v1/audio/speech - Generate speech (OpenAI-compatible)
• GET /v1/models - List available models
• GET /v1/voices - List available voices
• GET /health - Health check with backend status
• GET /docs - Swagger UI documentation
• GET /redoc - ReDoc documentation
• GET /health - Health check endpoint
• GET / - Web interface

• POST /v1/audio/speech supports stream=true and returns a chunked StreamingResponse.
• Audio encoding is offloaded to worker threads to keep the FastAPI event loop responsive.
• Concurrency is bounded by TTS_MAX_CONCURRENT to stabilize p95 tail latency under load.

This project builds upon the incredible work of the Qwen Team at Alibaba Cloud. We are deeply grateful for their development and open-sourcing of Qwen3-TTS, a state-of-the-art text-to-speech model that enables:

• Powerful Speech Representation via Qwen3-TTS-Tokenizer-12Hz
• Universal End-to-End Architecture with discrete multi-codebook LM
• Extreme Low-Latency Streaming (as low as 97ms)
• Intelligent Voice Control through natural language instructions

For more details about the underlying Qwen3-TTS models, please refer to:

• 📑 Qwen3-TTS Technical Blog
• 📄 Research Paper
• 💻 Original Repository

• 2026.1.22: 🎉🎉🎉 We have released Qwen3-TTS series (0.6B/1.7B) based on Qwen3-TTS-Tokenizer-12Hz. Please check our blog!

• ✨ Features
• 🚀 Quick Start (API Server)
  • Using OpenAI Python Client
  • Web Interface
  • Voice Studio
• 📦 Deployment
  • Option 1: Using Conda (Recommended for Development)
  • Option 2: Using Docker (GPU-Enabled)
  • Option 3: Using Docker (CPU-Only)
  • Docker Compose Configuration
• 🎯 API Endpoints
• 🙏 Acknowledgments
• Overview
  • Introduction
  • Model Architecture
  • Released Models Description and Download
• Quickstart (Python Package)
  • Environment Setup
  • Python Package Usage
    • Custom Voice Generation
    • Voice Design
    • Voice Clone
    • Voice Design then Clone
    • Tokenizer Encode and Decode
  • Launch Local Web UI Demo
  • DashScope API Usage
• vLLM Usage
• Fine Tuning
• Evaluation
• Citation

Qwen3-TTS covers 10 major languages (Chinese, English, Japanese, Korean, German, French, Russian, Portuguese, Spanish, and Italian) as well as multiple dialectal voice profiles to meet global application needs. In addition, the models feature strong contextual understanding, enabling adaptive control of tone, speaking rate, and emotional expression based on instructions and text semantics, and they show markedly improved robustness to noisy input text. Key features:

• Powerful Speech Representation: Powered by the self-developed Qwen3-TTS-Tokenizer-12Hz, it achieves efficient acoustic compression and high-dimensional semantic modeling of speech signals. It fully preserves paralinguistic information and acoustic environmental features, enabling high-speed, high-fidelity speech reconstruction through a lightweight non-DiT architecture.
• Universal End-to-End Architecture: Utilizing a discrete multi-codebook LM architecture, it realizes full-information end-to-end speech modeling. This completely bypasses the information bottlenecks and cascading errors inherent in traditional LM+DiT schemes, significantly enhancing the model’s versatility, generation efficiency, and performance ceiling.
• Extreme Low-Latency Streaming Generation: Based on the innovative Dual-Track hybrid streaming generation architecture, a single model supports both streaming and non-streaming generation. It can output the first audio packet immediately after a single character is input, with end-to-end synthesis latency as low as 97ms, meeting the rigorous demands of real-time interactive scenarios.
• Intelligent Text Understanding and Voice Control: Supports speech generation driven by natural language instructions, allowing for flexible control over multi-dimensional acoustic attributes such as timbre, emotion, and prosody. By deeply integrating text semantic understanding, the model adaptively adjusts tone, rhythm, and emotional expression, achieving lifelike “what you imagine is what you hear” output.

Below is an introduction and download information for the Qwen3-TTS models that have already been released. Other models mentioned in the technical report will be released in the near future. Please select and download the model that fits your needs.

During model loading in the qwen-tts package or vLLM, model weights will be automatically downloaded based on the model name. However, if your runtime environment is not conducive to downloading weights during execution, you can refer to the following commands to manually download the model weights to a local directory:

# Download through ModelScope (recommended for users in Mainland China)
pip install -U modelscope
modelscope download --model Qwen/Qwen3-TTS-Tokenizer-12Hz  --local_dir ./Qwen3-TTS-Tokenizer-12Hz 
modelscope download --model Qwen/Qwen3-TTS-12Hz-1.7B-CustomVoice --local_dir ./Qwen3-TTS-12Hz-1.7B-CustomVoice
modelscope download --model Qwen/Qwen3-TTS-12Hz-1.7B-VoiceDesign --local_dir ./Qwen3-TTS-12Hz-1.7B-VoiceDesign
modelscope download --model Qwen/Qwen3-TTS-12Hz-1.7B-Base --local_dir ./Qwen3-TTS-12Hz-1.7B-Base
modelscope download --model Qwen/Qwen3-TTS-12Hz-0.6B-CustomVoice --local_dir ./Qwen3-TTS-12Hz-0.6B-CustomVoice
modelscope download --model Qwen/Qwen3-TTS-12Hz-0.6B-Base --local_dir ./Qwen3-TTS-12Hz-0.6B-Base

# Download through Hugging Face
pip install -U "huggingface_hub[cli]"
huggingface-cli download Qwen/Qwen3-TTS-Tokenizer-12Hz --local-dir ./Qwen3-TTS-Tokenizer-12Hz
huggingface-cli download Qwen/Qwen3-TTS-12Hz-1.7B-CustomVoice --local-dir ./Qwen3-TTS-12Hz-1.7B-CustomVoice
huggingface-cli download Qwen/Qwen3-TTS-12Hz-1.7B-VoiceDesign --local-dir ./Qwen3-TTS-12Hz-1.7B-VoiceDesign
huggingface-cli download Qwen/Qwen3-TTS-12Hz-1.7B-Base --local-dir ./Qwen3-TTS-12Hz-1.7B-Base
huggingface-cli download Qwen/Qwen3-TTS-12Hz-0.6B-CustomVoice --local-dir ./Qwen3-TTS-12Hz-0.6B-CustomVoice
huggingface-cli download Qwen/Qwen3-TTS-12Hz-0.6B-Base --local-dir ./Qwen3-TTS-12Hz-0.6B-Base

The easiest way to quickly use Qwen3-TTS is to install the qwen-tts Python package from PyPI. This will pull in the required runtime dependencies and allow you to load any released Qwen3-TTS model. We recommend using a fresh, isolated environment to avoid dependency conflicts with existing packages. You can create a clean Python 3.12 environment like this:

conda create -n qwen3-tts python=3.12 -y
conda activate qwen3-tts

then run:

pip install -U qwen-tts

If you want to develop or modify the code locally, install from source in editable mode.

git clone https://github.com/QwenLM/Qwen3-TTS.git
cd Qwen3-TTS
pip install -e .

Additionally, we recommend using FlashAttention 2 to reduce GPU memory usage.

pip install -U flash-attn --no-build-isolation

If your machine has less than 96GB of RAM and lots of CPU cores, run:

MAX_JOBS=4 pip install -U flash-attn --no-build-isolation

Also, you should have hardware that is compatible with FlashAttention 2. Read more about it in the official documentation of the FlashAttention repository. FlashAttention 2 can only be used when a model is loaded in torch.float16 or torch.bfloat16.

After installation, you can import Qwen3TTSModel to run custom voice TTS, voice design, and voice clone. The model weights can be specified either as a Hugging Face model id (recommended) or as a local directory path you downloaded. For all the generate_* functions below, besides the parameters shown and explicitly documented, you can also pass generation kwargs supported by Hugging Face Transformers model.generate, e.g., max_new_tokens, top_p, etc.

For custom voice models (Qwen3-TTS-12Hz-1.7B/0.6B-CustomVoice), you just need to call generate_custom_voice, passing a single string or a batch list, along with language, speaker, and optional instruct. You can also call model.get_supported_speakers() and model.get_supported_languages() to see which speakers and languages the current model supports.

import torch
import soundfile as sf
from qwen_tts import Qwen3TTSModel

model = Qwen3TTSModel.from_pretrained(
    "Qwen/Qwen3-TTS-12Hz-1.7B-CustomVoice",
    device_map="cuda:0",
    dtype=torch.bfloat16,
    attn_implementation="flash_attention_2",
)

# single inference
wavs, sr = model.generate_custom_voice(
    text="其实我真的有发现，我是一个特别善于观察别人情绪的人。",
    language="Chinese", # Pass `Auto` (or omit) for auto language adaptive; if the target language is known, set it explicitly.
    speaker="Vivian",
    instruct="用特别愤怒的语气说", # Omit if not needed.
)
sf.write("output_custom_voice.wav", wavs[0], sr)

# batch inference
wavs, sr = model.generate_custom_voice(
    text=[
        "其实我真的有发现，我是一个特别善于观察别人情绪的人。", 
        "She said she would be here by noon."
    ],
    language=["Chinese", "English"],
    speaker=["Vivian", "Ryan"],
    instruct=["", "Very happy."]
)
sf.write("output_custom_voice_1.wav", wavs[0], sr)
sf.write("output_custom_voice_2.wav", wavs[1], sr)

For Qwen3-TTS-12Hz-1.7B/0.6B-CustomVoice models, the supported speaker list and speaker descriptions are provided below. We recommend using each speaker’s native language for the best quality. Of course, each speaker can speak any language supported by the model.

For the voice design model (Qwen3-TTS-12Hz-1.7B-VoiceDesign), you can use generate_voice_design to provide the target text and a natural-language instruct description.

import torch
import soundfile as sf
from qwen_tts import Qwen3TTSModel

model = Qwen3TTSModel.from_pretrained(
    "Qwen/Qwen3-TTS-12Hz-1.7B-VoiceDesign",
    device_map="cuda:0",
    dtype=torch.bfloat16,
    attn_implementation="flash_attention_2",
)

# single inference
wavs, sr = model.generate_voice_design(
    text="哥哥，你回来啦，人家等了你好久好久了，要抱抱！",
    language="Chinese",
    instruct="体现撒娇稚嫩的萝莉女声，音调偏高且起伏明显，营造出黏人、做作又刻意卖萌的听觉效果。",
)
sf.write("output_voice_design.wav", wavs[0], sr)

# batch inference
wavs, sr = model.generate_voice_design(
    text=[
      "哥哥，你回来啦，人家等了你好久好久了，要抱抱！",
      "It's in the top drawer... wait, it's empty? No way, that's impossible! I'm sure I put it there!"
    ],
    language=["Chinese", "English"],
    instruct=[
      "体现撒娇稚嫩的萝莉女声，音调偏高且起伏明显，营造出黏人、做作又刻意卖萌的听觉效果。",
      "Speak in an incredulous tone, but with a hint of panic beginning to creep into your voice."
    ]
)
sf.write("output_voice_design_1.wav", wavs[0], sr)
sf.write("output_voice_design_2.wav", wavs[1], sr)

For the voice clone model (Qwen3-TTS-12Hz-1.7B/0.6B-Base), to clone a voice and synthesize new content, you just need to provide a reference audio clip (ref_audio) along with its transcript (ref_text). ref_audio can be a local file path, a URL, a base64 string, or a (numpy_array, sample_rate) tuple. If you set x_vector_only_mode=True, only the speaker embedding is used so ref_text is not required, but cloning quality may be reduced.

import torch
import soundfile as sf
from qwen_tts import Qwen3TTSModel

model = Qwen3TTSModel.from_pretrained(
    "Qwen/Qwen3-TTS-12Hz-1.7B-Base",
    device_map="cuda:0",
    dtype=torch.bfloat16,
    attn_implementation="flash_attention_2",
)

ref_audio = "https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen3-TTS-Repo/clone.wav"
ref_text  = "Okay. Yeah. I resent you. I love you. I respect you. But you know what? You blew it! And thanks to you."

wavs, sr = model.generate_voice_clone(
    text="I am solving the equation: x = [-b ± √(b²-4ac)] / 2a? Nobody can — it's a disaster (◍•͈⌔•͈◍), very sad!",
    language="English",
    ref_audio=ref_audio,
    ref_text=ref_text,
)
sf.write("output_voice_clone.wav", wavs[0], sr)

If you need to reuse the same reference prompt across multiple generations (to avoid recomputing prompt features), build it once with create_voice_clone_prompt and pass it via voice_clone_prompt.

prompt_items = model.create_voice_clone_prompt(
    ref_audio=ref_audio,
    ref_text=ref_text,
    x_vector_only_mode=False,
)
wavs, sr = model.generate_voice_clone(
    text=["Sentence A.", "Sentence B."],
    language=["English", "English"],
    voice_clone_prompt=prompt_items,
)
sf.write("output_voice_clone_1.wav", wavs[0], sr)
sf.write("output_voice_clone_2.wav", wavs[1], sr)

For more examples of reusable voice clone prompts, batch cloning, and batch inference, please refer to the example codes. With those examples and the generate_voice_clone function description, you can explore more advanced usage patterns.

If you want a designed voice that you can reuse like a cloned speaker, a practical workflow is: (1) use the VoiceDesign model to synthesize a short reference clip that matches your target persona, (2) feed that clip into create_voice_clone_prompt to build a reusable prompt, and then (3) call generate_voice_clone with voice_clone_prompt to generate new content without re-extracting features every time. This is especially useful when you want a consistent character voice across many lines.

import torch
import soundfile as sf
from qwen_tts import Qwen3TTSModel

# create a reference audio in the target style using the VoiceDesign model
design_model = Qwen3TTSModel.from_pretrained(
    "Qwen/Qwen3-TTS-12Hz-1.7B-VoiceDesign",
    device_map="cuda:0",
    dtype=torch.bfloat16,
    attn_implementation="flash_attention_2",
)

ref_text = "H-hey! You dropped your... uh... calculus notebook? I mean, I think it's yours? Maybe?"
ref_instruct = "Male, 17 years old, tenor range, gaining confidence - deeper breath support now, though vowels still tighten when nervous"
ref_wavs, sr = design_model.generate_voice_design(
    text=ref_text,
    language="English",
    instruct=ref_instruct
)
sf.write("voice_design_reference.wav", ref_wavs[0], sr)

# build a reusable clone prompt from the voice design reference
clone_model = Qwen3TTSModel.from_pretrained(
    "Qwen/Qwen3-TTS-12Hz-1.7B-Base",
    device_map="cuda:0",
    dtype=torch.bfloat16,
    attn_implementation="flash_attention_2",
)

voice_clone_prompt = clone_model.create_voice_clone_prompt(
    ref_audio=(ref_wavs[0], sr),   # or "voice_design_reference.wav"
    ref_text=ref_text,
)

sentences = [
    "No problem! I actually... kinda finished those already? If you want to compare answers or something...",
    "What? No! I mean yes but not like... I just think you're... your titration technique is really precise!",
]

# reuse it for multiple single calls
wavs, sr = clone_model.generate_voice_clone(
    text=sentences[0],
    language="English",
    voice_clone_prompt=voice_clone_prompt,
)
sf.write("clone_single_1.wav", wavs[0], sr)

wavs, sr = clone_model.generate_voice_clone(
    text=sentences[1],
    language="English",
    voice_clone_prompt=voice_clone_prompt,
)
sf.write("clone_single_2.wav", wavs[0], sr)

# or batch generate in one call
wavs, sr = clone_model.generate_voice_clone(
    text=sentences,
    language=["English", "English"],
    voice_clone_prompt=voice_clone_prompt,
)
for i, w in enumerate(wavs):
    sf.write(f"clone_batch_{i}.wav", w, sr)

If you only want to encode and decode audio for transport or training and so on, Qwen3TTSTokenizer supports encode/decode with paths, URLs, numpy waveforms, and dict/list payloads, for example:

import soundfile as sf
from qwen_tts import Qwen3TTSTokenizer

tokenizer = Qwen3TTSTokenizer.from_pretrained(
    "Qwen/Qwen3-TTS-Tokenizer-12Hz",
    device_map="cuda:0",
)

enc = tokenizer.encode("https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen3-TTS-Repo/tokenizer_demo_1.wav")
wavs, sr = tokenizer.decode(enc)
sf.write("decode_output.wav", wavs[0], sr)

For more tokenizer examples (including different input formats and batch usage), please refer to the example codes. With those examples and the description for Qwen3TTSTokenizer, you can explore more advanced usage patterns.

To launch the Qwen3-TTS web ui demo, simply install the qwen-tts package and run qwen-tts-demo. Use the command below for help:

qwen-tts-demo --help

To launch the demo, you can use the following commands:

# CustomVoice model
qwen-tts-demo Qwen/Qwen3-TTS-12Hz-1.7B-CustomVoice --ip 0.0.0.0 --port 8000
# VoiceDesign model
qwen-tts-demo Qwen/Qwen3-TTS-12Hz-1.7B-VoiceDesign --ip 0.0.0.0 --port 8000
# Base model
qwen-tts-demo Qwen/Qwen3-TTS-12Hz-1.7B-Base --ip 0.0.0.0 --port 8000

And then open http://<your-ip>:8000, or access it via port forwarding in tools like VS Code.

To avoid browser microphone permission issues after deploying the server, for Base model deployments, it is recommended/required to run the gradio service over HTTPS (especially when accessed remotely or behind modern browsers/gateways). Use --ssl-certfile and --ssl-keyfile to enable HTTPS. First we need to generate a private key and a self-signed cert (valid for 365 days):

openssl req -x509 -newkey rsa:2048 \
  -keyout key.pem -out cert.pem \
  -days 365 -nodes \
  -subj "/CN=localhost"

Then run the demo with HTTPS:

qwen-tts-demo Qwen/Qwen3-TTS-12Hz-1.7B-Base \
  --ip 0.0.0.0 --port 8000 \
  --ssl-certfile cert.pem \
  --ssl-keyfile key.pem \
  --no-ssl-verify

And open https://<your-ip>:8000 to experience it. If your browser shows a warning, it’s expected for self-signed certificates. For production, use a real certificate.

To further explore Qwen3-TTS, we encourage you to try our DashScope API for a faster and more efficient experience. For detailed API information and documentation, please refer to the following:

vLLM officially provides day-0 support for Qwen3-TTS! Welcome to use vLLM-Omni for Qwen3-TTS deployment and inference. For installation and more details, please check vLLM-Omni official documentation. Now only offline inference is supported. Online serving will be supported later, and vLLM-Omni will continue to offer support and optimization for Qwen3-TTS in areas such as inference speed and streaming capabilities.

You can use vLLM-Omni to inference Qwen3-TTS locally, we provide examples in vLLM-Omni repo which can generate audio output:

# git clone https://github.com/vllm-project/vllm-omni.git

# cd vllm-omni/examples/offline_inference/qwen3_tts

# Run a single sample with CustomVoice task
python end2end.py --query-type CustomVoice

# Batch sample (multiple prompts in one run) with CustomVoice task:
python end2end.py --query-type CustomVoice --use-batch-sample

# Run a single sample with VoiceDesign task
python end2end.py --query-type VoiceDesign

# Batch sample (multiple prompts in one run) with VoiceDesign task:
python end2end.py --query-type VoiceDesign --use-batch-sample

# Run a single sample with Base task in icl mode-tag
python end2end.py --query-type Base --mode-tag icl

Please refer to Qwen3-TTS-Finetuning for detailed instructions on fine-tuning Qwen3-TTS.

During evaluation, we ran inference for all models with dtype=torch.bfloat16 and set max_new_tokens=2048. All other sampling parameters used the defaults from the checkpoint’s generate_config.json. For the Seed-Test and InstructTTS-Eval test sets, we set language="auto", while for all other test sets we explicitly passed the corresponding language. The detailed results are shown below.

If you find our paper and code useful in your research, please consider giving a star ⭐ and citation 📝 :)

@article{Qwen3-TTS,
  title={Qwen3-TTS Technical Report},
  author={Hangrui Hu and Xinfa Zhu and Ting He and Dake Guo and Bin Zhang and Xiong Wang and Zhifang Guo and Ziyue Jiang and Hongkun Hao and Zishan Guo and Xinyu Zhang and Pei Zhang and Baosong Yang and Jin Xu and Jingren Zhou and Junyang Lin},
  journal={arXiv preprint arXiv:2601.15621},
  year={2026}
}