Qwen3-14B VRAM requirements
fits any 24GB card, 8.6 GiB to spare · densest 32K fit: official FP8 at 20.7 GiB, 1.8 to spare (tight)
Qwen3-14B needs 10.1 GiB at Q4_K_M (ggml-org build) at 8K context and 13.9 GiB at 32K (classic KV bound counted) — any 24GB card runs it with 8.6 GiB to spare. Q4_K_M is the community default. Headroom hunters: Q5_K_M totals 15.3 GiB at 32K (7.2 to spare), the densest 32K fit on 24GB is the official FP8 build at 20.7 GiB (1.8 to spare, tight), and unsloth's UD-Q8_K_XL lands just past the line at 23.0 GiB — it fits 24GB at up to ~29K of context at the bound.
ollama run qwen3:14b — comfortable on any 24GB card, even at 32K (Ollama boots at 4K context — /set parameter num_ctx 32768 for the 32K window this page prices).Qwen3-14B is Alibaba's dense mid-size model from the April 2025 Qwen3 release: 14.8B parameters (GGUF BF16 file-derived), 40 full-attention GQA layers — 40 query heads, 8 KV heads, head dim 128 (config.json) — native 40K context, Apache-2.0. No MoE, no hybrid attention: every layer grows KV linearly, which is why its 32K KV bound is a plain 5.0 GiB config derivation, and why this page's totals are labeled upper-bound estimates (actual ≤ value).
Data verified · sources pinned in Where every number comes from
How much VRAM at each quantization? (weights + overhead + 4K KV, batch 1)
| Quantization | VRAM needed @4K | KV @32K provisional i · beyond the @4K column | Smallest tracked fit | Note |
|---|---|---|---|---|
| UD_IQ1_S | 4.7 GiB | 5 GiB | RTX 3060 12GB | measured · at 32K: 9.1 GiB |
| IQ2_M | 6.1 GiB | 5 GiB | RTX 3060 12GB | measured · at 32K: 10.4 GiB |
| Q4_K_M | 9.5 GiB | 5 GiB | RTX 3060 12GB · ≤~10K ctx | measured · at 32K: 13.9 GiB |
| Q4_K_L | 10.0 GiB | 5 GiB | RTX 4060 Ti 16GB | measured · at 32K: 14.4 GiB |
| FP8 | 16.3 GiB | 5 GiB | RTX 3090 24GB | measured · at 32K: 20.7 GiB |
| UD_Q8_K_XL | 18.6 GiB | 5 GiB | RTX 3090 24GB · ≤~29K ctx | measured · at 32K: 23.0 GiB |
GB vs GiB: card names are the manufacturer's nominal GB; totals here are GiB (230 bytes) — a "24GB" card holds 24 GiB, and a file quoted 9,001,753,376 B in decimal is the same 8.4 GiB. Caliber →
The 48GB-class doors, spelled out: a dual-GPU combo (2× 24GB; not one card doubled), a workstation card (RTX 6000 Ada), or a Mac Studio (unified memory; runs, slower tok/s).
How this page computes the numbers (reproduce any cell)
- usable VRAM = nominal minus reserve, per card: 12GB → 10.5 GiB, 16GB → 14.5 GiB, 24GB → 22.5 GiB, 32GB → 30.0 GiB.
- total@32K = weights + overhead + KV@32K; KV@32K = 5 GiB (config-derived — 163,840 B/token effective at 32K; hybrid models carry a constant state on top, composition in sources).
- total@4K (main column) = total@32K − KV@32K × 7/8 — KV is fully linear in context on this model.
- The "≤~XK ctx" note = 8K + 32K × (usable − total@8K) ÷ KV@32K — the context length that exactly fills the card (KV grows linearly with context on this model).
- A build fits a card at 32K when total@32K ≤ usable; tight = under 2.5 GiB of headroom, one site-wide threshold.
Is your GPU enough? (find your card: one row tells you)
| Your GPU | VRAM | Biggest quant that fits (ceiling) | How it feels |
|---|---|---|---|
| RTX 3060 12GB | 12 GB | IQ2_M (2-bit) · 10.4 GiB | 0.05 GiB spare at 32K (incl KV bound) |
| RTX 4060 Ti 16GB | 16 GB | Q4_K_L (4-bit) · 14.4 GiB | 0.08 GiB spare at 32K (incl KV bound) |
| RTX 3090 24GB | 24 GB | FP8 (8-bit) · 20.7 GiB | 1.8 GiB spare at 32K (incl KV bound) |
| RTX 4090 24GB | 24 GB | FP8 (8-bit) · 20.7 GiB | 1.8 GiB spare at 32K (incl KV bound) |
| RTX 5090 32GB | 32 GB | UD_Q8_K_XL (8-bit) · 23.0 GiB | 7.0 GiB spare at 32K (incl KV bound) |
Quants stack by size: each GPU has exactly one ceiling — a card that runs a bigger build runs every smaller one. Main-column totals price the 4K load (weights + overhead + the KV term at 4K — the community runtime default); each row's Note prices the full 32K load this page promises (Q4_K_M at 32K = 13.9 GiB), and CPU offload trades tok/s for headroom.
What GPU should you buy for it? (the 24GB sweet spot logic)
| The logic | 24GB is the cheapest tier that runs Q4_K_M with real headroom: 13.9 GiB at 32K with the KV bound counted, 8.6 GiB to spare. Below it, 16GB tops out at Q4_K_L (0.08 spare) and 12GB at IQ2_M (0.05 spare) — usable, but the quality floor you feel. Above it, a 32GB RTX 5090 reaches UD-Q8_K_XL with room to breathe; nice, not necessary. |
| Why it fits | Dense 14.8B at Q4_K_M is 8.4 GiB of weights; the whole 32K load rides a 5.0 GiB KV bound plus 0.5 GiB of runtime overhead — the plain-GQA arithmetic this page shows line by line — totaling 13.9 GiB against 22.5 GiB usable. |
⚠ Tight is a site-wide threshold: under 2.5 GiB of headroom. Q4_K_M @32K leaves 8.6 GiB — comfortable. The tight fits worth knowing: Q8_0 totals 20.1 GiB (2.4 spare, tight), FP8 totals 20.7 GiB (1.8 spare, tight), and the near-miss row UD-Q8_K_XL totals 23.0 GiB — 0.5 GiB over the 22.5 GiB usable, fitting ≤ ~29K of context at the bound. All totals carry the classic KV bound, so these verdicts are stable, not flip-check rows.
Tracked builds (actual file sizes, not theory)
| Build | Publisher | File size | 24GB @32K | Source |
|---|---|---|---|---|
| UD_IQ1_S | unsloth | 3.6 GiB | OK · 9.1 | HF @a04a82c4 verified |
| IQ2_M | bartowski | 5.0 GiB | OK · 10.4 | HF @bd080f76 verified |
| Q2_K | unsloth | 5.4 GiB | OK · 10.8 | HF @a04a82c4 verified |
| Q2_K_L (bartowski) | bartowski | 6.1 GiB | OK · 11.6 | HF @bd080f76 verified |
| Q4_K_M | ggml-org | 8.4 GiB | OK · 13.9 | HF @af3732ec verified |
| Q4_K_L | bartowski | 8.9 GiB | OK · 14.4 | HF @bd080f76 verified |
| FP8 | Qwen | 15.2 GiB | TIGHT · 20.7 | HF @9a283b4a verified |
| UD_Q8_K_XL | unsloth | 17.5 GiB | NO · 23.0 | HF @a04a82c4 verified |
Same quant, different builds: bartowski's Q2_K_L measures 6.1 GiB against unsloth's 5.5 GiB — a 9.7% spread at the same name (different tensor coverage), and the two sit side by side above. The mirror cases: Q4_K_M and Q8_0 ship at the same size between unsloth, ggml-org, and bartowski (one row stands for all three — the ggml-org file is cited), so for this model the Q4 name is not fuzzy: every Q4_K_M file on the three main repos is the same 8.4 GiB. Where 24GB ends at 32K: the official FP8 build at 20.7 GiB; UD-Q8_K_XL (23.0 GiB at the bound) is the first door that misses, and BF16 (33.0 GiB) needs 48GB-class hardware.
Self-host or API?
Why in / out? Output tokens cost more than input: a prompt is read in one parallel pass, while output is generated token-by-token — costlier to serve. For example, qwen3-14b listed at $0.12 in / $0.24 out per 1M tokens in the 2026-09-18 OpenRouter snapshot; blended at a typical chat mix (4 input : 1 output) ≈ $0.14/1M.
API prices float; the crossover moves less than one decade either way — so this page answers the question that doesn't need live prices: how much monthly usage makes self-hosting worth considering at all.
| Monthly usage | Verdict | Why |
|---|---|---|
| < 100M tokens | API | Even the cheapest self-host ($30/mo) never breaks even against the API bill at this usage — don't bother calculating. |
| 100M-500M tokens | Conditional | The decisive variable is whether you already own a 24GB card — amortization dominates the self-host bill. |
| > 500M tokens | Self-host | Per-token API billing stops scaling here; consider a managed dedicated instance too — at 1.5B+ tokens/mo it often beats DIY. |
Robustness: at 0.12/1M blended the crossover sits near 500 tokens/mo; at 0.24/1M near 130/mo. The three bands hold under ±2.5× API-price and ±2× self-host-cost floats. Self-host cost basis: $800-1900 GPU amortized over 30 months ($27-63/mo) + ~350W × 4h/day × $0.15/kWh (≈ $6/mo). Live prices via OpenRouter (linked, not re-verified by us); the band is a 14B-class reference from the 2026-09-18 OpenRouter listing, not a pinned price for this model.
Where every number comes from (every figure carries its tag)
Totals: measured weights + KV as the classic stacked upper bound (plain-GQA config derivation — labeled, and actual ≤ value) + measured overhead. This page exists for one config: the dense 14–16B tier × Q4_K-class quant × 32K context on a 24GB card — the cheapest tier that runs the community default with real headroom.
| Tag | Slot | What it is | What the verdict can claim |
|---|---|---|---|
| reported | model | Hugging Face config.json (hypothesis-parameter carrier) | Tight, conditional — stands on the linked source, re-checkable by you. |
| reported | static | Hugging Face model page | Tight, conditional — stands on the linked source, re-checkable by you. |
| provisional | kv | KV cache @ 32K — no published measurement for Qwen3-14B in our sources (kaitchup/vLLM/official reports checked 2026-09-14); the page shows the classic stacked bound instead: 163,840 B/token × 32K = 5.0 GiB, config-derived (40 layers × 8 KV heads × 128 dim × K/V × 2 bytes), actual ≤ value | Very likely right, order of magnitude only — replaced the moment measured values land. |
| measured | overhead | Deployment overhead — llama.cpp FA-on compute buffer anchor (507 MiB; measured empirical; same constant as the other champion pages) | Determinate — "it runs" means it runs. |
| Hugging Face config.json (hypothesis-parameter carrier) | @40c06982 | accessed 2026-09-13 |
| Hugging Face model page | @40c06982 | accessed 2026-09-13 |
| KV cache @ 32K — no published measurement for Qwen3-14B in our sources (kaitchup/vLLM/official reports checked 2026-09-14); the page shows the classic stacked bound instead: 163,840 B/token × 32K = 5.0 GiB, config-derived (40 layers × 8 KV heads × 128 dim × K/V × 2 bytes), actual ≤ value | latest | — |
| Deployment overhead — llama.cpp FA-on compute buffer anchor (507 MiB; measured empirical; same constant as the other champion pages) | latest | accessed 2026-09-05 |
FAQ
Does Qwen3-14B fit in 24GB VRAM?
Yes, comfortably at the community default. The Q4_K_M build totals 13.9 GiB at 32K context (weights + overhead + the 5.0 GiB classic KV bound) against 22.5 GiB usable on an RTX 3090 24GB or 4090 24GB — 8.6 GiB to spare. Even the official FP8 build (20.7 GiB at the bound) fits the same cards, tight.
How much VRAM does Qwen3-14B need at Q4_K_M?
13.9 GiB at 32K context: 8.4 GiB weights + 0.5 GiB runtime overhead + 5.0 GiB KV cache. The KV figure is the classic stacked bound for this plain-GQA model (163,840 bytes/token × 32,768 tokens — 40 layers × 8 KV heads × 128 dim, config-derived, unmeasured): actual KV ≤ that value, and KV quantization shrinks it further. At 4K context the KV term drops eightfold to ≈0.6 GiB, so the same build runs in ≈9.5 GiB. The short form (ollama run qwen3:14b) pulls the ollama Q4_K_M build.
What is the smallest GPU that runs Qwen3-14B?
At 32K context an RTX 3060 12GB tops out at IQ2_M (10.4 GiB at the bound, 0.05 GiB to spare — tight) and a 16GB card reaches Q4_K_L (14.4 GiB, 0.08 to spare) — usable, but you are living at the quality floor. For Q4_K_M, buy 24GB. At 4K context everything relaxes a band: Q4_K_M at 4K is ≈9.5 GiB, fitting a 12GB card.
What is the biggest build that fits a 24GB card at 32K?
The official FP8 build: 15.2 GiB of weights + overhead + the KV bound totals 20.7 GiB against 22.5 GiB usable — 1.8 GiB to spare, tight. Unsloth's UD-Q8_K_XL lands just past the line at 23.0 GiB (0.5 over), fitting a 24GB card at up to ~29K of context at the bound; F16 (33.0 GiB at the bound) is the first door that misses outright, needing 48GB-class hardware.
Which Q4_K_M file should I download — unsloth, ggml-org, or bartowski?
For this model it doesn't matter by size: Q4_K_M ships at the same size across all three publishers (9,001,753,376 bytes each — verified from the pinned file listings), and the same is true of Q8_0; the table cites the ggml-org file. The one same-name spread worth knowing is Q2_K_L: bartowski's build runs 9.7% larger than unsloth's (different tensor coverage), and both are listed. Read bytes, not labels.
How does Qwen3-14B compare to the 27B models on VRAM?
It is the budget rung of the same 24GB ladder: Q4_K_M at 13.9 GiB leaves 8.6 GiB of headroom where the 27B hybrids (Qwen3.5/3.6/3.8) leave 3.9–4.3 GiB, and its 24GB ceiling is the official FP8 build rather than a Q6-class door. What you give up is capability, not comfort — the 27B pages in the related tables above carry the same 24GB promise with less room to spare.
How does this site compute these VRAM numbers?
Weights are measured file sizes at pinned revisions (sources below); totals add runtime overhead plus the KV cache at 32K context. Here KV@32K = 5.0 GiB = 163,840 B/token × 32,768 (40 layers × 8 KV heads × 128 dim, config-derived bound). A build fits a card at 32K when the total clears usable VRAM (nominal minus reserve), and tight means under 2.5 GiB of headroom — the full formula lives in the method box under the quantization table.