Strata 0.2.10

# Strata 0.2.10: DFlash2 is the default drafter, one model across all your cards on Linux, the ISTA-DAS Coder, DeepSeek pictures on a Mac, 128K on 8 GB cards

The app and the Terminal are 0.2.10. Control and every engine package are 0.1.56.

The numbers first

Speeds are in tokens per second (a token is a short piece of a word). Decode is the speed of writing the answer; a prompt is the text you send. DFlash2 and MTP are two drafters: small helper models that guess the next words so the main model can check them together. Greedy means always taking the most likely next word; sampled is the app's normal setting. The picture tower is the part of the engine that reads pictures.

• DFlash2 against MTP, Qwen3.8 on one card. Same engine and files, runs alternated between the two. Change in decode speed:
• Ryzen AI Max (Strix Halo) on Windows: UD-Q4_K_XL +12.0% on short answers and +8.8% on long ones; IQ3_S +8.4% and +4.0%.
• RTX PRO 5000 (CUDA, sm_120), IQ3_S: +7.88% on greedy answers, +6.23% on short sampled answers, +1.38% on long ones (2K tokens).
• Radeon AI PRO R9700 (one card, app sampling): +6.6% on short answers and +4.2% on long ones.
• DGX Spark, IQ3_S, app sampling: +5.8% over three rounds, about 0 in long agent sessions.
• Apple M5 Max, app sampling: UD-Q4_K_XL +7.4%, IQ3_S +3.8%.
• Intel Arc A750: 2.6% slower than MTP.
• Greedy runs show larger gains than the sampled ones above.
• Two RTX A6000 cards on Linux, UD-Q4_K_XL, 128K context: the all-cards split engine against the layer split. In a layer split each card holds some layers of the model; in the all-cards split every card holds a share of every layer. Three interleaved pairs, medians of 3 runs.

| | layer split (0.2.9 default) | all-cards split | |---|---|---| | code edit, tokens per second | 195 | 377 to 394 | | new code | 139 to 144 | 189 to 232 | | prose | 93 | 139 to 146 | | agent loop (up to 123K-token prompts) | 112 to 119 | 165 | | 8K / 32K / 114K prompt, first token | 4.6 / 14.8 / 37.2 s | 2.50 / 9.4 / 34.0 s | | one, 2, 4, 6 requests at once (combined tokens per second) | 69, 104, 144, 168 | 108, 169, 212, 224 | | a 28K prompt joins running requests: its first token / the longest stall of the others | 8.0 s / 8.0 s | 8.45 s / 2.29 s | | 61-task suite, temperature 0 | 57 of 61 | 57 of 61 (same four failures) |

Against the layer split with DFlash2 (what Auto picks on a card the split does not cover), the split decodes 55% faster on edits, 7% on new code, 28% on prose and 9% on JSON on two A6000 cards (IQ3_S set). It reads a 32K prompt more slowly: 10.1 to 10.2 s against 7.65 to 7.81 s.

On two RTX PRO 6000 Blackwell cards (UD-Q4_K_XL; other users were using both cards during every run), the split against the layer split with DFlash2: edits ran at 666 to 741 against 420 to 432 tokens per second. An 8K prompt took 1.09 to 1.29 s against 2.44 to 2.49 s, and a 32K prompt 3.47 to 3.70 s against 7.01 to 7.36 s.

