mlmodelc: What It Is, Compiled Model Format and Compilation

What Is mlmodelc and How It Differs from .mlmodel

mlmodelc is a compiled binary Core ML model format intended for direct execution on Apple devices. The original .mlmodel format is a package containing a protobuf model description, weights as arrays, and metadata in JSON. During compilation, this structure is transformed into a compact binary representation optimized for the specific hardware platform.

The key difference of mlmodelc is the absence of an interpretation stage during inference. Core ML Runtime does not parse the protobuf schema or build the computation graph dynamically — all these steps are performed at compile time. This yields a first-load time improvement of 30% to 60% depending on architecture complexity.

According to the WWDC 2023 session “Core ML Tools and Model Optimization,” compilation includes floating-point operation optimization, merging consecutive layers, and conversion into a format understood by the Apple Neural Engine. Developers do not need to manage this process manually — Xcode performs compilation automatically at build time.

Comparison of mlmodelc and .mlmodel

How the mlmodelc Compilation Process Works

Model compilation into mlmodelc goes through three stages. In the first stage, Core ML Tools reads the protobuf specification of the .mlmodel and builds an internal computation graph in MIL (Model Intermediate Language) format. The tool checks each operation’s compatibility with the target device and marks unsupported layers for CPU execution.

In the second stage, graph optimization is performed: merging consecutive layers (convolution + batch norm → fused convolution), removing dead nodes, and quantizing weights from FP32 to FP16 or INT8. According to the Apple Engineering Report “Core ML Optimization Pipeline” (2024), layer merging reduces the number of inference operations by up to 40%.

The third stage is binary representation generation. The optimized graph is serialized into the proprietary Core ML Runtime format. Weights are saved aligned to CPU cache lines, and metadata is stored in a separate index for fast access. The result is a folder with the .mlmodelc extension, ready to be included in the app bundle.

Internal Architecture of mlmodelc

The mlmodelc structure includes three key components. Model Description contains model metadata: input and output types, their dimensions, tensor names, and preprocessing parameters. This section is stored in a JSON-like format for compatibility with the Core ML API.

Program is the binary representation of the computation graph in the internal MIL language. Apple uses MIL as an intermediate representation analogous to MLIR in TensorFlow or ONNX. A MIL program consists of operations, each with a type, input and output tensors, and attributes. The MIL format is optimized for efficient execution on the Apple Neural Engine.

The third component is weights.bin — a file containing all trained model weights. Weights are stored aligned to 64 bytes for optimal cache loading. If quantization is specified during compilation, weights are saved in FP16 or INT8, reducing file size and accelerating inference on Apple A17 and M4 chips with hardware support for these formats.

Ways to Deploy mlmodelc in an Application

Apple supports three ways to include mlmodelc in an application. The first is static inclusion in the bundle: the mlmodelc file is added to the Xcode project and ends up in the .app at build time. This approach is optimal for small models up to 100 MB and does not require network access for the first launch.

The second way is downloading from the network with on-device compilation via MLModel.compile(at:). The developer downloads the .mlmodel, places it in a temporary directory, and calls the Core ML compiler. The result is an mlmodelc that can be cached for subsequent launches. According to Apple HIG for Core ML, this approach is recommended for models larger than 100 MB and for dynamic updates without publishing a new app version.

The third way is On-Demand Resources for models downloaded on demand. Apple ODR allows storing mlmodelc in the cloud and downloading only when needed. This is a popular scenario for applications with dozens of models where the user only uses a few.

Asynchronous On-Device Compilation

When downloading a model from the network, it is important to account for compilation time. MLModel.compile(at:) executes synchronously and may block the UI on devices with A12 and older for up to 5–10 seconds for medium-sized models. It is recommended to perform compilation in a background thread and notify the user of the progress via a loading indicator.

Performance Advantages of mlmodelc

The main benefit of mlmodelc is model loading speed. According to Apple Performance Benchmarks (2024), a 100 MB ResNet-50 model loads 58% faster in mlmodelc format compared to .mlmodel. This is especially important for applications working with multiple models sequentially.

The second advantage is reduced peak memory consumption. When loading .mlmodel, Core ML Runtime allocates a buffer for parsing protobuf and a second buffer for graph compilation. mlmodelc starts directly, bypassing these stages. Peak memory consumption is reduced by 30–45% for computer vision models.

The third is hardware optimization. The coremlc compiler analyzes the target device at build time and selects the optimal division of operations between ANE, GPU, and CPU. If the build is universal, compilation is deferred to the device on first launch, and the result is cached for subsequent sessions.

Code Examples for Working with mlmodelc in Swift

Example of loading a compiled model from the app bundle. Simply specify the URL of the model and call MLModel.load(contentsOf:). Core ML Runtime will automatically detect the mlmodelc format by extension and perform initialization.

import CoreML

guard let modelURL = Bundle.main.url(
    forResource: "MyModel",
    withExtension: "mlmodelc"
) else { return }

let model = try await MLModel.load(contentsOf: modelURL)
let prediction = try await model.prediction(from: input)

Example of compiling a .mlmodel on the device with subsequent caching. Use MLModel.compile(at:) to get the temporary path to the mlmodelc, then copy it to the cache directory.

let sourceURL = FileManager.default.temporaryDirectory
    .appendingPathComponent("MyModel.mlmodel")

let compiledURL = try await MLModel.compile(at: sourceURL)

let cacheURL = FileManager.default.urls(
    for: .cachesDirectory, in: .userDomainMask
)[0].appendingPathComponent("MyModel.mlmodelc")

try FileManager.default.copyItem(at: compiledURL, to: cacheURL)