What Changed in Strata Updates: Should 12GB and 16GB GeForce Users Upgrade?

This article is based on the Strata release notes published up to 0.1.45 as of October 18, 2026. On November 1, 2026, we added the changes up to 0.2.9 to the "What Changed in the 0.2 Series" section. On November 4, we added the 0.2.10 changes and a summary of the 0.2.10 drafting comparison measured in a separate article to the same section, added dated paragraphs to the key points and the summary, and added 0.2.10 to the 0.2-series item in the list of what we have not measured.

Strata Is Updated Almost Daily: The Big Changes for 12GB and 16GB GeForce Cards

Strata is an inference engine that runs large MoE models that do not fit in VRAM by keeping only the frequently used parts on the GPU and reading the rest from system RAM. On the GitHub release list, 52 versions, including fix versions (such as 0.1.40.1), were published from 0.1.0 on September 24, 2026 to 0.1.45 on October 17. The dates are the publication dates (UTC) on the release list; when we checked the list on October 18, 2026, the newest published version was 0.1.45.

Of these 52 versions, the big changes that matter to people using 12GB or 16GB VRAM GeForce cards, grouped by content rather than by version number, are as follows.

• 0.1.0: From the very first version, a prebuilt engine for Windows that runs on RTX 30, 40 and 50 series cards was distributed. According to the release notes, no compiler or CUDA Toolkit is needed, only NVIDIA driver 580 or later.
• 0.1.16: Coder was added. It is Qwen3.8-Flash-Next with half of its experts (the parts of an MoE model of which only some are used for each token) removed, keeping the ones needed for code, tool calls and images; as of 0.1.16, the official docs said it runs with 32GB of system RAM. In the same version Strata became open source under the MIT license. According to the release notes, Coder only started on PCs with 32GB from 0.1.26 onward.
• 0.1.26: A mechanism for PCs with little system RAM was added. According to the release notes, until then all of a model's experts were loaded into system RAM, so even Coder would not start on a PC with 32GB of system RAM. With the new mechanism, the memory the engine allocates for Coder goes down, and the output in this mode is said to be the same as in normal operation. With a small GPU, however, many experts are read from the SSD, so it is much slower. The batched processing for speculative decoding (MTP) added in the same version can occasionally produce output that differs from 0.1.25.
• 0.1.35: Fixed a problem where, on Windows PCs with 32GB of system RAM, the mode that keeps experts that do not fit on the GPU in system RAM (added in 0.1.30) was not working. When not all experts fit in system RAM, it now keeps as many as fit, starting with the most frequently used.
• 0.1.17 and 0.1.39: From 0.1.17, Claude Code can connect to Strata. According to the release notes, you set ANTHROPIC_BASE_URL to Strata's address and put a Claude model name that Claude Code knows in ANTHROPIC_MODEL (Strata does not look at the name). 0.1.39 added support for OpenAI's Responses API (/v1/responses), so Codex CLI works with Strata.
• 0.1.41 and 0.1.42: Defaults that make a single NVIDIA GPU faster were added. In exchange, calculation results change slightly, and the output text can start to differ from earlier versions partway through.
• 0.1.44: Strata added support for Qwen3.6-35B-A3B as a model other than Qwen3.8-Flash-Next, so the same strata program can run two models.

On our RTX 5080 and RTX 5060 Ti, upgrading from 0.1.41 to 0.1.45 made generation faster. Between these versions came the NVIDIA defaults in 0.1.42 and the added sampling defaults in 0.1.45, among other changes, and we have not isolated which change made it faster. The test conditions and numbers are in "Versions We Measured, and What We Have Not Measured".

The update steps and what to check before upgrading are in "How to Update, and What to Check Before Upgrading", the detailed per-version changes up to 0.1.45 are in "List of Changes by Version", and the 0.2-series changes are in "What Changed in the 0.2 Series".

How to Update, and What to Check Before Upgrading

Up to 0.1.45, if you installed Strata with git, you update it with UPDATE.bat (update.sh on Linux). According to the official install guide (docs/INSTALL.md), if you installed from a zip, you extract the new zip and run START-HERE.bat (this is the guidance as of 0.1.45; the new zip you can download now is not necessarily the 0.1.45 one, and we have not checked the steps for installing the 0.2 series from a zip on this page). The model files are in Strata-data next to the Strata folder, so you do not have to download them again. Either way, a running engine cannot be replaced, so close the model window before you run it. Coming from a git install of 0.1.40 or earlier, you first need a one-time manual step (see the warning below). According to the release notes, UPDATE.bat, added in 0.1.36, updates Strata without starting a model. For a git install it pulls in the new files, and for a zip install it tells you to download the new zip; then it updates the Python packages, the engine and each model's settings, and stops. The 0.1.45 release notes also say to update with UPDATE.bat and that setup replaces the engine. For a git install, UPDATE.bat fetches the latest history at the time you run it (git pull --ff-only), so it is not a way to upgrade specifically to 0.1.45, and neither are the steps in the warning below that move you to origin/main (Update, November 4, 2026: running this now may take you to the 0.2 series rather than 0.1.45). What the 0.2-series release notes say about upgrading, and what they leave out, is in "What Changed in the 0.2 Series".

As of 0.1.45, UPDATE.bat does not regenerate each model's settings file (in the 0.1.45 setup code, it only rewrites some old options in the settings file to the 0.1.45 defaults; we have not checked whether this is still true after moving to the 0.2 series). The settings file is regenerated when you redo setup with --setup, and when you extract a new zip into a different folder and carry over the previous settings. According to the official install guide, engine options you added by hand to args in the settings file are not kept in that case. In the 0.1.45 setup code, however, the option for the file that decides which experts go into VRAM first (the expert profile) is carried over (--expert-profile when the file it points to still exists, --expert-profile-save when the new settings do not already have the same option). Entries you wrote yourself in env and the sampling block are kept, and the previous file is kept as strata-<model>.json.bak. In the settings files for Unsloth quantizations, though, STRATA_ROUTE_TAIL_SKIP (an entry in the "Settings to revert the NVIDIA defaults" table below) is treated as an entry that setup writes, and a value you wrote yourself is not kept.

