Core AI model zoo

CoreAI-Model-Zoo

CoreAIKit HF downloads CI Nightly device gate

Converted models + conversion recipes for Apple Core AI (.aimodel, iOS 27 / macOS 27): every model here is downloadable, gated against the original model before it ships, and carries the recipe that produced it in models/<model>/recipe.toml — rerun it (zoo_convert.py run <name>), check the published bundle against its source model (zoo_verify.py), or adapt it for your own port. Don’t take the gates on faith — they are run here, and everything needed to re-run them is published. Each card states what was measured on which hardware (iPhone tier is device-measured; the large models are Mac-only and say so) and how strong that model’s parity proof is, because it differs per model. Where the shipped configuration could not be recovered from the repository, the recipe says so rather than guessing. Model ports are open to everyone — the catalog serves community ports from the contributor’s own Hugging Face namespace (first: Nanbeige4.2-3B by @ukint-vs). Successor to CoreML-Models.

The from_pretrained of Core AI — one line, any zoo model, via CoreAIKit (SPM):

let chat = try await ChatSession(catalog: "qwen3.5-2b")   // downloads once, then cached
let reply = try await chat.respond(to: "What can you do, offline?")

Same gesture for every capability — KitTranscriber(catalog: "whisper-large-v3-turbo") is speech-to-text in 3 lines (card). Each model’s card carries the complete copy-paste snippet and its integration checklist. Every row below also links a ready-to-build app — in this repo’s apps/ or a CoreAIKit example (marked ↗).

Chat models also plug straight into Apple’s FoundationModels API: LanguageModelSession(model: try await KitLanguageModel(model: .qwen3_0_6B)) gives you the system session — Tool calling, @Generable guided generation, transcripts — backed by a zoo model (how). Zero-dependency alternative: every bundle loads with Apple’s own CoreAILanguageModel(resourcesAt:) as-is; this repo’s ZooFMProvider adds streaming tool calling on top (incl. LFM’s native dialect) — engineering notes in knowledge/fm-provider.md.

Quickstart — running a model on your device

New here? You’ll have a model answering on-device in a few minutes (needs Xcode 27 + a Mac or an iPhone/iPad on iOS/macOS 27):

git clone https://github.com/john-rocky/coreai-kit
open coreai-kit/Examples/ChatDemo/ChatDemo.xcodeproj   # Run, then pick a model in the picker

The app downloads the model on first pick (cached after), then runs it fully offline. Start small for the fastest first run: Qwen3-0.6B (454 MB) or Qwen3.5-2B on iPhone; any of the Mac-only rows on a Mac. Prefer the terminal? swift run chat-cli --model qwen3-0.6b --prompt "Hello" from Examples/ChatDemo. To drop a model into your own app, copy the snippet from that model’s card — it’s the same catalog: one-liner shown above.

Rebuild a bundle — the conversion recipes

Every published bundle carries the configuration that produced it in models/<model>/recipe.toml, and one command runs it:

python3 conversion/zoo_convert.py list                    # what can be rebuilt
python3 conversion/zoo_convert.py show  qwen3.5-0.8b      # the command + everything it needs
python3 conversion/zoo_convert.py run   qwen3.5-0.8b --dry-run
python3 conversion/zoo_convert.py run   qwen3.5-0.8b      # do it

show prints four kinds of prerequisite, and the run-time ones matter as much as the rest — an export that skips them still succeeds, and the bundle then misbehaves inside the app:

line means
overlay the interpreter needs coreai_models with conversion/overlay/ applied — zoo_convert.py doctor checks it
needs something the export cannot run without: a checkpoint download, a gather-table dump, a package patch
runtime what the app needs to run the result: an engine patch from apps/, an environment variable such as COREAI_CHUNK_THRESHOLD=1
device the AOT compile step for the iPhone bundle
uv this script declares its own dependencies — no venv, no overlay, nothing to install

Ports whose exporter is self-contained need no setup at all:

uv run conversion/export_da3.py --variant small --dtype float16 --res 504

Paths never assume a machine: python3 conversion/_paths.py prints where downloads, exports and the Hugging Face cache resolve, and ZOO_WORK_ROOT / ZOO_EXPORTS / ZOO_CODE_ROOT / HF_HUB_CACHE move them.

