DeepSeek-R1 model sizes and RAM requirements: what fits on one GPU?

DeepSeek-R1 does not have one RAM or VRAM requirement.

The full DeepSeek-R1 model has 671 billion total parameters, with 37 billion activated for each token. DeepSeek also released six smaller distilled models at 1.5B, 7B, 8B, 14B, 32B, and 70B parameters. They are different models with radically different hardware requirements.

That distinction is the first thing to get right.

A 14B DeepSeek-R1 distill can run on a single modern GPU with appropriate precision. A quantized 32B model can fit within the 32GB VRAM class. A 70B model usually moves you into higher-memory or multi-GPU territory. The full 671B DeepSeek-R1 is a data-center-scale model even though only 37B parameters are active for each token.

Here is the short version:

Those numbers estimate model weights only.

‍

‍

Actual inference needs additional memory for the KV cache, runtime, temporary allocations, quantization metadata, and active requests. Context length and concurrency can change the practical requirement substantially.

If you are choosing hardware for AI models more generally, our RTX 5090 VRAM guide explains that calculation in more detail.

DeepSeek-R1 is a family, not one hardware requirement

The phrase “run DeepSeek-R1” has become misleading shorthand.

DeepSeek's official R1 release contains two distinct kinds of model:

1. DeepSeek-R1 itself, a 671B-parameter Mixture-of-Experts model.
2. DeepSeek-R1-Distill models, smaller dense models trained using examples generated by R1.

DeepSeek officially released these distilled variants:

The distinction matters because the smaller models are not the 671B model compressed down to 14B or 32B.

‍

‍

DeepSeek fine-tuned existing Qwen and Llama base models using reasoning samples generated by DeepSeek-R1. The Qwen distills, for example, were fine-tuned using 800,000 samples curated with R1.

A 32B R1 distill therefore remains a 32B dense model based on Qwen2.5-32B.

It has learned from R1's outputs. It does not contain 671B parameters hidden inside a 32B checkpoint.

RAM and VRAM are not the same thing

Searches for “DeepSeek RAM requirements” often mix two kinds of memory together.

VRAM is memory attached to the GPU. If you want the model to run entirely on the GPU, its weights and inference state need to fit here.

System RAM belongs to the CPU host. It stores the operating system, application processes, model files during loading, datasets, caches, and anything you deliberately offload from the GPU.

For Compute with Hivenet, one RTX 5090 provides 32GB of GPU VRAM while the instance also includes separate ECC system RAM. Hivenet's documentation explicitly separates the two because they solve different problems.

If all model weights are resident on the GPU, adding hundreds of gigabytes of CPU RAM does not turn a 32GB GPU into a 200GB GPU.

If you deliberately offload model layers to CPU memory, more system RAM can let you run models that exceed available VRAM.

The tradeoff is data movement.

A GPU repeatedly waiting for weights to travel across PCIe is not the same thing as keeping the whole model in fast local GPU memory.

How to calculate DeepSeek-R1 memory requirements

The simplest estimate is:

parameters × bytes per parameter = approximate weight memory

Common precisions give us:

• BF16 or FP16: about 2 bytes per parameter
• 8-bit: about 1 byte per parameter
• 4-bit: about 0.5 bytes per parameter

For a 14B model:

14 billion × 2 bytes ≈ 28GB at BF16

14 billion × 1 byte ≈ 14GB at 8-bit

14 billion × 0.5 bytes ≈ 7GB at 4-bit

For a 32B model:

32 billion × 2 bytes ≈ 64GB at BF16

32 billion × 1 byte ≈ 32GB at 8-bit

32 billion × 0.5 bytes ≈ 16GB at 4-bit

These are deliberately simple calculations.

Real quantization formats add scales and metadata. Some layers may remain at higher precision. The inference engine needs its own memory. The KV cache grows with context and active sequences.

So think of these numbers as the floor for model-weight memory, rather than the complete VRAM budget.

DeepSeek-R1-Distill-Qwen-1.5B memory requirements

