0.1.45-poly.1

The Strata project's 0.1.45 is in: Qwen3.6 on Strata's engine reads pictures and answers several requests at once, and a model switch in the web app now runs the new model with its own settings.

What changed since 0.1.44.1-poly.6

• The Strata project's 0.1.45 is merged. Qwen3.8-Flash-Next, which runs on Strata's own engine, takes everything in it, from the faster decode kernels to the opt-in switches for servers with many users. Qwen3.6 on Strata's engine (--family qwen36-strata) now reads pictures (--vision) and answers several requests at once (--parallel), with faster decode kernels (docs/QWEN36.md).
• For every model, two things from 0.1.45's server: a long chat's prompt is encoded again only from where it differs from the last one, and when a request allows 1,024 tokens or more and sets no thinking budget, thinking is closed early enough to leave a quarter of max_tokens for the answer. "answer_room": false in strata-<model>.json turns the second one off. Strata's server also gives Qwen3.8-Flash-Next its model card's sampling when a request names none; the models on strata-poly keep their own defaults.
• A model switch in the web app runs the new model with its own strata-<model>.json: before, every key but the sampling, the aliases and the GPU stayed as the first model set them, and Ctrl+C after a switch closed the wrong engine. By arbitropy (PR 39, issue 37).
• AMD cards on Linux: the expert cache gives VRAM back to other programs and grows again when they free it, instead of only shrinking until a restart (PR 28, issue 13), and --kv q8_0 runs on AMD cards (PR 29). Both by donschen, measured on an RX 9070 XT.
• STRATA_FREEZE_EXPERTS=1 holds the split of the experts between the card and the CPU still, so the same request gives the same greedy answer bit for bit; with guesses on, add --window 1 for that everywhere (PR 32). The load now writes VRAM on the engine's own stream (PR 31). Both by smashdog; Tako88 checked the first on an AMD card.
• docs/DEEPSEEK.md: what a user measured with DeepSeek V4 Flash files larger than the RAM (issue 21).

The engine's shared kernels changed with the merge, so the zip below is a new ready-made Windows engine; the installer downloads it and checks its SHA-256. It gives the same greedy tokens as 0.1.44.1-poly.6's engine on an RTX 5090 with GLM 5.3 Flash, DeepSeek V4 Flash, Qwen3.6, LFM2.5 and MiniCPM-V, and on an RTX 4070 laptop with Gemma 4, and several requests at once still give each the tokens it gets alone.

Install

Download the source below, or git clone the repository. Then run START-HERE.bat on Windows or ./setup.sh on Linux. An earlier install updates with UPDATE.bat or ./update.sh.

Limits

• The eight added models are experimental.
• The ready-made engine is for Windows and CUDA 13 only; CUDA 12 and AMD cards compile on your PC.
• GLM 5.3 Flash and DeepSeek V4 Flash need 70 to 100 GB of RAM, and about 8 GB more than their files in a container. A DeepSeek file larger than the RAM runs several times slower than llama.cpp with the same file.
• AMD cards on Windows run Qwen3.8-Flash-Next only.

Most of this project is the work of Strata's author and contributors.

0.1.44.1-poly.6

The eight added models answer several requests at once, and DeepSeek V4 Flash's MXFP4 experts run on the card without a converted copy in RAM.

What changed since 0.1.44.1-poly.5

