IndexTTS-2 Setup: Voice Cloning With Emotion Sliders

IndexTTS-2 is the local voice cloner to install if you want director-level control: it clones a voice from one short reference clip, then hands you eight independent emotion sliders — happy, angry, sad, afraid, disgusted, melancholic, surprised, calm — that steer delivery without changing the identity. Setup is four commands (git clone, uv sync --all-extras, a ~5.9GB checkpoint download, uv run webui.py --fp16). There is no official VRAM spec; community reports put 12GB at comfortable and 6GB at working-but-slow.

No other model we have set up on this site does the emotion part. F5-TTS copies whatever mood your reference clip happens to be in. Chatterbox gives you one "exaggeration" knob. IndexTTS-2 — built by bilibili's IndexTeam, repo at 22,421 GitHub stars / 2,729 forks and pushed August 4, 2026 (GitHub API, checked August 5) — decouples who is speaking from how they feel, and exposes that as sliders, a second reference audio, or a plain-text mood description. This guide covers the exact official install, all four emotion-control modes, the ComfyUI wrappers worth using, and the license fine print most tutorials skip.

One warning before anything else, straight from the project itself: the README carries an explicit caution that the only official channel is github.com/index-tts/index-tts. Several lookalike "IndexTTS2" demo websites rank for the name; none are affiliated with the team, so don't paste audio of your own voice into them.

---

Why IndexTTS-2 Is Different

The pitch in one line: state-of-the-art zero-shot cloning accuracy, plus emotion control no open competitor matches. Open-sourced in September 2025 and still actively developed a year later, it is positioned by its authors as an industrial-grade dubbing tool — the paper's headline feature is even precise duration control for video sync (more on why you can't use that yet in limitations).

The numbers below are from the IndexTTS2 paper (arXiv 2506.21619, v2, September 2025) — the authors' own evaluation, so apply the usual grain of salt, but the competitor set is the right one. Lower WER (word error rate, via ASR transcription of generated speech) is better; higher SS (speaker similarity to the reference) is better:

Source: IndexTTS2 paper, arXiv 2506.21619, Table 1 (author-reported), rounded to two decimals.

On the emotional test set (12 speakers, 7 emotions), the paper reports an emotion-similarity score of 0.887, its best-in-table result. Training scale, per the same paper: 55K hours of speech (30K Chinese, 25K English), including 135 hours of dedicated emotional data from 361 speakers. That training mix explains both the strength (Chinese and English are genuinely excellent) and the main limitation (those are the only two languages — see alternatives if you need more).

---

What You Need to Run It

Short version: an NVIDIA GPU with 8GB+ VRAM (12GB to be comfortable), ~10GB of disk, git with git-lfs, and the uv package manager — which the repo makes mandatory, not optional.

Two things worth internalizing before you start. First, the repo's maintainers only support uv installs — the README states outright that pip or conda environments produce "random bugs... missing GPU acceleration" and that issues from non-uv installs are considered invalid. Don't fight this; uv is genuinely the smoothest part of the setup. Second, there is no documented reference-audio length requirement: this is zero-shot cloning, every official example uses a single wav file, and the quality lever is clip cleanliness, not clip duration.

Wondering what else the same 12GB card earns you? Our 12GB VRAM model picks cover the LLM side of the house.

---

Install: The Official WebUI

Four steps: clone, sync, download checkpoints, launch. On a decent connection the whole thing is a coffee break, and every command below is transcribed from the official README (read August 5, 2026).

1. Clone the repo (git-lfs must be enabled for the bundled assets):

git lfs install
git clone https://github.com/index-tts/index-tts.git && cd index-tts
git lfs pull  # download large repository files

2. Install dependencies with uv. If you don't have uv yet: pip install -U uv (or any method from the uv docs). Then:

uv sync --all-extras

--all-extras pulls in every optional feature: webui (the Gradio interface), deepspeed, accel (GPT2 flash-attention engine), and torch_compile (triton compilation of the s2mel stage). On Windows, DeepSpeed is a known pain — the README's own advice is to drop --all-extras and add only the extras you want (--extra webui at minimum). If the install complains about CUDA, install NVIDIA's CUDA Toolkit 12.8 or newer.

3. Download the model checkpoints (~5.9GB from Hugging Face):

uv tool install "huggingface-hub[cli,hf_xet]"
hf download IndexTeam/IndexTTS-2 --local-dir=checkpoints

A few small auxiliary models auto-download on first run. Behind a slow connection to Hugging Face, export HF_ENDPOINT="https://hf-mirror.com" first — that tip is in the README too.

4. Launch:

uv run webui.py --fp16

Open http://127.0.0.1:7860. The --fp16 flag is the single most important one — the README calls FP16 faster and lower-VRAM with "a very small quality loss," and community threads (below) show it is the difference between painful and usable on mid-range cards. If you installed the acceleration extras, stack them:

