Voicebox: The Local ElevenLabs, and Its 7 Voice Engines

Short answer: run Kokoro (150 MB VRAM) if you have no GPU, Chatterbox Turbo (~1.5 GB) for expressive English, Qwen3-TTS 1.7B (~6 GB) for the best cloning quality, and TADA 3B (~8 GB) only for long-form. Voicebox bundles seven TTS engines behind one interface, and the difference between the smallest and largest is a factor of 55 in memory. Picking wrong is the single most common reason people conclude "local TTS is bad".

Voicebox is Jamie Pine's project — the same person behind Spacedrive — and that pedigree is a big part of why it went from a January 2026 repo to over 50,700 GitHub stars by mid-August. It positions itself explicitly as a local-first replacement for two cloud products at once: ElevenLabs on the output side, WisprFlow on the input side. MIT licensed. Models, voice data and captures never leave your machine.

This page is the constraint guide. Not a feature tour — the README does that well enough — but the thing the README does not do: tell you which of the seven engines your hardware can actually hold, and where the project is still rough.

---

The engine picker

Every size and VRAM figure below is read from Voicebox's own model-management documentation, not estimated. These are the project's numbers for the model as it downloads it.

Two things jump out. First, Kokoro is not a cloning engine — it is 50 curated preset voices, and it is by far the cheapest thing here. If you want a narrator voice and do not care that it is not your voice, that is where to start and you may never leave. Second, the language spread is wildly uneven: Chatterbox Multilingual is the only engine covering 23 languages, and it is the only route to Arabic, Danish, Finnish, Greek, Hebrew, Hindi, Malay, Norwegian, Polish, Swahili, Swedish or Turkish. Qwen covers a solid 10 (English, Chinese, Japanese, Korean, German, French, Russian, Portuguese, Spanish, Italian). Everything else is English-only.

Only Chatterbox Turbo interprets paralinguistic tags. Type [laugh] into any other engine and it will read the word "laugh" out loud. That is documented behaviour, not a bug, and it catches everyone once.

Speech-to-text is separate and simpler: Whisper in five sizes, from Base at roughly 300 MB to Large-v3 at roughly 3 GB, plus Turbo at roughly 1.5 GB. On Apple Silicon, MLX-Whisper is the default, and the docs credit that — not Turbo on its own — with roughly 8x faster transcription; the changelog puts the Whisper Turbo plus MLX combination at ~20s down to ~2-3s on M-series chips. For a deeper look at the transcription side, our faster-whisper guide covers the same models tuned for throughput.

---

Fit by VRAM tier

The trap is that Voicebox can hold several models resident at once — a TTS engine, Whisper, and a Qwen3 LLM for refinement all share the GPU. Budget for the stack, not the single engine. There is a per-model unload control in Settings for exactly this reason.

That MLX caveat matters more than it sounds. The project documents native MLX support for exactly two things — Qwen3-TTS and Whisper — with Chatterbox, LuxTTS, TADA, Kokoro and Qwen CustomVoice all routing through PyTorch MPS instead. The stated speedup for the MLX path is 4-5x. So on a Mac, Qwen3-TTS is not just the best-quality engine, it is disproportionately the fastest one, and the usual "pick a smaller model to go faster" instinct works against you. Kokoro on macOS additionally needs PYTORCH_ENABLE_MPS_FALLBACK=1, which the app sets for you unless you launch from a custom environment. MLX vs CUDA for local AI explains why that gap exists.

The project's own stated system requirements are modest: 8 GB RAM and 5 GB of free storage as a minimum, 16 GB RAM and a CUDA-capable GPU as the recommendation, 10 GB+ storage. The 5 GB storage minimum is optimistic if you plan to try more than two engines — the models add up to well over 25 GB if you download all of them.

---

Install

macOS and Windows have prebuilt binaries. Linux does not. The download table offers a DMG for Apple Silicon, a DMG for Intel Macs, an MSI for Windows, and docker compose up. The Linux note is blunt: pre-built binaries are not yet available, build from source. The installation docs attribute that to GitHub runner disk-space limits.

Grab the installer from the releases page and launch it. The first generation is slow because the engine you pick downloads its model on demand — sizes range from Kokoro's 350 MB to TADA 3B's 8 GB.

