Strata 0.2.11

# Strata 0.2.11: Unsloth's new 1- to 4-bit Qwen3.8-Flash-Next files, prompt-speed changes on NVIDIA and Radeon cards, small multi-card starts, chats saved as files, a fix for mixed-up replies from model copies, and GUI and Terminal fixes

The app and the Terminal are 0.2.11. Control and every engine package are 0.1.57. The update feed is sequence 121. The DGX Spark (linux-aarch64) gets 0.2.11 too.

Unsloth's new Qwen3.8-Flash-Next files

On 11-04 Unsloth re-uploaded its Qwen3.8-Flash-Next GGUFs ("Dynamic v3.1"). Strata can now download, prepare and run seven of them in the app, in the Terminal (strata launch --family unsloth --model <name>), and from a folder you downloaded yourself ("Use a local GGUF" in the app, or strata launch --model-path <first file>). Each file is checked by size and SHA-256 against Unsloth's revision d9620119.

| Name in Strata | Download | Files | |---|---|---| | UD-IQ1_M | 68.0 GB | 3 | | UD-Q2_0 | 70.6 GB | 3 | | UD-IQ2_XS | 75.8 GB | 3 | | UD-Q2_K_XL | 79.6 GB | 4 | | UD-IQ3_XXS | 83.6 GB | 4 | | UD-Q3_K_XL | 89.5 GB | 4 | | UD-IQ4_XS-v31 | 93.7 GB | 4 |

• Each set's last file is the 28.8 GB table the model reads per token. Sets that share it share the file: UD-IQ1_M and UD-IQ2_XS use one, UD-IQ3_XXS and UD-IQ4_XS-v31 the other.
• UD-IQ4_XS-v31 is a different file from the UD-IQ4_XS Strata already offers. It has other tensor types and four files instead of three, so it has its own name. The existing UD-IQ4_XS stays as it is.
• UD-Q4_K_XL, UD-Q5_K_XL, UD-Q6_K_XL and Q8_0: Strata keeps downloading the 09-30 files it already uses. The 11-04 UD-Q4_K_XL holds the same weights split into four files in a different place; Strata accepts that split too if you already have it.
• UD-IQ1_S does not load. One of its layers mixes two expert formats, which Strata cannot load. UD-IQ1_M is the 1-bit choice.
• On a Mac, the app and the Terminal offer all seven, and the app now offers Unsloth's sets at all. Before the first start, the Mac writes the experts into one file for the GPU, so it needs room for the download plus that file plus a few GB (about 115 GB for UD-IQ1_M).
• New expert format, Q5_0: UD-IQ4_XS-v31 has it in 33 layers, UD-Q3_K_XL in 20, UD-IQ2_XS and UD-Q2_K_XL in one each. Strata computes it more exactly than llama.cpp's formula does. In our tests the difference from the exact result fell from 2.6-3.0% to 1.2-1.3%, the same as the other formats. The Mac got new kernels for it.

What we ran with real files (start, three chats including a tool call, a clean stop; speeds are decode tokens per second from the engine log on short prompts):

| Set | Machine | Start | Decode | |---|---|---|---| | UD-IQ1_M | DGX Spark (GB10) | 1 min 50 s, including the first check and preparation | 43-45 | | UD-IQ1_M | 1 and 2 RTX A6000, Linux | about 2 min | 101-114 | | UD-IQ1_M | Radeon AI PRO R9700, Linux | 114 s | 100-130 | | UD-IQ1_M | Intel Arc A750 | 76 s | 5-6 (the set is read through an 8 GB card and 62 GB of RAM) | | UD-IQ1_M | RTX 3060 12 GB, Linux (18% of the experts on the card) | under a minute after preparation | 31-37 | | UD-IQ2_XS | 1 and 2 RTX A6000 | about 2 min | 86-114 | | UD-IQ2_XS | Strix Halo, Windows | 190 s, including the first check and preparation | 54-75 | | UD-IQ3_XXS | Strix Halo, Windows | 191 s, including the first check and preparation | 55-73 | | UD-IQ4_XS-v31 | 2 RTX A6000 | about 2 min | 96-118 |

