Skip to content

Releases

Fork 0.2.15-nvfp4.7: two GPUs under Windows pin at most 62 GiB in all, a refusal is remembered

Choose a tag to compare

@sergqwer sergqwer released this 21 Nov 20:41

strata-nvfp4 0.2.15-nvfp4.7 - two GPUs under Windows pin at most 62 GiB in all

The fix. 0.2.15-nvfp4.6 did not help the two RTX 5060 Ti with 256 GB of RAM (Unsloth UD-Q6_K_XL). Their start still
hung after "the free graphics memory could not be read (out of memory)". The new log showed why. Windows refused the
pinned experts at the same total, 63.74 GiB on both cards together, however the cards shared it. After that refusal the
driver gave nothing back, so the 0.2.15-nvfp4.6 recovery could not work.

Now:

  • A layer split under Windows pins at most 62 GiB of experts on all its GPUs together. Each card's own limit still
    holds, and the cards still take turns.
  • If Windows refuses earlier, the engine writes down where. The file is %LOCALAPPDATA%\strata\wddm-pin-limit.txt,
    with one line per RAM size, GPUs and driver. The engine then ends at once instead of hanging.
  • strata serve starts it again by itself. The next start pins 2 GiB less than the refused one had.

No setting is needed. If you added STRATA_ARENA_PIN_GIB to work around this, remove it: it now only pins less.

Checked on an RTX 5090 with two stages on one card. With the driver's refusal simulated at 40 GiB, the first start was
refused at 38.23 GiB, wrote it down and ended within 5 s. serve started it again, and the second start pinned 35.60 GiB
and was ready. With the defaults it pinned 61.96 GiB and read a 32K prompt at 9,206 tokens/s.

The same text. One GPU is unchanged. With two GPUs the change only decides which layers stay pinned. The details are
in docs/NVFP4.md ("Two GPUs under Windows: one limit of about 64 GiB for all the GPUs").

Update

  1. Close the server.
  2. Run update.cmd in the release folder (UPDATE.bat in a clone). This release needs no new model files.

SHA-256 84bd404b27b8a3982538294d9547a25fd1c3e483c749856a275a9a8cabed5759

Fork 0.2.15-nvfp4.6: two GPUs under Windows start where the driver limits pinned memory

Choose a tag to compare

@sergqwer sergqwer released this 21 Nov 17:52

strata-nvfp4 0.2.15-nvfp4.6 - two GPUs under Windows start where the driver limits pinned memory

The fix. With two GPUs under Windows the engine could end before it was ready, after "the free graphics memory could
not be read (out of memory)" and an expert cache of 0 slots. Reported on two RTX 5060 Ti with 256 GB of RAM and the
Unsloth UD-Q6_K_XL model, five starts out of five.

A layer split pins the experts in RAM for each card, a layer at a time. Before this release the first card pinned all
of its layers, then the second card pinned until the driver refused. That card got 64-70 GiB pinned in all, while Windows
reported a budget of 115 GiB. At that point the drivers had no room left for anything else, so neither card could even
report its free memory.

Now:

  • The cards take turns. Each card holds the same share of its layers wherever the pinning stops, whatever its VRAM
    and however many layers the split gave it.
  • The driver's first refusal ends the pinning on every card. 4 GiB go back (STRATA_PIN_MARGIN_GIB).
  • Every card must answer before the engine goes on. It must read its free memory and pin a 256 MiB test buffer. If a
    card cannot, more layers go back.

No setting is needed. The log says what happened in one line:
expert arena: the driver refused a slice on CUDA1 (...): one limit for all the GPUs; ... handed back ...; every GPU answers.

Checked on an RTX 5090 with two stages on one card and the driver's limit simulated at 40 GiB. 0.2.15-nvfp4.5 ended
before it was ready ("KV streaming: cannot pin 0.26 GiB"). 0.2.15-nvfp4.6 was ready in 12 s, with 50% / 54% of each
stage's layers pinned.

The same text. One GPU is unchanged. With two GPUs the change only decides which layers stay pinned. Handing layers
back leaves nothing behind: a start that reached a set of pinned layers through a refusal and one that reached the same
set without one give bit-identical first-token logits. The details are in docs/NVFP4.md ("Two GPUs under Windows").

