Coqui TTS
XTTS v2 — Open-Source Voice Cloning & TTS
Updated: September 22, 2026 — status, licence and install commands re-verified against the fork README, PyPI, GitHub and the Hugging Face model card
In short: XTTS v2 is Coqui's open-weight voice-cloning text-to-speech model: it clones a voice from a ~6-second clip and speaks 17 languages, entirely on your own machine. Coqui the company shut down in January 2024, so the code now lives in the maintained fork idiap/coqui-ai-TTS (PyPI package coqui-tts, v0.27.5, January 2026, Python 3.10-3.14). Install PyTorch first, then pip install coqui-tts, and load tts_models/multilingual/multi-dataset/xtts_v2 (a ~2.1 GB download). The code is MPL-2.0, but the XTTS v2 weights are under the Coqui Public Model License, which allows only non-commercial use.
🔬 TECHNICAL SPECIFICATIONS
pip install coqui-tts (after PyTorch)Technical Overview & Architecture
Coqui TTS represents a significant advancement in open-source text-to-speech technology. Originally based on Mozilla's TTS project, it has evolved into a comprehensive voice synthesis platform that competes with commercial solutions while maintaining open-source accessibility and local deployment capabilities.
Technology Heritage
Originally developed from Mozilla's TTS project, Coqui TTS builds upon years of research from established organizations. When Mozilla discontinued the original project, the community continued development, enhancing the technology with modern architecturesand improved performance characteristics.
The XTTS v2 architecture enables voice cloning with minimal audio samples (as little as ~6 seconds, 15-30s recommended for best quality), supports 17 languages, and operates entirely on local hardware. This approach provides advantages in data privacy, cost efficiency, and deployment flexibility compared to cloud-based alternatives. Because everything runs offline, it pairs well with other local models — many builders run it on the same modest rig they use for a small LLM (see our guide to the best local AI models for 8GB RAM).
Development Timeline
pip install coqui-tts) — v0.27.3 Dec 2025 added PyTorch 2.9 support, v0.27.4 Jan 2026 added Python 3.14 and PyTorch 2.10, v0.27.5 (January 26, 2026) fixed XTTS with newer transformersComparative Analysis with Commercial Services
The honest comparison with hosted voice services is not about a quality score — nobody publishes a like-for-like one — it is about what you give up and what you keep. XTTS v2 costs nothing per character, never sends audio off your machine and has no quota; the hosted services sell a commercial licence, support and a polished UI. The table below sticks to what each side actually offers.
📊 Feature Comparison
📈 XTTS v2 wins on cost, privacy and limits; hosted services win on commercial licensing and support
XTTS v2 vs Kokoro vs F5-TTS vs Fish Speech vs Piper (2026)
ElevenLabs isn't the only thing XTTS v2 competes with anymore. By mid-2026 a wave of newer open-weight engines has changed the local TTS landscape. Here's how XTTS v2 stacks up against the models people most often pick instead — and when each one wins.
| Engine | Voice cloning | Languages | License (weights, verified Sept 2026) | Best for |
|---|---|---|---|---|
| Coqui XTTS v2 | Yes (~6s sample) | 17 | Coqui Public Model License (non-commercial) | Multilingual cloning for personal / research use |
| Chatterbox (Resemble AI) | Yes | See model card | MIT | Cloning you can ship commercially |
| Kokoro-82M | No (preset voices) | See model card | Apache 2.0 | Lightweight preset voices, commercial-OK |
| F5-TTS | Yes (flow-matching) | EN/ZH (+ community checkpoints) | CC-BY-NC-4.0 (non-commercial); code MIT | English / Chinese cloning, research use |
| Fish Speech / OpenAudio S1-mini | Yes | Multilingual | CC-BY-NC-SA-4.0 (S1-mini weights) | Multilingual cloning, non-commercial |
| Piper | No | Many | MIT (rhasspy/piper, archived Aug 2025); GPL-3.0 (piper1-gpl successor) | Raspberry Pi / low-power |
The short version: XTTS v2 still has the widest built-in language list for cloning (17 languages, cross-lingual transfer) but its weights are non-commercial; Chatterbox is the cloning model whose MIT licence lets you ship a product — see the Chatterbox TTS setup guide; Kokoro is the light, Apache-licensed choice when preset voices are enough — see the Kokoro TTS local setup guide; and F5-TTS is the closest English cloning rival, with the same non-commercial catch — our F5-TTS setup guide covers installing it. For the whole field ranked in one place, read best local TTS models, the three-way shootout in Kokoro vs XTTS vs Chatterbox, or the licence-first list of open-source ElevenLabs alternatives.
🔬 TTS Technology Research & Development
XTTS Architecture Innovation
Coqui TTS represents significant advancement in open-source text-to-speech technology, building upon the original Mozilla TTS project. The XTTS v2 architecture introduces cross-lingual voice cloning capabilities, allowing voice synthesis across multiple languages using minimal training data.
The system employs advanced neural network architectures including diffusion models and attention mechanisms specifically optimized for speech synthesis tasks, enabling high-fidelity voice generation with improved naturalness and expressiveness compared to earlier TTS systems.
Multilingual Speech Synthesis
Coqui TTS supports 17 languages with native pronunciation quality through sophisticated multilingual training methodologies. The model architecture enables zero-shot cross-lingual voice transfer, where a voice sample in one language can be used to generate speech in different supported languages while maintaining speaker identity.
The technology leverages large-scale multilingual datasets and advanced training techniques to achieve consistent voice characteristics across languages, making it suitable for international applications and multilingual content creation workflows.
📚 Authoritative Research Sources
Primary Research
- • Coqui TTS Repository - Official GitHub
- • coqui-tts Fork Documentation - Maintained Docs (idiap)
- • YourTTS: Towards Zero-Shot Multi-Speaker TTS - Research Paper
- • XTTS: Cross-lingual TTS - XTTS Research
Speech Technology Documentation
- • Mozilla TTS Documentation - Original Project
- • Hugging Face TTS Models - Model Hub
- • TTS Research Papers - Papers With Code
- • DeepSpeed Integration - Performance Optimization
Is Coqui TTS still maintained in 2026? Status, licence and the install that works today
Short answer: the company is gone, the model is not. Coqui's website was replaced by a "Coqui is shutting down" notice in January 2024 (the archived snapshot is dated January 5, 2024; today coqui.ai returns a GitHub Pages 404). The original coqui-ai/TTS repository is not archived on GitHub, but its last release is v0.22.0 from December 12, 2023 and its last push was August 2024. The maintained line is the fork idiap/coqui-ai-TTS, whose README describes itself as a "Fork of the original, unmaintained repository" and publishes the PyPI package coqui-tts — latest release v0.27.5 on January 26, 2026, with a release every few months through 2025.
The licence, precisely: code is MPL-2.0, XTTS v2 weights are CPML (non-commercial)
Two different licences apply. The library (the fork and the original) is Mozilla Public License 2.0. The XTTS v2 model weights on Hugging Face ship with the Coqui Public Model License 1.0.0, whose first line is:
"This license allows only non-commercial use of a machine learning model and its outputs."
It defines non-commercial purposes as uses "only so far as you do not receive any direct or indirect payment arising from the use of the model or its output": personal research, study, hobby projects; use by for-profit companies "for testing, evaluation, or non-commercial research and development"; and charitable use. It states that training other models for commercial use, and "revenue-generating activity, including projects directly funded by government grants", are not non-commercial. The outputs — the generated audio — are covered by the same restriction, not just the weights. Coqui used to sell a separate commercial licence; with the company gone there is no longer anyone to buy it from. Our XTTS / Coqui commercial licence explainer walks through what that means for specific projects.
Install the maintained fork (commands from the fork README)
Since coqui-tts 0.27.4, PyTorch is no longer pulled in automatically — install it first, choosing the CPU / CUDA / ROCm build for your machine, then the package. The import path is unchanged (from TTS.api import TTS). The README recommends uv; plain pip works the same without the uv prefix.
# 1. PyTorch (+ torchaudio; torchcodec only needed for PyTorch 2.9+)
uv pip install torch torchaudio torchcodec --torch-backend=auto
# ...or pick a build at https://pytorch.org/get-started/locally/
# 2. The maintained fork (idiap/coqui-ai-TTS)
uv pip install coqui-tts
# Tested on Ubuntu 24.04 with Python >= 3.10, < 3.15 and PyTorch 2.2+;
# the README says it "should also work on Mac and Windows".
# Optional extras, e.g. the demo server and Japanese support:
uv pip install "coqui-tts[server,ja]"Hardware, as far as the project documents it: the XTTS v2 download is ~2.1 GB (model.pth 1.87 GB, dvae.pth 0.21 GB, plus the 58 preset speaker embeddings); it runs on CPU or CUDA, with the docs choosing cuda when available; the docs note that turning off sentence splitting costs "more VRAM"; and the fork README says XTTS "can stream with <200ms latency". Neither the README nor the docs publish a minimum RAM or VRAM figure, so we do not invent one.
Should you still pick XTTS v2?
- • Yes — for personal / research multilingual cloning, its 17 built-in languages are still the widest list among local cloning models.
- • Mind the licence — the weights and their outputs are non-commercial (CPML). For paid products pick an engine whose weights allow it: the MIT-licensed Chatterbox for cloning, or Apache-2.0 Kokoro for preset voices.
- • Newer options — F5-TTS (also non-commercial weights) is the closest English cloning rival; the full ranked field is in best local TTS models.
- • Pair it with STT — combine cloned narration with a transcription model. See how to generate local subtitles with Whisper for a full offline audio pipeline.
- • Need preset voices only? A lighter, commercial-friendly option is in our Kokoro TTS setup guide.
Seeing "coqui-tts switched to a forked version of coqpit"?
That notice is informational, not an error — your install is fine. The idiap fork replaced the abandoned coqpit config library with its own fork, coqpit-config, and prints this message during install and upgrade. The only time you need to act is if Python later fails with ImportError: cannot import name 'Coqpit' from 'coqpit' — that means the old package is still installed and shadowing the new one:
pip uninstall -y coqpit
pip install --upgrade coqui-tts coqpit-configTechnical Implementation Guide
Install PyTorch, then Coqui TTS
PyTorch is no longer bundled (since 0.27.4); install it for your GPU first, then the maintained fork (idiap/coqui-ai-TTS)
Record Voice Sample
A clean ~6-second clip is enough per the model card; longer or multiple clips are accepted
Initialize Model
Load the powerful XTTS v2 model
Clone & Generate
Create speech in the cloned voice
Legacy note: the original pip install TTS still works on Python 3.11 or older, but that package is archived and gets no fixes — new installs should use pip install coqui-tts. Both use the same import path (from TTS.api import TTS).
Complete Voice Cloning Script
from TTS.api import TTS
# Initialize Coqui TTS with XTTS v2
tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to("cuda")
# Clone any voice with just one line
tts.tts_to_file(
text="I can now speak in any voice I want. This is incredible!",
speaker_wav="path/to/voice_sample.wav", # ~6 s clip per the model card; a list of clips also works
language="en", # Supports 17 languages
file_path="cloned_voice_output.wav"
)
# Since coqui-tts 0.27.0: clone once under a custom speaker ID, then reuse it
# without passing the reference clip again (docs: "Voice cloning" page)
tts.tts_to_file(
text="Hello world",
speaker_wav=["my/cloning/audio.wav", "my/cloning/audio2.wav"],
speaker="MySpeaker1", # cached under the model's voices/ folder
language="en",
)
tts.tts_to_file(text="Hello again", speaker="MySpeaker1", language="en")Want the full API walkthrough — batching, streaming, fine-tuning, and error handling? See our Coqui TTS Python guide.
XTTS v2 API Reference: tts_to_file() Parameters & Language Codes
Quick answer: tts_to_file() takes your text, a speaker_wav reference clip (or a preset speaker name), a language code, and a file_path for the output WAV. The official docs at docs.coqui.ai went offline when the company shut down, so here is the reference searchers keep looking for — every parameter, then all 17 language codes.
| Parameter | Type | What it does |
|---|---|---|
| text | str (required) | The text to synthesize. |
| speaker_wav | str or list | Path to your reference clip (~6s or longer) for voice cloning. Pass a list of clips for a more stable clone. |
| speaker | str | A built-in preset voice name (e.g. "Ana Florence") — use this instead of speaker_wav. See the voices list below. |
| language | str | One of the 17 codes below. Required for XTTS. Gotcha: Chinese is "zh-cn", not "zh". |
| file_path | str | Where the output WAV is written. Default: "output.wav". |
| speed | float | Speaking-rate multiplier. 1.0 is normal; lower is slower. |
| split_sentences | bool | Splits long text into sentences before synthesis (default True). Turn off for short phrases to cut latency. |
All 17 XTTS v2 language codes
en English · es Spanish · fr French · de German · it Italian · pt Portuguese · pl Polish · tr Turkish · ru Russian · nl Dutch · cs Czech · ar Arabic · zh-cn Chinese · ja Japanese · hu Hungarian · ko Korean · hi Hindi
Non-English example: German output from any voice sample
from TTS.api import TTS
tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to("cuda")
# German output from an English reference clip — XTTS clones across languages
tts.tts_to_file(
text="Willkommen! Diese Stimme wurde komplett lokal erzeugt.",
speaker_wav="my_voice.wav", # your ~6s reference clip (any language)
language="de", # swap to "tr", "ja", "hi"... any of the 17
file_path="willkommen.wav",
speed=1.0,
split_sentences=True,
)The same call with language="tr" produces Turkish in the same cloned voice. For batching, streaming, and error handling, see the Coqui TTS Python guide.
Built-in XTTS v2 Voices: 58 Preset Speakers, No Cloning Needed
Quick answer: XTTS v2 ships with 58 built-in studio voices, so you don't need a reference clip at all — pass speaker="Ana Florence" instead of speaker_wav. There is no separate voices download: the presets come bundled with the model checkpoint the first time it downloads.
from TTS.api import TTS
tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2")
# List all 58 built-in voices
print(tts.speakers)
# ['Claribel Dervla', 'Daisy Studious', 'Gracie Wise', 'Ana Florence', ...]
# Use a preset voice — no speaker_wav needed
tts.tts_to_file(
text="No voice sample? Pick a built-in studio speaker instead.",
speaker="Ana Florence",
language="en",
file_path="preset_voice.wav",
)The roster mixes female and male voices — Claribel Dervla, Daisy Studious, Gracie Wise, Ana Florence, Sofia Hellen, Andrew Chipper, Damien Black, Viktor Eka and 50 more — and every preset works with all 17 language codes, so "Ana Florence" can narrate in German or Japanese as easily as English. Presets are also faster than cloning, since the model skips extracting a speaker embedding from your clip.
Want your own voice instead of a preset? Follow the XTTS v2 voice cloning guide for recording tips and a full walkthrough.
🎯 Pro Voice Training Tips
Recording Quality
- • Use 16-bit WAV or high-quality MP3
- • Record in quiet environment
- • Maintain consistent distance from mic
- • Include varied intonations
Optimal Samples
- • The model card cites a ~6-second clip; longer clean speech is fine
- • Pass several clips as a list — the docs support multiple references for a steadier clone
- • Include questions and statements
- • Natural speaking pace works best
Performance: what the project documents
Neither the fork README nor the XTTS docs publish a real-time factor, a MOS score or a VRAM table, so this section lists only what they do state. Anything more specific depends on your GPU, quantisation and text length, and you should measure it yourself.
- ▸Output: 24 kHz sampling rate (XTTS docs, "Features").
- ▸Streaming: "Streaming inference with < 200ms latency" via the model-level
inference_stream()API; the docs add that streaming "is typically slower than regular inference, but it allows to get a first chunk of audio faster". - ▸Speed-up: loading the checkpoint with
use_deepspeed=Trueis the documented accelerator; it requirespip install deepspeed. - ▸Memory: the docs warn that disabling sentence splitting means "more VRAM and possibly hitting models context length limit"; cache the speaker latents from
get_conditioning_latents()to avoid recomputing them per call. - ▸Download: model.pth 1.87 GB + dvae.pth 0.21 GB + speakers 8 MB (Hugging Face file listing), fetched on first use.
Streaming, as documented (model-level API)
The high-level TTS.api wrapper has no streaming method; streaming uses the Xtts class directly. This is the docs' example, abridged:
import torch, torchaudio
from TTS.tts.configs.xtts_config import XttsConfig
from TTS.tts.models.xtts import Xtts
config = XttsConfig()
config.load_json("/path/to/xtts/config.json")
model = Xtts.init_from_config(config)
model.load_checkpoint(config, checkpoint_dir="/path/to/xtts/", use_deepspeed=True)
model.cuda()
gpt_cond_latent, speaker_embedding = model.get_conditioning_latents(audio_path=["reference.wav"])
chunks = model.inference_stream(
"It took me quite a long time to develop a voice and now that I have it I am not going to be silent.",
"en", gpt_cond_latent, speaker_embedding,
)
wav_chunks = [chunk for chunk in chunks] # play each chunk as it arrives
wav = torch.cat(wav_chunks, dim=0)
torchaudio.save("xtts_streaming.wav", wav.squeeze().unsqueeze(0).cpu(), 24000)Installation & Setup Instructions
System Requirements
🪟 Windows
# Python 3.10-3.14, PowerShell
# 1. PyTorch build for your GPU:
# https://pytorch.org/get-started/locally/
pip install torch torchaudio
# 2. the maintained fork
pip install coqui-tts🍎 macOS
# Install via Homebrew
brew install python@3.12
pip3 install torch torchaudio
pip3 install coqui-tts🐧 Linux
# Ubuntu/Debian (the README's tested platform)
uv pip install torch torchaudio torchcodec --torch-backend=auto
uv pip install coqui-tts
# or without uv: pip install torch torchaudio && pip install coqui-tts🐳 One-Click Docker Setup
# Maintained fork images (idiap) — CPU:
docker run --rm -v ~/tts-output:/root/tts-output ghcr.io/idiap/coqui-tts-cpu \
--text "Hello." --out_path /root/tts-output/hello.wav
# With GPU support:
docker run --rm --gpus all -v ~/tts-output:/root/tts-output ghcr.io/idiap/coqui-tts \
--text "Hello." --out_path /root/tts-output/hello.wav --use_cudaProfessional Applications & Use Cases
📚 Content Creation
Narration prototyping, draft audiobooks and course voice-overs where one cloned voice has to stay consistent across hours of text. Remember the licence: fine for your own study material, not for audio you sell.
🎙️ Media Production
Scratch tracks, table reads and translated drafts: clone the host once, then generate any of the 17 languages in that voice before a human records the final take.
🎮 Game Development
Placeholder NPC dialogue and dynamic narration during development, using the 58 preset speakers or cloned character voices, with streaming for interactive prototypes.
📱 Application Development
Accessibility features, local assistants and voice feedback in personal or internal tools, where nothing leaves the machine and no internet connection is required.
🎯 Professional Applications
Content Creation
- • Educational video narration
- • Podcast audio production
- • Audiobook narration
- • Training content creation
- • Documentation reading
Business Solutions
- • Interactive voice response
- • Virtual assistant voices
- • Employee training materials
- • Product demonstrations
- • Accessibility features
Entertainment
- • Game character dialogue
- • Animation voice acting
- • Interactive storytelling
- • Audio entertainment
- • Voice customization
Advanced Optimization Techniques
⚡ GPU Acceleration Guide
NVIDIA GPU Setup
# Install the CUDA build of PyTorch for your driver:
# https://pytorch.org/get-started/locally/
# (or let uv pick: uv pip install torch torchaudio --torch-backend=auto)
# Verify GPU
import torch
print(torch.cuda.is_available()) # Should return True
# Use GPU in Coqui (the docs' own pattern)
device = "cuda" if torch.cuda.is_available() else "cpu"
tts = TTS(model_name).to(device)What the docs say speeds it up
- • Load with
use_deepspeed=Trueafterpip install deepspeed - • Cache
get_conditioning_latents()per speaker - • Stream with
inference_stream()for a faster first chunk - • The project publishes no GPU-vs-CPU speed multiples; measure on your own hardware
🎯 Voice Fine-Tuning
# The docs ship a Gradio fine-tuning demo that
# (1) preprocesses your audio, (2) trains the XTTS
# GPT encoder, (3) lets you test the result.
pip install coqui-tts
pip install gradio faster_whisper
python3 -m TTS.demos.xtts_ft_demo.xtts_demoDocumented under "XTTS → Training → Easy training" in the fork docs; a Colab version exists for machines without a suitable GPU. The docs promise no fixed quality gain — judge by ear.
🚀 Batch Processing
# Process multiple texts efficiently
texts = ["Text 1", "Text 2", "Text 3"]
for i, text in enumerate(texts):
tts.tts_to_file(
text=text,
speaker_wav="voice.wav",
file_path=f"output_{i}.wav"
)Generate hours of content automatically
💎 Performance Best Practices
- ▸Model Caching: Load models once for multiple uses
- ▸Sample Rate: XTTS v2 outputs 24 kHz; resample afterwards if your pipeline needs 44.1/48 kHz
- ▸Streaming Output: Enable real-time generation for long texts
- ▸Audio Preprocessing: Clean samples for better voice cloning
- ▸Multi-GPU Support: Distribute processing across available GPUs
- ▸DeepSpeed: the docs' documented speed-up path (
use_deepspeed=True) - ▸Voice Embedding Cache: Pre-compute for instant voice switching
- ▸Service Architecture: Deploy as REST API for multi-app access
FAQs: Everything About Voice Cloning
Is voice cloning with Coqui TTS legal?
The software itself is 100% legal open-source. You must have permission to clone someone's voice — cloning your own voice or a voice you have explicit consent for is fine. Note the licensing split (see below): the TTS code is MPL 2.0, but the XTTS v2 model weights ship under the Coqui Public Model License (CPML), which is non-commercial. For commercial work, prefer an engine with permissive weights such as Chatterbox (MIT) or Kokoro (Apache 2.0).
How does Coqui TTS compare to ElevenLabs quality?
There is no like-for-like published score, so judge by ear with your own reference clip. What is verifiable: XTTS v2 is free, runs offline, has no quota and clones in 17 languages; ElevenLabs is a hosted service with a commercial licence included in paid plans. For commercial work XTTS v2 is ruled out by its licence regardless of quality.
Can I use Coqui TTS for commercial projects?
It's nuanced. The Coqui TTS code is Mozilla Public License 2.0 (commercial-friendly). The catch is the XTTS v2 model weights: those use the Coqui Public Model License (CPML), which allows only non-commercial use of the model and its outputs. Coqui the company shut down in January 2024, so there is no longer anyone selling a commercial licence. For commercial products, run an engine whose weights are also permissive — Chatterbox (MIT) for cloning or Kokoro (Apache 2.0) for preset voices. For personal projects, research, and a company's own testing and evaluation, XTTS v2 is free to use.
What languages does Coqui TTS support?
XTTS v2 supports 17 languages: English, Spanish, French, German, Italian, Portuguese, Polish, Turkish, Russian, Dutch, Czech, Arabic, Chinese, Japanese, Hungarian, Korean, and Hindi. All with native-speaker pronunciation, and you can clone a voice in one language and have it speak any of the others.
Do I need a powerful GPU for Coqui TTS?
No. The docs' own example picks CUDA when available and falls back to CPU, and the Docker images come in CPU and GPU variants. The project publishes no speed figures for either, so expect CPU to be slower and test with your own text length before committing to a machine.
How much voice data do I need for cloning?
The model card says XTTS v2 clones from a 6-second clip. You can pass several clips as a list to speaker_wav, and since coqui-tts 0.27.0 the cloned voice can be cached under a custom speaker name so you only supply the audio once.
Can Coqui TTS stream audio in real time?
Yes. The fork README states XTTS can stream with under 200 ms latency, using the model-level inference_stream() API shown above. The docs note streaming is typically slower overall than a single pass but gets the first chunk of audio to you sooner.
Is my voice data safe with Coqui TTS?
100% safe! Everything runs locally on your machine. No data is ever sent to any server. Your voice samples, generated audio, and all processing stay completely private on your hardware.
Can I create multiple voice personalities?
Unlimited! Unlike ElevenLabs which limits voice slots (10-160 depending on plan), Coqui TTS lets you create and store unlimited voice profiles. Build entire voice libraries for free.
How do I deploy Coqui TTS as a server?
The fork ships a demo server (tts-server, installed with the [server] extra) and Docker images ghcr.io/idiap/coqui-tts-cpu and ghcr.io/idiap/coqui-tts; the docs describe the demo server as not optimized for performance. For anything beyond personal use, wrap the Python API in your own service, and remember the CPML licence rules out commercial deployments of XTTS v2.
Getting Started with Voice AI
Begin your journey with professional-grade text-to-speech technology. Coqui TTS provides enterprise-level voice synthesis capabilities with open-source flexibility and local deployment.
pip install coqui-tts
Quick installation. Setup takes approximately 2 minutes.
📈 Growing developer community
💰 Cost-effective alternative to commercial services
🔧 Troubleshooting Common Issues
Installation Problems
Windows Build Tools Error
Getting "Microsoft Visual C++ 14.0 or greater is required"? This happens when Python packages need compilation.
# Solution: Install build tools first
# Download from: visualstudio.microsoft.com/visual-cpp-build-tools/
# Then retry: pip install coqui-ttsPython Version Mismatch
The legacy TTS package fails to install on Python 3.12+. The maintained coqui-tts fork requires Python >= 3.10 and < 3.15 (PyPI metadata).
# Create environment with a supported Python
conda create -n coqui python=3.12
conda activate coqui
pip install torch torchaudio
pip install coqui-ttsOld TTS package shadowing the fork
Both packages install the same TTS import path, so an old TTS install can mask coqui-tts. Use a fresh environment or remove the old one first.
pip uninstall -y TTS
pip install --upgrade coqui-ttsRuntime Problems
Out of Memory (OOM)
The project publishes no VRAM minimum, but XTTS v2 is the largest bundled model. If the GPU runs out of memory, keep sentence splitting on (the docs say disabling it costs more VRAM), or fall back:
# Use smaller model or CPU mode
tts = TTS("tts_models/en/ljspeech/tacotron2-DDC")
# Force CPU if GPU fails
tts = TTS(model_name).to("cpu")Voice Consistency Issues
Cloned voice sounds different each time? The model needs better samples.
# Use longer, cleaner samples
# Minimum: 6 seconds of clear speech
# Remove background noise first
# Use consistent tone/emotionCUDA Not Available
"Torch not compiled with CUDA"? Your PyTorch doesn't match your CUDA version.
# Reinstall PyTorch with the CUDA build for your driver
pip uninstall torch torchaudio
# pick the command at https://pytorch.org/get-started/locally/
# or: uv pip install torch torchaudio --torch-backend=auto✅ Quick Fixes That Work
For Windows Users:
- 1. Use a fresh conda or venv environment
- 2. Install Visual Studio Build Tools if a package needs compiling
- 3. Use Python 3.10-3.14 (the fork's supported range)
- 4. The fork publishes prebuilt wheels for Windows since 0.24.2
For Mac/Linux Users:
- 1. Use virtual environments
- 2. Install from source if pip fails
- 3. Check audio backend (soundfile)
- 4. Verify ffmpeg is installed
Pro Tip: Still having issues? The fork "coqui-tts" on PyPI is actively maintained and has better compatibility than the original. Try: pip install coqui-tts instead.
🚀 No GPU? Rent one by the hour
When a cloud GPU makes sense for XTTS v2
CPU only
- • Works — the docs and Docker images support it
- • Fine for short clips and testing a voice
- • Streaming latency claims apply to GPU inference
Rented GPU
- • Batch a long manuscript in one session
- • Run the Gradio fine-tuning demo
- • Pay only for the hours you use; check current prices on the provider
RunPod
Best Value- ✓ Hourly consumer and datacenter GPUs
- ✓ Pre-installed AI templates
- ✓ No commitment
Vast.ai
Cheapest- ✓ Marketplace pricing, wide GPU selection
- ✓ Docker ready
- ✓ Pay as you go
Tutorial
Learn- ✓ Complete setup guide
- ✓ Voice AI optimization
- ✓ Cost calculator
- ✓ Pro tips included
Was this helpful?
Build Real AI on Your Machine
RAG, agents, NLP, vision, and MLOps - chapters across 25 courses that take you from reading about AI to building AI.
Coqui TTS Technical Architecture
Coqui TTS's XTTSv2 architecture for professional voice synthesis with cross-lingual capabilities and high-quality output
Go from reading about AI to building with AI
25 structured courses. Hands-on projects. Runs on your machine. Start free.
Written by the Local AI Master Team
The team behind Local AI Master
We build Local AI Master around practical, testable local AI workflows: model selection, hardware planning, RAG systems, agents, and MLOps. The goal is to turn scattered tutorials into a structured learning path you can follow on your own hardware.
Related Guides
Continue your local AI journey with these comprehensive guides
Voice Cloning Guide
Complete voice cloning tutorial with multiple tools.
Bark Text-to-Speech
Suno's open-source TTS with music and sound effects.
Whisper Large v3
OpenAI's speech recognition model for transcription.
Music Generation Guide
Generate music locally with AI models.