On a Strix Halo, a set whose experts fit the shared graphics memory now keeps all of them there, with no RAM pinned beside it. During testing, the first start of UD-IQ2_XS failed with the earlier plan (a small fixed cache plus 35 GB of pinned RAM); with the new plan it started on the first try and decoded about three times faster. Not run with a real file: UD-Q2_0, UD-Q2_K_XL and UD-Q3_K_XL (their formats ran in the parity tests and in the sets above), any of the new sets on a Mac, and pictures with the new sets on an Arc. On the Arc the DFlash2 drafter's guesses were never accepted with UD-IQ1_M, which costs speed; with the GSQ IQ3_XXS file it accepted 77 to 94% as before.

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, and the prompt speed is how fast the engine reads it. "First token" is the wait between sending a prompt and the first piece of the answer. DFlash2 and MTP are two drafters: small helper models that guess the next words so the main model can check them together. A layer split gives each card some layers of the model; the all-cards split engine gives every card a share of every layer. Experts are the model's specialist parts; a file "streams" when some of its experts are read from RAM or the SSD instead of sitting on the card. A prompt chunk is the piece of a long prompt the engine reads in one go. KL measures how far a model's next-word probabilities move from a reference (0 is identical, lower is closer); top-1 is how often both pick the same next word. The "61-task suite" is our own set of 61 tasks (retrieval, extraction, summary, JSON, code, agent loops) run at temperature 0.

Most speed lines below were measured on engine builds made from the source of this release, in branches before the last merge, and on "package-like" folders (a release package with one engine file replaced); each line says which. The speed lines were not measured again on the 0.1.57 release packages; those packages were installed from a signed feed and run with real models (see "What we ran on the release files"). Many cells are one start per arm or two to three rounds; the line says so, and where a line names a noise level it is the one measured on that box.

• Four Radeon AI PRO R9700 cards (Linux), the all-cards split engine, UD-Q4_K_XL. The 0.2.10 release package against the same package with the new split engine, through a plain strata launch-style start, 2 interleaved pairs, 1 start per run (change in the last column):

| | 0.2.10 package | new | change | |---|---|---|---| | 1 user, tokens per second | 161.8, 161.6 | 173.2, 172.4 | +6.9% | | 8 users at once, combined tokens per second | 276.3, 263.3 | 358.4, 357.4 | +32.7% | | two prompts of about 103K tokens, seconds each | 32.97 / 33.31, 33.71 / 34.14 | 30.93 / 31.35, 30.12 / 30.61 | -8.1% |

The new build has 4 changes: 8 request slots by default instead of 6; the prompt sums go through the other cards' memory, so librccl is not needed; chunks of up to 256 rows are summed in one step; and a cheaper expansion in the IQ3_S, IQ3_XXS and IQ2_S decode math (0 of 25 million test dot products differ). Greedy answers were identical to the 0.2.10 path in each step's check (6.5K, 26K and 103K tokens for the prompt sums; one 26K-token IQ3_S answer for the cheaper math). Without librccl, our screen measured a 103K-token prompt at 30.43 / 30.93 s against 28.91 / 29.42 s with it, and 1 user 1.7% behind it (2 pairs).

A later change lets the shared expert (an expert every word uses) ride in the routed launches for every expert type, not only Q4_K. Engine-level harness, the build before this change against the build with it, 2 interleaved pairs, 1 start per run:

| UD-Q4_K_XL, 4 x R9700 | before | after | change | |---|---|---|---| | 1 user, tokens per second | 178.9, 178.2 | 186.1, 185.8 | +4.1% | | 8 users, combined | 367.3, 377.8 | 384.6, 381.1 | +2.8% |

• Four R9700 cards, IQ3_S set: Auto now starts the split engine. Through strata launch on a package-like folder with --parallel 8, 1 start per run:

| IQ3_S, 4 x R9700 | layer split (--split-engine off) | split engine, before this change | split engine, new | |---|---|---|---| | 1 user, tokens per second | 104.2 | 92.8 | 186.8 | | 8 users, combined | 320.7 | 303.2 | 364.6 |

A plain strata launch --model-path ... --gpu 0,1,2,3 with no flags picked the split by itself and measured 187.1 and 363.3 (default lanes, no --parallel