On Windows with NVIDIA, there is one extra step that trips people up. CUDA is not bundled in the main installer. When you first need it, Settings → GPU offers "Install CUDA backend", which pulls two archives separately: a server core and a CUDA libs archive. The docs quote these as "~200-400 MB" and "~4 GB"; the actual assets attached to the v0.5.0 release are voicebox-server-cuda.tar.gz at 1.03 GB and cuda-libs-cu128-v1.tar.gz at 2.11 GB, so budget roughly 3.1 GB of download and more once it unpacks. The app restarts to swap the backend in. Since version 0.4 those are versioned independently, so most upgrades only re-download the smaller core.

If you are on an RTX 50-series card and see "no kernel image is available", the fix is documented: be on 0.4.0 or newer (that release moved to cu128, which has Blackwell kernels — earlier builds used cu126 and did not), then reinstall the CUDA backend to clear stale libs. That is the same class of error covered in our HSA_OVERRIDE / unsupported-GPU guide on the AMD side.

For AMD on Linux, Voicebox auto-configures HSA_OVERRIDE_GFX_VERSION for common cards. If detection fails, set it manually before launch — 10.3.0 for RX 6000, 11.0.0 for RX 7000, 9.0.0 for older Vega.

Build from source, if you need to:

git clone https://github.com/jamiepine/voicebox.git
cd voicebox
just setup   # creates the Python venv, installs deps
just dev     # starts backend + desktop app

Prerequisites are Bun, Rust, Python 3.11+, the Tauri prerequisites, and Xcode on macOS. It is a Tauri app, not Electron, which is why the DMG is around 538 MB rather than a gigabyte.

---

Cloning a voice

10 to 30 seconds of clean speech, one upload, and you have a reusable profile. The workflow is genuinely short: upload or record a sample, the selected engine extracts a voice embedding, and the profile is stored locally for any future generation.

Five of the seven engines support cloning — Qwen3-TTS, Chatterbox Multilingual, Chatterbox Turbo, LuxTTS and TADA. The two CustomVoice/Kokoro engines are preset-only by design, which is why the profile grid greys out engines that cannot use a given profile.

The documented advice on sample quality is unglamorous and correct: 10-30 seconds, clear and consistent speaking, minimal background noise, natural pace. Avoid clips under five seconds, music or overlapping voices, and heavily processed audio. You can attach multiple samples to one profile — different speaking styles and emotions — and the model builds a more robust representation from the spread. That is the single highest-leverage thing most people skip.

If your clone comes out flat or metallic, the reference clip is nearly always the cause rather than the engine. Our general voice-cloning guide and the XTTS v2 walkthrough both go deeper on reference-audio prep, and that advice transfers to any of Voicebox's engines.

One thing worth saying plainly: the project's own documentation asks you to only clone voices you have consent to clone, and points at local law on synthetic voice content. That is not boilerplate. A tool that removes the cloud gatekeeper also removes the gatekeeper's terms-of-service check.

---

The dictation half

This is the part that makes Voicebox more than another TTS front-end, and it is the half most reviews skip. Dictation arrived in 0.5.0 alongside the Captures tab.

Hold a chord anywhere on your system. A floating pill fades in over whatever app you are in, showing a live waveform and elapsed time. Speak. Release. The pill flips to Transcribing, then Refining if you have auto-refine on, then disappears — and the text lands in the field you had focus in.

Three details are better-designed than they need to be:

1. Focus is snapshotted at chord-start. The paste targets the field you were talking from, not wherever focus drifted to while Whisper was running. On macOS this is a CGEventPost at the HID tap with the original app reactivated first, and your clipboard is saved before and restored after so nothing you had copied goes missing.
2. Holding push-to-talk and tapping Space mid-hold upgrades the hold into a toggled session without a gap in the audio. Short bursts stay fast, long narration goes hands-free, and you never have to decide up front which mode you wanted.
3. The chord defaults deliberately avoid collisions. On macOS they stay off left-hand Cmd+Option so devtools, force-quit and Spotlight all keep working. On Windows they route around AltGr on German, French and Spanish layouts.

Optional LLM refinement runs the raw Whisper transcript through a local Qwen3 model (0.6B, 1.7B or 4B) to strip ums, stutters and false starts before pasting. That is the same model that backs the voice-personality features, so there is one LLM in the app and one GPU footprint for both.

Every capture — dictation, in-app recording, uploaded file — lands in the Captures tab with its original audio paired to its transcript, so you can re-transcribe at a different Whisper size, re-refine with different flags, or promote the audio to a voice sample on a profile.

There is also an MCP server built in, mounted at http://127.0.0.1:17493/mcp, exposing voicebox.speak, voicebox.transcribe, voicebox.list_captures and voicebox.list_profiles. You can bind a specific voice per client, so Claude Code and Cursor speak to you in different voices. Whether that is useful or maddening is a matter of temperament, but it is a genuinely novel thing to ship.

