RegesARC 0.0.25 (development preview)

RegesARC 0.0.25: an optional Speed mode for Qwen3.8-Flash-Next

Windows x64 development preview. Unsigned. Installed copies of 0.0.20 and later update themselves.

Speed mode (opt-in)

Qwen3.8-Flash-Next on RegesARC Engine Flash now has an extra Speed mode switch in Load Lab. It is off by default
and is not remembered between app starts, so every expert stays computed unless you turn it on for a load.

• What it does: uses Strata's own defaults, route tail skip and route prior: an expert that the model ranks low and
  that is not already on the GPU is skipped, and routing leans toward experts that are on the GPU.
• Measured on an RTX 4070 SUPER 12 GB with 80 GB of RAM (IQ3_S, 32K context): about 54–56 tokens per second
  in Speed mode, against 32–34 with every expert computed. In that test Strata skipped about 4% of the expert work.
• What it costs: answers can differ from the full model's. RegesARC labels the engine "RegesARC Engine · Flash ·
  Speed mode" and reports how many experts were skipped after every answer.
• No draft model: Strata's MTP draft is not used; on a 12 GB card it changed answers without adding speed.

Speed mode is only for Qwen3.8-Flash-Next on RegesARC Engine Flash. RegesARC Turbo and every other engine always
compute every expert and refuse the setting.

Everything in 0.0.24 is included.

RegesARC 0.0.24 (development preview)

RegesARC 0.0.24: Qwen3.8-Flash-Next on RegesARC Engine Flash, and models split into parts

Windows x64 development preview. Unsigned. Installed copies of 0.0.20 and later update themselves.

RegesARC Engine · Flash for Qwen3.8-Flash-Next

Qwen3.8-Flash-Next (the qwen4exp architecture: 512 experts, 10 per token) now loads in RegesARC. Pick its first
file in Load Lab with RegesARC Engine in Turbo mode; RegesARC runs it on RegesARC Engine · Flash, built on
Strata's engine and server (MIT, Niko1221 and the Strata contributors).

• Every expert computed: Strata skips or re-ranks some experts by default to go faster; RegesARC turns both off and
  checks the engine's own log at every load. No draft model is used: on a 12 GB card it made answers differ without
  making them faster.
• Measured: about 30 tokens per second on an RTX 4070 SUPER 12 GB with 80 GB of RAM (IQ3_S, 32K context), first
  word in about a second.
• Installed on first use: the engine (about 700 MB) is not in the installer. The first load downloads it from
  Strata's official release, checks every byte against its pinned SHA-256 and keeps it for later loads.
• The model is prepared once: the first load of a model file builds its 1.5 GB pack in a few seconds.
• Answers can vary by a word between runs: Flash splits work between the GPU and CPU by timing, so rounding can
  differ slightly from one run to the next. Turbo does not have this.

Models split into parts load

Large models are published in several files (name-00001-of-00007.gguf and so on). RegesARC now treats a set as one
model: it checks that every part is there and belongs to the same set, adds up the whole model's size for the memory
plan, and RegesARC Turbo reads all the parts. RegesCore 397B (Q4_K_M, 7 parts, 242 GB) loads this way.

On a 12 GB card with 80 GB of RAM, RegesCore 397B runs at about 0.2 tokens per second: most of its experts come from
the SSD. It is useful for long jobs you leave running, not for chat.

Everything in 0.0.23 is included.

RegesARC 0.0.23 (development preview)

RegesARC 0.0.23: the first message after a load starts right away

Windows x64 development preview. Unsigned. Installed copies of 0.0.20 and later update themselves.

The first message no longer waits for the system prompt

RegesCore's own system prompt is about 4,000 tokens. Every first message after a load read all of it, which took about
a minute on BF16, and a new chat read about half of it again.

• Read ahead: right after a model loads, RegesARC reads the system prompt once in the background. A message you
  send meanwhile waits for it and then starts right after the prompt instead of reading it again.
• New chats: the engine keeps a checkpoint every 256 tokens, so a new chat re-reads at most a few hundred tokens.
• Same answers: the same tokens are read in the same order; only when they are read changes. Checked token by
  token against a cold start.

The engine is called RegesARC Engine · Turbo

What the app called "Strata-Poly" is now Turbo, and its processes are named reges-turbo.exe, reges-turbo-bf16.exe
and reges-vision.exe in Task Manager. It is still built from PolyStrata's strata-poly (MIT), and the app's notices say
so.

Safer agent edits

• No writes inside .git: the agent never writes inside a project's .git folder, in any mode. Git runs programs
  from there, so a file edit could otherwise run code. Windows look-alike names are caught too.
• Hook files ask first: changes to .husky, .githooks, .gitattributes and .gitmodules ask first, even in
  Auto-accept edits.
• More commands ask: git restore, checkout of files, forced checkout or switch, stash drop and robocopy /MIR now
  count as destructive, so Allow all asks before running them.

Fixes

• Image temp folders: the image encoder's temporary folder is removed when it closes, and empty ones left by a
  crash are cleared.

Everything in 0.0.22 is included.

RegesARC 0.0.22 (development preview)

RegesARC 0.0.22: the agent sees, debugs, uses your computer, learns and remembers

Windows x64 development preview. Unsigned. Installed copies of 0.0.20 and later update themselves.

Paste screenshots into Build, Dev, Research and Terminal

