VoiceStudio: Local Voice Cloning, Dubbing and TTS API (2026 Guide)

VoiceStudio (debpalash/VoiceStudio) is one of the fastest-rising repos on GitHub this week. It bundles voice cloning, voice design, video dubbing, dictation, transcription and audiobook narration into one Electron app backed by a local Python server. That same server speaks OpenAI’s audio API and MCP, so your scripts and agents can use it too.

On 28 Oct 2026 I read the README, package.json, pyproject.toml, the install, API and MCP docs, the v0.5.7 changelog and the model license registry. I wanted to separate what runs locally from what needs a network, and what the AGPL covers from what the model weights allow. I didn’t install it or generate audio: every command below is checked against the repo at v0.5.7, and every number is attributed.

1. What It Is: Stars, License and Scope

VoiceStudio describes itself as “the local voice studio: clone, design, dub, dictate, transcribe and narrate in 646 languages”, with no accounts and no API keys. In practice it’s two things in one repo: a desktop app for people who produce audio, and a headless speech service on 127.0.0.1:3900 for anything that can call an HTTP endpoint. The GitHub description pitches it as an open-source, fully local ElevenLabs alternative.

⭐

GitHub stars

~92.4K

GitHub API, 28 Oct 2026, with ~10.2K forks

⚖️

License

AGPL-3.0

Covers the app only. Model weights keep their own terms

🏷️

Latest release

v0.5.7

Published 26 Oct 2026. Adds iOS and Android previews

🌍

Languages

646

Through the default OmniVoice engine; other engines cover fewer

Why it’s trending now

The repo was created on 9 Apr 2026. v0.5.7 landed on 26 Oct 2026, a month after the previous stable release, with phone apps, support for PCs without a GPU and a redesigned UI. The agents-radar AI trends report for 27 Oct 2026 lists it at +2,297 stars in a single day. The 646 figure comes from docs/languages.md, which counts 581k hours of training data across those languages.

VoiceStudio is the app; OmniVoice is the model

The project started as OmniVoice Studio, and the old name still shows: the package is omnivoice-studio-monorepo, every setting is an OMNIVOICE_* variable, and Docker Hub hosts palashdeb/omnivoice-studio. The default engine, though, is k2-fsa/OmniVoice, a separate model with a separate license. Keep the two apart; it matters in section 6.

2. The Architecture in 4 Steps

Putting together electron/README.md, the backend’s main.py, the engine guides and the API docs, a request travels through four layers.

🖥️

1. Electron shell, built with Bun

The desktop app is Electron 44 with React 19 and electron-vite, and Bun 1.4.2 is the pinned package manager. The renderer never calls the backend directly: it calls app-relative /api paths that the main process proxies. On launch, a supervisor probes 127.0.0.1:3900, attaches to a running backend or spawns its own Python process, and restarts it if it crashes. The older Tauri app is archived at v0.5.3.

🐍

2. A local Python API

The backend is FastAPI on uvicorn, in a Python 3.11+ environment that uv builds from the locked uv.lock. It binds to 127.0.0.1 by default, and a comment in main.py says why: the backend ships no authentication, so binding to 0.0.0.0 would expose every route to your network. OMNIVOICE_API_KEY adds a bearer key for the cases where you do expose it.

🧩

3. Model Manager and engines

The default TTS engine is k2-fsa/OmniVoice, a zero-shot cloning model built on Qwen3-0.6B (about a 2.3 GB download). The Model Catalogue adds nearly twenty more, including OmniVoice GGUF and CosyVoice 3 GGUF for Vulkan GPUs, VoxCPM2, IndexTTS and KittenTTS. For speech-to-text, WhisperX and Faster-Whisper are installed by default, MLX Whisper covers Apple Silicon, and whisper.cpp is an optional engine you supply yourself. Each model row shows its license, and the app asks before it downloads anything.

📤

4. Outputs: files, API and MCP

The UI produces takes, dubbed video, MP3 or M4B audiobooks and dictated text. The same backend serves OpenAI-compatible /v1/audio/speech and /v1/audio/transcriptions routes, a WebSocket for live transcription and an MCP server mounted at /mcp/. New audio gets an invisible AudioSeal watermark by default whenever the watermark model is available.

What actually touches the network

Local by default doesn’t mean fully offline. Model weights download from Hugging Face when you install them, packaged apps check GitHub Releases for updates, and product analytics (PostHog) run only if you accept them in the first-run prompt. For dubbing, Argos and NLLB-200 translate offline, while Google, DeepL and LLM translators send your transcript out. Multi-speaker diarization uses pyannote models that are gated on Hugging Face and need a token.

3. Quickstart: Installer or From Source

