Strata: Running Qwen 3.8 Flash Next on a 12 GB Card

What Strata is

Strata is an open-source engine that runs Qwen 3.8 Flash Next, a 180-billion-parameter model built for servers, on one gaming card with 12 to 24 GB and 64 GB of system RAM. It comes from Niko Veit (@coldniko), under the MIT licence, runs on NVIDIA and recent AMD cards on Linux and Windows, on Intel Arc and on Apple Silicon Macs, and serves an OpenAI-compatible API on your own machine. Since 0.2.0-beta it is an app, a Terminal and an engine underneath them.

Since 24 October it runs a second model family. Strata 0.2.4 puts DeepSeek V4.1 Flash 1017, a 763.2-billion-parameter model, on one 12 GB card with 46 to 64 GB of RAM, and it is the first model both Strata and Project Maya run, so the two engines can be set side by side. Strata 0.2.5 on 25 October brought it into the app. The section on it starts below.

The two parameter counts are both right. Qwen's card lists 125 billion parameters, plus a 51-billion-parameter n-gram embedding table and a 4-billion-parameter multi-token-prediction layer, and the files add up to 180.0 billion. The 125 billion is the network that computes; the 51 billion is a lookup table. Strata's whole design follows from that split. The engine itself, its download sizes and its release history have their own page: Strata engine: DeepSeek 748B on a Gaming PC, With One Catch.

It is a month old. The first release went up on 24 September, and on 25 October 2026 the repository lists 59 releases and 32,451 stars, against 828 on 28 September.

Latest: Strata 0.2.10, 2 November. The app and the Terminal are 0.2.10; Control and every engine package are 0.1.56. It starts Qwen3.8 Flash Next at 128K context on 8 GB discrete cards, makes DFlash2 the default drafter for Qwen3.8, runs a split engine across all the cards on Linux, adds the ISTA-DAS Coder for DeepSeek, and reads pictures on a Mac. The 0.2.9 cache reports are still open in the issue tracker; the 0.1.56 evidence is in the 0.2.10 section below.

Also, 1 November 2026. vLLM merged the same PLE-on-disk trade for Qwen in its main branch, with limits: Qwen4Exp on CUDA only, and not yet DeepSeek. The section "vLLM Now Does the PLE Trick, With Limits" has the numbers. The detailed Strata release notes below stop at 0.2.5; the 0.2.10 and 0.2.9 sections cover the current releases.

Will it run on your PC? Our Strata calculator takes your graphics card, RAM and context and shows which build runs and what goes to the GPU, to RAM and to the SSD. It tracks Strata 0.2.10 as of 3 November: the pack sizes are unchanged, and the DeepSeek view now carries the ISTA-DAS Coder. It carries the card roles, Gyro on Intel Arc and Macs, the 5 GB the size pick leaves for the system, and the DeepSeek view at 0.2.9. Since 24 October it also sizes DeepSeek V4.1 Flash 1017: open it on a 12 GB card with 64 GB of RAM and change the card and the RAM. Its DeepSeek view follows 0.2.9: the 1-bit sets, the uncapped RAM store and the Faster mode are in it.

Strata Runs DeepSeek V4.1 Flash 1017 on a 12 GB Card

Update, 24 October 2026. The question for this model used to be how many big cards. Strata 0.2.4 answers it with one 12 GB card and 46 to 64 GB of RAM: the engine keeps the experts it uses most in RAM and streams the rest from the SSD. DeepSeek V4.1 Flash 1017 has 763.2 billion parameters, 384 routed experts per layer and 6 active per token, which is why most of it can sit on a drive and still answer. DeepSeek is in the Terminal (strata launch, strata setup); the app gained it in 0.2.5 on 25 October. Engine packages at the 0.2.4.2 release: Windows with NVIDIA RTX 30, 40 and 50 cards, Linux with the same cards, and Linux with Radeon AI PRO R9700 and RX 9070 cards.

Update, 25 October. Strata 0.2.5 puts DeepSeek in the app, with an 8K context and no calibration step, and adds a Faster or Full quality choice. The speed table below is the 0.2.4 release's; the 0.2.5 notes report new gains on several PCs, listed under the release below.

The files are ISTA-DASLab's, three sizes of the same model. The Engram table is the model's lookup memory, read a few rows a token, so it can live on the SSD. Strata's download figure includes the 111 GB Engram table and the DSpark drafter; ISTA's own card lists the backbone and the shared 110.60 GB Engram file separately.

Two views of quality, and they come from different people. ISTA-DASLab's own results, at reasoning effort 50, put IQ2_XXS at 93.54 on its task average, level with the base model (100.0%), and IQ1_M at 92.32 (98.7%). Strata's test, perplexity on 4,995 texts, is the second view; ISTA calls IQ2_XXS the recommended build. The IQ2_XS row on ISTA's card has no benchmark result yet, so its quality figure on this page is Strata's alone.

How fast, by engine version

Strata's own figures are for the 2.00-bit set; the 2.25-bit set reads 13% more data per token. Every other row is the poster's own figure. Each row stands alone: different RAM, builds, prompts and engine versions.

On the 12 GB cards the drive sets the pace: Strata says a slow NVMe drive lowers every number above, and on the RTX 5070 PC with 64 GB the RAM expert store gave 4.3 to 4.9 tokens a second where memory-mapping the files gave 1.8 to 2.2. DSpark, the drafter, is off by default on 12 GB cards; on the 5070 PC with a Ryzen 5 7600 it gave no gain at any setting. Both Strata and Maya ship almost hourly, so read any speed here as a number for that engine version, not a ceiling.

Our calculator's answer for the same 12 GB card and 64 GB of RAM is "Runs: the busiest experts in RAM, the rest from the SSD", and the tool says a 12 GB card runs it at 4 to 10 tokens a second.

How the RAM expert store works

The model is 15,360 routed experts of 18.8 MB each, 288.8 GB in all, plus 16.8 GB of attention and other dense weights and the Engram table. Strata's engine doc splits them three ways. The dense weights go to graphics memory. The experts go to the card "as many as fit"; the rest are computed on the CPU, read in place from the model files, and the RAM store keeps the busiest of those cached. The store sizes itself when the model starts. The Engram table stays on the SSD and is not counted in RAM, but it is read a few rows for every word, so a slow disk slows every word and the files belong on an NVMe drive. With less RAM than the CPU's experts need, part of them are read from the SSD while the model answers, and the doc's words for that are "It runs, slowly."

Strata's own fit check predicted 6,240 experts on the card for the four-R9700 machine and the engine held 6,197. That is at the default context of 8,192 tokens, the size the engine was checked at. Two things sit outside that check: a longer window asked for with --context, and the DSpark drafter, whose 7 GB of experts take graphics memory even when it is switched off, which is why Strata's start script leaves it on auto. So when an outside machine's placement is posted, read it against its context and its drafter before comparing it with an estimate: @DaSun64125381's report shows 2,357 experts resident on his RTX 5090 with 558 MiB of VRAM to spare.

Maya and Strata run the same model

