CoreML Export for YOLO26 Models

Apple ships dedicated AI silicon — the Neural Engine — in every modern iPhone, iPad, and Mac, and CoreML is Ultralytics' supported path for deploying models to it today. Exporting Ultralytics YOLO26 models to CoreML turns a trained .pt checkpoint into a native .mlpackage that runs all seven YOLO tasks on-device at low latency, with no network connection and no data leaving the device.

Watch: How to Export Ultralytics YOLO26 to CoreML with INT8 Quantization | Apple Deployment | iOS/MacOS 🍎

What is CoreML?#

CoreML (styled "Core ML" by Apple) is Apple's on-device machine learning framework. It loads models in the modern ML Program format — the .mlpackage bundle the Ultralytics exporter produces — and schedules them across the device's CPU, GPU, and Apple Neural Engine (ANE), the dedicated NPU in every Apple-silicon chip. Because everything runs locally, inference works offline, adds no network latency, and keeps user data on the device.

CoreML integrates directly with Apple's Vision framework, which handles image scaling and orientation on the way into the model — this is how the Ultralytics iOS SDK feeds camera frames to YOLO with effectively zero preprocessing cost.

Why Export YOLO26 to CoreML?#

• Neural Engine speed: CoreML schedules supported operations on Apple's Neural Engine for low-latency on-device inference. See the physical-device table below, and benchmark your exact export on your target hardware.
• Choose the output: Default exports leave NMS to your app. Use nms=True to embed NMS, or nms=False for YOLO26's NMS-free head.
• Private and offline: All computation stays on the device — no cloud round-trips, no API keys, full data privacy.
• One export, the whole ecosystem: The same .mlpackage runs on iOS, iPadOS, macOS, watchOS, tvOS, and visionOS, and powers the official Ultralytics iOS SDK and Flutter plugin.

Measured Performance#

End-to-end single-image inference for the standardized v8.3.0 YOLO26n INT8 CoreML assets on an iPhone 17 Pro with 12 GB memory and iOS 27.0.1. Its A19 Pro has a 6-core CPU (2 Performance and 4 Efficiency cores), 6-core GPU with Neural Accelerators, and 16-core Neural Engine. Each cell shows the total time (preprocessing + inference + postprocessing, excluding annotation) with the per-stage split beneath it. On iOS, Vision performs input scaling inside the inference request, so preprocessing is reported as 0 and its cost is included in inference.

• The exact v8.3.0 release assets declare 224×224 inputs for classification and 640×640 for every other task.
• On iOS 27.0.1, .cpuOnly inference of the l and x depth, pose, and OBB models crashes inside Core ML's CPU kernels (EXC_BAD_ACCESS in libBNNS); the same models run with .cpuAndNeuralEngine, and every other task and size runs on the CPU.
• Speed values are single-image burst latencies — the mean of 15 runs after 3 warmup runs on bus.jpg, measured through the iOS SDK's per-stage timing via the Flutter plugin's benchmark harness in profile mode (optimized native code). CPU/accelerator order alternated between tasks in one sequential sweep. CPU rows request Core ML .cpuOnly; CPU + ANE preferred rows request .cpuAndNeuralEngine, with final operation placement controlled by Core ML. Sustained real-time camera operation runs higher because it includes the capture and scaling pipeline plus thermal settling. A historical pre-standard camera sweep measured 11.3 ms/frame for YOLO26n detect and 16.5 ms/frame for YOLO26n Depth on the same device — see the iOS SDK performance doc for steady-state profiling.
• Compare the Android CPU/GPU results in the LiteRT integration and Snapdragon NPU results in the Qualcomm QNN integration.

Supported Tasks#

CoreML export supports all seven Ultralytics tasks. Semantic segmentation and depth estimation are available only with YOLO26, the only family that ships those heads.

Exporting YOLO26 Models to CoreML#

Installation#

To install the required package, run:

# Install the required package for YOLO26
pip install ultralytics

The coremltools converter is installed automatically on first export. Export runs on macOS or x86 Linux; for detailed instructions and best practices, check our installation guide and the Common Issues guide.

Usage#

