mlboydaisuke/VoxCPM-0.5B-CoreAI

Core AI is Apple's on-device ML runtime in iOS 27 / macOS 27 and the successor to Core ML: PyTorch models are exported with Apple's coreai-torch (LLMs: coreai.llm.export) into .aimodel bundles that run on the GPU or the Neural Engine, e.g. Qwen3-8B 4-bit decodes at 94 tok/s on an M4 Max GPU, MLX 90 under the same protocol (apple-silicon-llm-bench, macOS 27 beta 26A5353q, 2026-06-11).

<!-- gen-cards:devicemark begin (managed by scripts/gen-cards + tools/devicemark_row.py — edit cards.json, not this block) --> This model has no row on DeviceMark, the on-device LLM leaderboard. <!-- gen-cards:devicemark end -->

VoxCPM-0.5B — Core AI (on-device, iPhone + Mac)

OpenBMB's **VoxCPM-0.5B** converted to Apple's Core AI engine, running fully on-device — iPhone (Apple Neural Engine / GPU, AOT-compiled) and Apple-silicon Mac. No network, no server.

VoxCPM is not a classic vocoder TTS: it pairs a MiniCPM4 language-model backbone with a LocDiT flow-matching diffusion head and an AudioVAE, generating speech through a continuous (token-rate) diffusion loop. This repo ships the whole stack as Core AI model bundles plus the small host-side glue the runtime needs.

• —Output: 16 kHz mono
• —License: Apache-2.0 (commercial-friendly), inherited from the base model
• —Quantization: weight-only int8 on the two LM backbones (the size driver); the diffusion decoder, feature encoder, and AudioVAE stay fp16 — the continuous-feedback path is quantization-sensitive (the same split mlx-community/VoxCPM2 uses).

<!-- gen-cards:use-it begin id=voxcpm-0.5b (managed by scripts/gen-cards — edit cards.json / QuickStart.swift, not this block) --> Earlier VoxCPM 0.5B capture on iPhone 17 Pro in the zoo's coreai-audio app. This is separate from the release's Mac entry check linked below; it does not validate that package on iPhone.

Use it

New to Core AI? [Start with CoreAIKit 0.4.1](https://github.com/john-rocky/coreai-kit#readme). Follow its requirements and first-run steps for qwen3-0.6b, then open the same release's ChatDemo. The README records the tested OS/SDK and download size; model and device coverage is stated per example.

⚡ One line — this model is the default behind the kit's task op (import CoreAIOps; no session, no model plumbing, downloads on first use):

let audio = try await CoreAI.speak(text)

Every op, one shape — Cookbook.

▶️ Run it (source) — the Speak runner (GUI + CLI, one app for every text-to-speech model in the catalog):

git clone --branch 0.4.1 --depth 1 https://github.com/john-rocky/coreai-kit
export DEVELOPER_DIR=/Applications/Xcode-27.0.0-Beta.5.app/Contents/Developer
open -a /Applications/Xcode-27.0.0-Beta.5.app coreai-kit/Examples/Speak/Speak.xcodeproj
# → Run, then pick "VoxCPM 0.5B" in the model picker

# agents / headless (macOS):
cd coreai-kit/Examples/Speak
swift run -c release speak-cli --model voxcpm-0.5b --text "Hello from Core AI." --output hello.wav

Use Xcode build 27A5237l from the release's .xcode-pin; adjust the app path if your installation is named differently.

💻 Build with it — complete; the glue is kit API, copy-paste runs:

import CoreAIKit

let speaker = try await KitSpeaker(catalog: "voxcpm-0.5b")
let audio = try await speaker.synthesize(text)
// audio.samples: 16 kHz mono PCM in [-1, 1] — play it or write a WAV

The take-home is `Examples/Speak/Sources/QuickStart.swift` — this exact code as one typed function, no UI; the CLI is an argument shell over it, and the GUI drives the same KitSpeaker(catalog:) and plays the samples. Live playback? synthesizeStreaming(_:onChunk:) hands you ~0.5 s chunks as they decode, so audio starts before the whole clip exists. The WAV container is your app's territory (the runner ships a 20-line writer).

Integration checklist

• —SPM: https://github.com/john-rocky/coreai-kit (exact 0.4.1) → product CoreAIKit
• —Info.plist: none needed
• —Entitlements: none needed
• —First run downloads the model — ~1,373 MB (Mac) / ~1,679 MB (iPhone) — then it loads from the local cache (Application Support; progress via the downloadProgress callback)
• —Measure in Release — Debug is ~3× slower on per-token host work <!-- gen-cards:use-it end -->

Contents

A q=32 batched-prefill bundle is shipped, for fast time-to-first-audio: it seeds the KV cache in a single pass instead of looping the decode bundle once per text token (costly on the bandwidth-bound A19). Text longer than 32 tokens falls back to the bit-identical prefill-via-decode loop, so length stays unbounded.

Usage

Easiest path is the [coreai-model-zoo](https://github.com/john-rocky/coreai-model-zoo) coreai-audio app (the "Voice" tab) and [CoreAIKit](https://github.com/john-rocky/coreai-kit):

import CoreAIKit

let tts = try await VoxCPMTTS(paths: .standard(artifactsRoot: modelRoot))   // macOS (.aimodel)
// let tts = try await VoxCPMTTS(paths: .aot(root: modelRoot, arch: "h18p")) // iOS (.aimodelc)
let pcm = try await tts.synthesize("On device speech synthesis, running entirely on your iPhone.")
// pcm: [Float] @ 16 kHz mono

// Or stream — get each ~0.48 s chunk as it is generated (first chunk emitted at ~0.43 s). On iPhone
// RTF sits near 1.0, so pre-roll ~2 chunks (~1 s) before playback for smooth, gapless audio
// (perceived first audio ~0.9 s — still ~5x faster than waiting ~4 s for the whole clip):
let stats = try await tts.synthesizeStreaming(text) { chunk in player.play(chunk) }

The conversion scripts and the Swift host are in the zoo (conversion/voxcpm/) and CoreAIKit.

Notes

• —Plain TTS (fixed speaker). VoxCPM's voice-cloning branch is a follow-on.
• —Per-step quality is fp16-equivalent (int8 LM cos > 0.999 vs the fp32 reference); whole-utterance output is natural speech.
• —Community port — not an official Apple model.

Acknowledgements

OpenBMB / VoxCPM. Built on Apple's Core AI.

<!-- funnel:v1 -->

More models in this format: Core AI Model Zoo — 75 models, each with the recipe that produced it.

Want a different model on-device? Open a request — free, open weights only; the export and its measured numbers get published publicly.

<!-- /funnel:v1 -->