If you are on 0.1.35 or earlier, from before UPDATE.bat existed, and start Strata with START-HERE.bat: since 0.1.3, START-HERE.bat checks and replaces the engine every time it starts, but according to the release notes, the new files for Strata itself have to be put in place first with git pull or a fresh download. If you installed from a zip, extract the new zip and run START-HERE.bat; if you installed with git, move to the new history with the steps in the next warning.

git fetch origin
git branch pre-cleanup-backup
git checkout -B main origin/main

As a guide for choosing the version to upgrade to, the main versions in which problems were found after release and fixed in the next version are listed in the "Versions where problems were found" table.

0.1.44 also had a problem when setup was redone. According to the release notes, redoing setup on 0.1.44 could switch the installed model size to the new default, IQ3_S. IQ3_S is about 10–15% slower than IQ3_XXS and uses about 7GB more system RAM. From 0.1.44.1, redoing setup keeps the installed size. Redoing setup on 0.1.44 also erased entries such as STRATA_ROUTE_TAIL_SKIP that you had written yourself in env in the settings file. This was also fixed in 0.1.44.1, and such values are now kept (except in the settings files for Unsloth quantizations). If the model size was switched and it was originally IQ3_XXS, the following command switches it back. If you had a different size installed, put that size's name after --model.

START-HERE.bat --setup --model IQ3_XXS

What the two options in this command do is shown in the "Options in the command to revert to IQ3_XXS" table.

You can check your own speed after updating with BENCH.bat (bench.sh on Linux), added in 0.1.43. According to the 0.1.43 release notes, it measures a fixed set of items (a short chat, 4K and 16K inputs, and a five-turn agent task) on your own machine in about 3 to 10 minutes.

Versions Whose Output Changes Slightly After Updating, and the Settings to Revert Them

The release notes for many versions say the developers checked that the output is the same as in the previous version. Some versions, on the other hand, change how calculations are done or change defaults for speed, and in exchange the output can change. The main ones, and the settings that bring back the original output, are in the "Versions whose output changes" table. The 0.1.45 row alone is not a speed change: it fills sampling fields the request does not specify with the values the model card recommends, and you revert it not through env but by specifying sampling in the request. The 0.1.44 change for Unsloth quantizations and the 0.1.45 change for Qwen3.6-35B-A3B are covered in the "Changes by version" table and in "What Changed in 0.1.45".

How much the 0.1.42 defaults help depends on the configuration. When the developers measured Q2_0 with the setup settings on a Windows PC with an RTX 5070 (Ryzen 5 7600), alternating three runs each, generation went from 77.0 to 85.6 tokens per second (+11.2%; the release notes attribute this gain to the default that skips low-ranked experts), while prompt processing at 16K barely changed, from 2,778 to 2,820 tokens per second.

According to the release notes, this default has no effect in configurations that put almost all experts in VRAM. As an example of the effect, the developers cite an RTX 3060 12GB with IQ3_XXS, where the default that measures and sets the share read over PCIe raised generation from 47.7 to 62.1 tokens per second (+30.0%). The OS for this example is not given in the relevant line of the release notes.

In the 0.1.42 release notes, the only figure for a 12GB VRAM card where the OS is stated as Windows is the +11.2% for the RTX 5070 above (the +30.0% for the RTX 3060 12GB has no OS stated, so we cannot say whether Windows would see the same).

To match the 0.1.40-series output on NVIDIA, open the model's settings file (strata-<model>.json) and write the three entries in the "Settings to revert the NVIDIA defaults" table into its env. The STRATA_PREFILL_CPU_SHARE setting added in 0.1.41 is one of these three.

These settings are only for situations such as comparing results with an earlier version or reproducing the same output. Writing all three also stops the CPU help added in 0.1.41, so what you get back is the 0.1.40-series output. The 0.1.42 release notes call the output of this combination "the 0.1.41 output". That 0.1.41 is 0.1.41 with the CPU help turned off, and according to the 0.1.41 release notes, that state gives the same output as the 0.1.40 series. The original output comes back for the existing quantizations of Qwen3.8-Flash-Next (Q2_0, IQ3_XXS, IQ3_S and others) and for Coder. For Unsloth quantizations, setup writes another output-changing setting into env, and Qwen3.6-35B-A3B is a model supported only from 0.1.44, so neither can be compared with the 0.1.40 series. Also, even on the same version, temperature 0 output can change in a continued conversation or right after a restart. Following the release notes, write the values as strings, like this. If your settings file already has an env, add the three lines inside it (if you write two env blocks, the earlier env is not read).

"env": {
  "STRATA_ROUTE_TAIL_SKIP": "0",
  "STRATA_PCIE_FRAC_DEFAULT": "old",
  "STRATA_PREFILL_CPU_SHARE": "0"
}

However, 0.1.45 fills sampling fields the request does not specify with the values the model card recommends (see "Versions We Measured, and What We Have Not Measured"). For a request with thinking off, even if you specify only temperature, presence_penalty gets the model card's recommended value (the 0.1.45 code fills each field the request did not specify, one by one, with the model card's recommended value). So the three env settings alone do not give the same output as the 0.1.40 series. The 0.1.40-series default is the state with no sampling block in the settings file. To match it, also specify temperature 0 and presence_penalty 0 in the request. At temperature 0 the most probable candidate is picked every time, so top_p and top_k do not affect the result. You can also put the temperature and presence_penalty values in the sampling block of the settings file, but if the Sampling settings in the web UI are shared with other apps through "Use for other apps too", the web UI settings take priority. We have not checked whether the output with these two values (temperature and presence_penalty) added to the revert settings matches the 0.1.40 series.

