TL;DR: 64GB buys you the 70B class at the quantization it deserves — Llama 3.3 70B Q5_K_M is 49.9GB and loads with real cache room, at ~27 tok/s on dual RTX 5090s or 11.49 tok/s on dual R9700s. The tier’s heartbreak is gpt-oss-120b: 64.9GB at 32K context, a sub-gigabyte miss that a small CPU offload papers over.

	Llama 3.3 70B (Q5_K_M)	gpt-oss-120b (MXFP4)	Qwen3.6-35B-A3B (Q8_0)
Weights	49.9 GB	59.02 GiB (~63.4 GB)	36.9 GB
Fits at 64GB?	Yes, with ~10GB cache room	Almost — 2–4 MoE layers go to CPU	Yes, with ~24GB cache room
Speed	~27 tok/s (dual 5090), 11.49 (dual R9700)	Fast — 5.1B active per token	Fastest thing this size
Best for	Deepest dense-model quality	Reasoning + agent loops	Daily driver with huge context

Honest take: If you’re building toward 64GB from scratch, dual R9700s at ~$3,150 are the value play and dual RTX 5090s at ~$8,700 are not — but the smartest money at this budget is often a third used RTX 3090, because 72GB is where gpt-oss-120b stops needing excuses. 64GB is a great tier to land on and a strange one to aim for.

No single card sells with 64GB in 2026, so this tier is always a build: two 32GB cards — dual RTX 5090s or dual AMD Radeon AI PRO R9700s — or a 64GB unified-memory machine that, as we’ll get to, isn’t actually a 64GB machine. Everything below assumes you know your exact model-plus-context arithmetic; if you don’t, run your combination through our VRAM calculator first.

This is the 64GB entry in our VRAM tier series, slotting between the 48GB page and the 96GB page, with the models-by-VRAM hub holding the full map.

What 16GB over the 48GB tier actually buys

The 48GB tier’s headline was Llama 3.3 70B at Q4_K_M (42.5GB) — fully resident, but capped there: Q5_K_M physically doesn’t fit two 24GB cards once the cache lands. At 64GB the cap moves up two rungs.

Llama 3.3 70B Q5_K_M (49.9GB) is the quant this tier exists for. Bartowski’s GGUF ladder puts Q5_K_M at 49.9GB and Q6_K at 57.9GB — Q5_K_M loads with roughly 10GB left for KV cache and compute buffers, enough for 16K context in fp16 (the 70B’s cache runs about 2.6GB per 8K of context — our planning math from the model’s 80-layer GQA layout, not a benchmark). Q6_K technically fits too, but 57.9GB of weights leaves so little cache room that you’re quantizing the KV to q8_0 just to hold an 8K conversation. Q5_K_M is the sweet spot; treat Q6_K as a party trick.

Loading it across two cards with llama.cpp:

./llama-server -m Llama-3.3-70B-Instruct-Q5_K_M.gguf \
  -ngl 99 --split-mode layer -c 16384 --flash-attn

What you want to see in the log — both devices claimed, weights split near-evenly:

llm_load_tensors: offloaded 81/81 layers to GPU
llm_load_tensors: CUDA0 model buffer size = 24913.11 MiB
llm_load_tensors: CUDA1 model buffer size = 25026.47 MiB

If one card sits near idle while the other fills, that’s a platform problem, not a model problem — our dual-GPU PCIe configuration guide covers the BIOS settings that cause it.

Speed depends entirely on which two cards you bought. Databasemart’s dual RTX 5090 Ollama benchmark measured ~27 tok/s on Llama 3.3 70B — H100-class eval rate from consumer silicon, and nearly triple the 7–10 tok/s that dual 3090s manage on the same model one tier down. Our own dual R9700 testing landed at 11.49 tok/s with ~600 tok/s prompt processing under ROCm — reading pace, fine for chat and batch work, frustrating for agent loops. Same 64GB, 2.4× apart. That’s the tier in one sentence: capacity is what you buy, speed is what you pay extra for.

The near-miss: gpt-oss-120b at 64GB

The model everyone builds this tier hoping to run is gpt-oss-120b’s big sibling — the 117B MoE with 5.1B active parameters that has become the default local reasoning model. The official llama.cpp gpt-oss guide puts the MXFP4 GGUF at 59.02 GiB of weights, with total memory at 64.0GB for 8K context, 64.9GB at 32K, and 68.5GB at the full 131K window.

Read those numbers against a 64GB build and you can see the problem: the weights fit, and then the context doesn’t. At any usable window, 64GB misses full residency by roughly a gigabyte — close enough to taste it.