Project Maya has run DeepSeek V4.1 Flash 1017 on its own engine, maya-ds4. Strata's engine doc says its DeepSeek engine is "ported from Project Maya's maya-ds4", and the notice in its repository says the files come from that engine (Maya release v1.1.17), with later changes taken from Maya releases v1.1.18 to v1.1.26, and that "Project Maya is itself built on Strata." So for the first time one model runs on both engines, and the two tools link to each other with the card and the RAM carried across. The Maya calculator lists Maya-S and Maya-XS from SSD for that 12 GB card.

The one card where both have published runs is the RTX 5090 32 GB. None of the three is a like-for-like test.

What the rows do show is that the quants differ before the engines do. Maya-S downloads at 347.5 GB and Maya's smaller Maya-XS at 280.9 GB, made for the whole model in a 128 GB PC's memory; Strata's three ISTA sets run 239 to 274 GB. The quality yardsticks do not convert either: Maya reports the share of next tokens that match the original (92.6% for Maya-S, 87.5% for Maya-XS), Strata reports perplexity. So we rank neither the quants nor the engines on this page. @niklaslenz_ai's raw page also records about 1,970 of 15,360 experts on the 5090 for his Maya run.

On a Mac, outside Strata's DeepSeek release, @niklaslenz_ai measured 54.5 tok/s on a Mac Studio M5 Ultra 256 GB with antirez's ds4 engine, in batched mode with 5 sessions (his post).

Strata 8 GB VRAM: 128K Context, and the RAM It Really Needs

Strata runs Qwen3.8 Flash Next at its default 128K context on an 8 GB graphics card as of 0.2.10, and that figure is about VRAM only. The model still reads its experts from system RAM and the SSD, so an 8 GB card does not make it an 8 GB machine. The card decides how much of the model stays on the GPU; the RAM decides whether the rest can be read fast enough to answer.

How an 8 GB card keeps 128K. When a start is short of graphics memory, Strata keeps the context and the number of requests and moves work off the card instead of shrinking the window. The walk has four steps: the KV window on the card steps down to 20,480, then 8,192, then 4,096 tokens; the MTP layer is dropped when it cannot fit; the prompt path keeps 16 expert-cache slots instead of 128; and as the last step the output head, 0.41 GiB, sits in pinned host memory, which makes decode about three times slower. It applies to discrete cards only, not to Apple silicon or an integrated GPU such as Strix Halo.

The three 8 GB results, kept apart. The release reports three different things and they should not be mixed:

• A real Intel Arc A750, 8 GB: all four 128K starts they tried started at the asked context and request count, at 12.7 to 14.8 tok/s. With the drafting setting on Auto it ran DFlash2 alone at 13.9 to 18.4 tok/s.
• A larger card limited by hand to about 8 GB, on a workstation with a lot of RAM: 63 to 73 tok/s for DFlash2 alone with 391 MiB of graphics memory free, and a 32K prompt read in 19.8 s. With MTP asked for, MTP was dropped and it ran 61 to 71 tok/s with 555 MiB free, reading the same prompt in 13.4 s. The release does not name the card.
• A real RTX 5070, 12 GB, limited to about 8 GB: the 128K start kept its context and ran 17 to 27% slower than on the full card. The absolute figure is not given.

What the card class really costs. At 128K with IQ3_S, the set the 0.2.10 test used, you need about 50 GB of experts plus about 6 GB of working set, which is a 64 GB machine. The smallest standard set, Q2_0, is about 34 GB of experts plus about 6 GB, so 48 GB is the practical floor and 64 GB is comfortable; the 28.8 GB n-gram table stays on the SSD and is not counted in either figure. A 32 GB machine should look at the Coder instead, at about 23 GB of experts.

What to expect from the headline. @coldniko's launch post says "20+ tokens/second" on an 8 GB card. The measured real 8 GB card is the Arc A750 at 13.9 to 18.4, and the 60s are the larger card limited by hand. On a home PC with less RAM than the test workstation, both will read more from the SSD and run slower.

12 GB cards are unchanged. That is the release's own line, and it is why the 12 GB guidance on this page still applies.

Which Build Strata Picks for Your Memory

Since 0.2.0 the app and strata launch suggest a size by RAM and VRAM added together, and since 0.2.2 they first take 5 GB off that total for Windows and the system. Strata's own example: a PC with 32 GB of RAM and a 16 GB card used to land in the 48 GB tier and then read about 11 GB of the model from the SSD on every answer; it now gets the 40 GB tier.

Inside setup the floors sit 2 GB under each name (62, 46 and 38), because the system reports a little less than what is installed. Every size stays a choice; the tier is a recommendation. With less RAM than a build asks for, the low-RAM mode starts by itself and reads experts from the SSD, more slowly. Our calculator's verdicts are our own arithmetic, and it shows Strata's pick beside them, labelled as Strata's.

Avalon vs Strata: What the 47% Measured

Avalon is a llama.cpp fork built around one model, Qwen 3.8 Flash Next, for AMD RDNA3 cards on ROCm. On its author's Radeon RX 7900 XT it is faster than Strata 0.2.9. On an NVIDIA RTX 4090 the two are level on short-prompt decode, and Strata reads prompts faster.

The figures below are the Avalon author's own, from the Avalon README (1 November): greedy decoding, 512 tokens, MTP with 2 draft tokens. The RX 7900 XT box is a Ryzen 7 3800XT with 64 GB of DDR4-3200 on PCIe 3.0. The RTX 4090 was a rented card with an EPYC 7443. Decode is in tokens per second, prompt reading is marked.

The README puts the AMD gap at 44% faster than Strata on a short prompt and 30% faster at 250K filled. Of the 4090 it says Strata's prefill is faster on that card.

The 47% in the videos is older than that. Three YouTube videos repeat it: Code Unpacked on 30 October, Kai on 31 October and Code Bear on 1 November. The figure compares Avalon at 91.0 tok/s against Strata 0.1.43 at 61.9, from the 22 October README. Against Strata 0.2.9 the author's current README gives 44% and 30%. Two of the titles say "9x". Nothing in the README supports that.

Limits. Every number is the Avalon author's, one machine per card. The engines ran different files: Avalon its own 89 GiB IQ3_KS hybrid, Strata ISTA-DASLab's IQ3_S. The repository shows 0 tagged releases on 2 November. It runs one model, multi-GPU is marked experimental and untested, and the Windows installer is in testing. One outside report: a Radeon Pro W7800 48 GB user on r/ROCm read 75 to 90 tok/s with a draft depth of 3, and 57 without MTP.

Who should try which. Avalon if you have a Radeon RX 7900 XT or XTX on Linux and only run Qwen 3.8 Flash Next. Strata for NVIDIA cards, several models, Windows, or a GUI.

Latest Updates, Newest First

0.2.10, 2 November: 128K on 8 GB Cards, DFlash2 by Default, and a Split Engine on Linux

Release notes. The app and the Terminal are 0.2.10. Control and every engine package are 0.1.56. It shipped at 23:52 UTC on 2 November, four hours after the 12 GB post that preceded it.

