The Definitive Guide to Running Qwen3-Coder & DeepSeek Locally (VRAM, Tags, & Hardware Specs)

The old world was simple: you paid an API bill and someone else worried about servers. The new world is better: you own the model, the weights, and the throughput — and your data never leaves your machine. By mid-2026, the open-weight model ecosystem has reached a point where Alibaba's Qwen3-Coder series and the entire DeepSeek lineage can be run locally with performance that rivals, and in many developer workflows outright beats, proprietary cloud APIs. The catch? You need to know exactly how much VRAM you need, which Ollama tag to pull, and what hardware configuration is actually viable at each tier.

This guide cuts through the noise entirely. No vague "it depends" answers. You'll find exact Ollama pull commands, VRAM requirement tables, quantization trade-off math, and specific hardware profiles for everything from a budget developer workstation running the Qwen3-Coder-30B on a single RTX 3090, all the way up to the monstrous DeepSeek-V4-Pro requiring a petabyte-scale cluster. The Mixture-of-Experts architecture powering these models fundamentally decouples memory capacity from compute throughput — and understanding that asymmetry is the key to provisioning hardware correctly.

1. Why MoE Architecture Changes the VRAM Equation

Before diving into specific models and commands, understanding the fundamental memory dynamics of Mixture-of-Experts (MoE) architecture is non-negotiable. Every flagship model in this guide — Qwen3-Coder-30B, Qwen3-Coder-Next, Qwen3-Coder-480B, DeepSeek V3, R1, and V4 — uses MoE. And MoE creates a counterintuitive hardware provisioning challenge that catches first-time deployers by surprise.

In a standard dense transformer model, the relationship between model size and VRAM requirements is linear and obvious: a 7B parameter model at FP16 needs ~14GB. But in an MoE model, the architecture splits the feed-forward network into many parallel "expert" sub-networks, then routes each input token to only a small subset of experts via a learned gating function. Qwen3-Coder-30B-A3B, for example, has 30 billion total parameters organized across 128 experts, but routes each token to only 8 active experts — resulting in only 3.3 billion active parameters per forward pass.

The critical implication: all 30 billion parameters must reside in accessible high-speed memory. The routing algorithm can call any expert at any time based on the input token. If even a fraction of those expert weights are offloaded to slower PCIe-connected system RAM, every token generation event that routes to an offloaded expert triggers a catastrophic latency spike — reducing a 30+ tokens/sec model to 2–4 tokens/sec in the worst case.

Parameter counts from official Qwen3-Coder and DeepSeek V4 model cards. Active parameter ratios vary by architecture.

The Memory-Bandwidth Asymmetry

MoE also creates a profound memory bandwidth dependency during the decode phase (text generation). Because the entire parameter space must remain hot in memory — and any of those experts may be called for any token — the system must continuously stream weight tensors from memory to compute cores. This means MoE models are even more memory-bandwidth-constrained than equivalent dense models of the same active parameter count.

The result: a 30B MoE model generates text at roughly the speed of an 8B dense model (due to only 3B active params per step), but it requires the VRAM footprint of a 30B model. This is the MoE bargain — and it's a genuinely good deal if you provision hardware correctly. The practical implication is that GPU or unified memory capacity takes absolute priority over raw compute (TOPS or TFLOPS) when selecting hardware for these models.

Context Window & KV Cache: DeepSeek's MLA Advantage

DeepSeek's V2, V3, R1, and V4 architectures introduced Multi-Head Latent Attention (MLA) — a mechanism that compresses Key-Value tensors into a lower-dimensional latent space before caching them, then projects them back to full dimensions only at inference time. This compression reduces KV cache memory requirements by approximately 12× compared to Grouped-Query Attention and up to 64× compared to standard MHA. The practical result: DeepSeek-V4-Flash can maintain a 1,000,000-token context window with only ~10GB of cache overhead — a feature previously requiring petabyte-scale data center resources.

Qwen3-Coder-Next takes a different approach: it interleaves Gated DeltaNets (linear attention / state-space mechanics) with traditional Gated Attention layers in a 3:1 ratio, enabling linear-time context scaling. This hybrid layout — 12 blocks of (3 × DeltaNet-MoE → 1 × Attention-MoE) — supports 262,144 native tokens with dramatically lower memory scaling compared to pure transformer attention.