The 1.5B model is tiny by current LLM standards.

Its approximate weights need:

• 3GB at BF16
• 1.5GB at 8-bit
• 0.75GB at 4-bit

It can therefore run on modest GPUs and, depending on the runtime and performance you accept, on CPUs.

That makes it useful for experimenting with the R1-style reasoning behavior without renting substantial hardware.

The limitation is model capability.

DeepSeek's own evaluation shows a clear progression as its distilled models get larger. The 1.5B model performs impressively for its size, but the 14B and 32B distills are considerably stronger across reasoning, mathematics, and coding benchmarks.

Use 1.5B because your workload benefits from a small model, not because all R1 distills are interchangeable.

DeepSeek-R1-Distill-Qwen-7B memory requirements

The 7B model needs roughly:

• 14GB at BF16
• 7GB at 8-bit
• 3.5GB at 4-bit

A 16GB GPU can hold its BF16 weights on paper, but that leaves little room for inference overhead and cache.

On a 24GB or 32GB GPU, BF16 becomes much more comfortable.

At 8-bit or 4-bit, the model can run on considerably smaller hardware and leaves more space for context.

This size class is useful when latency, throughput, or cost matter more than extracting the highest possible reasoning performance from the distill family.

DeepSeek-R1-Distill-Llama-8B memory requirements

The 8B Llama-based distill is similar:

• 16GB at BF16
• 8GB at 8-bit
• 4GB at 4-bit

DeepSeek built this variant from Llama 3.1 8B rather than Qwen.

A 16GB card is again tighter than the weights-only number suggests. An 8B BF16 model may occupy around 16GB before the serving engine has allocated a useful KV cache.

If your GPU has 16GB, quantization is the safer route.

With 24GB or 32GB, you have much more freedom.

How much VRAM does DeepSeek-R1 14B need?

This is one of the most useful model sizes in the family because it sits between small, inexpensive distills and the heavier 32B model.

DeepSeek-R1-Distill-Qwen-14B needs approximately:

So how much VRAM does the quantized DeepSeek-R1 14B actually need?

‍

‍

At 4-bit, 7GB is the raw weight estimate. A real deployment needs more than 7GB because the runtime, cache, quantization data, and active context also need memory.

That means an 8GB GPU should not be treated as a guaranteed 14B deployment simply because 4-bit weights calculate to 7GB.

With 16GB, a validated 4-bit checkpoint has much more useful headroom.

With 24GB or 32GB, you can give the model more room for context and concurrent requests, or experiment with less aggressive quantization.

On an RTX 5090 cloud GPU, I would generally run the 14B model quantized rather than loading 28GB of BF16 weights simply because they almost fit.

Leaving VRAM unused is not waste. It is where your workload runs.

Can DeepSeek-R1 14B run on an RTX 5090?

Yes.

A 32GB RTX 5090 has ample capacity for a quantized 14B model and can theoretically hold the BF16 weights as well. NVIDIA specifies 32GB of GDDR7 VRAM on the desktop RTX 5090.

I would still favor quantization for most inference workloads.

The reason is not just whether the model starts.

A quantized 14B model leaves significantly more VRAM for:

• longer context
• KV cache
• multiple active sequences
• batching
• runtime buffers

If your evaluation shows that the quantized checkpoint preserves the quality you need, the spare memory is useful capacity.

DeepSeek-R1-Distill-Qwen-32B memory requirements

The 32B model changes the calculation:

BF16 clearly does not fit on one RTX 5090.

‍

‍

Eight-bit is also a poor single-5090 target. The weights alone use the card's entire nominal 32GB capacity before inference has begun.

Four-bit is the practical single-GPU route.

A validated 4-bit 32B checkpoint starts around a theoretical 16GB of weight storage, leaving the rest of the RTX 5090's VRAM for the inference engine and workload.

This is why 32B is probably the most interesting R1 distill size for a 32GB GPU if reasoning quality matters more than maximum concurrency.

