Strata 0.2.13: new DFlash2 defaults per card, a faster app start, a fix for the Strix Halo Terminal launch, and Qwen4 groundwork

The app and the Terminal are 0.2.13. Control and every engine package are 0.1.59. The update feed is sequence 124 (the DGX Spark feed stays 123).
The DGX Spark (linux-aarch64) gets 0.2.13 too.

0.2.13.1 (11-09): Intel Arc fix for the Linux app

Control 0.1.59.1 lets the desktop app set up a model on an Intel Arc card. Before, setup stopped with "no NVIDIA GPU found". To get it, press Update on the Strata row in Settings > Updates, or run strata update in the Terminal, then start the app again. The app can't download models for an Arc card yet: choose "Use your own GGUF…" and pick the folder with the model's .gguf files. On an Arc A750, Q2_0 was ready in 121 seconds, and a chat ran at 12.6 tokens per second. Windows, Mac and the DGX Spark have nothing to update.

Windows and Mac, Terminal still on 0.2.12: strata update updates the engine to 0.1.59 and keeps the Terminal at 0.2.12; it says "Control not part of this feed". On an RTX 5070, Gyro-S was ready in 114.7 seconds after this update and 3 chats passed. The Terminal moves on with the next release. The app is not affected.

Highlights

• DFlash2 drafting, new defaults per card: Strix Halo, UD-Q4_K_XL, 46.6 to 49.1 tokens per second (+5.2%). RTX PRO 5000 72 GB, IQ3_S, 256-261 to 263-265 (+2.8%).
• Strix Halo (Windows): the Terminal launch of UD-Q4_K_XL with pictures off starts. Setup writes a 700 MB reserve, and the engine no longer applies its 2,560 MiB Windows floor on integrated graphics.
• Intel Arc: the same prompt gives the same answer on every run. 50 of 50 runs were identical on an A750, against 3 to 5 different answers in 5 runs before.
• App start: the main file went from 3.12 MB to 0.76 MB, and the start screen from 248.5 ms to 143.4 ms (headless Chrome, median of 10).
• Linux: the expert store loads again when free memory, the file cache or a reserved huge-page pool can hold it (#5327, PR #5531 by pjgmobile).
• Qwen4 groundwork: the signed update feed can carry a model list, and a model of a new shape gets its own engine download beside the Strata engine.

Speed against 0.2.12

Tokens per second, 0.2.12 to 0.2.13, on the DFlash2 defaults that changed. Other machines and models were not measured again.

How it was measured: the 0.2.12 settings and the 0.2.13 settings side by side through the Terminal's own flags, 3 interleaved rounds, a fresh engine start per run, greedy answers of 300 tokens. Speeds were not measured again on the final 0.1.59 packages.

What changed for you

• DFlash2 window and confidence per card. Strix Halo: window 5 to 8. Blackwell cc 12.0 with 48 GB or more (the RTX PRO 5000 72 GB class): window 6 to 8, and confidence 0.35 to 0.55 for IQ3_S. The DGX Spark and other cards keep their 0.2.12 values.
• The app's Load fetches the tuned DFlash2 drafter by itself when Auto picks it (as on the RTX PRO 5000 72 GB), as the Terminal does. On an RTX PRO 5000 with IQ3_S (3 rounds of 12 prompts per kind): agent +10.1%, chat +4.8%, all +6.1%, output identical 72 of 72.
• Windows RX 9070 / R9700 (gfx1201) and RX 7900 (gfx1100): the hipBLASLt table is no longer used by default. This restores the 10-19 rule of gfx1151 only, which the engine had overridden since 0.2.10. STRATA_HIPBLASLT_TABLE=on uses the table.
• Settings the launcher used to write are now the engine's own defaults, so a plain engine start matches the app and the Terminal: the parallel stack on Linux CUDA with 2 or more slots, the GDN settings on Linux CUDA, the chunked GDN scan on Linux with all cards gfx12, the gfx1151 hipBLASLt table, the Q8_0 hyper-connection read for Unsloth UD files on CUDA, and fp16 decode windows on the Mac for a resident IQ3_S or Q2_0 pack.
• One fit label in the app and the Terminal: "fits" when the model files without the lookup table fit graphics memory plus RAM, otherwise "may run slower". The Unsloth sets used to be measured against RAM only, which showed "too big" on a V100 32 GB with 31 GB of RAM. DeepSeek's Needs column shows its whole size. NVFP4-QAD is sized at 76.8 GB, the pack that runs.
• Strix Halo (Windows): on UD-Q4_K_XL with pictures off, 22,991 expert-cache slots against 17,556 on 0.2.12, because the engine's reserve floor no longer applies. Configs saved before the fix work after the update.
• Linux: a data folder on an external drive (/run/media/..., /media/..., /mnt) is accepted. Real system folders are still refused. The doubled "Nothing was downloaded or changed." line is gone.
• Intel Arc: the prompt path's small bf16 matrix products run on Strata's own fixed-order kernel, because oneMKL's result changed from launch to launch for them. Prompt speed is 0.995 to 1.004 of before on an A750. STRATA_SYCL_BF16_DET=0 brings oneMKL back.
• Qwen4 groundwork:
  • A model of a new shape gets its own engine download (strata-q4-<shape>) beside the Strata engine, which stays as it is. The engine reports its shape with strata --geometry, and Control checks it against the signed manifest at install.
  • Models listed in the signed feed install through setup, checked by installing a real synthetic model file from a test feed.
  • 0.2.12 and older versions ignore the new feed members. The 0.2.13 feed has neither a model list nor a shape engine yet.
• Removed opt-in switches from finished experiments: STRATA_METAL_ROUTE, STRATA_METAL_PARTIAL, STRATA_METAL_WPF_MIB, STRATA_MMVQ_PF, STRATA_MMVQ_SG, STRATA_GR_Q32_PL, STRATA_DF2_GATE, STRATA_DF2_ROW_MS.
• Docs: a new page, docs/SETTINGS.md, lists every setting.

Fixed

• Strix Halo (Windows): the Terminal launch of UD-Q4_K_XL with pictures off was not ready after 308 seconds in one 0.2.12 test and took 594.8 seconds in another, on the same PC. With 0.2.13 it starts in 60 to 85 seconds, also from a config saved before the update.
• Linux, #5327 (PR #5531, pjgmobile): an expert-arena shortfall that the file cache can cover loads through the file cache again.
• Feed models: a model without a picture reader no longer stops the install with KeyError 'mmproj'; a model with no draft layer no longer fetches the Flash-Next one; a model of another shape gets a neutral expert profile; the low-RAM mode no longer writes a second copy of the experts.
• Mac: a model of its own shape installs on a Mac too. The app host no longer signals its caller's process group when a child never started.
• Builds: the engine sources are split by backend (cmake/backends), and the ggml sources the engines build sit in third_party/strata-ggml, so an engine build needs no llama.cpp download.

Known problems

• A first launch of a fresh install can take about 5.5 minutes in the one-time "Preparing your model" step. On a Windows PC with an RTX 5070 the first launch took 398 to 406 seconds, and on a Strix Halo 337 to 411 seconds. The same install with 0.2.12 took 398 and 595 seconds the same day, and 107 to 118 seconds on 11-07. We did not find the cause.
• On cards where Auto picks the MTP drafter (for example 12 GB cards), the first load from the app's setup screen runs without a drafter. The next Load from the Models page fetches it. 0.2.12 did the same.
• Intel Arc in the desktop app: setting up a model stopped with "no NVIDIA GPU found". Fixed in 0.2.13.1 (Control 0.1.59.1, Linux); see the top of these notes. 0.2.12 did the same.
• Linux (AppImage): after the in-app update, Strata closes and does not open again by itself. The new version is installed; start Strata again. Updating from 0.2.12 does this because the 0.2.12 app does the restart. Your chats and settings stay.
• Peer mode (--peer-device, two cards) can fault on its first request, in about 4% of fresh starts. Not looked at again in 0.2.13.
• Radeon gfx1201: DFlash2 chosen by hand can stall on the prompt (11 of 50 engines on 0.2.11). Not looked at again in 0.2.13.
• Mac: the final files were not run with a model. They passed Apple's notarisation and the start-up self-test only.

Updating

• App: the in-app update offers 0.2.13, or download the installer below.
• Terminal: run strata update. From a 0.2.12 install the update check saw sequence 123, and strata update moved Control and the engine from 0.1.58 to 0.1.59 on Windows (RTX 5070 and Strix Halo) and on the DGX Spark. strata components rollback returns to the 0.1.58 engine; Control stays 0.1.59, so strata --version still says 0.2.13.
• The Windows installer installed for a standard user, passed its 13-step self-test and uninstalled on a Strix Halo.
• What we ran on the release files: fresh installs from the signed 0.2.13 feed, a model launch, and plain, two-turn and tool chats on Windows (RTX 5070 with Gyro-S, Strix Halo with UD-Q4_K_XL), Intel Arc A750 (Q2_0 on the SYCL engine), the DGX Spark (IQ3_S, and DeepSeek IST-DAS-2.25bpw on its DeepSeek engine), a Radeon R9700 and an RTX PRO 5000 72 GB. Launch to ready and decode speed, IQ3_S: Radeon R9700 133 s and 91 to 98 tokens per second; RTX PRO 5000 with DFlash2 25 s and 221 to 360 tokens per second (setup wrote --spec 8 --draft-conf 0.55). DeepSeek IST-DAS-2.25bpw on the R9700: 366 s and 14.5 to 27 tokens per second. The real-file feed-model install gate passed with an engine on the RTX PRO 5000. strata --geometry printed flash_next on the CUDA 12, CUDA 13, HIP rdna3 and Spark engines.
• Not run: launches on RX 7900, RX 6000 and Strix Halo on Linux (no hardware), CUDA 12 launches (Pascal), the DeepSeek CUDA 13 engine on the RTX PRO 500...

Strata 0.2.12: a tuned DFlash2 drafter, faster prompts on 12 GB cards, Strix Halo and Mac, and tool-call fixes

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

Highlights

• 12 GB cards (RTX 3060 class): UD-IQ4_XS-v31 prompts read about 3 times faster, 87 to 264 tokens per second at 2K.
• Strix Halo (Windows): prompts x1.24 to x2.14 on UD-IQ4_XS-v31 and UD-Q4_K_XL.
• Mac (M5 Max): output +10.3% to +12.7% and prompts +11.7% to +13.9% on UD-Q4_K_XL and UD-IQ4_XS-v31.
• Tuned DFlash2 drafter: Strata's own copy of the helper model that guesses the next words; decode +2.4% to +5.0% on the RTX PRO 5000 and the DGX Spark.
• Radeon R9700: 32K prompts +8.6% to +11.6%.
• Tool calls: Claude Desktop's model name is accepted (#5312), plus fixes for #5409, #5276, #5281, #4622 and PRs #4828 and #4832.

Speed against 0.2.11

Tokens per second, 0.2.11 to 0.2.12. "Output" is the geometric mean over the kinds we tried where we have one; the worst kind is shown when it is a loss.

How it was measured: each machine ran 0.2.11 and the 0.2.12 candidate side by side, 2 to 3 rounds, a fresh engine start per run, the arms swapped in order each round, greedy answers of 300 tokens. Each version used the settings it writes for that machine, so the 0.2.12 column includes the new drafter choices. Speeds were not measured again on the final 0.1.58 packages; the engine source after the check changed only in the version number and two build fixes for old NVIDIA cards.

What changed for you

• Tuned DFlash2 drafter (0.34 GB, 0.52 GB on Intel Arc). Auto now uses it on: Mac (UD-Q4_K_XL, UD-IQ4_XS-v31; DFlash2 is now the Mac default for these, confidence 0.7); NVIDIA cards with every expert on the card and the DGX Spark (IQ3_S, UD-IQ4_XS-v31); Strix Halo (IQ3_S, UD-Q4_K_XL, UD-IQ4_XS, UD-IQ4_XS-v31); Intel Arc A-series (IQ3_XXS); 12 GB NVIDIA cards (UD-IQ4_XS-v31). Back: strata launch --drafting mtp.
• Radeon gfx1201 (R9700, RX 9070): Auto starts MTP, not DFlash2, because 11 of 50 DFlash2 engines on 0.2.11 stopped on the prompt. Line shown: "DFlash2 is off by default on this graphics card for now; choose it in Drafting to use it." Back: --drafting dflash2.
• 12 GB cards (Linux): the second start-up check no longer counts the engine's own memory as free, so it stops switching to the slower file cache. When it still switches it says: strata: expert reads now go through the file cache (X GiB of RAM free for them, Y GiB limit). On the RTX 3060, 0.2.11 switched in 3 of 3 starts and 0.2.12 in 0 of 3. Auto now starts MTP for IQ3_S and the tuned DFlash2 for UD-IQ4_XS-v31 on these cards. Back: STRATA_FILE_TIER_HONEST=0.
• A download with the wrong checksum is kept as <name>.bad, not deleted: <name> does not match the pinned SHA-256 (it is <got>, Strata expects <want>); the file was kept as <name>.bad. Setup checks it again on the next run.
• Strix Halo (Windows): the fused prompt kernels for UD-Q4_K_XL and the Q5_0 layers of UD-IQ4_XS-v31, and the grouped decode kernels, are on. Back: STRATA_GFX1151_DEFAULTS=0.
• Mac: the prompt path overlaps host work with the GPU (same bits). Back: STRATA_METAL_PROMPT_HOSTPIPE=0, STRATA_PROMPT_MERGEH=0, STRATA_PROMPT_V6=0. Mac line: "On your Mac, DFlash2 was faster than MTP on this model in our tests."
• Radeon gfx12, prompts of 30,000 tokens or more use the chunked GDN scan (32K +6.1%, 64K +6.7% on an R9700): strata: RDNA4 (gfx12): prompt chunks of 30,000+ tokens use the chunked GDN scan (STRATA_GDN_CHUNKED=0 turns it off).

Fixed

• Tool calls:
  • #5312: Claude Desktop's claude-5-5-sonnet on /v1/messages now uses the one loaded model.
  • #5409: <function=tools NAME> and a bare <function=tools> are read as the declared tool.
  • #5276: <toolcall> and <tool-call> openers are read when a declared tool follows.
  • #5281: an MCP tool written by its last segment is matched when exactly one tool ends that way.
  • #4828 (gdevenyi): forced tool_choice with several tools; 24 of 24 runs now, 0 of 24 before.
  • #4832 (gdevenyi): Anthropic tool results follow tool_use_id.
  • #4622: new setting undeclared_tool_calls (text by default, call is opt-in).
• Engine fixes from pull requests:
  • Copy ordering and lost adaptive swaps (#5096, #4844).
  • Row-table over-read that could fault long CUDA prompts (#5108).
  • A first-request hang with --pipeline-windows 2 on two AMD cards (#5149); not run on hardware.
  • Speed and time figures in the server reports (#5318, #5307, #4006); a short request admitted into a slot now reads 125, not 215, tokens per second because admission time is counted.
  • Hyper-connection rows copied per stage: 414 MiB less per card on two A6000 (#3559).
  • A window of slots kept in every expert pool, so 12, 20 and 30 GiB RAM splits start (#5158).
  • File tier defaults stay off when every expert is on the cards (#4972).
• Mac install (#5390, cwf75): a fresh install of UD-Q4_K_XL or UD-IQ4_XS-v31 from the Mac app or Terminal stopped at "Preparing your model" ("the desktop app's installer only runs its bundled preparation tools"); the installer now runs the bundled Mac tools in metal/tools. On an M5 Max a fresh Terminal install of UD-Q4_K_XL prepared the model, fetched the tuned drafter and answered plain, two-turn and tool chats.
• Builds: the CUDA 12 and 13 engines build again for old NVIDIA cards (sm_60 to 75); MSVC and the Spark link failures; the Docker image build.

Opt-in switches (all off unless set)

• STRATA_PF_FUSED_Q50=1 (Radeon gfx12): Q5_0 layers on a fused kernel; prompts 2K +44%, 8K +40% on an R9700.
• STRATA_IQ4_W4A8=1|2 (NVIDIA, cctan): int8 kernel for IQ4_XS and IQ4_NL experts, same output as MMQ.
• STRATA_SELECT_TWO_PASS=1 (NVIDIA, bitaccesscomau): exact two-pass selection for long prompts; 128K +1.65%.
• STRATA_ADAPT_FETCH=1|2 (CUDA, sergqwer): fetched misses go into the card's cache; decode +10.2% with =2 in one setup.
• STRATA_ADAPT_OVERLAP=1 with --peer-device (bulhenvaster): the peer's copies land while the next window runs.
• STRATA_PF_PEER_CPU=1 (bulhenvaster): the CPU helps beside a peer GPU; on two A6000, 12 follow-up turns took 14.28 s against 20.50 s.
• STRATA_VNNI_TIER=1 (Michel Pollet): 512-bit expert rows on CPUs without AVX-512-VBMI.
• undeclared_tool_calls: "call" (or STRATA_UNDECLARED_TOOL_CALLS=call): return a call of an undeclared tool as a tool call.

Known problems

• Peer mode (--peer-device, two cards) can fault on its first request, in about 4% of fresh starts (also in 0.2.11); the all-cards split engine is not affected. Cause not found.
• Radeon gfx1201: DFlash2 chosen by hand can stall on the prompt (11 of 50 engines on 0.2.11). The engine stops itself and the next request restarts it.
• DGX Spark, UD-IQ4_XS-v31: the first long prompt after a start can read slowly (590 to 670 tokens per second against 1,154 to 1,235 when the pages are cached); also in 0.2.11.
• Losses: RTX 3060 UD-IQ4_XS-v31 JSON extraction -18.9%; Strix Halo tool calls -9.5% on UD-IQ4_XS-v31 (measured to come from the tuned drafter) and -5.8% on UD-Q4_K_XL (its answers differ from 0.2.11's, so that ratio is rougher).
• Tool-call issues still open: #4923, #5226, #5282, #5110, #5039, #4949, #4981, #4704, #4077, and #5153.

Updating

• App: the in-app update offers 0.2.12, or download the installer below.
• Terminal: run strata update. From a 0.2.11 install it updated Control and the engine from 0.1.57 to 0.1.58 on Windows (RTX 5070 and Strix Halo) and Linux (Intel Arc A750). strata components rollback returns to the 0.1.57 engine (Control stays 0.1.58, so strata --version still says 0.2.12), and a plain strata update brings 0.1.58 back.
• The tuned drafter downloads once (0.34 GB) the first time Auto needs it. Offline, Strata uses the standard drafter or MTP. Nothing downloads if you use MTP.
• Mac: the app, the Terminal and the DeepSeek engine are signed with Developer ID and notarized (Apple accepted all four files), and the app and the dmg pass Gatekeeper.
• What we ran on the release files: fresh installs from the signed 0.2.12 feed, a model launch and plain, two-turn and tool chats on Windows (RTX 5070 and Strix Halo), Linux (RTX PRO 5000, Radeon R9700 with the Qwen and DeepSeek engines, Intel Arc A750), the DGX Spark (Qwen and DeepSeek) and the Linux AppImage. The tuned drafter came from the feed and passed its checks on the RTX PRO 5000, the DGX Spark, the Strix Halo and the Intel Arc (its own file). Not run on a matching card: CUDA 12 (Pascal), RX 7900, RX 6000 and Strix Halo on Linux; the Mac files beyond Apple's checks and a start of the app.

Downloads

42 files, 9.70 GiB in all. Names, sizes and SHA-...

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.

• 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):

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); a picture (a code, a red square, a blue circle) was read in 1.1 s. Against the layer split on the same prompts (53 prompts, first token and 64 generated tokens): top-1 48 of 53 (90.6%), KL mean 0.0406, median 0.0047, max 0.85; the generated ids were identical on 13 of 53. The 61-task suite, one start each, 4 cards: the split 57 of 61 (fails: agent-A4, agent-A5, extr-M-d28, extr-L-d31), the layer split 54 of 61 (fails: agent-A3, A4, A5, A7, A10, extr-M-d28, extr-L-d31). The two extraction tasks fail in both; the agent tasks change from run to run (one run each, so this is not a verdict on them). Two and three R9700 cards were not re-measured with this change and keep the layer split.

• NVIDIA UD-Q4_K_XL prompts: the K-quant prompt kernels are the default on cards of compute capability 8.0 and up. UD-Q4/Q5/Q6_K_XL files used to be converted to 16-bit numbers and multiplied by a general library; they now run on llama.cpp's MMQ kernels (compact integer kernels for quantized weights). Prompt speed in tokens per second, median of 4 requests per cell, 2 rounds, arms interleaved, a fresh engine per arm per round, MTP, 131072 context, medians shown as old to new:

  card	4K prompt	8K	20K	32K
  RTX PRO 6000 (sm_120, all experts on the card)	2,338 to 3,097 (+37.7%)	3,389 to 4,241 (+25.8%)	3,386 to 4,573 (+34.3%)	3,709 to 4,886 (+32.6%)
  RTX A6000 (sm_86, 13.1K of 24.6K experts on the card)	1,113 to 1,130 (+1.7%)	1,917 to 2,093 (+9.0%)	1,726 to 1,867 (+8.1%)	2,010 to 2,235 (+11.2%)

  Decode speed did not change. This path rounds differently: first-token KL against the old path, 24 prompts of about 2K tokens (19 plain, 5 agent turns): RTX PRO 6000 0.0243 (plain 0.0170, agent 0.0521), top-1 23 of 24; A6000 0.0351 (plain 0.0305, agent 0.0528), top-1 22 of 24 (noise floor 0.0013). The 61-task suite on the RTX PRO 6000, one server start per arm, two starts each: old path 53 and 53, new path 54 and 54 (agent 5 o...

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.
    • Enough free RAM for what stays in RAM (about 43 GiB, of which the embedding table is 27.5 GiB).
    • A context of 131,072 or less.
  • We ran it on two RTX A6000, two RTX PRO 6000 Blackwell and four R9700 cards, not on a GeForce pair. Anything else keeps the layer split.
  • The split runs the model's MTP draft layer, so the first start on such a PC downloads it (5.2 GB) and the plan says so. If the engine cannot start, the server says so in one line and starts the layer split, and the final summary names the layer split. If it stops after it was running, the same engine starts again.
  • Turn it off: strata launch --split-engine off, or "split_engine": "off" in the run config, or STRATA_SPLIT_ENGINE=0. --split-engine on asks for it and prints why when it cannot run. It also runs the cases Auto leaves out, such as 2 or 3 R9700 cards, or the IQ3_S set on AMD, where the layer split is faster today.
  • Pictures work on it (a sphinx picture described in 3.45 s the first time and about 0.4 s after).
• ISTA-DAS Coder for DeepSeek-V4.1-Flash. strata launch --model ISTA-DAS-Coder (the app lists it too). Details below.
• DeepSeek pictures on a Mac (Apple Silicon). The picture tower now runs on Metal (Apple's graphics system) in the DeepSeek engine. It follows antirez/ds4 (MIT), with the credit and licence in the package. The Control turns pictures on when the engine carries the marker STRATA_DS4_METAL_VISION_V1; an older Mac DeepSeek engine stays text only.
  • Measured on an M5 Max (8 requests in one server, 5 different pictures, a 6K-token needle, 2 repeats). A needle test hides one fact in a long text and asks the model to find it. Results: "CODE 4217" read as 4217; a red square and a blue circle; an invoice (number and amount right; the code "QX-9042-LM" read as "OX-9042-LM", which the Windows engine also reads); a 1344 x 1260 picture ("MARMALADE-77", red circle, blue square).
  • The first picture of a server session adds 6.0 to 8.7 s for c...

Strata 0.2.9: Unsloth's 1-bit DeepSeek sets as a choice, much faster prompts on Strix Halo, faster parallel requests on Linux NVIDIA cards, fixes from your reports

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

The numbers first

• Strix Halo on Windows, Qwen3.8 IQ3_S: prompts 1.8 times as fast, decode the same. Against the 0.2.8 engine on the same PC, interleaved, nothing set: an 8K prompt goes from 791 to 1,424 tokens per second and a 32K prompt from 778 to 1,460. With Unsloth's UD-IQ4_XS, 8K goes from 794 to 1,243. Decode went from 57.4 to 58.9 tokens per second (about 3% more, inside normal spread), and the greedy answers were the same.

• Strix Halo on Windows, DeepSeek 2.25, engine level against 0.2.8: a 200-token prompt reads at 24.9 tokens per second against 15.0 (x1.66), a 4K prompt at 183.7 against 148.8 (x1.24), a 16K prompt at 469.9 against 298.0 (x1.58). With the drafter, decode went from 10.89 to 12.01 tokens per second, about 10% more but inside run-to-run noise; without the drafter it is unchanged (10.30 and 10.24).

• Parallel requests on Linux with NVIDIA cards: 1.45 times the 0.2.8 speed at 8 requests at once. One RTX PRO 5000, Qwen3.8 IQ3_S, 1,000-token prompts, 128 tokens out, three paired blocks, range 1.451 to 1.459. One request alone is 5.3% faster, and its greedy answers matched in 12 of 12 prompts. With --parallel or --batch of 2 or more, the server now sets the nine qualified settings itself.

• Prompts about 2% to 6% faster on Linux, by default. On Linux NVIDIA cards the Gated DeltaNet prompt kernels now run on the tensor cores: 4.4% faster at 4K and 5.5% to 5.7% at longer prompts on an RTX PRO 5000, 2.6% at 16K and 3.2% at 32K on an RTX A4000. On Linux with Radeon cards that are all gfx12 (such as the R9700) the chunked kernel now starts at 64 tokens: 3.5% at 4K, 4.7% at 16K and 6.1% at 32K, and 1.7% to 3.2% at 1K to 3K. Decode is unchanged. The KL check, the 61-task suite (55 against 54 to 56) and a 30-minute soak all passed. Windows, Mac and Intel are not changed.

• Two Intel Arc Pro B65 cards: prompts 4.6% to 15.8% faster. Prompts of 1K, 4K and 16K tokens: 4.6%, 14.6% and 15.8% faster. Eight requests at once: 53.8 tokens per second, against 42.1 before. Single-request decode through the batch server is 2.7% slower. The 42.1 is the old default of one group.

• DGX Spark, DeepSeek 2.25: a 442-token prompt reads at 80 to 82 tokens per second against 40 to 42 on the 0.2.8 engine, and a 1,953-token prompt at 208 against 144, on an otherwise quiet box. Decode is the same within noise.

• DeepSeek on several AMD cards now uses all of them by default. Four Radeon AI PRO R9700 cards, ISTA-DAS 2.25, strata launch with no --gpu: before this release it ran on one card, with 2,371 of 15,360 experts on the card, 6 experts per token and decode at 7.8 and 25.7 tokens per second on two short answers. It now fills all four, with 12,147 of 15,360 experts on the cards, 5 experts per token (the launcher's choice on four cards) and decode at 57.7 to 103.7 across six chat and tool answers on the release files.

• Unsloth's 1-bit DeepSeek sets, UD-IQ1_S and UD-IQ1_M, are now a choice in setup and strata launch. Downloads are 241 GB and 258 GB, about 111 GB less if you already have ISTA's Engram file. The default set is unchanged. We measured both next to the ISTA-DAS 2.25 set, one run each, on four Radeon AI PRO R9700 cards (UD-IQ1_M on two RTX A6000), with 6 experts per token. The reference is Unsloth's own Q8_K_XL file.

  	UD-IQ1_S	UD-IQ1_M	ISTA-DAS 2.25
  KL against the reference (4,995 positions)	0.114	0.087	0.110
  Top-1 agreement	87.2%	88.8%	87.4%
  Perplexity against the reference	+4.8%	+3.0%	+8.9%
  61-task suite (35 on 14K to 30K-token documents)	53 of 61	53 of 61	56 of 61

  By family in that suite (UD-IQ1_S, UD-IQ1_M, ISTA-DAS 2.25): retrieval 11, 11, 12 of 12; extraction 11, 13, 13 of 13; unanswerable 9, 9, 9 of 9; summary 8, 6, 7 of 8; code 6, 5, 6 of 6; JSON 3, 3, 3 of 3; agent loops 5, 6, 6 of 10. All 10 agent loops finished on all three sets, with no invalid tool calls and no tool errors. Speed: UD-IQ1_S on four R9700 cards, decode 48 to 88 tokens per second and a 4K prompt at 1,204 to 1,296; UD-IQ1_M on two A6000 cards, decode 41 to 82 and a 4K prompt at 304 cold and 415 warm. These are single runs on our own test texts. UD-IQ1_M's suite ran on the two A6000 cards, the other two on four R9700 cards, and the reference file is Unsloth's own.

What is new

• Parallel requests and the Gated DeltaNet kernels are on by default, on Linux. Parallel: Linux with NVIDIA cards, with --parallel or --batch of 2 or more. Gated DeltaNet kernels: Linux with NVIDIA cards (Qwen3.8) and Linux with Radeon cards that are all gfx12. Any environment variable or config value you set still wins. Windows, Mac, Intel and DeepSeek are not changed.
• Intel Arc B-series. Prompt attention now runs on the int8 path, on by default for Battlemage cards. Set STRATA_PROMPT_ATTN_ESIMD=0 to turn it off. Two B-series cards with 8 or more slots now run 2 pipelined groups by default; set --batch-groups 1 or STRATA_BATCH_GROUPS_AUTO=0 to turn that off. A single request through the batch server is 2.7% slower than before. The A750 keeps the old path, and we did not run it.
• Strix Halo on Windows (gfx1151). The prompt experts use the F16 matrix-core kernels by default (STRATA_PF_F16), a Q8_0 down layer of the Unsloth files takes the same kernel, and STRATA_SELECT_WMMA (the block scorer on matrix cores) is on by default. The block scorer is not bit-exact: about 10 of 2,051 selected cells flip at the cutoff for prompts past about 5K tokens. Turn any of them off with NAME=0, for example STRATA_PF_F16=0. On DeepSeek, the shards are no longer held open after the load by default (DS4_NO_VIEW=0 turns that off), and the CPU lane waits for the next token more steadily. Part of the prompt work follows ideas from asf0's libstrix (MIT).
• DeepSeek GGUF layouts. Strata now accepts the four-shard set that ISTA re-published on 26 October and ISTA's six-shard layout, both for "Use a local GGUF" in the app and for --model-path. A cut or missing shard is still refused, and the message names the missing part. Thanks to lu123bing for the GGUF reader fix (PR #4348) and to StackArc3 for the six-shard layout (PR #4632).
• Unsloth's 1-bit sets, where they are offered. Windows and Linux (NVIDIA and AMD), the DGX Spark, and the Mac. On a Mac, UD-IQ1_S ran on an M5 Max (decode 15.4 to 18.5 tokens per second, a 3K prompt at 230 cold and 314 warm, a 14K prompt at 519); UD-IQ1_M is offered there but was not run. On the DGX Spark, UD-IQ1_S decodes 15 to 26 tokens per second on code and reads a 3,950-token prompt at 377 to 397; UD-IQ1_M decodes 7.6 to 13 and reads at 330 to 345. The Engram table comes from the ISTA file you already have, if you have one. Setup keeps its own plain note about these 1-bit sets.

Fixed, from your reports

• Chat:
  • A long answer no longer slows the page down. Each streamed token used to redraw the whole chat. Now the text is applied about ten times a second, and only the streaming message redraws. For a 40,000-token answer, main-thread time fell from 15.7 to 9.0 seconds, and peak heap from 114 MB to 62 to 75 MB. We measured it in the app on a synthetic long answer, not on the reporter's own setup.
  • A client that hangs up right after data: [DONE] no longer gets "Request cancelled." (#4690).
• Tool calls and the server:
  • Calls shown inside a code fence or an indented block are no longer run as tool calls. A fence closes only with the same length it opened with (#4702, #4703).
  • A tool the conversation already used counts as declared, so a later call to it comes back as a tool call, not as raw text (#4663).
  • Qwen3.6: the warm-up no longer writes past the KV cache. On one test, the old build crashed with a heap error at a 2,048-token context. The new build ran (#4708).
  • The layer-major prefill copies an expert with no mapped blob from its source, instead of ending the request (#4695). We only compiled this change. The path is Windows-only and we did not run it there.
• Setup and the update:
  • A child process that prints non-UTF-8 text, such as GBK adapter names, no longer stops Step 1 or launch (#4675).
  • The update's test start names the kept log file to report (#4692). We have not found why that test start failed for the reporter.
  • A compiled engine includes code for every usable NVIDIA card in the PC, not only the one setup picked (#4662). In our test, an engine built only for an older architecture failed every request on a newer card. The server also prints one plain line at start when a card is of an architecture the engine was not built for. The report came from a PC with a TITAN RTX and an RTX 3080; we have not confirmed this was its cause.
  • Hardware list: AMD cards are counted from the kernel driver files when neither the setup module nor rocm-smi is there, as with a ROCm install from a Python venv.
• Which cards a launch uses:
  • DeepSeek on several AMD cards, Linux: setup saved its own pick of one card as if you had chosen it, while --plan showed all of them. With no --gpu, it now uses every card the engine package can run. An install set up that way moves to all its cards at its next start, with nothing rebuilt, and prints how to stay on one: strata launch --gpu N, which is now remembered. If you named that same card yourself before 0.2.9, we can't tell it from setup's pick, so it moves once too. Windows stays on one AMD card. An integrated Radeon beside a card with its own memory is left out, and so is a card the package has no code for.
  • Two or more Intel Arc cards: strata launch did not know the Arc Pro B65, B60, B50 or A770M, so it named n...

Strata 0.2.8: faster Arc B-series pairs and four-card Radeon servers, a Mac DeepSeek memory leak fixed, fewer lost tool calls

The app is 0.2.8. Control and every engine package are 0.1.54.

The numbers first

• Two Intel Arc Pro B65 cards: decode 17% to 23% faster, prompts about 7% to 13% faster. Chat runs at 71 to 74 tokens per second, against 60 to 63 before, and JSON at 80 to 83, against 67 to 68. We tested two Arc Pro B65 32 GB cards with Qwen3.8-Flash-Next IQ3_S, five paired runs, and every pair was faster. The answers are the same as before. This applies to exactly two Arc B-series cards; one card, A-series cards and three or more cards run as before.
• Four Radeon AI PRO R9700 cards serving many requests: 2.4 times the total speed at 32 requests at once (155 to 370 tokens per second in total; at 8 at once, 157 to 261). One request alone runs at the same speed as before (67 tokens per second). Setup and the launcher pick this for exactly four R9700 cards running Qwen3.8 IQ3_S. All 32 answers matched a single-request run, and two soaks (25 and 12 minutes, 1,600 requests) had no errors.
• DeepSeek on the Mac no longer slows down after a few requests. On the Metal engine every request left about 1.3 GB of GPU buffers behind, until the Mac ran short of memory and decode fell from 16 tokens per second to 3. Memory now stays flat at 76 GB over 34 requests, and decode stays at 18 to 22 tokens per second, with the same answers. Tested on an M5 Max with 128 GB, not on a 256 GB Mac Studio.
• Tool calls the model writes slightly wrong now still go through, by default. Over 1,462 agent turns, 98.3% are now read as intended, against 92.9% before. This only applies to tools the request declared.
• RTX cards with 12 GB or less: the 0.2.7 routing speed-up is off again by default. It made answers faster (RTX 3060: story +15%, code +37%), but your reports and our own checks tied it to repeated text in long sessions. With nothing set, the engine now routes exactly as 0.2.6 did. To get the speed back, turn on "Faster answers on 12 GB NVIDIA cards" under Models, Native engine settings, Speed (or run strata launch --set STRATA_ROUTE_PRIOR=1.5).
• DeepSeek no longer stops in the middle of a word. The server ended a reply on pieces such as im, | or >, so "Nerazim" came out as "Neraz" (#4576, #4137). It happened when a DeepSeek server was started from a config that did not name the model family.
• 0.2.8 against 0.2.7.1, five paired runs each. On one RTX A6000 with Qwen IQ3_S, decode went from 105.9 to 111.4 tokens per second on a story and from 139.8 to 145.2 on code; prompts are unchanged (1,927 and 1,924 at 4K, 2,571 and 2,569 at 20K). On one Radeon R9700, decode went from 73.7 to 79.7 on a story and from 106.3 to 107.8 on code; prompts are within 0.4% once the engine is warm. DeepSeek 2.25 decode is 4.3% faster on an RTX A6000, with the same output as 0.2.7.1 on our score check.

What is new

• Arc B-series pairs. The first card starts the next window while the second card is still checking the current one (--pipeline-windows 2), and setup writes --spec 2 for the pair. Turn it off with --pipeline-windows 0; a --spec you set yourself is kept. The Arc engine also reads prompts about 5% faster on B-series cards with a new attention path, and three bugs that stopped --pipeline-windows from running at all are fixed.
• Four-card Radeon profile. For four R9700 cards: 32 request slots in 4 groups, layer split 13,26,39, a prompt chunk of 2048 and three small switches. It only fills in what you have not set. Turn it off with "four_card_profile": false in the config.
• Bigger batch windows on AMD. The HIP engines now check and batch up to 16 rows at once instead of 8, which is what the four-card profile needs. The answers are bit for bit those of the 8-row build on every card we ran (10 of 10 on R9700, RTX PRO 5000, A6000, A4000 and P100). NVIDIA, Intel and Mac builds stay at 8.
• DeepSeek prompt speed, opt-in. DS4_FAT_ROWS (thanks to lyesrock, PR #4366) gives the busiest experts of a long prompt one bigger matrix multiply: +2% to +5% on two RTX A6000. It is off by default, because the gain is under our bar for a default and the output is not bit-exact.
• A clearer message on Arc and older CPUs. A model folder without native_experts.txt is read as the AVX-512 pack, and the engine used to blame the CPU. It now names the real cause, and strata doctor warns before the start.
• One source for the driver floor. Setup now reads the CUDA 12 driver floor from the engine package, so setup and the update agree. The floor itself has not changed: 575.51, or 576.02 on Windows.

Fixed, from your reports

• App:
  • DeepSeek no longer fails to load with picture reading off (#4358, #4359, #4505, #4507). The app now sends DeepSeek only the options it takes, and "GPU memory for other apps" goes out as --reserve-mib (#4504).
  • The wait for a big model to load now follows the model size, as strata launch does (#4191, #3459; thanks to miketgv, PR #3817).
  • "See engine log" no longer points at a log that was never written (#3714).
• Monitor: with a model running, an AMD card on Windows showed load, memory and temperature as "Not available". The Monitor now fills in what the engine does not report, and reads the temperature on Windows AMD cards (#3727). On Linux, a server's remote-console chip no longer shows up as a graphics card.
• Terminal and setup:
  • The update's test start skips DeepSeek configs (#4440; thanks to ai-bits, PR #4267).
  • A saved lower-case model tag such as iq3_xxs is found (#4209, PR #4317).
  • The packaged Terminal runs setup without CMakeLists.txt, and strata install --source modelscope passes its options on (#4188).
• Memory and cache:
  • A 256K start on two cards no longer takes the Strix Halo reserve off the RAM store. On 2x A6000 the RAM store grew from 77.7 to 106.5 GB (#4147).
  • The conversation cache no longer runs short when the PLE table is locked (#4518).
  • Parking an idle --batch slot keeps the shared prefix, so the first token of round 2 takes 0.66 s instead of 3.3 s (#4420).
  • The automatic expert cache leaves the reserve you asked for (#4474).
  • A new engine waits for the old one to give its memory back (#4051).
• Tool calls and the server:
  • An argument that quotes a tool call stays exact (#4078; thanks to Tsury, PR #4132).
  • Damaged arguments, a missing </function> and a stray closing think tag no longer lose the call (#4427, #4077).
• DeepSeek on several cards:
  • A layer split's chunked prompt no longer deadlocks (PR #4211).
  • slot_load() writes each tensor-parallel member's state under its own device (#4350; the single-card fault is still open).
• Mac: the DeepSeek memory leak described above.

Going back to 0.2.7.1

strata components rollback returns to the previous engine. The Qwen route prior and tool-call recovery can both be set the 0.2.7 way: STRATA_ROUTE_PRIOR=1.5 and "tool_call_recovery": false in the model's run config. The 16-row windows are a build option (-DSTRATA_WINDOW_MAX_T=8); there is no switch at run time.

Off unless you turn it on

• DS4_FAT_ROWS=N (DeepSeek, CUDA).
• Everything listed under "Off unless you turn it on" in 0.2.7 is unchanged.

What we did not test

• A 256 GB Mac Studio, or any Mac other than one M5 Max.
• The four-card profile on anything other than four R9700 cards, and 64 slots at long context.
• The Monitor fix on a Windows AMD graphics card. We tested it on Linux AMD cards and on Windows with NVIDIA and an AMD integrated GPU. If you have a Radeon on Windows, please tell us whether the Monitor now shows load, memory and temperature.
• The Windows commit-limit side of #4518, the full #4051 wedge on a host with little RAM, and #4427 on a real model beyond the parser tests.
• Metal and SYCL builds with 16-row windows; they stay at 8 and were only compile-checked.
• The B-series pipeline on anything other than two Arc Pro B65 cards.
• Strix Halo changes are not in this release.

Updating

• App: the in-app update offers 0.2.8, or download the installer below.
• Terminal: run strata update. It fetches Control 0.1.54 and the 0.1.54 engine in the same run, and keeps the old engine for strata components rollback. If your Terminal is older than 0.2.0 (for example 0.1.45.x), run the install line again.
• DeepSeek engine: it updates itself on the next strata launch.
• DGX Spark: run strata update; it reads strata-feed-linux-aarch64.json.
• Mac: the app, the Terminal and the DeepSeek engine are signed and notarized.

Downloads

40 files. Three installers (Windows, Linux AppImage, Mac dmg) and the Mac updater archive Strata.app.tar.gz (0.2.8), with the update signatures for the Windows, Linux and Mac app; the four Control packages (0.1.54: Windows, Linux x86, Mac, Linux ARM64); 14 Qwen engine packages (0.1.54: Windows CUDA 13, CUDA 12 and three AMD packages; Linux CUDA 13, CUDA 12, four AMD packages and Intel SYCL; Mac Metal; Linux ARM64); six DeepSeek engine packages (0.1.54: Windows CUDA 13 and AMD RDNA3, Linux CUDA 13 and AMD rx9070, Mac Metal, Linux ARM64); strata-feed.json and strata-feed-linux-aarch64.json with their signatures; latest.json, install-manifest.txt, install.sh, install.ps1 and SHA256SUMS.txt. The DeepSeek CUDA packages are built for sm_86, sm_89 and sm_120.

Strata is free and open source. If it runs well on your PC, a coffee keeps the work on it going:

Strata 0.2.7: faster 12 GB NVIDIA cards, DeepSeek on Ryzen AI Max, a bigger web chat page, French

The app is 0.2.7. The 0.2.7.1 section below is the new part of this release; everything after it is the 0.2.7 text. Control is 0.1.53 since 0.2.7.1. The engine packages of 0.2.7 stay at 0.1.52, and the new Spark engines are 0.1.53.

0.2.7.1: NVIDIA DGX Spark, and DeepSeek on the Mac

This update adds two things: Strata now runs on the NVIDIA DGX Spark (Linux ARM64), and DeepSeek-V4.1-Flash runs on Apple silicon Macs. If you use Windows, Linux with an x86 processor, or a Mac for Qwen only, you get no new engine, no speed change and no app change, and you do not need to update. Your Terminal will still show a small update (Control 0.1.52 to 0.1.53). It brings a reader for the update feed that skips entries it does not understand instead of stopping, so a later release can add a new kind of computer without breaking yours. Your engines stay as they are.

DGX Spark

• What runs. Qwen3.8-Flash-Next (IQ3_S and the NVFP4 pack, 64K context) and DeepSeek-V4.1-Flash 2.00 bpw. We tested one Spark (Ubuntu 24.04, NVIDIA driver 580, CUDA 13.0). We do not know that it works on any other ARM computer. The Spark needs glibc 2.39 or newer (Ubuntu 24.04, DGX OS 7) and driver 580.65 or newer.

• Install. The Terminal only, because there is no desktop app for ARM Linux:

  curl -fsSL https://github.com/Niko1221/Strata/releases/latest/download/install.sh -o install.sh && sh install.sh
  strata launch

  strata launch downloads the Spark engine, shows what each model needs, and starts the one you pick. The guide is docs/DGX_SPARK_LINUX.md.

• Speed. Four Spark settings are on by default. The table is the same engine with them on and with them off (STRATA_SM121_PERF=0), on one Spark with 64K context and 256-token answers, medians of four runs per cell. It is not a comparison with 0.2.7 or with another machine.

  Model	Settings	Prompt, tok/s (4K / 16K / 32K)	Answer, tok/s (4K / 16K / 32K)
  IQ3_S	on	1,296 / 1,680 / 1,735	45.5 / 46.5 / 46.5
  IQ3_S	off	1,203 / 1,416 / 1,276	48.5 / 45.3 / 45.2
  NVFP4	on	1,408 / 1,670 / 1,698	42.8 / 40.5 / 40.1
  NVFP4	off	1,156 / 1,350 / 1,353	41.0 / 41.2 / 38.4

  Prompts are 1.20 times faster on IQ3_S (90% range 1.12 to 1.31) and 1.24 times faster on NVFP4 (1.14 to 1.36). Answer speed did not change in this check: 0.996 times on IQ3_S (0.97 to 1.02, and 0.94 times at 4K) and 1.02 times on NVFP4 (1.00 to 1.05). An earlier run had shown about 5% for each of two answer-speed settings; this check did not repeat it.

• Several chats at once. strata launch sets four slots on a Spark. With IQ3_S, 2,000-token prompts and 128-token answers, all clients at the same time, the total over all clients was 35.6 tok/s for 8 clients, 41.7 for 16 and 47.3 for 32 at four slots, and 54.2 for 32 clients at eight slots. One chat alone answers at about 46 tok/s, so several chats mostly share the Spark's speed. We also gave every client its own prompt and a hidden code: each answer named its own code and nobody else's (8 clients on four slots, 16 clients on eight slots), and none failed or hung.

• Answer quality. The faster prompt path rounds numbers a little differently, so the same question can come back in different words. On a 61-task suite (finding facts in long documents, copying up to 72 exact rows, summaries, code, JSON, agent loops with tools) the settings on passed 56 tasks and off 51 on IQ3_S, and 56 against 52 on NVFP4. Every run found all 63 facts, and no agent loop made an invalid tool call. The answers differ in wording on 21 of the 61 tasks (IQ3_S) and 25 (NVFP4), and the wins and losses go both ways. Read it as no loss that we could measure, not as an improvement. On NVFP4 one 40-row register lost a row with the settings on (616 of 642 extraction facts against 621). To get the answers of 0.2.7 back on the Spark, set STRATA_SM121_PERF=0.

• DeepSeek on the Spark. DeepSeek-V4.1-Flash 2.00 bpw at 8K context in the default Faster mode (5 of 6 experts per word) answered a short chat at 13 to 18 tok/s, and the first answer after a start is the slowest. With --experts 6 the first run measured 17 to 23 tok/s on a 1.7K-token chat.

• What we did not test. DeepSeek beyond short chats, contexts above 128K, a long soak, and reading pictures (it is built in and was not tried). The Q2_0 and Gyro packs do not start on ARM, because their CPU kernels exist for x86 only. There is no desktop app, HIP, SYCL or CPU-only engine for ARM. strata doctor --live lists the GB10 without a memory figure, because nvidia-smi reports none for it.

• Thanks. @ferstar's pull request #3622 made the engine build for ARM64 and is the base of this port; their name is on the commit.

DeepSeek on the Mac

• What runs. DeepSeek-V4.1-Flash 2.00 bpw and 2.25 bpw on Apple silicon (M1 or newer, macOS 15 or newer), text only. strata launch fetches the DeepSeek engine for the Mac the first time you pick DeepSeek, like on Windows. It needs 257 GB (2.00) or 274 GB (2.25) of free disk on the internal SSD or an NVMe drive, not a USB or network drive. We recommend 64 GB of memory or more, but we tested one Mac only, an M5 Max with 128 GB. A Mac with less memory starts, and setup says it will be much slower and asks before it goes on, but we ran nothing under 128 GB.

• Install. Use the Terminal (the app is still 0.2.7 and we did not try DeepSeek on the Mac in it):

  strata launch --family deepseek41 --model ist-das-2.00bpw --plan
  strata launch --family deepseek41 --model ist-das-2.00bpw

  The guide is docs/DEEPSEEK_MAC.md.

• Speed. Measured on the M5 Max with 128 GB, the engine as shipped, one fresh start per run, two runs each, in tokens per second. They were measured while another person's Qwen server (a 60 GB model, loaded and idle) was running on the same Mac, so both shared the file cache. A Mac with nothing else running may be faster; we did not measure that.

  	2.00 bpw	2.25 bpw
  Short answer, code prompt	15.2 to 16.0	14.7 to 15.3
  Short answer, agent prompt	15.3 to 16.2	13.1 to 13.6
  Answer after a 3,000-token prompt	14.5 to 15.1	11.7 to 11.8
  Answer after a 14,000-token prompt	13.8 to 15.1	10.5 to 11.1
  Reading a 3,000-token prompt	236 to 241	293 to 294
  Reading a 14,000-token prompt	479 to 512	553 to 586
  Reading a 32,000-token prompt	609	720

  The model does not fit in memory, so part of it is read from the SSD for every word (48 MB per word on 2.00, 111 MB on 2.25). Answer speed is limited by those reads and by the processor, not by the graphics chip.

• Quality. The 2.25 set stays closer to the original model: on a scoring run over 4,995 text positions it ends about 8% above the original model's perplexity, and the 2.00 set about 17% above. The Mac's closeness score for 2.25 (0.111, lower is closer) sits inside the run-to-run spread of the same set on a Radeon AI PRO R9700 (0.109 to 0.111). A hidden code in a long text was found at 14,600, 17,000, 19,500 and 26,200 tokens.

• A choice we made. The Mac reads DeepSeek's large per-word table (the Engram) with two threads. With more threads, 3 to 9 of 16 runs gave slightly different words from the same prompt. We have not found the cause. Two threads cost about 3 to 12% of prompt speed (about 12% at 3,000 tokens, 7 to 12% at 14,000, about 3% at 32,000) and do not change answer speed. DS4_ENGRAM_THREADS=N sets another number. Two runs of the same prompt can still differ in the last digits of a score, because the engine moves experts between memory and the SSD as it learns what the prompt needs; the answers stay equally good.

• Found and fixed in testing, before release. A code hidden past 16,000 tokens was missed, and some short follow-up turns went wrong.

• What we did not test. Any Mac with less than 128 GB, prompts longer than about 32,000 tokens, and the 1.75 bpw set (not offered on the Mac). There are no pictures yet, because DeepSeek's picture reader was not run on the Metal engine, and a picture sent to a DeepSeek model on a Mac is refused. The DSpark drafter is off on the Mac, because it gave the same answers and no speed-up. Qwen on the Mac keeps its pictures.

What you will notice

• NVIDIA cards with 12 GB or less answer faster. The router now prefers experts that are already on the card, which saves page-ins from RAM. On an RTX 3060 12 GB (Qwen3.8-Flash-Next IQ3_XXS, five paired runs against the same build with the setting off), a story answer went from 46.2 to 53.1 tok/s (+15%) and a code answer from 45.7 to 62.5 tok/s (+37%). It picks a slightly different set of experts, so the wording of answers changes. We checked the answers on that card (IQ3_XXS) with 80 tasks and saw no copy or code errors. Agent loops may finish slightly less often, within the run-to-run spread: out of 10 agent tasks, 4.5 passed on average over 4 runs at 1.5, against 5.6 over 7 runs with the setting off, where the off runs alone ranged from 4 to 6. A stronger setting (2.0) did show copy and code defects, so the default is 1.5. It applies to a discrete NVIDIA card of 13 GiB or less; larger cards, Radeon and Strix Halo are not changed. Off: the row "Faster answers on 12 GB NVIDIA cards" in the Expert settings (Models, Native engine settings, Speed), or STRATA_ROUTE_PRIOR=0.

• Radeon RX 9000 and AI PRO R9700: faster Qwen. Two changes: the large per-token lookup table stays in RAM when the PC has room for it, and the decode split between card and processor starts at a better value. One R9700 (32 GB) with 125 GB of RAM on Linux, Qwen IQ3_S, medians of three runs:

  | Context | Prompt before | Pr...

Strata 0.2.6: fixes from the stress tests, a faster DeepSeek on big-RAM PCs, and an uninstaller that finishes the job

The app and the Terminal are 0.2.6. The DeepSeek engine and Control are 0.1.51. The Qwen engines stay at 0.1.50: nothing in them changed, so their packages are the same files as in 0.2.5.

What you will notice

• Uninstalling on Windows removes the program folder. Strata's own app, host and engine processes are stopped first, so the folder no longer stays behind after you have used the app. This fixes the known issue of 0.2.5. Only processes that run from the install folder are stopped.
• The monitor handles a small integrated graphics chip next to a real card. With All GPUs, a Radeon or Intel chip inside the CPU is left out of the totals and the count when a real card is present. The hardware report gives each card a stable id, because AMD, Intel and NVIDIA each number their cards from 0.
• About no longer shows the placeholder engine version (strata-engine 0.1.0) while the real one is still being read, and after an engine update it shows the new version, not the old one.
• A DeepSeek model shows its one 8K context on the Models screen, as in the guided setup, instead of the 32K default.
• A model whose files are all gone is not listed as a download in Storage and Manage models.
• A chat request with no message is answered with a 400 ("messages must be a non-empty list"), as OpenAI does. A reply of one token shows no tokens-per-second figure; a one-token probe used to read 1,250 tok/s in the monitor.

DeepSeek is faster on PCs with a lot of RAM

When all the CPU-side experts fit in RAM with 8 GiB to spare, the engine now copies all of them in at load and runs without the demand store (all or none, never a part). --mmap-experts on or off, --ssd-cache N and DS4_STORE_GB still do what you set. On Windows the check also needs the commit room (RAM plus page file), so a PC with a small page file is not pushed into paging. A PC that cannot hold the whole set, such as a 46 GB RAM PC with a 12 GB card, keeps the store as before and gets the same answers and speed.

Loading takes longer: one R9700 loads the 2.00 set in about 55 s instead of 34 s, because it copies 108 GB. The answers are the same as with --ssd-cache 0 --mmap-experts off, which we checked again on the release package. The rule comes from Project Maya (MIT).

Updating

• App: the in-app updater installs the new installer. Your engine stays.
• Terminal: run strata update. It fetches Control 0.1.51. Your Qwen engine stays at 0.1.50.
• DeepSeek engine: updates itself on the next strata launch (0.1.50 to 0.1.51).

AMD in WSL

The Linux AMD (HIP) engines hang inside WSL because the GPU bridge there never finishes a command. Setup and strata launch now say so and point to the Strata app or Terminal for Windows. They warn and go on; nothing is refused. NVIDIA cards work under WSL as before.

Small things

• Setup no longer stops with "can't reach GitHub" when you point it at a local update feed.
• The README and the docs have the new guide set: one installer per system, DeepSeek in the app and the Terminal, and the model order in all seven languages. File names in them are the 0.2.6 ones.

Downloads

Three installers, the three Control packages (0.1.51), 13 Qwen engine packages (0.1.50, unchanged), 3 DeepSeek engine packages (0.1.51: Windows CUDA 13, Linux CUDA 13, Linux AMD rx9070), plus strata-feed.json with its signature, latest.json, install-manifest.txt, install.sh, install.ps1 and SHA256SUMS.txt.

Strata is free and open source. If it runs well on your PC, a coffee keeps the work on it going:

Strata 0.2.5: one installer, DeepSeek in the app, a faster DeepSeek, and a long list of fixes

The app and the Terminal are 0.2.5. Every engine package (Qwen and DeepSeek) and the Control are 0.1.50, rebuilt for this release.

What is new

• One installer per system. Windows: Strata-0.2.5-windows-x64-setup.exe. Linux: Strata-0.2.5-linux-x86_64.AppImage. Mac: Strata-0.2.5-macos-arm64.dmg. 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. If you downloaded the engine file yourself, choose "I already have the file" and it installs offline. The Mac file keeps its small Metal engine inside.
• 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 that is 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: --speed, --full-quality or --experts N. It needs DeepSeek engine 0.1.50 or newer; an older engine gets no Speed step and no flag. On an RTX 5070, Faster mode decoded code and agent runs 16% faster. On a Strix Halo it was 11 to 13% faster to decode and 5 to 7% faster on prompts. On an MI325X the quality checks showed no difference from Full quality.

DeepSeek is faster on many PCs

• The RAM store can hold every expert. It used to stop at 48 GB. Where the free RAM holds all routed experts, it now keeps all of them (one R9700 with 251 GB of RAM: 12.6 to 21.4 tokens/s on the 2.00 set). It still leaves 12 GB free.
• The CPU starts on the experts it already has while the rest are read from the SSD. +13.5% on an RTX 5070 and +11 to 15% on an RTX 3060 PC.
• Fewer GPU launches per layer. Decode +13% on one test PC in 5 of 5 pairs (same output every run), +2.4% on one R9700 and +4.5% on four.
• Prompt chunk sizes follow what the PC holds. NVIDIA cards under 16 GB now read prompts in chunks of 4096 instead of 8192: agent decode +2%, an agent turn takes the same time, a cold 8K prompt is 9% slower. AMD cards and cards with 16 GB or more keep 8192. Four R9700 cards that hold most experts use 1024.
• One card on a PC with several cards no longer reads prompts in small chunks. It used chunks of 1024 and was up to 2 times slower on long prompts (one R9700: 8K prompt 205 to 431 tokens/s).
• Strix Halo. The prompt kernels use the matrix units on gfx1151: prompts 22% faster at 4K and 29% at 8K, same answers (KL 0.10204 against 0.10203). The RAM store is sized again after the weights are on the GPU, so the PC keeps 12 GB free and 32K and 64K contexts no longer run out of memory on the new AMD driver.
• The same prompt always takes the same path. The engine now picks the prompt path from the prompt's length (96 tokens and more go through the chunked pass). The old timing guess changed answers between runs. Once the model is ready, the engine also warms up the chunked pass in the background. If a few seconds pass before your first prompt, that prompt no longer pays the one-time setup (about 3.6 s on an R9700).
• Intel server CPUs (Sapphire Rapids and newer) read the i-quant tables with a gather, which takes 25 to 47% less time on the expert rows we timed (gate and up of one expert, 1 to 4 tokens, on a Xeon 8468; identical output). That is a microbenchmark, not an end-to-end speed. On the AVX-512 CPUs we tested (Zen 4 and Sapphire Rapids), the DeepSeek IQ1_M rows used for prompts are 9% faster, with identical output.
• Qwen engine: on one CUDA GPU 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.

Fixes in the Terminal

• An NVIDIA driver from 528 to 579 runs the CUDA 12 engine by itself and says so (#3843). A card taken out of the PC no longer decides the engine (#3892). RTX 40 cards (sm_89) take the sm_86 package.
• A big model gets a longer start wait by itself: 10 minutes plus about 8 s per GB above 40 GB, at most 30 (#3949, #3459).
• strata update says "the engine was NOT updated" when it was not (#3653), runs the new engine's test start with a short context (#3842) and keeps the CUDA build that runs on your PC (#3835). The launch summary names the engine log (#3656).
• Setup: a Mac with an Intel Python is still an Apple Silicon Mac (#3894); the --kv fp16 flag from the Docker guide works (#3785); a download that gets no data for two minutes says so (#3567); cmake and Visual Studio 2022 are checked in the right order with a plain stop (#3822, #3566); a shared Windows/Linux .venv installs again (#3634).
• Deleting a model removes the files Strata downloaded, even in another models folder (#3716). A file set with the layout of a tested build is used with a notice (#3651, #3777).
• AMD cards on Windows show their memory in setup (#3727, PR #3798 by chicco83). strata connect scales the compaction point with the server's context (PR #3852 by demetree).
• strata launch at 80 columns keeps the verdict column. The DeepSeek engine upgrade lines also show on the setup path.

Fixes in the app

• A finished app update is no longer shown as "Interrupted operation"; the update writes its steps to the log and warns if the app came back as the old version.
• Copy response and Copy message say Copied or say why not (#3731); a pasted screenshot is read (#3748); typed line breaks and decimals in the sampling fields work (#3720, #3736); PDFs go into the chat folder (#3838); reopening a chat restores its folder (#3754); downloaded models appear in the chat picker (#3814); one newline inside a paragraph is a soft break (#3818).
• The monitor no longer starts a cold PowerShell every 3 seconds (#3939), and shows the memory and load of AMD and Intel cards on Windows (#3727, #3836). With All GPUs, a card that cannot report a value is left out and the one that can is named.
• The folder picker falls back to typing the path when security software closes it (#3831). The Models page shows a neutral placeholder until the engine answers (#3740) and counts the chosen context in the memory estimate (#3832).
• 69 interface strings that had no key now exist in all eight languages (#3479, #3825). Sizes are decimal MB everywhere.
• Known issue: uninstalling Strata on Windows right after using it can leave its program folder behind. Close Strata first, then uninstall.

Updating

• App: the in-app updater installs the new installer (same file as the download). Your engine stays; the first-run card appears only when there is none.
• Terminal: run strata update. It fetches Control 0.1.50 and the engines you use.
• DeepSeek engine: updates itself on the next strata launch (0.1.49.2 to 0.1.50), as in 0.2.4.2.
• Intel Arc on Linux (SYCL): needs Ubuntu 24.04 or newer (glibc 2.38).

Downloads

New installers (3), the Control packages (3), 13 engine packages and 3 DeepSeek engine packages, all at 0.1.50, plus strata-feed.json with its signature, latest.json, install-manifest.txt, install.sh, install.ps1 and SHA256SUMS.txt. The old per-GPU installers are not attached again.

Strata is free and open source. If it runs well on your PC, a coffee keeps the work on it going:

Strata 0.2.4.2: DeepSeek launch and install fixes

Fixes for strata launch with DeepSeek and for the one-line installer. The Terminal's Control (0.1.49.2), install.sh and the three DeepSeek engine packages (0.1.49.2) changed. The app stays 0.2.3 and every Qwen engine package stays as it was, so there is nothing new to download for them.

What is fixed

• Faster DeepSeek on AMD Ryzen 3000 / Threadripper 3000 / EPYC 7002 CPUs. The 2.00 and IQ1_M sets answered up to 3x slower there; the answers are unchanged. The DeepSeek engine is now 0.1.49.2 (strata-dsv41-0.1.49.2-windows-x86_64-cuda-cuda13, -linux-x86_64-cuda-cuda13 and -linux-x86_64-hip-rx9070).
• DeepSeek setup no longer stops on a Qwen picture file in your models folder (#3927, #3917). If the folder you share between models held a Qwen vision file, DeepSeek setup picked it up by mistake and failed. It now ignores any picture file that is not DeepSeek's.
• Model files you already have are recognised for DeepSeek in the guided screen too, including Unsloth's UD-Q8_K_XL set (#3914). The "use model files I already have" screen called a downloaded UD-Q8_K_XL file unreadable. It now recognises DeepSeek sets by their file names, as strata launch --model-path already did.
• The right DeepSeek engine runs when you have more than one Strata install. Launch now picks the newest DeepSeek engine package of the install that is running, and of the install your model's settings came from, instead of an old path saved in the model's settings.
• A plain message when GitHub cannot be reached. DeepSeek setup checks for 10 seconds before it downloads anything and says in one line that GitHub is not reachable, instead of retrying for minutes.
• Faster returns to a conversation. DeepSeek keeps recent conversations (and a shared system prompt) on disk, so a returning agent or a sub-agent with the same system prompt answers sooner; up to 2 GB, cleaned after a week.
• The DeepSeek engine updates itself. A newer DeepSeek engine package in the signed feed is installed on the next strata launch (see Updating).
• DeepSeek no longer downloads the Qwen engine. A DeepSeek launch does not fetch or test-start the Strata (Qwen) engine, the llama.cpp source or CUDA libraries it never uses. strata launch --plan no longer promises that download.
• The disk check counts only what is still to download. If most of the model files are already in your models folder (also under the first release's file names), the model list no longer says "tight: needs more disk space". The room for the prepared model is still counted.
• Smaller wording fixes. A setup message that ended with a full stop no longer gets a second one ("engine.."), and the second sentence of "The model could not be installed. The model does not answer sensibly after the preparation: ..." starts with a capital.
• The install one-liners keep your terminal open on an error. install.sh is now a function that returns an error instead of closing the shell it runs in, and the commands in the README and docs download it first: curl -fsSL https://github.com/Niko1221/Strata/releases/latest/download/install.sh -o install.sh && sh install.sh.

Updating

• DeepSeek engine: it updates itself on the next launch. When the signed feed has a newer DeepSeek engine package for your PC (0.1.49.2 over 0.1.49), strata launch downloads it, checks it, starts it once, switches to it and removes the old one. If that fails you see one line and the engine you have keeps running; with no internet the launch goes on without waiting. An engine you gave with --dsv41-package or STRATA_DSV41_EXE is never replaced.
• From 0.2.4 or 0.2.4.1: run strata update in the Terminal. It fetches Control 0.1.49.2 and the next strata command runs it (strata --version says 0.2.4.2).
• New installs: use the command in the README (download install.sh, then run it).
• Mac: the Mac Terminal gets Control 0.1.49.2 too. DeepSeek is not on the Mac yet.

Downloads

Everything from 0.2.4.1 is attached again, so the release page still holds every file. New in this release: the three Control packages (strata-control-0.1.49.2-windows-x86_64.zip, -linux-x86_64.tar.gz, -macos-arm64.tar.gz), the three DeepSeek engine packages (strata-dsv41-0.1.49.2-windows-x86_64-cuda-cuda13.tar.gz, -linux-x86_64-cuda-cuda13.tar.gz, -linux-x86_64-hip-rx9070.tar.gz), install.sh, the feed and SHA256SUMS.txt. The installers, AppImages, dmg and Qwen engine packages are the 0.2.3 files.

Update 0.2.4.1: DeepSeek setup now works from the installed Terminal. The 0.2.4 Terminal package was missing the DeepSeek preparation scripts, so setup stopped at "Preparing your model". If you installed 0.2.4, run strata update, then run your DeepSeek setup again. New installs get the fix automatically. The RTX 3060 figure below is corrected to the release defaults (8 to 10 tokens/s; DSpark stays off by default on 12 GB cards).

Strata 0.2.4: DeepSeek V4.1-Flash in the Terminal

Strata now runs DeepSeek V4.1-Flash on a PC with one 12 GB graphics card and 46 to 64 GB of RAM. The engine keeps the experts it uses most in RAM and streams the rest from your SSD.

DeepSeek is in the Terminal (strata launch, strata setup) in this release. The desktop app is unchanged (it stays 0.2.3) and gets DeepSeek in a later update.

What you get

• DeepSeek V4.1-Flash in the model list of Setup, in three sizes from ISTA-DASLab:

  set	download	quality against the original model
  IQ1_M (1.75 bits)	239 GB	perplexity +21% (KL 0.217); code and agent text +8.9% and +10.2%; weaker on plain English prose. ISTA-DASLab's model card: keeps 98.7% of the base model's task average (AIME25, GPQA-Diamond, LiveCodeBench v6)
  IQ2_XXS (2.00 bits)	257 GB	perplexity +15.5% (KL 0.170); code and agent text +8.6% and +5.3%
  IQ2_XS (2.25 bits)	274 GB	perplexity +7.3% (KL 0.107); code and agent text +3.2% and +2.2%
  IQ4_NL (Engram table, not a model to pick)	111 GB, already in all three downloads above	The 4-bit Engram lookup table the model reads from RAM or SSD; all three sets use this one file

  "Perplexity" is how surprised the model is by a fixed set of 4,995 test texts; lower is closer to the original. Pick IQ2_XS for coding and agent work when you have the disk. Setup shows all three sizes and warns if your PC is short of disk or RAM. It does not stop you.

• Setup downloads the files, builds the model folder and starts the engine. You set no flags.

Speed on real PCs

Output is the speed of the answer. Prompt is how fast Strata reads what you send it.

These are the 2.00-bit set. The 2.25-bit set reads 13% more data per token, so expect it to be a little slower. Your drive matters: the 12 GB cards spend most of each token waiting on the SSD and on the CPU, and a slow NVMe drive lowers every number above.

How it works

• A RAM expert store that sizes itself. The model is a mixture of experts: each token uses a few of thousands of small blocks. Strata keeps the busiest ones in RAM, takes whatever RAM is free, and reads the rest from the SSD with direct reads. On the RTX 5070 PC with 64 GB this gave 4.3 to 4.9 tokens/s where memory-mapping the files gave 1.8 to 2.2.
• Hot-expert profiles ship with the engine, so the first prompts do not start cold.
• Faster prompts. The engine now reads long prompts layer by layer in big chunks instead of 16 tokens at a time. A 200-token prompt went from 3.6 to 6.4 tokens/s on the RTX 5070 PC, and 8K prompts reach 231 tokens/s.
• Faster prompts on Radeon AI PRO R9700. New matrix-core kernels (RDNA4) read prompts 36% faster at 8K and 49% faster at 32K on 4 cards (370 to 505 and 550 to 818 tokens/s). Answer speed does not change. They are on by default on these cards.
• Faster long prompts. A prompt over about 3,700 tokens skips work that the last 20 layers cannot use (a 16K prompt is about 34% faster). In 99.5% of the 799 positions we compared, the model's top choice for the next word was the same with and without the skip.
• Thinking budget. When neither your request nor your config sets one, DeepSeek thinks for at most 32,768 tokens. A request can set its own budget; 0 turns the limit off.
• DSpark (a small draft model from Unsloth) is on where it measured faster and off on CPU-bound PCs. On 12 GB cards DSpark stays off by default; turning it on (--dspark on) adds 2-13% on the RTX 3060 PC. On the 4x R9700 box it raised 31 tokens/s to 55 to 69. On the RTX 5070 PC with a 6-core Ryzen 5 7600 it gave no gain at any setting (code 4.64 tokens/s with it off against 4.33 at best with it on; agent 3.41 against 2.86 to 3.21), because checking the drafts costs the CPU about what the saved tokens are worth. There --dspark auto does not load the drafter.
• Faster CPU rows. The engine has new exact rows for the experts the CPU computes: AVX-512 on Zen 4 and Zen 5, AVX2 on other CPUs, chosen automatically. On the Ryzen 5 7600 PC with an RTX 5070 (2.00 set, DSpark on, three alternating pairs, identical text in all six runs), decode went from 4.08 to 5.11 tokens/s (+25%) and prompt reading rose 26%. This was measured on one CPU, a Zen 4. Zen 5 gained more in the kernel tests.
• Cards and engines: tested on an RTX 3060 (Linux, full model), an RT...