VoxCPM on Mac: Run It, or Use a Local Voice App?

Short answer: VoxCPM is an open source, tokenizer-free text to speech family from OpenBMB, and the current release, VoxCPM2, is a 2B parameter model for multilingual speech, voice design, and voice cloning. Murmur does not run VoxCPM, so a Mac user has to install the Python package and use Apple's MPS backend, or take one of the packaged community routes. This guide sticks to the project's own README, model cards, and docs, including the places where macOS support is thinner than a quick skim suggests.

The name covers three checkpoints, not one. VoxCPM-0.5B was the first release, VoxCPM1.5 followed in December 2025, and VoxCPM2 arrived in April 2026. They differ in parameter count, output sample rate, language coverage, and cloning modes, so a tutorial that says "VoxCPM" without a version can send you down the wrong install path.

What tokenizer-free actually means

Most modern TTS pipelines turn audio into discrete codec tokens, train a language model over that vocabulary, and decode the tokens back into sound. VoxCPM skips the vocabulary. The README describes an end-to-end diffusion autoregressive architecture that generates continuous speech representations directly from text, then decodes them with its AudioVAE. In VoxCPM2 the VAE is asymmetric: it accepts 16kHz reference audio and decodes at 48kHz, so the model handles the sample-rate jump internally instead of relying on a separate upsampler.

That design is also why the model does not fit every serving stack. The project's FAQ points high-throughput users to NanoVLLM-VoxCPM rather than a generic LLM server, because the core model produces continuous audio latents instead of discrete tokens. For a single Mac, that detail mostly matters as context: you are running a diffusion model, not a chat model with an audio head.

The three checkpoints, by the numbers

The README's comparison table is the clearest single source for version differences. These are its figures, not estimates.

One inconsistency is worth knowing before you download. The documentation's version history page lists 640M for VoxCPM 1.0 and 800M for VoxCPM1.5, and the VoxCPM1.5 model card shows a model size of 0.8B. The README table says 0.6B for 1.5. If parameter count matters to your decision, check the model card for the exact checkpoint rather than trusting a single table.

Voice design, cloning, and what each mode needs

VoxCPM2 has three generation modes, and they ask for different inputs. Voice Design needs no reference audio at all: you put a description in parentheses at the start of the text, such as "(a young woman, gentle and sweet voice)", followed by the line to synthesize. The usage guide says the instruction can be written in Chinese or English.

Controllable Voice Cloning takes a reference clip through reference_wav_path and copies its timbre. No transcript is required in VoxCPM2, and a parenthesized instruction can still steer speed, emotion, or style. Hi-Fi cloning, which the README calls Ultimate Cloning, adds the exact transcript: pass the same clip to both prompt_wav_path and reference_wav_path, and put its words in prompt_text. The usage guide notes that the control instruction is ignored in Hi-Fi mode.

The 1.x checkpoints are simpler and less flexible. They clone by continuation only, using prompt_wav_path plus prompt_text, and the usage guide says they do not support reference_wav_path. If a tutorial shows a one-argument clone call with no transcript, it is describing VoxCPM2, not 1.5 or 0.5B.

• Reference audio: the usage guide calls 5 to 30 seconds a practical range, in any format torchaudio can read.
• Cleaner reference audio preserves timbre better, and the denoiser is optional rather than automatic.
• With no reference audio, VoxCPM generates a random voice each call, so a series will not sound consistent.
• Only clone voices you own or have written permission to use. A local install removes the upload, not the consent requirement.

For a broader look at reference recordings and consent, the voice cloning guide and the private voice cloning guide cover the workflow side.

Languages and the hardware numbers the project publishes

VoxCPM2 lists 30 languages: Arabic, Burmese, Chinese, Danish, Dutch, English, Finnish, French, German, Greek, Hebrew, Hindi, Indonesian, Italian, Japanese, Khmer, Korean, Lao, Malay, Norwegian, Polish, Portuguese, Russian, Spanish, Swahili, Swedish, Tagalog, Thai, Turkish, and Vietnamese. The README also lists nine Chinese dialects, including Sichuan, Cantonese, and Hokkien, and says no language tag is needed because the model infers the language from the text.

The published speed and memory figures are NVIDIA measurements. The FAQ states that all RTF values were measured with inference_timesteps=10 and torch.compile enabled on a single RTX 4090, and the README's table gives roughly 5 GB of VRAM for 0.5B, 6 GB for 1.5, and 8 GB for VoxCPM2. Those numbers tell you the relative weight of each checkpoint. They do not tell you what an M1 or M4 will do.

The one Apple Silicon figure in the project's own material comes from the llama.cpp-omni section of the README: RTF of about 1.76 with Q8_0 weights on an M4 Pro using Metal. An RTF above 1 means generation takes longer than the audio it produces. That path is a useful reality check against the RTX 4090 numbers.

Installing VoxCPM on a Mac

The installation page supports CPU and Apple Silicon MPS, and says CUDA is optional. It recommends Python 3.10 to 3.12, with 3.10 and 3.11 the most tested, and the FAQ page warns that Python 3.14 and newer can fail on dependency incompatibilities. Use a virtual environment so a bad install does not touch the rest of your Python setup.

python3.12 -m venv .venv source .venv/bin/activate pip install voxcpm python -c "from voxcpm import VoxCPM; print('VoxCPM is ready')"

VoxCPM installation docs, checked 2026-10-19

