VoxCPM2 on RTX 5070 Ti: 30-Language 48kHz Voice Cloning in ~8 GB VRAM

What You'll Build

A local text-to-speech pipeline using OpenBMB's VoxCPM2 — a 2B-parameter tokenizer-free, diffusion-autoregressive TTS model built on the MiniCPM-4 backbone. It synthesises 48 kHz studio-quality audio in 30 languages, supports zero-shot voice cloning from a short reference clip, and adds "voice design" — generating a voice from a natural-language description like "A young woman, gentle and sweet voice". VoxCPM2 is the successor to VoxCPM (the original 0.5B model): the v2 jump moves to 2B parameters, upgrades audio output from 16 kHz to 48 kHz (via AudioVAE V2's built-in super-resolution), and expands language coverage to 30 languages plus several Chinese dialects.

Hardware data: RTX 5070 Ti (16 GB VRAM) · ~8 GB VRAM requirement per the official model card leaves ~8 GB free for other workloads · See benchmark data

ℹ️ Blackwell note. The RTX 5070 Ti is an sm_120 (Blackwell GB203) card. The default pip install torch from a CUDA 12.x index does not ship Triton kernels with native sm_120 support, which causes silent fallbacks or crashes — so the install below pins a CUDA 12.8+ / 13.0 PyTorch wheel. This is the one place where the 5070 Ti recipe differs from the same model on older (Ada/Ampere) cards.

Requirements

Component	Minimum	Tested
GPU	8 GB VRAM (model card lists `VRAM: ~8 GB` on the official HF page and confirms in the Quick Start FAQ VRAM & RTF reference table)	RTX 5070 Ti (16 GB GDDR7, Blackwell GB203 sm_120)
RAM	8 GB	—
Storage	~5 GB (`model.safetensors` 4.58 GB + `audiovae.pth` 0.38 GB on the HF repo)	—
Software	Python ≥ 3.10 (<3.13), PyTorch ≥ 2.5.0, CUDA ≥ 12.0 (source) — CUDA 12.8+/13.0 on Blackwell	—

Installation

1. Install a Blackwell-compatible PyTorch first

On sm_120 cards, install PyTorch from a CUDA 12.8 (cu128) or newer index before the voxcpm package, so the correct CUDA build wins over any transitive CPU-only torch that dependencies might pull in:

pip install torch torchaudio --index-url https://download.pytorch.org/whl/cu128

The motivation is documented on the canonical repo: PR #250 explains that CUDA 12.x does not ship Triton wheels with native sm_120 support — causing silent fallbacks or crashes on RTX 5000-series (Blackwell) GPUs — and that a CUDA 13.0 toolchain resolves this and lets VoxCPM2 run at full speed on the RTX 5070/5080/5090. A CUDA 13.0 (cu130) wheel works equally well if you prefer the newest toolchain.

2. Install the `voxcpm` package

The canonical install is the published PyPI package, identical across both the Hugging Face model card and the official OpenBMB/VoxCPM GitHub README:

pip install voxcpm

3. (Optional) Install from source for the web demo

If you want the Gradio playground, clone the repo and install in editable mode:

git clone https://github.com/OpenBMB/VoxCPM.git
cd VoxCPM
pip install -e .

Source: VoxCPM 2 Quick Start docs.

4. (Optional) Pre-download model weights

Weights download on first inference automatically, but you can pre-fetch them to control where they land:

from huggingface_hub import snapshot_download
snapshot_download("openbmb/VoxCPM2")

Running

Python — basic synthesis

import soundfile as sf
from voxcpm import VoxCPM

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)

Two notes on this snippet, both from the HF model card and the Quick Start docs:

load_denoiser=False skips loading the optional ZipEnhancer denoiser. Keep it off unless you plan to use voice cloning with prompt/reference audio — the denoiser is only needed to clean up reference clips, and per the FAQ it runs on CPU even when CUDA is active.
The sample rate is read off the loaded model (model.tts_model.sample_rate) rather than hardcoded — VoxCPM2 emits 48 kHz audio, up from VoxCPM v1's 16 kHz.

Higher inference_timesteps trades speed for quality.

Python — voice design (new in v2)

VoxCPM2 lets you describe the desired voice in natural language inside the text itself, as shown on the HF card:

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

Python — zero-shot voice cloning

