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 compiling the kernels once (a kernel is a small program for the graphics chip). Later pictures add 0.8 to 1.0 s.
  • Tower times, warm: 798 x 448 in 93 ms, 672 x 448 in 76 ms, 1344 x 1260 in 1.24 s. The plain kernel needs 2.6 s, 2.1 s and 29 s for the same three.
  • M4: the tower ran on an M4 with 32 GB (encode only, not a chat): 896 ms, 710 ms and 8.6 s for the same three pictures with the tensor-operation kernel, and 4.3 s and 3.5 s for the first two with the plain kernel. The output matched the M5's plain kernel.
  • M1 to M3: not measured. At the first picture the engine compiles the tensor-operation kernel and checks it against the plain kernel on a small problem. If the kernel does not compile or the result differs, it uses the plain kernel. We tested that fallback by forcing it (DS4_VISION_FORCE_MPP_FAIL=1), not on an M1, M2 or M3 chip. DS4_VISION_NO_MPP=1 selects the plain kernel.
  • Compared with the Windows tower on the same pictures, the Mac output differs a little: cosine similarity (1 is identical) 0.997 to 0.998 on the worst rows of the two smaller pictures, 0.984 on the 1344 x 1260 picture. Text answers were unchanged (5 prompts, token counts identical with pictures on and off).

