Running DeepSeek locally: hardware requirements for the R1 distills and the full model

Among DeepSeek's models, a home PC runs the small R1 distills: dense 8B to 32B Qwen and Llama models trained on DeepSeek-R1's outputs. ollama run deepseek-r1 downloads DeepSeek R1 0528 Qwen3 8B, which fits on an 8GB RTX 4060 at 8k. The 14B distill fits fully on a 12GB RTX 3060, and the 32B on a 24GB RTX 3090. The full DeepSeek-R1 and V3 are mixture-of-experts models with hundreds of billions of parameters, which CanRun does not calculate. DeepSeek V4 Flash 0731 is calculated: its MXFP4 file fits fully on a Mac Studio with M3 Ultra and 256GB, while an 8GB RTX 4060 with 32GB of RAM holds none of its files.

Which DeepSeek models run on a home PC

According to its model card, DeepSeek-R1, released in January 2025, is a mixture-of-experts (MoE) model with 671B total and 37B activated parameters and a 128K context, trained on DeepSeek-V3-Base. DeepSeek-V3, from December 2024, has the same 671B and 37B. The V4 series first came out as a preview: its card lists V4-Pro at 1.6T total parameters (49B activated) and V4-Flash at 284B (13B activated), both with a 1M context. In July 2026 DeepSeek released DeepSeek-V4-Flash-0731, the official V4 Flash, which comes with a speculative decoding module attached. CanRun calculates it as DeepSeek V4 Flash 0731, and a section below covers it. CanRun does not calculate R1, V3 or V4-Pro.

A distill is not a smaller version of R1. DeepSeek fine-tuned existing open models, among them Qwen2.5-14B, Qwen2.5-32B and Llama-3.1-8B, on samples generated by R1. In January it open-sourced six distills: 1.5B, 7B, 8B, 14B, 32B and 70B. In May 2025 it post-trained Qwen3 8B Base on the chain-of-thought of R1-0528, and the card says the architecture is "identical to that of Qwen3-8B". CanRun covers four distills: DeepSeek R1 0528 Qwen3 8B, DeepSeek R1 Distill Llama 8B, DeepSeek R1 Distill Qwen 14B and DeepSeek R1 Distill Qwen 32B.

The License column reads MIT, DeepSeek's license for the weights. The Qwen distills derive from Qwen2.5, originally under Apache 2.0, and the Llama 8B distill from Llama 3.1 8B Base, which is under the Llama 3.1 license. The R1-0528 card says the series supports commercial use and distillation. In daily use, the January cards advise against a system prompt, while the R1-0528 and 0528 Qwen3 8B cards say a system prompt is now supported.

What each Ollama deepseek-r1 tag downloads

Ollama's deepseek-r1 page puts the full model and several distills under one name, so the tag decides what you get:

• deepseek-r1, deepseek-r1:latest and deepseek-r1:8b download DeepSeek R1 0528 Qwen3 8B. All three share one digest with deepseek-r1:8b-0528-qwen3-q4_K_M.
• deepseek-r1:8b-llama-distill-q4_K_M downloads R1 Distill Llama 8B, which is no longer the plain :8b.
• deepseek-r1:14b is R1 Distill Qwen 14B (14b-qwen-distill-q4_K_M).
• deepseek-r1:32b is R1 Distill Qwen 32B (32b-qwen-distill-q4_K_M).
• deepseek-r1:1.5b and :7b, built on Qwen2.5-Math according to the R1 card, and :70b, built on Llama 3.3 70B Instruct, are not in CanRun's catalog.
• deepseek-r1:671b is the full DeepSeek-R1, and its default tag is the 0528 version. CanRun does not calculate it.

Ollama's page says the 0528 upgrade covered the 8B distill and the full 671B model, so the 14B and 32B tags are still the January distills. The default tags are Q4_K_M, the usual 4-bit quant and the level CanRun uses as its baseline. Ollama's files come from its own library, though, not from the community GGUFs in the GGUF source column, so sizes can differ slightly. The 32B file CanRun calculates with is 19.9 GB.

Which graphics card each distill needs

