Run DeepSeek V4 Locally: Which Size Actually Fits Your Hardware (Flash vs Pro)

DeepSeek V4 landed as an open-weight frontier release under the MIT license, and the search traffic since has been one question repeated a thousand ways: can my machine run it? The honest answer for most people is no, not the big one, and the reason has nothing to do with how fast your GPU is. It is about how many bytes of weights you have to load before the model produces a single token. This guide walks the lineup, does the memory math, and points you at the size that actually fits your hardware.

The V4 lineup: Flash vs Pro

There are two models people mean when they say DeepSeek V4. They are not two sizes of the same thing you pick between casually; they are a workstation model and a datacenter model.

V4 Flash is a Mixture-of-Experts (MoE) model: 284 billion total parameters, but only around 13 billion are active for any given token. V4 Pro is a 1.6-trillion-parameter model that is not a local-hardware target for anyone reading this on a desktop. The rest of this guide is about Flash, because Pro belongs on a multi-node cluster, not under your desk.

Why MoE confuses everyone

The MoE design is where people get burned. They read "~13B active" and assume V4 Flash runs like a 13B model on a card that handles Llama-class 13B fine. It does not. Active parameters tell you how much compute each token costs. They say nothing about memory. The router can send any token to any expert, so all 284B parameters must be resident in memory at once, ready to be picked. You pay 13B of compute speed but 284B of memory cost. Small active set, large footprint. That is the whole trap.

The honest memory reality

A 4-bit quantization (Q4_K_M) stores weights at roughly 4.5 to 4.8 bits each once you include the higher-precision blocks the K-quant format keeps. For 284B parameters that lands the weights file in the rough neighborhood of 160 to 180 GB, before you add any context. That is far past any single consumer GPU. An RTX 5090, the current top consumer card, has 32 GB of VRAM. You would need five of them just to hold the weights, and that is the optimistic, no-context-yet figure.

These are estimates from the bits-per-weight math, not published download sizes. Treat them as the right order of magnitude for capacity planning, not exact disk numbers. The takeaway does not change at any of these levels: V4 Flash is a hundred-plus-gigabyte model.

Who can actually run V4 Flash

Three kinds of machine can hold a model this size. Everything else is wishful thinking.

• A multi-GPU workstation: several high-VRAM cards (think stacked RTX 5090s or pro-class accelerators) splitting the weights across cards.
• A big-RAM CPU-offload box: 192 GB or 256 GB of system RAM, running the model mostly on CPU with the GPU handling what fits. Slow per token, but it runs.
• A large unified-memory Mac: an Apple Silicon machine with 192 GB or more of unified memory, where the GPU can address the whole pool. This is the cleanest single-box option for a Q4 of this size.

The realistic option for normal hardware

If you have a laptop or a single mid-range GPU and you actually want DeepSeek's reasoning style today, you do not run V4 Flash. You run a DeepSeek-R1 distilled model. DeepSeek published distillations of its R1 reasoning model into small dense bases like Llama and Qwen, released under the MIT license. The 8B distill is a dense 8-billion-parameter model that runs in roughly 5 GB at 4-bit, fitting an 8 GB GPU or any modern laptop. It is not V4, but it gives you the chain-of-thought behavior on hardware you own.

Install path A: Ollama with partial CPU offload

If you do have the memory for V4 Flash, Ollama is the simplest runner. It pulls the weights and, when the model does not fit entirely in VRAM, automatically offloads the overflow layers to system RAM and CPU. You control how many layers stay on the GPU. The endpoint stays OpenAI-compatible at localhost:11434/v1, so your existing code does not change.

Install path B: llama.cpp for heavy RAM offload

On a 128 GB-plus DDR5 system where you want fine control over the offload, llama.cpp is the tool. It loads a GGUF and lets you set exactly how many layers go to the GPU with -ngl, leaving the rest on CPU. This is the path for people running a high-RAM CPU box rather than a stack of GPUs.

The 1M context window costs memory too

V4 Flash advertises a 1-million-token context window, and that number is real, but using it is not free. The KV cache that holds the attention state for your context grows with every token. Fill anywhere near a million tokens and the cache alone consumes tens of gigabytes on top of the weights you already loaded. The practical move is to set the context to what your task actually needs (-c 8192 or -c 32768) rather than maxing it out, because an over-large context window will push you back into CPU offload and tank your speed even if the weights fit.

License: MIT means you can ship it

Both V4 Flash and Pro are MIT-licensed. That is the permissive end of the spectrum: commercial use is allowed, you can build it into a product, fine-tune it, and redistribute, with no usage caps or revenue thresholds attached to the weights. For a business deciding between a self-hosted open model and a metered API, MIT removes the licensing question entirely and leaves only the hardware-economics question.

Local vs hosted API: when self-hosting pays off

Holding 180 GB of weights in memory means buying or renting serious hardware that mostly sits idle between requests. For occasional use, a hosted V4 endpoint is cheaper than the electricity, let alone the hardware. Self-hosting Flash makes financial sense in three cases: you run high, steady volume where per-token API costs would dwarf a fixed hardware spend; you have data-residency or privacy requirements that forbid sending prompts off-box; or you need guaranteed availability without a vendor's rate limits. If none of those apply, run the R1 distill locally for privacy and reach for a hosted API when you need full V4 quality.

Recommended hardware tiers (and the 2026 DRAM reality)

There is a wrinkle to the big-RAM-box plan in 2026: a DRAM shortage has pushed memory prices up hard. A 64 GB DDR5 kit runs around $1,150 right now, so a 192 GB or 256 GB build is a real budget line, not an afterthought. Plan accordingly.