MLX Swift — When Python Isn't an Option

When Python is the wrong tool

Most of MLX Quest assumes Python because most ML work happens in Python. But there are deployment targets where Python isn't an option — App Store applications, anything that needs to ship inside an iOS / macOS app binary, scenarios where you need Swift's tighter integration with Apple's app frameworks. For those cases, mlx-swift is the same MLX framework with a Swift API surface.

The mental model carries over from Python MLX with very few surprises. Arrays are typed; lazy evaluation is the default; function transforms exist. The syntax is Swift-shaped (Swift's let, type inference, methods on values), but the conceptual API is parallel.

What MLX Swift gives you

Same MLX kernels under the hood — performance is comparable to Python MLX on the same hardware.
App-shipping path — you can embed MLX inside an iOS / macOS app and ship through the App Store. Python can't do this.
Tight Apple framework integration — direct interop with SwiftUI, Combine, and the rest of Apple's app stack.
Smaller deployment surface — no Python interpreter, no pip dependencies, no virtual env to ship.

What you give up

Library ecosystem — most ML libraries (Hugging Face transformers, mlx-lm with all its conveniences) are Python-first. mlx-swift covers the core but not the full breadth.
Iteration speed — Swift's edit-compile-run loop is slower than Python's REPL. Iterate in Python; ship in Swift.
Community size — Python MLX has more users, more StackOverflow answers, more example code.

The recommended workflow

Train and iterate in Python MLX. Use mlx-lm or mlx-vlm for the experimentation phase.
Convert / fuse the result. If you fine-tuned a LoRA, fuse it into a deployable model (Track 4 lesson 5).
Embed via mlx-swift. Load the same model directory you produced in step 2; the file format is identical.
Ship the app. Standard iOS / macOS deployment from there.

This is exactly the path Ollama-on-Mac uses. The MLX path doesn't change just because the language at the deployment edge is Swift.

Code

MLX Swift — same array operations, Swift syntax·swift

// Add mlx-swift via Swift Package Manager:
//   https://github.com/ml-explore/mlx-swift
import MLX

// Create arrays — same shape as Python MLX
let a = MLXArray([1.0, 2.0, 3.0, 4.0])
let b = MLXArray([5.0, 6.0, 7.0, 8.0])

// Operations — also same shape
let c = a + b
print(c)   // array([6, 8, 10, 12], dtype=float32)

// Lazy by default; eval to materialize
let d = a * b
d.eval()
print(d)   // array([5, 12, 21, 32], dtype=float32)

// Default device is GPU on Apple Silicon — no .to(device) ritual
print(MLX.defaultDevice())

Embedding in a SwiftUI app (sketch)·swift

// SwiftUI view that runs MLX inference on a button tap.
import SwiftUI
import MLX
import MLXLLM   // mlx-swift's LLM extension package

struct ContentView: View {
    @State private var prompt: String = "Capital of France?"
    @State private var output: String = ""

    var body: some View {
        VStack {
            TextField("Prompt", text: $prompt)
            Button("Generate") {
                Task {
                    // Load model once at app start in production code.
                    let model = try await loadModel(...)
                    output = try await model.generate(prompt: prompt, maxTokens: 50)
                }
            }
            Text(output)
        }
    }
}

// In production, load the model once at app startup, not per tap.

Exercise

If you have Xcode installed, create a minimal Swift Package or iOS / macOS app and add mlx-swift via Swift Package Manager. Run a basic array operation (the matmul or the add from this lesson). Note the build time vs the Python iteration loop. Two sentences on whether Swift's deployment story is worth the iteration cost for your use case.