DeepSeek's published evaluation places its 32B Qwen distill ahead of its 14B model across the main math, reasoning, and coding benchmarks it reports.

That does not make 32B universally better.

If 14B already passes your application's evaluation, the smaller model gives you lower memory use and more serving headroom.

DeepSeek-R1-Distill-Llama-70B memory requirements

At 70B parameters:

‍

‍

That pushes the model outside a single RTX 5090 even at a simple 4-bit calculation.

A 70B 4-bit deployment generally needs:

• a GPU with substantially more than 35GB VRAM, or
• multiple GPUs with the model sharded between them

Two 32GB GPUs provide 64GB of aggregate VRAM, but multi-GPU memory is not a magic shared pool. The serving engine must explicitly shard the model, and each GPU also needs room for runtime state.

Our planned Llama 3.3 70B GPU requirements guide will go deeper into that boundary because the same underlying hardware calculation applies to DeepSeek's Llama-based 70B distill.

What about the full 671B DeepSeek-R1?

This is where the most common misunderstanding appears.

DeepSeek-R1 has:

• 671B total parameters
• 37B activated parameters per token
• 128K context length

It uses a Mixture-of-Experts architecture inherited from DeepSeek-V3.

Only part of the network is used for each token, which reduces the amount of computation required compared with activating all 671B parameters at once.

But 37B activated parameters does not mean the model only needs enough memory for 37B parameters.

The complete expert weights still exist.

If you want them resident in accelerator memory, you need somewhere to store the full model.

The weights-only calculation is enormous:

This is not a consumer-GPU workload.

‍

‍

Can eight RTX 5090s run full DeepSeek-R1?

Not as a conventional fully resident 4-bit deployment.

Eight RTX 5090s provide:

8 × 32GB = 256GB aggregate VRAM

The raw 4-bit weight calculation for 671B parameters is:

671B × 0.5 bytes ≈ 335.5GB

That is already about 79.5GB more than the entire eight-GPU VRAM pool, before the runtime or KV cache needs memory.

Hivenet supports RTX 5090 configurations up to eight GPUs in one instance. That is useful for substantial multi-GPU training and inference, but it does not turn full R1 into a sensible RTX 5090 workload.

You can find specialized implementations that use aggressive quantization, CPU offloading, or distributed expert placement.

Those are engineering projects.

They should not be confused with “DeepSeek-R1 runs on a few gaming GPUs.”

For Hivenet's current RTX fleet, the distilled R1 models are the practical target.

Why the 37B activated-parameter number still matters

If it does not tell us the memory requirement, why does DeepSeek publish it?

Because it tells us something about computation.

In a Mixture-of-Experts model, the router selects a subset of experts for each token rather than sending every token through every parameter.

That makes the amount of active computation much smaller than a dense 671B model.

So the two numbers answer different questions:

671B total parameters helps explain how large the model's stored weights are.

37B activated parameters helps explain how much of that network participates in processing each token.

Confusing those two turns a useful architectural feature into bad hardware advice.

Which DeepSeek-R1 model fits a 32GB RTX 5090?

For one 32GB GPU, I would think about the distills like this:

If I wanted inexpensive experimentation, I would start with 7B or 8B.

‍

‍

If I wanted a good balance of reasoning capability and substantial serving headroom on one RTX 5090, I would test 14B.

If model quality mattered enough to spend more of the card's VRAM, I would evaluate a good 4-bit 32B checkpoint.

Then I would measure them on the same application-specific test set.

That last step matters more than the parameter number.

14B or 32B on one RTX 5090?

There is no universal winner.

The 32B model is stronger on DeepSeek's published reasoning benchmarks.

The 14B model is much lighter.

That gives 14B advantages in:

• memory headroom
• longer practical context
• concurrency
• startup time
• potentially lower latency
• easier experimentation

The 32B model gives you more model capacity but consumes much more of the same card.

If your application is solving difficult reasoning or coding tasks, test 32B.

