What Is Strata? How This Free App Runs Huge AI Models on a Gaming PC

A 125 billion parameter AI model running on a gaming PC sounds like it shouldn't work. With Strata, it does, as long as your PC has enough of the right kind of memory.

Strata is a free, open-source app, not an AI model. It downloads models and runs them on your own PC, so you can chat with them, write code with them and show them pictures without sending anything to a cloud service. What sets it apart is that it can run models much bigger than your graphics card's memory. Strata's main model is Qwen3.8-Flash-Next, and the versions of it that Strata recommends need 37.6 to 54.8GB of memory.

Once it's set up, Strata works a lot like the AI chatbots you already know, except everything happens on your own PC and there's no account to make. The desktop app for Windows, Linux and Mac gives you a chat window with your files and a live preview of any code it writes sitting right beside it.

The assistant in the app can do more than chat, too. It can read and edit files and run commands on your PC, and in its default mode it asks you before it changes anything, which we'd leave switched on. If you'd rather live in the terminal, there's a version you start with strata launch that does the same job and shows you the model's speed and memory use while it runs.

Strata also runs a small local server that speaks the same language as cloud AI services (OpenAI- and Anthropic-compatible APIs, if you want the technical name). That means coding tools like Claude Code, Codex CLI and OpenCode can use the model on your graphics card instead of one in the cloud, and running strata connect prints the setup steps for each of them.

You might be thinking this sounds a lot like Ollama or LM Studio, and you'd be partly right. Those are general apps for running lots of different models, and our Ollama vs LM Studio guide covers them. Strata only supports a few very large models, and everything about it is aimed at squeezing those onto ordinary desktop hardware. Its engine uses parts of llama.cpp and ggml, according to the project's how it works page, and Strata's own code is MIT-licensed.

The trick works because Qwen3.8-Flash-Next is what's called a mixture-of-experts model. Instead of one giant network, most of it is split into 512 smaller networks called experts, and for each token (roughly a word, or part of one) only 10 of them, plus one shared expert, actually do any work. According to its model card, that means only 6B of its 125B parameters are busy at any moment.

Don't worry, you don't need to remember any of that. What matters is that most of the model is sitting around waiting most of the time, so it doesn't all need to live on your graphics card.

So Strata splits the model three ways. Your graphics card holds the parts that run for every token, along with the KV cache, which is the model's memory of your conversation, and it fills any VRAM left over with the experts that get used most. Your system RAM holds every single expert, and your CPU works out any expert that isn't on the card. Your SSD holds a 28.8GB lookup table that the model reads a few rows from for each token.

That's why you can't add your VRAM and RAM together as if they were one big pot of memory. Your RAM has to hold every expert by itself, plus about 10GB for Windows and whatever else you've got open. A bigger graphics card will make Strata faster, but it won't lower the amount of RAM you need, which catches a lot of people out.

Strata doesn't make its own models. Its model guide covers three, and each comes in several compressed versions that trade a little accuracy for a smaller size.

Qwen3.8-Flash-Next is the main one, and it's the one the rest of this article focuses on, though Qwen still labels it an experimental preview. If that's too much for your PC, Qwen3.6-35B-A3B is the smaller option, with 35B parameters and 3B active per token. The model guide puts it at 32 to 52GB of RAM, and it runs on NVIDIA and AMD cards but not on Intel Arc or Mac.

Then there's DeepSeek V4.1-Flash-1017, which is the giant of the group. Its downloads run from 191 to 274GB, and because most of it can't fit in memory, Strata reads much of it straight from your SSD as it goes. You'll need a 12GB card, at least 46GB of RAM and an NVMe SSD for that one.

One thing worth knowing is that Strata's MIT license covers the app, not the models. Qwen3.8-Flash-Next uses the Qwen Community License 1.0, Qwen3.6-35B-A3B is Apache 2.0 and DeepSeek is MIT. The recommended ISTA-DASLab files are tagged Apache 2.0 but also say they inherit the base model's license, so check the model page before you use any of them for paid work.

Forget your graphics card for a minute and check how much system RAM you have, because that's what decides which version of Qwen3.8 you can run. These are the four versions Strata recommends first, according to its model guide.

If you've got 48GB, Q2_0 or IQ2_XS is your pick. With 64GB, we'd start with IQ3_XXS, because it leaves you room for a browser and everything else you normally have open, and only step up to IQ3_S if you're happy to close things down while it runs.

With 32GB of RAM your options shrink, but you're not out of luck. There's a Coder version of Qwen3.8 that keeps only the half of the experts chosen for programming, so it's weaker at everything else, and it runs on a 32GB PC with a 12 to 16GB graphics card. With a 24GB card, a 32GB PC can also run Q2_0 and IQ2_XS in a low-RAM mode that reads some experts from the SSD, though the docs say that's much slower. Qwen3.6-35B-A3B is the other choice at 32GB.

Honestly, if you're sitting on 32GB, we'd add more RAM before we'd buy a new graphics card for Strata. Our guide to how much RAM you need for local LLMs covers how capacity and speed trade off, and at the other end of the scale, Unsloth's higher-quality versions of Qwen3.8 need about 72 to 136GB.

