How to run DeepSeek V4.1-Flash on a gaming PC with Strata

DeepSeek put V4.1-Flash-1017 on Hugging Face on October 17. On October 23, IST Austria's DASLab published 2-bit builds; they passed 890,000 downloads in three days. On October 24, Strata, the same tool that runs Qwen3.8-Flash-Next on a gaming PC, added DeepSeek support, and a day later put it in its desktop app. This is the hands-on version: what the model is, what your PC needs, which size to pick, what speed to expect, how to install it, and where it falls short.

What is DeepSeek V4.1-Flash?

DeepSeek V4.1-Flash-1017 is an open-weights mixture-of-experts model from DeepSeek with 763.2B parameters, a 1M-token context window and an MIT license. It has 384 routed experts in each layer and uses 6 of them for each token. About 196.6B of those parameters are two “Engram” lookup tables, which the model reads a few rows at a time rather than multiplying through, and that is part of why it can run with most of itself on disk.

The 1017 update improved its agent scores over the first V4.1-Flash. These are DeepSeek-reported numbers:

Those are numbers for the model as released. Everything below runs a 2-bit version, so read the quality section before you trust them on your own code.

What hardware do you need?

A 12 GB GPU, about 46 GB of RAM or more, and 239 to 274 GB of free space on an NVMe drive. Strata splits the model across your machine: as many experts as fit go in graphics memory, the rest are computed on the CPU from RAM, and the Engram tables are read from the SSD a few rows per word. That last part is why the drive matters. A slow disk slows every word, so keep the model files on NVMe, not a hard drive or a USB disk.

• GPU: 12 GB is the floor Strata and DASLab both point to. Strata's DeepSeek engine ships for NVIDIA (CUDA) on Windows and Linux, plus a Linux build for AMD's Radeon AI PRO R9700 and RX 9070; Strata notes the RX 9070 build is untested and that AMD engines hang under WSL.
• RAM: 46 GB is the smallest Strata measured; 64 GB is comfortable. Under about 40 GB, Strata calls it untested and slow, warns you, and still installs.
• Disk: 239 GB for the smallest set, 257 GB for the recommended one, 274 GB for the largest. The 111 GB Engram file and an 8 GB drafter are shared by all three.
• Mac: Strata's DeepSeek engine packages are for Windows and Linux only. There is no Mac build of the DeepSeek engine.

Our VRAM calculator and GPU guide only get you part of the way here: for this model, check your RAM and your free NVMe space first.

Which size should you pick?

Pick the 2.00-bit set (IQ2_XXS) unless you are short on disk. All three are official builds from IST Austria's DASLab, each one assigning a different precision to each tensor based on how sensitive it is:

Higher perplexity means the compressed model is further from the original; lower is better. DASLab's own model card says the 2.00 build matches the base model on AIME25, GPQA-Diamond and LiveCodeBench v6, reaching 100% of its task average, and the 1.75 build gives up 1.2 points. The 1.75 build keeps 98.7%, the figure Strata quotes for it. DASLab measured these at reasoning effort 50, while Strata defaults to high (75), so treat “almost no loss on those three tests” as the honest summary. Those are reasoning and coding puzzles, not long agent sessions in your repo.

How fast is it?

Roughly 4 to 10 tokens per second on a 12 GB gaming GPU, by Strata's own measurements. Here is what Strata reports:

Two things to read into that. First, the older RTX 3060 setup answered faster than the 5070 one. Strata does not break that down, but on a 12 GB card the engine keeps the experts it uses most in RAM and streams the rest from your SSD, so your CPU, RAM and drive matter as much as the card. Do not read it as a GPU ranking. Second, these are short-task speeds. At 4 to 10 tokens per second, a long answer with thinking turned on takes minutes, not seconds.

Strata 0.2.5 added a “Faster” mode that uses 5 of the model's 6 experts per word. It is the default on PCs with 16 GB of graphics memory or less, and Strata measured it 16% faster on an RTX 5070 for code and agent work, at a small quality cost. Choose “Full quality” if you would rather have all six.

How do you run DeepSeek V4.1-Flash locally?

Install Strata 0.2.5 or later, pick DeepSeek V4.1-Flash and the 2.00 size, and let it download. Strata's app has one installer per system and downloads the right engine for your graphics card on first start. The DeepSeek engine is a separate download that Strata fetches when you pick the model. If you work from a source checkout of Strata, the setup script takes the family and the size (with the installed Terminal, use strata launch instead):

