VoxCPM2 Is Apache-2.0: Voice Cloning You Can Sell

Short answer: VoxCPM2 is Apache-2.0 — commercial use, no attribution clause, no revenue ceiling — and it is the most capable voice-cloning model that can say that. 2B parameters, 30 languages plus 9 Chinese dialects, 48kHz output, ~8GB VRAM, and a real-time factor of ~0.30 on an RTX 4090 (~0.13 with NanoVLLM serving), all per OpenBMB's own documentation. Install is one line: pip install voxcpm.

If you have been circling this space looking for something you can put inside a paid product, the licence is the entire headline. Nearly every open model that clones voices well arrives wrapped in a research licence, a non-commercial clause, or a "contact us above $X revenue" gate. VoxCPM2 does not.

Two honest notes before the detail. First, this is not a this-week release — the Hugging Face repo was created on 3 April 2026 and commits were still landing the day we wrote this. It is a franchise under active development, and 453,089 downloads say the demand is sustained rather than a spike. Second, every performance number on this page is OpenBMB's, measured on their hardware. We have not yet run VoxCPM2 on our own 8GB card; where that matters, it is flagged.

---

The Licence, First

Apache-2.0. Free for commercial use. That is the rarest property in this entire category, and it is why this page exists.

The model card states it twice — once in the highlights ("Fully Open-Source & Commercial-Ready — Apache-2.0 license, free for commercial use") and once in the licence section. The Hugging Face repo metadata carries license: apache-2.0. There is no separate community licence file bolting on extra conditions, which is the trap you have to check for these days.

Here is how that compares against the models people actually weigh it against. These are the licence fields we read off each repo directly:

Two things that honesty requires us to say. VoxCPM2 is not the only permissive option — Chatterbox is MIT and also clones voices, and Kokoro is Apache-2.0 if you only need fixed voices. And for a couple of other models people ask about, including k2-fsa's OmniVoice and IndexTTS-2, we could not find a licence field on the repository at all, which is not the same as "restricted" and not the same as "safe". Do not deploy against a blank licence field; ask the maintainers.

Where VoxCPM2 wins is the combination: permissive licence and 30 languages and reference-audio cloning and 48kHz output and text-driven voice design. Nothing else on that table has all five.

One boundary worth stating plainly, because the licence does not cover it: Apache-2.0 gives you rights to the model, not to someone's voice. OpenBMB's own limitations section says use for impersonation, fraud or disinformation is "strictly forbidden" and that AI-generated content should be clearly labelled. Consent for the reference clip is your problem, and in several jurisdictions it is a legal one. If licence terms are why you are here, our breakdown of the XTTS/Coqui commercial licence mess is the cautionary version of this story.

---

Will It Fit? Per-VRAM Table

~8GB is the official figure for VoxCPM2, and it is a floor rather than a comfort zone. The VRAM column below comes from OpenBMB's own reference table in the VoxCPM documentation; the rest is our reading of what each tier means in practice.

Download size is small by 2026 standards. The official repo is two files that matter: model.safetensors at 4.58GB (bf16, 2,290,004,544 parameters per the repo metadata) and audiovae.pth at 0.377GB — under 5GB total. Compare that to the tens of gigabytes a modern image or music model wants, and TTS starts to look like the cheapest capable thing you can host. Our MiniMax Music 3 guide is the other end of that scale: a 57GB download for the same "make audio locally" job.

If you are choosing a card around this workload rather than fitting it to what you own, the hardware hub has the wider picture — but honestly, TTS is the one modern workload where a 12GB card is genuinely enough.

---

Setup in Three Commands

pip install voxcpm is the whole install. The first from_pretrained call downloads the weights.

Requirements, from the official installation page: Python 3.10–3.12 (3.10–3.11 most tested), PyTorch 2.5.0 or higher, and CUDA 12.0+ optional — the docs are explicit that "CUDA is not required for CPU inference or Apple Silicon MPS usage".

pip install voxcpm

Then the minimal generate, straight from the model card:

from voxcpm import VoxCPM
import soundfile as sf

model = VoxCPM.from_pretrained("openbmb/VoxCPM2", load_denoiser=False)

wav = model.generate(
    text="VoxCPM2 brings multilingual support, creative voice design, and controllable voice cloning.",
    cfg_value=2.0,
    inference_timesteps=10,
)
sf.write("output.wav", wav, model.tts_model.sample_rate)

There is also a CLI, which defaults to openbmb/VoxCPM2:

voxcpm design --text "Hello from VoxCPM!" --output out.wav

voxcpm clone --text "This is a cloned voice sample." \
  --reference-audio path/to/voice.wav --output out.wav --denoise

And streaming, if you are wiring this into an assistant rather than batch-rendering files:

