Strata 0.2.10 makes a small drafter the default and doubles throughput on split GPUs
DFlash2 is now the default drafter, one engine can split weights across all your cards on Linux, and 8 GB graphics cards can finally hold 128K context. Strata developer Niko Veit shipped the update on November 2, 2026, along with 0.1.56 of Control and every engine package.
The app and the Terminal are 0.2.10. Everything else sits at 0.1.56. Keep in mind that a single update now brings the Terminal, Control, and both the Qwen and DeepSeek engine packages together. An older 0.2.9 install needs a second pass to fetch the DeepSeek engine.
Strata has quietly become one of the more followed local inference projects out there. It's an MIT-licensed engine by Veit, known online as Niko1221, built to run Qwen3.8-Flash-Next, a 125-billion-parameter mixture-of-experts model, on a consumer gaming PC. The whole pitch is offline execution on a 12 GB card and 64 GB of RAM, no account, no per-token fee. It blew up in early October 2026, when a Hacker News thread demanding proof pulled in hundreds of points and hundreds of comments. As of now the repo holds roughly 38,700 GitHub stars and over 4,200 forks.
The trick is that Strata stops treating VRAM as the only place a model can live. The 125B model has 24,576 tiny experts, but each token only needs about 10 of them. So the engine keeps the most-used experts in GPU memory, computes the rest on the CPU in parallel, and pulls a ~29 GB n-gram lookup table from the SSD. Speculative decoding lets a small helper guess the next tokens while the big model verifies them in one pass. That's the foundation the new release builds on.
A smaller drafter wins on memory, split engines win on speed
The most visible change is that DFlash2 takes over as the automatic drafting choice for Qwen3.8, including Unsloth's files and the "Gyro" variants. Before this, Strata defaulted to its own MTP draft layer, which costs 5.2 GB of VRAM just to load. DFlash2 is a small ~0.7 GB model, leaving that layer untouched and handing the freed memory back to experts or longer context.
There's now exactly one drafter per run. Auto, MTP, DFlash2, or Off, each loads only one. Older settings that named two, like "both" or "mtp+dflash2," now collapse into Auto.
Auto is clever about placement. It reaches for MTP when you run parallel requests, when no DFlash2-capable engine is installed, for DeepSeek or non-Qwen3.8 families, and on the new split engine. On a layer split the split engine doesn't cover, it runs DFlash2 alone. The first start also pulls just ~1.2 GB and builds the drafter locally, versus the old 5.2 GB MTP file.
The speed payoff is real, though it bends to your hardware. In Strata's A/B tests, decode gains ranged from roughly +1% to +12%. You saw +12.0% on short answers and +8.8% on long ones on a Ryzen AI Max (Strix Halo) with the Unsloth UD-Q4_K_XL quant, plus +7.9% on an RTX PRO 5000, +6.6% on a Radeon AI PRO R9700, and +7.4% on an Apple M5 Max. Greedy runs beat sampled ones.
Notably, on the Intel Arc A750 DFlash2 came out about 2.6% slower than MTP, yet it remains the Auto choice. Strata's making a judgment call: speed be damned, memory savings win.
The more interesting feature is the all-cards split engine. For the first time it launches automatically from the Terminal with strata launch on supported Linux setups. Built from sFNX by John Fink (MIT), it changes how weights move across GPUs. Instead of a layer split, where each card holds whole layers, every card now holds a share of every layer, so all of them read weights at once. NVIDIA cards pass partial sums through page-locked host memory; AMD cards write into each other's memory where allowed, falling back to the host path otherwise.
Auto only flips it on when a strict checklist is met: Linux, exactly two NVIDIA cards of compute capability 8.6 or 12.0, or four Radeon AI PRO R9700s with a UD-Q4_K_XL file; a Qwen3.8 file to read; every routed expert fitting in card memory; ~43 GiB of free RAM; and context at or below 131,072 tokens.
Strata tested on two RTX A6000s, two RTX PRO 6000 Blackwells, and four R9700s. It explicitly did not test on a GeForce pair or with other card counts, so anything else keeps the older layer split.
The numbers are where it gets interesting. On two RTX A6000s with a 128K context, the split roughly doubled throughput. Edits ran 377–394 tokens/sec versus 195 on the layer split. New code hit 189–232 versus 139–144. An agent loop with up to 123K-token prompts pulled 165 tokens/sec versus roughly 112–119. First-token latency dropped as well, from 14.8 seconds down to 9.4 on a 32K prompt.
On two RTX PRO 6000 Blackwells, with other users running both cards during the test, edits ran 666–741 tokens/sec versus 420–432.
The trade-offs are honest. Reading a 32K prompt is slower on the split engine (10.1–10.2 seconds versus 7.65–7.81), answers aren't bit-identical to the layer split, and it skips logprobs and logit_bias entirely. Turn it off with strata launch --split-engine off or STRATA_SPLIT_ENGINE=0. The desktop app gets the split engine in a follow-up 0.2.10.1; for now its app keeps the layer split with DFlash2.
8 GB cards, 128K context, vision on Mac
Small cards have always had to shrink their context as memory ran short. This update flips that. The default context is now 131,072 tokens even on 8 GB cards, and Strata preserves both your context and your request count by moving work off the card instead of cutting anything.
The memory walk is graded. First the KV window steps down, 20,480 then 8,192 then 4,096 tokens. Then the MTP layer drops when it can't fit. Then the prompt buffers shrink to 16 expert-cache slots instead of 128. As a last resort, the output head sits in pinned host memory, which makes decode roughly three times slower.
This only applies to discrete cards. Apple chips and integrated graphics like Strix Halo are excluded. On an 8 GB-class setup with DFlash2 alone, speeds ranged from 48–52 tok/s down to 31 tok/s once the head moved to host memory. Configs below roughly 5,200 MiB were refused outright.
The DeepSeek engine's picture tower now also runs on Metal, following antirez/ds4. On an M5 Max, 8 of 8 picture requests read correctly, with decode at 19–22 tok/s against 21–22 for text alone. The vision tower adds just 319 MiB of VRAM and doesn't move peak memory. An M4 ran it too; M1 through M3 fall back to a tested-safe plain kernel.
There's a new ISTA-DAS Coder as well. strata launch --model ISTA-DAS-Coder runs DeepSeek-V4.1-Flash with only 192 of 384 experts per layer kept, the ones chosen for code and agent work. It's smaller and faster with ~59.2 tok/s on four R9700s, ~22.8 on one, ~20–22 on Strix Halo and M5 Max, ~100 on an RTX PRO 6000 Blackwell. It trades some fidelity, landing at a perplexity of 4.645 versus 3.140 for the full model, yet matches the pruned sets on 54 of 61 tasks. The full set is a large download, roughly 191 GB, including an 110.6 GB Engram lookup table that stays on the SSD.
The floor is still high
The community response has been warm but clear-eyed. Early users described running the model for real programming tasks on consumer hardware as genuinely usable, with one calling a 32 GB card "the stack to run right now." Others pointed at the hardware floor: a local-coding experience at scale still wants a 5090-class GPU, 96 GB of RAM, and a strong CPU. Expensive. Sometimes hard to find.
Strata is candid about the caveats. Loading takes 1 to 3 minutes and 35–55 GB of RAM, and the PC may freeze while the model loads. A base set runs roughly 70 GB on disk, swelling to ~191 GB for the ISTA-DAS Coder. It handles one request at a time by default, making it a personal workstation rather than a team server. DeepSeek answers can shift slightly between even temperature-0 starts, and heavily SSD-streamed tool calls occasionally come out malformed. Windows coverage has gaps too: AMD DeepSeek support targets Strix Halo only, Intel Arc A750 aborts on certain 64-float programs, and the all-cards split engine hasn't landed on GeForce pairs, macOS, or Windows.
Where to start
The desktop app ships as a Linux AppImage, Windows installer or notarized Mac dmg. Head here to the GitHub release page.