If it is extraction, classification, structured transformation, or another narrower task, the 14B model may already be enough.

Use the smallest model that passes the evaluation you care about.

DeepSeek-R1 Distill versus Qwen3.6-27B

There is another useful comparison inside the same GPU class.

DeepSeek-R1-Distill-Qwen-32B is based on Qwen2.5-32B and tuned on reasoning examples generated by R1.

Qwen3.6-27B is a newer 27B multimodal model with a different architecture and native reasoning capabilities.

Both can sit in roughly the same broad single-GPU conversation after suitable quantization, but they are different model families built for different purposes.

We cover the Qwen side separately in our Qwen3.6-27B RTX 5090 guide.

That gives us a more useful comparison than treating parameter count as a leaderboard.

How to run a smaller DeepSeek-R1 distill with vLLM

DeepSeek officially recommends vLLM or SGLang for serving the distill models. Its reference repository shows a vLLM deployment for the 32B model.

For a straightforward single-GPU experiment, start smaller.

For example:

vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-7B \
 --max-model-len 16384 \
 --reasoning-parser deepseek_r1

vLLM currently supports a dedicated deepseek_r1 reasoning parser, which separates reasoning output from the model's final answer in its OpenAI-compatible API.

Starting with a 16K maximum context is deliberate.

The model may support more, but every additional context token consumes cache memory. Once the server works under a realistic workload, increase the limit if the application actually requires it.

If you have not used vLLM on Hivenet before, see our vLLM guide.

DeepSeek's prompting recommendations are unusual

The official DeepSeek-R1 repository recommends:

• a temperature between 0.5 and 0.7, with 0.6 as the default recommendation
• avoiding system prompts and putting instructions in the user prompt
• running multiple evaluations rather than judging performance from one sampled answer

That is worth respecting when comparing the models.

If you test one checkpoint at its recommended settings and another using an arbitrary configuration, the comparison becomes partly a test of your serving setup.

DeepSeek also notes that R1-family models can occasionally bypass their expected thinking pattern. That is another reason to use a serving engine that understands reasoning output rather than parsing <think> tags yourself.

How much context should you configure?

Do not start with the maximum because it exists.

Context consumes memory.

A 32B quantized checkpoint might fit comfortably at startup and then run into trouble when you combine:

• very long prompts
• long reasoning output
• multiple simultaneous users
• a large KV cache

This is particularly relevant to reasoning models because they can generate long internal reasoning sequences before the final answer.

Start with the context your application needs.

Measure VRAM under realistic requests.

Then increase it.

A server that advertises a huge context window but becomes unusable under concurrent load has not solved the problem.

How much system RAM do you need?

There is no one-to-one rule such as “32GB VRAM requires 32GB RAM.”

For a GPU-resident model, system RAM mainly supports:

• the operating system
• Python and the inference server
• model loading
• tokenizer and application processes
• filesystem cache
• request handling
• datasets or other application data

If you use CPU offloading, RAM becomes part of the model-memory budget and the requirement rises accordingly.

For example, trying to offload part of a 70B or 671B model can consume tens or hundreds of gigabytes of host memory.

That may make a model technically runnable.

It does not mean it will perform like a GPU-resident deployment.

Treat offloading as a deliberate performance tradeoff rather than free VRAM.

What does a DeepSeek-R1 deployment cost on RTX 5090s?

Hivenet currently prices RTX 5090 Compute from €0.75 per GPU-hour, with per-second billing.

That gives a simple hardware-cost baseline:

Those figures do not tell you cost per token.

‍

‍

A 14B model and 32B model running for one hour on one GPU cost the same amount of GPU time but may serve very different numbers of requests during that hour.

For inference economics, measure:

• time to first token
• output tokens per second
• requests per second
• average prompt length
• average reasoning length
• concurrency
• GPU utilization

Then calculate cost around the workload.

An idle reasoning server is still an idle GPU.

Current rates are on the Hivenet pricing page.

Which DeepSeek-R1 model should you choose?

