Differences Between VoxCPM2, VoxCPM1.5, and VoxCPM-0.5B: Architecture and Capabilities

VoxCPM2 (~2B parameters) delivers the highest quality multilingual TTS with full voice cloning and voice design control, VoxCPM1.5 (~0.8B) offers similar features with reduced fidelity for moderate compute budgets, while VoxCPM-0.5B (~0.5B) supports only basic text-to-speech without reference-audio cloning for edge deployment.

The OpenBMB/VoxCPM repository ships three officially released model checkpoints that share the same underlying transformer architecture but differ significantly in parameter scale, training data coverage, and advanced capabilities. Understanding these distinctions ensures you select the optimal checkpoint for your specific text-to-speech requirements, whether prioritizing voice cloning accuracy, inference latency, or hardware constraints.

Model Specifications and Parameter Scales

VoxCPM2 (~2 Billion Parameters)

The VoxCPM2 model represents the flagship release, built on a 2 billion parameter MiniCPM-4 backbone. According to the repository documentation, this variant supports 30 languages plus 9 Chinese dialects (trained on approximately 48 hours of multilingual audio) and outputs native 48 kHz audio quality. It provides tokenizer-free TTS, advanced voice design through natural language instructions, and controllable voice cloning using reference audio samples.

This variant requires a GPU with ≥8GB VRAM for reasonable inference latency and excels when maximum naturalness and multilingual support are required.

VoxCPM1.5 / I.S (~0.8 Billion Parameters)

VoxCPM1.5 (referred to internally as "I.S" or the 0.8B variant) utilizes the same language coverage as VoxCPM2 but was trained on a smaller dataset. As implemented in src/voxcpm/model/voxcpm.py, this checkpoint shares the LocEnc → TSLM → RALM → LocDiT four-stage pipeline but operates with reduced model capacity.

It supports both voice design and reference-audio cloning, though with slightly lower fidelity and slower inference compared to the 2B model. This variant serves as the optimal middle ground when compute resources are limited but voice cloning capabilities remain necessary.

VoxCPM-0.5B / O.SB (~0.5 Billion Parameters)

The VoxCPM-0.5B model (designated "O.SB" in source references) is the lightweight edge-deployment option. With only ~0.5B parameters, it covers a core set of high-resource languages rather than the full multilingual suite. Critically, this variant lacks the fine-grained conditioning mechanisms required for reference-audio cloning, supporting basic TTS only with reduced naturalness.

As noted in the codebase, this model is ideal for CPU-only environments or latency-critical applications where model size matters more than cloning capabilities.

Shared Architecture and Implementation Differences

Despite their different sizes, all three variants share identical core modules. The repository does not maintain separate source branches for each version; instead, they are differentiated through configuration and parameter count.

• VoxCPM2 implementations reside in src/voxcpm/model/voxcpm2.py (VoxCPM2Model class)
• VoxCPM1.5 and 0.5B share src/voxcpm/model/voxcpm.py (VoxCPMModel class)

Both classes inherit from the same nn.Module base and utilize identical components: LocEnc (local encoder), LocDiT (local diffusion transformer), AudioVAE V2 (continuous latent audio representation), and the MiniCPM-4 language model backbone. The only runtime differences are the configuration JSON files specifying model_name, feat_dim, and layer dimensions.

Capability Matrix: Voice Design vs Voice Cloning

Voice Design (All Variants)

All three models support voice design through natural language instructions describing speaker characteristics, tone, and speaking style.

Reference-Audio Voice Cloning (2B and 1.5B Only)

Controllable voice cloning using reference audio requires the larger model capacity found in VoxCPM2 and VoxCPM1.5. The command-line interface in src/voxcpm/cli.py validates the --reference-audio flag specifically against VoxCPM2Model instances, though the 1.5B checkpoint shares this capability through the same class hierarchy.

The 0.5B model cannot perform reference-based cloning and will raise a ValueError if cloning is attempted.

Code Examples for Each Variant

Loading Specific Model Versions

from voxcpm import VoxCPM

# Load the 2B model (VoxCPM2)

v2 = VoxCPM.from_pretrained("openbmb/VoxCPM2")

# Load the 1.5B checkpoint (VoxCPM I.S)

v1_5 = VoxCPM.from_pretrained("openbmb/VoxCPM1.5")