• "parallel": N in strata-<model>.json, or --parallel N when you run setup, now works for GLM 5.3 Flash, DeepSeek V4 Flash, LFM2.5, Qwen3.6, Ornith 1.5, Gemma 4, Tiel Coder and MiniCPM-V, up to 8 (issue 22). Before, strata-poly answered one request at a time and the server queued the rest. The server drives it as it drives the Strata project's engine: a request alone writes with guesses as before, and when a second comes the two write together in batch slots, each with its own position, recurrent state and attention rows, while the weights and the experts they share are read once for both. A long prompt being read gives way to the slots between its pieces, so a chat does not stall while someone else pastes a long document. On an RTX 5090 with Qwen3.6 UD-Q4_K_M, four 300-token chats at once came at 428 to 430 tokens/s in all, where one alone writes at 312 to 333. On an 8 GB laptop, where most experts run on the CPU, three Qwen3.6 UD-Q3_K_M chats at once came at 105 tokens/s together and at 79 one after the other. With the expert cache fixed and no guesses, each answer is the one it would get alone: strata-poly --check-batch compares them token by token, every token matched for all five architectures, and three chats through the server gave the same text at once as alone. With the default settings two runs of a chat already differ after a few dozen words, together or alone. How it works and how to check it: docs/BATCHING.md.
• DeepSeek V4 Flash's MXFP4 experts are multiplied on the card now. Before, the engine converted the four MXFP4 layers' down experts to Q5_0 at load, into RAM that cannot be paged back to the file: 6 GB with UD-IQ2_XXS, 1.38 GiB a layer with UD-IQ4_XS, which mattered on a PC whose RAM is smaller than the file. On the 5090 the engine's own RAM went from 5,959 MiB to 341 with UD-IQ2_XXS, a 24K-token prompt read at 1,091 tokens/s where 1,000 before, and writing speed is the same. On RTX 50 cards llama.cpp's FP4 tiles quantize the prompt's rows to FP4, as llama.cpp does, so greedy text can differ from 0.1.44.1-poly.5 after a few tokens.
• The README's speed chart has all eight added models, and there is an issue form for model requests.

The engine changed, so the zip below is a new ready-made Windows engine; the installer downloads it and checks its SHA-256.

Install

Download the source below, or git clone the repository. Then run START-HERE.bat on Windows or ./setup.sh on Linux. An earlier install updates with UPDATE.bat or ./update.sh, and START-HERE.bat --setup --parallel 3 turns on three requests at once.

Limits

• The eight added models are experimental.
• Requests in batch slots write without guesses, and --batch-groups and the other batching options of the Strata project's engine are not there yet.
• The ready-made engine is for Windows and CUDA 13 only; CUDA 12 and AMD cards compile on your PC.
• GLM 5.3 Flash and DeepSeek V4 Flash need 70 to 100 GB of RAM, and about 8 GB more than their files in a container.
• AMD cards on Windows run Qwen3.8-Flash-Next only.

Most of this project is the work of Strata's author and contributors.

0.1.44.1-poly.5

MiniCPM-V 4.7 35B-A3B reads pictures on PolyStrata, the Qwen3.6 family can keep its attention cache in 8 bits, and a model can keep the thinking of earlier turns.

What changed since 0.1.44.1-poly.4

• MiniCPM-V 4.7 35B-A3B by OpenBMB is the ninth model, brought in by iMilnb (PR 20): ./setup.sh --family minicpmv installs one of three sizes, Q4_K_M, mix_q3gud_im or Q6_K (16 to 29 GB). It has Qwen3.6-35B-A3B's architecture and its own weights, made to read pictures. A large picture is read as an overview and a few tiles, and on four test pictures, from a 64x64 icon to a 2520x1620 chart, it read the same numbers and labels as llama.cpp's own llama-mtmd-cli. Its file has no draft block, so it writes one token at a time: with Q4_K_M an RTX 4070 laptop (8 GB) writes a short chat at 64 tokens/s and reads a 32K-token prompt at 1,150; an RTX 5090 writes at 308 to 311 and reads at 7,910 to 7,950. Its license is Apache 2.0.
• --kv q8_0 for Qwen3.6, Ornith, Tiel Coder and MiniCPM-V, by vpkoskinen (PR 23): the attention cache in ggml's Q8_0 blocks, about half its VRAM, which the expert cache can use at long contexts. It is off unless you add it to the run config's args; without it the engine gives the same text as before. On the 5090 it wrote 2% to 6% slower after an 8K prompt; on the 8 GB laptop there was no difference to measure.
• "preserve_thinking": true in strata-<model>.json, or "chat_template_kwargs": {"preserve_thinking": true} in a request (issue 25): Qwen3.6's template, which Ornith and Tiel Coder share, then keeps the thinking of earlier turns in the prompt instead of dropping it, and the server remembers the thinking of the answers it wrote, so it works with apps that send an answer back without it (the chat page, Open WebUI, VS Code's Copilot). In a test where the model thinks of two 20-digit numbers and says one, with the app dropping the thinking, it gave the other exactly when asked later, and made one up without the setting.
• The picture encoder builds from llama.cpp 69f201a, which MiniCPM-V needs; the two engines stay on the Strata project's 3cf03257.