There are three routes: an installer from the releases page, the official one-line script, or a source checkout. The commands come from the README, package.json, electron/README.md and docs/install/script.md at v0.5.7. I didn’t run them, so try them on a machine where a multi-gigabyte model download is fine.

Option A: the official installer script (read it first)

# The README's one-liners pipe a remote script straight into your shell:
#   curl -fsSL https://voicestudio.sh/install | sh      (macOS / Linux)
#   irm https://voicestudio.sh/install.ps1 | iex        (Windows PowerShell)

# macOS / Linux: download it, read it, then decide
curl -fsSL https://voicestudio.sh/install -o install.sh
less install.sh
sh install.sh

# Windows: save the PowerShell script and read it first
irm https://voicestudio.sh/install.ps1 -OutFile install.ps1
notepad install.ps1

Piping to sh is a trust decision

The script itself looks careful: per docs/install/script.md, it resolves the latest release, downloads the DMG or AppImage and checks it against that release’s SHA256SUMS.txt, stopping on any mismatch. But curl | sh runs whatever the server returns at that moment, unread. Downloading, reading and then running it costs you a minute. On Windows, the .exe from the releases page is the simpler path.

Option B: from source

# Prerequisites (CONTRIBUTING.md): Git, Bun, uv, ffmpeg, Rust/Cargo.
# uv provisions Python 3.11+ for you.
git clone https://github.com/debpalash/VoiceStudio.git
cd VoiceStudio
bun install
bun run setup:api   # uv sync --locked + scripts/setup.py (picks CUDA, CPU or ROCm PyTorch)
bun run dev         # Electron app: attaches to or spawns the backend on 127.0.0.1:3900

No NVIDIA GPU, or backend only

# No NVIDIA GPU? Force the CPU PyTorch wheels (electron/README.md)
OMNIVOICE_TORCH_VARIANT=cpu bun run setup:api

# Same thing in PowerShell
$env:OMNIVOICE_TORCH_VARIANT = "cpu"
bun run setup:api

# Backend only, no Electron window (root package.json script)
bun run dev:api

What the first run asks of you

The app asks before downloading any model, and the first OmniVoice generation pulls about 2.3 GB of weights. Since v0.5.7, models without a plainly commercial license, the default OmniVoice model included, ask you to accept their license once in Model Catalogue; until you do, API and MCP requests that use them return a license error. Judge speed from the second generation onward: the performance guide notes that weights load lazily on the first one.

On Windows

The v0.5.7 notes say Windows installers aren’t code-signed yet, so expect a SmartScreen warning. In PowerShell, use the .ps1 URL: the bare /install URL may return the shell script instead. Out of the box, PyTorch GPU acceleration on Windows is NVIDIA-only; AMD cards get an opt-in ROCm setup or the Vulkan-based GGUF engines.

Hardware gotchas

Intel Macs can’t run the backend because PyTorch ships no Intel-Mac wheels; they get the UI and connect to a backend on another machine. The default OmniVoice engine has a measured 6 GB VRAM floor, and below it a render can take minutes. For Docker, pin :stable, because :latest is a rolling build of main.

4. The Local API and MCP: Wiring It Into Agents

This is what makes VoiceStudio interesting for developers, not just creators. The backend implements OpenAI’s audio routes, so any SDK or framework with a configurable base URL can use your local voices. It also mounts an MCP server, so coding agents can speak, clone and transcribe.

OpenAI-compatible routes from the terminal

# Loopback calls need no key. Service root: http://127.0.0.1:3900
curl http://127.0.0.1:3900/.well-known/voicestudio-speech   # transport discovery
curl http://127.0.0.1:3900/v1/audio/voices                  # saved voices and presets

# OpenAI-compatible TTS ("model" defaults to omnivoice, "voice" to default)
curl http://127.0.0.1:3900/v1/audio/speech \
  -H "Content-Type: application/json" \
  -d '{"model":"omnivoice","voice":"default","input":"Chapter one.","response_format":"wav"}' \
  --output chapter-01.wav

# OpenAI-compatible STT with the active ASR engine, straight to subtitles
curl http://127.0.0.1:3900/v1/audio/transcriptions \
  -F file=@chapter-01.wav -F model=whisper-1 -F response_format=srt

Speech accepts up to 4,096 characters and returns MP3 by default, or opus, aac, flac, wav and 24 kHz pcm. The voice field takes a profile id or name, “default”, or an OpenAI voice name such as alloy, which maps to the engine’s default voice. Transcription returns json, text, verbose_json, srt or vtt, but not stream=true: live text goes over the WebSocket at /v1/audio/transcriptions/stream.

MCP: a Codex CLI config plus a per-agent voice