# Load the 0.5B checkpoint (VoxCPM-0.5B)

v0_5 = VoxCPM.from_pretrained("openbmb/VoxCPM-0.5B")

The VoxCPM wrapper automatically instantiates the correct underlying class (VoxCPM2Model vs VoxCPMModel) based on the config.json file present in each checkpoint.

Voice Design Across All Models

text = "Hello, welcome to VoxCPM."
instruction = "(young female, gentle tone)"

# Works on all three variants

audio_v2 = v2.synthesize(text, instruction)
audio_v1_5 = v1_5.synthesize(text, instruction)
audio_v0_5 = v0_5.synthesize(text, instruction)

Reference-Audio Cloning Limitations

ref_wav = "reference_speaker.wav"
text = "This is a cloned utterance."

# ✅ Supported on 2B and 1.5B

audio = v2.clone(text, reference_wav_path=ref_wav)
audio = v1_5.clone(text, reference_wav_path=ref_wav)

# ❌ Raises ValueError on 0.5B model

# audio = v0_5.clone(text, reference_wav_path=ref_wav)

LoRA Fine-Tuning Compatibility

All three variants support LoRA fine-tuning through the same training utilities:

from voxcpm.training import train_finetune_lora

# Fine-tune the 2B model

train_finetune_lora(
    model_id="openbmb/VoxCPM2",
    lora_rank=8,
    dataset="my_speech_dataset",
    output_dir="./lora_ckpt_v2"
)

# Fine-tune the 0.5B model (faster, lighter)

train_finetune_lora(
    model_id="openbmb/VoxCPM-0.5B",
    lora_rank=4,
    dataset="my_speech_dataset",
    output_dir="./lora_ckpt_v0_5"
)

Deployment and Hardware Considerations

• VoxCPM2: Requires high-end GPU (≥8GB VRAM), delivers best-in-class naturalness and multilingual support
• VoxCPM1.5: Suitable for mid-range GPUs, maintains cloning capabilities with modest quality reduction
• VoxCPM-0.5B: Optimized for edge devices, CPU inference, or rapid prototyping where latency outweighs voice cloning requirements

Summary

• VoxCPM2 (~2B) is the premium choice supporting full voice cloning, voice design, and 30+ languages at native 48kHz quality
• VoxCPM1.5 (~0.8B) offers reference-audio cloning and voice design with reduced fidelity for resource-constrained environments
• VoxCPM-0.5B (~0.5B) provides basic TTS only, lacking reference cloning but enabling edge deployment
• Architecture: All variants share AudioVAE V2, LocDiT, and MiniCPM-4 backbone code in src/voxcpm/model/ files
• Fine-tuning: LoRA support is universal across all three model sizes

Frequently Asked Questions

Can I use voice cloning with the VoxCPM-0.5B model?

No. The 0.5B model lacks the parameter capacity and conditioning mechanisms required for reference-audio voice cloning. According to the source code in src/voxcpm/cli.py, the --reference-audio flag is validated against model capabilities, and attempting to call .clone() on a 0.5B instance will raise a ValueError. You must use VoxCPM2 or VoxCPM1.5 for voice cloning functionality.

Are VoxCPM1.5 and VoxCPM-0.5B separate codebases or just smaller checkpoints?

They are simply smaller checkpoints of the same architecture, not separate branches. Both the 1.5B and 0.5B models utilize src/voxcpm/model/voxcpm.py (VoxCPMModel class), while the 2B model uses src/voxcpm/model/voxcpm2.py (VoxCPM2Model class). The differences lie only in the model weights and configuration parameters (hidden dimensions, layer counts) loaded at runtime.

Which model is best for edge device deployment?

VoxCPM-0.5B is explicitly designed for edge deployment. With only ~0.5 billion parameters, it can run on CPU-only environments or GPUs with minimal VRAM. However, this comes at the cost of reduced language coverage (core high-resource languages only) and the complete absence of reference-audio cloning capabilities.

Is LoRA fine-tuning supported on all three model variants?

Yes. The training utilities in the repository support LoRA fine-tuning for VoxCPM2, VoxCPM1.5, and VoxCPM-0.5B using the same train_finetune_lora() API. The smaller variants fine-tune faster and require less memory, making them suitable for experimentation before scaling to the full 2B model.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}