The engine and the picture encoder changed, so the zip below is a new ready-made Windows engine; the installer downloads it and checks its SHA-256.

How fast

The README has MiniCPM-V's tables for both PCs, next to the other models'.

Install

Download the source below, or git clone the repository. Then run START-HERE.bat on Windows or ./setup.sh on Linux. An earlier install updates with UPDATE.bat or ./update.sh, and START-HERE.bat --setup --family minicpmv adds MiniCPM-V.

Limits

• The eight added models are experimental.
• The ready-made engine is for Windows and CUDA 13 only; CUDA 12 and AMD cards compile on your PC.
• --kv q8_0 is for the qwen35moe models only; the others refuse it at start. It has not been tried on an AMD card, where the engine refuses it.
• GLM 5.3 Flash and DeepSeek V4 Flash need 70 to 100 GB of RAM, and about 8 GB more than their files in a container.
• AMD cards on Windows run Qwen3.8-Flash-Next only.

Most of this project is the work of Strata's author and contributors.

0.1.44.1-poly.4

strata-poly gives the expert cache back the VRAM a long request took, and the server can drop a chat's oldest turns when it no longer fits.

What changed since 0.1.44.1-poly.3

• The expert cache gets its VRAM back after a long request. The attention caches grow as a conversation does, and until now they kept that VRAM for as long as the server ran, so every request after one long read had fewer experts on the card. Now the rows that neither the current request nor the one before it reaches go back to the expert cache. GLM 5.3 Flash on an RTX 5090 with 8 GB kept free, after a 287K-token request: the requests after it wrote at 64 to 65 tokens/s before and 70 to 71 now, with 1,631 experts in VRAM instead of 1,192. A context set to 1M that is not filled costs nothing either way: GLM starts with 1,684 experts at 32K and 1,672 at 1M (issue 10).
• "drop_oldest": true in strata-<model>.json (off by default): when a chat no longer fits the context, the server leaves out its oldest turns until there is room for the answer, instead of refusing the request. The system prompt and the last message stay (issue 17, FAQ).
• DeepSeek V4 Flash runs on Windows, by a user's report: UD-IQ2_XXS on an RTX 5090 D v2 (24 GB) with 128 GB of RAM, 29 to 36 tokens/s, and a filled 1M context read with every planted fact found (issue 21).

The engine changed, so the zip below is a new ready-made Windows engine; the installer downloads it and checks its SHA-256.

Install

Download the source below, or git clone the repository. Then run START-HERE.bat on Windows or ./setup.sh on Linux. An earlier install updates with UPDATE.bat or ./update.sh.

Limits

• The seven added models are experimental.
• The ready-made engine is for Windows and CUDA 13 only; CUDA 12 and AMD cards compile on your PC.
• GLM 5.3 Flash and DeepSeek V4 Flash need 70 to 100 GB of RAM, and about 8 GB more than their files in a container.
• AMD cards on Windows run Qwen3.8-Flash-Next only.

Most of this project is the work of Strata's author and contributors.

0.1.44.1-poly.3

LFM2.5-24B-A2B runs on PolyStrata, and strata-poly reads long prompts faster on a card that holds the model.