# ~/.codex/config.toml: the block the app exports under Integrations for Codex CLI
[mcp_servers.voicestudio]
url = "http://127.0.0.1:3900/mcp/"
http_headers = { "X-OmniVoice-Client-Id" = "codex-cli" }

# Bind that client id to a saved voice (loopback REST API, docs/mcp.md)
curl -X PUT localhost:3900/api/mcp/bindings \
  -H 'Content-Type: application/json' \
  -d '{"client_id":"codex-cli","label":"Codex CLI","profile_id":"<voice-profile-id>"}'

The MCP server is mounted on the running backend, so there’s nothing extra to start. Its tools are generate_speech, clone_voice, describe_voice, design_voice, transcribe, list_voices, list_personalities, list_languages and check_health. The app’s Integrations page exports ready-made configs for Claude Code (.mcp.json), Cursor and Codex, and stdio-only clients use the bundled shim, python -m backend.mcp_shim, from a source checkout.

Voice agents: pipecat and LiveKit Agents

# pipecat: its OpenAI services take a base_url (docs/agentic-voice.md)
from pipecat.services.openai.tts import OpenAITTSService
from pipecat.services.openai.stt import OpenAISTTService

tts = OpenAITTSService(
    base_url="http://localhost:3900/v1",
    api_key="not-needed-locally",   # ignored unless OMNIVOICE_API_KEY is set
    voice="<your-voice-profile-id>",
    model="omnivoice",
    sample_rate=24000,
)
stt = OpenAISTTService(base_url="http://localhost:3900/v1", api_key="not-needed-locally")

# LiveKit Agents: the same base_url through its OpenAI plugin
from livekit.plugins import openai

tts = openai.TTS(base_url="http://localhost:3900/v1", api_key="x", voice="<profile-id>")
stt = openai.STT(base_url="http://localhost:3900/v1", api_key="x")

Both snippets come from docs/agentic-voice.md, and the repo pins that request shape with contract tests that drive every route through the official openai SDK. The docs recommend pipecat for a single local agent and LiveKit when you need its WebRTC or SIP scale. Either way, VoiceStudio is the voice provider; turn-taking and the LLM stay in your own code.

Don’t put this on the internet

Loopback requests need no credential, and the MCP docs state that the transport is not authenticated. Keep remote access on a trusted LAN or behind TLS, such as Tailscale Serve. Two variables matter for agents: OMNIVOICE_MCP_BASE_PATH is the only directory the file-based tools may read from or write to, and OMNIVOICE_MCP_OUTPUT_MODE=files returns a path instead of a base64 WAV, so audio doesn’t eat your agent’s context.

5. Use Cases: Where It Earns Its Place

VoiceStudio does many things. These four are where running locally changes the result, not just the price.

🎬

Video dubbing

The dub pipeline extracts the audio, separates vocals with Demucs, transcribes with WhisperX for word-level timing, translates, then synthesizes each segment in the cloned voice and mixes it back. Argos or NLLB-200 keep translation offline, and you can paste your own translation instead.

Best for: course videos, product demos and interviews where you own the voice

📚

Audiobooks and long-form narration

The Audiobook and Stories pages split a manuscript into chapters, accept [pause 0.5s] markup and per-line voice tags, and export MP3 or M4B with embedded chapters plus a cue sheet. A stopped render can resume from its server manifest.

Best for: drafts, internal training audio and accessible versions of your own texts

🎙️

Dictation

A global shortcut records, transcribes locally with a dictation model (Whisper Tiny is the recommended default, with Sherpa-ONNX for live streaming) and inserts the text where your cursor was. Editors and scripts can stream their own microphone audio to the WebSocket instead.

Best for: dictating into an editor or an agent prompt without cloud ASR

🤖

Local TTS for voice agents

Point pipecat or LiveKit Agents at /v1 and your agent speaks in a voice you control, with no per-character bill. Through MCP, Claude Code, Codex or Cursor can speak status updates, each in its own bound voice.

Best for: prototypes, internal assistants and privacy-bound deployments

Which engine for which machine (from the engine guides)

Your hardware	Engine to start with	What the docs say
NVIDIA GPU, 6 GB+ VRAM	OmniVoice (default)	The only engine with a measured VRAM floor: 6 GB
AMD, Intel or small NVIDIA GPU	OmniVoice GGUF on Vulkan	Picks Q8_0 (~945 MB) or Q4_K_M (~659 MB) by available VRAM
Apple Silicon	OmniVoice on MPS, plus MLX engines	MLX Whisper and Parakeet MLX handle speech-to-text
CPU only	KittenTTS, or OmniVoice on CPU	KittenTTS is 25–80 MB with 8 English preset voices and no cloning

No benchmark table yet

