RTX 3090 vs RTX 5090: Tested AI Speed, VRAM and Price

RTX 3090 vs RTX 5090 for local AI comes down to two measured facts. The 5090 generates tokens about 1.9 times faster, and it costs roughly four times as much as a used 3090. Both cards hold a 32B model at 4-bit, so for short chats you’re mostly paying for speed. The 5090’s extra 8 GB starts to earn its price once you load long documents, because that’s where a 24 GB card runs out of room.

Original content from computingforgeeks.com - post 168827

We rented one of each on vast.ai, built the same llama.cpp release on both and ran identical llama-bench tests with the 3090 at its stock 350 W and the 5090 at NVIDIA’s 575 W reference rating. That covers an 8B and a 32B model, the 32B at up to 64K tokens of context, and a 70B squeezed into 32 GB. You get tokens per second, the point where the 3090 runs out of memory, power draw, card sizes and three buying paths. We benchmarked both cards in October 2026, and the prices and stock below were checked that same week.

The quick verdict

For most people building a local LLM box, a used RTX 3090 is still the card to buy, and the 5090 is the one to buy when context length or raw throughput is the bottleneck. The three realistic options line up like this:

• Best value: a used RTX 3090. It runs every model up to 32B at 4-bit and generated 38.9 tokens per second on Qwen3 32B, faster than anyone reads, for about a quarter of a 5090’s price.
• Best single card: RTX 5090. It hit 74.5 tokens per second on the same 32B, kept 53.3 tokens per second at 32K context where the 3090 failed to load, and ran a 70B at 3-bit entirely on the GPU.
• Best for 70B models: two used RTX 3090s. Our dual-card rig ran Llama 3.3 70B at 4-bit at 31.9 tokens per second for less than half the price of one 5090.

GPU prices move week to week, so treat every figure here as a band. The renewed 3090 Founders Edition on Amazon ran about $1,900 when we checked (check the live price), while the ResalePrices tracker, which follows eBay US listings, put the used average at $1,535 the week we tested. The 5090 pick and the second-3090 option have their own sections below, with images and links.

How we tested both cards

Both cards were rented by the hour, each on its own host, with nothing else running on either GPU. We built llama.cpp from the same source tag on each host with CUDA 13.0, pulled the same GGUF files from Hugging Face, and ran llama-bench. It reports two speeds: pp512 is how fast the card reads a 512-token prompt, and tg128 is how fast it writes 128 tokens. Generation is the number you feel while a model is answering, so it leads every table here.

• RTX 3090: 24 GB, power limit at the stock 350 W, driver 580.159, PCIe 4.0, Ryzen 5 3600 host.
• RTX 5090: 32 GB, power limit at NVIDIA’s 575 W rating, driver 615.71, PCIe 5.0, EPYC 9554 host.
• Software: llama.cpp build b11741 on both, all layers on the GPU (-ngl 99), three repetitions for the empty-context tests and two for the long-context ones, except the single 64K runs and the 3090’s 70B run, which kept only 66 of 80 layers on the GPU.
• Models: Llama 3.1 8B Instruct Q4_K_M, Qwen3 32B Q4_K_M and Llama 3.3 70B Instruct IQ3_XXS.
• Power: nvidia-smi sampled every second during each run.

Rented cards are not your card in your case. The hosts differ (CPU, PCIe lanes), which barely matters once a model sits in VRAM, but it does matter for the one test that spills to system RAM, so we flag it there. We did not test image generation or training. For Stable Diffusion and FLUX numbers, see our ComfyUI GPU tests. The dual-3090 figures come from our dual RTX 3090 build, run a day earlier on the same llama.cpp build but with the host capping each card at 290 W, so treat those as a floor.

RTX 3090 vs RTX 5090 at a glance