What changed since 0.1.44.1-poly.2

• LFM2.5-24B-A2B is the eighth model: ./setup.sh --family lfm25 installs one of five sizes on strata-poly, Unsloth's UD-Q4_K_XL, UD-Q3_K_XL, UD-Q6_K_XL and Q8_0 or Liquid AI's QAD-Q4_0 (11 to 25 GB). Most of its 40 layers have no attention, so a long conversation takes little VRAM: a 128K context takes 2 GB more than 32K. With UD-Q4_K_XL an RTX 4070 laptop (8 GB) writes a short chat at 70 to 73 tokens/s and reads a 30K-token prompt at 3,590 to 3,620 tokens/s; llama.cpp, tuned on the same laptop, read a 32K prompt at 530 and wrote after it at 53. An RTX 5090 reads the 30K prompt at 23,400 tokens/s, as fast as llama.cpp with a batch of 2,048, and after it writes one token at a time at 388 tokens/s where llama.cpp writes at 369. A 124K-token prompt in a 128K context was read and answered in 8.7 s on the 5090, and read in 45 s on the laptop. Windows or Linux, one NVIDIA card. Its license, the LFM Open License v1.0, allows commercial use only to companies with less than 10 million dollars of yearly revenue. More in docs/LFM.md.
• Faster prompt reading on a card that holds every expert: a prompt batch runs its cached experts in three launches a layer instead of nine. Qwen3.6 UD-Q2_K_XL on an RTX 5090 reads a 30K prompt in 3.7 s instead of 3.9 to 4.0, a 2K prompt in 333 to 338 ms instead of 371 to 376. Setup now reads prompts 2,048 tokens at a time where the card holds every expert of LFM2.5 or Qwen3.6 beside the larger batch, and for LFM2.5 on any card from 8 GB. The products with few outputs (routers, a gate a head) read their next inputs while they work, with the same bits: Qwen3.6's took 82 ms of a 7.7K read instead of 126. GLM 5.3 Flash, which copies half its experts as it reads, reads as fast as before.
• Faster writing on a card that holds every expert: a few tokens' experts are routed on the card, and a token's layers run as one recorded launch. On the 5090, one token at a time, Qwen3.6 UD-Q2_K_XL writes at 294 tokens/s instead of 279 and Gemma 4 UD-Q2_K_XL at 254 instead of 245.
• The server reads LFM2.5's tool calls, a Python list between two tokens, for the OpenAI and Anthropic APIs, and its chat template.

The engine changed, so the zip below is a new ready-made Windows engine; the installer downloads it and checks its SHA-256.

How fast

The README has the tables, now with LFM2.5-24B-A2B ahead of Qwen3.6, and Qwen3.6's, Ornith's and Gemma 4's workstation numbers measured again; docs/LFM.md and docs/BACKENDS.md have the runs.

Install

Download the source below, or git clone the repository. Then run START-HERE.bat on Windows or ./setup.sh on Linux. An earlier install updates with UPDATE.bat or ./update.sh.

Limits

• The seven added models are experimental. LFM2.5 has run on an 8 GB laptop and a 32 GB card, and not on an AMD card.
• The ready-made engine is for Windows and CUDA 13 only; CUDA 12 and AMD cards compile on your PC.
• GLM 5.3 Flash and DeepSeek V4 Flash need 70 to 100 GB of RAM, and about 8 GB more than their files in a container.
• AMD cards on Windows run Qwen3.8-Flash-Next only.

Most of this project is the work of Strata's author and contributors.

0.1.44.1-poly.2

DeepSeek V4 Flash runs on PolyStrata, and prompts are read faster on a card that holds the model.

What changed since 0.1.44.1-poly.1