The first generation downloads weights automatically. The docs also document a mirror for networks that cannot reach Hugging Face: set HF_ENDPOINT=https://hf-mirror.com before running any script. Weights are several gigabytes per checkpoint, and if you keep 0.5B, 1.5, and 2 side by side, budget disk accordingly.

Device selection is automatic by default, with the order CUDA, then MPS, then CPU. You can force MPS explicitly. The installation page notes that optimize=True enables torch.compile and is mainly useful on CUDA, and that on CPU, MPS, or other non-standard environments you may need optimize=False or the CLI flag --no-optimize. That flag is the most common first-run fix on a Mac.

from voxcpm import VoxCPM import soundfile as sf model = VoxCPM.from_pretrained( "openbmb/VoxCPM2", device="mps", optimize=False, load_denoiser=False, ) wav = model.generate( text="VoxCPM2 is running locally on this Mac.", cfg_value=2.0, inference_timesteps=10, ) sf.write("demo.wav", wav, model.tts_model.sample_rate)

Adapted from the VoxCPM quick start and installation docs, checked 2026-10-19

If loading a reference clip throws a torchcodec error, the FAQ says torchaudio now uses torchcodec and needs FFmpeg. On macOS the documented fix is brew install ffmpeg, or forcing the soundfile backend with torchaudio.set_audio_backend("soundfile"). The denoiser is a separate issue: it runs on CPU even when MPS is active, so load_denoiser=False saves memory when you do not need prompt enhancement.

The web demo is not included in the pip install. The quick start says to clone the repository, run pip install -e ., then python app.py. It also downloads SenseVoice-Small on first use to transcribe prompt audio, so the first launch needs network access even if the main weights are already cached.

Ways to run it on Apple Silicon

The official docs name several routes, and they do not cover the same versions. Three are covered here. Pick by checkpoint first, then by how much terminal work you want.

The MLX-Audio route is the least demanding, because it ships a CLI and an OpenAI-compatible local server. The catch is that the sources disagree about VoxCPM2: the VoxCPM docs page says support is not there yet, while MLX-Audio's README lists VoxCPM2 with mlx-community MLX conversions. Trust the MLX-Audio README for current status. If you want the 30-language model, the official package or the GGUF path is the way in. The MLX TTS overview explains what that stack changes.

Should you run it yourself?

Murmur's catalog is Kokoro (bundled), Chatterbox Turbo, Chatterbox Multilingual, Qwen3-TTS Base, Voice Design, SparkTTS, Fish Audio S2 Pro, Breeze TTS 2, and OmniVoice. VoxCPM is not on that list, and no setting will add it. If your reason for wanting VoxCPM is multilingual cloning or cloning from a short clip, several shipped models cover similar ground; the local TTS model guide compares them. If your reason is the tokenizer-free architecture or the ability to fine-tune, self-hosting is the honest answer.

What can go wrong

• MPS is supported but not guaranteed. The FAQ says torch.backends.mps.is_available() only proves the backend exists, and recommends forcing device="cpu" with optimize=False if a path fails.
• torch.compile can crash on first run. Use optimize=False or --no-optimize, which the docs list as the quick fix on non-CUDA hardware.
• The denoiser runs on CPU even under MPS. Set load_denoiser=False when you do not need prompt enhancement.
• Memory pressure: the VRAM table lists about 8 GB for VoxCPM2 on an RTX 4090. On a Mac that comes out of unified memory shared with the rest of the system, so close other heavy apps before a long run.
• Disk adds up. Each checkpoint is several gigabytes, and the web demo plus cached ASR weights add more on top.
• torchcodec errors need FFmpeg. Install it with Homebrew or switch torchaudio to the soundfile backend.
• Python 3.14 and newer may fail to install. Stay on 3.10 to 3.12.
• Long text is unstable. The usage guide lists speed-up, buzzing, out-of-memory errors from KV cache growth, and generations that never stop, and recommends splitting text into segments.
• No reference audio means a random voice every call, so a multi-part project will drift.
• Bidirectional streaming is not supported. You can stream audio out, but not feed text token by token.
• The VoxCPM docs page says MLX-Audio does not cover VoxCPM2 yet, though MLX-Audio's own README now lists it, and the docs call the integration community maintained.
• CPU inference works but is slow, which the FAQ states plainly.

License, consent, and commercial use

The repository LICENSE is Apache License 2.0, and the Hugging Face cards for VoxCPM2, VoxCPM1.5, and VoxCPM-0.5B all list apache-2.0. The README describes the weights and code as fully open source and free for commercial use, and the VoxCPM2 card repeats that. Apache-2.0 allows commercial use and modification, subject to its notice and attribution conditions.

Read the card for the exact checkpoint, though. The VoxCPM-0.5B and VoxCPM1.5 cards still carry a line saying the model is released for research and development and that the authors do not recommend production or commercial use without rigorous testing and safety evaluation. The VoxCPM2 card drops that framing but still recommends testing for your use case. A license and a model card recommendation are different things, and both matter. The open source model license checklist walks through the rest.

Voice cloning adds a second layer that no license settles. Use recordings you made, recordings you licensed, or recordings you have written permission to imitate. Do not clone a public figure or a private person to imply endorsement, and do not use a cloned voice for impersonation, fraud, or disinformation. The VoxCPM2 card forbids impersonation, fraud, and disinformation and asks that generated content be labeled as AI-generated.

Frequently asked questions