The grid crosses the four distills with six NVIDIA cards at an 8k context, an f16 KV cache (the memory that holds the context), 32GB of DDR5 system RAM and Windows. The badge shows the Q4_K_M verdict, and a line under it appears only when CanRun suggests a different file.

8GB cards: the two 8B models

On the 8GB RTX 4060, both 8B models fit fully on the GPU and Run great. DeepSeek R1 0528 Qwen3 8B needs 6.5 GB against the 7.4 GB the card can use, which leaves little margin, so check ollama ps. Its estimate also sits just over the stricter Runs great line that CanRun uses for thinking models.

The 14B distill needs 10.7 GB, more than the card can use, so part of it runs from system RAM and it Runs slowly. The 32B at Q4_K_M is rated Won't run. The line under its badge offers Q2_K, which still splits and Runs slowly. Q2_K is a 2-bit file in the Heavy loss group, and CanRun suggests one only when every other quant is rated Won't run, as here.

12GB and 16GB cards: the 14B distill

On the RTX 3060 12GB, the 14B distill fits fully on the GPU and Runs well. The margin is small, so check ollama ps. Its estimate clears the normal Runs great line but not the stricter one for thinking models. Both 8B models Run great on this card.

On the RTX 5060 Ti 16GB, the 14B Runs well at Q4_K_M, and at IQ4_XS, one step down in the same Good balance group, it Runs great. The two estimates sit just either side of the stricter line, a small edge rather than a real speed gap.

At Q4_K_M the 32B splits on both cards and Runs slowly. The ladder shows every quant of the 32B on the RTX 5060 Ti 16GB:

Q2_K needs 14.8 GB, so it fits fully on the 16GB card with little margin; check ollama ps. It then Runs well, but it is in the Heavy loss group. Q6_K is rated Won't run. CanRun does not measure answer quality, so it cannot say whether a 2-bit 32B or a 4-bit 14B answers better. GGUF quantization: Q4_K_M vs IQ4_XS vs Q8_0 — which to download explains the quality groups.

24GB and 32GB cards: the 32B distill

On the RTX 3090 and RTX 4090, the 32B needs 22.1 GB against 23.4 GB usable, so it fits fully with a little over a gigabyte to spare. It Runs well on the RTX 3090 and Runs great on the RTX 4090. The two estimates sit on either side of the stricter Runs great line, so a few percent of real speed could move either card one level.

All four distills Run great on the 32GB RTX 5090. Its extra room can go to a longer context, and even the 32B's Q6_K file fits fully and Runs great.

Thinking out loud fills the context

All four models write out their reasoning before the answer, and CanRun treats them as always thinking. DeepSeek's January card says the R1 series tends to "bypass thinking pattern", which can hurt performance, and recommends forcing each reply to start with <think>\n. The 0528 card says this is no longer required.

That reasoning sits in the same context as your messages and takes KV cache, the memory that holds the context, like any other token. DeepSeek evaluated R1 and the January distills with a maximum generation length of 32k tokens, and R1-0528, including its 8B distill, with 64k. Ollama picks its default context length from the GPU memory it finds: 4k tokens below 24 GiB, 32k tokens from 24 to 48 GiB, and 256k tokens at 48 GiB or more (Ollama docs, checked 2026-09-29). That means 4k on the 8GB to 16GB cards in the grid and 32k on the 24GB and 32GB cards, while CanRun's verdicts assume 8k. Once the context is full, the start of the conversation drops out; Ollama slow or forgetting your prompt? Context length defaults shows how to raise it.

The table shows what each model needs at 32k:

DeepSeek R1 0528 Qwen3 8B fits fully on the RTX 3060 12GB at 32k and Runs well. On the RTX 5060 Ti 16GB, the 14B needs 15.8 GB at 32k, just over the 15.4 GB the card can use. A small part spills to system RAM, and it still Runs well. With a q8_0 KV cache it stays fully on the GPU and also Runs well.

All four use full attention on every layer, with no sliding window in their configs, and the same 8 KV heads per layer. The cache per token therefore follows the layer count: 64 layers in the 32B against 32 in the Llama 8B. At 32k, the 32B's cache alone takes 8.6 GB.