import numpy as np
chunks = [c for c in model.generate_streaming(text="Streaming is easy with VoxCPM!")]
sf.write("streaming.wav", np.concatenate(chunks), model.tts_model.sample_rate)

Three setup landmines the docs call out, so you do not lose an evening:

• Windows + Triton. Python int too large to convert to C long on load is a Triton-on-Windows problem. Either install triton-windows, match your Triton version to your PyTorch version, or just pass optimize=False to skip torch.compile entirely — slower, functionally correct.
• Could not load libtorchcodec when you use reference audio. torchaudio ≥ 2.9 defaults to torchcodec, which wants FFmpeg. Install FFmpeg system-wide (brew install ffmpeg / apt install ffmpeg), or force the soundfile backend.
• CUDA Graphs and threads do not mix. With torch.compile on (the default), running inference from a background thread throws AssertionError in cudagraph_trees. Use optimize=False for multi-threaded code, or NanoVLLM-VoxCPM for real concurrent serving. For Gradio apps the docs suggest default_concurrency_limit=1.

Also worth knowing: VoxCPM2 is not compatible with vLLM or lmdeploy. The docs explain why — it is a diffusion architecture producing continuous audio latents, not discrete tokens. NanoVLLM-VoxCPM is the supported high-throughput path.

---

The Three Cloning Modes (Plus Voice Design)

Four ways to get a voice out of it, in increasing order of how much you have to give it.

1. Voice Design — no reference audio at all. Put a description in parentheses at the start of the text:

wav = model.generate(
    text="(A young woman, gentle and sweet voice)Hello, welcome to VoxCPM2!",
    cfg_value=2.0, inference_timesteps=10,
)

This is the mode that matters commercially. A designed voice has no real person behind it — no consent question, no likeness rights, nothing to renegotiate when your narrator raises their rate.

2. Basic cloning — one reference clip.

wav = model.generate(text="This is a cloned voice.", reference_wav_path="speaker.wav")

3. Controllable cloning — clip plus a style instruction. Same parenthetical trick, applied on top of a cloned timbre:

wav = model.generate(
    text="(slightly faster, cheerful tone)This is a cloned voice with style control.",
    reference_wav_path="speaker.wav", cfg_value=2.0, inference_timesteps=10,
)

4. Ultimate cloning — clip plus its exact transcript. This reframes the job as audio continuation, which is why it is the highest-fidelity path:

wav = model.generate(
    text="This is an ultimate cloning demonstration.",
    prompt_wav_path="speaker_reference.wav",
    prompt_text="The transcript of the reference audio.",
    reference_wav_path="speaker_reference.wav",
)

OpenBMB's tip: pass the same clip to both prompt_wav_path and reference_wav_path for highest similarity. Getting the transcript exactly right is the whole trick — a sloppy transcript is worse than no transcript, because the model is trying to continue audio it has been told the wrong words for.

A quality note from the docs' own limitations, and it is the honest one: Voice Design and style control results vary between runs, and OpenBMB recommend generating 1–3 times to get what you want. Budget for re-rolls. If you want the general technique rather than this specific model, our local voice cloning guide covers reference-clip preparation, which is where most bad clones actually come from.

---

Speed: What RTF 0.30 Actually Means

Faster than realtime by roughly 3x on a 4090, and about 7x with the serving stack. OpenBMB's reference table, reproduced as published:

Read the conditions attached, because they matter: all values measured with inference_timesteps=10, torch.compile enabled, on a single RTX 4090, at concurrency 1.

RTF 0.30 means one minute of speech takes about eighteen seconds to synthesise. For an audiobook that is roughly a 3x-realtime render — a ten-hour book in something over three hours of compute, single-stream. See our local audiobook generator walkthrough for the pipeline around that.

Note the counter-intuitive line in that table: the smaller models are faster, and VoxCPM2 is the slowest of the three. You pay RTF 0.30 versus 0.15 for the 30 languages, the 48kHz output and the better cloning. If your product is English-only and latency-critical, VoxCPM 1.5 may genuinely be the better engine.

What we could not verify: RTF on an 8GB card, real peak VRAM under load as opposed to the docs' round figure, and whether the MLX quants hold quality. All of those need our own hardware and a stopwatch, and this page gets updated when we have them.

---

Apple Silicon, CPU and Quants

Apple Silicon is supported — properly, in the official docs, not as a community hack. device="auto" falls back cuda → mps → cpu, and you can force any of them.

model = VoxCPM.from_pretrained("openbmb/VoxCPM2", device="mps")
# if MPS throws at runtime:
model = VoxCPM.from_pretrained("openbmb/VoxCPM2", device="cpu", optimize=False)