Memory bandwidth explains most of what you see in this table. The 5090 moves 1,792 GB/s against the 3090’s 936 GB/s, a ratio of 1.91, and our generation results landed at 1.89 to 1.92 times faster across both model sizes. Token generation reads the whole model out of VRAM for every token, so the card with the faster memory wins by almost exactly that margin.

Spec or test	RTX 3090	RTX 5090
VRAM	24 GB GDDR6X, 384-bit	32 GB GDDR7, 512-bit
Memory bandwidth	936 GB/s (19.5 Gbps)	1,792 GB/s (28 Gbps)
CUDA cores	10,496 (Ampere)	21,760 (Blackwell)
Board power / PSU NVIDIA lists	350 W / 750 W	575 W / 1000 W
Founders Edition size	313 x 138 mm, 3 slots	304 x 137 mm, 2 slots
Llama 3.1 8B, generation	147.1 tok/s	277.8 tok/s
Qwen3 32B, generation	38.9 tok/s	74.5 tok/s
Qwen3 32B, prompt reading	1,304 tok/s	3,657 tok/s
Qwen3 32B at 32K context	Out of memory	53.3 tok/s
Llama 3.3 70B IQ3_XXS (25.58 GiB)	3.4 tok/s, 15 of 80 layers in system RAM	52.8 tok/s, all on the GPU
Price, Oct 2026	about $1,500 used, $1,800 to $1,900 renewed	about $6,800 used, about $8,000 new on Amazon

Prompt reading is the exception to the bandwidth rule. That is compute work, and the 5090’s doubled core count plus newer tensor cores read the 32B prompt 2.8 times faster. You notice it when you paste a long file and wait for the first word. Specs come from NVIDIA’s GeForce comparison page and the card makers’ spec sheets. Every speed figure is ours.

1. Used RTX 3090: the value pick

The 3090 wins on tokens per dollar by a wide margin. At the used average from the verdict above and 38.9 tokens per second on a 32B model, it works out to about 25 tokens per second for every thousand dollars spent. The 5090 manages about 11 on its used price and less on Amazon’s. A 32B model at 39 tokens per second already streams text faster than you read it, so for one person chatting, coding or running a home assistant, the 5090’s extra speed sits unused most of the time.

A used 3090 holds the same ladder of models as the 5090 up to 32B at 4-bit. Our Qwen3 32B run peaked at 19,214 MiB of the 24,576 MiB that nvidia-smi reports, which leaves room for about 16K tokens of context at full precision. At 8K the 3090 still wrote 35.6 tokens per second and at 16K it wrote 32.8. Under load it ran at its 350 W limit, averaging 341 W across the busy samples of the 32B run, and peaked at 69 to 74 °C on the rented host.

Look elsewhere when any of these describe you:

• You feed it long documents: past roughly 16K tokens on a 32B model, the 3090 needs a quantized KV cache and slows down hard (next section).
• You want a warranty: these cards are four to six years old, often ex-mining, sold renewed or used. Buy from a seller with returns and budget for new thermal pads.
• Your case is tight: the Founders Edition takes three slots and two 8-pin leads through NVIDIA’s 12-pin adapter.

On Amazon the renewed Founders Edition ran about $1,900 when we checked (check the live price). That’s well above the used average, so eBay with buyer protection is usually the cheaper route. Our VRAM sizing guide covers which models fit in 24 GB before you buy.

2. RTX 5090: the fastest single consumer card

The 5090 is the better card whenever context, throughput or a 70B model matters more than price. It generated 277.8 tokens per second on the 8B and 74.5 on the 32B. Its 32 GB also carried the 32B to 32K tokens of context at full precision, at 53.3 tokens per second, while the 3090 couldn’t even allocate the cache. It also ran Llama 3.3 70B at 3-bit (IQ3_XXS, 25.58 GiB) fully on the GPU at 52.8 tokens per second, which no 24 GB card can do.

