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

> Explore VoxCPM2, VoxCPM1.5, and VoxCPM-0.5B differences. Discover their architecture and capabilities from OpenBMB for advanced multilingual TTS, voice cloning, and edge applications.

- Repository: [OpenBMB/VoxCPM](https://github.com/OpenBMB/VoxCPM)
- Tags: deep-dive
- Published: 2026-04-10

---

**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`](https://github.com/OpenBMB/VoxCPM/blob/main/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`](https://github.com/OpenBMB/VoxCPM/blob/main/src/voxcpm/model/voxcpm2.py) (`VoxCPM2Model` class)
- **VoxCPM1.5 and 0.5B** share [`src/voxcpm/model/voxcpm.py`](https://github.com/OpenBMB/VoxCPM/blob/main/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`](https://github.com/OpenBMB/VoxCPM/blob/main/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

```python
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`](https://github.com/OpenBMB/VoxCPM/blob/main/config.json) file present in each checkpoint.

### Voice Design Across All Models

```python
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

```python
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:

```python
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`](https://github.com/OpenBMB/VoxCPM/blob/main/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`](https://github.com/OpenBMB/VoxCPM/blob/main/src/voxcpm/model/voxcpm.py) (`VoxCPMModel` class), while the 2B model uses [`src/voxcpm/model/voxcpm2.py`](https://github.com/OpenBMB/VoxCPM/blob/main/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.