A recipe marked unverified refuses to run without --force. It means the repository does not record which configuration produced the published bundle, and it prints the exact question it cannot answer. Running it anyway yields a bundle, not the bundle.

Do not expect a checksum match. Conversion is not byte-deterministic here: the same recipe run twice on the same machine produces bundles that differ from each other (measured: main.mlirb by 7 bytes, main.hash entirely). A rebuild is judged by the gates the export runs — and by checking the published artifact itself:

python3 conversion/zoo_verify.py mlboydaisuke/Gemma-4-12B-CoreAI     # one repo
python3 conversion/zoo_verify.py --all --json models/_VERIFY.json    # the whole catalog, minutes

That compares a bundle’s tokenizer, chat template, context length and declared precision against the source model it names in its own metadata.json — no oracle, no device, no weights.

The numerical check is a different command. zoo_verify.py checks that a bundle is described correctly; it does not check that the bundle still computes the right thing. That is conversion/coreai_gate.py, which rebuilds the reference model in fp32 and compares a greedy decode token for token:

python3 conversion/coreai_gate.py <bundle-dir> Qwen/Qwen3.5-2B --revision <sha> \
    --transcript models/qwen3.5-2b/gate.json

It runs outside this working tree — point --runner / ZOO_LLM_RUNNER at your llm-runner and --python / ZOO_CONVERT_PYTHON at an interpreter that has the export overlay, and it tells you which one is missing rather than failing obscurely. It currently covers the decode architectures in --arch (the oracle is a per-architecture transcription of that model’s export, so it grows one port at a time, not all at once).

--transcript is the part worth publishing: the pinned revision, the exact input_ids, both sides’ generated tokens, the tie margins, and the verdict. Rebuilding the oracle is expensive; re-running the engine side against a published transcript is not — it needs the bundle, llm-runner, and the recorded input_ids, and the output must match engine.gen_text.

New ports publish one. For models ported before the flag existed, conversion/backfill_gate_transcripts.py prints what can still be gated and, with --run, gates it — preferring the published bundle out of the CoreAIKit cache over a local export, so the transcript describes the bytes apps download at the revision the catalog pins. Nothing reconstructs a transcript from a card’s prose after the fact: a model that cannot be re-gated keeps a card that says what was gated, without a file claiming to prove it.

Results land in models/_INVENTORY.md; models/index.json is the same catalog machine-readable, which is where an agent should start. Each recipe entry there carries status (does the repository record what produced this bundle) and gate_transcript (is the numerical check against the original published, and where) — two different questions, kept as two fields so neither has to be inferred from prose.

Models

