RUST + METAL / BUILT FOR APPLE SILICON

Local models.
Native execution.

Run AI models on your Mac. Generate text, score decisions and prepare models with one open-source engine.

Built from source today. Installer packages aren't available yet.

STARK / 001RUST · METAL
Stark's angular black cat with gold eyes and STARK wordmark
NATIVE INFERENCEAPPLE SILICON
7.36%

higher generation throughput
than MLX-LM in our comparison

Qwen3.5-2B · 4-bitM5 Max · one request at a time
Source build availableRust + Metal on your MacSee the setup steps

01 / BENCHMARKS

See how
Stark compares.

Generation throughput and decision latency on Apple M5 Max. Explore the latest MLX-LM result, the earlier multi-engine pilot and JevK5 scoring.

OCT 20, 2026 / UPDATED STARK BUILD

Stark vs MLX-LM.

7.36% higher generation throughput overall. Stark led all six workloads in this comparison.

APPLE M5 MAX / 40 GPU CORES128 GiB MEMORYQWEN3.5-2B / 4-BITONE REQUEST AT A TIME
StarkMLX-LM
Qwen3.5-2B generation speed on Apple M5 Max. Bar lengths compare engines within each workload.
WorkloadStark tokens / secondMLX-LM tokens / secondAdvantage
Fibonacci module358.2321.5+11.40%
GPU explanation358.7322.1+11.34%
Copy editing330.4305.3+8.23%
Medium context315.0296.7+6.13%
Long context238.8230.6+3.53%
Long output344.2331.6+3.83%

Higher is better. These measure complete generation requests on the same model and Mac, with model loading excluded. Performance varies by model and hardware.

How we benchmarked

Four of six planned pairs passed the frozen host guards. Two pairs were excluded for external CPU activity and system pageouts. Whole-campaign timing_accepted remains false. These are preliminary local results; quality equivalence and broader production performance remain unqualified.

Rates include prefill, generation, IPC/readout and cleanup. Loading and warmup are excluded. Values are geometric means of within-load medians; each table cell covers 20 requests across four accepted loads. The overall gain gives equal weight to the 24 paired workload/load ratios. Gains use unrounded paired results and can differ from ratios of rounded rates. Bars compare engines within each workload.

Token hashes matched across engines on 6/10 fixtures; decoded text matched on 5/10. Both engines passed only sorting among four strict sanity checks. Arithmetic, prime and Python failed exact-reply checks; the retained receipts cannot distinguish semantic failures from formatting failures.

This measured direct workers at concurrency one. HTTP serving, concurrent requests, time to first token, power and other models or Macs were not measured here. Per-process GPU activity was unavailable; nominal thermal state does not prove equal clock frequencies.

The pinned comparison used Stark 045d0ca6, MLX-LM 72be8c955, MLX/MLX-Metal 0.32.4, context 8192, greedy sampling and fresh request state. Pair-level leads ranged from 6.09% to 7.95%; these are observed ranges, not confidence intervals.

Full benchmark report

OCT 19, 2026 / EARLIER STARK BUILD

Qwen3.5-2B across engines.

MLX-LM beat Stark on all six workloads in this earlier pilot. Stark's newer result is in the first tab; these runs predate its latest improvements.

APPLE M5 MAX / 128 GiBQWEN3.5-2B / 4-BITONE REQUEST AT A TIMESTOCK ENGINES
Higher is better
Fibonacci module — complete-request output tokens per second
Engine / configurationTokens / secondRelative throughput within this workload
Stark Earlier release build300.2
MLX-LM 0.32.2322.4
vLLM Metal 0.31.0 plugin283.4
llama.cpp b11747 / Q4_K_M GGUF200.6
TensorFold 1.1.1 / default drafting162.9
TensorFold 1.1.1 / drafting off156.6

An earlier snapshot, not a ranking of today's releases. llama.cpp used a different quantized model format, so its result compares the full engine and model stack. These preliminary measurements include request overhead and exclude model loading.

MetalRT: not measured. Stock support for this exact model was unverified.

Method and comparison limits

The stock pilot used unchanged engine implementations, normal setup controls and external measurement adapters. Stark, MLX-LM, TensorFold and vLLM Metal used the same MLX affine 4-bit/group-64 checkpoint; Stark used its normal native repack. llama.cpp used the existing Unsloth Q4_K_M export, whose source-weight equivalence to the MLX derivative was not verified.