uv run webui.py --fp16 --accel --torch_compile

Sanity checks when something misbehaves: uv run tools/gpu_check.py tells you whether PyTorch actually sees your GPU, and uv run webui.py -h lists every startup flag. One habit to unlearn: never manually activate the virtualenv — uv run handles environments itself, and the README warns that manual activation causes dependency conflicts.

The WebUI gives you a reference-audio upload, the emotion-mode selector, the eight vector sliders, and segment-length control. For scripting and batch jobs, the same install also ships an indextts2 CLI (docs/cli_v2_usage.md in the repo) that takes --voice, --emotion-audio / --emotion-vector / --emotion-text (mutually exclusive), and JSONL batch manifests — genuinely useful for audiobook-length runs, which we cover more generally in our local voice cloning overview.

---

Emotion Control, Four Ways

This is the reason to pick IndexTTS-2 over everything else: identity comes from one reference clip, emotion comes from wherever you want — the same clip, a different clip, eight sliders, or a text description. All four modes are in the WebUI and the Python API; snippets below use the official API shape (indextts.infer_v2.IndexTTS2), with example text ours.

Mode 1 — plain cloning. One reference wav supplies both identity and delivery:

from indextts.infer_v2 import IndexTTS2
tts = IndexTTS2(cfg_path="checkpoints/config.yaml", model_dir="checkpoints", use_fp16=True)
tts.infer(spk_audio_prompt="my_voice.wav", text="Read this in my voice.", output_path="gen.wav")

Mode 2 — a second, emotional reference. Keep the identity from spk_audio_prompt, borrow the mood from emo_audio_prompt, and blend with emo_alpha (0.0-1.0, default 1.0):

tts.infer(spk_audio_prompt="my_voice.wav", text="I can't believe this happened.",
          output_path="gen.wav", emo_audio_prompt="angry_sample.wav", emo_alpha=0.9)

This is the dubbing workflow: your narrator's clean studio clip stays the identity, and a raw emotional take — anyone's voice — drives the performance.

Mode 3 — the eight sliders. Pass an 8-float vector in this fixed order (from the README): [happy, angry, sad, afraid, disgusted, melancholic, surprised, calm]:

tts.infer(spk_audio_prompt="my_voice.wav", text="Please... just leave me alone.",
          output_path="gen.wav", emo_vector=[0, 0, 0.8, 0, 0, 0, 0, 0], use_random=False)

That vector is 80% sad, nothing else. Values are per-emotion intensities and you can mix them — a touch of afraid under mostly sad reads as genuine distress. Keep values moderate: TTS-Audio-Suite's emotion guide (the most detailed third-party documentation) recommends 0.0-1.2 per slider and notes that pushing above 1.0 "may interfere with the cloned voice resemblance." The official README makes the related warning: enabling use_random adds variety but reduces voice-cloning fidelity.

Mode 4 — describe the mood in text. Set use_emo_text=True and the bundled QwenEmotion model — a fine-tuned Qwen3, shipping as the 1.19GB qwen0.6bemo4-merge checkpoint — converts a description into an emotion vector for you. By default it reads the mood off your script text; pass emo_text to direct it separately:

tts.infer(spk_audio_prompt="my_voice.wav", text="Hide. Now. He's coming.",
          output_path="gen.wav", use_emo_text=True, emo_text="terrified whisper",
          emo_alpha=0.6, use_random=False)

The README specifically recommends emo_alpha around 0.6 or lower in text mode for natural results — full-strength text emotion tips into melodrama fast. In practice we'd reach for mode 4 first (fastest iteration), then lock the final read with mode 3 sliders once you know what you want.

---

The ComfyUI Path

If you already live in ComfyUI, skip the Gradio WebUI entirely: TTS-Audio-Suite (1,134 stars, pushed August 4, 2026) is the wrapper we'd install first, with chenpipi0807's dedicated ComfyUI-Index-TTS (730 stars) as the runner-up. Star counts and push dates via the GitHub API, August 5, 2026:

Install is the standard ComfyUI custom-node dance — clone into custom_nodes, install the wrapper's requirements.txt, drop the IndexTTS-2 checkpoints where the wrapper expects them (TTS-Audio-Suite auto-downloads; chenpipi's wrapper uses ComfyUI/models/IndexTTS-2/). If ComfyUI itself is new to you, start with our ComfyUI complete guide first — the node-graph mental model matters more than any individual wrapper.

Why bother with ComfyUI for TTS at all? Chaining. A workflow that generates dialogue with per-character emotion tags, runs it through IndexTTS-2, and drops the audio onto a video timeline is a saved graph you re-run forever — that's the "industrial" use the model was built for.

---

Speed: What to Expect