The 64k column is R1-0528's maximum generation length, and 128k is the longest context all four models support. At 128k with an f16 cache, even the two 8B models need more for the cache alone than the RTX 5060 Ti 16GB can use. CanRun's calculation then runs them entirely from system RAM, and both are rated Won't run.

On the 8GB RTX 4060, DeepSeek R1 0528 Qwen3 8B runs out of room soon past 8k:

At 16k with an f16 cache it needs 7.7 GB, more than the card can use, so it spills and Runs slowly. A q8_0 cache keeps 16k fully on the GPU, where it Runs great. At 32k an f16 cache Runs slowly, and only q4_0 keeps it fully on the GPU, where it Runs well. Other contexts are in the table.

The 32B distill on a 24GB card: how far the context goes

At 8k with an f16 cache, the 32B distill fits fully on the RTX 3090 and Runs well. The table shows each context and cache type:

At 16k with f16 it needs 24.4 GB against 23.4 GB, so a small part goes to system RAM. It still Runs well, but the estimate is about half of the 8k one. A q8_0 cache needs 22.4 GB and keeps 16k fully on the GPU, where it Runs well.

32k is what Ollama picks by default on a 24GB card. In CanRun's calculation, an f16 cache there Runs slowly, and q8_0 still Runs slowly, just under the Runs well line. Only q4_0 fits 32k fully on the GPU, where it Runs well. The Ollama FAQ rates q4_0's precision loss as small to medium and more noticeable at long contexts. It adds that models with a high GQA count, such as Qwen2, may see a larger impact, and Ollama lists the 14b and 32b tags' architecture as qwen2. If you try q4_0, check with ollama ps that the model stayed on the GPU.

Beyond 32k the RTX 3090 runs out of room. At 64k an f16 cache is rated Won't run, and q4_0 Runs slowly. At 128k an f16 cache does not fit even with 32GB of system RAM. The 32GB RTX 5090 holds 32k with an f16 cache fully on the GPU and Runs great there.

Setting the context and KV cache in Ollama

Ollama quantizes the KV cache only when the server starts with OLLAMA_KV_CACHE_TYPE (f16, q8_0 or q4_0) and flash attention on; the setting applies to every model the server runs (Ollama docs, checked 2026-09-29). On Windows, quit the Ollama app from its taskbar icon, then start the server from PowerShell:

$env:OLLAMA_CONTEXT_LENGTH="16384"; $env:OLLAMA_FLASH_ATTENTION="1"; $env:OLLAMA_KV_CACHE_TYPE="q8_0"; ollama serve

In a second PowerShell window, run ollama run deepseek-r1:32b, or deepseek-r1 or deepseek-r1:14b. In CanRun's calculation, this one 16k q8_0 start keeps each of them fully on the GPU: DeepSeek R1 0528 Qwen3 8B on the RTX 4060, the 14B on the RTX 3060 12GB, where it Runs well, and the 32B on the RTX 3090. With an f16 cache instead, the 14B on the RTX 3060 12GB spills at 16k and Runs slowly, just under the Runs well line.

On macOS or Linux, the one-off form is OLLAMA_CONTEXT_LENGTH=16384 OLLAMA_FLASH_ATTENTION=1 OLLAMA_KV_CACHE_TYPE=q8_0 ollama serve. To keep the settings on Windows, add the three variables under "Edit environment variables for your account", which needs no administrator rights, and restart Ollama. Then run ollama ps with the model loaded: PROCESSOR should read 100% GPU, and the CONTEXT column shows the context you got. KV cache explained: how context length eats VRAM explains what each cache type saves, and Ollama or LM Studio not using your GPU? Check the split and fix the offload covers what to do when the split is not 100% GPU.

DeepSeek V4 Flash: large-memory Macs, more cards or experts in system RAM