128K context now starts on 8 GB discrete cards. The four-step card walk, the real Arc A750 measurement, the hand-limited larger card and the system-RAM floor are in the section above, Strata 8 GB VRAM: 128K Context, and the RAM It Really Needs. 12 GB cards are unchanged.

DFlash2 is the default drafter for Qwen3.8, including Unsloth's files and Gyro. It is about 0.7 GB (the engine prints 625 MiB of graphics memory with the Q4_0 selector), so the 5.2 GB MTP layer is no longer downloaded or loaded on a first start; the first start fetches about 1.2 GB and builds the drafter file on your computer. Against MTP, same engine and files, runs alternated:

DFlash2 answers one request at a time. When you have not chosen a number of requests, the app now loads the model for one at a time, on one card and on several. To run several at once, choose MTP or set the request count in Expert mode. Auto picks MTP when two or more requests run at once, for DeepSeek and the ISTA-DAS Coder, on the split engine, and where no DFlash2 engine is installed. The choices are Auto, MTP, DFlash2 and Off, and each loads exactly one drafter.

The all-cards split engine starts by itself on Linux, from strata launch and the server it starts. In a layer split each card holds some layers; in the all-cards split every card holds a share of every layer, so all cards read the weights at the same time. Built from sFNX by John Fink, MIT. With Auto it starts when the machine is Linux, has exactly two NVIDIA cards of compute capability 8.6 (RTX 30, A6000 class) or 12.0 (RTX 50, RTX PRO 6000 Blackwell), or four Radeon AI PRO R9700 with a UD-Q4_K_XL-type file, the Qwen file fits entirely in the cards, there is enough free RAM (about 43 GiB, of which 27.5 GiB is the embedding table), and the context is 131,072 or less.

On two RTX A6000 at UD-Q4_K_XL and 128K, medians of three interleaved runs:

The cost is prompt reading on that pair: 10.1 to 10.2 s for a 32K prompt against 7.65 to 7.81 s on the layer split with DFlash2, and two or four 32K prompts at once run at 12.5 and 12.7 tok/s in total against 11.7 and 12.9. On two RTX PRO 6000 Blackwell the split ran edits at 666 to 741 against 420 to 432 tok/s and read an 8K prompt in 1.09 to 1.29 s against 2.44 to 2.49 s. On four R9700 it gave 158 tok/s for one user and 350 at eight, against 98 and 243 on the layer split, with a 103K prompt read in 33 s. --split-engine off, "split_engine": "off" or STRATA_SPLIT_ENGINE=0 turns it off; --split-engine on asks for it and prints why when it cannot run. The GeForce pair, 3 or 4 NVIDIA cards, Windows, macOS and contexts above 128K were not tested.

ISTA-DAS Coder for DeepSeek V4.1 Flash 1017. It keeps 192 of the 384 experts in every layer, the ones chosen for code and agent work. strata launch --model ISTA-DAS-Coder; the app lists it. A fresh install downloads 191 GB: the 72.1 GB model, the shared 110.6 GB Engram and an 8.0 GB drafter. The Engram stays on the SSD.

Quality against the original model, 4,995 positions: KL 0.397, top-1 76.4%, perplexity 4.645 (original 3.140). The 2.00 set is KL 0.171 and the 2.25 set KL 0.109, so the Coder is the rougher of the three. The 61-task suite gives 54 of 61, the same as both. ISTA-DASLab's own card: SWE-bench Verified 77.00 against 81.20 for the base, LiveCodeBench v6 88.57 against 89.71.

DeepSeek pictures on a Mac. The picture tower now runs on Metal, following antirez/ds4, MIT. On an M5 Max, 8 of 8 picture requests read correctly, decode with pictures ran at 19 to 22 tok/s against 21 to 22 for text alone, the tower adds 319 MiB and the engine's peak stayed at 74.0 GB. The first picture of a session adds 6.0 to 8.7 s for compiling the kernels once; later pictures add 0.8 to 1.0 s. M4 was tested for encoding only; M1 to M3 were not measured.

The 0.1.55 reports, one day on. Two things have changed since the 0.2.9 section.

First, #4733 is fixed. On Windows, an engine started from a low-priority program (Task Scheduler, a service, an IDE) inherited Low disk priority and read its model about 15 times slower, which cost about 14% decode. The engine now resets disk priority to Normal. That was the one non-default cause named in the 5090 comments on our 12 GB post, and it is gone in 0.1.56.

Second, 0.1.56 is measurably faster on the cards that were reported slow. @lyesbahi ran 0.2.10 on both his servers and posted paired before and after tables:

The P40 run is not stock: he names a long-lookup-window patch, so it is an old-card configuration, not a release result. The 5090 run is stock. He also reports that 99% of expert reads hit system RAM, which is the point of the configuration rather than a new feature.

#4841 is still open, last updated on 3 November at 07:24 UTC with 25 comments, and 0.2.10 does not name it in the fixed list. The 3090 at 204.8K is still reported at about 80 to 60 tok/s with 4,445 experts (13.0 GB) in VRAM against 5,413 (15.8 GB) on 0.1.52. So the cache story in the 0.2.9 section stands, and the paired 0.1.56 numbers above are evidence about a different card class, not a refutation of it.

0.2.9, 31 October: 1-Bit DeepSeek Sets, Faster Strix Halo Prompts, and the 0.1.55 Cache Reports

Release notes. The app is 0.2.9. The Control and every engine package are 0.1.55.

The release. Unsloth's 1-bit DeepSeek sets are now a choice in setup and the app. On Strix Halo Windows, Qwen3.8 Flash Next IQ3_S prompts read 1.8 times as fast as 0.2.8: 8K went from 791 to 1,424 tok/s and 32K from 778 to 1,460, with decode unchanged. DeepSeek 2.25 prompts read 1.24 to 1.66 times as fast on the same class of machine. Linux NVIDIA cards serve 1.45 times the 0.2.8 total at eight requests. The release also carries fixes from user reports.

The 0.1.55 cache reports. Some users on 12 GB and 24 GB cards see fewer experts in VRAM and lower decode than 0.1.52. The open report is #4841: an RTX 3090 at 204.8K with UD-Q4_K_XL went from about 80 to 60 tok/s, and 0.1.55 kept 4,445 experts (13.0 GB) in VRAM against 5,413 (15.8 GB) on 0.1.52. #4863's switcher author reports 6 / 40 / 100 tok/s on 0.1.55 / 0.1.54 / 0.1.52 on an RTX 3080 12 GB, and a 4070 Super user reports about 10 against 40 to 50. The 22.7% figure in #4826 was retracted by its author, who found expert-cache warm-up, not the engine version, and closed the issue. Part of the 12 GB slowdown is a changed default, not a bug. Strata 0.2.7 made the router prefer experts already on the card on NVIDIA cards of 13 GiB or less (RTX 3060: story +15%, code +37%). 0.2.8, with engine 0.1.54, switched it off again by default, because user reports and the developer's own checks tied it to repeated text in long sessions. The documented way back is the "Faster answers on 12 GB NVIDIA cards" row under Models, Native engine settings, Speed, or strata launch --set STRATA_ROUTE_PRIOR=1.5. It does not apply to the 24 GB 3090 in #4841, and one user there says it did not help on an RTX 3070. Users also report that --spec-min-p 0.8 with a higher spec depth helps on predictable text; that one is not official. Do not treat a downgrade as the first fix.