Price is the catch. NVIDIA lists the 5090 from $1,999, but the in-stock 5090 listings we found on Amazon the week we tested ran $7,979 to $10,999, all from third-party sellers. The ZOTAC AMP Extreme Infinity above was the cheapest of them at about $8,000 (check the live price). Used 5090 listings averaged $6,782 on ResalePrices, up 61% in 90 days. Pass on it when:

• Your models stay at 32B or below with short prompts: you would pay four times as much for speed you won’t notice in a chat window.
• Your power supply is under 1000 W: the card reached its 575 W limit on the long-context and 70B runs and averaged about 490 W while busy on the 32B test.
• You want 70B at 4-bit: 32 GB is not enough for Llama 3.3 70B Q4_K_M (39.6 GiB), so you’d still be at 3-bit.

Power draw is less of a penalty than it looks. On the 32B run the 5090 averaged about 490 W for 74.5 tokens per second, while the 3090 averaged 341 W for 38.9, so the newer card produced more tokens per watt. Those averages cover only the one-second samples where the GPU was at 50% utilization or more, which mixes prompt reading and generation. If you’re weighing the 5090 against a 96 GB workstation card for even bigger models, our RTX Pro 6000 vs RTX 5090 test covers that step up.

3. Two used RTX 3090s: the 70B option

If your real target is a 70B model at 4-bit, two 3090s beat one 5090 on both capacity and price. Together they give you 48 GB, enough for Llama 3.3 70B Q4_K_M with room for context. In our dual-card lab that model generated 31.93 tokens per second with llama.cpp’s tensor split (-sm tensor) and 19.48 with the default layer split, with both cards capped at 290 W by the host. The same pair ran Qwen3 32B at 59.78 tokens per second, about 80% of a single 5090’s 74.52.

Two cards at the used average come to about $3,070, less than half of a used 5090. The MSI Ventus 3X above was a renewed listing on Amazon at about $1,830 when we checked (check the live price). Your second 3090 does not have to be the same brand as the first. A dual build costs you more than the two cards, though:

• Board spacing: two 3-slot cards need slots four apart, which few AM5 boards have. The build guide names one that does.
• Power: budget a 1200 W supply or more for two 350 W cards and their spikes.
• Single-stream speed: a 32B model on one 3090 still runs at 39 tokens per second, so the second card helps only when you split a model across both.

You’ll find the full parts list, the board and case picks, and the vLLM results in the dual RTX 3090 build guide. For quieter routes to big-model capacity without discrete GPUs, our unified memory vs VRAM comparison covers Strix Halo and Mac boxes.

RTX 3090 vs RTX 5090 benchmarks: tokens per second

The 5090 roughly doubled the 3090 on every generation test, and the gap held steady as context grew until the 3090 ran out of memory. Each pair of bars you see below is the same model, file and command on both cards:

You can reproduce any row with the same tool. If you have not built llama.cpp with CUDA yet, our llama.cpp guide walks through it; the CMake build leaves llama-bench in ./build/bin/, so run the commands below from the llama.cpp directory. The hf download tool comes from Hugging Face’s own CLI installer, which also works on current Ubuntu and Debian, where the system pip refuses to install packages:

curl -LsSf https://hf.co/cli/install.sh | bash

Download the Qwen3 32B file into a models folder:

hf download Qwen/Qwen3-32B-GGUF Qwen3-32B-Q4_K_M.gguf --local-dir models

Then run the benchmark with the same flags we used on both cards:

./build/bin/llama-bench -m models/Qwen3-32B-Q4_K_M.gguf -ngl 99 -p 512 -n 128 -r 3

On the RTX 3090, the tg128 row is the generation speed and pp512 is prompt reading:

ggml_cuda_init: found 1 CUDA devices (Total VRAM: 24122 MiB):
  Device 0: NVIDIA GeForce RTX 3090, compute capability 8.6, VMM: yes, VRAM: 24122 MiB