Models Strata Can Run, and System RAM Guidelines

From 0.1.44, in addition to the existing quantizations of Qwen3.8-Flash-Next, you can choose Unsloth quantizations, NVFP4, and a different model, Qwen3.6-35B-A3B, in setup. The version that added each model, the system RAM guidelines and the official notes are in the "Models selectable in Strata" table (main ones only; existing quantizations such as Q2_0 and IQ3_XXS are left out).

As for which to pick, the official setup recommends one based on how much system RAM you have, so you can simply start with the setup's recommendation.

On how close each quantization's output is, the 0.1.44 release notes give, from official measurements at 4,995 positions, the share of positions where the chosen next token matched Q8_0: 94.6% for UD-Q6_K_XL, 93.1% for UD-Q4_K_XL, 88.9% for UD-IQ4_XS, 87.7% for IQ3_S, 84.5% for IQ3_XXS and 80.6% for Q2_0. These are official measurements; we have not compared output quality across all quantizations.

Which of the models that run on the 0.2 series (Gyro, the Qwen3.8-Flash-Next Coder, DeepSeek V4.1-Flash and others) to choose now, based on your system RAM and 12GB or 16GB of VRAM, is covered in "Strata Models and Memory Requirements".

What Changed in 0.1.45 (Released October 17, 2026)

The core of 0.1.45 is an update to Qwen3.6-35B-A3B. According to the release notes, Qwen3.8-Flash-Next's output is the same as 0.1.44.1, and it was byte-for-byte identical in consistency checks on the GPU machines the developers tested (CUDA sm_60 and sm_86, AMD gfx1201, Intel A750 and Mac M4). The tested machines do not include RTX 40 or 50 series cards. However, according to the official docs/DETAILS.md, the default that fills sampling fields the request does not specify with the model card's values arrived in 0.1.45 (see "Versions We Measured, and What We Have Not Measured"). What kind of model Qwen3.6-35B-A3B is, including how this MoE, multimodal model works and how to run it locally, is covered in our Qwen3.6-35B-A3B explainer.

0.1.45 brought three changes to Qwen3.6-35B-A3B: it can read images, it can process several requests at the same time, and it got faster.

On speed, the release notes' heading says "up to 40% faster" but does not say which figure that refers to. The numbers listed in the speed section include generation going from 83.2 to 117.8 tokens per second (1.42x) and prompt processing for a 4K input going from 3,453 to 6,220 tokens per second (1.80x) for Qwen3.6-35B-A3B UD-Q4_K_XL on a 32GB Radeon AI PRO R9700. In the same official measurements, on an RTX 3060 12GB, which cannot fit the model in VRAM and runs it together with system RAM, generation was +2% and prompt processing +3%.

Up to 8 requests can now be processed at the same time. According to the release notes, on cards where not all experts fit in VRAM, the slots for concurrent processing use VRAM that would otherwise hold experts, so a single request runs 4–11% slower, and the combined speed of concurrent processing is only 1.0–1.15x that of processing one request at a time with speculative decoding. These are the official examples for the RTX 3060 12GB, RTX A4000 16GB and Tesla P100 16GB; setup recommends 2 requests at a 32K context on 16GB, and 4 requests at 8K on 12GB (none at 32K). The official docs say this matters when you run several users or agents at the same time and does nothing for a single chat.

For images, setup asks whether you want to use images with Qwen3.6, and if you do, it downloads the vision projector file (mmproj, 0.9GB) and writes --vision into the settings. Also, from 0.1.45, on NVIDIA cards with less than 24GB of VRAM, answering yes to images in setup makes reading images on the CPU the default. According to the release notes, this takes 4–6 seconds per image, reads up to 300 tokens (--vision-tokens 1024 reads in more detail), and takes nothing from the GPU. Reading on the GPU (--vision gpu) takes about 1.4GB of the VRAM available for experts, and in official Linux measurements generation speed dropped 3–5% on 16GB cards. A report of a 35–60% drop on a Windows RTX 4080 SUPER could not be reproduced by the developers. Settings you have already created are not rewritten by this change.

The default chunk size for reading Qwen3.6-35B-A3B input also got bigger, so for long inputs the output differs slightly from the previous chunk size. Inputs shorter than the chunk are unaffected, and --prefill 512 goes back to the previous chunk size.

What Changed in the 0.2 Series (Added November 1, 2026; 0.2.10 Added November 4)

After 0.1.45, 11 entries were published on the GitHub release list, from 0.2.0-beta on October 19, 2026 to 0.2.9 on October 31 (dates are the publication dates on the release list, in UTC; we checked the list on November 1, 2026). The release notes for 0.2.1, 0.2.4 and 0.2.7 also have entries added for later fix versions (0.2.1.4, 0.2.4.2, 0.2.7.1 and others). This section picks, from these 11 release notes, the changes that matter to people using 12GB or 16GB VRAM GeForce cards on Windows; it is not our measurement. On November 4, 2026, we added the changes in 0.2.10 (released November 2, UTC) to the two lists and the warning below, to the paragraph on 0.2.9 parallel requests, and to the paragraph on upgrading to the 0.2 series (the sentence beginning "The 0.2.8, 0.2.9 and 0.2.10 release notes") (including 0.2.10, that makes 12 release notes). To the last paragraph of the section we added a summary of our 0.2.10 results measured in a separate article (this is the only paragraph in this section that mentions our measurements, and all of them come from the separate article; in the 0.2.10 items, "drafting speed and how to revert" refers to those results).