Two caveats direct from the docs. The ZipEnhancer denoiser runs on CPU even when MPS is active — set load_denoiser=False if you are not enhancing reference audio, which saves memory. And torch.backends.mps.is_available() being true does not guarantee every inference path works on MPS; OpenBMB tell you to fall back to CPU explicitly if you hit an error. optimize=True (torch.compile) is described as primarily useful on CUDA — use --no-optimize on Mac. Which Mac to buy for this kind of work is covered in our Apple Silicon buying guide.

There is a real ecosystem of conversions, which is itself a signal of how much this model gets deployed. Sizes read from the repo listings:

All four are community uploads, not OpenBMB releases, and all carry apache-2.0 in their metadata — consistent with the base model. The docs' own ecosystem page also lists VoxCPM.cpp, VoxCPM-ONNX, an Apple Neural Engine port, an RKNN2 build for Rockchip boards, a Rust binding, and three separate ComfyUI nodes. We have not tested any of them, and quantised TTS degrades in ways that are easy to miss on one sample — listen to sibilants and long vowels before you commit.

AMD users: there is a community-reported WSL2 + ROCm path in the FAQ, but the docs are clear it is not a primary tested environment and needed two workarounds (patching torchaudio's codec loader, and optimize=False).

---

Honest Limitations

From OpenBMB's own limitations list plus what falls out of the docs:

• Voice Design and style control are non-deterministic. Generate 1–3 times to get the take you want. This is stated, not inferred.
• Language quality is uneven. 30 languages are supported; performance "varies across languages depending on training data availability". Assume English and Chinese are the strong end.
• Long or highly expressive inputs can destabilise it. Chunk your text.
• Max sequence length is 8,192 tokens, LM token rate 6.25 Hz — the architecture table on the card.
• No vLLM/lmdeploy. Diffusion architecture; use NanoVLLM-VoxCPM or nothing.
• torch.compile is fragile off the happy path — Windows Triton, background threads, MPS, ROCm all want optimize=False.
• The licence does not grant you consent. Cloning a real voice is governed by law and ethics, not by Apache-2.0.

---

vs Chatterbox, Kokoro and XTTS

Better than Kokoro at anything involving a specific voice. Better licensed than Fish S2 or the research-licensed pack. Genuinely contested against Chatterbox.

vs Kokoro-82M — not really a competition, they solve different problems. Kokoro is 82M parameters, Apache-2.0, runs on a potato and sounds great on its fixed voice set. It does not clone. If you need one narrator forever and want it fast and cheap, Kokoro is still the right answer. If you need this voice, or 30 languages, VoxCPM2.

vs Chatterbox (MIT) — the closest fight, and the one where we will not pretend certainty without a listening test. Chatterbox is MIT, which is if anything marginally more permissive than Apache-2.0, and it is the most-downloaded open cloning model by a distance. VoxCPM2's arguments are 48kHz output via AudioVAE V2's built-in super-resolution (accepting 16kHz reference audio), 30 languages, text-driven voice design, and a documented fine-tuning path with 5–10 minutes of audio. Our Chatterbox setup guide and the three-way comparison are the starting points if you want to A/B them yourself — which you should, on your own reference clips.

vs XTTS-v2 — this is the one VoxCPM2 straightforwardly replaces. XTTS was the default open cloning model for years and its licence made it commercially unusable for most people, which we covered in detail here. VoxCPM2 is newer, higher sample rate, better licensed, and actively maintained. If you are still on XTTS for commercial work, this is your exit.

vs Fish S2 Pro and Supertonic-3 — the licence decides it. Fish's repo carries a fish-audio-research-license; Supertonic-3 is OpenRAIL, which attaches use restrictions. Both may sound excellent. Neither is a thing you casually build a paid product on. For the whole field ranked, see best local TTS models.

---

Verdict

1. The licence is the product. Apache-2.0 with real cloning, 30 languages and 48kHz output is a combination nothing else on the shortlist offers. If licensing was blocking you, it is unblocked.
2. ~8GB VRAM, ~5GB of weights, one pip command. This is the cheapest capable model in modern local AI. A 12GB card runs it comfortably.
3. RTF ~0.30 on a 4090, ~0.13 with NanoVLLM — OpenBMB's numbers, at concurrency 1, torch.compile on. Faster than realtime with room to spare; unmeasured by us on smaller cards.
4. Use Voice Design for commercial work wherever you can. A designed voice has no consent problem attached. Save cloning for voices you have the rights to.
5. It is not the only permissive option. Chatterbox is MIT and clones; Kokoro is Apache-2.0 and does not. Test all three on your own clips before you standardise.

The interesting thing about VoxCPM2 is not that it is the best-sounding TTS in the world — that is arguable and will change next month. It is that a model this capable shipped under a licence with no strings, from a lab that keeps committing to it four months later. That is the part that makes it safe to build on.

---

FAQ