2. Qwen3-Coder Series: Models, Tags & Hardware Profiles

Alibaba's Qwen3-Coder series is the definitive local-first coding model ecosystem as of mid-2026. Built specifically for autonomous software engineering, executable task synthesis, IDE integration, and long-horizon agentic workflows, the series spans an enormous range — from edge-device 0.6B models to the flagship 480B behemoth. For local deployment purposes, three variants dominate the conversation.

Qwen3-Coder-30B-A3B: The Developer Workstation King

The 30B variant is where local LLM deployment becomes genuinely practical for individual developers. With 30 billion total parameters activating only 3.3 billion per token across 128 experts (8 active), it delivers output quality comparable to 30B-class dense models at the inference speed of a much smaller model. A single high-end consumer GPU handles it comfortably at default quantization.

Qwen3-Coder-Next (80B Total / 3B Active): The Agentic Powerhouse

Qwen3-Coder-Next occupies a unique architectural space. At 80 billion total parameters with only ~3 billion active parameters, it delivers near-frontier coding quality while maintaining the generation speed of an 8B model. Its hybrid DeltaNet-Attention architecture natively supports 262,144-token contexts — critical for agentic workflows spanning entire codebases.

Critical architectural note: Qwen3-Coder-Next is explicitly compiled as a non-thinking model. Unlike other Qwen3 variants that can enter deep multi-step reasoning loops, Next skips internal evaluation blocks entirely in favor of rapid, reflexive agentic responses. This is intentional and essential for overnight autonomous coding runs — earlier thinking-mode models would frequently enter infinite verification loops on complex tasks, causing automated workflows to stall. Next bypasses this entirely.

Qwen3-Coder-480B-A35B: The Frontier Local Model

The flagship 480B model with 35 billion active parameters is the most capable locally-deployable coding model in existence as of May 2026. Its 262,144-token native context can be extended to 1 million tokens via YaRN (Yet another RoPE extensioN method). It supports over 100 programming languages and achieves benchmark scores rivaling closed-source frontier models on coding tasks. The hardware bar is high: you're looking at 4× 80GB enterprise accelerators at minimum.

Qwen3-Coder Ollama Tags & Hardware Profiles

Data synthesized from Unsloth GGUF release notes and official Qwen3-Coder model cards, May 2026. Memory estimates include ~1.2× loading overhead buffer.

3. DeepSeek V3, R1 & V4: Full Deployment Specifications

While Qwen3-Coder dominates the coding-specific niche, DeepSeek's model lineage serves as the foundational general-purpose logic architecture for local deployment in 2026. The ecosystem spans three distinct generations, each with different hardware requirements and use-case profiles.

DeepSeek V3 & R1: The 671B Workhorses

DeepSeek V3 (foundation model) and R1 (advanced reasoning variant) share an identical architectural footprint: 671 billion total parameters, 37 billion active parameters, 256 routed experts plus one shared expert. R1 is fine-tuned specifically for complex logical reasoning using reinforcement learning on chain-of-thought traces, making it the superior choice for mathematics, structured analysis, and multi-step problem solving. V3 excels at general instruction following and code generation.

At Q8_0 precision, the R1 model consumes approximately 700GB — firmly datacenter territory. At Q4_K_M, the requirement drops to ~400GB, feasible only on specialized multi-accelerator workstations or maximum-capacity unified memory systems (Mac Studio Ultra with 512GB). The distilled variants (covered below) are the pragmatic path for most independent developers.

DeepSeek V4-Pro & V4-Flash: Million-Token Intelligence

Released in April 2026, the V4 ecosystem introduces DeepSeek's hybrid Compressed Sparse Attention + Heavily Compressed Attention mechanism — the technology that enables a 1,000,000-token context window with only ~10GB of KV cache overhead locally. Two models comprise the V4 lineup:

• DeepSeek-V4-Pro: 1.6 trillion total parameters, 49 billion active parameters. Requires enterprise cluster topologies with high-bandwidth interconnects (NVLink or InfiniBand). Not practical for individual local deployment at any consumer hardware tier.
• DeepSeek-V4-Flash: 284 billion total parameters, 13 billion active parameters. Achieves approximately 95% of the Pro variant's benchmark performance. This is the practical ceiling for high-end local self-hosting and the most capable model a well-resourced individual can realistically deploy.