---

What it does better and worse

Better than a single-model setup: you get seven engines behind one interface with per-generation switching, which means the "which local TTS is best" question stops being a research project and becomes a dropdown. It covers more backends than almost anything else in this space — MLX, CUDA cu128, ROCm, Intel XPU, DirectML and CPU. It bridges input and output, which no single cloud product does. And the post-processing chain (8 effects on Spotify's pedalboard, with per-profile default chains) is a real production feature, not a toy.

Better than ElevenLabs: no per-character billing, no reference audio leaving your machine, no rate limit, unlimited generation length via auto-chunking with crossfade up to 50,000 characters.

Worse than ElevenLabs: you own the decisions. Which engine, which size, which backend, how much VRAM to allocate, why Kokoro ignores your [laugh] tag. There is no single tuned pipeline. And nobody has published a blind quality comparison, so anybody telling you it matches ElevenLabs on output quality is guessing.

Worse than a single-purpose tool: if all you want is a narrator voice for a video, Kokoro on its own is a 350 MB download and a Python script. Voicebox is a 538 MB app that then downloads models. The overhead only pays off when you use both halves of the loop.

---

Honest limitations

The most important caveat is version drift. The latest tagged release is v0.5.0, published 25 April 2026, but the repository has been pushed to continuously since — most recently 9 August 2026. Several features described in the README and docs live on the main branch, and it is not always obvious which ones made it into the 0.5.0 binary you download. If a documented feature is missing from your install, that is the likely reason; check the release notes rather than assuming it is broken.

The rest, in order of how likely they are to bite you:

• No Linux binaries. Build from source or use Docker. For a project this popular, that is a notable gap, and the maintainers attribute it to CI disk-space limits rather than a design choice.
• Auto-paste platform coverage is ambiguous. The docs describe a Windows SendInput implementation with a SetForegroundWindow + AttachThreadInput handshake, while the README roadmap still lists "Windows / Linux auto-paste" as pending parity work. macOS is the verified path. Test Windows before you rely on it.
• 646 open issues and pull requests on 18 August 2026, on a repo seven months old (GitHub's open-issue count folds PRs in, so treat it as a ceiling). That is what 50,000 stars in seven months does to an issue tracker; it is not by itself a quality signal either way, but it does mean a bug you hit may already be filed and unresolved.
• Only one engine understands emotion tags. Chatterbox Turbo. Everything else reads them literally.
• Whisper is the only STT engine. Parakeet v3 and Qwen3-ASR are on the roadmap, not shipped. If you need better non-English transcription today, Whisper Large is your ceiling here.
• The CUDA backend is roughly a 3.1 GB extra download on Windows (1.03 GB server core + 2.11 GB CUDA libs, measured from the v0.5.0 release assets), on top of the 543 MB installer.
• Model licences are not the app licence. MIT covers the code. The seven model families do not all share it.

---

Verdict

Install it if you want both halves of the voice loop and you have at least 8 GB of VRAM or 16 GB of unified memory. Skip it if you only need one voice for one video — grab Kokoro directly instead.

The engine spread is the product. A tool that runs on a fanless laptop at 150 MB and an audiobook model at 8 GB, behind the same interface, with a global dictation hotkey attached, does not have a real equivalent. Cloud incumbents split that job across two subscriptions.

What holds it back today is polish at the edges: the release cadence has outrun the tags, Linux users build from source, and the platform matrix has soft spots. None of that is fatal, and a project that went from nothing to 50,700 stars in seven months tends to fix that class of problem quickly. If you are choosing between engines rather than apps, our best local TTS models roundup and the Qwen3-TTS setup guide go deeper on the individual models Voicebox is wrapping — and the Chatterbox setup guide covers the engine most people end up using for expressive English.

---

Where these numbers come from

Repository metadata (MIT licence, created 25 January 2026, last push 9 August 2026, 50,702 stars, 6,299 forks, 646 open issues and PRs) read from the GitHub API on 18 August 2026 — star and issue counts move daily. Release version and asset sizes from the GitHub releases API for v0.5.0, which is where the CUDA-archive figures above come from rather than the docs' older estimates. All per-engine model sizes, VRAM figures, language counts, backend matrix, system requirements, cloning guidance and dictation behaviour read directly from the project's README and the docs in docs/content/docs/ on the main branch, same date. Where the README and the docs disagree — notably on Windows auto-paste — we have said so rather than picking one.

---

FAQ