0.2.5, 25 October: One Installer, DeepSeek in the App, a Faster Mode

Release notes. The app and the Terminal are 0.2.5. Every engine package, Qwen and DeepSeek, and the Control are 0.1.50.

• One installer per system. A setup program on Windows, an AppImage on Linux and a dmg on Apple Silicon Macs. The Windows and Linux files no longer carry an engine: on first start the app shows the engine for your graphics card with its size and one Download button, with progress and resume, and "I already have the file" installs a file you fetched yourself, offline. The Mac file keeps its small Metal engine inside. This replaces the per-card installers of 0.2.3.
• DeepSeek V4.1 Flash in the app. The model picker lists the three official sizes with a plain note on size, speed and disk that warns and never blocks. The context is fixed at 8K and there is no calibration step.
• A Speed choice for DeepSeek: Faster or Full quality. Faster uses 5 of the model's 6 experts per word, a small quality change the release calls usually not noticeable. It is the default on a PC with 16 GB of graphics memory or less and on PCs whose graphics share the computer's memory (Strix Halo). In the Terminal it is --speed, --full-quality or --experts N, and it needs DeepSeek engine 0.1.50 or newer. The release measured Faster mode on an RTX 5070 at 16% faster decoding of code and agent runs, and on a Strix Halo at 11 to 13% faster decoding and 5 to 7% faster prompts. On an MI325X the quality checks showed no difference from Full quality.
• DeepSeek is faster on many PCs. The RAM store used to stop at 48 GB; where the free RAM holds every routed expert it now keeps all of them and still leaves 12 GB free (one R9700 with 251 GB of RAM: 12.6 to 21.4 tokens/s on the 2.00 set). The CPU starts on the experts it already has while the rest are read from the SSD, which the release measured at +13.5% on an RTX 5070 and +11 to 15% on an RTX 3060 PC. On Strix Halo the prompt kernels use the matrix units: prompts 22% faster at 4K and 29% at 8K, with the same answers.
• Qwen engine. On one CUDA card with all experts in RAM, the engine now tries the asynchronous tier itself, measures it for 64 windows and keeps it only if it is not more than 2% slower.
• Terminal and app fixes. An NVIDIA driver from 528 to 579 runs the CUDA 12 engine by itself and says so, a big model gets a longer start wait by itself, and strata update says "the engine was NOT updated" when it was not. The app no longer shows a finished update as "Interrupted operation", and pasted screenshots are read. The release lists many more.
• Known issue: uninstalling Strata on Windows right after using it can leave its program folder behind; close Strata first.
• Updating: the in-app updater installs the new installer and keeps your engine. In the Terminal run strata update, and the DeepSeek engine updates itself on the next strata launch. Intel Arc on Linux (SYCL) needs Ubuntu 24.04 or newer.

0.2.4, 24 October: DeepSeek V4.1 Flash 1017 in the Terminal

Release notes. DeepSeek runs on its own engine package, strata-dsv41, which sits beside the Qwen engine and never replaces it; Strata downloads the one that fits your PC when you choose DeepSeek in strata launch or strata setup. The Terminal Control and the DeepSeek engine are at 0.1.49.2 in the 0.2.4.2 notes, which also say the DeepSeek engine updates itself on the next launch and that the 2.00 and IQ1_M sets answer up to 3x faster on AMD Ryzen 3000, Threadripper 3000 and EPYC 7002 CPUs. The app and every Qwen engine package stay as in 0.2.3. Thanks in the release go to ISTA-DASLab for the three sets and to Unsloth for the DSpark drafter. A 0.2.4.1 update fixed DeepSeek setup from the installed Terminal, whose package had missed the preparation scripts, and corrected the RTX 3060 figure to the release defaults of 8 to 10 tokens a second.

0.2.3, 23 October: Faster Strix Halo, Intel Arc Released, DFlash2 Opt-In

Release notes. The engine packages move to 0.1.48 and the app is 0.2.3.