DeepSeek V4 Flash 0731 is the one full-size DeepSeek model that CanRun calculates. It is a mixture-of-experts model whose experts ship in 4-bit FP4, so no GGUF repository offers Q4_K_M. CanRun's baseline is the MXFP4 file from llama.cpp's ggml-org organization at 155.0 GB, and the same repository has a Q2_K file at 117.4 GB in the Heavy loss group. Both come in two parts: llama-server -hf ggml-org/DeepSeek-V4-Flash-0731-GGUF:MXFP4 downloads them and leaves out the separate DSpark draft file, and Ollama cannot pull split files from Hugging Face, so CanRun's pages show only llama.cpp commands for this model.

Its attention is compressed. Most of its layers store the keys of four tokens, or of 128, as one entry, and llama.cpp keeps no separate values. The KV cache therefore stays small: at 128k with an f16 cache it takes 0.9 GB, where the 32B distill needs 34.4 GB.

CanRun counts the compressed caches, and the small index that sits next to them, the way llama.cpp allocates them for one request slot. llama.cpp keeps a separate set for every slot, and llama-server opens four slots unless told otherwise, which would take four times the KV cache, so CanRun's llama.cpp commands for this model add -np 1. Every layer also keeps the last 128 tokens uncompressed; that part does not grow with the context, so CanRun leaves it to its compute buffer estimate.

On a Mac Studio with M3 Ultra and 256GB, the MXFP4 file fits fully in the memory the GPU can use and Runs great, a theoretical estimate. The 512GB configuration rates the same, and so does an M5 Ultra with 256GB, also theoretical. An M2 Ultra with 192GB sits at the edge. CanRun lets a Mac's GPU use 70% of unified memory, and even macOS's default of about three quarters on a Mac this large falls short of the MXFP4 file. CanRun therefore runs it on the CPU path, where it Runs slowly (theoretical). The Q2_K file fits on the GPU of the same Mac and Runs great, also theoretical. Raising the limit with sudo sysctl iogpu.wired_limit_mb= lets llama.cpp put MXFP4 on the GPU as well, which CanRun's verdicts do not assume; Running local LLMs on a Mac (M4, M5): how much unified memory? covers the command and the risk of leaving macOS too little memory.

128GB of unified memory is not enough for MXFP4. On a 128GB NVIDIA DGX Spark or Ryzen AI Max+ 395, it does not fit at all. On the Ryzen AI Max+ 395 the Q2_K file runs only on the CPU path, where it Runs slowly (theoretical). On the DGX Spark, CanRun counts what Linux and the desktop leave free, 116.9 GB, and the Q2_K file needs 118.0 GB at 8k, so it fits neither on the GPU nor on the CPU path. That figure starts from the lowest boot log owners have posted, on a kernel that reserves more memory than earlier ones, so check the llama.cpp load log before you rule the file out.

With a graphics card, most experts sit in system RAM and the card holds the attention, the shared expert and as many expert layers as fit. With 128GB of system RAM, the MXFP4 file does not fit even with an RTX 5090, because the experts left in RAM need more than it has to spare. The Q2_K file does fit with an RTX 5090 or an RTX 4090 and 128GB, keeping most experts in RAM, and Runs slowly, a theoretical estimate. In CanRun's calculator, 192GB of system RAM is enough for MXFP4 with either card, which again Runs slowly (theoretical).

More cards hold more of the experts. In CanRun's calculator, four RTX 5090 cards with 64GB of system RAM hold the whole Q2_K file at 8k and rate it Runs great, while MXFP4 still keeps some experts in RAM and Runs well. Four RTX 3090 cards with 128GB of RAM rate Q2_K Runs well and MXFP4 Runs slowly. Like every multi-card result, these are theoretical, and llama.cpp's --fit makes the final split across the cards; Two GPUs for local LLMs: memory adds up, speed doesn't explains how the cards share the work.

How sure are these numbers?

Memory figures come by formula from real GGUF file sizes, each file's header and each model's configuration, so they carry no error band. For the four distills, speeds are calibrated estimates, ±12% with the model fully on an NVIDIA card and ±20% with partial offload. CanRun's data attaches no public benchmark to these DeepSeek models, so no cell is measured. That includes the 32B's Runs well on the RTX 3090 and the partly offloaded 14B's Runs slowly on the RTX 4060.