• DeepSeek V4 Flash is the seventh model: ./setup.sh --family deepseek installs Unsloth's UD-IQ2_XXS (three files, 91 GB) on strata-poly, the engine GLM 5.3 Flash runs on. On an RTX 5090 with 120 GB of RAM it writes a short chat at 56 tokens/s and reads a 30K-token prompt at 1,040 tokens/s; llama.cpp on the same PC wrote 25 to 28 tokens/s and read a 3K prompt at 96. Its cache keeps 6,880 bytes a token, so long contexts fit beside the experts: a 487,529-token prompt in a 512K context was read and answered in 32 minutes, with the three facts hidden in it found. Its greedy tokens match llama.cpp's up to near ties. Linux and one NVIDIA card for now, about 72 GB of RAM beside a 32 GB card. More in docs/DEEPSEEK.md.
• Faster prompt reading for every model of strata-poly: a prompt batch now routes its tokens on the card instead of the CPU, computes products with few outputs without cuBLAS, and runs the causal convolutions of all its tokens at once. Tiel Coder on an RTX 5090 reads a 32K prompt at 7,520 to 8,110 tokens/s instead of 6,090 to 6,870, and Qwen3.6 UD-Q4_K_XL a 4K prompt at 8,100 to 8,400 instead of 5,582. Where most experts stay in RAM (an 8 GB laptop) the copy of the experts to the card still sets the pace, so the change there is small: Gemma 4 reads a 2K prompt at 1,290 tokens/s instead of 1,084. Writing speed did not change.
• Experts stored as MXFP4, which no kernel here runs on the card, are converted at load to Q5_0, which holds the same values exactly; DeepSeek's file has two such layers.
• The tokenizer gives control tokens as their text, as llama.cpp does, and the server reads DeepSeek's DSML tool calls.

The engine changed, so the zip below is a new ready-made Windows engine; the installer downloads it and checks its SHA-256.

How fast

The README has the tables, now with DeepSeek V4 Flash and Tiel Coder's new workstation numbers; docs/BACKENDS.md has the runs.

Install

Download the source below, or git clone the repository. Then run START-HERE.bat on Windows or ./setup.sh on Linux. An earlier install updates with UPDATE.bat or ./update.sh.

Limits

• The six added models are experimental. DeepSeek V4 Flash has run on one machine, with a 32 GB card and 120 GB of RAM.
• The ready-made engine is for Windows and CUDA 13 only; CUDA 12 and AMD cards compile on your PC.
• GLM 5.3 Flash and DeepSeek V4 Flash need 70 to 100 GB of RAM, and about 8 GB more than their files in a container.
• AMD cards on Windows run Qwen3.8-Flash-Next only.

Most of this project is the work of Strata's author and contributors.

0.1.44.1-poly.1

Strata's 0.1.44 and 0.1.44.1 are in, and Qwen3.6 can now run on either engine.

What changed since 0.1.43.1-poly.2

• The Strata project's 0.1.44 and 0.1.44.1 are merged (0.1.44, 0.1.44.1). Qwen3.8-Flash-Next, which runs on Strata's own engine, takes everything in them: Unsloth's UD-Q4_K_XL to Q8_0 files and the NVFP4 packs in setup, the faster AMD and Arc paths, and the fixes. For the five added models what reaches you is the server and setup: a literal <tool_call> or <tool_response> in a message is text, a picture in a long conversation keeps the cached state, the Responses API (Codex) follows the config's reasoning_effort, and running setup again keeps the size you installed.
• Strata's 0.1.44 runs Qwen3.6-35B-A3B on an engine of its own. Setup now has both: --family qwen36 is Qwen3.6 on strata-poly, as before, with the small sizes for 8 GB cards, and --family qwen36-strata is Qwen3.6 on Strata's engine, UD-Q4_K_XL and up with 32 GB of RAM or more. Strata's engine refuses files with Q3_K experts, which Qwen3.6's UD-Q2_K_XL and UD-Q3_K_M and every Tiel Coder size have, so those stay on strata-poly.
• Both engines on the same UD-Q4_K_XL file on an RTX 5090: strata-poly writes faster with every expert on the card (400 against 379 tokens/s), Strata's engine writes faster with 3 GiB of experts (196-201 against 180-183) and reads a 4K prompt 1.6 times as fast; at 31K the two read about as fast. The table is in docs/BACKENDS.md.