• Strix Halo is faster. Measured on a Strix Halo PC (gfx1151, Windows, IQ3_S model, three pairs against 0.2.2): answer speed +6% to +19% and prompt speed +5% to +14%, with 4K, 8K and 64K prompts at 685, 783 and 749 tokens a second. The answers are not bit-identical to 0.2.2, and the release names a switch that restores the old read.
• Intel Arc is a released engine package (Linux, SYCL). B-series cards such as the Arc Pro B70 are now allowed; the Arc A750 is the card the maintainers tested.
• DFlash2 drafting is opt-in and Terminal-only. strata launch --drafting dflash2 uses the DFlash2 drafter in place of MTP. Auto means MTP, because no card has shown DFlash2 winning everywhere yet.
• The agent chat copes with a full context. On a scripted 64K window with five 34,000-character messages the peak prompt fell from 83% to 61% of the window.
• Better defaults. On an RTX 5070 12 GB PC the app's Work profile now uses 5 CPU workers and keeps 1536 MiB of video memory free, and answer speed rose from 31 to 45 tokens a second against the 0.2.1 app. The conversation cache is sized from free memory: with two agents sharing a model, 91% of the prompt was reused instead of 0%.
• 0.2.3.1, the same day, fixed a setup crash on the Windows NVIDIA package (#3810); only the Terminal's Control changed.
• Limits the release states: two runs of the same prompt can differ at near-tie words, and the RX 6000, RX 7000 and Arc B-series cards were not run on real hardware. From 0.2.0-beta, run the install command once more rather than strata update.

0.2.2, 21 October: Card Roles, Gyro on Intel Arc and Macs

Release notes. The engine packages move to 0.1.47.

• Each card is Main, Helper or Off. Main holds the last layers, the draft layer and the final check of every window; a Helper holds a share of the layers and of the expert cache; an Off card is not used at all. The best card starts as Main, the others as Helpers, and a card with 8 GB or less starts Off. On the command line it is strata launch --gpu-roles 1=main,0=helper. Tested on two RTX A4000; the release says AMD and Intel cards with roles are not tested.
• Gyro on Intel Arc, Linux, tested on an Arc A750 only. On the A750 (8 GB, 62 GB of RAM) Gyro-S writes 15.8 tok/s with the draft layer and reads a 20,000-token prompt at 195 tok/s. The card holds 410 of 24,576 experts, so the CPU and the PCIe link carry most of the work.
• Gyro on Apple Silicon Macs. Gyro-S needs about 38 GB to stay in memory, so a 48 GB Mac holds it and a 32 GB Mac streams the experts from the SSD. Measured on a Mac mini M4 with 32 GB: 9.1 tok/s decode and 109 tok/s on a 4K prompt. Gyro-M was not run end to end on a Mac, and Gyro is never the Mac default.
• Gyro is faster on NVIDIA. New trellis kernels, same answers bit for bit:

Gyro-S, 0.2.153.6

Gyro-S, 0.2.262.8

Gyro-M, 0.2.150.6

Gyro-M, 0.2.256.1

Medians of 5 interleaved pairs. Gyro-S +17%, Gyro-M +11%; prompts unchanged. Only the RTX 3060 was timed.

• A start that is a little short shrinks instead of stopping. Setup and strata launch try a 32K, then 16K and 8K context, a smaller prompt chunk and a smaller reserve, in that order, and keep anything you set yourself. Gyro-M on the 8 GB A750 used to stop; it now starts at 16K and answered at 16.6 tok/s. This runs in the Intel Arc setup and the Terminal launch; the app's own fit check is unchanged.
• Also new: an engine package for the RX 6000 series (built, not run on a real RX 6000 card), Gyro about 30% faster on a Tesla P100, one models folder shared by the app and the Terminal, an optional API key, and one definition of answer speed everywhere.

0.2.1, 20 October: Pictures on Macs and Intel Arc, Docker Images

Release notes. Engine packages 0.1.46.

• Pictures on the Mac, by default, on the Mac's GPU. On an M4 Mac a 972-token picture reads in 2.4 s against 194 s on the CPU; the GPU reader takes about 1.2 GB of memory.
• Pictures on Intel Arc. The A-series reads them by default through the CPU reader, the B-series stays opt-in, and a new GPU reader (--vision gpu) takes 0.16 s per picture on an A750 against 1.73 s on the CPU.
• Docker images for CUDA 13, CUDA 12 and three AMD targets. The start-up test passed on an RTX A4000 and a Radeon AI PRO R9700; there is no Intel image yet.
• Your own engine settings stay. The app used to rewrite the run config on every Load, which for one reporter cut decode from 80 to 50 tok/s by forcing a 1,536 MiB reserve.
• A compute-only card keeps less in reserve: 512 MiB (700 with pictures) instead of 1,536 MiB, so the expert cache gets more room. A card that drives a screen keeps the safety default.
• Faster defaults where they were measured: prompts 1.6 to 2.03 times faster on a Radeon 780M mini PC under Linux; two NVIDIA cards serving several requests at once about 12 to 16% faster; packed models on a 32 GB Linux PC decoding 1.21 to 1.38 times faster.

0.2.0-beta and 0.1.45, 17 to 19 October: An App, a Terminal, Pictures by Default

0.2.0-beta went up on 19 October (notes), with engine 0.1.45.3 inside. Its change is structural. The app installs on Windows, on Linux as an AppImage and on Macs (Apple silicon, macOS 15 or newer): chat with a coding agent, web search, pictures pasted into the chat, a Models page, a Storage page, a choice of which cards a model uses and two models on two GPUs. The Terminal installs with one line: strata launch is the guided flow, and strata connect sets up OpenCode, Codex CLI, Claude Code, oh-my-pi, pi, Hermes Agent and OpenClaw. The engine is a separate package per platform and card, so a fresh install starts a model without a download, and later engines arrive from a signed feed, test-started before the switch and rolled back on any failure.

Pictures are on by default, and from 24 GB the card pays for them. Under 24 GB the reader runs on the CPU and takes nothing from the card. From 24 GB it runs on the GPU, where, in the release's words, "the GPU reader keeps 1,470 MiB of VRAM". On a Radeon AI PRO R9700 Strata measured a 972-token picture at 0.40 s on the GPU reader against 14.1 s on the CPU. --vision gpu, --vision cpu or off still choose per model.

Two new files on the ladder. NVFP4-QAD is NVIDIA's FP4 trained for FP4: a 102.2 GB download that the PC turns into a Strata pack once, with 110 GB more disk for that one-time build, 80 GB of RAM, NVIDIA only. Gyro-S and Gyro-M are trellis builds, one GGUF each, sized by memory in total: setup calls Gyro-S "the smallest option, for PCs with little memory (27.6 GB of VRAM + RAM together)" and puts Gyro-M at about IQ3_XXS quality at 35 GB. Neither is anyone's default.

Fixes worth knowing. Gyro-S gave empty or garbage answers on RTX 50 and RTX PRO cards before 0.2.0. A clean Windows PC could not start the engine without the CUDA toolkit on its PATH; packages now carry every library they import. On Linux, a model read in place from its GGUF files reads a 20K prompt 2.46 times faster on an RTX 3060 with a SATA drive. Three days earlier, 0.1.45 (notes) gave Qwen 3.6-35B-A3B pictures and parallel requests and left answers on the Flash Next builds byte-identical.

Limits the release states. The Windows installers are not code-signed yet, so Windows shows "Windows protected your PC" (choose More info, then Run anyway), and the AMD Windows installer was built without the maintainers running it on a real AMD card.

What We Measured on One 96 GB Blackwell Card, 17 and 19 October

We ran Qwen 3.8 Flash Next in Strata on one NVIDIA RTX PRO 6000 Blackwell Server Edition with 96 GB (97,887 MiB, ECC enabled, driver 580.82.07) on Linux, on engine 0.1.44.1 on 17 October and on 0.1.45.3 on 19 October. Each build ran at a 128K and a 262K window with the same request every time: one long document (116,294 tokens at 128K, 234,932 at 262K), the same ~400-word report prompt, temperature 0, thinking off, a 512-token answer cap, streamed. One measured request per cell, made to check our calculator's memory model rather than to chase speed.

128K, engine 0.1.44.159.48

128K, engine 0.1.45.3168.99

262K, engine 0.1.44.164.27

262K, engine 0.1.45.3186.11

Our run, one measured request per cell. Prefill barely moved and first token stayed where it was.

Three days of releases nearly tripled decode and left the memory alone. NVIDIA's own checkpoint pack wrote 182.01 tok/s at 128K and 175.61 at 262K on identical memory lines. The w4a4 prompt path read prefill at 7233.0 tok/s against 6178.4 (+17.1%), first token 14.6% sooner, with decode flat.

NVFP4 pack72.92

Gyro-M39.4

Gyro-S32.5

Our run at 128K, picture reader on. Every expert of all three sat on the card.

Gyro-S wrote 173.14 tok/s at 128K on less than half the NVFP4 pack's memory; Gyro-M wrote 128.87 and 106.66 for its higher quality tier. On a card this size there is no split to make, in the engine's own words: every expert is in the GPU cache (24576 of 24576), with the n-gram table read from the model file and the KV cache streaming to pinned RAM beside the card.

The picture reader, measured. Idle VRAM rose by 1.67 GB between our run with the reader off and the one with it on, and the engine's own expert-cache line moved by the same amount: a little more than the 1,470 MiB the release states, with about 0.23 GB we leave unattributed.

Two refusals. The prompt option w4a4x2 is still in Strata's NVFP4 documentation and the 0.1.45.3 engine refuses it: STRATA_PREFILL_NVFP4=w4a4x2: expected w4a8, w4a4 or fp16. NVFP4-QAD never started: setup asked for about 221 GB free against the 207.4 GB the machine had, and refused before a byte moved.

What it did to the calculator. The calculator now plans the expert cache 1,470 MiB short on one discrete NVIDIA or AMD card of 23.5 GB and more. The one published community run that had its GPU reader on moved from +13.1% error against our model to +6.3%. Gyro-S and Gyro-M entered the build list placed by those log lines rather than by the pitch text. The full run set (every build, window and memory line) goes into the next issue of our sizing guide for paid readers.

0.1.44 and 0.1.44.1, 13 and 14 October: Macs, NVFP4, Unsloth's Larger Files

0.1.44 notes, 0.1.44.1 notes; the author says 0.1.44.1 is the one to use.

• Apple Silicon, experimental. M1 to M5 Macs, macOS 15 or newer, with ./setup.sh building the Metal engine from source in about seven minutes. On the author's M5 Max with 128 GB, decode with the draft layer is 1.6 to 1.9 times llama.cpp's on the same files (IQ3_S 95 to 103 tok/s). One request at a time, measured to 32K.
• Four more Unsloth files and two NVFP4 packs as regular choices, each pinned by size and SHA-256; sizes are in the build table below. NVFP4 is NVIDIA only: RTX 50 cards have FP4 tensor cores, and on older RTX cards the author says UD-IQ4_XS is faster.
• Qwen 3.6-35B-A3B in the same binary, NVIDIA and AMD only, sized by RAM at 32, 44 and 52 GB.
• IQ3_S replaced IQ3_XXS as the 64 GB default.

0.1.42 and 0.1.43, 10 and 11 October: Faster Decode, the Same Memory

0.1.42 (notes) turned on a routing shortcut on NVIDIA worth about 13 to 16% more decode; STRATA_ROUTE_TAIL_SKIP=0 brings 0.1.41's answers back. 0.1.43 (notes) added up to 38% on a 16 GB Radeon, 5 to 11% on RTX 30 and Tesla P100 cards under Linux, 14 to 21% on an Arc Pro B70, and a ten-minute benchmark after installing. Neither changed how much memory a build needs.

Earlier Releases, 30 September to 7 October

Every Build, Side by Side

Strata's setup offers 15 files for Qwen 3.8 Flash Next. The figures are setup's own, re-read at 0.2.2 on 21 October and unchanged since 0.2.0-beta. "Experts" is the expert arena, the part that lives in RAM or on the card; the rest of the download is mostly the 28.8 GB n-gram table, which stays on the SSD.

The Coder keeps 256 of each layer's 512 experts, chosen on code, agent and vision data; its authors report 91.3% of the full model's SWE-bench Verified. Strata's docs say it is weaker outside code and in every language but English, and in Strata's tracker @lybhb8 found it answered 0 of 10 Chinese prompts correctly where Q2_0 answered 10 of 10. If you write in any language other than English, take a build that keeps every expert.

Where the Model Lives

Fully resident, the model does not come close to a gaming card. Our engine, the one behind the calculator, sizes Qwen 3.8 Flash Next at 76.0 GB at Q2_K and 106.8 GB at Q4_K_M with 8K of context, which is why our Flash-Next VRAM page points at a DGX Spark. 26.8 GB of either figure is the n-gram table.

Strata spreads the same model over three kinds of memory:

The experts are the trick. Each token uses 10 of each layer's 512 experts. The card keeps the ones asked for most, learned from use, and the CPU computes the rest where they sit in RAM, at the same time as the GPU works. Every extra gigabyte of VRAM holds about 700 more experts, which is why a bigger card is faster but does not lower the RAM needed. A card big enough for every expert changes the placement, as our 96 GB run showed above.

This is offloading, and it is the part our main tools deliberately do not model: they answer what fits fully on the card. Strata is the case where a careful split beats that answer by a wide margin, the same question our 405B on 8 GB page asks of a larger model.

vLLM Now Does the PLE Trick, With Limits

Update, 1 November 2026. vLLM merged PR #59958 on 30 October, and vLLM's main branch can now keep Qwen3.8 Flash Next's 51B PLE n-gram table in the checkpoint's safetensors files. It reads only the rows a token needs and leaves the rest to the OS page cache, instead of making the table resident in VRAM or pinned RAM. On one DGX Spark GB10 with the NVIDIA NVFP4 checkpoint, the PR's own measurement reads 99.09 GiB loaded against 72.09, 32.0 GiB of host MemAvailable against 4.6, decode 32.45 tok/s at one stream against 33.63 (3.5% lower), 73.33 against 72.57 at four streams, 91.99 against 94.04 at eight, and an 8K time to first token of 2,820 ms against 2,540 (11% higher). GSM8K moved from 247/256 to 246/256.

The limit is narrow. The flag is --engram-config '{"disk_offload": true}' and it applies to Qwen4Exp on CUDA only. DeepSeek V4.1's Engram table is not covered: that is a separate open PR (#62238), and DeepSeek's default path uses CPU offload, not disk. The vLLM docs also say the checkpoint files must not change while the server runs, weight reload and elastic EP are unsupported, and .bin, runai, fast-safetensors and instant-tensor checkpoints are refused. A cold 8K prefill reads about 1 GB from disk and adds about 20% time to first token on local NVMe; on network storage it is 2 to 4.5 times slower.

That is the same trade this page describes for Strata's n-gram table, now in stock vLLM for one model family. It does not make Strata redundant on a 12 GB card, and it does not yet do it for DeepSeek. The post that surfaced it, @TeksEdge's "vLLM adopted a trick Strata uses", is right about Qwen's PLE and too broad if read as every model or every vLLM release. The feature is in main and nightly, not in v0.32.0, which shipped on 18 October before the merge.

Which PC It Needs

The Strata calculator does this arithmetic for every build at once. Strata's rule of thumb is RAM of at least the build's first shard plus about 10 GB for Windows and everything else, and a card with 12 GB or more:

• NVIDIA: RTX 20, 30, 40 and 50 series in the ready-made engine, driver 580 or newer; older cards and drivers through the CUDA 12 engine.
• AMD: RX 7900, RX 9070, RX 9070 XT and R9700 through ROCm on Linux, and on Windows since 0.1.34; an RX 6000 package since 0.2.2, built and not yet run on a card.
• Smaller cards: 8 GB runs, slowly, and since 0.1.38 a 6 GB card starts.
• Processor: AVX2 for the ready-made engine, which covers any desktop CPU from the last eight years or so. Older ones are covered below.
• Disk: about 80 GB for the 2- and 3-bit builds.

Its README warns that while the model starts, the PC "can be slow or stop responding for 1-3 minutes", longest the first time.

How Fast It Writes

Owners post their own numbers, on their own prompts. Each row stands on its own: different engines, contexts and settings.

@lyesbahi's 185 tok/s ran with every expert resident in system RAM at a 98.5% cache hit, and @geldeki's best long run held 195 tok/s over 27,500 tokens.

For coding agents, check the prompt cache before tok/s. @murasametech ran Strata under OpenCode on an RTX 5070 12GB plus an RTX 5060 Ti 16GB and found 94% of the waiting was prompt reading: with --prompt-cache 0 every step re-read the whole conversation. Set to 6, a three-turn test took 94.8 seconds, then 6.9, then 4.1 (his post, in Japanese). The cache is on by default; if an agent re-reads everything every turn, look for a stray --prompt-cache 0.

The author's own baseline, from the first days: an RTX 5070 with 12 GB, a Ryzen 5 7600, 64 GB of DDR5-5200, Windows, engine 0.1.14, one code-agent prompt per length, 256 tokens, with the draft layer on. Later engines are faster; the shape still holds.

IQ3_XXS and IQ3_S were not measured at 262K: with 43 and 50 GB of experts, a full window takes a 64 GB PC to its memory limit, so setup caps them at 128K.

What the Smaller Builds Give Up

ISTA-DASLab publishes the quality of each of its builds against the full BF16 model, 354 GB:

The fastest build costs about four points of task average, most of it in code; IQ3_S matches the full model on these tests. ISTA-DASLab reads its own above-100% results as benchmark noise.

Strata's author ran a second test against Q8_0 for 0.1.44, teacher-forced on 4,995 positions: how often each build picks the same next token.

UD-Q6_K_XL94.6

UD-Q5_K_XL94.6

UD-Q4_K_XL93.1

NVFP492.1

UD-IQ4_XS88.9

IQ3_S87.7

IQ3_XXS84.5

Q2_080.6

Mean KL from 0.033 for UD-Q6_K_XL to 0.315 for Q2_0.

Long tasks widen the gap. On 7 October Benjamin Marie published agentic coding results for four Flash-Next GGUF builds: ISTA-DASLab's IQ3_S came out "excellent", and builds that held up on single-turn tests could do poorly on long tasks. He would not go below IQ3_S (his post, his article), which is also what Strata now picks from 64 GB.

Older CPUs and Older Cards

From Strata's creator, 2 October. We pointed out on X that Strata refused CPUs without AVX2, which rules out the cheap DDR3 workstations. Niko Veit answered us directly: "Old CPU support comes in next week!" His reply on X. It shipped two days later, in 0.1.39.

Older processors, experimental since 0.1.39 (notes). Setup warns on a CPU without AVX2, then compiles the engine for it once, in 10 to 20 minutes: AVX-only chips such as Sandy and Ivy Bridge, the Xeon E5 v1 and v2 and AMD's Bulldozer, and SSE4.2-only Nehalem and Westmere. Only the i-quant builds run there (IQ2_XS and IQ3_S, not Q2_0), the CPU's share of the work is slow, and Strata's own test PC has no old CPU. Forced onto that PC's Ryzen, the AVX build wrote 11 to 17 tok/s and the SSE4.2 build 3.5 to 3.8, against 26 for the normal engine. The work grew out of two community pull requests, #394 by demetree and #595 by 4EverBuilder.

Older NVIDIA cards. The P40, P100, GTX 10 series, V100 and Titan V use a second engine built with CUDA 12.9, which is also the route for a driver older than 580 (528 or newer on Windows, 525 or newer on Linux). 0.2.2 restored Pascal and Volta code to the Linux CUDA 12 package and ran an IQ2_XS model on a Tesla P100.

AMD's older cards. The Instinct MI50 and MI60 and the Radeon VII build by hand; the notes cite two MI50s running the Coder at 50 tok/s at 4K. Strata owns none of this older hardware: each path is compile-checked and the figures come from the people who ran them.

Intel Arc and the XeStrata Fork

Intel Arc has been officially supported on Linux since 0.1.40.2, through a SYCL port of Strata's own engine. The author's figures at a 4K prompt:

0.1.43 added 14 to 21% on the B70, 0.2.1 brought pictures, and 0.2.2 brought Gyro.

XeStrata, by MistVVK, is a separate fork that rewrites Strata's GPU code for SYCL and Level Zero and also compiles for AMD and NVIDIA cards, under the LGPL 3.0. Against Strata 0.1.41 on the same PC, IQ3_XXS, by its developer's own runs:

@ClayShoaf ran it on one Arc Pro B70 with 64 GB: XeStrata wrote 64.5 to 69.8 tok/s on four agent tasks against 24.0 to 38.8 for Strata's own SYCL build. Its xe0.1.45-1 release on 18 October "carries upstream Strata up to v0.1.45" and adds Windows, so the app and picture reader of 0.2.0 are not the fork's story. Packages up to xe0.1.40.2.2 carried the wrong GPU code on some cards, including the RTX 30 and 40 series (notes); update before you test.

Macs and Ryzen AI Max

Macs. Since 0.1.44 Strata runs on M1 to M5 Macs through its own Metal engine, experimentally; 0.2.1 added the picture reader and 0.2.2 added Gyro. A pack stays in memory when it fits the engine's cap, and otherwise its experts stream from the SSD; the author puts Q2_0 on a 32 GB Mac at 8 to 14 tok/s. The Strata calculator's Mac tab shows which side of that line your Mac falls on. Inco Splash is the other Mac route and one of Strata's credited influences, though it runs Qwen 3.8 27B and Qwen 3.6-35B-A3B rather than Flash Next.

Ryzen AI Max (Strix Halo), experimental since 0.1.40. Setup treats the chip's memory as one pool and recommends UD-IQ4_XS. Strata's own measurements on a Ryzen AI Max+ 395 with 128 GB:

Since 0.2.1 the packaged Strix Halo engines use a tuning table that read prompts 2.11 times faster in a community test, and 0.2.1.2 fixed a start failure on Windows.

The Switch Named "Speed Projection"

Strata ships an optional "experimental speed projection", off by default. Its documentation quotes the vector's own package: "a refusal-direction projection", with which the model "declines far fewer requests (it reports 1 of 50 vs 50 of 50 on its test set)". It is not a speed feature; it costs 0.2 to 0.4% per token and changes the top token at 10% of positions. It is the technique our abliterated models page explains, applied at run time, and setup asks before turning it on.

Who Should Try It

• A 12 to 24 GB NVIDIA or recent AMD card with 64 GB of RAM: the machine it was built for. Strata picks IQ3_S there, which is also the floor Benjamin Marie's long-task tests set.
• Less memory, RAM and VRAM counted together: 48 GB gets IQ3_XXS, 40 GB Swift 1.5's IQ2_XS or Gyro-M, 32 GB Gyro-S or the Coder for code. Since 0.2.2 take 5 GB off your total first.
• A card of 24 GB or more, pictures wanted: the reader runs on the card by default and keeps 1,470 MiB of it from the experts. Under 24 GB it runs on the CPU and takes nothing from the card.
• A 12 GB card, 46 to 64 GB of RAM and 239 to 274 GB of free disk, DeepSeek wanted: Strata's release says 46 GB worked on the RTX 3060 and 64 GB is the tested comfortable size; a fast NVMe drive matters.
• An Intel Arc card, a Mac or a Ryzen AI Max: supported, with the limits in the sections above.
• To check your card first: the GPU checker says what runs fully on it; the Strata calculator says which Strata build your card and RAM can run.

FAQ

What is Strata?

An open-source, MIT-licensed engine by Niko Veit that runs Qwen 3.8 Flash Next, and since 0.2.4 DeepSeek V4.1 Flash 1017, on one NVIDIA or recent AMD card with 12 to 24 GB and 64 GB of RAM, by keeping the model's experts in system RAM, the busiest of them cached on the GPU, and its n-gram table on the SSD. Since 0.2.0-beta it ships as an app, a Terminal and the engine underneath them.

Does Strata run DeepSeek V4.1 Flash 1017?

Yes. Strata 0.2.4 added it to the Terminal on 24 October and 0.2.5 added it to the app on 25 October, with an 8K context there. It needs one 12 GB card, 46 to 64 GB of RAM and 239 to 274 GB of disk for ISTA-DASLab's IQ1_M, IQ2_XXS or IQ2_XS set. On 12 GB cards Strata's own table shows about 5 tokens a second on an RTX 5070 and about 8 to 10 on an RTX 3060. Those are 0.2.4 figures, and the 0.2.5 notes report further gains on several PCs.

How is Strata different from Project Maya?

Both place a model's experts across the GPU, RAM and the SSD, and since 24 October both run DeepSeek V4.1 Flash 1017. Strata's repository says Project Maya is built on Strata and that Strata's DeepSeek engine files come from Maya's. The difference you see is the files: Maya ships its own Maya-S and Maya-XS quants, Strata uses ISTA-DASLab's sets. Our Maya calculator and Strata calculator size the same machine for each.

What is new in Strata 0.2.5?

Released on 25 October: one installer per system that downloads the engine for your graphics card on first start, DeepSeek V4.1 Flash 1017 in the app with an 8K context, a Faster or Full quality choice for DeepSeek, and a RAM store that holds every expert when the free RAM allows. Before it, 0.2.4 on 24 October brought DeepSeek to the Terminal, and 0.2.3 on 23 October a faster Strix Halo, Intel Arc as a released engine package and opt-in DFlash2 drafting. The 0.2.2 card roles (Main, Helper or Off) and Gyro on Intel Arc and Macs are still in.

Does Strata run on an 8 GB graphics card?

Yes, at 128K context, since 0.2.10, on discrete cards. A real Intel Arc A750 8 GB started all four 128K tests at 12.7 to 14.8 tok/s, and 13.9 to 18.4 on Auto with DFlash2. The catch is the rest of the PC: at 128K with IQ3_S you need about 50 GB of experts plus 6 GB, so 64 GB of RAM; the smallest set, Q2_0, needs about 34 plus 6, so 48 GB. The 8 GB card changes where the experts sit, not how much RAM the model needs. The "20+ tok/s" in the launch post is a larger card limited by hand to about 8 GB, not a real 8 GB GPU.

How much RAM does Strata need?

Its rule is the build's first shard plus about 10 GB: with 64 GB every ISTA-DASLab build fits, with 48 GB Q2_0 and IQ2_XS, with 32 GB the Coder. For DeepSeek, 46 GB worked on an RTX 3060 and 64 GB is the tested comfortable size. The size Strata recommends counts RAM and VRAM together, less 5 GB since 0.2.2: IQ3_S from 64 GB, IQ3_XXS at 48, Swift 1.5's IQ2_XS or Gyro-M at 40, Gyro-S below that. A bigger card makes it faster but does not lower the RAM it needs.

How fast is Strata?

It depends far more on the engine version than on the card. On our NVIDIA RTX PRO 6000 Blackwell 96 GB, the NVFP4 pack went from 59.48 tok/s on engine 0.1.44.1 to 168.99 on 0.1.45.3 at 128K. Owners report 185 tok/s on average on one RTX 5090 with 121 GB of RAM (@lyesbahi), about 153 sustained on two RTX 3090 (@geldeki), and about 40 on two RTX 3060 (@needmorevram).

Does Strata run on an older CPU without AVX2?

Yes, as an experimental option since 0.1.39, released on 4 October. Setup compiles the engine once for an AVX-only or SSE4.2-only CPU; only the i-quant builds run there, the CPU's share of the work is slower, and Strata has not tested it on a real old CPU.

Does Strata run on AMD cards?

Yes: the RX 7900 series, RX 9070, RX 9070 XT and Radeon AI PRO R9700 on Linux and Windows, Ryzen AI Max experimentally, and since 0.2.2 an RX 6000 package that was built but not run on a real card. The release notes still say nothing has run on a real AMD card on Windows with the 0.2 installers.

Is Avalon faster than Strata?

On the Avalon author's RX 7900 XT, yes: with MTP it decodes 98.4 tok/s against 68.4 for Strata 0.2.9 on a short prompt (44% faster) and 81.1 against 62.6 at 250K filled (30%). On a rented RTX 4090 the two are level on short-prompt decode, 141.9 against 141.4, and Strata reads prompts faster. All of it is from the Avalon README, one machine per card.

Does Strata run on Intel Arc or a Mac?

Both, with limits. Intel Arc is officially supported on Linux, tested on an Arc Pro B70 and an Arc A750, with pictures since 0.2.1 and Gyro since 0.2.2. Macs run experimentally from M1 to M5 through Strata's own Metal engine, with pictures since 0.2.1 and Gyro since 0.2.2; Gyro-S measured 9.1 tok/s on a 32 GB Mac mini M4.

Does Strata read pictures by default?

Yes, since 0.2.0-beta on NVIDIA and AMD and since 0.2.1 on Macs and Intel Arc A-series cards. A card under 24 GB gets the reader on the CPU and loses nothing; from 24 GB it runs on the card and keeps 1,470 MiB of VRAM. Our own runs on a 96 GB card measured 1.67 GB more idle VRAM with the reader on.

What are Gyro-S and Gyro-M?

Two single-file trellis builds, sized by RAM and VRAM together: Gyro-S at 27.6 GB with a 58.5 GB download, the smallest option, rated below the 2- and 3-bit sizes in quality; Gyro-M at 35 GB with a 92.0 GB download, at about IQ3_XXS quality. Neither is a default. On our 96 GB card Gyro-S wrote 173.14 tok/s while using 32.5 GB of VRAM.

Does the 2-bit model lose quality?

On ISTA-DASLab's tests Q2_0 scores 89.07 on the task average against 93.12 for the full model, and IQ3_S 93.26. On long agentic coding tasks Benjamin Marie found the lower builds fall further behind and would not go below IQ3_S.

Does the calculator model the new builds?

Yes. The Strata calculator, 0.7 beta since 21 October, sizes all 15 builds from Strata 0.2.2 data, places Gyro from our own run, charges the picture reader on one NVIDIA or AMD card of 23.5 GB and more, and shows Strata's own size pick beside our verdict. With several cards it shows which one is Main, which are Helpers and which a card of 8 GB or less leaves Off, and on Intel Arc it shows the smaller start the 0.2.2 fit check would pick.

What is the experimental speed projection?

An optional control vector, off by default, that Strata's own documentation describes as a refusal-direction projection: the model declines far fewer requests with it on. It is not a speed optimization.

---