A Mac-native on-device inference engine — built on MLX and tuned by MacPaw Research with custom speculative decoding, KV-cache strategies, and quantization.
Four pieces that make the Mac a first-class place to run a model.
Elix runs on MLX, Apple's array framework for the Mac — unified memory, Metal-backed kernels, and the swift-transformers stack. Native from the metal up, with no Python runtime in sight.
Custom optimizations on top of MLX — speculative decoding, KV-cache tactics, quantization, prefill tuning — for the most tokens per second, per watt.
A growing library of LoRA adapters — summarization, classification, voice, and more. Fuse them at inference time and ship new capabilities without retraining.
A Swift-first DSL stitches models, adapters, tools, and memory into pipelines that compile to a parallelized execution graph. Build a local AI feature in minutes, not months.
On-device intelligence only wins if it feels instant. Elix is engineered so every interaction stays snappy — fast is the feature.
Prefill tuning and KV-cache reuse cut time-to-first-token, so output starts the moment the user hits enter.
MLX kernels and speculative decoding push tokens-per-second past stock runtimes — smooth even on a laptop.
Everything runs on the Mac — no round-trips, no rate limits, no cold starts waiting on a remote server.
Three families of tools power AI on the Mac today. Each one leaves a real gap in efficiency, control, or both.
Every prompt leaves the device, per-token pricing scales with usage, and latency lives in someone else's data center.
llama.cpp, Ollama, and MLC give you a runtime — but not one tuned for the Mac, and no model, adapters, or packaging.
Closed and fixed — no control over fine-tuning, evaluation, or upgrade cadence. Built for Apple's roadmap, not ours.
Define AI pipelines the way you write SwiftUI — declarative, native Swift. The compiler lowers your intent into a parallelized execution graph.
struct ChatTurn: Pipeline {
typealias Output = String
@State var message: String
@State var context: String = ""
var body: some Pipeline {
Guardrail(rules: [.politics, .pii])
$context.set {
Model(instructions: "Summarize history", input: $message)
}
Model(instructions: "Reply using context", input: $context)
}
}
// Compile once, then run on the engine.
let graph = PipelineCompiler(optimizations: [.parallelize])
.compile(ChatTurn(message: "hello").pipelineGraph)
let reply = try await engine.run(graph: graph)Swift structs with @State and native control flow, composing Model, Guardrail, ForEach, and ClientTask — no YAML, no wiring.
The compiler analyses @State reads and writes and batches independent branches automatically — concurrency for free.
The Codable graph runs in-process on iOS, across XPC on macOS, or in a test simulator — same pipeline, every target.
Every pipeline travels the same path — Swift source to executed graph. A Codable AST is the transport boundary, so the same code runs anywhere.
Swift authoring with @PipelineBuilder, @State, Model, and Guardrail.
A Codable PipelineGraph — the transport boundary across XPC.
Hazard analysis parallelizes independent branches.
Deterministic walk, parallel batching, prefix-skip on re-runs.
Elix doesn't just run on Apple silicon — it's tuned for it. Every layer of the engine is optimized per chip, and every gain is verified on real Macs.
Custom Metal kernels — one of Elix's optimization tracks. LFM2.5-1.2B (4-bit), averaged over 1k–16k contexts, each chip vs. its own stock baseline.
Kernels, caches, decoding, adapters — every layer of the engine moves through the same build, measure, ship loop.
Numbers come from real Macs across real workloads, averaged — never a single best case.
Speed comes from the engine, not from trading away model quality — outputs stay the model's own.
The runtime never opens files, holds secrets, or calls your APIs. Every side effect runs in a ClientTask on the client — same shape on macOS and iOS.
// Pipelines declare intent; ClientTasks own the outside world.
ClientTask(
input: query,
action: { encodedQuery in
// Runs in the client process — full access to
// keychain, entitlements, UI, file system, network.
let token = try Keychain.read("calendar-api-token")
let result = try await CalendarAPI(token: token).search(encodedQuery)
return try JSONEncoder().encode(result)
}
)Keychain, file access, entitlements, OAuth — all in the client process. The macOS agent holds no secrets.
One launch agent (ElixAgent) serves many client apps over XPC — clients send a graph; it compiles, runs, and calls back.
On iOS the same runtime embeds in-process — identical pipeline code, no platform branches or conditional compilation.
A growing library of LoRA-style adapters that turns one base model into many. Drop them in by hand, or let Elix dynamically fuse the best-fit set for each query at inference time.
+ many more, with new ones shipped continuously
Query-aware routing picks the best-fit adapter at inference time — no branching, no offline rebuild.
Stack summarization, extraction, classification, and more in one forward pass — full quality, marginal cost.
Train a new adapter for a new capability and ship it — no base-model re-tuning. The Store keeps growing.
Elix sits in the gap between "ship to a remote API" and "wire up your own runtime." It's built to complement Apple Foundation Models — not replace them — adding Mac-tuned inference, adapters, and composable pipelines on top.
| Elix | Cloud LLM APIs | Generic on-device | Apple Foundation Models | |
|---|---|---|---|---|
| Stays on device by default | ✓ | ✗ | ✓ | ✓ |
| Mac-native (MLX) | ✓ | — | ◐ | ✓ |
| Tuned inference (spec. decoding, KV-cache) | ✓ | — | ✗ | ◐ |
| Bespoke partner models | ✓ | ✗ | ✗ | ✗ |
| Adapter store / fine-tuning | ✓ | ◐ | ◐ | ◐ |
| Composable pipelines (SDK) | ✓ | ◐ | ✗ | ✗ |
| Production packaging for Mac apps | ◐ | ✓ | ✗ | ✓ |
| Cost per query at scale | $0 | $$ | $0 | $0 |
| Open / extensible | ◐ | ✗ | ✓ | ◐ |
Patterns Elix is built for.
Eney is the proving ground for the stack — Elix for local inference and model selection, and Mnemos for memory.
Drop a tuned adapter into a CleanMyMac, MacPaste, or third-party Mac app. Process a document, classify a screenshot, extract a structured field — without ever leaving the user's machine.
Combine Elix with Respeecher's voice models and Mnemos for context. Real-time transcription, summarization, and natural-voice playback for meetings, calls, or accessibility flows.
Use Elix with Swift-tuned adapters (SwiftEval-validated) to power autocomplete, code review, or refactor suggestions in IDEs and developer tools — running where the source code already lives.
Composable AI Pipelines: Write Intent, Not Infrastructure — by Maksym Kotliar. Covers the DSL, the PipelineGraph AST, the compiler's hazard analysis, epoch-based re-execution, the XPC contract, and the open-source plan.
Working on a Mac product that needs on-device intelligence? Talk to us about partnership, adapter requests, or early access.
Talk to the team ↗