Skip to content
llm-speed

Best GPU for Local LLMs (2026): Measured tok/s on RTX 5090, 4090, 3090

Measured decode tok/s for RTX 5090, 4090 and 3090 across 8B to 32B models, plus what fits in 24GB vs 32GB. Every number is from a signed benchmark run.

Verdict (measured runs)

On the same model ([Qwen3.8-27B](/m/qwen3-8-27b) Q4_K_M, llama.cpp, chat-short), we measured the RTX 5090 at 65.7 tok/s, the RTX 4090 at 43.06 and the RTX 3090 at 37.65 ([r_c3ps9wjygi9](/r/r_c3ps9wjygi9), [r_11kn1epxewh](/r/r_11kn1epxewh), [r_ptct8o01o5l](/r/r_ptct8o01o5l)). The 5090 is the fastest single consumer card we've tested, and its 32 GB fits more. Among 24 GB cards, the 4090 led the 3090 by about 14% on that model. With MTP on, our 4090 reached 84.51 tok/s on the same model ([r_7j8rpk9mwhg](/r/r_7j8rpk9mwhg)). The runs used different hosts and llama.cpp builds, so treat them as measured reference points, not a controlled ranking.

Recommendation

Choose the model file, context and number of simultaneous requests first. Then check runtime support and measure that workload before buying another card.

Start with the workload you need to run. A model loading successfully does not establish useful response time or answer quality. The examples below show reported configurations and source settings; use them to find relevant measurements, then validate your intended model, quantization and workload before buying.

Three checks before buying or adding a GPU

1. Can the runtime use this exact card?

Check the GPU, operating system, driver and runtime together in the Ollama hardware support list. A supported vendor name does not establish support for every card or mixed-card setup. Check motherboard slots, physical clearance, cooling and power requirements against the manufacturers' specifications too.

2. Does the full workload fit?

Budget for the exact weight file, context cache, runtime allocations and other resident models. Two simultaneous long conversations need a different memory budget from one short chat. Ollama documents how parallel requests increase context allocation. Start with the memory estimator, then measure your actual concurrency; its estimate is not a guarantee.

3. Is a second card solving the right problem?

Two cards do not behave like one card merely because their capacities add up. Ollama prefers one GPU when the model fits, otherwise it can split across available GPUs. llama.cpp exposes device and split controls. Validate support and placement on each device; more capacity does not establish a speed increase. System RAM plus VRAM is also a different configuration from GPU-only inference. In Ollama, inspect ollama ps and follow the placement and latency checklist.

Before spending, run representative prompts at your intended context and concurrency. Record first-token wait, decode speed, memory use and whether the answers meet your task. Our Qwen3.8 and Gemma 4 RTX 5090 study supplies specific speed measurements; it does not validate a different GPU pair, long-context concurrency or coding quality.

Sources checked September 22, 2026. The examples below retain reported host capacities, including nonstandard configurations. They do not prove GPU-only residency, current prices or which purchase has the best value. Token counts describe measured prompts and responses, not the maximum configured context. Missing fields remain explicit.

Short answer

On our measured runs, the RTX 5090 (32GB) is the fastest consumer card we have tested: 318.4 tok/s on gpt-oss-20b (run) and a median of 65.66 tok/s on dense Qwen3.8-27B Q4_K_M over three repeats (study), all measured with llama.cpp on the chat-short workload. A 24GB RTX 4090 or RTX 3090 measured 43.06 and 37.65 tok/s on the same Qwen3.8-27B Q4_K_M (llama.cpp, chat-short). Pick by the largest model you need to keep fully on the GPU, then by speed.

Not a controlled comparison: hosts, llama.cpp builds and dates differ, and some rows below use Ollama 0.31.1. Runs from a host whose RTX 4090 reports 48GB of GPU memory (a retail 4090 has 24GB) are left out. All rows are single-request decode speeds. See methodology.

Measured speeds by model size

8B to 9B dense

