A developer at a small UK company recently ran the full DeepSeek v4.1 Flash on a five-year-old gaming PC. The model's original weights total 510 GB. The test machine had an NVIDIA RTX 3060 with 12 GB of video memory and 64 GB of system RAM. The model has 763 billion parameters. The developer reported speeds of up to 7.4 tokens per second. The project had about 30 stars on GitHub at the time.

The most widely used engine for this setup, Strata, has over 37,000 GitHub stars. Many video demonstrations show DeepSeek running on 12 GB cards. Most of these demonstrations do not mention that Strata runs a compressed copy of the model, not the original release. On any card with 16 GB of memory or less, Strata also disables one of the six experts that the model normally activates for each token by default.

This article covers three ways to run DeepSeek on a 12 GB card. It describes the RAM and storage each route requires, the speeds reported by the developers and by independent users, and whether the compressed versions remain DeepSeek in practice.

Background: Why the Model Fits on a Gaming Card

DeepSeek v4.1 Flash 1017 was released on October 17. It is licensed under MIT. The model is one of the strongest open-weight models available for download. Its download size is 510 GB.

Two architectural features make local operation possible:

• Mixture of experts (MoE): The model has 40 layers with 384 experts in each layer. Only six experts activate for any given token.
• N-gram lookup tables: The model includes 196 billion parameters in N-gram lookup tables. Each token reads only a few rows from these tables.

Because most of the model remains inactive for any given token, the system can distribute the model across three storage tiers:

In this setup, the SSD becomes a working part of inference. One tester's drive read 2.2 TB during 19 minutes of use. That amount is about nine times the size of the model file. The same drive wrote only about 1 GB. The workload is read-intensive, not write-intensive, so the tester's drive wear risk is low.

Route 1: Strata

Strata is a free, open-source engine on GitHub. It runs a compressed version of DeepSeek created by Ista, a research lab in Austria.

Requirements

Strata's documentation describes configurations below about 40 GB of RAM as untested and slow.

Setup

Setup requires one command. The user specifies the model family and file. Strata downloads all required components and starts a local server.

Speed: Developer-Reported Figures

Strata's documentation reports the following results:

• RTX 3060 with 46 GB of RAM: 8 to 10 tokens per second
• RTX 5070 with 64 GB of RAM: about 4.7 tokens per second

The older card is faster. When most of the model resides outside the GPU, the GPU spends most of its time waiting for data from other components.

Speed: Independent Results

RAM capacity determines performance more than GPU capacity. With 64 GB, the model runs slowly but usably. With 32 GB, output arrives one word at a time.

Quality of the Compressed Files

Ista reports that its two-bit version retains 100% of the original model's average score across three difficult reasoning benchmarks. Two points qualify this result:

• The original model scores 100 on one of the three benchmarks. That column cannot show a loss.
• The file labeled "two-bit" is not uniformly two-bit. Half of its expert layers use a 1.75-bit format. The two-bit figure is an average.

Strata's team measured divergence from the original model directly. They compared word predictions of the compressed copies against the original over about 5,000 positions. Perplexity measures how surprised a model is by real text. Results:

Code and agent tasks showed single-digit drift, which is considerably smaller than the drift on prose.

On a 12 GB card, Strata's default fast mode also runs five experts instead of six.

Side-by-Side Test

AI Receipts is the only independent tester identified who compared the local copy with DeepSeek's cloud version on the same task. Both received the prompt: build a cart racing game in one web page.

• Local copy: Ran on an RTX 5070 with a 20,000-token context window. It produced 13,000 tokens in 2 hours and 6 minutes. The page ran without errors.
• Cloud version: Used DeepSeek's API.
• Grading: Two AI reviewers graded both games blind, out of 12 points. The cloud version scored 10. The local copy scored 2.

Each model ran once, with thinking disabled and fast mode enabled. The result does not prove that the local copy is broken. It does show a large difference on this task. At DeepSeek's off-peak price, 13,000 output tokens cost less than one cent.

Route 2: Prometheus

Prometheus is a Windows engine developed by Ryan Flavel, a developer who built it with AI coding assistants. The name is spelled with a V, the historical Roman spelling. It is also the name of a UK company, Magnus, which is spelled with a V.

Unlike Strata, Prometheus runs the original DeepSeek weights.

Why Not Run the Original Weights Directly?

The author measured plain, exact decoding of the full model on the test PC. The result was 2.14 tokens per second. That speed is too slow for practical use.

Compress, Then Correct

Prometheus uses a two-stage process:

1. Initial computation: Each token is first computed using the two-bit copy of the experts, as in Strata.
2. Confidence check: At every token, the engine checks the model's confidence. If the top two candidate tokens are closer in probability than a fixed margin, the engine discards the token and recomputes it with the original weights. The original weights are reconstructed from the two-bit copy plus a set of correction layers.

