Core ML vs Core AI: which Apple framework to use in 2026
What Apple's new Core AI framework does, what stays in Core ML and where Foundation Models fits, taken from Apple's own docs and WWDC26 sessions.
Apple shipped Core AI with the 27 releases and kept Core ML, so a new on-device AI feature now starts with a choice of Core ML vs Core AI, with Foundation Models and MLX alongside them.
In short:
- Core AI is Apple’s new framework for running AI models in your app on Apple silicon. It arrived with the 27.0 releases of iOS, iPadOS, macOS, Mac Catalyst, tvOS, visionOS and watchOS.
- Core ML is still there. On 12 November 2026 its documentation page showed no deprecation notice, and it now points apps that use “the latest architectures and inference techniques” to Core AI.
- Use Core AI for neural networks you convert from PyTorch. Use Core ML for decision trees and other models that aren’t neural networks, and for users who aren’t on the 27 releases yet.
- Foundation Models is the Swift API for language models. It runs Apple’s on-device model on iOS 26 and later, and from the 27 releases it can also run a language model you converted to Core AI.
- MLX is Apple’s open source array framework for training, fine-tuning and research on Apple silicon Macs.
- We converted MobileNetV2 both ways on a MacBook Air M1. The Core AI file was 14.0 MB, the same as a 32-bit Core ML file, and from Python it ran slower: 5.33 ms per image at best, against 0.55 ms for Core ML’s default 16-bit version. The converter wouldn’t install on an Intel Mac.
What is Core AI, in Apple’s words?
The Core AI documentation sums it up in one line: “Run AI models in your app on Apple silicon.” The overview says it “helps you build, run, and deploy AI models in your app” across the CPU, GPU and Neural Engine, through a Swift API.
The framework comes with tools for each step before the app:
| Step | Tool | What it does |
|---|---|---|
| Prepare | coreai-optimization | Compresses PyTorch models with quantization, palettization and pruning |
| Convert | coreai-torch | Converts a PyTorch model into the .aimodel format |
| Measure | Evaluations framework | Measures a model’s quality |
| Debug | Core AI Debugger app | Shows model structure and traces tensor values back to your Python code |
| Compile | coreai-build |
Compiles models ahead of time, so they load faster on the device |
Apple also publishes coreai-models, a catalog of export recipes for open source models plus a Swift package with helpers for running them.
In the WWDC26 session Meet Core AI, Apple describes it as “the inference framework powering on-device Apple Intelligence,” now open to developers. Apple’s integration guide lists the reasons to run models on the device: data stays private, features work offline, and “there is no per-inference cost to you or the people using your app.”
Plan for the first load. The first time a model loads on a device, Core AI specializes it for that device’s hardware, and Apple says this “can take a significant amount of time for very large models.” Later loads come from a cache. Apple recommends keeping that first load out of the moments when someone is waiting on the screen.
Is Core ML deprecated?
No, going by Apple’s own pages on 12 November 2026. The Core ML documentation shows no deprecation notice and still lists support back to iOS 11 and macOS 10.13.
The word “replace” came from before WWDC26. In March 2026, 9to5Mac reported Bloomberg’s Mark Gurman saying Apple planned to “replace the long-existing Core ML with something a bit more modern.” Apple shipped two frameworks that point to each other:
- The Core ML page says: “If your app integrates AI models using the latest architectures and inference techniques, see Core AI.”
- The Core AI page says: “If your app uses model types other than neural networks, such as decision trees or tabular feature engineering, see Core ML.”
Neither of the two main Core AI sessions, Meet Core AI and Integrate on-device AI models into your app using Core AI, mentions Core ML in its transcript. Apple calls Core AI “the next evolution of on-device AI execution across Apple platforms.” That points new work on neural networks toward Core AI. We found no Apple page or session saying Core ML will be removed.
Core ML also covers things Core AI’s documentation doesn’t list. Models you train in Create ML come out in Core ML format, and Core ML’s documentation describes retraining and fine-tuning a model on the device with that person’s data. Core AI’s documentation topics cover inference, model specialization, caching and debugging, with nothing listed for training.
Where does Foundation Models fit?
Foundation Models is the Swift API for language models. It gives you Apple’s on-device model, guided generation with the @Generable macro so the model fills in your own Swift types, and tool calling. It needs a device that supports Apple Intelligence. For what it handles inside a business app, see Foundation Models framework in a business app.
Core AI connects to it in two ways. A language model you convert to Core AI can run through the same LanguageModelSession API, and in session 326 Apple loads a Qwen model this way: “Same session.respond to: call, same streaming support, same structured output capabilities.” Apple’s machine learning updates page also says Foundation Models now works “with any language model, including Apple Foundation Models, cloud models like Claude and Gemini.”
So for a text feature, start with Foundation Models and Apple’s model. Bring in your own model through Core AI only when Apple’s model can’t do the task or doesn’t support the language you need.
Where does MLX fit?
MLX is “an array framework for machine learning on Apple silicon, brought to you by Apple machine learning research.” Its Python API closely follows NumPy, and it also has C++, C and Swift APIs. It installs with pip install mlx on Apple silicon Macs, with CUDA and CPU-only builds for Linux.
Apple’s updates page describes it as the place for “experimenting with, training, and fine-tuning large language models,” and this year it added support for Metal 4 and for spreading training across several Macs over Thunderbolt. Use MLX to train or fine-tune a model and to try ideas on a Mac. Core AI is the framework Apple documents for putting a model inside your app, with Xcode integration, specialization and profiling built in.
Core ML vs Core AI: which framework for which feature?
| You want to | Use | Minimum OS |
|---|---|---|
| Summarize, extract or classify text with Apple’s on-device model | Foundation Models | iOS, iPadOS, macOS and visionOS 26.0 |
| Run your own language model with the same session API | Core AI model through Foundation Models | 27.0 |
| Run a vision, audio or transformer model converted from PyTorch | Core AI | 27.0 |
| Run a decision tree or tabular model | Core ML | iOS 11, macOS 10.13 |
| Ship a neural network to people still on iOS 26 or earlier | Core ML | iOS 11, macOS 10.13 |
| Retrain a model on the device with a person’s own data | Core ML | See Apple’s Core ML docs |
| Train, fine-tune or experiment on a Mac | MLX | Apple silicon Mac |
If you already ship Core ML models, nothing in the Apple pages we read tells you to move them. In our MobileNetV2 test, the Core AI version also ran slower than the Core ML one, so measure before you move a model for speed. Move a model when you need something Core AI documents and Core ML doesn’t: newer model architectures, the coreai-models recipes, or running your own language model through Foundation Models.
OS and device support: who can run it?
| Framework | Introduced in | Hardware |
|---|---|---|
| Core AI | iOS, iPadOS, macOS, Mac Catalyst, tvOS, visionOS and watchOS 27.0 | Apple silicon, per Apple’s session 324 |
| Core ML | iOS 11, iPadOS 11, macOS 10.13, Mac Catalyst 13, tvOS 11, watchOS 4, visionOS 1.0 | CPU, GPU and Neural Engine |
| Foundation Models | iOS, iPadOS, macOS, Mac Catalyst and visionOS 26.0; watchOS 27.0 | Devices that support Apple Intelligence |
| MLX | Not part of the OS; installed as a package | Apple silicon Macs, plus Linux builds |
Check what share of your users run the 27 releases. Until nearly all of them do, a Core AI feature has to be optional or backed by a Core ML or server version.
Converting a model with coreai-torch: what we measured
Apple’s coreai-torch quick example is short:
import torch
from coreai_torch import TorchConverter, get_decomp_table
model = MyModel().eval()
ep = torch.export.export(model, args=(torch.randn(1, 10),))
ep = ep.run_decompositions(get_decomp_table())
coreai_program = TorchConverter().add_exported_program(ep).to_coreai()On an Intel Mac, the converter didn’t install
We first tried it on 12 November 2026 on an Intel Core i9-9980HK running macOS 26.7, with Python 3.12 and uv. It didn’t get as far as converting anything.
- coreai-torch 0.4.3 is on PyPI as a pure Python package, but it requires
coreai-core1.0.0b3. That package only publishes wheels for macOS 26 on Apple silicon and for Linux on x86_64, so uv stopped with: “coreai-core==1.0.0b3 has no wheels with a matching platform tag (e.g.,macosx_26_0_x86_64).” - The installation guide also asks for Python 3.11 or later and PyTorch 2.8.0 or later. PyTorch 2.8 and newer publish no wheels for Intel Macs on PyPI, so that requirement fails on the same machine for a second reason.
On a MacBook Air M1, both conversions worked
We then converted one model both ways on an Apple silicon Mac and timed each version on the same machine.
| Machine | MacBook Air, Apple M1, 8 GB memory, macOS 27.3 (build 26C5035r), command-line tools only, no Xcode |
| Packages | Python 3.12, PyTorch 2.13.0, torchvision 0.28.0, coreai-torch 0.4.3 with coreai-core 1.0.0b3, coremltools 9.0 |
| Model | MobileNetV2 from torchvision with its ImageNet weights, the model Apple uses in its own coreai-torch examples |
| Input | One 224 × 224 image tensor, the same for every run |
Installing took one fix. pip install coreai-torch pulled in PyTorch 2.15.0, and coreai-torch warned that it’s only validated up to 2.13.0, so we pinned 2.13.0. coremltools 9.0 warned that it’s only tested up to PyTorch 2.7.0, and converted the model anyway. On macOS 27, the coreai-core package runs models through the Core AI framework built into the OS, so we could time Core AI from Python without building an app.
Each time below is the median of 50 predictions after a first, untimed one, measured from Python.
| Core ML, 16-bit (coremltools default) | Core ML, 32-bit | Core AI (coreai-torch) | |
|---|---|---|---|
| File size | 7.1 MB .mlpackage |
14.0 MB .mlpackage |
14.0 MB .aimodel |
| CPU | 2.71 ms | 4.52 ms | 5.33 ms |
| GPU | 2.61 ms | 2.82 ms | 7.18 ms |
| Neural Engine | 0.56 ms | 4.52 ms | 7.53 ms |
| Default setting | 0.55 ms | 2.78 ms | 7.51 ms |
| Largest difference from PyTorch’s output | 0.023 | under 0.00001 | under 0.00001 |
For Core ML, the rows are its compute unit settings: CPU only, CPU and GPU, CPU and Neural Engine, and all units as the default. For Core AI, they’re the preferred compute unit in its specialization options. Every run picked the same top class as PyTorch.
What the numbers show:
- At full 32-bit precision, the Core AI file was the same size as Core ML’s, 14.0 MB. Core ML converts to 16-bit by default, which halves the file. We didn’t run coreai-optimization, Apple’s compression tool for Core AI, so we have no 16-bit Core AI number yet.
- Core AI was slower than Core ML in every setting we tried. Its fastest median was 5.33 ms on the CPU. Core ML’s 16-bit model took 0.55 ms with default settings, the same as with the Neural Engine allowed, so that’s most likely where it ran.
- Asking Core AI for the Neural Engine didn’t speed it up. Its output matched the GPU run exactly, and the Neural Engine works in 16-bit precision, so this 32-bit model most likely ran on the GPU. Core ML’s 32-bit model behaved the same way: with the Neural Engine allowed, it ran at the CPU-only speed.
- The first prediction is the slow one. The first Core ML prediction on the GPU took 1.9 seconds, and the first Core AI prediction with default settings took 0.21 seconds. Later ones took milliseconds.
- When it loaded the converted file, Core AI warned that the file had no minimum deployment target and defaulted to the Mac’s own OS version, 27.3. Set one when you convert a model you plan to ship.
This is one small vision model on one Mac, timed from Python, with a beta runtime (coreai-core 1.0.0b3). A Swift app may see different overhead. Measure your own model before you move it from Core ML to Core AI for speed.
What we couldn’t test without Xcode
- Ahead-of-time compiling with
coreai-build. With only the command-line tools installed,xcruncouldn’t find it. - Running the model inside an app or on an iPhone. The coreai-models README asks for macOS and iOS 27.0 or later and Xcode 27.0 or later.
- Converting on Linux. The published wheels suggest it works on Linux x86_64, and we haven’t tried it.
So converting needs an Apple silicon Mac on macOS 26 or later, or a Linux x86_64 machine. If your team’s build machines or CI runners are Intel Macs, check this before you plan a sprint around Core AI.
Planning an on-device AI app
Before choosing a framework, answer these:
- Which OS versions do your users run? This decides whether Core AI can be the only path.
- How big is the model? In session 326, Apple’s example models added over 1 GB to the app download, so Apple moved them to an on-demand download with Background Assets.
- Where does the first load happen? Plan a first-run screen for specialization, or compile ahead of time with
coreai-build. - How will you measure quality? Apple’s Evaluations framework scores a feature against metrics you define and works with any model available through Foundation Models. Apple pitches it for comparing approaches, tracking quality over time and catching regressions before they ship.
- Does Apple’s own model already do the job? If Foundation Models handles the task, you ship no model at all.
We build iOS apps in Swift and Flutter apps with on-device AI, and our app build pricing starts at $15,000. To see how a build runs from scope to release, read about our AI-native app builds.