Reported hardwareModel · quantBackend · workloadDecode (measured)TTFT (measured)Run
RTX 5090 (32GB)Llama-3.1-8B-Instruct
quant not reported
llama.cpp
chat-short
232.2tok/s33.8msr_kfrkg-vn376
2026-07-01
RTX 3090 (24GB)llama3.1
Q4_K_M
ollama 0.31.1
chat-short · TTFT includes a cold model load
136.2tok/s49,960msr_9hurqggbshk
2026-07-02

14B to 20B (dense and MoE)

Reported hardwareModel · quantBackend · workloadDecode (measured)TTFT (measured)Run
RTX 5090 (32GB)gpt-oss-20b
quant not reported
llama.cpp
chat-short
318.4tok/s173msr_b9ul-vxh9sc
2026-07-01
RTX 3090 (24GB)coder-v2
Q4_0
ollama 0.31.1
chat-short
189.5tok/s735msr_o2-1w665rtq
2026-07-02
RTX 3090 (24GB)qwen2.5-coder
Q4_K_M
ollama 0.31.1
chat-short
69.21tok/s326msr_6ahy-dq0f_0
2026-07-02

27B to 32B dense

Reported hardwareModel · quantBackend · workloadDecode (measured)TTFT (measured)Run
RTX 5090 (32GB)Qwen3.8-27B
Q4_K_M
llama.cpp 1 (9725a31)
chat-short · 1 of 3 repeats (65.43 to 65.73)
65.66tok/s118msr_dz5a3lzxhrj
2026-09-05
RTX 5090 (32GB)Qwen3.6-27B-Q4_K_M.gguf
quant not reported
llama.cpp
chat-short · single run
73.96tok/s190msr_f7ulllqu4vk
2026-07-01
RTX 5090 (32GB)Qwen2.5-Coder-32B-Instruct
quant not reported
llama.cpp
chat-short
71.91tok/s71.0msr_nkbs6d3-d21
2026-07-01
RTX 4090 (24GB)gemma3
Q4_K_M
ollama 0.31.1
chat-short
46.95tok/s817msr_x23y_sg24pm
2026-07-02

30B-class MoE

Reported hardwareModel · quantBackend · workloadDecode (measured)TTFT (measured)Run
RTX 5090 (32GB)Qwen3-Coder-30B-A3B-Instruct
quant not reported
llama.cpp
chat-short
259.9tok/s218msr_c7qyvvmmsv1
2026-07-01
RTX 4090 (24GB)qwen3-coder
Q4_K_M
ollama 0.31.1
chat-short
145.2tok/s562msr_wjq32z47vlp
2026-07-02

24GB vs 32GB: what the extra memory buys

In our RTX 5090 study, Qwen3.8-27B Q4_K_M (an 18.97 GB file) ran with all 65 layers on the GPU and the runtime reported 18.62 GiB allocated for model, context and compute buffers, with a 16,384-token context configured. On 24GB cards we have since measured the same model with every layer on the GPU (llama.cpp -ngl 99): 43.06 tok/s on an RTX 4090 (run) and 37.65 on an RTX 3090 (run), llama.cpp chat-short. We have also measured on a 24GB RTX 4090 is Gemma 3 27B Q4_K_M at 47.0 tok/s (run) and the 30B MoE qwen3-coder at 145.2 tok/s (run), both via Ollama. Card memory sizes are manufacturer specs. Use the memory-fit estimator for your exact file and context.

Is a used RTX 3090 still worth it?

For models up to about 16B, our measured 3090 rows are fast: 189.5 tok/s on deepseek-coder-v2 (15.7B, Q4_0) and 136.2 tok/s on llama3.1 8B Q4_K_M. The 14.8B qwen2.5-coder ran at 69.2 tok/s. These come from one host on Ollama 0.31.1, so treat them as examples rather than a ranking. Same-backend runs of the same models on a 3090, 4090 and 5090 are the comparison we still need.

What we have not measured yet