Every DeepSeek V4 Flash cell is a theoretical estimate (±30%). Its compressed attention and the hyper-connections that mix each layer's input add work that CanRun's speed formula does not count. For the one public result from a current llama.cpp build, an M2 Ultra run, CanRun's estimate was about a quarter higher than the measured speed. In an August build on the same Mac, llama.cpp slowed by about a fifth between an empty context and a 30k one, while CanRun's estimate barely moves, so its long-context cells are optimistic. Long prompts slow down even more: in that August run, reading a prompt after 30k tokens of context went at about a quarter of the speed on an empty context, which CanRun's prompt processing estimate does not reflect. Builds from before August 2026 were much slower on Macs.

The 1.5× factor for thinking models is a fixed policy and the least certain part. Several cells sit right at the stricter line, where a few percent of real speed moves them a level: the 32B on the RTX 3090 against the RTX 4090, the 14B at Q4_K_M against IQ4_XS on the RTX 5060 Ti 16GB, DeepSeek R1 0528 Qwen3 8B on the RTX 4060, and the 32B at 32k with q8_0 on the RTX 3090.

All verdicts assume Windows with the card driving the display, 32GB of DDR5-5600 dual-channel system RAM, an 8k context, an f16 KV cache, one model loaded and one request at a time. Ollama's library files differ slightly from the community GGUFs CanRun uses, so ollama ps is the ground truth on your PC. The full R1, V3 and V4-Pro are outside CanRun's calculation.

Models with a thinking mode face 1.5× stricter speed thresholds, which the legend below does not show; for the four distills and DeepSeek V4 Flash, multiply each speed in it by 1.5. The thresholds:

Where to go next

• Thinking models on local hardware: the speed cost and how to turn thinking off: turning thinking off, and the stricter thresholds.
• KV cache explained: how context length eats VRAM: KV cache size and the q8_0 and q4_0 cache types.
• Ollama slow or forgetting your prompt? Context length defaults: Ollama's default context and how to change it.
• GGUF quantization: Q4_K_M vs IQ4_XS vs Q8_0 — which to download: Q2_K, IQ4_XS and the quality groups.
• Ollama or LM Studio not using your GPU? Check the split and fix the offload: checking that a model runs on 100% GPU.
• Running MoE models bigger than your GPU: gpt-oss-120b with system RAM: how experts in system RAM work, which is how a graphics card runs DeepSeek V4 Flash.
• Model pages such as DeepSeek R1 Distill Qwen 32B, DeepSeek R1 0528 Qwen3 8B and DeepSeek V4 Flash 0731 list every card.

FAQ

Can I run the full DeepSeek R1 on my PC?

Not with the 8GB to 32GB graphics cards in this guide, and CanRun does not calculate it. Its model card lists 671B total parameters with 37B activated, about twenty times the 32B distill. The full-size DeepSeek model CanRun does calculate is V4 Flash 0731, and it needs a large-memory Mac or a lot of system RAM: its MXFP4 file fits fully on a Mac Studio with M3 Ultra and 256GB, and its Q2_K file fits with an RTX 5090 and 128GB of RAM, keeping most experts in RAM. The small distills are what a typical home PC runs.

Is a DeepSeek R1 distill the same model as DeepSeek R1?

No. A distill is a Qwen or Llama model fine-tuned on samples that R1 generated, and it keeps its base model's architecture: Qwen2.5 for the 14B and 32B, Llama 3.1 for the Llama 8B and Qwen3 for the 0528 8B.

What GPU do I need for the DeepSeek R1 32B distill?

A 24GB card such as the RTX 3090 or RTX 4090 holds Q4_K_M at 8k fully on the GPU. On the 16GB RTX 5060 Ti, only the Heavy loss Q2_K file fits fully. For 32k, the RTX 3090 needs a q4_0 KV cache to stay on the GPU, and then it Runs well. The 32GB RTX 5090 holds 32k with an f16 cache and Runs great.

Why does DeepSeek R1 seem to forget my question in Ollama?