From 0.2.0-beta, Strata is split into three parts: the desktop app, the Terminal (for using Strata from the command line) and the engine (the part that drives the graphics card). In the 0.2 series, you update with strata update on Terminal 0.2.1.3 or later, or with Update in Settings in the app. According to the 0.2.3 release notes, the Terminal from 0.2.0-beta to 0.2.1.2 cannot switch to a new version with strata update, so you run the install command again (0.2.3 says this command keeps models and settings, but that describes reinstalling a 0.2-series Terminal). The 0.2.8, 0.2.9 and 0.2.10 release notes describe how to upgrade when the Terminal is older than 0.2.0 (they give 0.1.45.x as an example): run the one-line install command again. On Windows, that line is irm https://github.com/Niko1221/Strata/releases/latest/download/install.ps1 | iex. It is a command you type in PowerShell; it fetches install.ps1 from the latest release on the official GitHub and runs it on the spot (it does not pin 0.2.10; you get whatever version is the latest when you run it). The 0.2-series release notes do not say whether this applies if you installed 0.1.45 with git or from a zip, or how settings carry over when you reinstall. For updating Strata installed from source, the 0.2.0-beta release notes also list UPDATE.bat. From 0.2.5, the desktop app's Windows installer became a single file that no longer includes the engine; the first time you start the app, it offers to download the engine that matches your graphics card.

The main additions in the 0.2 series are as follows.

• 0.2.0-beta: The desktop app (with a coding agent that can either ask before acting or act freely, web search, a choice of which graphics card to use for models, and more) and the Terminal's strata connect (which writes and checks settings for OpenCode, Codex CLI, Claude Code and others) were added. Image reading is on by default on NVIDIA and AMD cards, and on cards with less than 24GB of VRAM images are read on the CPU (card memory is not used). A problem where Gyro-S returned empty or meaningless answers on RTX 50 series cards was also fixed.
• 0.2.2: You can now give each card a Main, Helper or Off role. With several cards, a card with 8GB of VRAM or less sitting alongside other cards is set to Off from the start.
• 0.2.4: DeepSeek V4.1-Flash runs in the Terminal (in the desktop app from 0.2.5). The official target is a PC with one 12GB VRAM card and 46–64GB of system RAM, keeping frequently used experts in system RAM and reading the rest from the SSD. On disk, the three official sizes need 239–274GB. The 0.2.4 release notes give the output on a 12GB card as 4–8 tokens per second, while the measurement table in the same release notes gives about 5 tokens per second on an RTX 5070 12GB and about 8–10 on an RTX 3060 12GB, and says it is usable for chat but slow for long agent tasks. They also say that on Windows RTX 30 series cards it was built but not run.
• 0.2.9: The Unsloth 1-bit set for DeepSeek V4.1-Flash (UD-IQ1_S and UD-IQ1_M, 241GB and 258GB downloads) can be chosen in setup and in strata launch (the default set is unchanged). As of 0.2.9, the developers had not tried running it on Windows either (see the warning below).
• 0.2.10 (Update, November 4, 2026): ISTA-DAS Coder, a code-oriented version of DeepSeek V4.1-Flash, was added (a different model from the Qwen3.8-Flash-Next Coder of 0.1.16 on this page) (the model file is 72.1GB; on a PC without the DeepSeek files, it also downloads the 110.6GB n-gram table shared with the other DeepSeek sets and an 8.0GB draft model, for a 191GB download in total; on a PC that already has the n-gram table, it is 80GB). The developers have not yet run ISTA-DAS Coder on Windows NVIDIA cards (what they checked on a Windows RTX 5070 12GB was Qwen3.8 startup and the like; see the warning below). For Qwen3.8, a new split was added that shares the contents of each layer across all cards (different from the existing layer split, which assigns layers to each card). The developers use it automatically only in the Linux Terminal, and only when conditions line up, such as exactly two NVIDIA cards (CUDA architecture 8.6 or 12.0) or four Radeon AI PRO R9700 cards with all experts fitting in card memory; in that case drafting uses MTP and the MTP draft layer (5.2GB) is downloaded. The desktop app in 0.2.10 still uses the layer split. It has not been tested with two GeForce cards on Windows.

The main default changes affecting the speed and output of 12GB and 16GB VRAM GeForce cards are as follows (selected from the release notes; not a complete list). All numbers are official measurements and cannot be used to predict speed on your own machine.