Paste a screenshot (Ctrl+V), drop files, or use the attach button, as in Chat. RegesCore reads images when it's loaded
in Strata-Poly with its vision file. A model that can't read images says so, and nothing is dropped silently.

Browser debugging and frame capture

• Debugging: the agent reads the page's console errors, network requests, elements and their styles, and
  performance. It can also run JavaScript in the page; on sites that aren't on this PC, that asks first. The Browser
  pane has a Debug tab showing the same.
• Frame capture: up to 30 frames tiled into one image, with timestamps and how much each frame changed. The agent
  sees game and animation motion, not just a still screenshot.

Computer use (off until you turn it on)

The agent can take screenshots of your desktop and use the mouse and keyboard.

• Turning it on: per conversation, after a confirmation that lists what it can do.
• Asking first: every click and keystroke asks, unless that conversation is in Allow all or Bypass. Password and
  sign-in fields always ask.
• Always refused:
  • typing anything that looks like a secret;
  • any input while the screen is locked or a Windows security prompt is open;
  • typing into terminals or the Run dialog (commands go through the terminal tool, where your blocked-command list
    applies).
• Stopping: a red "RegesARC is controlling your computer" bar stays on top. Stop, Esc or Ctrl+Alt+Q
  ends it at once.
• Limits: can be limited to apps you choose, matched by program name. Screenshots stay on your PC.

It learns from its mistakes, and remembers

• Lessons: when a run fails and then recovers, RegesARC writes a short lesson: what failed, why, and what worked.
  Later runs get the relevant lessons as hints. See and edit them on Knowledge → Lessons.
• Save as skill: a successful run of three or more steps can be saved as a skill. It stays off until you turn it on.
• Plugin proposals: the agent can draft a new plugin for itself; you review and install it.
• Graph memory: a map of your projects, files, functions, errors and fixes, kept on this PC, per project and
  overall. The agent reads it freely; adding or forgetting something asks. See it on Knowledge → Memory.

Works with Claude Desktop

• Claude Desktop's third-party inference: works with RegesARC as its gateway. A system message inside the message
  list, which Claude Desktop sends, is now merged into the system prompt instead of failing with "messages[1].role must
  be user or assistant".
• Health check: Claude Desktop's connection check (HEAD /api/hello) now answers without a key. Health checks say
  only "ok"; models and messages still need the key.
• Model aliases: in Server → Local API, give the loaded model extra names (for example Reges-Opus4.8 or
  claude-sonnet-4-5), like LM Studio's model identifier. Every alias is listed in /v1/models, in Anthropic's format
  for Anthropic clients, and is accepted on both the OpenAI and Anthropic routes.

Fixes

• Copy buttons work: model names, API keys, code blocks and terminal output. The app had refused its own clipboard
  permission.
• Images in chat messages open full size when clicked; Esc or a click closes them.

Everything in 0.0.21 is included.

RegesARC 0.0.16 (development preview)

RegesARC 0.0.16: rich chat, themes and large models on a small GPU

Windows x64 development preview. Unsigned.

Rich chat

• Formatted answers. Answers render as Markdown: headings, lists, tables, quotes and links. Code blocks have
  syntax highlighting and a Copy button. Highlighting starts when the answer is done, so streaming stays fast.
• Links ask first. Clicking a link in an answer asks before it opens in your browser.
• Paste and attach anything readable.
  • A long paste becomes a chip instead of filling the box.
  • Code and text files can be attached by picker, paste or drag-and-drop, up to 1 MB each.
  • Images work as before, with RegesCore in Strata-Poly.
  • The model gets each attachment by name as a fenced block after your message.
• Message queue. Press Enter while RegesARC is answering and your message waits in a queue above the box. Queued
  messages go out one by one when each answer finishes. You can edit or remove them before they go.

Themes

Ten themes under Settings → Preferences → Theme, each recoloring the whole app:
Night, Day, Midnight, Graphite, Ocean, Forest, Ember, Royal, Paper and High contrast.

Large models on a small GPU

• Lemonade fits the GPU for you. When a model's layers do not all fit in VRAM at the context you chose, Load Lab
  puts as many layers on the GPU as fit and runs the rest on the CPU, as LM Studio does. It tells you how many fit.
  The context is never reduced. Example: Qwen3.8-27B Q8_0 at 262,144 context puts 13 of 65 layers on a 12 GB card.
• RegesCore BF16 (experimental).
  • The two-part BF16 release loads in Strata-Poly on a BF16 build of the engine, with BF16 GPU expert kernels.
  • RegesARC checks both parts against their pinned SHA-256 and remembers each hash, so the 69 GB set is read once.
  • Measured with 80 GB RAM: 124–235 tokens/s reading and 4–9 tokens/s writing. The weights do not fit in RAM, so
    experts are read from disk.
  • For near-BF16 quality at about 28 tokens/s, use the Q8_0 conversion.

Coding workspace

The terminal is now packaged with the app: node-pty 1.1.0, with each of its 23 files checked by size and SHA-256.
Its licenses, and those of xterm.js, marked, DOMPurify and highlight.js, are in the third-party notices.

Measured in 0.0.15 QA

RegesCore MXFP4 in Strata-Poly at 262,144 context:

• Writing: 50–55 tokens/s.
• Prompt reuse: later turns reused 19, 56 and 671 cached tokens; the reply started in 0.5–1.1 s.
• Clients: OpenAI and Anthropic tool calls passed, as did streaming.

Everything in 0.0.15 is included.