F5-TTS Zero Shot TTS: Install & Deploy v1.1.x Guide

Zero shot TTS means cloning a voice from a few seconds of reference audio without retraining. F5-TTS is currently the strongest open-source contender for this – MIT-licensed code, a Diffusion Transformer with ConvNeXt V2 backbone, and an inference RTF of 0.15 on the paper’s reference setup (arXiv:2410.06885). If you want to run zero shot TTS locally instead of paying per character at a hosted API, this is the install path that actually works as of mid-2026.

This guide skips the marketing recap. We’re going straight to the deployment blockers other tutorials ignore: the numpy dependency conflict, the Gradio UI freeze, the licensing trap, and what to do when AMD users on new GPUs see silent failures.

What you’re actually installing (and the license fine print)

The upstream package is f5-tts on PyPI, source at github.com/SWivid/F5-TTS. As of mid-2026 the stable line is the v1.1.x series – the ONNX downstream port confirms it tracks v1.1.7 as the supported upstream, and newer point releases keep landing on the same minor. Check pip index versions f5-tts before installing – version numbers move fast here.

Now the part every tutorial glosses over. The code is MIT. The pretrained weights are not. Per the README, the released checkpoints are CC-BY-NC because they were trained on the Emilia dataset. If you’re shipping a commercial product, you cannot use the default F5TTS_v1_Base weights without negotiating separately or training from scratch on a license-clean corpus.

Watch out: If you need a commercial-safe zero shot TTS today, deploy F5-TTS for prototyping but plan a finetune on a permissively-licensed dataset (or a different model). Don’t discover the CC-BY-NC clause after launch.

This split – permissive code license, restricted model weights – is a pattern that keeps catching people. The README is clear about it, but most install tutorials skip straight to the pip command. The Emilia dataset terms flow down to the weights, full stop. Worth spending five minutes on this before you build a product dependency.

System requirements (honest minimums)

The official README doesn’t publish a strict spec sheet, so these numbers combine official install commands with community benchmarks. Treat the VRAM figure as a working minimum, not a comfort zone.

CPU-only inference technically works but isn’t practical for interactive use. The interesting part: RDNA 3.5 and RDNA 4 AMD cards (Radeon 8050S/8060S, RX 9060/9070) require ROCm 7.x – the older ROCm wheels exclude gfx1151/gfx1201 and will fall back to CPU without an obvious error. That’s straight from the official install notes.

RTF of 0.15 sounds like a spec sheet win. But what does it mean in practice? On a mid-range GPU it translates to roughly a 10-second sentence generating in about 1.5 seconds. That’s fine for async workflows – batch narration, podcast production – but not the same as streaming latency. If your use case is real-time conversation, that gap matters more than the benchmark number.

The recommended install (pip + conda)

Three supported paths exist: pip from PyPI, source install with -e, and Docker. The pip+conda route is the one the official README leads with, and it’s the easiest to debug.

# 1. Fresh conda env
conda create -n f5-tts python=3.11 -y
conda activate f5-tts

# 2. FFmpeg (audio I/O)
conda install -c conda-forge ffmpeg -y

# 3. PyTorch matching your CUDA (as of mid-2026)
# CUDA 12.8 (RTX 40/50-series, latest stable)
pip install torch==2.8.0+cu128 torchaudio==2.8.0+cu128 
 --extra-index-url https://download.pytorch.org/whl/cu128

# CUDA 12.4 (older but very stable)
# pip install torch==2.4.0+cu124 torchaudio==2.4.0+cu124 
# --extra-index-url https://download.pytorch.org/whl/cu124

# 4. F5-TTS itself
pip install f5-tts

If pip install f5-tts resolves cleanly, you’re done. If it doesn’t, jump to the errors section – the numpy issue catches most people.

Source install (if you plan to finetune)

git clone https://github.com/SWivid/F5-TTS.git
cd F5-TTS
# optional, only if you want BigVGAN vocoder
# git submodule update --init --recursive
pip install -e .

Docker (one-liner deploy)

docker container run --rm -it --gpus=all 
 --mount 'type=volume,source=f5-tts,target=/root/.cache/huggingface/hub/' 
 -p 7860:7860 ghcr.io/swivid/f5-tts:main 
 f5-tts_infer-gradio --host 0.0.0.0