• Four Radeon AI PRO R9700 cards, UD-Q4_K_XL: the split engine is on by default (from the Terminal). Measured with the release package: 158 tokens per second for one user and 350 with 8 requests at once (--parallel 8), against 98 and 243 on the layer split. A 103K-token prompt took 33 s. With the default of 6 request slots, 8 requests run in two waves (255 tokens per second). IQ3_S stays on the layer split: 105 tokens per second for one user, 318 with 8 at once. One R9700 with UD-Q4_K_XL and DFlash2: 94 tokens per second and an 8K-token prompt in 4.4 s. The RX 9070 / R9700 package now ships a newer AMD runtime (TheRock 7.13). With it the split gained 27% with 8 requests; one card did not change.
• 8 GB cards start at 128K context. The test PC was made to hold what an 8 GB card holds (a larger card limited by hand; Qwen3.8 IQ3_S, 128K context):
• DFlash2 alone ran at 63 to 73 tokens per second with 391 MiB of graphics memory free, and read a 32K prompt in 19.8 s.
• With MTP asked for, Strata left the MTP layer out. It ran at 61 to 71 tokens per second with 555 MiB free, and read the same prompt in 13.4 s.
• Two and four requests at once also start now (they did not before). They run slower, because more of the work moves off the card.
• 12 GB cards are unchanged.
• On a real RTX 5070 (12 GB) limited to about 8 GB, a 128K start with DFlash2 kept its context and ran 17 to 27% slower than on the full card.
• On an Intel Arc A750 (a real 8 GB card), all four 128K starts we tried (DFlash2, and two requests at once) start, at 12.7 to 14.8 tokens per second.
• The ISTA-DAS Coder (DeepSeek-V4.1-Flash with 192 of 384 experts per layer): decode 59.2 tokens per second on four R9700 cards, 22.8 on one, 20.9 to 21.9 on Ryzen AI Max (Strix Halo), 19.1 to 22.5 on an Apple M5 Max, about 100 on an RTX PRO 6000 Blackwell. Table below.
• DeepSeek pictures on a Mac. On an M5 Max, 8 of 8 picture requests read correctly. Decode with pictures ran at 19 to 22 tokens per second against 21 to 22 for text alone. The picture tower adds 319 MiB of graphics memory, and the engine's peak stayed at 74.0 GB, the same as text alone.

What is new

• DFlash2 is the default drafter for Qwen3.8 (including Unsloth's files and Gyro). With the drafting setting on Auto, Strata runs DFlash2 where the engine has it: CUDA cards of architecture 8.6, 8.9, 12.0 and 12.1, Radeon gfx1100, gfx1151 and gfx1201, Apple Metal, and Intel Arc. DFlash2 is small, 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 not downloaded or loaded. The first start downloads about 1.2 GB (41.5 s on the test PC) and builds the drafter file on your computer.
• One drafter per run, never two. The choices are Auto, MTP, DFlash2 and Off (the app's Models page, strata launch --drafting, or the Terminal's Drafting step). Each loads exactly one drafter. A setting an older version saved that named both ("both", "mtp+dflash2") now counts as Auto. In the Terminal, Auto now overrides a choice the app saved in the model's file.
• Auto picks MTP when several requests run at once (--parallel or --batch of 2 or more), when no engine with DFlash2 is installed, for DeepSeek, the ISTA-DAS Coder and families other than Qwen3.8, and on the all-cards split engine (below), where split plus MTP decodes faster than layer split plus DFlash2. On a layer split over several cards that the split engine does not cover, Auto and an explicit DFlash2 now run DFlash2 alone (16 of 16 test requests gave the same tokens as without a drafter).
• DFlash2 answers one request at a time. When you have not chosen a number of requests, the app now loads the model for one request at a time with DFlash2, on one card and on several (0.2.9 filled in up to 4 at once with MTP). To run several at once, choose MTP, or set the number of concurrent requests in Expert mode.
• If an Auto start with DFlash2 stops before it is ready, Strata starts once more with MTP. If you choose MTP and its layer is not on the disk, DFlash2 runs and says so.
• The all-cards split engine starts by itself on Linux, from the Terminal. In 0.2.10 strata launch (and the server it starts) uses it. The desktop app keeps the layer split with DFlash2 and gets the split engine in 0.2.10.1. 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). On NVIDIA the cards exchange their sums through page-locked memory on the host. On AMD they write into each other's memory where the system allows it, and use the host path when it does not.
• With Auto it starts when all of this is true:
• Linux.
• Exactly two NVIDIA cards of compute capability 8.6 (RTX 30 series, RTX A6000 class) or 12.0 (RTX 50 series, RTX PRO 6000 Blackwell), or four Radeon AI PRO R9700 cards with a UD-Q4_K_XL-type file.
• A Qwen3.8 file the engine reads.
• Every routed expert fits in the cards' memory.

-