DeepSeek-V4-Flash: VRAM Requirements by Quantization Tier

Q2 quantization results in ~15–25% degradation in reasoning quality — acceptable for summarization or general queries, not recommended for complex coding or math. Recommend Q4 as minimum for production use.

DeepSeek Distilled Models: R1 Intelligence on Consumer Hardware

Recognizing the hardware barriers of the 671B and 1.6T architectures, DeepSeek released a suite of distilled models — dense transformers (built on Llama and Qwen bases) trained on the logical verification traces generated by the flagship R1. These bypass MoE routing complexity entirely while preserving R1-grade reasoning capability in significantly smaller footprints.

Data from DeepSeek model cards and community benchmarks. Q4_K_M quantization used as baseline.

4. Quantization Tiers: The VRAM/Quality Trade-off Table

Quantization is the primary lever between "this won't fit" and "this runs." The 2026 landscape features a mature set of formats with well-understood trade-off profiles. Choosing the wrong tier — either over-quantizing and sacrificing code quality, or under-quantizing and running out of VRAM — is the most common deployment mistake.

Quality loss estimates based on perplexity degradation benchmarks and HumanEval coding pass rate comparisons. Coding tasks are more sensitive to quantization artifacts than general text generation.

The NexaQuant Breakthrough for Distilled Models

A significant 2026 advancement for deploying the smaller R1 distilled models is the NexaQuant algorithm. Traditional Q4_K_M quantization of an 8B model resulted in ~22% accuracy degradation on complex reasoning benchmarks. NexaQuant targets specific layer weight distributions, achieving a 4× size reduction while maintaining near-perfect parity with the FP16 baseline. On HellaSwag and MMLU benchmarks, NexaQuant 4-bit deployments score within 1 percentage point of the unquantized model — ensuring the distilled R1 reasoning capability remains intact even at minimum VRAM.

5. Step-by-Step Deployment: Ollama Setup & Commands

The fastest path to running Qwen3-Coder or DeepSeek locally is through Ollama — it handles GGUF format management, GPU detection, automatic layer offloading, and the API server in a single binary. Here's the complete setup sequence from zero to running inference in under 10 minutes.

1. Install Ollama (Linux/Mac/Windows):
   Copy curl -fsSL https://ollama.com/install.sh | sh # Windows: Download installer from https://ollama.com/download
2. Pull and run Qwen3-Coder-30B (the 24GB GPU build):
   Copy ollama run qwen3-coder:30b # Ollama auto-detects GPU and optimizes layer allocation
3. Pull Qwen3-Coder-Next at Q4_K_XL (2×24GB or 64GB unified):
   Copy ollama run hf.co/unsloth/Qwen3-Coder-Next-GGUF:UD-Q4_K_XL
4. Pull DeepSeek R1 distilled variants:
   Copy # For single 24GB GPU (R1 reasoning in 24GB): ollama pull deepseek-r1:32b # For dual 24GB GPUs (full 70B quality): ollama pull deepseek-r1:70b # Budget option - any laptop with 8GB RAM: ollama pull deepseek-r1:8b
5. Enable KV Cache compression for long-context models:
   Copy # Compress KV cache to Q8 — critical for 128K+ context windows export OLLAMA_KV_CACHE_TYPE=q8_0 # Then run your model as normal ollama run qwen3-coder:30b

   Setting KV_CACHE_TYPE=q8_0 reduces KV cache memory by ~50% with negligible quality loss on context recall tasks.

6. Advanced — llama.cpp with explicit GPU layer control:
   Copy # Load specific number of layers onto GPU (tune based on your VRAM): llama-server --model qwen3-coder-30b.Q4_K_M.gguf \ -c 65536 \ --n-gpu-layers 60 \ --host 0.0.0.0 --port 8080
7. Connect to local model from IDE (Continue.dev / Cursor):

   In Continue.dev config.json, set your model provider to ollama and point to http://localhost:11434. Select qwen3-coder:30b as the model ID. Cursor supports Ollama through the custom model endpoint feature in Settings → Models → Add Model.