The Docker image is published to GitHub Container Registry. The named volume matters – without it, you’ll re-download model weights every container start.

First run and verification

# Launch the web UI on localhost:7860
f5-tts_infer-gradio

# Or expose it to your LAN
f5-tts_infer-gradio --port 7860 --host 0.0.0.0

Hit http://localhost:7860, drop a 5-15 second reference WAV, type a transcript of that reference, then type the text you want synthesised. First generation downloads the F5TTS_v1_Base checkpoint from Hugging Face – expect a few hundred MB before anything plays.

For a headless verify:

f5-tts_infer-cli --model F5TTS_v1_Base 
 --ref_audio "ref.wav" 
 --ref_text "This is the text spoken in the reference audio." 
 --gen_text "And this is the new sentence I want generated."

Output WAV plays back and roughly matches the reference voice? Install is good. Leaving --ref_text "" empty triggers a Whisper-style ASR transcription of your reference – that uses extra GPU memory, so give it explicit text on first run.

Common errors people actually hit

numpy 2.x dependency conflict

Most reported install failure. Issue #1162 documents it: f5-tts==1.1.7 pins numpy<=1.26.4, and if any other package in your env wants numpy 2.x, pip throws a resolver error. The community workaround from the issue thread:

pip install f5-tts --no-deps
pip install "numpy>=1.24,<2.3" # then install remaining deps manually

Tensor ops and audio generation work fine on numpy 2.x in practice – the cap is conservative, not technical. Check whether it’s been lifted in your installed version before bypassing it.

Gradio UI freezes after loading

Blank Gradio page that never loads? You’re on an incompatible Gradio version. Per the F5-TTS release notes, PR #1290 capped Gradio at <6.11 to fix it. Installing Gradio manually after F5-TTS can overwrite that constraint:

pip install "gradio<6.11" --force-reinstall

RTX 50-series: torch can’t see the GPU

The default pip install torch often pulls a cu121 build that doesn’t know about Blackwell. You need the cu128 channel explicitly. Quick check:

python -c "import torch; print(torch.cuda.is_available(), torch.cuda.get_device_name(0) if torch.cuda.is_available() else 'no gpu')"

Last word missing in short sentences

An older bug in batch inference truncated the final word on shorter inputs. Fixed in a recent release across both the PyTorch and TRT-LLM runtime paths – issues #1039 and #1179 in the official changelog. On an older v1.1.x build, upgrade. There’s no config flag to work around it on old versions.

Upgrade and uninstall

pip install --upgrade f5-tts
# verify
python -c "import f5_tts; print(f5_tts.__version__)"

Cached weights live under ~/.cache/huggingface/hub/. If you switched from a pre-v1 checkpoint to F5TTS_v1_Base, use the new model’s default inference settings first – old inference parameters are not forward-compatible across major checkpoint generations. Tune only after you have a clean baseline output.

Full removal:

pip uninstall f5-tts
conda deactivate
conda env remove -n f5-tts
rm -rf ~/.cache/huggingface/hub/models--SWivid--F5-TTS

The cache deletion is the step most people forget. The weights alone are easily a few GB.

FAQ

How does F5-TTS compare to other zero shot TTS models for commercial use?

The weights are CC-BY-NC. That’s the answer for commercial use – F5-TTS is off the table unless you retrain on a permissively-licensed corpus. Speed and quality comparisons are secondary to that constraint.

Can I run F5-TTS without a GPU?

Yes, but you’ll regret it for anything interactive. PyTorch CPU mode loads fine and generates audio, just slowly – expect tens of seconds per short sentence on a modern desktop CPU. Fine for offline batch narration, useless for real-time.

Does the install include voice cloning out of the box, or do I need extra weights?

Out of the box. The default F5TTS_v1_Base checkpoint downloads on first run from Hugging Face and is itself a zero-shot model – give it any 5-15 second reference clip and matching transcript, and it clones. No separate “voice cloning add-on” exists. One thing worth knowing: the model was trained on English and Chinese (the 100K-hour Emilia dataset), so performance on other languages depends on community-finetuned checkpoints, not the base install.

Next: run the Gradio CLI command above, drop in a clean 10-second reference of your own voice, and generate one test sentence. If it works, your deployment is real. If it doesn’t, the error message you see now fits into one of the four buckets above.