Model Download (.aimodel) Run in app License
Qwen3.5-0.8B 🤗 qwen3.5-0.8B-CoreAI ChatDemo ↗ Apache-2.0
Qwen3.5-2B 🤗 qwen3.5-2B-CoreAI ChatDemo ↗ Apache-2.0
Qwen3.6-35B-A3B (MoE, Mac-only) 🤗 Qwen3.6-35B-A3B-CoreAI ChatDemo ↗ Apache-2.0
Qwen3.6-27B (dense, Mac-only) 🤗 Qwen3.6-27B-CoreAI ChatDemo ↗ Apache-2.0
Ornith-1.0-9B (zoo’s first agentic-coding model — self-scaffolding coder, Qwen3.5 arch, DeepReinforce; Mac-only, 48 tok/s int8 / 59 int4) 🤗 Ornith-1.0-9B-CoreAI CoreAIChatMac MIT
GLM-4.7-Flash (MoE + MLA, Mac-only — zoo’s first MLA) 🤗 GLM-4.7-Flash-CoreAI ChatDemo ↗ MIT
🔧 Gemma 4 E2B (text, incl. official-QAT int4) 🤗 gemma-4-E2B-CoreAI ChatDemo ↗ Gemma
Gemma 4 E2B ⚡raw-Metal (hand-written mixed-bit int2/int4 kernels, ~55 tok/s on iPhone 17 Pro = LiteRT-LM parity, lossless) raw-metal/ in 🤗 gemma-4-E2B-CoreAI CoreAIChat Gemma
🔧 Gemma 4 E4B (text, official-QAT int4) 🤗 gemma-4-E4B-CoreAI ChatDemo ↗ Gemma
🔧 Gemma 4 12B (dense, Mac-only — custom flash-decode kernel) 🤗 Gemma-4-12B-CoreAI ChatDemo ↗ Gemma
🔧 Gemma 4 31B (dense, Mac-only — custom flash-decode kernel) 🤗 Gemma-4-31B-CoreAI ChatDemo ↗ Gemma
LFM2.5-1.2B-Instruct 🤗 LFM2.5-1.2B-CoreAI ChatDemo ↗ LFM Open License v1.0
LFM2.5-8B-A1B (MoE, custom gather_qmm kernel — first iPhone MoE) 🤗 LFM2.5-8B-A1B-CoreAI ChatDemo ↗ LFM Open License v1.0
Granite 4.0-H 1B / 350M 🤗 granite-4.0-h-CoreAI ChatDemo ↗ (1B) · 350M: CoreAIChat Apache-2.0
Nanbeige4.1-3B (dense reasoning/agentic, iPhone — 32B-class @ 3.93B) 🤗 Nanbeige4.1-3B-CoreAI ChatDemo ↗ Apache-2.0
Nanbeige4.2-3B (looped Llama: 22 physical blocks × 2 passes, 44 KV layers; int8 46.4 tok/s on M4 Max; port by Vadim Smirnov) 🤗 Nanbeige4.2-3B-CoreAI ChatDemo ↗ Apache-2.0
MiniCPM5-1B (1B-class on-device LLM, hybrid Think/No-Think, 128K, OpenBMB) 🤗 MiniCPM5-1B-CoreAI ChatDemo ↗ Apache-2.0
Youtu-LLM-2B (dense MLA — zoo’s first iPhone MLA & first dense MLA; DeepSeek-V2-style latent-KV attention at 1.96B with an absorbed flash-decode kernel, reasoning + agentic; Tencent) 🤗 Youtu-LLM-2B-CoreAI ChatDemo ↗ Other (youtu-llm)
BitCPM-8B (zoo’s first 1.58-bit ternary LLM — every weight is {-1,0,+1}; MiniCPM4-8B arch, custom 2-bit packed-GEMM Metal kernel; 8B running in ~2.1 GB on iPhone GPU; OpenBMB) 🤗 BitCPM-8B-CoreAI CoreAIChat ‡ Apache-2.0
LLaDA-8B dLLM (zoo’s first diffusion LLM — masked-diffusion decode: fills a canvas of [MASK] tokens in parallel, not left-to-right AR; bidirectional LLaMA-dense 8B, d3LLM-distilled; int4 ~4.9 GB, Mac) 🤗 LLaDA-8B-dLLM-CoreAI DiffuseChat ↗ Other
BitVLA (zoo’s first Vision-Language-Action / robotics model + first ternary multimodal — image+instruction → 7-DoF robot action; 1.58-bit BitNet-2B LLM + BitSigLIP vision, shared ternary kernel; runs on iPhone GPU; arXiv 2506.07530) 🤗 BitVLA-CoreAI CoreAIChat ‡ MIT
Qwen3-VL (vision-language) 🤗 2B · 4B · 8B VLChat ↗ Apache-2.0
Holo2-4B (GUI-grounding / computer-use VLM — screenshot + instruction → click coordinates; Qwen3-VL-4B backbone, H Company; zoo’s first computer-use model) 🤗 Holo2-4B-CoreAI VLChat ↗ Apache-2.0
MiniCPM-V 4.6 (vision-language, sub-2B — strongest tiny VLM) 🤗 MiniCPM-V-4.6-CoreAI VLChat ↗ Apache-2.0
🔧 Gemma 4 E2B vision (VL) (image+text) vl/ in 🤗 gemma-4-E2B-CoreAI CoreAIChat Gemma
Unlimited-OCR (document OCR → markdown: tables→HTML, formulas→LaTeX; zoo’s first doc-OCR — stock runtime, no patch, flat-latency R-SWA) 🤗 Unlimited-OCR-CoreAI ReadDoc ↗ MIT
GLM-OCR (document OCR → Markdown; GLM-4.V small 0.9B, single-pass, tables→Markdown; iPhone + Mac, ~4 s/page) 🤗 GLM-OCR-CoreAI ReadDoc ↗ MIT
MinerU2.5-Pro (whole-page document parsing → structured Markdown; zoo’s first whole-page auto-structuring — 2-stage layout + per-region recognition in one stock Qwen2-VL 1.2B, tables→<table> HTML; Mac) 🤗 MinerU2.5-Pro-CoreAI ReadDoc ↗ Apache-2.0
Qwen2.5-Omni-3B Audio (audio understanding — describes sounds, not a transcript; iPhone + Mac, zoo’s first audio model) 🤗 Qwen2.5-Omni-3B-Audio-CoreAI AudioChat ↗ Apache-2.0
Whisper large-v3-turbo (speech→text — 100 languages, auto-detect; stock runtime, iPhone AOT + Mac) 🤗 whisper-large-v3-turbo-CoreAI-official Transcribe ↗ MIT
Qwen3-ASR-1.7B (speech→text — the zoo’s first ASR; AuT encoder + Qwen3 decoder, 52 languages; iPhone + Mac) 🤗 Qwen3-ASR-1.7B-CoreAI Transcribe ↗ Apache-2.0
Parakeet-TDT-0.6B (speech→text — zoo’s first transducer / TDT (RNN-T); NVIDIA FastConformer + LSTM predictor + joint, 3 graphs + host greedy loop, 25 EU languages; iPhone 47.9× real-time) 🤗 Parakeet-TDT-0.6B-CoreAI Transcribe ↗ CC-BY-4.0
Nemotron 3.5 ASR Streaming 0.6B (speech→text — the zoo’s first STREAMING ASR: live-mic transcription in 320 ms chunks, cache-aware FastConformer + pure RNN-T with explicit KV/conv cache I/O; 40 locales in one checkpoint via a run-time language input, punctuation built in, any-length audio) 🤗 Nemotron-3.5-ASR-Streaming-CoreAI coreai-audio OpenMDW-1.1
Streaming Sortformer 4-spk v2 (speaker diarization — the zoo’s first “who spoke when”, up to 4 speakers; NeMo core as a Core AI graph + Swift host streaming loop + AOSC speaker-cache compression; pairs with any zoo ASR for a diarized transcript; iPhone + Mac, 100% activity-agree vs NeMo) 🤗 Streaming-Sortformer-Diar-CoreAI coreai-audio CC-BY-4.0
Kokoro-82M (text-to-speech — zoo’s first TTS; StyleTTS2 + iSTFTNet, 28 English voices, runs on any text) 🤗 Kokoro-82M-CoreAI Speak ↗ Apache-2.0
VoxCPM-0.5B (text-to-speech — diffusion TTS: MiniCPM4 LM + LocDiT flow-matching + AudioVAE; iPhone + Mac, int8 LM) 🤗 VoxCPM-0.5B-CoreAI Speak ↗ Apache-2.0
VoxCPM2 2B (text-to-speech — 2B successor at 48 kHz: MiniCPM4 28L LM + LocDiT-12L flow-matching + 48 kHz AudioVAE; iPhone + Mac, int8 LM) 🤗 VoxCPM2-CoreAI Speak ↗ Apache-2.0
VibeVoice-Realtime-0.5B (text → multi-speaker dialogue — the zoo’s first multi-speaker / podcast-style TTS: dual Qwen2.5 LM (4L context + 20L speech) + next-token diffusion head (DPMSolver++ v-pred, CFG) + causal-conv acoustic VAE, 24 kHz; host turn-switching for N-speaker conversations, pairs with Sortformer for a generate → diarize loop; iPhone + Mac, all-fp16, 10.6 tok/s ≈ 1.4× real-time on iPhone 17 Pro) 🤗 VibeVoice-Realtime-0.5B-CoreAI coreai-audio MIT
Mel-Band RoFormer (song → vocals + instrumental stems — the zoo’s first source separation: band-split mel RoFormer with STFT/iSTFT folded into the graph as constant DFT matmuls, so the host only frames and overlap-adds; iPhone + Mac, fp16, 6.5× real-time on iPhone 17 Pro) 🤗 MelBandRoformer-Vocal-CoreAI coreai-audio MIT
Stable Audio Open Small (text → music / audio — the zoo’s first generative audio; latent diffusion: T5 encoder + DiT (8-step rectified-flow) + Oobleck VAE, ~11s 44.1 kHz stereo; fp16 ~1 GB, ~0.4 s / 11 s on M4 Max ≈ 30× real-time; Stability AI + Arm) 🤗 Stable-Audio-Open-Small-CoreAI Music ↗ Stability Community
V-JEPA 2 (ViT-L, SSv2 — the zoo’s first world model: Meta’s self-supervised video encoder (JEPA, predicts in representation space) + action-recognition head, 174 physical-interaction classes; 16-frame clip → action, fp16 ~675 MB, ~160 ms/clip on M4 Max; Meta AI, MIT) 🤗 VJEPA2-ViTL-SSv2-CoreAI ActionCamera ↗ MIT
EmbeddingGemma 300M (text embeddings — on-device RAG / semantic search) 🤗 embeddinggemma-300m-CoreAI DocChat ↗ Gemma
Qwen3-Embedding 0.6B (multilingual text embeddings, last-token pooling + MRL) 🤗 Qwen3-Embedding-0.6B-CoreAI DocChat ↗ Apache-2.0
Qwen3-Reranker 0.6B (cross-encoder reranker — yes/no relevance score) 🤗 Qwen3-Reranker-0.6B-CoreAI DocChat ↗ Apache-2.0
ColModernVBERT (visual document retrieval — late-interaction MaxSim over page images, no OCR; zoo’s first multi-vector retriever) 🤗 ColModernVBERT-CoreAI DocSearch ↗ MIT
GLiNER2-PII (information extraction / NER — the zoo’s first NER / schema-driven extraction & first DeBERTa-v3 port; zero-shot PII detection + redaction, any label set at call time; mDeBERTa-v3 fused graph + Swift host collator/decode, iPhone + Mac, byte-identical to GLiNER2) 🤗 GLiNER2-PII-CoreAI InfoExtract ↗ Apache-2.0
RF-DETR nano/small/medium/large (object detection, no NMS) 🤗 RF-DETR-CoreAI DetectCamera ↗ Apache-2.0
RF-DETR-Seg nano→2xlarge (instance segmentation, 6 sizes) 🤗 RF-DETR-CoreAI DetectCamera ↗ Apache-2.0
YOLOX-S (object detection — dense anchor-free, host NMS) 🤗 YOLOX-CoreAI DetectCamera ↗ Apache-2.0
AdcSR ×4 (super-resolution — zoo’s first; one-step diffusion-GAN, on-device) 🤗 AdcSR-CoreAI UpscaleDemo ↗ Apache-2.0 + OpenRAIL++
Depth Anything 3 (monocular depth — zoo’s first depth model; small + base, fp16/fp32) 🤗 Depth-Anything-3-CoreAI DepthCamera ↗ Apache-2.0
TripoSplat (single image → 3D Gaussian splats — the zoo’s first 3D; DINOv3 ViT-H + 20-step flow-matching DiT + octree sampler + Gaussian decoder, Mac GPU ~1 min; .ply/.splat → RealityKit / MetalSplatter; VAST) 🤗 TripoSplat-CoreAI TripoSplatMac MIT
LTX-Video 2B distilled (text → video — the zoo’s first video model; T5-XXL + 8-step flow-matching DiT + causal video VAE, host FlowMatch sampler; 512×768×49f ~14 s Mac GPU; Lightricks) 🤗 LTX-Video-2B-CoreAI CoreAIVideo Other (LTXV)
FLUX.2 klein 4B (text → image + in-context editing — the zoo’s first image-generation & editing model; step-distilled flow-matching DiT (4 steps, guidance 1.0) + Qwen3 text encoder, 1024²; native in-context edit — add/replace/combine while keeping the subject, unlike strength-based SDEdit — plus multi-reference compose, both exported as edit-sequence transformers (output latent T=0 concatenated with reference tokens T=10·i); int4, Mac; Black Forest Labs) 🤗 FLUX.2-klein-4B-CoreAI CoreAIImageGen Apache-2.0
GLM-Image (text → image — the zoo’s first AR + diffusion hybrid; a 9B GLM-4 AR model samples the image as discrete visual prior tokens like an LLM (~36 tok/s), then a 7B flow-matching DiT denoises conditioned on them + 16ch VAE; composition from the AR, texture from the DiT; 1024² native + 512² fast, int8, Mac; ZhipuAI) 🤗 GLM-Image-CoreAI CoreAIImageGen MIT
Z-Image-Turbo (text → image — a 6B Single-Stream DiT (S3-DiT): Qwen3-4B text encoder → 34-block DiT (8-step FlowMatchEuler + CFG) → 16ch VAE; photoreal by default. One graph covers 256²/512²/1024² and any prompt length (dynamic image + caption axes, ~5–9 % cost). bf16 and near-lossless — PSNR 42.6 dB vs the fp32 reference; 18 s @512² / 70 s @1024² on M4 Max. fp16 NaNs this model, so Mac-only: AOT will not take a bf16 module; Alibaba Tongyi-MAI) 🤗 Z-Image-Turbo-CoreAI CoreAIImageGen Apache-2.0
TimesFM 2.5 200M (time-series forecasting — the zoo’s first forecasting foundation model; decoder-only patched transformer, any univariate series → 128-step point + 10-quantile forecast; one stateless graph + host RevIN/flip DSP, fp16 ~463 MB, ~14 ms/forecast M4 Max / ~25 ms iPhone 17 Pro device-verified; Google) 🤗 TimesFM-2.5-200M-CoreAI Forecast ↗ Apache-2.0