Update

  1. Close the server.
  2. Run update.cmd in the release folder (UPDATE.bat in a clone). This release needs no new model files.

SHA-256 9ff90d6c104e355a7d59fc54860795a02bb4e426aa1f9de65930926642e29628

Fork 0.2.15-nvfp4.5: long dialogs decode up to 13% faster on RTX 50, pictures read in the engine 2-5x sooner

Choose a tag to compare

@sergqwer sergqwer released this 21 Nov 13:24

strata-nvfp4 0.2.15-nvfp4.5 - RTX 50: long dialogs decode faster, pictures read in the engine

Long dialogs decode up to 13% faster on RTX 50. In a long dialog the indexer has to score more key blocks for every
draft window, and that scoring was most of the slowdown from 2K to 370K tokens. Past 24,576 cells the blocks are now
scored by a kernel that reads each pooled key once for all of the window's queries, with the same scores bit for bit. The
drafter's attention runs pipelined, and the K/V resolve ends at once while every block is still in VRAM. RTX 5090 at
600 W, serve, greedy, one dialog that grows to 370K tokens with the same continuation at every length, against the build
before this round (both release builds, 3 runs each), tokens/s:

Context JSON English prose
32K 363 -> 378 (+4%) 195 -> 201 (+3%)
64K 370 -> 388 (+5%) 175 -> 182 (+4%)
128K 366 -> 389 (+6%) 168 -> 175 (+4%)
256K 353 -> 400 (+13%) 162 -> 172 (+6%)
370K 324 -> 367 (+13%) 164 -> 166 (+2%)

Short answers. Two more decode rounds of exact kernel changes. Against 0.2.15-nvfp4.4: a JSON answer about +7%, a chat
+4%, English prose +6%, Ukrainian +1%.

The engine reads pictures itself, on the GPU. It borrows ~360 expert slots only while it encodes a picture, then
refills them from RAM. Between pictures every slot is the cache's. Time to the first token of a picture turn:

Picture 0.2.15-nvfp4.4 (CPU reader) 0.2.15-nvfp4.5 (in the engine)
329 tokens 1,352 ms 631 ms
1,085 tokens 4,777 ms 924 ms

Setup and this release's config turn it on ("in_engine": true in the config's vision section). update.cmd keeps a
config you edited, so add the key there yourself. STRATA_VISION_IN_ENGINE=0 keeps the CPU reader.

Fixes

  • Smaller RTX 50 cards (RTX 5080, 5070, 5060): 0.2.15-nvfp4.4's early hyper-connection read (STRATA_EARLY_READ)
    could wait 2 s a window there. It is off by default now, and skipped on a card where it cannot fit.
  • Two GPUs: the pinned experts are cut to the Windows shared segment (upstream #3725), and a layer split sizes its
    DeltaNet grid and prompt buffer for each card.
  • Expert slots: under KV streaming the indexer's keys and the RoPE table grow with the context instead of being sized
    for all of it at the start, which frees +320 expert slots at short contexts.

The same text. Every decode and prompt change is exact. In the fixed-placement check the decode texts and the 16K /
64K prompt texts and first-token logits are bit-identical to 0.2.15-nvfp4.4's. Past the model's 262,144 positions (dynamic
RoPE, prompts of 294K-360K tokens) the text is unchanged too. The prompt reads as fast as before.

Switches

  • Each new switch has its own =0, and STRATA_NVFP4_SM120=0 still turns off the whole RTX 50 set.
  • The list is in docs/fork/ENVIRONMENT.md ("RTX 50 in 0.2.15-nvfp4.5"). The measurements and what was tried and dropped
    are in docs/NVFP4.md ("RTX 50: decode rounds 3-5").

Update

  1. Close the server.
  2. Run update.cmd in the release folder (UPDATE.bat in a clone). This release needs no new model files.
  3. Updated to 0.2.15-nvfp4.4 with update.cmd and your model has no mtp\rt-tuned folder? Run prepare-model.cmd once.
    It fetches Basalt's draft layer, which update.cmd does not.

SHA-256 83f4fa8e5c78f035f18a2c6da07c283b311c7ff9d899afd54f1829ab587f1340

Fork 0.2.15-nvfp4.4: RTX 50 decode kernels and drafting after Basalt - decode 23-56% faster, long prompts ~30% faster

Choose a tag to compare

@sergqwer sergqwer released this 20 Nov 18:29

strata-nvfp4 0.2.15-nvfp4.4 - RTX 50: Basalt's decode kernels and drafting, faster prompts

Decode 23-56% faster on RTX 50. This release ports the decode kernels and the MTP drafting of
Basalt (MIT, Jesús Gulfo), a Strata fork tuned for this model on RTX 50 cards, and
adds kernels of our own for decode and the prompt. RTX 5090, serve, greedy, the tray's arguments, tokens/s, one run of
each in the same hour (power limit 510 W):

Answer 0.2.15-nvfp4.3 (Auto: DFlash2) 0.2.15-nvfp4.4 (Auto) Basalt
JSON 330 487 475
chat 219 269 248
English prose 205 261-271 276
Ukrainian 154 241 235
  • Auto on CUDA, one request at a time, is now the MTP with Basalt's drafting for the Qwen3.8-Flash-Next sets: its
    two-stage draft head (--mtp-head proxy), its cumulative window rule (--mtp-cum auto) and a window of 8.
    STRATA_AUTO_NEW_MTP=0 keeps the old Auto (DFlash2).
  • Basalt's self-distilled draft layer ships with the GPTQ set. Setup and update.cmd download it (116 MB, checked by
    SHA-256) into the model's mtp\rt-tuned; the set's own experts and draft vocabulary are linked beside it. It is from
    Basalt's pack (huggingface.co/jesdga/Qwen3.8-Flash-Next-Basalt, Qwen Community License 1.0, like the model itself).
    Without it Auto uses the set's own MTP layer, which accepts fewer drafts.