• 0.2.0-beta: The heading says the defaults for NVIDIA 12–16GB cards were made faster, but the NVIDIA generation defaults that come with numbers are the settings for RTX 30 series and RTX A series (sm_86) and for sm_60 cards such as the Tesla P100; on an RTX 3060 12GB, generation went from 60.36 to 66.52 tokens per second (+10.2%) (the model and quantization are not given in the relevant line of the release notes). The developers say the answers are the same as in 0.1.45. RTX 40 and 50 series cards are not mentioned in this item.
• 0.2.5: On PCs with 16GB of VRAM or less, a speed-first setting (Faster) that cuts the number of experts DeepSeek V4.1-Flash uses per token from 6 to 5 became the default. To use all of them, add --full-quality in the Terminal or choose Full quality in the app.
• 0.2.7 and 0.2.8: In 0.2.7, on NVIDIA cards with 13GiB of VRAM or less, a setting that makes Qwen-family engines favor experts already on the card became the default (when the developers compared Qwen3.8-Flash-Next IQ3_XXS on an RTX 3060 12GB against the same build with the setting off, in 5 pairs, generation speed rose 15% for a story answer and 37% for a code answer). In 0.2.8 this setting was taken out of the defaults for RTX cards with 12GB of VRAM or less. The developers say this is because it was linked to text repeating in long sessions. If you change nothing, expert selection on these RTX cards is the same as in 0.2.6. To get the speed back, the developers suggest turning on "Faster answers on 12 GB NVIDIA cards" under Speed in Native engine settings on the app's Models page, or starting with strata launch --set STRATA_ROUTE_PRIOR=1.5. 16GB VRAM cards were not covered by this expert-selection default in either 0.2.7 or 0.2.8.
• 0.2.7: For RTX 40 series cards, a tuning table for matrix calculations on quantized weights is now included by default. The developers say the output is bit-for-bit identical to before. The release notes give no speed numbers for RTX 40, and the developers do not have an RTX 40 card, so the table is based only on the reporter's measurements.
• 0.2.10 (Update, November 4, 2026, default drafting): For Qwen3.8 (including the Unsloth files and Gyro), when the drafting setting is Auto, on cards the engine supports, the draft component used for speculative decoding changed from the MTP draft layer to DFlash2. Speculative decoding here is the mechanism in which a small draft guesses the upcoming tokens and the main model checks them; where this page says "speculative decoding (MTP)" or "MTP enabled", the draft component is the MTP draft layer. The support the developers list is CUDA architectures 8.6, 8.9, 12.0, 12.1 and others, which on GeForce corresponds to the RTX 30, 40 and 50 series (this mapping is ours; the RTX 20 series is not included). This is the range for which DFlash2 is included in the engine; the release notes contain no statement that the developers checked it on an RTX 40 series (8.9) card. DFlash2 is small, about 0.7GB (the developers say the card memory use reported by the engine is 625MiB). When running with DFlash2, it does not download the MTP draft layer (a 5.2GB file). This 5.2GB is the download size, not a difference in card memory use. On the first start it downloads about 1.2GB and builds the draft file on the PC. DFlash2 handles only one request at a time, so unless you choose a number, the desktop app loads the model to accept requests one at a time (the 0.2.10 release notes say the 0.2.9 app automatically allowed up to 4 with MTP when no number was chosen; which OS this refers to is not stated). To accept several at once, choose MTP or set the number in Expert mode. The developers say that even on Auto, MTP is chosen when the number of concurrent requests is 2 or more (--parallel or --batch in the Terminal), when the engine does not include DFlash2, for models other than Qwen3.8, and with the split that shares layers across all cards in the list above. When several cards are used with the existing layer split rather than the shared-across-all-cards split, Auto runs on DFlash2 alone. What the developers' tests (16 cases) confirmed is that the output tokens are the same as without drafting, not the speed.
• 0.2.10 (Update, November 4, 2026, drafting speed and how to revert): The developers' speed comparison ran Qwen3.8 on one card, alternating with MTP on the same engine and files. On the RTX PRO 5000, a professional card of the same generation as the RTX 50 series (VRAM amount not stated), IQ3_S generation speed rose about 6% for short answers (with the app's normal sampling settings) and about 1% for long answers of about 2,000 tokens (settings not stated). On other cards the results range from a gain of about 12% on Strix Halo (short answers with UD-Q4_K_XL) to 2.6% slower on the Intel Arc A750. The developers do not give a DFlash2-versus-MTP comparison on 12GB or 16GB VRAM GeForce cards (we compared them on an RTX 5080 and an RTX 5060 Ti with 16GB of VRAM and wrote the results in the last paragraph of this section (a summary of the separate article's measurements); we have not measured this DFlash2-versus-MTP comparison on 12GB VRAM cards either). To go back to the previous drafting, start with strata launch --drafting mtp in the Terminal, or choose MTP on the Models page in the desktop app. If the MTP draft layer is not on disk, though, it runs on DFlash2 and says so.
• 0.2.10 (Update, November 4, 2026, when VRAM runs short): When VRAM runs short, it now moves work off the card in stages instead of shrinking the context or the number of concurrent requests. In order, it shrinks the conversation memory kept on the card, removes the MTP draft layer, reduces the space used for prompt processing, and finally puts the output part in system RAM. The developers say generation becomes about 3 times slower at this last stage. This applies to discrete graphics cards (unified memory such as Mac or Strix Halo is excluded); the official tests used one card, and behavior with several cards is not described. In the item saying 8GB cards can now start with a 128K context, the developers say 12GB cards are unchanged, and they say nothing about 16GB cards.

The release notes say that the new defaults introduced in 0.2.9 for parallel requests and for Qwen3.8 prompt processing are Linux-only on NVIDIA cards, and that these two do not change on Windows NVIDIA cards. In 0.2.10, when Auto selects DFlash2 for Qwen3.8 and you do not choose a number, the desktop app accepts requests one at a time (see the 0.2.10 item above; update, November 4, 2026). This concerns the number the app picks automatically when you do not choose one, and the release notes do not make clear whether it is the same thing as the 0.2.9 parallel-request default in this paragraph.

On output changes, according to the 0.2.7 release notes, the defaults changed in 0.2.7 can be reverted to the 0.2.6 behavior all at once with STRATA_DEFAULTS=026 for Qwen or DS4_DEFAULTS=026 for DeepSeek (values you set yourself take priority over this). In 0.2.8, accepting tool calls that the model wrote slightly malformed, as long as the tool was declared in the request, became the default; to go back to the 0.2.7 behavior, write "tool_call_recovery": false in the model's run settings. The 0.2-series release notes do not give a setting that reverts everything to the 0.1.45 behavior.

This is not a measurement on this page, but we measured the 0.2 series in a separate article: Qwen3.8-Flash-Next (IQ3_S and Gyro) on Strata 0.2.3.1 and DeepSeek V4.1-Flash on 0.2.4.1, with results for a 12GB VRAM RTX 4070 SUPER and 16GB RTX 5060 Ti and RTX 5080 cards, in Strata Models and Memory Requirements. That article was published after we made the "Versions measured in our articles" table on this page, so it is not in the table. That article did not measure 0.2.5–0.2.9 either; for 0.2.10, we only added a DFlash2-versus-MTP drafting comparison on November 4, 2026 (Windows; the RTX 5080 and RTX 5060 Ti both have 16GB of VRAM; IQ3_S was measured on one RTX 5080, one RTX 5060 Ti and two RTX 5060 Ti cards, and Gyro-S on one and two RTX 5080 cards; 12GB VRAM cards were not measured). The method was to stop other processes using the cards or system RAM and alternate starts with drafting set to Auto and starts with --drafting mtp, checking in the engine log which draft was used. For long answers, we sent one Japanese and two English requests with a 2,048-token limit and repeated this 2–3 times, restarting each time; for short answers, we sent three requests at each of three input lengths with a 256-token limit and repeated this 3 times, restarting each time. Both were at temperature 0 with thinking off, and the speeds here are generation speed (output tok/s, not including prompt processing), the median of the values the engine reported. The detailed conditions are in that article's "Update, November 4, 2026 (our measurements)" section. For long answers, all three single-card configurations showed nearly the same speed for DFlash2 and MTP (medians within 5%). In the two-card layer split, IQ3_S was nearly the same for long answers, but Gyro-S alone was slower with DFlash2: less than half of MTP's speed for long answers, and 20–30% slower for short answers too (every two-card start showed a warning that the last RTX 5080 had 0–73MiB of free VRAM, but the MTP runs did too, so we do not know why it was slower). Starting IQ3_S on one RTX 5080 with --parallel 2 in the Terminal gave MTP even on Auto (the pre-start plan display still said DFlash2), and long answers sent one at a time ran at 41.6 tok/s, about 40% of the speed of an MTP start without --parallel (102.9 tok/s) (this configuration is from a single start; we did not measure the total when two requests were sent at the same time). Since it was this much slower than the same MTP start, we do not read it as an effect of the draft switch. We have not separated whether that is because the slots for concurrent requests took VRAM that would hold experts, or because handling several slots is itself slow.

List of Changes by Version

The "Changes by version" table lists only the changes, from the official Strata release notes (0.1.0–0.1.45), that matter to people using 12GB or 16GB VRAM GeForce cards on Windows; it is not our measurement. Most fix versions (such as 0.1.40.3) and changes that concern only AMD, Intel, Mac or multiple GPUs are left out, and release dates are the dates on the GitHub release list (UTC). The numbers in the table are official measurements, many of them taken on the developer's RTX 5070 12GB PC, so they will differ on your GPU.

For working with long Japanese documents, the relevant changes are in 0.1.27 and 0.1.13. 0.1.27 raised generation speed when outputting Chinese, Japanese and Korean; when the developers measured on their PC with an RTX 5070, Q2_0 and temperature 0, Japanese output went from 63 to 72 tokens per second. 0.1.13 roughly doubled the speed of reading long inputs (prompt processing tok/s) (the total time until the first character appears does not necessarily shrink by the same ratio); in official measurements on an RTX 5070 12GB with 64GB of system RAM, reading a 32K-token input with Q2_0 went from 572 tokens per second on 0.1.12 to 1,290 tokens per second. Generation speed is unchanged.

Notes on Reading the Speed Figures in the Release Notes

The speed figures in the release notes were measured on the developer's own PC, and the GPU, OS and model quantization used differ from version to version. Many of the NVIDIA figures were measured on the developer's RTX 5070 12GB PC (Windows, Ryzen 5 7600, 64GB of system RAM). The 0.1.40 release notes say the developer has one RTX 5070 and no second card.

The release notes also contain many figures measured on Linux with an RTX 3060 12GB, RTX A4000 16GB and Tesla P100 16GB. The 0.1.40.2 table labels the RTX 3060 12GB as Linux and the RTX 5070 12GB as Windows.

Some changes happened only on Linux. The processing made default for NVIDIA on Linux in 0.1.43 slowed generation on desktop GPUs (reports of -21% on an RTX 5070 Ti and -19% on an RTX 5060 Ti), and 0.1.43.1 removed it from the defaults on all machines. According to the release notes, this processing was never the default on Windows, so Windows was not affected.

So the figures in the "Changes by version" table offer clues about what changed between versions, but cannot be used to predict speed on your own GPU. You can check your own speed with BENCH.bat.

Versions We Measured, and What We Have Not Measured

The Strata versions measured in our 0.1-series Strata articles and on this page are in the "Versions measured in our articles" table (separate articles that measured the 0.2 series are not in the table; see the last paragraph of "What Changed in the 0.2 Series"). In the range covered by our earlier measurements in the first row of the table (not a measurement on this page), 0.1.31, 0.1.35 and 0.1.39–0.1.41, we could not say there was a speed difference between versions. Comparing 0.1.41 and 0.1.45 on this page, a difference in generation speed appeared (the 0.1.45 side also includes the difference in sampling defaults).

In the earlier test in the first row of the table (Qwen3.8-Flash-Next on 12GB and 16GB of VRAM), we measured Q2_0 on October 3, 2026, starting Strata 0.1.31 and 0.1.35 alternately on the same night (not a measurement on this page). By the median of three runs at each length, prompt processing for a 32K input was 3,151 tokens per second (0.1.31) and 3,199 tokens per second (0.1.35) on the RTX 5080, and 1,412 and 1,415 tokens per second on the RTX 5060 Ti, almost the same. Generation varied by about 20% even on the same version when restarted, so we could not say there was a speed difference between versions.

In results from the same series of tests on October 6 and 9, 2026, measuring IQ3_S on one RTX 5080 with a 262,144-token context limit on Strata 0.1.39, 0.1.40 and 0.1.41, generation also swung widely when the same version was restarted, so we could not say there was a speed difference between versions either.

Speed of 0.1.41 and 0.1.45 (Measured October 18, 2026)

On October 18, 2026, we measured Qwen3.8-Flash-Next IQ3_S on Strata 0.1.41 and 0.1.45, starting the two versions alternately three times each, using an RTX 5080 and an RTX 5060 Ti (both 16GB of VRAM) one card at a time. The PC was Windows 11, i7-14700F and 96GB of system RAM; the context limit was 65,536 tokens, KV was int8, MTP enabled, thinking off, and the output limit 256 tokens (the length actually generated varied with input length and version). The settings-file options were the same for both versions, and everything else was left at each version's defaults. The GPU to use was set to a single card in the settings file, and on every start we checked the GPU name in the engine log and that the other card's VRAM use had not gone up. Before each start we used nvidia-smi to check that no other process was using that card, and after stopping it we checked that the process had exited and VRAM had returned to about the pre-start level before starting the next run.

The request concatenated source code and documents from the Strata repository up to the input length and asked, in English, for an explanation of what the last file does and a diff for one improvement; it was sent at temperature 0. Speeds are the values reported by the Strata engine. On each start we measured three times at each input length and used the median as that start's value. These three requests were not identical: to keep the prompt from being skipped as a continuation of the conversation, each began with a different identifier, and the length was readjusted from the previous run's token count. As a result, the first request at each length was about 1,000 tokens at 1K and about 4,670 tokens at 4K, a different length from the second and later requests. The way the requests were built and the files they were built from were the same for both versions. The results are in the "Generation speed of 0.1.41 and 0.1.45" table.

The values in the table are medians of three starts, with the slowest and fastest of the three in parentheses. On both GPUs and at every length, 0.1.45 generated faster in all three pairs, and the fastest 0.1.41 value was lower than the slowest 0.1.45 value. Prompt processing, on the other hand, barely changed between versions: for a 32K input it was 3,439 tokens per second (0.1.41) and 3,502 tokens per second (0.1.45) on the RTX 5080, and 1,113 and 1,117 tokens per second on the RTX 5060 Ti, within the range of variation seen when the same version was restarted.

The first 0.1.45 start on the RTX 5060 Ti did not get as far as measuring, so we redid it. The first 0.1.41 run on the RTX 5060 Ti and the redone first 0.1.45 run are included in the totals even though both flagged that another heavy process was running on the PC during measurement. Excluding these two runs gives the same conclusion: 0.1.45 generates faster and prompt processing barely changes.

Our RTX 5060 Ti is connected over OCuLink, and the PCIe speed Strata measured was 7.0GB per second (the RTX 5080 was 43–47GB per second, once about 32GB). Compared with a card in a regular slot, the slowdown from reading over PCIe is different. So for an RTX 5060 Ti in a regular slot, neither the generation values nor the gain from upgrading are necessarily the same as in this measurement.

0.1.45 fills sampling fields the request does not specify with the values the model card recommends (for Qwen3.8-Flash-Next with thinking off, top_p 0.8, top_k 20, presence_penalty 1.5 and so on). The official docs/DETAILS.md describes this default as starting in 0.1.45. Our requests specified only temperature 0, so on 0.1.45 presence_penalty and other fields got the model card's values. 0.1.41 does not have this default, so the output changes even for the same request. To remove presence_penalty from this difference, we set presence_penalty to 0 on both versions on the RTX 5080 and measured again, starting each version alternately three times. Generation went from 76.7 to 94.1 tokens per second at 1K, from 75.3 to 87.3 at 4K, and from 69.4 to 97.9 at 32K. At 1K and 32K, 0.1.45 was faster in all three pairs. At 4K, 0.1.41 was faster in the first pair, and the two versions' value ranges overlap, so under the matched conditions we cannot say there is a difference. We did not run the matched-presence_penalty measurement on the RTX 5060 Ti. Even with it matched, the output text differs between versions: the length generated for the 1K input was 256 tokens on 0.1.41 and 99 tokens on 0.1.45. The generation speeds also include the effect of this difference in text. The "Generation speed of 0.1.41 and 0.1.45" table compares the versions at their defaults, and the 0.1.45 side includes the difference in sampling defaults.

In the 0.1.45 logs, the two NVIDIA defaults added in 0.1.42 (the default that skips low-ranked experts that are not in VRAM without reading or computing them, and the default that re-decides the share read over PCIe by measuring the CPU) were active, and the share of experts read over PCIe during generation was lower than on 0.1.41. We did not measure 0.1.42–0.1.44, so we have not separated which version's change made it how much faster. 0.1.43 made generation faster on Windows in configurations that read experts that do not fit in system RAM from the GGUF file during generation. Our measurements on both versions used a configuration that loads all experts into system RAM at startup (46.84GiB in the log), so that fix does not apply.

We have not yet measured the following seven things.

• Upgrading from 0.1.40 or earlier to 0.1.45 (we compared 0.1.41 and 0.1.45)
• An RTX 5060 Ti in a regular slot, and PCs with less than 96GB of system RAM
• We did not measure 0.1.42–0.1.44, so we have not separated which version between 0.1.41 and 0.1.45 made generation faster
• 12GB VRAM cards, quantizations other than IQ3_S (such as Q2_0), and configurations using two cards together have not been measured on 0.1.45
• We have not run Qwen3.6-35B-A3B on Strata
• We have not tried 0.1.45's image support or concurrent requests
• Measuring the 0.2 series (0.2.0-beta to 0.2.10) under the same conditions as 0.1.41 and 0.1.45 on this page (separate measurements of 0.2.3.1 and 0.2.4.1, and a 0.2.10 DFlash2-versus-MTP comparison under different conditions, are in the "Strata Models and Memory Requirements" article)

When we measure these, we will add the results to this page and the relevant articles.

Summary

Strata releases a version almost every day, and in the 0.1 series the main changes that matter to people using 12GB or 16GB VRAM GeForce cards are 0.1.41–0.1.42, which changed the NVIDIA defaults, and 0.1.44, which added models. On our RTX 5080 and RTX 5060 Ti, upgrading from 0.1.41 to 0.1.45 made Qwen3.8-Flash-Next generation faster, while prompt processing barely changed. The 0.1.45 side, however, also includes the difference in sampling defaults, and on the RTX 5080, measured again with presence_penalty matched, we could not say there was a difference with a 4K input. We have also not separated which version's change made it faster. The core of 0.1.45 is the Qwen3.6-35B-A3B update, and the release notes say Qwen3.8-Flash-Next's output is the same as 0.1.44.1 (the machines the developers tested do not include RTX 40 or 50). From 0.1.45, however, sampling fields the request does not specify get the model card's values. To update, use UPDATE.bat for a git install, or extract the new zip and use START-HERE.bat for a zip install; coming from a git install of 0.1.40 or earlier, a one-time manual step is needed first. To make Qwen3.8-Flash-Next's output on 0.1.45 match the 0.1.40 series, you need temperature 0 and presence_penalty 0 in addition to the revert settings listed in "Versions Whose Output Changes Slightly After Updating, and the Settings to Revert Them".

Update, November 1, 2026: In the 0.2 series (up to 0.2.9), Strata split into the desktop app, the Terminal and the engine (the part that drives the graphics card). The update steps above are as of 0.1.45. The 0.2.8 and 0.2.9 release notes say that if the Terminal is older than 0.2.0 (such as 0.1.45.x), you run the one-line install command again, and for updating an install from source, the 0.2.0-beta release notes also list UPDATE.bat. The 0.2-series release notes do not say which of these applies if you installed 0.1.45 with git or from a zip. For Qwen-family expert selection on RTX cards with 12GB of VRAM or less, the default changed in 0.2.7 was removed in 0.2.8, so with nothing configured it is the same as 0.2.6. On PCs with 16GB of VRAM or less, a setting that reduces the experts DeepSeek V4.1-Flash uses became the default from 0.2.5. This page does not measure the speed of the 0.2 series.

Update, November 4, 2026: In 0.2.10 (November 2, UTC), on RTX 30, 40 and 50 series cards and some others (our mapping; there is no statement that the developers checked RTX 40), when the Qwen3.8 drafting setting is Auto and the engine includes DFlash2, the draft component changed to DFlash2 and the MTP draft layer is no longer downloaded (when the Linux Terminal uses the split that shares layers across all cards, it stays on MTP and downloads the 5.2GB layer). DFlash2 handles only one request at a time, so when no number is chosen the desktop app loads the model to accept requests one at a time, and with settings that accept two or more at once, MTP is used even on Auto. To go back to the previous drafting, start with strata launch --drafting mtp in the Terminal, or choose MTP on the Models page in the desktop app. If the MTP draft layer is not on disk, though, it runs on DFlash2 even if you choose MTP. If you upgrade from 0.2.9 and also use DeepSeek V4.1-Flash, run strata update again (in the app, press Update in Settings again). We have not measured 0.2.10 under the same conditions as 0.1.41 and 0.1.45 on this page (our comparison of DFlash2 and MTP on 0.2.10 in a separate article is summarized in the last paragraph of "What Changed in the 0.2 Series"). The UPDATE.bat procedure above fetches the latest version, so running it now may take you to the 0.2 series rather than 0.1.45.

The key points as of 0.1.45 are as follows.

• If you run Qwen3.8-Flash-Next IQ3_S on a 16GB VRAM card with 0.1.41: on our RTX 5080 and our OCuLink-connected RTX 5060 Ti (Windows, 96GB of system RAM), generation was faster on 0.1.45. The 0.1.45 side also includes the difference in sampling defaults, and we have not separated which version's change is responsible.
• We have not measured 0.1.45 on 12GB VRAM cards. The numbers in the release notes come from the developer's configuration and cannot be used to predict your own speed, so after upgrading, check your own speed with BENCH.bat.
• If you use Qwen3.8-Flash-Next on 0.1.42–0.1.44.1: the core of 0.1.45 is the Qwen3.6-35B-A3B update, and the release notes say Flash-Next's output is the same as 0.1.44.1. From 0.1.45, however, sampling fields the request does not specify get the model card's values.
• If you want to use Qwen3.6-35B-A3B: neither the developers nor we have tested Qwen3.6 on 0.1.45 on real Windows hardware.

In separate testing on Strata 0.2.10, we checked installation and basic use, including whether to start with the desktop app or the Terminal, starting, updating and uninstalling.

References

• Strata (GitHub)
• Strata Release List (GitHub)
• Strata v0.2.10 Release Notes
• Strata v0.2.9 Release Notes
• Strata v0.2.8 Release Notes
• Strata v0.2.7 Release Notes
• Strata v0.2.5 Release Notes
• Strata v0.2.4 Release Notes
• Strata v0.2.3 Release Notes
• Strata v0.2.2 Release Notes
• Strata v0.2.1 Release Notes
• Strata v0.2.0-beta Release Notes
• Strata v0.1.45 Release Notes
• Strata v0.1.44.1 Release Notes
• Strata v0.1.44 Release Notes
• Strata v0.1.43.1 Release Notes
• Strata v0.1.43 Release Notes
• Strata v0.1.42 Release Notes
• Strata v0.1.41 Release Notes
• Strata v0.1.40.2 Release Notes
• Strata v0.1.40.1 Release Notes
• Strata v0.1.39 Release Notes
• Strata v0.1.38 Release Notes
• Strata v0.1.36 Release Notes
• Strata v0.1.26 Release Notes
• Strata v0.1.3 Release Notes
• Strata v0.1.45 Installation Instructions docs/INSTALL.md (GitHub)
• Strata v0.1.45 Detailed Description docs/DETAILS.md (GitHub)
• Strata v0.1.45 serve/server.py (GitHub)
• Strata v0.1.45 setup.py (GitHub)