Every engine ran at concurrency one. vLLM's separate concurrency-eight diagnostic is excluded from these comparisons. Context was 8192 with greedy decoding, thinking disabled and retained/prefix caches disabled through stock controls. Interfaces differed: Stark and MLX-LM used private pipes; the others used loopback HTTP. Missing cache counters remain unknown.

Values are medians of output tokens divided by complete-request seconds. Stark, MLX-LM, vLLM Metal and TensorFold default cover four accepted loads and twelve observations per workload. TensorFold with drafting off and the separately corrected llama.cpp repeat cover three accepted loads and nine observations; their first blocks were excluded for CPU activity. Whole-campaign timing acceptance is false. The llama.cpp driver correction and original rejected samples are retained in the report.

Stark, MLX-LM, vLLM Metal and TensorFold passed only sorting among four exact-answer sanity checks. llama.cpp passed arithmetic, prime and sorting but failed Python. This small screen does not establish generation quality equivalence. Continuous GPU, thermal and power isolation were not measured.

Full six-workload results and protocol

OCT 19, 2026 / JEVK5 BF16 PILOT

Decision scoring latency.

Stark had lower observed latency than llama.cpp on fresh JevK5 decisions. This measures direct candidate scoring.

APPLE M5 MAX / 128 GiBJEVK5 / BF16FRESH REQUEST STATELOWER IS BETTER
Median complete-request latency, milliseconds
Input lengthStarkllama.cpp
All inputs68.63 ms133.13 ms
Short inputs55.94 ms120.99 ms
Medium inputs118.47 ms187.65 ms
Long inputs598.26 ms893.67 ms

Descriptive pilot results with unequal accepted run counts and background activity. Both engines scored 25.5% accuracy on the public cases; faster scoring does not establish useful decision quality.

Stock source compatibility: Stark and llama.cpp ran the existing BF16 exports. MLX-LM, TensorFold and vLLM Metal rejected JevK5's unchanged flat source configuration.

Method and scoring limits

The same pinned JevK5 checkpoint was replayed over 231 public cases and twelve synthetic controls, using BF16 native and GGUF representations. Each decision used context 8192, fresh state, full-vocabulary log probabilities and candidate temperature 1.22. The complete-request timer includes context construction, prefill, normalization, cleanup and transport; loading and warmups are excluded.

Two Stark loads and all four llama.cpp loads passed the timing screens, giving 486 and 972 accepted measured requests respectively. Stark's other two loads were excluded for CPU interference. Whole-campaign timing acceptance is false; medians are descriptive and are not a paired speedup estimate. Input buckets are 0–255, 256–1023 and 1024–8191 tokens.

Public accuracy was 59/231 for both engines. They agreed on 241/243 choices and were individually repeatable across loads, but were not numerically identical. The twelve synthetic controls do not offset the low public accuracy. The sealed replay inputs remain private; public aggregates alone cannot reconstruct that exact replay.

Full scoring results and compatibility notes

02 / GET STARTED

Build it on
your Mac.

Stark currently requires a source build. You'll need Apple's Metal tools, Rust and uv. An installer isn't available yet.

Open the setup guide
  1. 01

    Install the build tools.

    Use an Apple silicon Mac with Xcode's Metal tools, Rust 1.98.1 and uv for the converter.

  2. 02

    Convert a supported model.

    Choose a supported checkpoint and prepare it with Stark's converter. The documentation lists model compatibility and tested configurations.

    Supported models
  3. 03

    Connect Stark to your app.

    Build the generation or scoring worker, then connect it to your application using the documented interface.

    Generation guide Scoring guide

03 / THE ENGINE

Run models.
Build your app.

The building blocks for assistants, local workflows and AI features on your Mac.

01

Generate locally.

Generate text on your Mac and connect it to your application. You control the chat experience and tools.

02

Score decisions directly.

Get candidate scores and probabilities for applications that make structured decisions.

03

Prepare your models.

Convert supported Hugging Face and MLX checkpoints for Stark. Check model compatibility before getting started.

BUILD COMMANDS
cargo +1.98.1 build --release --locked \
  -p stark-generate

./target/release/stark-generate \
  --model-path /path/to/converted-model
Run from the repository folder

BUILT IN THE OPEN

Inspect the work.