Strata 0.2.2

0.2.2: Gyro on Intel Arc cards and on Macs, faster Gyro on NVIDIA cards, a Main / Helper / Off choice for each graphics card, one models folder for the app and the Terminal, an engine package for the RX 6000 series, an optional API key, and one definition of answer speed. It also fixes the issues listed below. Each speed claim says what it was measured on, and each new default says whether the answers stay identical. The engine packages are version 0.1.47 (0.2.1 had 0.1.46) and the app is 0.2.2. Update with strata update (Terminal), Settings > Update (app), or UPDATE.bat / ./update.sh (source installs).

What is new

• Graphics cards can be Main, Helper or Off. In the app, strata launch, setup, the server and Docker, each card gets a role. Main holds the last layers, the draft layer and the final check of every window; a Helper holds a share of the layers and of the expert cache; an Off card is not used and gets no process. The recommended card starts as Main, the others as Helpers, and a card with 8 GB or less starts Off. Short warnings, never refusals, appear for built-in graphics as Main, a card the engine cannot run, too little memory for the chosen setup, and no card at all. A CUDA, HIP or SYCL engine needs a card to start, so with every card Off the server stops in 3 seconds with one plain line; the Mac engine can run without one. Command line: strata launch --gpu-roles 1=main,0=helper (cards you do not name are Off), the same flag in setup, GPU_ROLES in Docker. On two RTX A4000 the roles gave the expected order (head and draft layer on the Main card, picture reader on the first card), an Off card stayed at 1 MiB with no process, and all-Off stopped as described. Two equal cards now put the lower number on Main, so the engine order is [1, 0] where it was [0, 1]; the cards run at the same speed, so no change in speed is expected. Not tested: the Docker flag, and AMD or Intel cards with roles. Same work: strata launch kept replacing the card you picked at install ("gpu": 1) with its own pick of GPU 0, which is fixed; the engine log's "GPU 0 / CUDA0" for the first card it is given is now explained by one line from the server; an old AMD hip_ordinal no longer overrules the card you name now; and a card list such as [1, 0] is passed to the image generator as 1,0.
• Gyro runs on Intel Arc (Linux, tested on an Arc A750 only). The SYCL engine has the trellis kernels (TQ2_T, TQK6, TQK7) and the Hadamard rotation, so Gyro-S and Gyro-M load and answer on an Arc card. Setup lists them like for any card, warns and never refuses when VRAM and RAM together are short, and keeps Gyro's n-gram table on the SSD. On the A750 (8 GB, Ryzen 5 5600X, 62 GB of RAM) Gyro-S reads a 1,406-token prompt at 82 tok/s (40 before the matrix-unit launch took the trellis types, 5 of 5 pairs faster), a 20,000-token prompt at 195 tok/s, and writes 15.8 tok/s with the MTP draft. The card holds 410 of 24,576 experts, so the CPU and the PCIe link carry the decode; for these packs the engine gives the link a larger share (0.48 instead of 0.29, +16% decode, 5 of 5 pairs). On real tensors of both files the kernels equal a host replay of their own arithmetic in every bit, and 7 of 10 test prompts give the same 48 tokens as the CUDA engine (the other three agree for 5 to 9 tokens and then differ at a near tie; first-token KL 1e-4 to 1e-2, top-1 always the same). Details: GYRO.md.
• A model that is slightly too big gets smaller settings by itself. When a card is short by a little, setup and strata launch now try a 32K, 16K and 8K context, a smaller prompt chunk and a smaller reserve, in that order, and keep anything you chose yourself. Gyro-M on the 8 GB A750 used to stop with no room for a single cached expert; it now starts with a 16K context, reserve 100 and --prefill 1024 (the estimate was 300 expert slots and the engine got 309), and it answered correctly (Canberra, 391) at 16.6 tok/s. A model that fits keeps its settings. The check is wired into the Intel Arc setup and the Terminal's launch; the app's own fit check is not changed.
• Gyro-S and Gyro-M run on Apple Silicon Macs. The Metal engine now has kernels for agentionai's trellis experts (TQ2_T, TQK6, TQK7) and the Hadamard rotation they need, in the decode window and in both prompt paths, and reads the published files unchanged. Setup, the app and strata launch list Gyro on a Mac next to the other sizes, never as the default. Gyro-S is 58.5 GB on disk, of which 28.8 GB is the n-gram table that is read from the SSD; its weights need about 38 GB to stay in memory, so a 48 GB Mac holds it and a 32 GB Mac streams the experts. Measured on a Mac mini M4 with 32 GB: 9.1 tok/s decode (5 interleaved pairs) and 109 tok/s on a 4K prompt. The Gyro-specific dense-weight tiles gave +5% decode over the generic ones (5 of 5 pairs, same tokens). Checked: the decoder equals the format's definition bit for bit on the real tensors, the rotation equals the CPU's bit for bit, and the expert kernels match a double-precision reference to 1e-7 on real experts of Gyro-S and of Gyro-M (read by range requests, since it does not fit this Mac). KL against the CUDA engine on the same file (4,995 positions of the quant-quality set, mean KL / top-1): Mac against CUDA GPU experts 0.0207 / 95.5%, Mac against CUDA CPU experts 0.0187 / 95.4%, and the two CUDA runs against each other 0.0186 / 95.8%: the Mac sits at the CUDA engine's own noise level. Not measured: Gyro-M end to end, a Mac with 48 GB or more, and the experts' streaming copy for Gyro (it needs 26 GB more disk than the test Mac had). It needs the 0.2.2 Mac engine; an older one refuses the file when it loads, and setup says so.
• Gyro decodes faster on NVIDIA cards. The gate/up and down kernels for agentionai's trellis experts now keep the codebook in shared memory and take four rows per warp. On an RTX 3060 (12 GB) Gyro-S went from 54.3 to 62.5 tokens per second (+15%) and Gyro-M from 50.2 to 54.8 (+9%), 5 interleaved pairs each, faster in all of them; prompts are unchanged. The answers are bit for bit the old ones (identity gate on Gyro-S, Gyro-M, Q2_0 and IQ3_XXS), and Q2_0 and IQ3_XXS are not touched. Gyro-S is now about 7% and Gyro-M about 16% behind Q2_0 on that card (16% and 23% before); STRATA_IQ_STAGE_GRID=0 goes back to the old lookup. Cards of other generations were not measured.
• An engine package for the RX 6000 series (built, not tested on a real RX 6000 card). Linux has rx6000 and Windows has rdna2, each with GPU code for gfx1030 and gfx1031 (RX 6800, 6900 and 6950 series, RX 6700 XT). They are offered to a PC whose card reports one of those two and to no other: the RX 7000, RX 9000 and Strix Halo packages are unchanged, and a PC with an RX 7000 or 9000 card next to an RX 6000 card keeps the package it had. The engine runs plain kernels on these cards (RDNA2 has no matrix cores) and plain hipBLAS (hipBLASLt ships no kernels for gfx1030, so there is no tuning table). Setup and the app say once that this package was built and not tested on a real RX 6000 card. What was checked: the Linux package builds, every program in it has code for exactly gfx1030 and gfx1031, the rocBLAS kernel files for both are in it, every library it imports is in the package or belongs to the system, strata --version runs, and the whole engine (all targets, tests included) compiles for both. What was not: a model on an RX 6000 card, on either system, and the Windows package itself (the Windows build scripts take the new architecture list, but no Windows rdna2 package has been built). Earlier reports on these cards came from people who built the engine from source (docs/AMD_HIP.md). If something goes wrong, open an issue with the end of strata-<model>.log.
• The CPU expert pool splits per NUMA node on a machine with two NUMA nodes (from the branch behind #3201, not tested on a two-socket machine). Until now the pool kept its workers on the host thread's socket, because workers on the other socket read the experts across the link and were slower. The split gives each socket its own slice of the pool with its own task counter, and places each socket's half of every CPU-side expert in that socket's memory, so a slice reads local memory only. The reporter measured 59.3 against 54.05 tok/s (+9.7%, and +14% and +11.5% in two earlier sessions) on a dual Xeon Gold 6226 with the IOMMU in passthrough. It starts by itself on Linux when the machine has two NUMA nodes with CPUs and runs only when it can (pinned threads, enough free memory per node); otherwise the pool is exactly what it was and the log says why. A machine with one NUMA node runs the same code path as 0.2.1: on an RTX 3060 PC with one node the identity gate (10 prompts, exact prompt checks at 4K and 20K) was identical for IQ3_XXS and Q2_0, and the speed A/B (5 pairs, with a run of the same binary against itself as the noise measure) showed no slowdown. STRATA_NUMA_POOL=0 turns the split off; STRATA_NUMA_SPLIT=1 still asks for it. The start-up log says what it did: NUMA pool on: 2 NUMA nodes found ... or NUMA pool off: <reason>. On Windows the node count is read but the split itself is Linux-only for now. The logic runs in unit tests on made-up two-, three- and four-node machines; we have no two-socket machine, so the placement and the speed on real ones are the reporter's numbers, not ours. Do not wrap the server in numactl --cpunodebind or --membind: it pulls both halves onto one node. Please send the start-up lines and a decode run with and without STRATA_NUMA_POOL=0 from a two-socket machine.
• The API key is optional. The server, strata launch, the Terminal and the app no longer refuse to share without a key. Say so (--no-api-key, or "api_key": "none" in the server config) and it starts, with one plain warning that anyone who can reach the port can use the model and its tools; a public Cloudflare address gets a stronger one. The Terminal and the app still offer to make a key and do by default. In the app, Remove key now also works while local sharing or the tunnel runs. Fixes the refusals reported in #3198 and #3401. The Terminal part is already in 0.2.1.3.
• Your own GGUF files load again. "Use a local GGUF", strata launch --model-path and strata models import now accept what setup.py --gguf-dir always accepted: a folder with the files, the folder above it (a whole Hugging Face download, or an old Strata data folder), or one .gguf file. Unsloth sets whose first file holds no tensors, linked files (Hugging Face cache, Ollama) and folders with several sizes work; when a file is unusable, the message names the file and says why. Setup no longer deletes your own file when its checksum differs. The download and prepare steps use plain words, the checksum pass shows its own progress instead of a stuck 99% download bar, the bar no longer jumps to 99% when the last pieces of a parallel download arrive first, and a model folder you pick (a whole drive becomes D:\Strata) is accepted by the installer whatever it is called. Reports #3316, #3292, #3190. The Terminal part is already in 0.2.1.3.
• One models folder for the app and the Terminal. Each of the two settings files now remembers when the models folder was chosen; the one changed last wins and the other follows. Nothing is moved. A folder picked in the Terminal was not seen by the app before, so the same model could be downloaded twice.
• Change the models folder in Settings > Storage. A card shows the folder and offers three choices: move the models there, keep them where they are, or start empty (the old models' settings go to old-models inside the install folder, the files stay). A move copies each file to a .part name, compares its size and SHA-256 with the source, renames it and only then removes the original; on the same drive it renames, and hard-linked pack files are linked, not copied twice. Stop leaves the files already moved in place and points the settings at them. strata models move NEW does the same in the Terminal. If a move is interrupted, the card says so and offers "Finish the move" or "Leave it" (strata models move --status, --resume, --leave; strata launch prints one line while a move is unfinished). Checked in a real host with 4.3 GB of test files and in 19 tests; the interrupted-move notice was checked by tests only, and its six texts in the other seven languages were written without a native review.
• Strix Halo with a card of its own on Linux (Ryzen AI MAX+ and, for example, a Radeon AI PRO R9700). This follows a report of screen freezes, crashes and "engine stopped" on that pair. We have no such machine, so none of it ran on one. Built-in Radeon graphics is no longer the last stage of a layer split (the last stage holds the head and the final check, so it set the pace), the picture reader leaves it for the card with its own memory, setup --gpus all leaves it out when two cards of their own exist, and the engine runs at nice +5 on Linux when the PC has such a chip (STRATA_ENGINE_NICE=N, 0 turns it off). PR #3484 (John-Pi) is in with its author: STRATA_PF_PAD now applies only where the padded product exists (gfx11), which stops the engine from exiting on its first prompt when a gfx1151 stage and a gfx1201 stage share a process; a second change skips the padded dequantisation on the gfx12 stage. On an integrated GPU the automatic expert cache is sized from the smaller of the GPU's free memory and MemAvailable minus max(8 GiB, 8% of RAM), because the GPU's memory is the RAM (STRATA_UMA_RESERVE_GIB=N, 0 is the old behaviour; --expert-cache N is untouched). The fit check counts such a chip's BIOS carve-out once beside the RAM, and setup says when a BIOS carve-out above 16 GB belongs to a Strix Halo that this run does not use. On an R9700 (Q2_0, fixed gate flags) the identity gate was identical (10 of 10 prompts, exact prompt checks at 4K and 20K) and STRATA_PF_PAD=1 STRATA_PF_GEMM=1 no longer exits. Not tested: a real Strix Halo plus R9700 on Linux, the unified-memory cache cap, and whether the freeze comes from the engine's queues; reading the code, the engine only opens compute queues. Details: STRIX_HALO.md.
• The CPU workers say where they run, and you can choose. The start-up line now lists the logical processors of the CPU workers (CPU workers on logical processors 2,4,...,30 (15 workers, one per physical core; host on 0)), and the threads have names (strata-pool-N, strata-host, strata-stage). --pool-cores, STRATA_POOL_CORES and "pool_cores" in the run config (strata launch --pool-cores) pin the workers to a list you give; it is experimental and off by default. The question behind it ("the threads only use C0 to C7") came from a Ryzen AI MAX+ 395: the pool was already pinned one worker per physical core there (logical 2, 4, ... 30; in a pool-only test 15 workers read 145.5 GB/s, 8 workers on real cores 94.4 and 8 workers on logical 1 to 8 67.2); what sat on the first 16 logical processors were the threads nobody pins, and pinning the CPU picture encoder made it 7 to 19 times slower on that PC, so it is unchanged. No default placement changed. Identity gate (fixed flags, 10 prompts, exact prompt checks at 4K and 20K) identical on a Xeon box with two RTX A4000 and on an RTX 3060 PC; speed A/B on the Xeon box, 5 pairs, decode 64.90 to 66.40 tok/s (x1.023, 3 of 5 pairs), prompt x0.998, inside the noise. strata launch used to drop the notices its flags produce; it shows them now. --aux-cpus auto was measured again and stays off by default (decode x1.022, 4 of 5 pairs, inside the noise).
• One speed number everywhere. Answer speed is every token the model produced (thinking, answer, tool calls; with MTP the kept tokens) divided by decode time. The chat footer, the monitor, the model API and the server console used different definitions: an agent turn read about 632 tok/s in 0.2.0-beta, then fell to the real 50 to 75 in 0.2.1, and some places divided by the whole request, which reads about half (three real requests: 47.8, 64.8 and 65.9 tok/s by decode time, 20.6, 29.0 and 31.5 over reading plus decode). The footer now shows the last reply's own speed, the popover has a "Prompt reading" row, and the console no longer prints a million tok/s for a one-token reply.
• strata bench run, first real runs. Run on two test PCs with the 0.2.1 release, it showed that the release archive carried no commit (every run was nonconforming), that the drive lookup failed on LVM, that the CUDA runtime was missing from the nvidia-smi 615 output, and that the engine log in the result was empty. All four are fixed, the protocol text now says 2 to 4 minutes for the required part (measured 2:22 and 3:22), and results get a Capped column for answers that stopped at the token limit (7 of 9 performance requests ran into the 512-token limit while still thinking). Package building refuses to make a distributable archive without a commit. The two first complete runs are in bench/results/2026-10-20-0.2.1-bench/.
• Tool calls from a model that writes the opener wrong. A model that opens a call as <=NAME>, <function:NAME> or <NAME> is read as <function=NAME> when NAME is a tool the request declared; a block that still does not read as a call is counted and one line is printed per request (#3441). A call for a tool the request did not declare stays text, before and after </think> (#3075). This changes one behaviour: a Chat Completions or /v1/messages request with no tools can no longer get tool_calls back. The Responses route is left as it was, because Codex's compaction request relies on it. Constrained decoding for calls (item 3 of #3441) is not done.
• After a NaN in a long prompt the request survives (#3465). When the logits turn non-finite in a prompt window, the retry now reads the whole prompt through the batched path (one line in the server window) instead of failing the request. We could not reproduce the NaN itself on a Tesla P100 with a Broadwell Xeon, an RTX 3060 and a Core Ultra with VNNI turned off (IQ2_XS, IQ3_XXS, IQ3_S, Q2_0, prompts up to 30K), so the cause is still open; the retry was tested with an injected non-finite window. The reporter's debug list is in the issue.
• The Linux CUDA 12 engine package has Pascal and Volta code again (#3503). The 0.2.1 package was built for sm_75, 86 and 89 only because the repo held no recipe for it. packaging/build_cuda_linux.sh builds it for sm_60, 61, 70, 75, 80, 86 and 89, the packager refuses a CUDA 12 package without sm_60, 61 and 70, and the source Dockerfile takes CUDA_IMAGE and CUDA_ARCHITECTURES. A package built with it ran an IQ2_XS model on a Tesla P100. The 0.2.2 packages are built with it.
• HIP queue priming stands aside on a restricted queue count (#3480). When GPU_MAX_HW_QUEUES is 1 or 2, the engine no longer opens its two priming queues and says so in one line (STRATA_HIP_QUEUE_PRIME=nn still forces them). It compiles for gfx1201; it was not measured on a gfx12 card.
• Docker. An old (0.1.x) volume with /data/models, /data/packs and /data/mtp is moved into /data/Strata-data by rename instead of being downloaded and packed again (it used to start a 75 GB download). A card without --gpus stops at once with the --gpus all hint instead of after minutes of setup. A missing or empty MODEL_PATH gets a plain message. Settings that name another image's component folder (a CUDA 12 image on a CUDA 13 volume) are made again, and an engine folder renamed by an update no longer ends in server_exited when pictures are on. The terminal stage of the image build no longer needs git (it failed with FileNotFoundError); the commit comes in as a build argument, and all five image flavors built. Tested on one RTX 3060 PC with CUDA 12 and CUDA 13 images; no AMD or Intel image and no Docker Desktop.
• Re-runs do not tune again. A tuning that found the standard settings already fastest counted as "not tuned", so strata launch, the TUI and the Docker entrypoint measured again at every start (20 minutes); it counts as tuned now. In the Terminal a first launch of an installed model took 521 s and the second 13 s on the test PC.
• Problems with the computer's own setup are repaired or explained, not refused. If the Windows runtime folder lists another account, Strata locks it down itself instead of stopping. A Documents folder that cannot be used (Controlled folder access, an offline OneDrive) falls back to the Strata home folder and Settings > Storage says so. A port that is taken or reserved gets one sentence with the next step. Local requests ignore a system proxy. File-in-use errors and a full disk say what happened. strata launch asks plain questions in a terminal that reports a tty late. strata update copes with a slow --version, a busy graphics card is not held against an engine, pre-release Control builds hand over correctly, and a wrong PC clock is named as the reason a feed or certificate looks bad. install.sh and install.ps1 give clearer messages (ARM, TLS 1.2, proxy credentials, no tar.exe). The Terminal parts are already in 0.2.1.3; the Documents fallback and the port handling are app parts.
• A stale update notice goes away. After a version change the app and the Terminal no longer keep showing an offer for a version you already have.
• Idle GPU time was measured, with no default change. On a two-card test PC decode leaves 47 to 49% of the card time idle (batch 51%, prompts 24 to 42%), on a one-card PC 5%. Overlap gave +0.3, +2.1 and -0.3% against 2.8% noise; pipeline windows 2 gained 5.4% on code only, cost 5 to 13% with the draft layer on the first card, and --batch-groups 2 cost 15.3% with 4 chats, so nothing is switched on. Raw numbers are in bench/results/2026-10-20-0.2.1-idle-gpu/.
• The recommended size leaves 5 GB for Windows. The memory tiers now count RAM + VRAM less 5 GB, so a PC with 32 GB of RAM and a 16 GB card gets the 40 GB tier instead of the 48 GB one, which had it reading part of the model from the SSD (#3425). Every other size is still a choice.

Faster, with what we measured

Speed numbers are medians of interleaved pairs on the same box, a fresh engine per run; "pairs faster" counts the pairs the new code won. Each change has an off switch.

• Gyro decodes faster on NVIDIA cards. The gate/up and down kernels for agentionai's trellis experts now keep the codebook in shared memory and take four rows per warp (8 lanes per row), on every CUDA card above Pascal. On an RTX 3060 (12 GB) Gyro-S went from 53.6 to 62.8 tokens per second (+17%, 4 of 5 pairs) and Gyro-M from 50.6 to 56.1 (+11%, 5 of 5), 5 interleaved pairs each; prompts are unchanged. The answers are bit for bit the old ones (identity gate on Gyro-S, Gyro-M, Q2_0 and IQ3_XXS, with the pinned Gyro files), and Q2_0 and IQ3_XXS are not touched. Against Q2_0 on that card Gyro-S is now about 6% and Gyro-M about 16% slower (18% and 24% before). STRATA_TQ_SUB8=0 goes back to the old rows, STRATA_IQ_STAGE_GRID=0 to the old lookup. Only the RTX 3060 was timed for this path.
• Gyro decodes about 30% faster on a Tesla P100 (compute capability 6.0). On a P100, Gyro-S ran at about 70% of the speed of the Q2_0 file of similar size: 30 / 36 / 33 tok/s against 41 / 51 / 48 (story / code / facts, median of 5 interleaved pairs, default flags). On compute capability 6.0 the engine now keeps the 4 KB trellis codebook in shared memory, reads the down rows as 8-lane rows, lets each block work on several row chunks, and copies the activations of an expert group to shared memory once per block. Gyro-S now decodes 38.5 / 45.6 / 42.7 tok/s (+30%; every one of 10 reps and 5 of 5 pairs faster), 0.96 / 0.90 / 0.91 of Q2_0. Prompt speed is unchanged: 4096 tokens take 14.0 s and 20000 tokens 62 s, 3 to 5% slower than Q2_0. Answers are the same: the identity gate (10 prompts, 4096- and 20000-token prompt dumps) is identical on the P100 and on an RTX 3060, and Q2_0 on the P100 did not change (0.999 / 0.998 / 1.001). The ready-made CUDA 13 packages have no code for this card; the CUDA 12 packages do. STRATA_TQ_STAGE=0 turns the path off. Two attempts to speed up the prompt (a faster dp4a in llama.cpp's MMQ kernels, which this card lacks, and a register-tiled MMQ dot) were slower and are not included.

Fixes from user reports

• Your own GGUF on the first run (#3507, #3424). "Use your own GGUF" on the first-run page opened the folder chooser for the Strata data folder, so your GGUF folder became the data folder and the installer downloaded into it again. It now opens the local GGUF page, and preparing your own files never uses their folder as the data folder.
• Loading stopped for good by a reused PID (#3488). A marker without a start time counted any later program with the same PID number as our engine, and every load stopped. Such a marker now only blocks for a Python or Strata program, and the engine hash check reads twice before it refuses, with the expected and found hash start in the message.
• Tuning (#3502, #3490). A CUDA initialisation failure in a tuning run is no longer recorded as out of memory by the memory-guard line, and a command that passed on the same PC, engine and model is no longer switched off for good by a later failure. Tuning gives up waiting for memory when none is being freed in a minute, instead of waiting ten minutes per candidate, and says how much is free and needed.
• Smaller fixes of the same round. A Recycle Bin path is found on Linux too, authored by TheHubUser4860938 (#3501); --control-vector-layer-range is written and removed as two entries and an empty Advanced value is no longer a bare flag (#3504); the recommendation says how much of the picked size would be read from the SSD when RAM and VRAM only just reach the tier's floor (#3425); UPDATE.bat and setup fetch the engine from the signed update feed when a release has no flat zip, and the minimum engine is 0.1.46 (#3469, #3437; not tested on a Windows AMD PC); on a card that shares the PC memory (Strix Halo) the Work profile no longer reserves a fifth of the shared pool as graphics memory (#3510).
• From the issues labelled needs-format. The app numbers Radeon cards the way HIP does when an integrated GPU is present (#3418). The hardware report counts physical cores, so the Work profile asks for 6 pool workers on an 8-core CPU instead of 12 (#3417; the reporter measured 27.9 against 38.1 tok/s). Three trellis CPU tests skip on a ggml without trellis types, and the ISA guard knows the AVX-512 files (#3358, tests and build only; the memory fault on gfx1011 is not fixed, we have no such card).
• Small fixes. --mtp 2 is no longer checked as a folder (#3298); owner-only checks understand Windows account aliases (#3302, thanks jackbapa); strata bench with its own server sets its port (#3188); calibrate checks the report folder first (#3187); the CUDA 12.0 and 12.1 build error __half_as_ushort (#3368, thanks yudhanjaya, compiled as a snippet with CUDA 12.6 only); the AMD picture reader builds position independent (#3359, not built here); the Mac setup installs cmake and ninja before it builds (#3403); the picture reader recreates its work folder if a temp cleaner removed it (#3370); a list of GPUs such as "0,1" is accepted (#3275, thanks MEsfits); thinking_budget_tokens is read (#2141) and the Anthropic usage numbers add up to the prompt (#2289, thanks xrip); an engine that cannot start is a 503 with the reason (#2496, thanks devYRPauli); the serve web page no longer scrolls sideways on a phone (#2971, thanks ctr-137; 752 px wide before at a 412 px screen, 412 px after); folders in a Trash or Recycle Bin are not offered as installs (#3410). Ported pull requests keep their authors. Most of these are already in 0.2.1.3.
• Speculative decoding. A rare hang of the first verify window on the HIP engine is fixed: about 1 run in 5 on a Strix Halo with IQ3_S stopped after the first window (8 of 41 runs without the fix, 0 of 46 with it). The cause was a GPU launch that waited for a flag the host raised only after the launch returned; on HIP the flag is now raised before the first launch of each graph (STRATA_VERIFY_EARLY_PLE_FLAG=1 or 0 forces either order; CUDA and SYCL keep their order). Decode speed with the fix is 47.89 against 47.78 tok/s (10 interleaved pairs). A one-token prompt with --spec on a native pack never started the speculative loop and decoded 0 tokens; it now decodes 24 tokens with the same ids as --spec 2. A STRATA_SPEC_WATCH=<seconds> watchdog reports a stalled loop with its stage.

Already in 0.2.1.1 to 0.2.1.4

These went out as Terminal, Control and engine updates before 0.2.2, so a Terminal user has them; the app gets them with 0.2.2. 0.2.1.1: the Windows engine install survives long paths. 0.2.1.2: on Windows, a Strix Halo (gfx1151) no longer registers the whole expert arena at start (the default start failed with "0 MiB free" and exited), and strata.exe --version finds its ROCm libraries without a PATH entry. 0.2.1.3 (Control 0.1.46.2): the Terminal parts of the API key, own GGUF, refusal, small-fix and update-notice items above, and strata launch --plan that names your files, says what would be downloaded and says "Nothing to download" when everything is there, a total download label that counts every shard, a plain sentence plus a "still working" line during packing, a stored tuning result that is reused (--retune measures again), an interrupted experts.bin write that continues at the next layer, and the hand-over: after strata update installs a newer Control, the Terminal runs it on the next command. Terminals older than 0.1.46.2 cannot hand over (the code is in the Terminal): reinstall the Terminal once. 0.2.1.4 (Control 0.1.46.3): a Windows PC with an RX 9000 card is no longer given the RX 7000 engine because its graphics chip could not be read (#3456, #3486; with an unknown chip and several HIP builds it asks for the variant, then goes by the GPU name, and never picks by version), and every ranged download answer is checked (206, Content-Range, length, ETag); a file with a wrong SHA-256 is repaired piece by piece instead of deleted. Real test: a 907 MB file through a relay that reset connections, flipped 3 bytes and was killed twice ended with "2 of 28 parts were different and have been written again" and the pinned SHA-256; the 0.2.1 downloader deleted the file on the same input. A 39.8 GB shard went through 64 resets and two kills and matched its SHA-256.

Known limits

• RX 6000 series: the rx6000 and rdna2 packages were built, not run on a card; the Windows rdna2 package has not been built.
• Two-socket PCs: the NUMA split was not run on one; the numbers are the reporter's.
• Gyro on a Mac: Gyro-M was not run end to end, and a Mac with 48 GB or more was not tried. Gyro on Intel Arc: a B-series card, two Arc cards (the second-card helper refuses a Gyro pack and says so) and the xe driver were not tried.
• Gyro on NVIDIA: only the RTX 3060 was timed for the new rows; the Tesla P100 path is separate.
• Strix Halo with a card of its own on Linux: none of the changes ran on that pair, and the cause of the screen freeze is not confirmed.
• GPU roles: the Docker flag and AMD or Intel cards were not tested; a CPU-only choice is allowed with a warning, and the CUDA, HIP and SYCL engines cannot start with it.
• HIP queue priming (#3480): not measured on a gfx12 card.
• Open reports we could not reproduce: #3465 (the NaN itself), #3489 (a driver fault at a 6400-token chunk: two Linux boxes read a 177K-token prompt cleanly, so the reporter's logs are needed), #3297 and #3443 (gfx1201 stalls under memory pressure, not run).
• Not fixed: the vmm_test memory fault on gfx1011 (#3358), the Slot-to-pool copy speed (#3321, the reporter has a patch), an NVFP4 token soup on a CPU without AVX-512 (#3328).
• Package against source speed, #3252: not reproduced. On the same commit, a Linux CUDA 12 and CUDA 13 package matched a setup-style source build within 1% in decode and in 4K and 20K prompts on an RTX A4000 PC and an RTX 3060 PC (5 pairs each). The one difference left is that the packages build ggml's CPU part for a generic AVX2 CPU; we have no AVX-512 plus NVIDIA machine on Windows to test that.
• Docker: no AMD or Intel image was built or run, and no Docker Desktop.

Thanks to baptisterajaut, whose NUMA-split branch the pool is built on; to John-Pi (PR #3484), MEsfits (#3276), xrip (#2140, #2290), devYRPauli (#2497), ctr-137 (#3156), yudhanjaya (#3374), jackbapa (#3302) and TheHubUser4860938 (#3501), whose fixes are in with their names; and to agentionai, whose Gyro work all three Gyro ports build on.

---

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