Choosing Between MLX, Core ML, and Create ML

Apple platforms have three machine learning frameworks from Apple itself: Core ML, Create ML, and MLX. Each targets a different job.

• Core ML is for deploying trained models to run efficiently on device.
• Create ML is for training simple models without code or with minimal Swift.
• MLX is for research, flexible inference, and training with an array framework designed for Apple silicon.

Choosing the wrong one leads to unnecessary work. Converting a model to Core ML when MLX would work, or using MLX for a model that should be a static Core ML asset, both cost time and performance.

This guide compares the three frameworks across training, deployment, performance, and developer experience, with concrete advice for choosing.

Core ML

Core ML is Apple’s production inference framework. Core ML Tools converts models from libraries such as PyTorch and TensorFlow into Core ML models. Core ML then runs them with hardware-specific optimizations.

What it is good for

• Static inference — the model architecture is fixed at build time.
• Performance-critical deployment — Core ML uses the Neural Engine, GPU, and CPU selectively through the model’s execution plan.
• App Store distribution — models can be bundled with the app and optionally protected with model encryption.
• Strict latency requirements — real-time camera processing, audio classification, on-device decision making.

The conversion pipeline

flowchart LR
    PyTorch --> coremltools
    TensorFlow --> coremltools
    coremltools --> mlpackage
    mlpackage --> Xcode
    Xcode --> App

The conversion step (coremltools in Python) is where friction lives. Not every operation in a source model has a Core ML equivalent. Unsupported operations may require changing the model, using a supported composite operation, or adding a custom operation.

Performance characteristics

• Neural Engine access — the key advantage. Core ML is the only way to run models on the ANE, which is highly power-efficient for supported operations.
• Model compression — Core ML Tools supports techniques such as quantization, pruning, and palettization. The size and accuracy tradeoff depends on the model.
• Model encryption — models can be encrypted so they can only run on your app. Useful for proprietary models.

When to reach for it

• You have a fixed model that you ship with the app.
• You need Neural Engine acceleration.
• Model size and startup time matter (Core ML loads quickly from a compiled format).
• You want model protection.

Create ML

Create ML is Apple’s no-code/low-code training tool. It ships with Xcode and provides a drag-and-drop interface plus a Swift API for training common model types.

What it is good for

• Image classification — train a classifier from a folder of labeled images.
• Object detection — train an object detector from annotated images.
• Text classification — sentiment analysis, spam detection, topic tagging.
• Tabular data — regression and classification from CSV data.
• Sound classification — train on audio samples.
• Recommendation systems — implicit and explicit feedback models.

Training workflow

The Xcode UI presents a step-by-step wizard: pick a task type, point to your data, configure training parameters, and click Train. The output is a Core ML model ready to drag into your app.

// The Swift API for the same task
import CreateML

let data = try MLImageClassifier.DataSource
    .labeledDirectories(at: URL(filePath: "/path/to/images"))

let model = try MLImageClassifier(trainingData: data)
try model.write(to: URL(filePath: "/path/to/output.mlpackage"))

Limitations

• Limited architecture choices. Create ML chooses the model architecture for you.
• No custom layers or architectures. If your problem does not fit one of the predefined tasks, Create ML cannot handle it.
• Small-to-medium datasets only. For large-scale training, use PyTorch or MLX.
• Less control over hyperparameters.

When to reach for it

• You need a simple classifier and have labeled data.
• You want to prototype an ML feature in minutes.
• You are not an ML engineer and just want a model that works.

MLX

MLX is Apple’s array framework for ML, designed for Apple silicon. It is the newest of the three (open-sourced late 2023) and takes a fundamentally different approach: you work directly with array operations instead of converting models to Core ML first.

What it is good for

• Flexible inference — LLMs, diffusion models, and custom architectures that benefit from an array-oriented workflow.
• Training and fine-tuning — including LoRA and full model fine-tuning for supported models in MLX Swift LM.
• Research and experimentation — quick iteration without conversion pipelines.
• Running Hugging Face models directly — MLX Swift can load safetensors weights and run models with no conversion step.

The developer experience

import MLX
import MLXLLM
import MLXLMCommon
import MLXHuggingFace
import HuggingFace
import Tokenizers

let model = try await #huggingFaceLoadModelContainer(
    configuration: LLMRegistry.gemma3_1B_qat_4bit
)

let session = ChatSession(model)
print(try await session.respond(to: "What is the capital of Vietnam?"))

With the Hugging Face integration, the model downloads, loads into memory, and runs without a Core ML conversion step.

Performance characteristics

• CPU and GPU execution — MLX operations can run on CPU or GPU streams. MLX does not target the Neural Engine.
• Unified memory — MLX is designed around Apple silicon’s unified memory architecture, so CPU and GPU operations can work with the same arrays without copies between separate memory pools.
• Lazy computation — arrays are materialized when needed, which supports a flexible development workflow.

When to reach for it

• You are running an LLM or diffusion model.
• You need general-purpose training or fine-tuning.
• You want to iterate quickly without a conversion step.
• The model architecture is experimental or custom.
• You are building a research tool.

Side-by-side comparison

Decision guide

Start here

Does your model need to run on the Neural Engine?
├── YES → Use Core ML
└── NO → Does Create ML support your training task?
    ├── YES → Use Create ML to train, then ship the Core ML model
    └── NO → Do you need a flexible research or training workflow?
        ├── YES → Use MLX
        └── NO → Benchmark Core ML and MLX for your model

By use case

Combining frameworks

The frameworks are not mutually exclusive. Core ML supports on-device updates for models prepared as updatable, while MLX supports broader training workflows. A common pattern:

1. Research and prototype in MLX (fast iteration).
2. Once the architecture is frozen, convert to Core ML if Neural Engine acceleration and Core ML’s deployment optimizations help.

Or:

1. Train a small classifier in Create ML.
2. Ship an LLM-powered feature using MLX Swift alongside it.

Both frameworks can coexist in the same app. MLX handles the flexible model workflow, while Core ML handles optimized deployment where it is a better fit.