Strata gets described as "a fork of llama.cpp", and that shorthand is worth clearing up first,
because the precise version of it is more interesting. Strata (Niko1221/Strata, MIT licensed) is a
separate inference runtime with its own engine and desktop app; what it inherits from llama.cpp is
the raw materials - GGUF files, the quantisation formats, the kernel lineage from ggml - rather than
the codebase and its breadth. Third-party projects do fork llama.cpp directly (llamAmpere) or fork
those forks (Project Maya, kervia-Strata). So the accurate sentence is: Strata is an overfit
engine built on llama.cpp's formats, not a branch of llama.cpp's source.

That distinction is the whole point of the project.

What it actually does

Strata ships installers for Windows, Linux and Apple Silicon, plus a terminal command:

curl -fsSL https://github.com/Niko1221/Strata/releases/latest/download/install.sh -o install.sh && sh install.sh strata launch --family deepseek41 --model ist-das-2.00bpw --plan

You pick a model family and a quantisation set, it downloads them, and serves them. It exposes
OpenAI- and Anthropic-compatible APIs, so coding tools - Claude Code, Codex CLI, OpenCode, and the
rest - attach to it through strata connect without knowing which engine is underneath.

Where llama.cpp tries to run thousands of models across every backend it can reach, Strata supports
a short list of model families on a specific set of cards: consumer GeForce RTX 20-50 series, Radeon
RX 7700/7800/7900 and the AI PRO R9700, Intel Arc on Linux, Strix Halo, DGX Spark, and Apple
Silicon with 64 GB or more.

The trick that makes it fast is memory placement. Expert weights for a mixture-of-experts model are
cached per-expert in VRAM across all layers, native MTP (multi-token prediction) is used for
speculation instead of a bolted-on draft model, and whatever does not fit is read from SSD - which
is why the install asks for a lot of free disk: the 2.00 bpw set is about 257 GB of download and
asks for roughly 265 GB free.

What that buys you

On one published test on the same hardware, an RTX 4070 with 64 GB of DDR5 running a 125B MoE:
llama.cpp after tuning reached about 27 tokens/s decode, while Strata served about 53 tokens/s at
60,000 tokens of context - roughly double, with no hardware change. The same writer's notes make the
caveat explicit and it's a fair one: the quantisations and settings differ between the two engines,
so that is a comparison of complete serving setups rather than a controlled experiment.

Strata's own numbers are published per card, which is unusual and useful. A 12 GB RTX 3060 with 46 GB
of system RAM: 9-11 tokens/s output, around 155 tokens/s prompt processing at 4K context. A single
Radeon AI PRO R9700 with 251 GB RAM: 21-25 tokens/s. Four of them: 74-77 tokens/s. Those are the
kinds of figures that change what people think is possible on a desktop.

The engineering reason is boring and true: generality is a performance tax. A change to how experts
move across PCIe in llama.cpp must not break Metal's unified-memory path or twenty other backends,
so it goes through review, slowly. A runtime with one model family and one card can make the radical
change on a Tuesday.

What you give up

The trade is honest, and Strata's own documentation is blunt about it: today this is effectively a
short-list-of-models engine, while llama.cpp runs thousands of them across CUDA, ROCm, Metal, Vulkan,
SYCL and a long list of CPUs. If your workload is "whichever model shipped this week", breadth matters
more than speed, and llama.cpp is the right answer.

There's also a trust question. These engines are young, mostly one-person projects, shipping native
code that talks directly to your GPU driver. A sane minimum if you run one: build from source, pin a
commit, skim the diff before updating, and don't run it on a machine holding anything you can't
reconstruct.

So the practical advice is to stop treating the engine as the permanent part of your stack. Keep the
serving layer stable - an OpenAI-compatible endpoint, a model router such as llama-swap - and treat
the runtime underneath as replaceable. That way trying Strata is one model name away in your config,
and llama.cpp is still one model name away when the experiment needs to be undone.

For hardware like ours - a single box, fixed cards, models we choose ourselves - this is exactly the
profile where an overfit engine makes sense: the target doesn't change, so specializing at it is free
performance you were paying for in generality you didn't need.

Strata: https://github.com/Niko1221/Strata
The comparison write-up I lean on (with its caveats in full): https://carteakey.dev/blog/local-inference/the-rise-of-overfit-inference-engines/