| model                          |       size |     params | backend    | ngl |            test |                  t/s |
| ------------------------------ | ---------: | ---------: | ---------- | --: | --------------: | -------------------: |
| qwen3 32B Q4_K - Medium        |  18.40 GiB |    32.76 B | CUDA       |  99 |           pp512 |      1304.18 ± 13.79 |
| qwen3 32B Q4_K - Medium        |  18.40 GiB |    32.76 B | CUDA       |  99 |           tg128 |         38.91 ± 0.04 |

build: 1b29621 (1)

The RTX 5090 ran the same file at almost twice the generation speed and nearly three times the prompt speed:

ggml_cuda_init: found 1 CUDA devices (Total VRAM: 32202 MiB):
  Device 0: NVIDIA GeForce RTX 5090, compute capability 12.0, VMM: yes, VRAM: 32202 MiB
| model                          |       size |     params | backend    | ngl |            test |                  t/s |
| ------------------------------ | ---------: | ---------: | ---------- | --: | --------------: | -------------------: |
| qwen3 32B Q4_K - Medium        |  18.40 GiB |    32.76 B | CUDA       |  99 |           pp512 |     3657.43 ± 234.43 |
| qwen3 32B Q4_K - Medium        |  18.40 GiB |    32.76 B | CUDA       |  99 |           tg128 |         74.52 ± 0.11 |

build: 1b29621 (1)

Your numbers will move a few percent with drivers, quantization and the card’s power limit, and tools such as Ollama and LM Studio build on the same GGML kernels. The ratio between the two cards is what carries over. Our best GPU for LLMs roundup puts both against the 4090, the 5060 Ti and workstation cards.

The context cliff: where 24 GB runs out

The 3090’s real limit is not the model size but the model plus its context. The KV cache is the model’s running memory of the conversation, and for Qwen3 32B it takes 256 KiB per token at full precision, so 32K tokens adds 8 GB on top of the 18.4 GiB of weights. If you run that on the 3090, it does not fit, and llama.cpp stops before it starts:

./build/bin/llama-bench -m models/Qwen3-32B-Q4_K_M.gguf -ngl 99 -p 512 -n 128 -d 32768 -r 2

On the 3090, llama.cpp failed to allocate the cache and stopped with this error (the /workspace/models/gguf-32b/ path is where our rented host kept the file):

ggml_backend_cuda_buffer_type_alloc_buffer: allocating 8320.00 MiB on device 0: cudaMalloc failed: out of memory
ggml_backend_buft_alloc_buffer_n_default: failed to allocate CUDA0 buffer of size 8724152320
llama_init_from_model: failed to initialize the context: failed to allocate buffer for kv cache
llama_bench: error: failed to create context with model '/workspace/models/gguf-32b/Qwen3-32B-Q4_K_M.gguf'

The usual workaround is an 8-bit KV cache, which roughly halves the cache size. Add -ctk q8_0 -ctv q8_0 to llama-bench, or the same flags to llama-server:

./build/bin/llama-bench -m models/Qwen3-32B-Q4_K_M.gguf -ngl 99 -ctk q8_0 -ctv q8_0 -p 512 -n 128 -d 32768 -r 2

With the 8-bit cache the model loads, but the 3090 slowed to 17.4 tokens per second at 32K, with 23,526 MiB of the card’s 24,576 MiB in use. You can see the whole curve for both cards in this table:

Qwen3 32B Q4_K_M, generation	RTX 3090 24 GB	RTX 5090 32 GB
Empty context	38.9 tok/s	74.5 tok/s
8K tokens	35.6 tok/s	62.8 tok/s
16K tokens	32.8 tok/s	61.8 tok/s
32K tokens, FP16 cache	Out of memory	53.3 tok/s
32K tokens, 8-bit cache	17.4 tok/s	42.0 tok/s
64K tokens, FP16 cache	Not run	Out of memory
64K tokens, 8-bit cache	Not run	28.9 tok/s