docs/benchmarks.md ships a harness (scripts/bench_pipeline.py) and an empty results table: no verified rows yet. The performance guide’s timings come from a 16 GB M2. Until the community fills that table, measure on your own hardware before you promise anyone a turnaround time.

6. Consent, AGPL and Model Licenses

A local voice cloner removes the platform that would otherwise enforce the rules, so they become your job. Here’s what the repo and the model cards actually say.

🗣️

Consent for voice cloning

The README says to clone a voice only with its owner’s permission, and the OmniVoice model card prohibits unauthorized cloning and impersonation. The app has a consent lock: a profile becomes verified_own_voice when its owner records a spoken consent statement, and the MCP docs recommend a verified profile for any agent that speaks as you. Plain local synthesis doesn’t require it, so that check is on you.

⚖️

What AGPL-3.0 means as a service

Using the app, including commercially, is free. The Affero clause adds one obligation: if you modify VoiceStudio and let others use that modified version over a network, you must offer them its complete source under AGPL-3.0. voicestudio.sh says closed-source distribution and private hosting need separate terms; Pro, a closed-source build with a commercial license, costs $99 a year or $299 once.

🧠

The weights have their own licenses

The OmniVoice card puts its code under Apache-2.0 and its pretrained weights under CC-BY-NC, because of training data such as Emilia; its audio tokenizer adds Higgs Audio 2 and Llama 3 terms. The OmniVoice GGUF conversion is CC BY-NC 4.0. CosyVoice 3’s card says Apache-2.0, and NLLB-200 is non-commercial. VoiceStudio’s own inventory of 63 model repos marks none as cleared for commercial use.

🚫

No impersonation

Don’t clone public figures, colleagues or customers without written consent, and don’t use a clone to deceive anyone. Leave the invisible AudioSeal watermark on, and label synthetic audio where you publish it. The repo’s research notes cite Tennessee’s ELVIS Act and the EU AI Act’s Article 50 transparency duties; check the rules where you operate.

The commercial trap

For a paid audiobook or a client dub, the AGPL is rarely the blocker; the default engine’s CC-BY-NC weights are. Before you sell anything, pick an engine whose weights you have checked yourself, and keep that check on file. The Model Manager’s license notes are a starting point, not clearance.

7. When NOT to Use It

This is the part a star count won’t tell you.

✅ A good fit if...

• You produce audio from your own voice, or voices you have written consent for, and want it to stay on your machine
• You need dubbing, narration and transcription in one tool instead of three subscriptions
• You want a local, OpenAI-compatible TTS and STT endpoint for prototypes, pipecat bots or coding agents
• You have an NVIDIA GPU with 6 GB+ VRAM, Apple Silicon, or a GPU the GGUF engines can reach through Vulkan
• Your work is personal, internal or non-commercial, or you’ve cleared an engine’s license for commercial use

⚠️ Skip it (or keep it experimental) if...

• You sell the output and haven’t cleared the weights: the default engine is CC-BY-NC
• You plan to offer a modified version as a hosted product without publishing your changes: that’s AGPL territory, or a commercial license
• You need a hardened multi-tenant service: there’s no auth on loopback, and MCP has no authentication of its own
• You need low-latency speech-to-speech conversation: it’s a TTS and STT provider, not a realtime voice model, and it has no published latency numbers
• You’re on an Intel Mac or a 4 GB GPU and expect the default engine to be fast
• Your company only installs signed binaries: Windows installers aren’t code-signed yet
• You can’t verify consent for every voice you clone

My take

Install it from the releases page or from source, keep it on loopback, and judge it by one real job: a short dub or a chapter in your own voice. If the quality holds, wire the /v1 endpoints into your agent stack and run MCP in files mode. For anything you sell, swap the default engine for one whose license you’ve checked, or budget for that conversation with the model owner.

Conclusion

VoiceStudio’s pitch holds up on paper: one local app for cloning, dubbing, narration and dictation, with a backend that speaks OpenAI’s audio API and MCP, so the same voices serve your editor, your scripts and your agents. The docs are unusually candid about security boundaries, licenses and missing benchmarks.

The costs sit in the details: a 6 GB VRAM floor for the default engine, non-commercial weights behind the default voice, AGPL obligations if you host a modified version, and consent that only you can verify. Treat it like any powerful local tool: keep it on loopback, check the license of the model you actually use, and only clone voices you have a right to.

Verification stamp

Stars, forks, creation date, license and releases were checked against the GitHub API on 28 Oct 2026 (v0.5.7, published 26 Oct 2026). Commands, ports and endpoints come from the README, package.json, electron/README.md, the install, API and MCP docs and backend/api/routers/openai_compat.py at that version. Model licenses come from the OmniVoice and CosyVoice 3 cards on Hugging Face and the repo’s model license registry. I did not install the app, run the scripts or generate audio.