Model reference · open weights

dots.tts-soar

Audio dots-studio Text→speech 1 build Open weights 3k dl/mo

dots.tts-soar is an open-weight audio or speech model from dots-studio. dots.tts-soar (BF16) weighs 5.1 GB; the smallest configuration that runs it is RTX 3060 12 GB.

For self-hosting, compare this build's requirements below with the GPU you plan to rent.

  • dots.tts-soar is a 2.2B parameter text-to-speech model developed by dots-studio for zero-shot voice cloning.
  • It uses an autoregressive architecture with a flow-matching acoustic head to generate 48 kHz audio without discrete codec tokens.
  • The model is released under the Apache-2.0 license.

Summary of the dots-studio/dots.tts-soar model card, 2026-10-01

What it is

Released bydots-studio
Released2026-06-04
Parameters2.2B
VRAM5.1 GB for the weights

What it runs on

Memory and cards for dots.tts-soar (BF16)

5.1 GBweights, file size
1.6 GBruntime overhead
CardOne streamMemory
RTX 3060 12 GBfits11.6 GB
RTX 4060 Ti 16 GBfits15.4 GB
RTX 3090 24 GBfits23.4 GB
RTX 4090 24 GBfits23.4 GB
RTX 5090 32 GBfits31.0 GB
L40S 48 GBfits44.0 GB
A100 80 GBfits78.2 GB
H100 80 GBfits78.1 GB
RTX PRO 6000 Blackwell 96 GBfits93.8 GB
DGX Spark (GB10) 128 GB unifiedfits107 GB
H200 141 GBfits138 GB
B200 180 GBfits176 GB

From the model card

What dots-studio says about dots.tts-soar

Read the model card

dots.tts is a 2B-parameter fully continuous, end-to-end autoregressive (AR) text-to-speech system. The backbone pairs a semantic encoder, an LLM, and an autoregressive flow-matching acoustic head over a 48 kHz AudioVAE — no discrete codec tokens anywhere in the pipeline.

This repository hosts dots.tts-soar — the pretrained backbone further refined with Self-corrective Alignment (SCA), a reward-free flow-matching-native post-training stage. SCA pushes the model to the highest zero-shot fidelity and speaker similarity of the three releases and is the recommended default for production zero-shot voice cloning.


Quick Start

Installation

conda create -n dots_tts python=3.10 -y
conda activate dots_tts

python -m pip install --upgrade pip
python -m pip install "git+https://github.com/studio-dots-ai/dots.tts.git" \
  -c "https://raw.githubusercontent.com/studio-dots-ai/dots.tts/main/constraints/recommended.txt"

CLI

# Continuation voice cloning (reference audio + transcript) — recommended
dots.tts \
  --model-name-or-path dots-studio/dots.tts-soar \
  --text "Hello, this is a zero-shot voice cloning demonstration." \
  --prompt-audio /path/to/reference.wav \
  --prompt-text "The exact transcript of the reference audio." \
  --output clone.wav

Python API

from dots_tts.runtime import DotsTtsRuntime
import soundfile as sf

runtime = DotsTtsRuntime.from_pretrained(
    "dots-studio/dots.tts-soar",
    precision="bfloat16",
)

result = runtime.generate(
    text="Hello, this is a quick speech synthesis test.",
    prompt_audio_path="/path/to/reference.wav",
    prompt_text="The exact transcript of the reference audio.",
    num_steps=10,
    guidance_scale=1.2,
)

sf.write("output.wav", result["audio"].float().cpu().squeeze().numpy(), result["sample_rate"])

Recommended sampling settings

FlagRecommendedNotes
--num-steps10–32Flow-matching sampling steps; higher = better quality, slower
--guidance-scale1.2 (default)Standard CFG; SCA already tightens text and timbre adherence so small CFG suffices

Fine-tuning

Both dots.tts-base and dots.tts-soar are valid fine-tuning starting points. Pick dots.tts-soar when you want to inherit its tightened text/timbre alignment on top of the pretrained backbone. See the training script and smoke config in the source repository:

accelerate launch scripts/train_dots_tts.py --config configs/dots_tts.yaml

Architecture

A frozen AudioVAE encodes 48 kHz mono waveform into a continuous latent and decodes it back via a BigVGAN-style causal decoder. An autoregressive backbone predicts that latent one patch at a time:

  • Semantic encoder — re-encodes each newly generated VAE patch into a compact embedding for the LLM, stripping high-variance acoustic detail.
  • LLM — initialized from Qwen2.5-1.5B-Base, consumes BPE text directly (no phonemes), emits one hidden state per audio step.
  • AR flow-matching head — a DiT that conditions on the LLM hidden state and the AR prefix to denoise the next VAE patch, with a frozen CAM++ speaker x-vector as side input.

Self-corrective Alignment is a reward-free, flow-matching-native post-training stage applied on top of dots.tts-base. It improves text and speaker adherence without changing inference cost or sampling schedule.


Performance — dots.tts-soar

Seed-TTS-Eval — state-of-the-art average SIM (79.2)

ModelParamstest-en WER↓ / SIM↑test-zh WER↓ / SIM↑test-zh-hard WER↓ / SIM↑Avg WER↓ / SIM↑
Seed-TTS—2.25 / 76.21.12 / 79.67.59 / 77.63.65 / 77.8
Qwen3-TTS1.7B1.23 / 71.71.22 / 77.06.76 / 74.83.07 / 74.5
VoxCPM 22B1.84 / 75.30.97 / 79.58.13 / 75.33.65 / 76.7
dots.tts-base2B1.34 / 76.80.96 / 80.56.46 / 79.22.92 / 78.8
dots.tts-soar2B1.30 / 77.10.94 / 81.06.60 / 79.52.95 / 79.2

MiniMax Multilingual — highest average SIM (83.9) across 24 languages

ModelAvg WER↓Avg SIM↑
MiniMax2.876.6
Fish-Audio S23.778.0
VoxCPM 25.782.3
dots.tts-base6.683.5
dots.tts-soar6.883.9

CV3-Eval — leads both cross-lingual SIM subsets

Modelen→zh SIM↑zh→en SIM↑
CosyVoice 3 (1.5B)66.966.4
dots.tts-base74.671.9
dots.tts-soar75.072.8

EmergentTTS-Eval — top Syntactic Complexity in the table (65.7%)

On head-to-head judging vs. gpt-4o-mini-tts, dots.tts-soar posts 65.7% on Syntactic Complexity — above every closed-source system listed, while keeping competitive Emotions / Questions scores.

See the project README for full benchmark tables.


Risks and Limitations

  • Misuse risk. High-fidelity zero-shot voice cloning can produce highly realistic synthetic speech. This checkpoint is intended for research and authorized deployment. Do not use it for impersonation, fraud, or disinformation. Combine downstream use with consent-aware reference-audio policies, robust synthetic-speech detection, and content watermarking. Clearly mark AI-generated audio.
  • Low-resource WER gap. A BPE backbone inherits the text LLM's language coverage at the cost of a higher data appetite. On script-divergent and under-represented languages (Arabic, Hindi, Turkish, Vietnamese) WER is higher than on high-resource languages; speaker similarity is preserved.
  • Speech-heavy training. The backbone is trained on a speech-heavy mixture. Singing and unified speech + so

Quoted from the model card on Hugging Face. The full card is behind the Hugging Face link above.

© 2026 AxForge · EU-hosted AI infrastructure Pricing Docs Trust Privacy Terms