VibeVoice Local Setup: Microsoft's Multi-Speaker Podcast TTS (1.5B vs 7B)

Short answer: VibeVoice-1.5B runs on any 8GB GPU (~6GB in use) and generates up to 90 minutes of audio with up to 4 distinct speakers — free, MIT-licensed, still on Microsoft's official Hugging Face. The better-sounding 7B "Large" needs ~20GB of VRAM (~12GB for Q8, ~8GB for Q4) and comes from community mirrors, because Microsoft pulled its weights. Setup takes about ten minutes via the ComfyUI node or the community Python fork; both paths are below with verified commands.

Nothing else with open weights does what this model does. Kokoro gives you one beautiful narrator voice. Chatterbox clones a voice from seconds of audio. But a 90-minute, four-person podcast conversation generated in a single pass, with speakers that stay consistent from minute 1 to minute 88 — VibeVoice is the only open-weights game in town for that, a year after release. That is why the repo sits at 51,941 stars (our GitHub API check, early August 2026) while its weights situation has turned into the strangest supply chain in local AI. Let's untangle it first, because it changes where you download things.

---

What VibeVoice Is (and What Microsoft Removed) {#what-is-vibevoice}

The short version: VibeVoice is Microsoft's long-form multi-speaker TTS family, accepted as an Oral at ICLR 2026 — but Microsoft removed the TTS code and the 7B weights in September 2025 after misuse concerns, so today you run it through a community fork and community mirrors.

Technically, VibeVoice is a "next-token diffusion" system: a Qwen2.5-based LLM reads the whole script and tracks dialogue flow, while a diffusion head generates the acoustic detail. Its core trick is a pair of continuous speech tokenizers running at an ultra-low 7.5 Hz frame rate, which is what makes hour-plus generations computationally sane. The result reads a script like a table read, not a sentence-by-sentence stitch job — speakers interrupt, react, and hold their voice across the full runtime.

Then came the plot twist. On September 5, 2025, Microsoft added this to the repo: "After release, we discovered instances where the tool was used in ways inconsistent with the stated intent. Since responsible use of AI is one of Microsoft's guiding principles, we have removed the VibeVoice-TTS code from this repository." The 7B weights vanished from Hugging Face around the same time. The repo has since pivoted toward ASR models — a 60-minute single-pass speech-to-text line that is genuinely interesting, but a different job from the one this page is about.

Here is the state of every piece, as we verified it in early August 2026:

Sources: microsoft/VibeVoice README, GitHub API, Hugging Face model pages, checked early August 2026.

Note what did not happen: the license never changed. Everything shipped under MIT, which is why the community fork and the weight mirrors are legal — Microsoft withdrew distribution, not permission. It also means this whole ecosystem runs on mirrors that could rot. If the 7B matters to you, download it and keep a copy.

---

1.5B vs 7B: Specs and VRAM {#specs-vram}

The 1.5B is the practical default: longer maximum output (90 vs 45 minutes), bigger context (64K vs 32K), official weights, and it fits an 8GB card. The 7B sounds better and is more stable, but needs ~20GB of VRAM and mirror downloads.

Speaker/length/context specs from the official Microsoft README and model cards; download sizes and VRAM figures from the VibeVoice-ComfyUI node documentation (Enemyx-net); quantized builds by community members Fabio Sarracino (Q8) and DevParker (Q4).

One naming footnote so the Hugging Face pages don't confuse you: "1.5B" and "7B" refer to the Qwen2.5 LLM backbone. HF's tensor counter shows roughly 3B and 9B total parameters, because the acoustic/semantic tokenizers and the diffusion head ride along. Nothing is mislabeled — it is just two ways of counting the same model.

Why pay the 7B's VRAM bill at all? Quality and stability. Microsoft's own FAQ (preserved in the community fork) notes the Large model is "quite stable" where the 1.5B can wander — the small model occasionally hallucinates background music into quiet podcasts (more in the limitations section). For anything you plan to publish, the 7B — or at least its Q8 quant — is audibly the better generator.

---

What Hardware You Need {#hardware}

Rule of thumb: any 8GB NVIDIA card runs the 1.5B or the 7B-Q4; a 12GB card runs the 7B-Q8 comfortably; the full-precision 7B wants a 24GB card.

• 8GB (RTX 3060 Ti / 4060 class): VibeVoice-1.5B at ~6GB, or the 7B-Q4 at ~8GB — the Q4 will be tight, so close everything else using VRAM. An 8GB card is a legitimate podcast-generation machine here, the same way it handles the models in our best LLMs for 8GB VRAM picks.
• 12GB (RTX 3060 12GB / 4070 Ti class): The 7B-Q8 at ~12GB is the sweet spot the node docs explicitly call out — "production-quality audio with 12GB VRAM GPUs."
• 16GB: Q8 with breathing room. Full BF16 7B does not fit — the docs recommend 17GB+.
• 24GB (RTX 3090/4090): Full-precision 7B at ~20GB, no compromises. If you own one of these cards, it does double duty on the strongest 24GB LLMs when it is not making podcasts.

Two platform caveats. The ComfyUI node's on-the-fly quantization options explicitly require a CUDA GPU, so treat NVIDIA as the tested path. And generation is an offline batch job, not real time — you queue a script, you get a WAV. Plan VRAM around what stays resident, not around speed.

---

Setup Path 1: ComfyUI (Easiest) {#comfyui-setup}

The recommended install for most people: the Enemyx-net VibeVoice-ComfyUI node — ~1,520 stars, MIT, the more actively maintained option — last updated February 2026, versus the older wildminder node, untouched since September 2025.

Step 1 — install the node:

cd ComfyUI/custom_nodes
git clone https://github.com/Enemyx-net/VibeVoice-ComfyUI

Restart ComfyUI; the node installs its Python requirements on first use.

Step 2 — download models manually. Since node v1.6.0 the wrapper no longer auto-downloads; you place files yourself under ComfyUI/models/vibevoice/:

You also need the Qwen2.5-1.5B tokenizer files (from Qwen/Qwen2.5-1.5B on Hugging Face) in the same models folder — the node docs show the exact layout:

ComfyUI/models/vibevoice/
├── VibeVoice-1.5B/
├── VibeVoice-Large/
└── tokenizer files (Qwen2.5-1.5B)

Step 3 — build the workflow. The node pack gives you a Single Speaker node and a Multiple Speakers node (up to 4). Useful switches, straight from the docs:

• quantize_llm: dynamically quantize a full-precision model to 4-bit or 8-bit at load time — grab the BF16 Large once and run it at whatever precision your card allows (CUDA required).
• attention_type: auto / sdpa / flash_attention_2 / sage.
• free_memory_after_generate: returns VRAM when the job finishes — worth keeping on if the same GPU also runs your image workflows.

Voice cloning is built in: feed an audio node into voice_to_clone (or speaker1_voice … speaker4_voice for conversations). The docs ask for clean audio, minimum 3-10 seconds, and recommend 30+ seconds; everything gets resampled to 24kHz. If voice cloning is the part you care about, our local voice cloning guide compares the options beyond VibeVoice.

---

Setup Path 2: Python (Community Fork) {#python-setup}

For scripted or batch use, install the community fork directly — it preserves the removed official code and adds fixes Microsoft never shipped.

git clone https://github.com/vibevoice-community/VibeVoice.git
cd VibeVoice
pip install -e .    # or: uv pip install -e .

Quickest smoke test is the bundled Gradio UI:

python demo/gradio_demo.py --model_path vibevoice/VibeVoice-1.5B --share

For real work, generate straight from a script file:

# Single speaker
python demo/inference_from_file.py \
  --model_path vibevoice/VibeVoice-7B \
  --txt_path demo/text_examples/1p_abs.txt \
  --speaker_names Alice

# Two-speaker conversation
python demo/inference_from_file.py \
  --model_path vibevoice/VibeVoice-7B \
  --txt_path demo/text_examples/2p_music.txt \
  --speaker_names Alice Frank

The --model_path values point at Hugging Face repos: vibevoice/VibeVoice-1.5B and vibevoice/VibeVoice-7B are the community org's mirrors (the fork's own defaults); microsoft/VibeVoice-1.5B works too for the small model. --speaker_names assigns bundled preset voices to Speaker 1, Speaker 2, … in order.

The fork also supports the official Realtime-0.5B streaming model (demo/streaming_inference_from_file.py) — a different animal: single speaker, roughly 10-minute generations, ~300ms first-audio latency per Microsoft, preset voices only (voice cloning was removed from that model). Use it for live assistant voices, not podcasts.

---

Writing Multi-Speaker Scripts {#scripts}

Scripts are plain text, one line per turn, prefixed with "Speaker 1:", "Speaker 2:", and so on — the speaker labels map to the voices you pass in order.

From the fork's bundled examples, the real format looks like this:

Speaker 1: Hey, remember "See You Again"?
Speaker 2: Yeah… from Furious 7, right? That song always hits deep.
Speaker 1: Let me try to sing a part of it for you.

Three practical notes from the official FAQ that save you failed generations:

1. There is no text normalization. The model gets your raw text — numbers, URLs, abbreviations and all. It usually copes (that is the LLM backbone doing its job), but for anything critical, spell out "twenty-five dollars" rather than gambling on "$25".
2. Punctuation is performance direction. Ellipses, dashes and exclamation marks audibly change pacing and emphasis. Write the script like a screenwriter, not like documentation.
3. Your reference voice leaks style. If a cloned speaker sample has background music in it, the generated audio is more likely to sprout background music too. Clean samples in, clean audio out.

For turning generated conversations into an actual publishing pipeline — episode structure, show notes, batching — our podcast automation tutorial picks up where the WAV file ends.

---

Honest Limitations {#limitations}

VibeVoice is remarkable and clearly a research artifact. Know these seven things before you build anything on it.

1. The 7B lives on borrowed infrastructure. Microsoft pulled it; mirrors carry it. MIT licensing makes that legal, but a mirror can vanish any Tuesday. Download once, archive locally.
2. Microsoft explicitly discourages production use. The model card: "We do not recommend using VibeVoice in commercial or real-world applications without further testing and development." The MIT license permits commercial use; the vendor advises against it. Both things are true — decide accordingly.
3. Outputs are marked as AI, by design. Per the official model card, generations embed an audible disclaimer (along the lines of "This segment was generated by AI") plus an imperceptible watermark as safety measures. Whether every community build behaves identically varies — but do not plan a workflow that depends on unmarked audio, and honestly, you should be disclosing AI audio anyway.
4. Spontaneous background music. The official FAQ admits you cannot directly control it: the model is content-aware and sometimes decides your intro line deserves a soundtrack. The 1.5B does this more; the Large model is notably more stable.
5. Singing is emergent and off-key. The training data contains no music, so when a script asks a speaker to sing, the result is charmingly imperfect. Fun demo, not a feature.
6. English and Chinese are the real languages. The README lists both plus "other languages"; cross-lingual generation shows up as an unstable emergent ability in the FAQ. For polished non-English narration, look at the multilingual options in our best local TTS models roundup.
7. It is not fast, and it is not real time. The 1.5B/7B models are offline generators — you trade wall-clock time for a 90-minute coherent file. We have no trustworthy public tokens-per-second benchmarks to quote, so we won't invent any; expect long generations to take serious GPU time, and use the Realtime-0.5B model when latency matters.

---

VibeVoice vs Kokoro, Chatterbox, F5 {#vs-alternatives}

Pick VibeVoice when the deliverable is a long multi-speaker conversation. For every other TTS job, a smaller model does it faster.

• Kokoro — an 82M-parameter model that produces excellent single-voice narration near-instantly on almost any hardware. For audiobooks, video voiceover, and screen readers, it is the efficiency king; it simply does not do conversations.
• Chatterbox — Resemble AI's MIT-licensed model, the strongest zero-shot voice cloning of the small models. Clone-a-voice-and-say-a-paragraph is its lane.
• F5-TTS — flow-matching cloning with a strong research pedigree; great short-form cloning quality, no long-form multi-speaker story.
• VibeVoice — the only one that holds four consistent voices across an hour-plus of audio in one pass. That single capability is the reason to tolerate its mirror-based supply chain and research-grade rough edges.

The honest summary: VibeVoice is not the best TTS model — it is the only open-weights model in its category. A year after release, with 51,941 stars and no open-weights competitor doing 90-minute multi-speaker generation, that category still belongs to it.

---

Sources {#sources}

• microsoft/VibeVoice — official repo: specs, removal notice, model family status
• microsoft/VibeVoice-1.5B — official 1.5B weights and model card (safety measures, usage guidance)
• vibevoice-community/VibeVoice — preserved TTS code, install commands, official FAQ text
• Enemyx-net/VibeVoice-ComfyUI — ComfyUI node; source of all VRAM figures, model sizes, and voice-sample requirements
• aoi-ot/VibeVoice-Large — primary community mirror of the pulled 7B weights
• Star counts, fork counts and download figures: GitHub API and Hugging Face, checked early August 2026

---

FAQ {#faq}