Most likely its reasoning filled Ollama's default context. Ollama picks its default context length from the GPU memory it finds: 4k tokens below 24 GiB, 32k tokens from 24 to 48 GiB, and 256k tokens at 48 GiB or more (Ollama docs, checked 2026-09-29). A distill can write a long chain of reasoning before it answers, and once the context is full, the start of the conversation drops out. Raise OLLAMA_CONTEXT_LENGTH as shown above. On an 8GB card such as the RTX 4060, pair 16k with a q8_0 KV cache; DeepSeek R1 0528 Qwen3 8B then stays fully on the GPU and Runs great.

Can I turn DeepSeek R1's thinking off?

In Ollama, yes: run ollama run deepseek-r1 --think=false, or type /set nothink in a chat. DeepSeek's January card warns that skipping the thinking can hurt the answers, though. CanRun still applies the thinking thresholds to these models, and --hidethinking only hides the reasoning.

Sources

• DeepSeek-R1 model card: MoE with 671B total and 37B activated parameters and a 128K context, trained on DeepSeek-V3-Base; the distills' base models and a maximum generation length of 32,768 tokens; MIT weights and the Apache 2.0 and Llama 3.1 origins of the distills; usage advice against a system prompt and for forcing <think>\n.
• DeepSeek-R1-0528 model card: a minor version upgrade with a maximum generation length of 64K tokens, system prompt support, no need to force <think>\n, and commercial use and distillation allowed.
• DeepSeek-R1-0528-Qwen3-8B model card and configuration: Qwen3 8B Base post-trained on R1-0528's chain-of-thought, with the same architecture as Qwen3-8B, and system prompt support; 36 layers, 8 KV heads, no sliding window.
• DeepSeek-R1-Distill-Llama-8B model card: the Llama 3.1 8B distill.
• DeepSeek-R1-Distill-Qwen-14B model card: the Qwen2.5 14B distill.
• DeepSeek-R1-Distill-Qwen-32B model card and configuration: 64 layers, 8 KV heads, no sliding window, model type qwen2.
• DeepSeek-V3 model card: 671B total parameters with 37B activated for each token, 128K context.
• DeepSeek-V4-Flash model card: a preview of the V4 series, whose table lists V4-Pro at 1.6T total and 49B activated parameters and V4-Flash at 284B and 13B, both with a 1M context, and its compressed sparse and heavily compressed attention.
• DeepSeek-V4-Flash-0731 model card and configuration: the official V4 Flash release that supersedes the preview, with a speculative decoding module attached and reasoning effort low, high or max; 43 layers with per-layer compression ratios, 256 routed experts with 6 per token, MIT license.
• ggml-org DeepSeek-V4-Flash-0731 GGUF: the two-part MXFP4 and Q2_K files CanRun calculates, and the separate DSpark draft files.
• llama.cpp KV cache for DeepSeek V4 and a memory log from issue #27680: the compressed caches, the lightning indexer cache and the uncompressed recent-token window, kept separately for each sequence, with their sizes at a 64k context in a one-slot run (-np 1).
• llama-server startup code: four request slots when -np is not set.
• llama.cpp pull request #28948 and a benchmark in #25893: M2 Ultra results for DeepSeek V4 Flash with a current build, and with an August build for generation and prompt processing at contexts up to 30k.
• DeepSeek news: DeepSeek-R1 release: the January 2025 release, six small distilled models open-sourced, MIT License.
• DeepSeek news: DeepSeek-R1-0528: the May 2025 update.
• Ollama library: deepseek-r1 and its tags: which model each tag downloads, the 0528 upgrade of the 8B and 671B tags, and the qwen2 architecture of the 14b and 32b tags.
• Ollama blog: thinking: --think=false, --hidethinking and /set nothink, with DeepSeek R1 as an example.
• Ollama docs: context length: the default context by GPU memory, OLLAMA_CONTEXT_LENGTH, and the PROCESSOR and CONTEXT columns of ollama ps.
• Ollama FAQ: KV cache quantization with flash attention, the precision loss of q8_0 and q4_0, the larger impact on models with a high GQA count, and what 100% GPU means in ollama ps.