Start with the smallest model that can do the job.

Choose 1.5B for lightweight experimentation, education, or environments where hardware is severely constrained.

Choose 7B or 8B when speed, cost, and modest hardware matter more than maximum reasoning performance.

Choose 14B when you want a meaningful step up in reasoning while retaining plenty of flexibility on a single high-end GPU.

Choose 32B when difficult reasoning and coding tasks justify spending more of a 32GB card's memory.

Choose 70B when your evaluations show enough advantage to justify higher-memory or multi-GPU infrastructure.

Choose full R1 only when you actually have the infrastructure and operational reason to run a 671B Mixture-of-Experts model.

“Bigger” is not a deployment strategy.

DeepSeek-R1 model size FAQ

How much RAM does DeepSeek-R1 need?

It depends which DeepSeek-R1 model you mean. The distilled models range from 1.5B to 70B parameters, while full DeepSeek-R1 has 671B total parameters. GPU VRAM requirements therefore range from a few gigabytes for small quantized distills to hundreds of gigabytes for full R1.

How much VRAM does DeepSeek-R1 14B need?

Its weights require roughly 28GB at BF16, 14GB at 8-bit, or 7GB at 4-bit. Actual inference requires additional VRAM for the runtime, KV cache, quantization data, and active requests.

Can DeepSeek-R1 14B run on a 16GB GPU?

A suitable 4-bit checkpoint can fit comfortably within the raw weight budget of a 16GB GPU. Real memory use depends on quantization format, context length, and serving engine.

Can DeepSeek-R1 14B run on an RTX 5090?

Yes. A 32GB RTX 5090 has enough VRAM for the 14B distill, with quantization leaving considerably more space for context and serving overhead.

How much VRAM does DeepSeek-R1 32B need?

The raw weight requirement is approximately 64GB at BF16, 32GB at 8-bit, and 16GB at 4-bit. A suitable 4-bit checkpoint can therefore fit on a 32GB GPU.

Can DeepSeek-R1 32B run on one RTX 5090?

Yes, with suitable quantization. BF16 does not fit and 8-bit leaves effectively no useful headroom. Four-bit is the practical route for a single 32GB card.

Can DeepSeek-R1 70B run on one RTX 5090?

Generally no. The raw 4-bit weight estimate is approximately 35GB, already exceeding the RTX 5090's 32GB VRAM before inference overhead.

How many parameters does full DeepSeek-R1 have?

DeepSeek-R1 has 671B total parameters, with 37B activated for each token. It uses a Mixture-of-Experts architecture.

Why does DeepSeek-R1 have 671B parameters if only 37B are active?

The model contains many expert networks, but its routing system selects only a subset for each token. The full weights still need to be stored somewhere even though only part of the model participates in each token's computation.

Can full DeepSeek-R1 run on eight RTX 5090s?

Not as a normal fully resident 4-bit deployment. Eight RTX 5090s provide 256GB of aggregate VRAM, while 671B parameters require roughly 335.5GB for raw 4-bit weights alone.

Are DeepSeek-R1 Distill models just quantized versions of R1?

No. They are smaller Qwen and Llama models fine-tuned using samples generated by DeepSeek-R1. DeepSeek released distills at 1.5B, 7B, 8B, 14B, 32B, and 70B parameters.

What is the best DeepSeek-R1 model for a 32GB GPU?

There is no universal best model. A 14B distill leaves more memory for context and concurrency, while a suitable 4-bit 32B model gives you more model capacity. Evaluate both on your actual task.

Does DeepSeek-R1 support vLLM?

Yes. DeepSeek provides an official vLLM example for its distilled models, and current vLLM releases include a dedicated deepseek_r1 reasoning parser.

Is DeepSeek-R1 commercially usable?

DeepSeek licenses its R1 code and model weights under MIT and explicitly permits commercial use and derivative works. The distill models are based on Qwen and Llama models, so their underlying license lineage should also be checked when distributing derived work.

‍