Honest answer: fine on 12GB once --fp16 is on, slow at defaults, and the project publishes no official benchmark — the best public data points are GitHub issues. The most instructive one (issue #585): an RTX 3060 12GB user reported ~228 seconds to generate ~17 seconds of audio at default settings — a real-time factor of 13.1. The fix suggested in the thread — --fp16 plus a smaller segment size (--gui_seg_tokens 80) — brought the posted logs down to an RTF of roughly 1.6-2.2, i.e. about 6-8x faster on the same hardware. Same card, same model; the flags are the difference between unusable and comfortable. At the bottom end, a 6GB RTX 4050 user (issue #432) had it running but flagged generation as painfully slow, which matches the shared-memory spillover you'd expect once weights plus activations crowd 6GB.

Practical tuning order, distilled from the README and those threads:

1. Always --fp16. Halves memory pressure; README-sanctioned "very small quality loss."
2. Shrink segments (max text tokens per segment in the WebUI) if long paragraphs crawl or overflow VRAM.
3. Try --accel and --torch_compile if you installed those extras — flash-attention and triton compilation respectively. On Windows, --accel needs a prebuilt flash-attn wheel, which is its own adventure.
4. Treat DeepSpeed as a coin flip. The README itself says it may speed things up or slow them down depending on your system — test both ways.

---

Honest Limitations

Know these before you commit — two of them are dealbreakers for specific use cases.

• The license is custom, not MIT/Apache. The "bilibili Model Use License Agreement" is royalty-free but conditional: no using the model to improve other AI models (non-commercial excepted), mandatory disclaimers on distributed derivatives, prohibited high-risk uses, PRC governing law. Fine for most creator workflows; a real conversation with a lawyer if you're shipping a commercial product on top of it.
• Two languages. Chinese and English, per the model card. If you need Spanish, German, Japanese or the rest, this is the wrong tool — see XTTS-v2 for 17-language cloning.
• The headline duration-control feature is switched off. Precise duration control is the paper's main contribution — and the README states it is "not yet enabled in this release" (still true as of August 5, 2026). If frame-accurate dubbing is the reason you came, that reason isn't shipped yet.
• No official hardware docs. VRAM guidance in this guide is assembled from weight sizes, wrapper docs, and issues — clearly labeled — because the project publishes none.
• uv-only, GPU-first. Non-uv installs are explicitly unsupported, and there is no documented CPU or Apple Silicon path in the official README. This is a CUDA project in practice.
• Emotion intensity fights identity. Push the sliders past ~1.0 or leave emo_alpha at 1.0 in text mode and the voice drifts away from your reference — documented by both the README's use_random warning and TTS-Audio-Suite's guide. Subtle values win.
• Voice-cloning ethics apply, doubled. A model that can make a cloned voice sound convincingly afraid or angry is a model that makes scam audio more convincing. Clone voices you have rights to. The license's lawful-use clauses are explicit about this, and so are we.

---

vs the Other Voice Cloners

Pick IndexTTS-2 for controlled emotional performance in English or Chinese; pick something else for speed, simplicity, or languages. The one-paragraph map, against the models we've already covered in depth:

• F5-TTS — the fastest route to a good clone and the biggest community. Emotion is whatever your reference clip contains; there are no dials. If IndexTTS-2's install feels heavy, F5 is the pragmatic default.
• XTTS-v2 — 17 languages, mature tooling, but a licensing story you must read before commercial use, and no emotion decoupling.
• Chatterbox — MIT-licensed with a single emotion-exaggeration knob; think volume dial versus IndexTTS-2's mixing desk. Setup in our Chatterbox guide.
• Kokoro — not a cloner at all (fixed voices), but tiny and excellent for narration; see Kokoro vs XTTS vs Chatterbox for that three-way.

The full field, including the speech-to-text side, lives in our best local TTS models roundup. But if the phrase "eight emotion sliders on a cloned voice" made you sit up — that feature has exactly one open-weights address right now, and this page just walked you through it.

---

Sources

• index-tts GitHub repository — all install commands, emotion-control API examples and parameter guidance, FP16/accel/DeepSpeed notes, official-channel caution (README read August 5, 2026)
• IndexTTS2 paper, arXiv 2506.21619 — WER/speaker-similarity/emotion benchmark tables, training-data scale, emotion-identity disentanglement and duration-control design
• Hugging Face: IndexTeam/IndexTTS-2 — checkpoint file sizes, language tags, download counts (HF API, August 2026)
• GitHub API, August 5, 2026 — star/fork counts and push dates for index-tts and all ComfyUI wrappers cited
• index-tts issue #585 and #432 — RTX 3060 12GB and RTX 4050 6GB speed reports plus the fp16/segment-size fix
• TTS-Audio-Suite and its IndexTTS-2 emotion guide — slider ranges and blending behavior; ComfyUI-Index-TTS — 12GB daily-use note, model paths
• Repo LICENSE file — bilibili Model Use License Agreement terms summarized above. VRAM comfort tiers are our estimates from these sources and are labeled as such; we have not yet bench-tested IndexTTS-2 on our own hardware.

---

FAQ