• 128K context on 8 GB cards, and the context never shrinks. The default context is 131,072. When a start is short of graphics memory, Strata keeps your context and your number of requests and moves work off the card instead. The steps:

  • The KV window (the part of the conversation's memory kept on the card) steps down (20,480, then 8,192, then 4,096).
  • The MTP layer is dropped when it cannot fit.
  • The prompt path's buffers use less (it keeps 16 expert-cache slots instead of 128).
  • As the last step, the output head (0.41 GiB) sits in pinned host memory, which makes decode about 3 times slower.

  This applies to discrete cards only, not to Apple chips or integrated graphics such as Strix Halo. On a discrete Radeon card the same walk is priced from a base measured on an R9700 (3,900 MiB). At 128K with DFlash2 alone: 7,942 MiB gave 787 expert slots and 48 to 52 tokens per second; 7,000 MiB gave 439 slots; 6,400 MiB gave 273 slots; 5,800 MiB put the head on the host (31 tokens per second); 5,200 and 4,600 MiB were refused with a plain line.

• Setup and the launcher. When you point strata launch --plan at your own model files, it now counts the drafter, the Engram and the picture file it will still download, instead of saying "Nothing to download". The speed cards show the run's average (a patch by keinebenutzer, MIT, below). The app and the Terminal take the draft-vocabulary choice you made in setup (en, fr, cyrillic) for DFlash2.

The ISTA-DAS Coder

ISTA-DASLab's coding version of DeepSeek-V4.1-Flash keeps 192 of the 384 experts in every layer, the ones chosen for code and agent work. Experts are the model's specialist parts; each word uses only a few. Start it with strata launch --model ISTA-DAS-Coder. Repo ISTA-DASLab/DeepSeek-V4.1-Flash-1017-GSQ-RCO-Coder-GGUF, revision 0b1d5da5: five model files in IQ2_XXS/ (72.1 GB), the Engram file (110.6 GB, a large lookup table the model reads as it writes) and the picture file (0.97 GB). The weights inherit the base model's MIT licence.

• Download: 191 GB for someone with no DeepSeek file (72.1 GB model, 110.6 GB Engram, 8.0 GB drafter). The Engram file is the one the other ISTA-DAS sets use. A copy that is already there is used where it is, and the ISTA-DAS Coder then downloads 80 GB. The Engram stays on the SSD: the model reads a few of its rows for each word, so it is not counted in RAM (keep it on an NVMe drive).

• Your own files: --model-path <folder> takes the repository folder (IQ2_XXS/ with the Engram and picture file at the top) or IQ2_XXS/ itself. Every file is checked against its pinned size and SHA-256, and a stopped download resumes.

• The first launch of any DeepSeek set fetches the 8 GB drafter, also with --dspark off (it is part of the model's prepared data). strata launch --plan now says so.

• Same weights as the files we measured with: all 1,042 weight tensors, the Engram and the 298 picture tensors have the same hash as the official repository, tensor by tensor.

  Computer	Engine	Decode, tokens per second
  4 x Radeon AI PRO R9700, Linux	0.1.55 DeepSeek package	59.2 (4K prompt read at 1,280; a 32K needle found; an agent loop of 12 turns in 13.5 s)
  1 x Radeon AI PRO R9700, Linux	0.1.55 DeepSeek package	22.8 (start 54 s)
  Ryzen AI Max (Strix Halo), Windows, 128 GB (64 GB set aside for graphics)	0.1.56	20.9 to 21.9; ready in 87 s with nothing to download; 8,064 of 8,064 experts in graphics memory; a 6.4K needle read at 487 and found; pictures read correctly (about 21, the picture read in 0.8 s)
  Apple M5 Max	0.1.56	19.1 to 22.5
  RTX PRO 6000 Blackwell, Linux	test build of the 0.1.55 source	about 100
  DGX Spark (aarch64)	0.1.56	no speed measured; ready in about 4.5 minutes including the pack; 8,064 of 8,064 experts in memory; pictures read correctly with the GPU reader
  Windows with an NVIDIA card	0.1.56	not run yet; the plan for a 12 GB card with 64 GB of RAM says about 3 GB of the experts stay on the card and the rest come from RAM and the SSD

• Against the original model (4,995 positions, 6 experts per word): KL 0.397, top-1 76.4%, perplexity 4.645 (original 3.140). KL and perplexity are lower the closer a model is to the original; top-1 (how often both pick the same next word) is higher. In the same test the ISTA-DAS 2.00 set measures KL 0.171 and perplexity 3.630, and the 2.25 set KL 0.109 and perplexity 3.405. KL by part: code 0.230, agent 0.199, documents 0.302, English 0.476, multilingual 0.777. Our 61-task suite: 54 of 61, the same as the 2.00 and 2.25 sets. ISTA-DASLab's own figures (their model card): SWE-bench Verified 77.00 against 81.20 for the base model, LiveCodeBench v6 88.57 against 89.71.

• With the RAM limited (one R9700): 20.9 tokens per second at 40 GB, 18.5 at 32 GB, 15.0 at 24 GB, 8.0 at 16 GB.

• On one R9700, our test engine decoded the ISTA-DAS Coder at 25.6 tokens per second, against 22.8 for the 0.1.55 DeepSeek package (median of 3 answers each).

RTX 50 cards (Blackwell) and CUDA 12

The CUDA 13 package starts in about a minute on an RTX 50 card (60 to 80 s measured). The CUDA 12 package, which older drivers need, builds its GPU code on the first start: 310 s measured on a Blackwell card (compute capability 12.0). After a driver update to 580.65 or newer, choose CUDA 13 in Settings, Engine. An update keeps the CUDA build you have.

Going back to 0.2.9

strata components rollback returns to the 0.1.55 engine; Control stays 0.1.56. To go back to the earlier drafting choice: strata launch --drafting mtp. To turn the split engine off: --split-engine off or STRATA_SPLIT_ENGINE=0. To start with a smaller context than 131,072: --max-context.

What we ran on the release files

Every line below used the release packages themselves.

• Ryzen AI Max (Strix Halo), Windows, 128 GB: the final Terminal installed the engine from a local copy of the signed update feed, through its signature check. Qwen3.8 IQ3_S on Auto: DFlash2 alone, 64.9 / 67.7 / 56.5 tokens per second, a picture read correctly. The ISTA-DAS Coder from a Hugging Face layout folder, with a picture as the first request: ready in 93 s, nothing downloaded, "CODE 4217" read, first token on a code prompt in 0.70 s. The engine's working set peaked at 35.1 GiB and available RAM stayed above 15.4 GiB. With only about 19 GB of its 73 GB of experts held in memory (the rest read from the SSD), the ISTA-DAS Coder gave every answer right, at 4.0 to 5.5 tokens per second. No kernel-power, LiveKernelEvent 141 or watchdog event all evening.
• DGX Spark: the final Terminal and Control. Qwen3.8 on Auto ran DFlash2 alone (625 MiB) and read a picture correctly with the GPU picture reader. The ISTA-DAS Coder from the repository folder read a picture correctly; it used its own picture file and downloaded nothing (1.6 MB of network traffic in that part). An update from a 0.2.9 install moved Terminal, Control and engine to 0.2.10 / 0.1.56, kept 0.1.55 for rollback, and downloaded no model file again.
• Mac, M5 Max: the signed and notarized dmg installed the normal way (Gatekeeper accepted it as notarized; the app's own self-test passed 12 of 12 steps). From the installed app's Terminal, Qwen3.8 IQ3_S on Auto ran DFlash2 and read a picture correctly at 115 to 119 tokens per second. With the signed DeepSeek folder, the ISTA-DAS Coder answered 5 of 5 text requests (a tool call and a 6K needle among them) at 22 to 23 tokens per second, and read 3 of 3 pictures correctly. Peak memory was 74 GB.
• Linux, two RTX PRO 6000 Blackwell: a plain strata launch on a new install fetched the MTP draft layer by itself and started the split engine (edits 754 to 773 tokens per second, a 32K prompt in 3.3 to 3.5 s). Four requests at once and four requests on three slots all completed. Pictures and an 8-turn agent session worked. --split-engine off ran the layer split with DFlash2 alone. The Linux app (AppImage), on a new install, took a model from a folder already on the PC without downloading it again. Its Auto load on both cards downloaded only the DFlash2 drafter (1.21 GB), built the drafter file and ran the layer split with DFlash2, one request at a time; the MTP layer was not downloaded. A chat and a picture worked. After an unload, a second load downloaded nothing and ran DFlash2 again. On one card the app ran DFlash2 the same way.
• Linux, two RTX A6000: the split engine on Auto: edits 399 tokens per second against 201 on the layer split with MTP, a 32K prompt in 8.8 to 8.9 s against 11.0 s. Four requests at once completed.
• Intel Arc A750 (8 GB): Auto ran DFlash2 alone (13.9 to 18.4 tokens per second). All four 128K starts we tried started at the asked context and request count. With MTP chosen, only MTP loaded.
• Windows PC with an RTX 5070 (12 GB): the CUDA 13 and CUDA 12 packages passed these checks: 128K on Auto with DFlash2 alone; two requests at 128K on the full card and squeezed to about 8 GB (the context stayed 131,072); MTP chosen loading only MTP; the GPU picture reader; Gyro-S on Auto; and a start limited to about 8 GB. The Windows installer was checked without installing it: its hash, its update signature, the versions and the bundled runtime files.
• Linux, four R9700: the final Terminal installed the RX 9070 package from a local copy of the signed feed (signature and every file checked). A plain strata launch started the split engine on 4 cards. With --parallel 8, 8 requests ran at 350 tokens per second, a 103K-token prompt took 33 s, and pictures read correctly. IQ3_S on Auto ran the layer split (318 with 8 requests); one card ran DFlash2 at 94. Earlier on the same day with the same Terminal: tool calls, strata connect opencode --check, and the refusal of logprobs and logit_bias on the split engine.

Fixed, from your reports

• Chat and the app:
  • #4725: with a long reply on screen, the Approve and Deny buttons scrolled out of sight. They now stay above the message box, and the reply says it is waiting for your answer.
  • #4748: a copy gave no sign on the button itself, and seven copy buttons gave none at all. Every Copy control now shows a check mark for about two seconds ("Copied" in menus).
  • #4749: the Subagents panel had no way to answer a helper. Each helper row now takes a message (steer for a working helper, queue for a finished one) and says when it was sent or refused.
  • #4750: the summary that replaces older history was always written in English. It is now asked for in the language you used; paths, commands and names stay exact.
  • #4783: while an answer was being written, the desktop chat could only wait. Enter can now wait, send after the answer, or interrupt it. The choice is in Settings.
  • #4785: you can now quote a turn or a selected passage into your next message. Quotes sit above the box and can be removed.
  • #4721: a web address in a reply opened nothing. A plain click now opens it in your own browser, and the Open button of a website preview works.
  • #4722: one reply showed three text widths (paragraphs, lists, tables). Paragraphs, lists and quotes now share one width; tables and code keep the full width.
  • #4218: a stopped helper kept its "In progress" row after a restart. It is shown as stopped when the page loads again.
  • #4244: the agent's own questions now get a card with options, your own words, one answer or a skip. A goal, a plan step or a /loop run with nobody there declines the question at once instead of stalling.
  • #3723 (part): the first start now opens in your computer's language and the first screen has a language choice. Context memory says in one line what each format costs. A start that ran out of graphics memory says so in plain words with the next step. The taskbar icon part is not covered.
• Tuning, install and update:
  • #4802: the progress card of a download, load or tuning run now has its own look, a spinner, a running clock ("Still working for 3m 12s. You don't need to do anything.") and a line saying the buttons below wait.
  • #4804: "Start tuning" greyed out with no reason. It now says why in one sentence (still reading saved tunings, could not read them, another operation running).
  • #4805: a tuning that did not finish said only "could not start with these settings". It now shows the tuner's own reason and what this PC has, behind Details.
  • #4823: a model install that also updates a working engine now says from which version to which, that the old one is kept, and that Settings can go back.
  • #4853: the engine install could loop forever when Windows would not let Strata rename the checked engine into place. After a 40 second wait it copies instead, and the first-run card says why it stopped.
  • #4891: after two updates, a saved run config pointed into a removed engine folder, so every model showed as not installed. Saved paths now follow the update to the current folder.
  • #4772: DeepSeek-V4.1-Flash told you to update an engine that was fine, because it asked for the Qwen picture reader program. It reads pictures without it now.
  • #4824: strata launch after a tuning was blocked by a runtime host left in "failed", and --save-preset was lost. The host is cleared first, and the preset is kept when the start fails after the tuning.
  • #4779: in Docker, RETUNE=1 did nothing. It now passes --retune to the launcher.
  • #4693: Strata's own draft layer (mtp-q2_0.gguf) beside a model was counted as a second model, and the folder was refused ("holds more than one model"). It is no longer counted.
  • #4798: while sharing is on, the app now shows the address on this computer and the one for other devices, with a line on why their ports differ. The ports themselves are unchanged.
• Tool calls and the server:
  • #4663, #4700: a tool the conversation already called counts as declared on the Anthropic and Responses routes too (0.2.9 did this only on Chat Completions). An Anthropic tool-search request with a deferred tool now comes back as a tool_use, and a tool_reference loads the tool's definition.
  • #4751: a call written as tools.write, functions.write or default_api.write is now the declared tool write, not text.
  • #4701: a file write whose content lists the closing tags on their own lines was cut short, and the rest leaked into the answer. The closing tags now end a value only when no text and no later closing tags follow, so the file is written whole. Full serve suite: 1,265 passed.
  • #4838: on /v1/messages a context overflow now starts with Anthropic's own wording ("prompt is too long: N tokens > M maximum"), then Strata's sentence. Claude Code then compacts or shortens max_tokens instead of retrying the same request three times.
  • #4678: the token counter showed "-" for tokens in on an Anthropic stream. The prompt count from message_start is read now.
  • #4654: the ResourceWarning lines on every run are gone (two files were never closed). No answer changes.
  • #4590: Qwen (and Qwen3.6 and the Intel engine): the repeat, frequency and presence penalties counted the last tokens of the prompt, so a new task could repeat the old JSON. They now count the reply's own tokens. On the reporter's 4-message conversation, IQ2_XS on a P100, the old JSON came back in 13 of 32 seeds as shipped and 4 of 32 with the change. On the 61-task suite: 56 and 55 as shipped, 55 with the change. STRATA_PENALTY_PROMPT=1 brings the old window back.
  • #4677: a parked conversation was sometimes refused on the next turn, and about 6% of the prompt was read again. The request now keeps only the rows the client got. On Linux Radeon (HIP), 4 of 16 continuations fell back before and 0 of 16 now (4 x R9700, long conversations). It is on by default; STRATA_SERVE_STOP_BOUND=0 turns it off.
• Engine:
  • #4846: when RAM was still short at the expert arena, the host stalled with the table lock held. The lock is given back, and the experts are read from the file like --mmap-experts (or a RAM copy of the hottest ones). We have not run this on the reporter's setup.
  • #4671: the PLE table lock was refused under systemd's default memlock limit. Strata raises the soft limit to the hard one first, and if the table still does not fit it says how much this program may lock and what to set.
  • #4733: Windows: an engine started from a low-priority program (Task Scheduler, a service, an IDE) inherited Low disk priority and read its model about 15 times slower. Its disk priority goes back to Normal and one plain line says so.
  • #4741: a pack that keeps one projection in BF16 stopped the engine with "no native GGUF blocks" on the first request. That matrix is served as Q8_0 like its siblings.
  • #4825: Strix Halo, Unsloth UD-IQ1_S and UD-IQ1_M: every prompt of 96 tokens or more came out as NaN, because a Q6_K matrix overflowed the dequantizer's buffer. This is fixed, and the dequantizer is now bit-identical from run to run. Measured on a Strix Halo: UD-IQ1_S long prompts and the agent loop work. On the 2.25 set, prompt speed went from 166.1 to 164.9 at 4K and from 297.9 to 294.2 at 8K tokens per second (about 1% slower). We did not run the reporter's Linux container.
  • #3431, #2960 (PR #4787): Windows, Radeon (HIP): about one engine start in ten read every long prompt and picture wrong. The expert arena's GPU aliases are now kept clear of the process's memory. The author measured 0 bad starts in 110 with the change and 5 in 70 without, on an RX 7900 XTX. We only built it; we have no gfx1100 card to run it on.
  • #4144, #4730: Mac: a conversation never parked, so the second turn read its whole prompt again. With two conversations taking turns (11K and 6.5K, 24K and 3K tokens), the second request took 6.3 and 14.9 seconds before and 46 to 65 ms now, with the same answer ids.
• Thanks: the SYCL prompt kernels and the copy-engine hang fix from maxfridbe (#3248), the Battlemage decode work from glorysdj (#4185), the --lookup-max-t window from merbanan (#4040), and the arena patch from GoldenLeafBird (#4787) are in this release.

Probably fixed, please retest

• #4848: Gyro-S gave one token per answer on an RTX 4050. The log showed engine 0.1.52 under app 0.2.9. Auto now only uses what the installed engine can do, and the Models screen tells you an older engine has a newer one, with an Update engine button. We could not reproduce the one-token answer on that card, so please retest.
• #4926: after a switch to a local GGUF folder, picture reading said it was off or "prepare this model's vision files" although the picture file was there. Setup now uses a picture file you already have (also in the folder above --gguf-dir). Read pictures is on by default for models that can read them, and a load with no picture files fetches only those. Not tried on a 3090 with the reporter's folders.
• #4706: Mac (Metal): the 256-expert pruned Coder. The routers, the prompt chain and the SSD stream now take the model's expert count. The 512-expert path gave the same greedy ids; an end-to-end 256-expert run on the new code was not made (58 GB download).
• #4726 (part): the local-model importer accepts the Flash-Next family's own architecture (qwen4exp). The rest of that report (never registered, no autostart, "native load says not installed") is not covered.

Known problems

• DeepSeek answers can differ between starts at temperature 0 (the setting that should always give the same answer). One or two experts per card sit differently from one start to the next, and the expert cache moves experts between the CPU and the GPU between requests. On Radeon cards (HIP) the CPU lane computes part of the experts, which adds the same effect. We compared engines by KL, not by identical tokens. This was already so in 0.2.9.
• A DeepSeek tool call can come out broken when most of the model streams from the SSD. With only about 13% of the default set held in memory and temperature 0.6, 1 of 5 runs put a "DSML" marker inside the tool's argument, on both the 0.1.55 and the 0.1.56 engine, the same request each time. With the model in memory, 8 of 8 tool calls were correct on both engines.
• The drafter is fetched even with --dspark off. Skipping it for "off" or "none" is a later change.
• Mac: the Terminal archive and the DeepSeek folder are signed and notarized but carry no stapled ticket (Apple cannot staple a ticket to bare programs). The first launch of a copy downloaded with a browser needs an internet connection; installs with curl | sh are not affected.
• Intel Arc A750: 11 test programs that need 64-bit floats abort on the card, and the engine does not repeat its own answers exactly (the experts are computed on the CPU).
• AMD, the split engine: the AMD engine packages do not bundle librccl, and setup does not install it for them, so the split adds the prompt sums through the host. The engine says so in one line. In our tests that made a 103K-token prompt about 14% slower than with librccl (about 4.5 s); answers are the same. The split engine does not support logprobs or logit_bias; those requests get a clear error that names --split-engine off. A plain launch gives the split 6 request slots; use --parallel 8 for 8 at once.
• All-cards split engine on two A6000 cards: a 32K prompt is read in 10.1 to 10.2 s, against 7.65 to 7.81 s on the layer split with DFlash2. Two or four 32K prompts at once run at 12.5 and 12.7 tokens per second in total, against 11.7 and 12.9 on the layer split.
• Windows with an AMD card: the DeepSeek package is built for the Ryzen AI Max (gfx1151) only; on other Radeon cards on Windows, DeepSeek has no engine yet. (The 0.2.9 item about UD-Q4_K_XL stopping on the first request on Strix Halo is fixed; it ran all evening.)

What we did not test, and what we built but did not run on a matching card

• Built and checked as packages, not run through a model by us on a matching card: Windows RX 9070 and RDNA2; Linux RX 7900, Strix Halo (halo) and RX 6000. The packages start with a stripped environment and report 0.1.56. The Linux RX 7900 package keeps the earlier AMD runtime; only the RX 9070 package has the newer one.
• The all-cards split engine on a GeForce pair, on 3 or 4 NVIDIA cards, on Windows or macOS, on a PC with 64 GB of RAM and two large cards, and with contexts above 128K. The copy-engine ring it uses for prompts differs in its last bits from sFNX's, because the arithmetic differs: 39 of 61 suite answers are identical between the two, and 29 of 61 against the layer split's.
• DeepSeek pictures on an M1, M2 or M3, and at the largest size of 9,189 patches exactly (the largest tested has 8,640).
• The 8 GB NVIDIA and Radeon numbers above come from larger cards limited by hand, on a workstation with a lot of RAM. A home PC with less RAM reads more from the SSD and is slower. The Intel Arc A750 numbers are from a real 8 GB card. On the Arc, DFlash2 decodes 2.6% slower than MTP in our A/B; it is still the Auto choice there.
• The Mac DeepSeek engine is built from a different commit than the other engines (f457ed7, the Metal picture tower on top of 06698c6). The Windows and Linux engines were built from 06698c6, the AMD Linux and Windows packages as listed in the tag message.

Updating

• App: the in-app update offers 0.2.10, or download the installer below.
• Terminal: run strata update. It fetches Control 0.1.56 and the 0.1.56 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, coming from 0.2.9: run strata update a second time (or press Update in Settings again). The 0.2.9 updater has no step for the DeepSeek engine. The first update brings the new Terminal, Control and the Qwen engine; the second fetches the DeepSeek engine package (137 MB to 554 MB depending on the PC, 1.8 MB on a Mac) and keeps 0.1.55 for rollback. Until then DeepSeek keeps working on 0.1.55. From 0.2.10 on, one update brings both.
• DGX Spark: run strata update; it reads strata-feed-linux-aarch64.json.
• Mac: the app, the Terminal and the DeepSeek engine are signed with a Developer ID and notarized (Apple accepted all four submissions with no issues); the dmg and the app are stapled. The Mac Control is packed from the notarized Terminal.

Downloads

40 files. Three installers (Windows, Linux AppImage, Mac dmg) and the Mac updater archive Strata.app.tar.gz (0.2.10), with the update signatures for the Windows, Linux and Mac app; the four Control packages (0.1.56: Windows, Linux x86, Mac, Linux ARM64); 14 Qwen engine packages (0.1.56: 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.56: 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 packages are built for these cards (from each package's BUILD.json): Windows and Linux x86 CUDA 13 for compute capability 8.6, 8.9 and 12.0; the Linux ARM64 (DGX Spark) package for 12.1; the Linux AMD package for gfx1200 and gfx1201; the Windows AMD package for gfx1151 (Strix Halo); the Mac package for Apple GPUs.

Thanks and credits

• antirez/ds4 (MIT, commit 890898cf): the Metal form of the DeepSeek picture tower follows it. The licence and credit travel with the code in third_party/antirez-ds4 and in the Mac engine package.
• ISTA-DASLab: the ISTA-DAS sets and the ISTA-DAS Coder, and the Engram file they publish.
• keinebenutzer (STRATA-average-patch, MIT): the speed cards show the run's average; ported onto 0.2.10 by hand.
• John Fink: sFNX (MIT), the all-cards split engine Strata's is built from.
• nazeshinjite: the community DFlash2 GGUF (Apache-2.0) whose idea of storing the selector codebooks as Q4_0 rows Strata's DFlash2 pack follows.
• xrip (Anthropic tool search through the server), hanchengme (a request commits only the rows it can emit), Tycho Rasch (Windows HIP: the pinned expert arena's GPU aliases), and asf0 (libstrix, MIT, part of the Strix Halo prompt work since 0.2.9).

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