▸ Run in app — apps in apps/ live in this repo; ↗ links a CoreAIKit example app; ‡ = app wiring in progress. 🔧 = re-export to coreai-torch 0.4.1 queued (still loads on OS 27 beta 1; see the recovery note at the end). Full app list: apps/README.md.

Built with the zoo

Third-party apps running zoo models. Built something? Open a showcase issue — a name, a link, and one line is all it takes. Your app here.

Most downloaded

Most downloaded zoo models this month

(auto-updated weekly from Hugging Face download counts)

Decode throughput (tok/s, greedy; output top-1 exact vs the Hugging Face reference)

  iPhone 17 Pro · GPU iPhone 17 Pro · ANE M4 Max · GPU
Qwen3.5-0.8B 71.9 14.7 210
Qwen3.5-2B 29 — 161
LFM2.5-1.2B 45.4 — 276.5
Granite 4.0-H 1B 36.3 — 136.5
Nanbeige4.1-3B 15.9 — 114.5
Nanbeige4.2-3B (22 physical / 44 executed+cache layers; int8) pending — 46.4
MiniCPM5-1B (OpenBMB, int8 — 24/24 exact vs HF) 66.8 — 59.4
Youtu-LLM-2B (dense MLA, int8 — 16/16 device ≡ Mac ≡ HF) ~19 (in-app ~24) — 102.8
FastContext-1.0-4B (repo-exploration agent, 4bit — AOT h18p; ANE inference unsupported) 20.4 ✗ —
BitCPM-8B (1.58-bit ternary, OpenBMB — custom 2-bit packed-GEMM kernel; AOT h18p; ~2.1 GB resident; token-exact 3/3 vs ref) 17 ✗ 62.7
Gemma 4 E2B 30.3 (QAT 30.7) 6 77.0 (QAT 78.9)
Gemma 4 E4B (official QAT) 15.1 — 55.8
Gemma 4 E2B VL (image+text, official QAT) 25.5 — 82.4
MiniCPM-V 4.6 (vision-language, sub-2B) 53.4 — 224.3
Qwen3.6-35B-A3B (MoE, 35B/~3B active, Mac-only) — — 64.9 †
Qwen3.6-27B (dense, Mac-only) — — 15.9
GLM-4.7-Flash (MoE + MLA, 30B/~3B active, Mac-only) — — 52.4 †
Gemma 4 12B (dense, Mac-only) — — 23 int8 / 33 int4 ‡
Gemma 4 31B (dense, Mac-only) — — 17.2 int4 ‡