6. Hardware Decision Framework by Budget & Use Case

The right hardware tier depends entirely on which models you need to run and at what context length. Here is the definitive 2026 tier breakdown, ordered from most accessible to most capable.

Tier 1: Budget Developer (~$500–$1,500 hardware)

A system with a single RTX 4090 (24GB) or equivalent 24GB VRAM GPU, paired with 64GB of DDR5 system RAM. This setup supports the full Qwen3-Coder-30B at default quantization (the 2026 sweet spot for local coding) and all DeepSeek R1 distilled models up to 32B. With hybrid CPU+GPU offloading via llama.cpp, you can even push Qwen3-Coder-Next Q4_K_XL (~46GB) by storing the overflow expert layers in fast system RAM, trading ~50% of generation speed for access to the full 80B model quality.

• Primary model: ollama run qwen3-coder:30b (runs fully in VRAM)
• Reasoning model: ollama pull deepseek-r1:32b (fits in 24GB at Q4)
• Generation speed: ~35–55 tokens/sec on Qwen3-30B
• Context limit: ~64K practical (VRAM constrained at longer contexts)

Tier 2: Serious Developer (~$3,000–$8,000 hardware)

Two RTX 4090s (48GB combined) or equivalent dual-GPU setup, or a unified memory system like the Mac Studio M3 Ultra / M4 Ultra with 128–192GB. This unlocks Qwen3-Coder-Next at Q8_0 quality, DeepSeek R1-Distill-70B fully in fast memory, and partial DeepSeek V3/R1 671B access at aggressive quantization.

• Primary model: Qwen3-Coder-Next Q8_0 (~85GB — fits in 128GB unified memory)
• Reasoning model: DeepSeek R1-Distill-70B fully in fast memory
• Context limit: Full 256K for Next with appropriate KV cache compression

Tier 3: Enterprise Enthusiast (~$15,000–$40,000 hardware)

4× RTX 4090 (96GB) or 2× enterprise 80GB accelerators (160GB), or a Mac Studio Ultra 512GB. This tier unlocks DeepSeek-V4-Flash at Q4 quantization (~80GB weights, with context overhead requiring the full 96GB+ buffer), and Qwen3-Coder-480B at aggressive Q2_K quantization (~163GB in dual 80GB configs).

Tier 4: Server / Research Lab (>$50,000)

4–8× enterprise 80GB accelerators (320–640GB VRAM) or 512GB+ unified memory systems. Enables DeepSeek-V4-Flash at full mixed-precision FP4+FP8 (~175GB) with complete 1M-token context, and Qwen3-Coder-480B at Q4 or Q5 quality. The V4-Pro (1.6T parameters) remains cluster-only territory.

Quick decision tree: Which model for your hardware?

• Single 24GB GPU (RTX 4090/3090): → Qwen3-Coder-30B (primary coding) + DeepSeek R1-Distill-32B (reasoning). Best local setup under $1,500 in GPU cost.
• 16GB GPU (RTX 4080/5080) + fast system RAM: → DeepSeek R1-Distill-14B fully in VRAM, or Qwen3-Coder-30B with some layer offloading. Generation speed drops ~30% vs 24GB GPU.
• 8GB GPU or integrated (mainstream laptops): → DeepSeek R1-Distill-8B or Qwen3-Coder-7B/8B. Fast, capable for light tasks; not suitable for large codebase work.
• Mac with 64–96GB Unified Memory (M3/M4 Pro/Max): → Qwen3-Coder-Next Q4_K_XL (~46GB) or DeepSeek R1-Distill-70B. Best mobile local LLM setup available.
• Mac with 128–192GB Unified Memory (M3/M4 Ultra): → Qwen3-Coder-Next Q8_0 (~85GB) or DeepSeek V4-Flash Q2. Silent, efficient, no VRAM constraints up to this tier.
• Multi-GPU workstation (4× 24GB): → DeepSeek V4-Flash Q4 (~96GB) or Qwen3-Coder-480B Q2_K (~163GB). Enters server-class model territory.
• Dual enterprise 80GB (160GB): → DeepSeek V4-Flash Q6 (~120–130GB) with 256K context. The highest single-developer local deployment tier.

---

Frequently Asked Questions