The empty-context row is three runs, the 8K to 32K rows two each, and the 64K rows one. The 5090’s 8K figure was 62.83 ± 6.28 tokens per second across its two runs, which is why its 8K and 16K results look almost flat.

So the 5090 gives you more room before the cliff rather than removing it: it hit the same out-of-memory error at 64K with a full-precision cache and needed the 8-bit cache to get there. If you mostly paste a few pages at a time, 16K covers you and the 3090 never notices. If you load whole codebases or long PDFs into a 32B model, the 5090’s 8 GB is the reason to pay for it. Past 32K you also need YaRN, because Qwen3 32B handles 32,768 tokens natively; Qwen’s model card gives --rope-scaling yarn --rope-scale 4 --yarn-orig-ctx 32768 for llama.cpp. Our one run at 64K measured speed without it, so treat that row as a memory and speed test, not a quality check. A smaller quantization also frees room, and our GGUF vs AWQ vs GPTQ tests show what each format costs in memory.

Running a 70B on one 3090 means pushing part of it into system RAM, and that’s where the 24 GB card stops being a chat machine. We loaded the same 70B IQ3_XXS file the 5090 ran at 52.8 tokens per second, using -ngl 66. In this llama.cpp build that puts the output layer and the last 65 of the model’s 80 blocks on the 3090 (21,854 MiB in use), while the embeddings and the first 15 blocks stay in system RAM on the host’s six-core Ryzen 5 3600. Prompt reading held at 383 tokens per second, but generation fell to 3.44 tokens per second, because every token now waits on the CPU for those 15 blocks. A faster desktop CPU with DDR5 would help some, yet the GPU still sits idle while the CPU works through its share, so treat a 70B on one 3090 as a batch job.

3090 vs 5090 size, power and price

The Founders Edition 5090 is the smaller card, but you probably cannot buy one. NVIDIA’s 5090 FE is a 2-slot, 304 mm card, while the 3090 FE is a 3-slot, 313 mm brick. The partner 5090s actually in stock are bigger than both:

• ZOTAC RTX 5090 AMP Extreme Infinity: 332 x 137.5 x 69.6 mm, 3.5 slots, one 12V-2×6 connector, rated 600 W.
• Gigabyte AORUS RTX 5090 Infinity: 330 x 145 x 65 mm, one 16-pin connector, 1000 W PSU recommended.
• MSI RTX 3090 Ventus 3X: 305 x 120 x 57 mm, two 8-pin connectors, 350 W, 750 W PSU recommended.

Measure your case before ordering a partner 5090, and plan for a power supply with a native 12V-2×6 cable. Price is the bigger gap. Used 3090 listings averaged $1,535 (up 23% in 90 days) and used 5090 listings $6,782 (up 61%), both on the ResalePrices tracker on October 20, 2026. That’s 4.4 times the money for 1.9 times the generation speed and 8 GB more memory. Our GPU price tracker follows both cards if you’d rather wait for the 5090 to come down.

Which one to buy

Start from what you’ll actually run, not from the spec sheet:

• Models up to 32B, prompts under about 16K tokens: one used RTX 3090. It runs a 32B model at 33 to 39 tokens per second there and costs a quarter as much.
• Long documents or whole repositories in a 32B model: the RTX 5090. It ran 32K at full precision and, in one run, 64K with an 8-bit cache. Past 32K, Qwen3 needs YaRN enabled.
• Batch jobs, agents or several users at once: the RTX 5090, because double the generation speed and almost triple the prompt speed shorten every job.
• Llama 3.3 70B at 4-bit: two used RTX 3090s. A single 5090 only fits a 70B at 3-bit.
• A few prompts a week: neither. Rent a card by the hour and spend the difference elsewhere.

We would still point most people at the used 3090, because the work most home users give a local model fits in 24 GB and already runs faster than they read. The 5090 is the right call when your prompts are long or your workloads run unattended, and at the prices we saw it’s worth checking whether two 3090s would do that job for less.