The fix is the one the llama.cpp guide itself recommends: don’t chase full residency. The --n-cpu-moe N flag parks the MoE expert tensors of the first N layers in system RAM, and because only 5.1B parameters activate per token, the penalty for spilling a few layers is small. The reference point from the same discussion thread: a single 32GB RTX 5090 — offloading 21 of the model’s MoE layers — still generates around 30 tok/s at zero context. A 64GB rig offloads 2–4 layers instead of 21, so it operates far closer to the full-GPU end of that curve:

./llama-server -hf ggml-org/gpt-oss-120b-GGUF \
  -c 32768 -fa --jinja --n-cpu-moe 3 --split-mode layer

Start at --n-cpu-moe 3, watch for the CUDA out-of-memory error at load, and step up one layer at a time until it loads clean. It’s a two-minute tuning job, and the result is a frontier-adjacent reasoning model running at conversational speed on hardware that technically shouldn’t hold it. If you’d rather have zero asterisks, that’s precisely what the 96GB tier sells — or a third 3090, which we’ll get to.

The everyday picks: what most 64GB owners actually run

The pattern we documented at 48GB holds here: owners load the giant model for a week, then settle into mid-size models with the compromises removed.

Qwen3.6-35B-A3B at Q8_0 (36.9GB) — the unsloth GGUF that doesn’t fit any single consumer card runs here with ~24GB of cache room, and its ~3B active parameters keep decode fast even split across two cards. This is the tier’s best speed-to-quality ratio, same as one tier down — just with the context rationing gone.

Qwen3.6-27B Q8_0 (28.6GB) plus a whole second stack — the dense coding benchmark leader at 8-bit on one card, with the entire second card free for an embedding model, a reranker, a draft model for speculative decoding, or a second 27B serving a different user. If your endgame is a local backend for coding agents, two dedicated cards beat one shared pool — aicoderscope.com covers the tool-side wiring.

Nemotron 3 Super, cautiously — NVIDIA’s 120B/12B-active MoE lands at 60–80GB in Q4 builds depending on variant (our Nemotron 3 coverage); the low end of that range squeaks into 64GB with quantized KV. Verify the exact GGUF size before downloading 60GB — this one lives on the boundary.

And the standing rule from the 48GB page applies unchanged: if a model fits on one card, run it on one card. Splitting a 27B across two GPUs adds PCIe overhead and subtracts speed. The second card is for models that need it and for running two things at once — never for making a small model faster. Our NVLink vs PCIe breakdown has the mechanics.

What you cannot run at 64GB

The ceiling, so you don’t build a $3,000–$8,700 rig on a wrong assumption:

Model	Smallest useful build	Why it misses
gpt-oss-120b, fully resident	64.9GB at 32K ctx	The one-gigabyte heartbreak — CPU offload or 72GB+
Inkling-Small 276B	88GB quant	The 96GB tier’s ceiling experiment, not yours
Llama 3.3 70B Q8_0	~75GB	Q5_K_M is this tier’s 70B ceiling in practice
MiniMax M3 (428B)	IQ1_M 128GB	Even 1-bit overshoots by half
GLM-5.2 (~753B)	~245GB at 2-bit	Four RTX PRO 6000s — datacenter money
Kimi K3 (2.8T)	Multi-hundred GB	Not a home-lab model in any form

The honest read: 64GB perfects the tiers below it more than it opens a new one. The 70B class gets its proper quant, the 35B class gets unlimited context, and the one genuinely new model — gpt-oss-120b — runs with an asterisk. Every frontier MoE beyond it skipped straight to 96GB-and-up territory.

How to get to 64GB — and why the answer might be 72

Path	Price (Aug 2026)	Bandwidth	The catch
2× AMD R9700	~$3,050–$3,200 street	640 GB/s per card	ROCm/Vulkan stack, 11.49 tok/s on 70B
3× used RTX 3090 (72GB)	~$3,792	936 GB/s per card	Three slots, ~1,050W, platform work
2× RTX 5090	~$8,658	1,792 GB/s per card	Costs more than a used car
”64GB” unified memory	$2,499–$3,799	256–546 GB/s	Not actually 64GB — see below
Rent it on RunPod	$0 upfront	—	The right answer for occasional 120B jobs

Dual R9700s are the value 64GB. Two cards run $3,050–$3,200 street against a $2,598 MSRP (our full comparison has the August listings), and the 64GB pool is real. The cost is software friction and decode speed — 11.49 tok/s on a 70B is livable, not lovable. Read the R9700 guide before committing to the AMD stack.

Triple 3090s are the sleeper. At ResalePrices’ $1,264 August average, three used RTX 3090s cost $3,792 — $600 over the R9700 pair — and buy 72GB of CUDA-native VRAM at 936 GB/s per card. 72GB is the number that matters: gpt-oss-120b’s full 131K-context footprint is 68.5GB, so the third card converts this tier’s asterisk into full residency. The tax is platform reality — a motherboard with three usable x8+ slots, a 1,600W PSU for ~1,050W of GPU load, and the PCIe spelunking our multi-3090 guide exists for.