Measured on the iOS 27 / macOS 27 beta, Apple’s coreai-pipelined GPU engine, zero custom kernels (ANE column + †/‡ excepted). † = MoE bundle using the custom gather_qmm Metal kernel (reads only the routed experts). ‡ = dense bundle whose full/global-attention SDPA is a custom flash-decode Metal kernel — the stock MPSGraph SDPA crashes on the ≥16-head × 512 Q (a GPU scratch-heap overflow, apple/coreai-models#27), so these models are unrunnable without it. Prefill, sizes, per-model caveats, and the Mac-only big models: models/.

CoreAIChat screen recording

CoreAIChat (apps/) — the zoo's models running on-device on iPhone.

Start here

Repository layout

Dir What
coreai-kit ↗ (sibling repo) The Swift package that runs this zoo: 1-line catalog: APIs (ChatSession, KitTranscriber, …), model download + cache, and per-kind example apps in Examples/ — the cards’ ▶️ / 💻 doors point there.
models/ One directory per model — the card, the recipe.toml that reproduces its published bundles, and the generated _INVENTORY.md / index.json. Laid out like apple/coreai-models.
skills/ Agent skills — install them and your coding agent can pick a model, reproduce its bundle, and verify the result.
knowledge/ Verified notes on the framework: conversion, compression, stateful KV, custom Metal kernels, AOT, compute-unit rules, the Swift runtime.
conversion/ Re-authored models + convert / verify / compress scripts (PyTorch → .aimodel).
cli/ coreai export / doctor / verify — find a model’s export route, lint an artifact against the failure patterns in knowledge/, gate it against an HF oracle. DOCTOR_RULES.md is the table those checks come from: 64 ways a conversion succeeds and the result is quietly wrong.
swift/ CoreAIRunner — a Swift package that drives .aimodel LLM bundles, including architectures beyond the standard runtime.
apps/ Engine showcases — apps for models that need a hand-tuned backend (custom Metal kernels, patch stack: BitCPM, RWKV-7, LLaDA, …) and the device-verification bench behind the published numbers. Want to just run a model? Use the kit examples ↗ instead.

Agent Skills

This repo ships a plugin so a coding agent can use the zoo without being told how: pick a model from the catalog, reproduce its published bundle with the recorded recipe, and verify the result against the model it came from. With no plugin mechanism at all, point the agent at AGENTS.md — the same contract, zero install.

Skill Description
reproduce-a-zoo-model Choose a model from models/index.json, rebuild its published bundle with zoo_convert.py and its prerequisites, and check it with zoo_verify.py.
port-a-model-to-the-zoo Port a new model: the oracle-first method, the two gates, compression choices, the device tier, and what a finished port must ship.

Install

Claude Code

/plugin marketplace add https://github.com/john-rocky/coreai-model-zoo
/plugin install coreai-zoo-skills@coreai-model-zoo

Codex CLI

codex plugin marketplace add https://github.com/john-rocky/coreai-model-zoo

then /plugins → coreai-model-zoo → coreai-zoo-skills → Install.

Gemini CLI

gemini extensions install /path/to/coreai-model-zoo/skills

Apple’s own coreai-skills covers the toolchain itself (authoring, export, compression). These two cover this catalog; install both.

Contributing

Every model in the table is a conversion recipe anyone could have written — and from now on, some are. Nanbeige4.2-3B (PR #6, by @ukint-vs) is the reference for what a contributed port looks like: pinned checkpoint + immutable bundle revision, the overlay/recipe/gates in the PR, the bundle published under the contributor’s own HF namespace (you keep ownership and credit), and the maintainer runs the iPhone hardware gate for you if you don’t have the device.

Recovery note — the coreai-torch 0.4.0 incident

Every model broken by the coreai-torch 0.4.0 debug-location issue has been re-published: re-converted with 0.4.1 (verification gates re-run), or repaired in place with strip_debug_info (debug locations removed, weights byte-identical). Catalog-served apps just re-download. The few 🔧 rows above are the remaining re-export queue. If you have your own 0.4.0-converted assets, strip_debug_info fixes them in minutes — no re-conversion needed. (One port, FastContext-1.0-4B, was retired instead of recovered: Microsoft removed its upstream weights on 2026-06-30, so it cannot be rebuilt.) Details: knowledge/coreai-torch-041-ir-incident.md.

License

BSD-3-Clause (LICENSE). Re-authored model code derives from Apple’s BSD-3-Clause coreai_models and retains its notices. Model weights follow their own licenses (see each Hugging Face repo).

This site is open source. Improve this page.