Prompts of 16K and more read about 30-35% faster (the two rounds' ratios multiplied). Two rounds of prompt kernels: the DeltaNet scan on tensor cores, equal chunks, the grouped
FP4 expert GEMM, then int8 QSA block scores, f16-accumulate dense GEMMs, CUDA graphs for the prompt's kernel chains,
less hyper-connection traffic, and the borrowed expert slots refilled beside decode. One request, context 140,000, ms:

Prompt tokens 0.2.15-nvfp4.3 after round 1 before round 2 0.2.15-nvfp4.4 Basalt
3,072 924 853 922 857 1,258
16,676 1,938 1,657 1,686 1,350 1,972
66,617 7,845 6,163 6,208 5,110 6,300
131,000 14,460 12,471 12,496 10,345 -

The first two columns were measured at a 510 W power limit, the last three at 600 W, so compare within each pair.
Basalt's context ends at 66K. The time to the first token at 64K went from 6.19 to 5.25 s in round 2.

Accuracy is unchanged. Teacher-forced on this fork's corpus (the same text through both engines, every position):
the top token matches the base engine's 95.9-96.1% of the time with a KL of 0.015, while two runs of the base engine
itself differ by 96.5% / 0.012. With every switch of the second round at =0 the engine reproduces the previous text and
first-token logits bit for bit.

On by default on RTX 50 cards only (compute capability 12.0); other cards run as before.

  • STRATA_NVFP4_SM120=0 turns the whole set off.
  • Each switch's own =0 turns that one off; a switch you set yourself is kept.
  • The list with what each switch does and whether it changes rounding is in docs/NVFP4.md ("RTX 50: decode and prompt
    kernels after Basalt" and "RTX 50: faster prompts").

The release engine still runs on RTX 20/30/40 cards (sm_75/86/89). The new RTX 50 kernels take their older paths there.

Credits: Basalt by Jesús Gulfo (MIT; its draft layer under the Qwen Community
License); Geode
(github.com/sergqwer/geode).

Update: close the server, run update.cmd in the release folder (UPDATE.bat in a clone); it also fetches the draft layer.

SHA-256 2cf710f6cd63cf92b6ba65d977c1fbfee3ec3fe30023c1d0ece949b5c866447b

Fork 0.2.15-nvfp4.3: KV streaming on by default - decode holds ~195 tokens/s to the end of a long dialog

Choose a tag to compare

@sergqwer sergqwer released this 19 Nov 04:20

strata-nvfp4 0.2.15-nvfp4.3 - KV streaming on by default for long dialogs

Decode holds about 195 tokens/s to the end of a long dialog. Until now the engine kept each attention layer's whole
K/V in VRAM, and the elastic K/V took that VRAM from the expert cache as a dialog grew: at 274K it held 1,239 fewer
experts, and decode fell from about 205 tokens/s to 180. The engine now streams the K/V on its own for long contexts:
32,768 cells of each attention layer stay in VRAM, the rest is read from pinned RAM when the attention selects it, and
the experts keep their VRAM. RTX 5090, the GPTQ profile with DFlash2, the same 1,730-token answer after each prompt:

Prompt Before Now
2K 191-193 184-190
32K 204 202
128K 193 196
274K 179-180 193-195

A long prompt reads about 2% slower, and the K/V's RAM copy takes 6.2 GiB at a 512K context. The dialog cache in RAM
works as before (three dialogs of about 100K taken in turn: 258-286 ms to switch back).

Why --kv-resident looked slower before. The expert cache was one VMM range only together with the elastic K/V,
which --kv-resident turns off. The plain arena it fell back to made every GPU stage 20-60% slower under WDDM, and
unevenly from run to run (upstream #4815 reports the same slowdown). The cache is now one VMM range with KV streaming too.

When it is on: one CUDA card (not an integrated one, not WSL), --max-context of 131,072 or more, no --batch, every
expert in RAM, and RAM for the experts plus 32 GiB plus the K/V copy (a 96 GB PC keeps the old way).

  • --no-kv-stream (or --kv-resident 0, or STRATA_KV_STREAM=0) keeps the whole K/V in VRAM as before.
  • An explicit --kv-resident N is used as given, and setup's "KV streaming off" answers stay off.
  • The measurements, and what was tried and dropped (faster copy kernels, fetching blocks a round ahead), are in
    docs/NVFP4.md ("KV streaming on by default").

Update: close the server, run update.cmd in the release folder (UPDATE.bat in a clone).

SHA-256 14ead21e640b011f7004a104bf713902b334c5482b107d40a9379baf6d6941f0

Fork 0.2.15-nvfp4.2: DFlash2 drafts for the NVFP4 GPTQ - 7.5% faster decode on an RTX 5090

Choose a tag to compare

@sergqwer sergqwer released this 18 Nov 04:52

strata-nvfp4 0.2.15-nvfp4.2 - DFlash2 drafts for the NVFP4 GPTQ

DFlash2 is the NVFP4 GPTQ's drafter on cards like the RTX 5090. Auto now drafts with DFlash2, incoai's drafter for
Qwen3.8-Flash-Next, instead of the MTP layer, on one card that holds at least as many experts as a 32 GB RTX 5090. On the
5090 decode is 215 tokens/s against 200 (+7.5%), and 213 against 194 with the censorship switch on (+10%). The drafter
also takes less graphics memory than the MTP layer, so 158 more experts fit. The dialog cache in RAM works with it as
before. Upstream left DFlash2 off for NVFP4 models because it had no numbers for them.

  • Setup and the zip's prepare-model.cmd fetch the drafter where it is used: 1.2 GB once, about 0.86 GB kept beside
    the model. After update.cmd, run prepare-model.cmd once to get it. Until then the model drafts with the MTP, as
    before.
  • Cards of 12-24 GB, several cards, NVIDIA's NVFP4 and the mix keep the MTP until they are measured. A drafter chosen by
    name still wins over Auto.
  • The measurements, the confidence sweep and the greedy checks are in docs/NVFP4.md ("DFlash2 drafts for the NVFP4
    GPTQ"). A Q8_0 drafter and upstream's tuned drafter pack accepted no more guesses than the stock pack.

Fixed

  • Upstream #5153: saving a session file (/slots/0?action=save) with DFlash2 alone no longer fails with "conversation
    snapshot: invalid K/V extent". A saved dialog is restored and goes on from the file.
  • Switching models in a launcher no longer fails now and then with "port 8091 is already in use". Windows closes a
    stopped server's port a moment after the process is gone, so the new server now waits up to 15 s for it.
  • The zip has the draft vocabularies that setup's --draft-vocab en | fr | latin names. Every subset holds the English
    and code tokens; the default stays the English + Cyrillic one.

Update: close the server, run update.cmd in the release folder (UPDATE.bat in a clone), then prepare-model.cmd for
the drafter.

SHA-256 2c0fb2f7ace53afb9dcd3e71f4a386b1c366d03a4da2fd333027014fe1f82dce

Fork 0.2.15-nvfp4.1: on upstream 0.2.15 - the same bits and speed, #24 / #25 / #27 fixed

Choose a tag to compare

@sergqwer sergqwer released this 18 Nov 03:35

strata-nvfp4 0.2.15-nvfp4.1 - on upstream Strata 0.2.15 (engine 0.1.61)

This release moves the fork onto upstream 0.2.15 (upstream's 0.2.14 and 0.2.15). It takes upstream's engine, server
and setup. Upstream's desktop app, Terminal and installers are not included, and the release is still the Windows zip.

The same answers, the same speed. On one GPU with one dialog, the 2K and 32K prompts give logits and greedy tokens
bit-identical to 0.2.13-nvfp4.1's engine. On an RTX 5090, decode takes 11.71 ms a round against 11.75 for a 0.2.13
build (6 interleaved runs each). The 32K prompt reads at 8,794 tokens/s against 8,799.

Fixed

  • #24: a tool call whose parameter tag lost its > before the line break (<parameter=NAME or </parameter) is read
    as that tag. The streamed arguments no longer end as text that is not JSON. If the model ends its turn after the
    call's own closing tags while a value still looks open, the turn now simply ends: the end-of-turn token is no longer
    written into the argument up to 64 times. Text outside a call is left as written, and a call that never closes still
    fails loudly.
  • #25 / #26 (thanks, MatthewHines): in the browser interface opened over plain http from another machine on the LAN,
    attaching a picture no longer fails with "Some files could not be read". File previews, saved settings and saved
    model profiles are fixed too.
  • #27 / #28 (thanks, MatthewHines): the last round of a strata_mcp request that reaches the tool-use limit no longer
    fails with "System message must be at the beginning." on models whose chat template allows one system message.

Changed

  • NVFP4 prompts stay on this fork's path (llama.cpp's MMQ kernels, w4a4x2). From 0.2.14, upstream builds without MMQ
    and reads NVFP4 prompts on its own int8 kernels. On the RTX 5090 those gave other answers and were not faster:
    8,540 tokens/s against 8,794 for a 32K prompt, and 8,743 against 9,185 for 128K. STRATA_PF_FUSED=1 selects them.
    Setup's source build of the engine uses -DSTRATA_MMQ=ON.
  • Tool arguments follow upstream's #5979 rules for True / False. A declared boolean takes any case. With no schema,
    or where a string is allowed, the text stays text. This fork still reads them for anyOf and untyped parameters.
  • New and off by default: STRATA_GR_V5=1, a faster hyper-connection read. It gives the same bits as the plain read
    (checked with the gr_v4_check test tool). On an RTX 5090 it took 0.2 ms off a round (11.75 against 11.95 ms).
  • Setup: DeepSeek is gone, as upstream removed it.
  • From upstream 0.2.14 and 0.2.15: see upstream's release notes.

Update: close the server and run update.cmd in the release folder (UPDATE.bat in a clone).

SHA-256 03791154ee76fbb33db9297da0f47523393acc9fffa775734ad5fa8289fd9f3f

Fork 0.2.13-nvfp4.1: on upstream 0.2.13 - the same bits and speed, #20 / #15 / #16 fixed

Choose a tag to compare

@sergqwer sergqwer released this 09 Nov 22:24

strata-nvfp4 0.2.13-nvfp4.1 - on upstream Strata 0.2.13 (engine 0.1.59)

This release moves the fork onto upstream 0.2.13. It takes upstream's engine, server and setup; upstream's desktop app,
Terminal and installers are not included. The release is still the Windows zip.

The same answers, the same speed. On one GPU with one dialog, the 2K and 32K prompts give logits and greedy tokens
bit-identical to 0.2.0-beta-nvfp4.3's engine. Decode and the 32K prompt run at the same speed on an RTX 5090: 12.2 ms
a round and 8,589 tokens/s for the 32K prompt, on both engines.

Fixed

  • #20: a model copy that is page-locked slice by slice (a 64 GiB Mix, for example) no longer stops with "adaptive swap
    copy failed ... invalid argument". Each place in the copy that crosses a slice's edge gets its own page-locked copy,
    kept current as the adaptive tier moves experts in and out of it. Reproduced and checked on an RTX 5090 with a test
    switch (STRATA_TEST_COMPLEMENT_REFUSE, docs/NVFP4.md).
  • #15 / #16: the browser interface attached to a server shows the server's tools. Its Monitor shows the server's live
    numbers, but only while the Monitor tab is open, and asks the keyless /health first. An idle page never wakes a
    sleeping model.
  • docs/NVFP4.md: a 12 GB card runs the 262,144-token context with --kv-resident 32768 (#19).

Changed

  • Upstream's new defaults that change answers and were not measured on NVFP4 stay at 0.2.0's behaviour: the PCIe share
    that follows the CPU's speed, the pool-sized PCIe start, the server's wider verify window, and the async adaptive tier
    that switches itself on. Each has its environment variable (docs/NVFP4.md).
  • A call to a tool the request did not declare now arrives as text (upstream's behaviour).
    "undeclared_tool_calls": "call" in the run config restores the old behaviour. The opt-in tool_name_repair gave
    way to upstream's tool-name aliases.
  • Setup: upstream's UD-Q3_K_XL (4 files) replaces this fork's 3-file one.
  • From upstream 0.2.1-0.2.13: see upstream's release notes. Penalties now count only the reply's tokens (#4590).

Update: close the server and run update.cmd in the release folder (UPDATE.bat in a clone).

SHA-256 b928050dc13a7b1ac68e70488b4017b6bd6ffdc643a62632e6a0200e05aa1d19

Fork 0.2.0-beta-nvfp4.3: upstream 0.2.0's new interface in your browser, over the server you already run

Choose a tag to compare

@sergqwer sergqwer released this 20 Oct 01:32

Fork 0.2.0-beta-nvfp4.3: upstream Strata 0.2.0's new interface, in your browser instead of a separate desktop
program. The engine is unchanged (the same strata.exe as 0.2.0-beta-nvfp4.1 and .2, 56042c6e), so the model's
answers and speed are the same.

Opening it. Run start-server.cmd as before. Once the model is ready, the new interface opens at
http://127.0.0.1:8791:

  • chat with pictures and the thinking switch, with the chats kept by the browser;
  • skills and workspaces;
  • the Monitor with the engine's own numbers (speed, VRAM, experts in the cache, context fill, recent requests).

The old page stays at http://127.0.0.1:8080/.

How it runs.

  • The page is upstream's React app (apps/host). Its host runs on the folder's own node\node.exe (Node.js 24 LTS,
    in the zip).
  • It is a front end over the server you already run. The server owns the engine and the model; the page starts no
    engine of its own and ends with the server.
  • Model downloads, tuning and updates stay where they are (prepare-model.cmd, update.cmd). The pages for them are
    hidden in the new interface. So are upstream's agent tools, which need a component this fork does not ship. Chat
    with pictures and reasoning works fully.
  • Upstream's desktop app (Tauri) is not part of this release.

A model something else runs (a tray).

  • start-ui.cmd <address> opens the page for a server another program owns.
  • A run config with "app_ui": true starts the page with its server wherever that server is started from. With a tray,
    the page lives while the tray's model is loaded. "app_ui_open": false keeps the browser from opening at each load.
  • The page never wakes a sleeping model by itself. Only a chat you send does. An open, idle page does not keep the model
    loaded.

Changes made to upstream's host for this fork:

  • It answers only at http://127.0.0.1:8791 and checks the Host header, so a web page can't reach it through DNS
    rebinding. Other origins get 403 on every control route. It refuses to listen beyond loopback unless
    STRATA_ALLOW_LAN_BIND=1 (unsupported for now).
  • The host's own /v1 endpoint, the network share and the Cloudflare tunnel are off.
  • No check against upstream's releases. The page's update notice is this fork's own (STRATA_UPDATE_CHECK=0 turns it
    off). Nothing is downloaded by the host (STRATA_NO_ACQUIRE=1).
  • It sends no sampling of its own unless you set it in the page, so the model's own settings apply.
  • Upstream's GT Walsheim Pro webfont is not in the zip (it is a commercial typeface). The page uses Segoe UI.

No node\node.exe, or set STRATA_APP_UI=0: one line says why, and the old page is the interface, as before.

Checked:

  • Tests:
    • The host's tests: 836 run. The one failure also fails on upstream's code without these changes. 12 new tests cover
      the attach mode, the wake rule, the Host check and the update check.
    • The server's 1,029 tests pass.
  • A clean unzip with a fresh .venv-serve, run through start-server.cmd:
    • the new interface answered a chat at 149 tokens/s, and the Monitor showed the engine's numbers;
    • closing the server ended the host;
    • without node.exe, the old page answered;
    • start-ui.cmd attached to the folder's server and answered.
  • Security: a request with a foreign Host header gets 421 (before, it listed a model folder), a foreign Origin gets
    403, and the host's /v1 gets 404.
  • Behind a tray: the request counter stayed flat for 8 minutes with the page open. A chat from the page answered. A
    Claude Code request with two pictures through the tray was answered correctly.

The zip is 503.5 MB (0.2.0-beta-nvfp4.2: 467.7 MB): Node.js and the page add about 36 MB. Update with update.cmd in the
release folder (UPDATE.bat in a clone). No model files change.

SHA-256 1417c28baefc3c18d2d346fed53bf7f940eb5f2d1ab369fb550d2ffce77d2ad3

Fork 0.2.0-beta-nvfp4.2: this fork updates from this fork - an update notice at start, strata update runs the fork's updater

Choose a tag to compare

@sergqwer sergqwer released this 19 Oct 23:07

Fork 0.2.0-beta-nvfp4.2: this fork updates from this fork. The engine is unchanged (the same strata.exe as
0.2.0-beta-nvfp4.1, 56042c6e), so the model's answers and speed are the same.

An update notice at start. After the model is ready, the server asks GitHub which strata-nvfp4 release is the
newest. It asks at most once a day, on a thread of its own, so neither the start nor a request waits for it.

  • When the published release is newer than the installed one:
    • the server's window gets one line with the command that updates this folder (update.cmd in a release folder,
      UPDATE.bat / ./update.sh in a clone) and a link to the release notes;
    • the chat page shows a small "v… is out" link in its header. Its x hides it until the next release. About > Model and
      engine lists it too.
  • It only reads. The request is one small JSON request with no token, no install id and nothing about the PC. The
    answer is kept in .update/update-check.json. Nothing is downloaded or installed by itself.
  • Turn it off with STRATA_UPDATE_CHECK=0, or "update_check": false in the run config (also in the chat page's
    About > Settings). --offline never asks.

strata update runs this fork's updater. Without --feed, strata update (python strata.py update) runs this
fork's updater for the folder it is in:

  • in a release folder, update.cmd's tools/bundle_update.py;
  • in a clone, UPDATE.bat / ./update.sh.

Details:

  • --check changes nothing. It says whether a newer release, or in a clone newer commits, is there.
  • Upstream's signed engine feed is used only when you name it (--feed, STRATA_UPDATE_FEED).
  • Before, strata update without a feed stopped with a message.
  • The release zip has no strata.py. A release folder updates with update.cmd, as before.

One version order. Setup and the notice compare versions with the same function. 0.2.0-beta-nvfp4.2 reads as
0.2.0 + nvfp4.2, so it comes after 0.2.0-beta-nvfp4.1 and after upstream's 0.2.0-beta.

Checked:

  • Tests: the server's 1,022 tests pass. The tools' failures are the same 25 as in 0.2.0-beta-nvfp4.1, each of them
    failing on clean upstream 0.2.0-beta on this PC too. 43 new tests cover the notice, the cache, the version order and
    strata update's routing, with no network.
  • One real request to GitHub each way: with 0.2.0-beta-nvfp4.1 installed the check says "up to date"; with an older
    version it names the newer release.
  • Installed from this zip on an RTX 5090: the server started, and the check ran and kept its answer. A Claude Code
    request with two pictures was answered correctly.

Update with update.cmd in the release folder (UPDATE.bat in a clone). No model files change.

SHA-256 6ccb375756413b7e58e5ba9ad59f93b7fc353ae4aaf3e5923b09a27f313984f6