The CoreML format supports the Export, Predict, and Validate modes. Inference and validation with CoreML run on macOS only. Export your model, then load the exported model to run inference or validate its accuracy.

from ultralytics import YOLO

# Load a YOLO26 model
model = YOLO("yolo26n.pt")

# Export to CoreML with INT8 weight quantization, matching the official app models
model.export(format="coreml", quantize=8, imgsz=640)  # use imgsz=224 for classification

from ultralytics import YOLO

# Load the exported CoreML model (macOS)
model = YOLO("yolo26n.mlpackage")

# Run inference
results = model("https://ultralytics.com/images/bus.jpg")

from ultralytics import YOLO

# Load the exported CoreML model (macOS)
model = YOLO("yolo26n.mlpackage")

# Validate accuracy on the COCO8 dataset
metrics = model.val(data="coco8.yaml")

Export Arguments#

For more details about the export process, visit the Ultralytics documentation page on exporting.

Targeting the Neural Engine#

CoreML chooses hardware via MLModelConfiguration.computeUnits. The Ultralytics iOS SDK defaults to .cpuAndNeuralEngine on iOS 16+ rather than .all: in a real-time camera app the GPU is already busy compositing the preview and overlays, so excluding it avoids contention and frame-time jitter while the ANE does the heavy lifting. Pin .cpuOnly only for compatibility testing — the table above shows what it costs.

Running a CoreML model from Python on a Mac host (via Ultralytics or coremltools) follows the same rule: Ultralytics loads with ComputeUnit.CPU_AND_NE (macOS 13+, falling back to CPU_ONLY on older macOS), keeping inference on the Neural Engine (~3× faster than CPU). This also avoids a current macOS host limitation where the default ComputeUnit.ALL / CPU_AND_GPU — which add the GPU/MPSGraph compile path — abort the process with an Error: MLIR pass manager failed assertion on coremltools 9.x. RT-DETR models are the exception: they load with ComputeUnit.ALL, because their FP16 accuracy drops on the Neural Engine alone.

Deploying Exported YOLO26 CoreML Models#

The fastest path is the official Ultralytics YOLO iOS SDK, the same Swift package that powers the Ultralytics iOS app and the Flutter plugin. It resolves official model names automatically, downloads and caches the .mlpackage, and returns fully decoded results:

import UltralyticsYOLO

// Loads the official INT8 model (downloaded and cached on first use), then runs inference
let yolo = YOLO("yolo26n", task: .detect) { result in
    if case .success(let model) = result {
        let results = model(uiImage)  // boxes, labels, confidences, timing
    }
}

For camera apps, drop in the SDK's YOLOView for real-time inference with native overlays, or use the Flutter plugin for cross-platform apps that share one codebase with Android.

Integrating a raw .mlpackage yourself is also straightforward with Apple's stack — load it with MLModel, wrap it in a VNCoreMLRequest, and feed images through VNImageRequestHandler. These resources cover the details:

• Integrating a Core ML Model into Your App: Apple's guide to bundling and calling a CoreML model.
• CoreML Tools: Conversion, quantization, and optimization reference for the coremltools toolchain that powers this export.
• Xcode Core ML Performance Reports: Per-layer device placement and latency profiling for your exact model and device.

Ship the model either embedded in the app bundle (instant availability, ideal for nano/small models) or downloaded on first run and cached (smaller binary, easy model updates). The official apps combine both approaches: default nano models are bundled for immediate use, while larger variants download on demand and are cached locally.

Recommended Workflow#

1. Train your model with Ultralytics Train mode, or start from the official YOLO26 weights
2. Export with model.export(format="coreml", quantize=8, imgsz=640) on macOS or x86 Linux (imgsz=224 for classification)
3. Verify accuracy with model.val() on a Mac, and profile with an Xcode Core ML Performance Report on your target device
4. Deploy with the iOS SDK, the Flutter plugin, or your own Vision integration, targeting .cpuAndNeuralEngine

Summary#

In this guide, you learned how to export Ultralytics YOLO26 models to CoreML's .mlpackage format, quantize them for the Apple Neural Engine, and deploy them at single-digit-millisecond latencies — either through the official iOS SDK and Flutter plugin or your own Vision integration.

FAQ#