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.

Whisper large-v3-turbo — Apple Core AI export (autoregressive)

A pre-converted .aimodel from Apple's official coreai-models Whisper recipe, packaged so it actually transcribes on the stock Core AI runtime (no engine patch).

Whisper large-v3-turbo (809 M) is OpenAI's multilingual ASR encoder-decoder: 100 languages, automatic language detection.

Whisper large-v3-turbo on iPhone 17 Pro — the zoo's coreai-audio app, real speed.

Use it

New to Core AI? Start with CoreAIKit 0.7.3. 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 text = try await CoreAI.transcribe(audioURL)

Every op, one shape — Cookbook.

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

git clone --branch 0.7.3 --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/Transcribe/Transcribe.xcodeproj
# → Run, then pick "Whisper large-v3-turbo" in the model picker

# agents / headless (macOS):
cd coreai-kit/Examples/Transcribe
swift run -c release transcribe-cli --model whisper-large-v3-turbo --audio sample.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 transcriber = try await KitTranscriber(catalog: "whisper-large-v3-turbo")
let samples = try AudioFile.pcm16kMono(url)  // any wav/m4a/mp3 → 16 kHz mono Float
let result = try await transcriber.transcribe(samples: samples)
// result.text, result.language ("en", "ja", … auto-detected)

The take-home is Examples/Transcribe/Sources/QuickStart.swift — this exact code as one typed function, no UI; both the runner's GUI and its CLI call it. Recording? MicRecorder (kit API) captures mic audio as 16 kHz mono [Float] — the record button and permission prompt are your app's own chrome.

Integration checklist

SPM: https://github.com/john-rocky/coreai-kit (exact 0.7.3) → product CoreAIKit
Info.plist: NSMicrophoneUsageDescription — only if you record
Entitlements (iOS): com.apple.developer.kernel.increased-memory-limit
First run downloads the model — ~1,623 MB (Mac) / ~3,235 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

What's different from the stock recipe (and why)

Apple's models/whisper/export.py traces the model with decoder_input_ids of shape [1, 1] — a single decode step, no KV cache. That graph can't be driven autoregressively: with one token and no cache, every step is "position 0" and loses all prior context (it emits nothing useful).

This bundle is the same recipe with one change: the decoder is traced at a fixed 128-token window (decoder_input_ids: [1, 128]). You pad the decoder buffer to 128 and read the logits at the real last position. Because the self-attention is causal, the real token at position k never attends to the padding, so the read is exact — and because the shape is constant, MPSGraph compiles once (a dynamic-length export instead recompiles every step → ~15 s/token; this is ~0.18 s/token). Everything else is the upstream recipe and it runs on the stock runtime.

# stock single-step recipe:           uv run models/whisper/export.py
# this bundle (fixed 128-token decode): see _export_whisper_fixed.py in the zoo conversion/ dir

Bundle

whisper-large-v3-turbo_float16_fixed128.aimodel/   main.mlirb + main.hash + metadata.json
macos/, ios/                                       the same .aimodel + tokenizer/, per platform
ios-h18p/                                          the .aimodel name holding an h18p AOT bundle + tokenizer/
tokenizer/                                         HF Whisper tokenizer (detokenize output ids)
mel_filters_128.npy                                [201, 128] mel filterbank for the audio frontend
preprocessor_config.json                           n_fft=400, hop=160, 128 mels, 16 kHz

File	SHA-256
`…_fixed128.aimodel/main.mlirb` (1.6 GB; the root, `macos/` and `ios/`)	`12739247978e0c3cb0d116083c7607a5d64e5e7dbdf57f520fbe1ee14b57db31`
`…_fixed128.aimodel/main.hash` (the root, `macos/` and `ios/`)	`10d178900fa8f0ebf729c17002179f8e76eb97a29f2a615c2945089cec7aed10`
`mel_filters_128.npy`	`4eb6b0fe7aa985fa2ce80d81260d8b5b30ff908d2808a5d637683228c648db6f`

ios/ holds the same JIT files as the root and macos/; every iPhone generation specializes them on its first load. ios-h18p/ holds the bundle compiled ahead of time for the iPhone 17 Pro (h18p), under the same .aimodel name the kit opens; it moved there from ios/ in revision dabe8102 (2026-09-26). It was compiled on 2026-06-28 from an earlier export: its metadata.json names sourceHash f5824a2e01906ad72bb3241573e75a41ecbf89c2ebe5fb8b87716752cf144881, the main.mlirb this table listed before, not the JIT file above (exported 2026-07-21). The iPhone 18 Pro refuses an h18p bundle with incompatibleCompiledAssetArchitecture.

Measured (M4 Max, GPU)

Greedy decode, English clip, vs the HF PyTorch reference (generate, greedy):

Metric	Value
Transcript	token-for-token identical to PyTorch greedy
First step (compile + warmup)	0.68 s
Per token (steady state)	0.18 s

The fixed window caps a single 30 s decode at 128 tokens (enough for a 30 s window; chunk longer audio into 30 s segments).

Measured (iPhone 18 Pro, the JIT bundle in `ios/`, load only)

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 first after a fresh install of the app. The call is one run on all-zero inputs. 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).

JIT bundle in `ios/`	MB	first load	first call	load after relaunch
`whisper-large-v3-turbo_float16_fixed128.aimodel`	1,617	4.37 s	2,111 ms	0.26 s

How to run it (the decode loop)

The graph takes input_features [1, 128, 3000] (log-mel) + decoder_input_ids [1, 128] → logits [1, 128, 51866].

Audio → log-mel (mel_filters_128.npy, n_fft 400 / hop 160): STFT → power → mel filterbank → log10, clamp to max-8, (x+4)/4; pad/trim to 3000 frames.
Prompt: [<|startoftranscript|>, <|en|>, <|transcribe|>, <|notimestamps|>] (50258, 50259, 50360, 50364).
Loop: pad the prompt to 128, run, take argmax(logits[0, k]) at the real last index k, append, repeat until <|endoftext|> (50257).
Detokenize the generated ids with the bundled tokenizer.

Runs on macOS + iOS via coreai.runtime / the Swift CoreAI framework. A from-scratch reference implementation of this exact loop + the log-mel frontend (no kit dependency) is the CoreAITranscribe sample app (macOS + iOS, file or mic) — or skip the loop entirely and use the 3-line KitTranscriber snippet in Use it, which does it (plus the mel frontend, chunking, and auto language detect) for you.

Export environment

macOS 27.0 beta · coreai-core 1.0.0b1 · coreai-torch 0.4.0 · transformers 4.57
recipe: Apple models/whisper/export.py + a fixed 128-token decoder trace