A small draft head also predicts several tokens ahead. The engine verifies these predictions in parallel.

The developer describes this as a student who answers most questions from summary notes and consults the full textbook only when two answers appear equally correct.

Requirements

The storage requirement exceeds twice the model size. Prometheus stores the original weights, the two-bit copy, and the correction layers side by side. A 2 TB SSD currently costs about $250.

Setup

• Step 1: Download 510 GB of model files.
• Step 2: Run a build that takes about 4 hours while it prepares the copies.

Speed

The developer reports a best-case speed of 7.4 tokens per second. The developer states that this figure does not represent a typical session.

The developer reports that these results are about 2.7 times faster than running the plain original weights. They match the Strata 64 GB results.

With a prompt of about 1,100 tokens, the first word took about 2 minutes to appear. Follow-up messages began in about 2 seconds. The initial delay affects workloads that load large amounts of context at the start of each task, such as coding agents that read a large portion of a code repository for every task.

Output Quality

The developer compared Prometheus with the same engine running only the original weights:

• Short tests (960 words): Output matched 99.17% of the time.
• Longer agent prompt: Output matched 95.9% of the time, counting every difference. This result falls below the developer's target of 97%.

The 99% figure measures agreement with the engine's own exact mode. It does not measure agreement with DeepSeek's reference code. The developer states that they have not yet run that comparison.

Limitations of the Evidence

The developer states that all results come from one machine, one model, and one family of prompts. As of the time of writing, no one has reported a clean installation on a second PC. The release archive has been downloaded 39 times. The repository's issues section contains a benchmark template for independent testing.

Route 3: llama.cpp

llama.cpp is the general-purpose route. Support for this model was merged into the main llama.cpp branch on October 25. Unsloth publishes compressed versions of the model with a setup guide.

For 12 GB cards, this route is not yet practical:

• Unsloth's guide states that its smallest one-bit version requires about 128 GB of combined RAM and VRAM.
• The guide describes 64 GB as "possible but slower" and does not provide a speed figure.
• No published main-branch result on a 12 GB card was identified.

The closest published result comes from a llama.cpp reviewer using an AMD R9 700 with an RTX 5060 and 128 GB of RAM. That configuration produced about 6.5 tokens per second for output and 31 tokens per second for reading. The reviewer described the reading speed as "somewhat disappointing."

Why llama.cpp Is Slower Here

llama.cpp maps the model file into memory and lets the operating system load sections from the SSD as needed. Strata tested this approach on an RTX 5070 system with 64 GB of RAM. It achieved 1.8 to 2.2 tokens per second. Strata's direct read method, which reads from the drive using its own approach, achieved 4.3 to 4.9 tokens per second.

When half of the model resides on the SSD, the method used to read the drive affects performance more than the GPU does.

Hardware Checklist

Ranked by impact:

1. System RAM: Determines which routes are viable.
   • 32 GB: DeepSeek on a 12 GB card is a long-running batch task, not an interactive chat.
   • 64 GB: Both Strata and Prometheus are viable.
2. GPU: Upgrading is unnecessary. The RTX 3060 is the reference card for both Strata and Prometheus.
3. SSD: Use a fast NVMe drive. SATA SSDs and hard drives are not suitable.
   • Strata: 257 GB free.
   • Prometheus: 1.1 TB free.
4. Strata file selection:
   • For code and agent tasks, the two-bit file is suitable.
   • For long-form writing, avoid the 1.75-bit file. It shows 53% drift on prose.
   • For output that requires maximum accuracy, enable full quality mode, which runs all six experts.
5. Background GPU load: Close other applications that use the GPU. Each gigabyte that other applications use must be supplied by slower storage.
6. Thinking mode: Strata enables DeepSeek's thinking mode by default. For short tasks, disable it. At 2 to 7 tokens per second, a model that generates 1,000 reasoning tokens before answering takes several minutes per response.

Recommendations by Hardware

For speed and accuracy on the full model, DeepSeek's API runs the original model faster than any local route in this article. The cost of the cart-racing test was under one cent.

Summary

DeepSeek v4.1 Flash can now run on a 12 GB GPU, provided the system has sufficient RAM and fast storage. Whether the result is still DeepSeek depends on the route:

• Strata runs compressed files. Its reported quality retention varies by task type. On the single independent side-by-side test, the local copy scored 2 out of 12 against the cloud version's 10.
• Prometheus runs the original weights through a verification process. Its reported output agreement is 99.17% on short tests and 95.9% on a longer agent prompt. Its results have not been reproduced on a second system.
• llama.cpp does not yet provide published results on 12 GB cards.