As for graphics cards, the README lists GeForce RTX 20 to 50 cards, Radeon RX 7700, 7800 and 7900, RX 9060 and 9070, and the Radeon AI PRO R9700. The RX 6800 and 6900 are experimental, Intel Arc works on Linux, and Macs with Apple Silicon (M1 or newer) run the Mac app. The older GPUs guide recommends 12GB or more, though 8GB cards can run Qwen3.8 too, just more slowly.

You'll also want space on your SSD for the download in the table, plus about 6GB for a small helper model the app grabs on first start, or about 7GB if you want it to read pictures.

Speed with AI models is measured in tokens per second. The project's own release notes give a good idea of what to expect on short prompts. An RTX 3060 12GB on Linux ran Unsloth's 1-bit UD-IQ1_M version of Qwen3.8, which is smaller than anything in the table above, at 31 to 37 tokens per second (v0.2.11 notes). An 8GB Intel Arc A750 ran Qwen3.8 at 12.7 to 14.8 tokens per second with a 128K context (v0.2.10 notes).

DeepSeek is a lot slower on a desktop, because most of each token is spent waiting on the SSD and CPU. The README puts an RTX 3060 12GB with 46GB of RAM at 9 to 11 tokens per second on the 2.00 bpw set, measured on Strata 0.2.5.

Strata also speeds things up with a technique called drafting. Its DFlash2 and MTP options are small helper models that guess the next few words, so the main model can check several at once instead of writing them one at a time. The app picks one for your card automatically, and the v0.2.10 notes put DFlash2's gain over MTP at up to 12% on the cards they tested.

Just be ready for a wait the first time you run it. The v0.2.13 notes say a fresh install's one-time "Preparing your model" step took 398 to 406 seconds on a Windows PC with an RTX 5070, so that's nearly seven minutes, or roughly one coffee.

The desktop app is the easiest way in. Here's the Windows process from the project's install guide.

1. Make sure your graphics driver is current. NVIDIA's newest packages need driver 580 or newer, older NVIDIA cards get an older package, and Radeon owners follow a separate AMD guide.
2. Grab the newest Windows installer (Windows 10 or 11) from the releases page. It installs for your user account, so you don't need admin rights. The installer isn't code-signed yet, so Windows will throw up a "Windows protected your PC" warning first, and you'll need to click More info and Run anyway to get past it.
3. On first start, the app offers to download the engine built for your graphics card, which is the part that actually runs the model. If you already have that file, I already have the file installs it offline.
4. Pick a model and a storage folder. It suggests Documents/Strata/Models, so point it at another drive if that one's short on space. Hit download, and once it's done, you can start chatting.

On Linux, the same app comes as an AppImage, and Mac owners get a .dmg from the same releases page. Strata gets updated a lot, with nine releases between October 24 and November 9, 2026, but the app checks for updates itself, and you'll find them in its Settings.

If you'd rather skip the app, the README has a one-line install for the terminal version, using a PowerShell command on Windows and a shell script on Linux and Mac. Then run strata launch and follow the prompts. Adding --plan (for example, strata launch --family qwen --model q2_0 --plan) shows you what that model needs and what you're missing before anything downloads, which is handy before you commit to an 80GB download.

A big reason to run AI locally is keeping your stuff to yourself, and Strata's safety page says it sends no telemetry, its local server only accepts connections from your own PC by default, and an installed model runs without internet. Your chats are stored on your own drive.

A few things do leave your PC, though. Optional web search, tunnels and outside model services send data out when you turn them on, the app connects for model downloads and updates, and any API keys you save for outside services are stored unencrypted.

If you can't fit enough RAM in your desktop, you're looking at a different kind of machine. Strata supports AMD Ryzen AI Max (Strix Halo) and NVIDIA DGX Spark systems, where the CPU and GPU share one big pool of memory. On DGX Spark, the model just has to fit in that pool. On Strix Halo under Windows, you choose how much of the pool goes to graphics, so you're juggling two numbers: the graphics share and what's left for Windows.

The project's Strix Halo notes cover a GMKtec NucBox EVO-X2 with a Ryzen AI Max+ 395 and 128GB, split 64GB to graphics and 64GB to Windows 11 Pro. On a Strata 0.2.7 release candidate, it ran Qwen3.8 IQ3_S, the most accurate version in the table, with a 128K context at about 44 tokens per second in short chats (the median of three runs).

The CORSAIR AI Workstation 300 uses that same chip with 128GB of LPDDR5X, and up to 96GB of it can go to graphics, so it can give the model more graphics memory than the 64GB split in the project's test.

The NVIDIA DGX Spark with 128GB of unified memory can also work. The project's DGX Spark notes report about 45.5 to 46.5 tokens per second on Qwen3.8 IQ3_S with a 64K context, from one unit on Strata 0.2.7.1 (the median of four samples). It runs through the terminal on Linux, because there's no ARM version of the desktop app yet.

Those two tests used different versions and context lengths, so don't read them as a head-to-head. The bigger difference is how you'll use it. If you want the desktop app on Windows, we'd point you at the AI Workstation 300, and if you're happy living in a Linux terminal, DGX Spark is the one.

If you want to purchase a Gaming System that can run local AI while capable of playing games, take a look at our Vengeance System Catalog for your needs

If you want to spec out an AI Workstation capable of running Strata and local models take a look at Corsair Pro