Dual RTX 5090s are for people whose time costs more than hardware. ~$8,658 at Amazon’s August pricing (the $1,999 MSRP has been fiction since spring) buys the only 64GB that’s also fast — 27 tok/s on a dense 70B, and sub-32GB models at speeds nothing else here approaches. At 18.83¢/kWh (EIA’s April 2026 residential average), ~1,150W of GPU load also runs about $0.22/hour — our math from those two published figures. If you’re already sour on that price, you should be; the 96GB page shows what the same money almost buys.

The “64GB Mac” isn’t in this tier. A Mac Studio M4 Max with 64GB of unified memory ($3,799 for the 40-core GPU configuration, per Sweetwater’s current listing) reserves a chunk of that memory for macOS — the GPU-usable pool lands around 48GB by default, which is why ModelFit’s Mac Studio guide tops out its 64GB recommendations at the 35B Q8 class. Same story for the 64GB Strix Halo mini-PCs: the community Strix Halo benchmarks that measured gpt-oss-120b at 55.57 tok/s on Vulkan did it on the 128GB machine — the 64GB variant caps its GPU pool near 48GB. Unified memory is a fine way to run local AI; just shop it against the 48GB tier, because that’s what you’re getting.

And if gpt-oss-120b twice a week is the whole reason: don’t build. An 80GB card on RunPod runs it fully resident, full context, for a few dollars per session, with none of the PSU math.

If you want the next tier up

The next rung is 96GB — a used RTX PRO 6000 Blackwell if money is no object, or the fourth 3090 if you took the triple-3090 path here (which is the quiet argument for that path: it upgrades incrementally, $1,264 at a time, while dual-card builds upgrade by replacement). 96GB is where gpt-oss-120b runs at full context without flags, where the 70B goes to Q8, and where the 88GB ceiling experiments live. If you’re still deciding whether to climb at all, the GPU buying guide makes the case that most people should stop at 24GB and rent the rest by the hour on RunPod.

FAQ

Is 64GB worth it over 48GB? Only if you have a specific target: 70B at Q5 instead of Q4, gpt-oss-120b with minimal offload, or two resident models. If your daily models are 27B–35B, the 48GB tier already runs them at Q8 and the extra 16GB mostly sits idle.

Dual R9700 or triple 3090? Dual R9700 if you want lower power, fewer slots, and warranty-fresh cards, and you can live with 11.49 tok/s on dense 70Bs. Triple 3090 if gpt-oss-120b full-resident is the goal, you want CUDA, and your motherboard cooperates. The $600 difference is noise next to those two questions.

Can Ollama use 64GB across two cards automatically? Yes — it splits models that don’t fit one card and keeps smaller models single-card. Verify with ollama ps: a CPU percentage in the PROCESSOR column means you’ve spilled past VRAM and should quantize the KV cache or trim context.

Why not one used RTX A6000 plus a 3090 for ~$3,900? It works — llama.cpp splits across mismatched cards — but the slower card gates decode on layer-split, and you inherit two power connectors’ worth of platform complexity for the same money as three matched 3090s. Mixed rigs are for cards you already own, not cards you’re shopping for.

Sources

• guide: running gpt-oss with llama.cpp — ggml-org/llama.cpp discussion #15396
• Llama 3.3 70B Instruct GGUF quant sizes — bartowski / Hugging Face
• 2×RTX 5090 Ollama Benchmark: 70B LLM Inference — Databasemart
• Qwen3.6-35B-A3B GGUF quant sizes — unsloth / Hugging Face
• RTX 5090 32GB for Local LLMs: Runs 32B Q4, 70B Q3 — ModelFit
• Best Local LLMs for Mac Studio (2026) — ModelFit
• AMD Strix Halo — Backend Benchmarks (Grid View) — kyuz0
• Strix Halo guide: Ryzen AI MAX+ 395 local LLM setup and benchmarks — GitHub
• Apple Mac Studio M4 Max 64GB listing — Sweetwater
• RTX 3090 Used GPU Price & Fair Asking Range — ResalePrices

Last updated August 21, 2026. Prices and specs change; verify current rates before purchasing.

Recommended Gear

• AMD Radeon AI PRO R9700 32GB — two of these is the value path to a real 64GB pool
• Used RTX 3090 24GB — three of these is the budget gpt-oss-120b rig
• RTX 5090 32GB — the fast 64GB, if the price doesn’t scare you
• RTX PRO 6000 Blackwell 96GB — the next tier, asterisk-free