Strata 0.2.16 writes its own inference engine and swears the output didn't change
The open-source local AI app has dropped llama.cpp's kernels and claims the answers came out identical across nine GPUs. It's a bold thing to put in a release note, so the developer published the measurements.
Strata 0.2.16 landed on 18 November 2026, bringing the most-watched update yet to one of GitHub's more polarizing AI projects. The developer goes by Niko1221 online, his name is Niko Veit, and runs the whole thing mostly on his own alongside a large army of contributors. The headline change is that Strata now runs its models on its own inference engine. It no longer leans on ggml or llama.cpp's matrix kernels, whether you're on NVIDIA, AMD, Intel Arc or Apple Silicon.
That's a bigger deal than most release notes let on. Rewrite an inference backend from scratch and you usually get new answers. Silently different ones. That's the exact bug that bites people in the dark. Strata says it sidestepped it. The release notes claim the new engines produced the same tokens as 0.2.15 across nine different GPUs.
Those nine are an RTX PRO 5000, a Tesla P100, a Radeon R9700, an Arc A750, an M5 Max and a Strix Halo card, plus a couple of edge cases. A few short prompts on the DGX Spark and native CUDA 12 code for an RTX 5070 differ slightly. Strata explains those away. The Strix Halo picture answer, for instance, was a deliberate change baked into the new image reader.
The repo now sits at roughly 45,700 stars and 5,100 forks. Those numbers are easy to take with a grain of salt. Popularity and correctness aren't the same thing. But there's a pile of measurements attached here that most solo projects simply don't produce.
Why the identical-output claim actually matters
Rewriting an inference engine looks like a flex. It mostly looks like a good way to break things. The quiet, unglamorous version of that fear shows up in the fixes for Apple Silicon. In 0.2.15, Strata was producing wrong results on M1 through M4 chips. It computed only a quarter of the columns in some layers — 160 of 640 in one measured layer. Text still read fluently, which is exactly why the bug hid for so long. Short answers don't raise alarms.
The new version measures the fix straight on. Against the Mac's default path, on six prompts spanning 512 to 8,192 tokens, the first-token divergence fell from 0.303 down to 0.0068. That's the kind of number that proves or disproves a rewrite in a single shot. Strata ran it on an M5 Max, since it had no M1 through M4 machine on hand.
Keep in mind that this is precisely the kind of silent-quality bug that fuels Strata's critics in the first place. Skeptics have long asked whether Strata is genuinely distinct from llama.cpp or just wrapping its MoE expert-cache features. The question pops up constantly: is it real, or is it llama.cpp wearing a new coat?
Strata's answer is empirical. It posts token-for-token equivalence tables across many GPUs plus long-run reliability data. Independent quality comparisons, including one filed in the repo's issues under "distributional quality: Strata vs llama.cpp vs BF16 truth," found the disagreement between engines on the same model file to be small. Small cuts both ways here. The engines mostly agree, and the gap the skeptics feared is narrow.
What got faster and what still breaks
Speed is the part that doesn't need a faith test. On a Tesla V100 running a 26,000-token prompt, the new engine cut processing time from 17,464 milliseconds to 15,068. The RTX 2080 Ti moved from a speed index of 0.885 to 1.088. Nothing dramatic. Noticeable.
The chat window now surfaces the model's own steps: "Thinking...", "Calling read...", "Writing file app.js...". More usefully, a tool call that can't run no longer ends the turn. The agent gets an error listing its tools and keeps going. Strata says this held up in a live check, 20 out of 20.
The platform fixes read like a lab report. Windows once crashed on accounts that refuses a system query for, like a standard user over SSH, killing the whole thing about five seconds after launch. Ubuntu's memory guard used to kill big model loads on Linux; the fix frees memory from old model copies and pauses when memory gets tight, pushing loads from 0 of 5 surviving to 6 of 7. On NVIDIA Blackwell cards, the first answer on the CUDA 12 engine dropped from 173 seconds to 0.34 seconds. That's a fix you don't normally see in a changelog.
Strata also runs a frontier-class model called Qwen3.8-Flash-Next, which makes the whole thing more than a pure optimization exercise. The model has 125 billion parameters but only about 6 billion active per token, a native 262,144-token context window, and it handles text, image and video through a single API. It reportedly beats Claude Opus 4.6 Max on practical coding tasks while trailing Claude on the hardest reasoning exams. The clever part is how Strata squeezes such a huge model onto a consumer PC. It spreads the work across your whole machine. Picture a kitchen: the ingredients you reach for stay on the counter, which is your GPU's VRAM, while the rest waits in the pantry, which is RAM and your SSD. This flagship is a mixture-of-exparts design with roughly 24,576 small experts, of which only about ten get called per word. Each extra GB of VRAM holds around 700 more experts.
The price of that approach shows up in the known problems, and Strata is refreshingly honest about them. Windows plus a Strix Halo card with a small page file can stop with no message at all once memory fills up. You enlarge the page file, shorten the context, or cap the expert cache. A second chat on a Strix Halo with 32 GB of RAM can wait for minutes. 602 seconds measured, in one case. Not cheap. Not for the memory-constrained, at least. And there's a fair bit of the usual arms-race trade-off baked into the scene: specialized engines reportedly beat general-purpose servers like vLLM and llama.cpp at their own game, but they tend to lock you to one model and one GPU vendor.
The testing is the part that earns a little trust, if trust is something a single developer can earn on his own. Strata ran 21.4 hours, 14,976 requests and 23,919 tool calls across five PCs. Zero garbage answers. No unplanned stops. The longest single request took 159 seconds. The release test suites added another 4,040 terminal tests, 1,910 server tests and thousands more, all passing with zero failures on both Linux and Windows.
How to upgrade
If you're on 0.2.15 or earlier, an in-app update offers 0.2.16, or you can grab the installer directly. In the terminal, run strata update, though you may need to run it twice from 0.2.15 if the engine stays behind. If you cloned the repo, note that the folder layout moved: everything now lives under engine/, app/, terminal/, docs/ and tools/. Build the engine with cmake -S engine, then run UPDATE.bat or ./update.sh.
Head here to the GitHub release page