$./setup.sh --family deepseek41 --model IST-DAS-2.00bpw

Before anything big downloads, you can ask Strata where the model would go on your machine without changing anything:

$strata launch --model ist-das-2.00bpw --plan

Downloads resume and are checked with SHA-256, and setup finishes by asking the model a 16-token test question. Loading takes a few minutes. If setup cannot place the dense weights on your card, it says so before downloading, so you find out early.

What about llama.cpp?

llama.cpp merged DeepSeek V4.1-Flash support on October 25, but Strata runs it with its own engine, and that is the setup with published numbers. Strata's strata-dsv41 engine is ported from Project Maya's DeepSeek engine and is a separate download from its Qwen engine. Mainline llama.cpp support is new; we have not seen published speed numbers, or confirmation that DASLab's files and their separate Engram file load on it, and DASLab's card still described llama.cpp support as missing when it went up. If you already live in llama.cpp, it is worth watching, but for a first run, Strata is the tested path.

How do you connect a coding tool?

Strata serves the model through the same API it uses for its other models: an OpenAI-compatible /v1/chat/completions endpoint and an Anthropic-style /v1/messages endpoint. It converts DeepSeek's own tool-call format into OpenAI tool_calls and Anthropic tool_use, so tools that expect either work. Thinking is on by default; send reasoning_effort: "none" to turn it off for quick answers. Our Qwen3.8-Flash-Next with Strata guide covers connecting tools to Strata in more detail.

Mind the context. Strata runs DeepSeek at 8,192 tokens by default, the size it was checked at; --context asks for more, untested. A coding agent's system prompt and tool definitions can take a large share of 8K before your code is even in it, so this setup suits focused questions and short tasks better than a long autonomous run across a big repo. In an agent tool, start in chat or Ask mode rather than a long Act run.

For Bodega One Code, add Strata as a Custom OpenAI-Compatible provider pointing at its endpoint; see BYOLLM. With air-gap mode on, Bodega One Code itself only talks to local addresses; note that Strata's own launcher checks GitHub and its update feed for engine updates. We have not benchmarked Bodega One Code with Strata's DeepSeek engine; it is the same endpoint any client uses, and that is all we are claiming.

What are the honest caveats?

It runs, but it is slow, short on context and heavy on disk.

• It is slow. 4 to 10 tokens per second is fine for a question and painful for a long agent run.
• 8K context by default. The model supports 1M, but Strata runs and checks it at 8K.
• One request at a time, no images. Strata's DeepSeek engine ignores parallel requests and vision for now.
• The disk bill is real. 257 GB for the recommended set, on NVMe.
• The scores are DeepSeek's, for the model as released. The 2-bit quality numbers above are Strata's and DASLab's own measurements.
• The speeds are Strata's. Nobody has published independent numbers yet, and the 3060 and 5070 results are not a like-for-like comparison.

When is the simpler choice better?

If you want speed or a long context, a smaller model that fits your GPU will serve you better day to day. On a 24 GB card, a dense model like Qwen3.8-27B or the new Nanbeige4.3-33B fits at 4-bit with room for context and answers much faster. If you have 32 GB of RAM rather than 64, Strata's Qwen3.8-Flash-Next setup is the lighter big-model option. For a fast small coding model on a 12 GB card, see our Mellum 2.1 guide, and for the weekly picture, What's new in local AI.

DeepSeek V4.1-Flash on Strata earns the setup when you want a 763B model on your own hardware and are willing to trade speed and disk for it. That it runs on a 12 GB card at all is the point. Just do not expect it to feel like a cloud model.

Sources

• DeepSeek V4.1-Flash-1017 model card (license, context, benchmarks): huggingface.co/deepseek-ai/DeepSeek-V4.1-Flash-1017
• DASLab GSQ-RCO 2-bit builds (sizes, parameters, quality): huggingface.co/ISTA-DASLab
• Strata's DeepSeek guide (hardware, speeds, install, API, limits): github.com/Niko1221/Strata
• Strata 0.2.4 to 0.2.6 release notes: github.com/Niko1221/Strata/releases
• llama.cpp DeepSeek V4.1-Flash support, merged October 25, 2026: github.com/ggml-org/llama.cpp/pull/31086