CoreAI-Model-Zoo: downloadable models and rerunnable recipes for Apple's Core AI runtime

On-device models for Apple's Core ML successor

CoreAI-Model-Zoo provides converted models and conversion recipes for Apple's Core AI, the on-device ML runtime in iOS 27 and macOS 27 that the README describes as the successor to Core ML. In that pipeline, PyTorch models are exported with Apple's `coreai-torch` (for LLMs, `coreai.llm.export`) into `.aimodel` bundles that run on the GPU or the Neural Engine.

The user is an Apple-platform developer who wants to run models on-device, chat, vision, speech and generative, without wiring up conversion themselves. Every model in the zoo is downloadable, and prompts and inference stay on the device, which is the whole appeal of on-device inference: privacy and no server.

What sets this apart from a plain model dump is transparency about how each model was produced and verified. The README says every model ships with the recipe that produced it in `models/<model>/recipe.toml`, gated against the original model before shipping, with each card stating what was measured on which hardware and how strong the parity proof is. It is the successor to the author's `CoreML-Models`, and its license is reported as NOASSERTION on GitHub.

Recipes and gates you can rerun, not take on faith

The distinguishing design is that nothing is asked to be trusted blindly. The README is emphatic: don't take the gates on faith, they are run here, and everything needed to rerun them is published. Each model carries a `recipe.toml` you can rerun to rebuild the bundle, and a verification step to check the published bundle against its source model.

That matters because a converted model can silently diverge from its source, and most model zoos ask you to trust that the conversion preserved behavior. CoreAI-Model-Zoo instead publishes the conversion recipe and the parity gate so you can reproduce both. The README even notes that where the shipped configuration could not be recovered from the repository, the recipe says so rather than guessing, which is an unusually honest stance about the limits of reproducibility.

The conversion tooling is scriptable. The README shows listing what can be rebuilt, showing a model's exact command and requirements, and running a conversion, with a dry-run option:

python3 conversion/zoo_convert.py list
python3 conversion/zoo_convert.py show qwen3.5-0.8b
python3 conversion/zoo_convert.py run qwen3.5-0.8b --dry-run

The per-model honesty about parity strength, device-measured for iPhone tiers, Mac-only for large models, is what makes the benchmark claims (for example Qwen3-8B 4-bit decoding at 94 tok/s on an M4 Max GPU) checkable rather than marketing.

Putting a model in a Swift app

The consumption path is the companion CoreAIKit library, and the README starts developers with the built-in `qwen3-0.6b`. CoreAIKit downloads the matching platform bundle once and caches it, and the first download is about 352 MB on Mac, with a separate iPhone variant around 456 MB. The Swift usage looks up a model in the built-in catalog and opens a chat session:

import CoreAIKit

guard let modelID = ModelCatalog.builtin.entry(id: "qwen3-0.6b")?.modelID else {
    throw CoreAIKitError.modelNotAvailableOnPlatform(id: "qwen3-0.6b")
}
let chat = try await ChatSession(model: modelID)

For a command-line trial, the README shows cloning a pinned CoreAIKit release and running its example against a model:

git clone --branch 0.4.1 --depth 1 https://github.com/john-rocky/coreai-kit
cd coreai-kit/Examples/ChatDemo
swift run -c release chat-cli --model qwen3-0.6b

The README is careful that a Mac run is not evidence for the iPhone variant, and that the platform bundle differs by device. That distinction, plus the catalog throwing `modelNotAvailableOnPlatform` when a model is not available on the current platform, reflects that on-device models are platform-specific artifacts, not one universal file.

The limitations: bleeding-edge OS, big downloads, unclear license

The honest limitations begin with the platform requirement. Core AI is the runtime in iOS 27 and macOS 27, and the README's benchmark was measured on a macOS 27 beta, so this targets Apple's newest, still-emerging OS generation. Developers not on that OS cannot use these bundles, and beta-OS behavior can change under them.

The download sizes are a real cost. Even the small starter model is roughly 352 MB on Mac and 456 MB on iPhone, and larger models are Mac-only, which the cards say explicitly. On-device inference trades server cost for device storage and memory, and the zoo is honest that the large models do not fit the phone.

The most consequential ambiguity is legal: GitHub reports the repository as NOASSERTION, and the models are conversions of original models that carry their own licenses. The README's own emphasis on gating against the original model underscores that each model's terms trace back to its source, so a developer must check both the zoo's terms and the upstream model's license before shipping. Per-model parity strength also varies, which the cards state, so the reliability of a given conversion is not uniform.

Against exporting models yourself or using a cross-platform runtime

The alternatives are converting models to Core AI yourself with Apple's `coreai-torch`, or using a cross-platform on-device runtime such as an MLX or GGUF-based stack. Doing the conversion yourself gives full control but is exactly the work the zoo removes, and getting parity right is non-trivial. A cross-platform runtime runs on more than Apple silicon but does not use Apple's Core AI Neural Engine path.

CoreAI-Model-Zoo's difference is that it hands you ready `.aimodel` bundles that run on the GPU or Neural Engine through Apple's own runtime, with the recipe and parity gate published so you can verify or adapt each one. The README even notes MLX numbers alongside Core AI under the same protocol, so it is not hiding the comparison. The cost is Apple-only, newest-OS-only, and the license question. Choose self-conversion if you need a model the zoo does not have and want total control. Choose a cross-platform runtime if you must support non-Apple devices. Choose CoreAI-Model-Zoo when you are targeting iOS 27 or macOS 27, want on-device inference through Core AI with verifiable conversions, and one of its catalog models fits.

An unresolved license, open ports, and where to start

The license question is the thing to resolve before shipping. Because GitHub reports NOASSERTION and each model is a conversion of an upstream model, treat the zoo's terms and every source model's license as separate questions. The README's community-ports model, serving ports from contributors' own Hugging Face namespaces credited by name, reinforces that provenance and terms vary per model.

Maintenance tracks Apple's runtime and the CoreAIKit releases; the README pins CoreAIKit 0.4.1 in its example, so the Kit README is the source of truth for the exact tested OS and SDK. Because recipes are published, a model can be rebuilt rather than only re-downloaded, which is a durability advantage if a bundle needs regenerating.

The concrete first step is to start with `qwen3-0.6b` on the platform you actually target, and verify rather than assume: run the CoreAIKit chat example on that device, and if parity matters, use the published recipe and verification step to check the bundle against its source model. Remember the README's warning that a Mac run is not evidence for the iPhone variant, so test on the device you will ship to before trusting the numbers.

Editorial conclusion

Use CoreAI-Model-Zoo if you are building for iOS 27 or macOS 27 and want on-device models through Apple's Core AI runtime without doing the conversion yourself: the published recipe.toml and rerunnable parity gate per model, consumed via CoreAIKit in Swift, are what make it more than a model dump. It is the wrong choice if you are not on Apple's newest OS generation, cannot spare the download sizes (about 352 MB on Mac for even the small starter model), or need cross-platform support. Resolve licensing first, since GitHub reports the repo as NOASSERTION and each model carries its upstream license, then start with qwen3-0.6b on your actual target device and verify parity with the published recipe before trusting it.

Frequently asked questions

Official sources

1. Issues
2. john-rocky/coreai-model-zoo on GitHub
3. Project website
4. README
5. Releases