Supply a short reference clip plus its transcript and the model will mimic the speaker's timbre, accent, and pacing. The HF card covers both "Controllable Cloning" and "Ultimate Cloning" variants via the reference_wav_path / prompt_wav_path parameters. For cloning, you'll generally want load_denoiser=True so the reference audio is cleaned up before voiceprint extraction.

Gradio web demo

If you installed from source (step 3), launch the local UI:

python app.py

Results

Speed: Not yet community-benchmarked on the RTX 5070 Ti — no source names this card. The official model card publishes a Real-Time Factor (RTF) of ~0.30 standard / ~0.13 with the Nano-VLLM accelerated path, but those figures are measured on an NVIDIA RTX 4090 (Ada), a different architecture — treat them as a reference point, not a 5070 Ti prediction. The 5070 Ti's RTF could land either side of the 4090's: it has fewer compute cores (8960 vs the 4090's 16384) but Blackwell-native tensor cores, and a community report on the canonical repo (Issue #282) notes that early Blackwell builds ran VoxCPM2 inference below a 4090's throughput, suggesting Blackwell tuning was still maturing at that time. Track /check/voxcpm2/rtx-5070-ti and share your own measurement via /contribute when it lands.
VRAM usage: ~8 GB for the stock bf16 path, per the official model card's Model Details table and independently confirmed in the VoxCPM 2 FAQ VRAM & RTF reference table. That leaves about half of the RTX 5070 Ti's 16 GB free for stacking another model.
Quality notes: 48 kHz studio-quality output, tokenizer-free diffusion-autoregressive architecture (LocEnc → TSLM → RALM → LocDiT) on the MiniCPM-4 backbone, 30 supported languages plus several Chinese dialects, Apache-2.0 license (free for commercial use). Audio path is 16 kHz reference → AudioVAE V2 → 48 kHz output per the official model card architecture section. MLX 8-bit / 4-bit variants exist under the mlx-community namespace for Apple Silicon, but on NVIDIA the stock bf16 path is the supported route.

For the full benchmark data, see /check/voxcpm2/rtx-5070-ti.

Making use of the 16 GB headroom

The model needs ~8 GB; the RTX 5070 Ti has 16 GB. That spare ~8 GB is the real reason to run VoxCPM2 on this card rather than an 8 GB one — you can colocate a second workload on the same GPU instead of leaving half the VRAM idle:

Pair it with a small LLM — a 7B-class model at Q4 (~4–5 GB) fits comfortably alongside VoxCPM2, letting you run a text-generation → speech pipeline on one card.
Batch a voice-cloning queue — keep load_denoiser=True and the SenseVoice-Small ASR helper (downloaded by the web demo on first use) resident together for an end-to-end clone-from-clip service.
Keep optimize=True warm — torch.compile + CUDA Graphs (the default) reserves extra working memory for compiled kernels; the headroom means you don't have to trade that away to fit other workloads.

Troubleshooting

Crashes or "not compatible with the current PyTorch installation" on the RTX 5070 Ti

This is the Blackwell (sm_120) kernel-availability gap. A is not compatible with the current PyTorch installation error, or silent fallbacks/crashes after load, means torch was installed without sm_120 kernels. The fix is to (re)install PyTorch from a CUDA 12.8+ index as shown in Installation step 1; on Issue #258 a VoxCPM collaborator advised a 5000-series user to upgrade both CUDA and torch to resolve exactly this incompatibility. PR #250 documents that CUDA 13.0 is the cleanest toolchain for native sm_120 support.

`torch.compile` / Triton errors during warm-up

Per the VoxCPM 2 FAQ, torch._dynamo.exc.Unsupported errors (often mentioning einops) or Triton import failures during warm-up come from mismatched PyTorch/Triton versions. Quick fix — skip torch.compile entirely:

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

For a permanent fix, pin matching versions: the FAQ's compatibility table maps PyTorch 2.4/2.5 → Triton 3.1, 2.6 → 3.2, 2.7 → 3.3, 2.8 → 3.4. On Windows, Issue #258 reports that optimize=True (torch.compile + CUDA Graphs) can also hit a thread-local-storage assertion after a few generations when inference runs inside Gradio's background worker thread — optimize=False sidesteps it. For maximum stability on Blackwell, a VoxCPM collaborator on that thread recommends the Nano-VLLM accelerated runtime as an alternative.

`Could not load libtorchcodec` when using reference audio

The FAQ recommends installing FFmpeg system-wide and pip install torchcodec, or forcing torchaudio.set_audio_backend("soundfile") if torchcodec cannot be installed. This only matters when you pass reference/prompt audio for voice cloning.