Strata 0.2.4 lets you run a 763-billion-parameter model on a 12 GB gaming PC
The open-source local AI engine Strata just pulled off something that sounds like a typo. Version 0.2.4 runs DeepSeek V4.1-Flash, a 763-billion-parameter model, on a machine with a single 12 GB graphics card and 46 to 64 GB of RAM. That's normally the domain of data-center GPU clusters. Here it's free, offline, and runs entirely on your own hardware.
Strata was built by a developer known online as Niko1221 on GitHub. The project sits at roughly 31,300 stars and 3,400 forks as of this week, which is remarkable for a one-person repo with a README and no marketing team. The headline of this release is not a new feature so much as a new size limit being pushed out.
How it actually works
The core trick is that Strata stops pretending your graphics card can hold an entire model. It never could. Instead it spreads the work across the whole machine: GPU, CPU, RAM and SSD all talking to each other in real time.
Strata describes it with a kitchen metaphor. Your 24,576-part model is a kitchen staff where each word you get back needs only about 10 of them. The GPU is the countertop, small but fast, keeping the most-used specialists ready. The RAM is the pantry, holding all the experts at once. The SSD is the archive, storing a large lookup table that gets read in only a handful of rows per word, so it can live on disk without slowing you down.
Technically that's dynamic expert paging with an adaptive expert cache on top of a mixture-of-experts design. It works on NVIDIA, AMD and Intel cards and on Windows, Linux and macOS. And unlike most software built with this much ambition, Strata ships with no telemetry. That's unusual.
The DeepSeek part
DeepSeek V4.1-Flash is genuinely enormous. It has 763.2 billion parameters and 384 experts per layer, with just 6 active per token. The architecture is a bit unusual too: 40 transformer layers split into two 20-layer halves, so it activates only about 8 billion parameters during input and roughly 16 billion during output despite the massive backbone. You also get a 1-million-token context window, native image plus text input, and an Engram conditional memory component of 196 billion parameters that the model reaches for sparsely.
Here's the catch you should read before downloading anything. DeepSeek support lands only in the Terminal, not the desktop app. The GUI stays at 0.2.3 and will get DeepSeek later. If you want the clicky buttons, keep waiting.
Because the model is so big, it runs on its own separate engine package called strata-dsv41. It sits beside your Qwen engine and never replaces it. When you pick DeepSeek, Strata downloads the package that matches your PC, checks the signature and file hashes, and installs it. There's a manual install path for people who'd rather stay offline.
The numbers, at least
DeepSeek can't run at full precision on 12 GB of VRAM, so ISTA-DASLab at Austria's Institute of Science and Technology made three heavily compressed versions using two methods they built, GSQ and RCO. The point of those methods is giving each weight tensor its own quantization type under a total size budget.
The smallest set, IQ1_M, is 1.75 bits and a whopping 239 GB to download. Quality takes a hit, roughly 21 percent worse perplexity. It handles code and agent work decently, roughly 9 to 10 percent off, but plain English prose suffers a lot, closer to 53 percent worse. The middle set, IQ2_XXS, is 2.5 bits of compression, 257 GB, and roughly 15.5 percent worse on perplexity. IQ2_XS tops the quality chart at 2.25 bits and 274 GB, landing about 7.3 percent off. The Engram table, roughly 111 GB, comes in all three downloads as one shared file.
Strata's own card notes that IQ2_XXS matches the base model across AIME25, GPQA-Diamond and LiveCodeBench v6. That's the set I'd lean toward, though the 257 GB download will eat your drive.
Performance on real hardware tells a mixed story. On an RTX 5070 with 64 GB of RAM you're looking at about 5 tokens per second for code, while prompt reading hits 231 tokens per second at 8K context. An older RTX 3060 with 46 GB of RAM actually does a bit better for output, roughly 8 to 10 tokens per second, but prompt reading trails at 149 tokens per second.
On AMD hardware the numbers look better at first glance. A single Radeon AI PRO R9700 does about 11 tokens per second. Four of them together reach roughly 31 tokens per second, up to 55 or 69 with DSpark turned on. But that's a $2,000-plus rig, not the $600 build the pitch implies.
Under the hood
A few things changed this round that matter more than the press release suggests. Strata now keeps its busiest experts in RAM instead of memory-mapping the files, which roughly doubled decode speed on the tested 5070 PC, moving it from about 1.8 to 2.2 tokens per second up to 4.3 or 4.9. That's a real win for the slow part.
Long prompts read faster now, too. Instead of working through 16 tokens at a time, the engine reads big chunks layer by layer. A 200-token prompt jumped from 3.6 to 6.4 tokens per second. And there's a new long-prompt skip for inputs over roughly 3,700 tokens, saving about a third on a 16K prompt. Strata claims the model's top choice stayed unchanged in 99.5 percent of compared positions, which is fair enough for a heuristic.
One correction is worth flagging. The initial 0.2.4 Terminal package was missing the DeepSeek preparation scripts, so setup stopped partway through at "Preparing your model." That rolled out as an Update 0.2.4.1, and new installs get the fix automatically. If you already tried to set it up, run strata update.
What you actually need
To run DeepSeek at all you need a graphics card with 12 GB or more and somewhere between 239 and 274 GB of free disk space, depending on which quant you pick. RAM-wise, 46 GB is the smallest tested configuration and 64 GB is the comfortable one. Strata warns you if you fall short but won't stop the install, so I wouldn't try this on 32 GB.
There are limits worth accepting. Output on 12 GB cards runs about 4 to 8 tokens per second, which is fine for chat and slow for long agent runs. Your SSD speed sets the ceiling there, so a sluggish drive drags every number down. macOS and AMD Strix Halo don't support DeepSeek yet. And because some word choices are near-ties, you might get a slightly different answer if you run the same prompt twice.
Strata did ship with a nice bit of paranoia baked in. When you install manually, it refuses anything that isn't genuinely the DeepSeek engine, doesn't fit your system, or fails its signature and hash checks. That's the kind of thing you want from software that talks to your local coding agents.
The bigger picture
Strata has always been about two models. Qwen3.8-Flash-Next, a 125-billion-parameter backbone, was the original draw and still runs on machines with as little as 32 GB of combined RAM and VRAM. DeepSeek is the newcomer proving the architecture scales to something an order of magnitude bigger.
The whole thing spawned a small third-party ecosystem. ISTA-DASLab does the heavy quantizations. agentionai, UkisAI and Unsloth all contribute variants and a draft model. Strata itself is built on parts of llama.cpp and ggml under the MIT License, which also means no account, no subscription, and no cloud account required.
It's a rather expensive pile of hardware to chase the headline numbers, though the small-form-factor appeal and the privacy angle pull it the other way. On a single 12 GB card this is usable, if unhurried. Four AMD cards and you're basically competing with a small API.
How to get it
New installs are a single command:
# Linux / Mac curl -fsSL https://github.com/Niko1221/Strata/releases/latest/download/install.sh | sh # Windows (PowerShell) irm https://github.com/Niko1221/Strata/releases/latest/download/install.ps1 | iex
To pull DeepSeek specifically, run strata launch --model ist-das-2.00bpw, which grabs the 257 GB IQ2_XXS set Strata recommends. If you're updating from 0.2.3, run strata update in the Terminal. Your Qwen engine stays exactly as it was, byte for byte, since DeepSeek lives in its own package.
For offline setups you can grab a strata-dsv41 tarball from the release page, verify it against SHA256SUMS.txt, and pass it with --dsv41-package. Everything from 0.2.3 is still on the release page too, so you won't lose the earlier files.
Head here to the GitHub release page for the downloads and detailed change log.
