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).

This model has no row on DeviceMark, the on-device LLM leaderboard.

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) 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).

VoxCPM 0.5B demo 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.8.0. 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.8.0 --depth 1 https://github.com/john-rocky/coreai-kit
export DEVELOPER_DIR=/Applications/Xcode-27.0.0-RC.app/Contents/Developer
open -a /Applications/Xcode-27.0.0-RC.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 27A266a 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.8.0) β†’ product CoreAIKit
  • Info.plist: none needed
  • Entitlements: none needed
  • First run downloads the model β€” ~1,374 MB (Mac) / ~1,378 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

Contents

Path What
macos/voxcpm_base_int8_decode_cl512/ LM backbone (MiniCPM4, 24L), int8, static-KV decode β€” JIT .aimodel for Mac
macos/voxcpm_res_int8_decode_cl512/ Residual LM (6L), int8
macos/voxcpm_base_int8_prefill_t32/ LM backbone q=32 batched prefill β€” seeds the KV cache in one pass for fast time-to-first-audio, int8
macos/voxcpm_res_int8_prefill_t32/ Residual LM q=32 batched prefill, int8
macos/voxcpm_feat_decoder_fp16/ LocDiT CFM diffusion decoder (10-step euler + CFG, unrolled), fp16
macos/voxcpm_feat_encoder_fp16/ LocEnc + projection (per-frame feedback embed), fp16
macos/voxcpm_vocoder_fp16_t12/ AudioVAE decoder (DAC-style, 640Γ— upsample), fp16
ios/<name>/<name>.aimodel/ The same 7 JIT bundles, byte for byte, laid out as macos/; every iPhone generation specializes them on its first load
ios-h18p/*.h18p.aimodelc/ The same 7 bundles (5 + the 2 int8 prefill) compiled ahead of time for the iPhone 17 Pro (h18p), that phone only; moved from ios/ in revision 38fc0aea (2026-09-26)
voxcpm_host_glue/ Token-embedding table + dit/FSQ/stop-head weights (run host-side via Accelerate)
tokenizer/ Llama tokenizer (tokenizer.json + config)

Measured 2026-09-26 on an iPhone 18 Pro (iPhone19,2, iOS 27.0 build 24A437, h19p) with the zoo's DecideGate app in its load-only mode, without the increased-memory entitlement. Each first load was the graph's first in an app container that held no specialization of it; the app had run other graphs before. The call is one run on all-zero inputs; a graph with a KV state was loaded only. Each first load wrote a specialization of about the bundle's size into the app container, and the load after a relaunch reused it. One measurement per graph (knowledge/jit-distribution.md). The same phone refuses an h18p bundle with incompatibleCompiledAssetArchitecture.

JIT bundle in ios/ MB first load first call load after relaunch
voxcpm_vocoder_fp16_t12.aimodel 54 0.09 s 177 ms 0.04 s
voxcpm_res_int8_decode_cl512.aimodel 90 0.19 s β€” (KV state) 0.06 s
voxcpm_res_int8_prefill_t32.aimodel 90 0.19 s β€” (KV state) 0.06 s
voxcpm_feat_encoder_fp16.aimodel 122 0.17 s 176 ms 0.08 s
voxcpm_feat_decoder_fp16.aimodel 129 1.06 s 761 ms 0.10 s
voxcpm_base_int8_decode_cl512.aimodel 360 1.13 s β€” (KV state) 0.27 s
voxcpm_base_int8_prefill_t32.aimodel 360 1.19 s β€” (KV state) 0.27 s

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.

A clip's text and speech share the base and residual decode graphs' fixed KV cache of 512 positions: one position per text token and one per speech frame. A clip is at most 300 frames (24 s) by default (maxFrames), so a text of up to 211 tokens (about 800 characters of English) always fits, and a longer one can run out of room. From CoreAIKit 0.8.0, the clip then ends where the cache ends, before the end of the text, and a text that leaves no room for speech throws VoxCPMError.textTooLong. CoreAIKit 0.7.3 and earlier do not stop at the end of the cache, and what they output past it has not been checked.

KitSpeaker and CoreAI.speak pass the whole text at once: split a long text into sentences and synthesize them one by one.

Usage

Easiest path is the coreai-model-zoo coreai-audio app (the "Voice" tab) and CoreAIKit:

import CoreAIKit

let tts = try await VoxCPMTTS(paths: .standard(artifactsRoot: modelRoot))   // macos/ or ios/ (.aimodel)
// let tts = try await VoxCPMTTS(paths: .aot(root: modelRoot))               // ios-h18p/ (.aimodelc); from CoreAIKit 0.8.0 the arch: parameter defaults to this device's (0.7.3 and earlier: h18p)
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.


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.

Downloads last month
51
Inference Providers NEW
This model isn't deployed by any Inference Provider. πŸ™‹ Ask for provider support

Model tree for mlboydaisuke/VoxCPM-0.5B-CoreAI

Quantized
(6)
this model

Collection including mlboydaisuke/VoxCPM-0.5B-CoreAI