The engine's shared CUDA kernels changed with the merge, so the zip below is a new ready-made Windows engine; the installer downloads it and checks its SHA-256. On an RTX 5090 it gives the same tokens as 0.1.43.1-poly.2's on Tiel Coder and GLM 5.3 Flash, at the same speed.

How fast

The tables did not change: 0.1.42-poly.3, the README and docs/BACKENDS.md.

Install

Download the source below, or git clone the repository. Then run START-HERE.bat on Windows or ./setup.sh on Linux. An earlier install updates with UPDATE.bat or ./update.sh.

Limits

• The five added models are experimental, measured on two machines, a pair of RTX 3080s and one RX 7600.
• The ready-made engine is for Windows and CUDA 13 only; CUDA 12 and AMD cards compile on your PC.
• GLM 5.3 Flash needs about 100 GB of RAM, and about 8 GB more than its file in a container.
• AMD cards on Windows run Qwen3.8-Flash-Next only.

Most of this project is the work of Strata's author and contributors.

PolyStrata 0.1.43.1-poly.2

A fix for the draft block after a prompt read, from a contributor.

What changed since 0.1.43.1-poly.1

• The draft block's guesses after a prompt read could change from run to run: the engine handed the block its rows call after call without waiting for the card, so the next call could overwrite the pinned rows while the previous call's upload still read them (#15, NenadSteric, who found it with GLM 5.3 Flash on RTX 3090s and wrote the test for it). The engine now waits for that upload before it refills the rows. Checked on an RTX 5090: before the fix one of four runs gave other guesses, after it none of five; the greedy tokens of Qwen3.6 and GLM are the same as before, at the same speed.
• poly_draft_race_test (built with the engine, run by hand with a model file) checks that a read in several calls repeats bit for bit.

The engine's sources changed, so the zip below is a new ready-made Windows engine; the installer downloads it and checks its SHA-256.

How fast

The tables did not change: 0.1.42-poly.3, the README and docs/BACKENDS.md.

Install

Download the source below, or git clone the repository. Then run START-HERE.bat on Windows or ./setup.sh on Linux. An earlier install updates with UPDATE.bat or ./update.sh.

Limits

• The five added models are experimental, measured on two machines, a pair of RTX 3080s and one RX 7600.
• The ready-made engine is for Windows and CUDA 13 only; CUDA 12 and AMD cards compile on your PC.
• GLM 5.3 Flash needs about 100 GB of RAM, and about 8 GB more than its file in a container.
• AMD cards on Windows run Qwen3.8-Flash-Next only.

Most of this project is the work of Strata's author and contributors.

PolyStrata 0.1.43.1-poly.1

Strata's 0.1.43 and 0.1.43.1 are in, and AMD cards keep their attention caches whole.

What changed since 0.1.42-poly.4

• The Strata project's 0.1.43 and 0.1.43.1 are merged (their notes). Qwen3.8-Flash-Next, which runs on Strata's own engine, takes everything in them. For the five added models what reaches you is the server and the tools: a request's pictures are encoded on the engine's turn and a client that leaves meanwhile is let go at once; a tool call the model writes as fenced JSON inside its tags is read; a user message that quotes </tool_call> is text; a refused batch slot gets another one or a 503 instead of a broken conversation; a failed before_load hook checks the free VRAM; POST /unload?wait=1; timings.prompt_n counts what the engine read. New: BENCH.bat (./bench.sh) measures your install through the API in 5 to 10 minutes and writes a report in the community format; it read CMakeLists.txt in the Windows code page, which stopped it on a Chinese or Japanese Windows, fixed here.
• On an AMD card the attention caches take their VRAM at load: setup writes --kv-whole into the config and adds it to an older one on update. ROCm keeps the VRAM the expert cache gives back as a conversation grows, so a long prompt was refused with "no VRAM for the attention cache" (#13, iMilnb, who found the cause). With the caches whole, 32K of context fits on an RX 7600 with 8 GB beside 4,592 of Qwen3.6's experts. His benchmark on that card is in docs/AMD_HIP.md and the community table: Qwen3.6 UD-Q2_K_XL 74 tokens/s in a short chat, 53 after a 32K prompt read at 481; Ornith APEX-I-Mini 40 and 43, read at 444.
• The experts on the card and on the CPU do not give the same greedy tokens, on CUDA as on HIP: the two sum in a different order and a near tie goes the other way after some tens of tokens. Measured on an RTX 5090 and written next to his finding.

The engine's shared CUDA kernels changed with the merge, so the zip below is a new ready-made Windows engine; the installer downloads it and checks its SHA-256. On an RTX 5090 it gives the same tokens as 0.1.42-poly.4's on Qwen3.6 and GLM 5.3 Flash, at the same speed.

How fast

The tables did not change: 0.1.42-poly.3, the README and docs/BACKENDS.md.

Install

Download the source below, or git clone the repository. Then run START-HERE.bat on Windows or ./setup.sh on Linux. An earlier install updates with UPDATE.bat or ./update.sh.

Limits

• The five added models are experimental, measured on two machines, a pair of RTX 3080s and one RX 7600.
• The ready-made engine is for Windows and CUDA 13 only; CUDA 12 and AMD cards compile on your PC.
• GLM 5.3 Flash needs about 100 GB of RAM, and about 8 GB more than its file in a container.
• AMD cards on Windows run Qwen3.8-Flash-Next only.

Most of this project is the work of Strata's author and contributors.

PolyStrata 0.1.42-poly.4

AMD cards run the smaller models under Linux, as a beta.

What changed since 0.1.42-poly.3

• The engine of Qwen3.6, Ornith 1.5, Gemma 4, Tiel Coder and GLM 5.3 Flash compiles for an AMD card under Linux (ROCm from a system install or AMD's wheels), through the same HIP layer as Strata's own engine, with the virtual memory calls mapped onto HIP's. iMilnb wrote the port (#11) and ran it on an RX 7600 (8 GB): Qwen3.6 UD-Q2_K_XL writes 64 tokens/s, Ornith APEX-I-Mini 35. Install as for NVIDIA: ./setup.sh --family qwen36. Windows has no ready-made AMD engine, so setup refuses these models on an AMD card there; images stay off on AMD; Gemma 4, Tiel Coder and GLM have not been tried on an AMD card yet, and setup says so. On NVIDIA nothing changes: the same tokens and the same speed as 0.1.42-poly.3. docs/AMD_HIP.md.
• GLM 5.3 Flash has run on Windows: a user's report with an RTX 5090 D v2 (24 GB) and 128 GB of RAM, a 1M-token context and a 557K-token prompt read whole (#10). The docs say so.

The engine's sources changed, so the zip below is a new ready-made Windows engine; the installer downloads it and checks its SHA-256.

How fast

The tables did not change: 0.1.42-poly.3, the README and docs/BACKENDS.md.

Install

Download the source below, or git clone the repository. Then run START-HERE.bat on Windows or ./setup.sh on Linux. An earlier install updates with UPDATE.bat or ./update.sh.

Limits

• The five added models are experimental, measured on two machines, a pair of RTX 3080s and now one RX 7600.
• The ready-made engine is for Windows and CUDA 13 only; CUDA 12 and AMD cards compile on your PC.
• GLM 5.3 Flash needs about 100 GB of RAM, and about 8 GB more than its file in a container.
• AMD cards on Windows run Qwen3.8-Flash-Next only.

Most of this project is the work of Strata's author and contributors.