A controlled same-host, same-build comparison of the RTX 3090, 4090 and 5090; and any RTX 5080, RTX 5070 Ti or RX 7900 XTX run. If you own one, run the suite and submit: your row will appear here after the next build.

FAQ

What is the fastest GPU for local LLMs?

Of the GPUs we have measured, the RTX 5090: 318.4 tok/s on gpt-oss-20b and 259.9 tok/s on Qwen3-Coder-30B-A3B (llama.cpp, chat-short).

How many tok/s does an RTX 5090 get on a 27B model?

Measured: a median of 65.66 tok/s for Qwen3.8-27B Q4_K_M (three repeats, llama.cpp 9725a31, chat-short), and 74.0 tok/s for Qwen3.6-27B Q4_K_M in a single earlier run.

Is 24GB of VRAM enough for a 27B model?

Yes at 4-bit, in our runs: Qwen3.8-27B Q4_K_M ran with every layer on the GPU (-ngl 99) at 43.06 tok/s on a 24GB RTX 4090 and 37.65 tok/s on a 24GB RTX 3090 (measured, llama.cpp, chat-short).

Related: RTX 5090 vs RTX 4090 · Qwen3.8-27B · Apple Silicon vs NVIDIA · cheatsheet

Submitted benchmarks

Reported hostModel and settingsDecodeSource
RTX 3090 (24GB) + AMD EPYC 7282 16-Core Processor (16c) + 126GB
Qwen2.5-Coder-14B-Instruct
Q4_K_M · llama.cpp 0.7.0-dev (build 1, commit ea0c4c2)
Prompt / output tokens: 131 / 256
TTFT: 77.366 ms
78.21tok/sr_rkyf9wxzw9z
Submitted 2026-10-17
RTX 3090 (24GB) + AMD EPYC 7663 56-Core Processor (56c) + 252GB
llama3.1
Q4_K_M · ollama 0.31.1
Prompt / output tokens: 110 / 256
TTFT: 49,959.98 ms
136.2tok/sr_9hurqggbshk
Submitted 2026-07-02
RTX 3090 (24GB) + AMD EPYC 7702P 64-Core Processor (64c) + 252GB
deepseek-coder-v2
Q4_0 · ollama 0.31.1
Prompt / output tokens: 117 / 256
TTFT: 734.851 ms
189.5tok/sr_o2-1w665rtq
Submitted 2026-07-02
RTX 3090 (24GB) + AMD EPYC 7C13 64-Core Processor (128c) + 1008GB
Qwen3.8-27B
Q4_K_M · llama.cpp 0.6.0-dev (build 1, commit 8c2134a)
Prompt / output tokens: 154 / 256
TTFT: 417.884 ms
37.65tok/sr_ptct8o01o5l
Submitted 2026-10-14
RTX 3090 (24GB) + AMD EPYC 7C13 64-Core Processor (64c) + 252GB
NVIDIA-Nemotron-3.5-Bolt-74B-A9B-24GB-ctx8k
Quantization not reported · llama.cpp 0.7.0-dev (build 11669, commit 620d2225c)
Prompt / output tokens: 120 / 256
TTFT: 454.054 ms
80.32tok/sr_w3lond-s75t
Submitted 2026-10-15
RTX 3090 (24GB) + AMD Ryzen Threadripper PRO 5975WX 32-Cores (32c) + 504GB
gemma3
Q4_K_M · ollama 0.31.1
Prompt / output tokens: 118 / 256
TTFT: 4,534.104 ms
78.65tok/sr_3gnxkzhhmyj
Submitted 2026-10-16
RTX 4090 (24GB) + AMD EPYC 7352 24-Core Processor (24c) + 252GB
qwen3-coder
Q4_K_M · ollama 0.31.1
Prompt / output tokens: 110 / 256
TTFT: 562.272 ms
145.2tok/sr_wjq32z47vlp
Submitted 2026-07-02
RTX 4090 (24GB) + AMD EPYC 7443 24-Core Processor (24c) + 252GB
gemma3
Q4_K_M · ollama 0.31.1
Prompt / output tokens: 118 / 256
TTFT: 816.561 ms
46.95tok/sr_x23y_sg24pm
Submitted 2026-07-02
RTX 4090 (24GB) + AMD EPYC 7452 32-Core Processor (64c) + 1008GB
LFM2.5-24B-A2B
Q4_K_M · llama.cpp 0.6.0-dev (build 1, commit a0e6dc7)
Prompt / output tokens: 114 / 256
TTFT: 178.099 ms
231.9tok/sr_bqmpv9kncyd
Submitted 2026-10-15
RTX 4090 (24GB) + AMD EPYC 75F3 32-Core Processor (64c) + 504GB
glm-4.7-flash
Q4_K_M · ollama 0.31.1
Prompt / output tokens: 105 / 256
TTFT: 28,105.716 ms
164.9tok/sr_ted0u8uyre0
Submitted 2026-10-16
RTX 4090 (24GB) + AMD EPYC 7642 48-Core Processor (48c) + 252GB
gemma-4-12b-it-qat
Q4_0 · llama.cpp 8931 (9725a313b)
Prompt / output tokens: 124 / 256
TTFT: 111.808 ms
97.72tok/sr_jfh0qkngw76
Submitted 2026-10-16
RTX 4090 (24GB) + AMD EPYC 7763 64-Core Processor (128c) + 1008GB
Qwen3.6-27B
Q4_K_M · llama.cpp 0.6.0-dev (build 1, commit 3fb4767)
Prompt / output tokens: 112 / 256
TTFT: 320.472 ms
47.14tok/sr_d_wda_rw62f
Submitted 2026-10-14
RTX 4090 (48GB) + AMD EPYC 7763 64-Core Processor (128c) + 1008GB
qwen2.5-coder
Q4_K_M · ollama 0.31.1
Prompt / output tokens: 131 / 256
TTFT: 280.772 ms
89.45tok/sr_73tnfdueq2h
Submitted 2026-07-02
RTX 5090 (32GB) + AMD EPYC 7543 32-Core Processor (120c) + 945GB
Qwen2.5-Coder-14B-Instruct
Q4_K_M · llama.cpp 0.7.0-dev (build 1, commit 1268eda)
Prompt / output tokens: 131 / 256
TTFT: 64.951 ms
137.3tok/sr_xnr_k4emoyr
Submitted 2026-10-17
RTX 5090 (32GB) + AMD EPYC 9534 64-Core Processor (128c) + 756GB
Qwen3.8-27B
Q4_K_M · llama.cpp 0.7.0-dev (build 11669, commit 620d2225c)
Prompt / output tokens: 154 / 256
TTFT: 273.357 ms
75.19tok/sr_qfrb2zmyk0k
Submitted 2026-10-15
RTX 5090 (32GB) + AMD Ryzen 7 9850X3D 8-Core Processor (8c) + 30GB
gemma-4-12b-it-qat
Q4_0 · llama.cpp 1 (9725a31)
Prompt / output tokens: 121 / 256
TTFT: 59.667 ms
141.1tok/sr_v5arqmazf31
Submitted 2026-09-05
RTX 5090 (32GB) + INTEL(R) XEON(R) GOLD 6530 (64c) + 1008GB
LFM2.5-24B-A2B
Q4_K_M · llama.cpp 0.6.0-dev (build 1, commit a0e6dc7)
Prompt / output tokens: 114 / 256
TTFT: 206.102 ms
308.5tok/sr_c8k6fleym09
Submitted 2026-10-15
RTX 5880 (48GB) + AMD EPYC 9T24 96-Core Processor (16c) + 62GB
llama3.2
Q8_0 · ollama 0.34.2
Prompt / output tokens: 125 / 256
TTFT: 2,820.586 ms
466.9tok/sr_b948ehgi8g4
Submitted 2026-09-19

See also: All hardware · All models · Methodology