DEV Community: RigBase

Every DGX Spark recipe that runs current models, measured

RigBase — Wed, 28 Oct 2026 04:40:10 +0000

The DGX Spark gets a lot of "is it actually fast?" questions. The honest answer depends on the recipe: which quant, which engine, whether speculative decoding is on, and how many Sparks you link together.

Mia's AI Lab publishes open-source DGX Spark recipes (install scripts, engine work and benchmarks on GitHub) for the newest open models. All of the numbers below are theirs. I collected them, checked each decode figure against its recipe page or README, and put them in one table. Full table with links: getrigbase.com/dgx-spark/.

The short version

GLM-5.3 Flash (320B total, 18B active) does not fit one Spark at 4-bit, which is about 160 GB of weights. Mia's TensorFold recipe does 60.4 tok/s on 2 Sparks, 77.6 on 3 and 95.2 on 4, single stream, with prefill of 1,979–2,583 tok/s on a 32k prompt.
Qwen3.8 Flash-Next runs on a single Spark at 48.7 tok/s (NVFP4, vLLM); Mia's TensorFold recipe gives a 46–55 tok/s range.
DeepSeek V4.1 Flash reaches 74.9 tok/s on 2 Sparks (1017 checkpoint, EXL3 2.9-bit + DSpark). That works because about 196.6B of its parameters are Engram lookup tables that do not have to sit in accelerator memory (vLLM recipe).
Full GLM-5.3 (753B) needs 3 Sparks at 2.75 bits (≈259 GB of weights): 31.3 tok/s.

All 19 setups

Decode is single-stream tokens/sec. Prefill is prompt processing on a 32k prompt, where it was listed.

Model	Sparks	Quant	Engine	Decode tok/s	Prefill tok/s	Context	Source
Ling 3.0 Flash	1	INT4 + DSpark	SGLang	83	–	256k	recipe
Muse Glimmer 30B	1	NVFP4 + DFlash	vLLM	35	–	256k	recipe
Nemotron 3.5 Bolt 74B-A9B	1	IQ2_XXS + NVFP4 + LiLiCorr	TensorFold Zig	71	1,375	262k · up to 16 at once	recipe
Ornith 1.5 122B	1	EXL3 4-bit + DFlash2	TensorFold Zig	52.6	1,955	262k · 4 at once	recipe
Qwen3.6 35B-A3B	1	NVFP4 + MTP	vLLM	95.1	–	262k	recipe
Qwen3.8 27B	1	MLX 4-bit + DFlash2	TensorFold	58.3	1,633	262k · 1M with YaRN	recipe
Qwen3.8 27B	1	NVFP4 + DSpark	SGLang	18.3	–	262k · 1M with YaRN	recipe
Qwen3.8 Flash-Next	1	NVFP4	vLLM	48.7	1,769	262k · 512k with YaRN	recipe
Qwen3.8 Flash-Next	1	FP4 QAD or INT4-AR + MTP	TensorFold Zig	46-55	2,430	262k · up to 5 at once	recipe
DeepSeek V4.1 Flash	2	1017 checkpoint, EXL3 2.9-bit + DSpark	TensorFold Zig	74.9	2,175	1M	recipe
DeepSeek V4.1 Flash	2	EXL3 2.9-bit	vLLM	31.6	–	600k	recipe
GLM-5.3 Flash	2	EXL3 4-bit + DFlash2	TensorFold	60.4	1,978.9	1M	recipe
MiMo V2.6 Flash	2	MXFP4	SGLang	35	–	1M	recipe
Qwen3.8 Flash-Next	2	NVFP4 or INT4-AR + MTP	TensorFold Zig	67.4	2,575	1M · ×3 at full context	recipe
Qwen3.8 Flash-Next	2	NVFP4	vLLM	54.4	2,962	262k · 1M with YaRN	recipe
GLM-5.3	3	EXL3 2.75-bit + DSpark	TensorFold	31.3	591.2	~500k	recipe
GLM-5.3 Flash	3	EXL3 4-bit + DFlash2	TensorFold	77.6	2,064.2	1M	recipe
DeepSeek V4.1 Flash	4	1017 checkpoint, FP8 + MXFP4 + DSpark	TensorFold Zig	65.8	4,127.2	1M · up to 16 at once	recipe
GLM-5.3 Flash	4	EXL3 4-bit + DFlash2	TensorFold	95.2	2,583.3	1M	recipe

Most rows use speculative decoding (MTP, DFlash, DSpark, LiLiCorr). It helps predictable text such as code far more than free prose, so do not compare these 1:1 with plain-decode numbers from other GPUs.

Memory math in one line

Each Spark has 128 GB of unified memory (NVIDIA). Weights take about parameters × bits ÷ 8. NVFP4 is about 4.5 bits per weight because every 16 values share an FP8 scale (NVIDIA). Leave room for the KV cache on top. So:

320B at 4 bits is about 160 GB: 2 Sparks.
753B at 2.75 bits is about 259 GB: 3 Sparks.
A 27–35B model at 4 bits is 14–20 GB: one Spark with lots of room for context.

What I left out

Figures I could not find again in the recipe text are not in the table. That covers some card numbers that differ from the README, a chart-only number, and third-party numbers for other GPUs. Setups that are "not benchmarked yet" are also out. The full list is in the import script's skip log.

The table updates as Mia publishes new recipes: getrigbase.com/dgx-spark/. Comparing against a Mac Studio or Strix Halo? See DGX Spark vs Mac Studio vs Strix Halo.

Numbers: Mia's AI Lab (mia-ai.net), read 2026-10-27. RigBase did not re-run them.

What 117 real local-LLM rigs tell us about tok/s per euro in 2026

RigBase — Mon, 26 Oct 2026 07:10:54 +0000

"Which GPU should I buy for local LLMs?" usually gets answered with spec sheets. I wanted an answer from measured numbers, so I took the open RigBase dataset (117 home AI builds, 298 measured results, every row linked to its public source) and divided tokens/sec by what the card costs today.

Short version:

A used RTX 3090 gives about 3× more generation speed per euro than an RTX 5090 on every current model measured on both. The 5090 is 1.76–1.86× faster, but costs ~5.7× as much.
For gpt-oss 20B, 16 GB cards win on value. RTX 5070 Ti and 5060 Ti both deliver ~150 tok/s per €1,000.
Speculative decoding (MTP and friends) gave a median 1.76× speedup in ten same-hardware before/after pairs. That's a free upgrade.

The dataset in one paragraph

117 builds, 298 results, 48 models. 26 of those models are what people currently run (Qwen3.8, Qwen3.6, Gemma 4, gpt-oss, Nemotron 3.5…), and they account for 211 of the results.
Sources: 33 different sites. GitHub repos/issues are the biggest (47 builds), then Reddit (12), llm-speed.com (10) and llamabench.ai (7).
Engines: llama.cpp or Ollama (198 results), vLLM (37), MLX (29), other engines (34).
53 results use speculative decoding and are flagged as such, because they are not comparable 1:1 with plain decode.
Hardware: 72 NVIDIA builds, 24 Apple, 16 AMD, 3 Intel, 2 CPU-only.

It's free under CC BY 4.0: builds.csv and builds.json.

Method (so you can disagree with it)

Speed = decode (generation) tokens/sec as reported by the source. Plain decode only unless stated, single card, no CPU offload. Where a source gives a range, I use the low end.
Price = lowest new listing on billiger.de (Germany, incl. VAT), checked 16–24 Oct 2026. The exception is the RTX 3090, which is out of production. For it I use the used eBay sold median of €1,248 (237 sales, PCPrice.Watch, 24 Oct 2026).
Value = tok/s ÷ GPU price × 1000, i.e. tok/s per €1,000 of GPU. GPU only: no CPU, RAM, PSU or case.
Different sources use different quants and builds. I group comparisons by source wherever possible, and you should treat gaps under ~10% as noise.

1. gpt-oss 20B: one source, six cards

All of these are llama-bench runs in native MXFP4 from the same llama.cpp thread (discussion #15396), so this is the cleanest comparison in the set.

GPU	tok/s	Price	tok/s per €1k
RTX 5070 Ti	189.45	€1,245 new (2026-10-24)	152.2	build
RTX 5060 Ti 16GB	111.51	€739 new (2026-10-16)	150.9	build
RTX 3090 (used)	161.77	€1,248 used (eBay sold median)	129.6	build
RTX 5080	204.85	€1,770 new (2026-10-24)	115.7	build
RTX 5090	282.51	€7,140 new (2026-10-24)	39.6	build
RTX Pro 6000 Blackwell	286.91	€16,885 new (2026-10-24)	17.0	build

The 5090 is only 1.49× faster than a 5070 Ti here (282.51 vs 189.45), yet it costs 5.7× as much. A 20B MoE in MXFP4 fits comfortably in 16 GB, so the extra VRAM buys you nothing on this model.

Same test rig, with power

Jeff Geerling's ai-benchmarks swaps cards in one Core Ultra 265K system and records peak whole-system power:

GPU	gpt-oss 20B tok/s	Price	tok/s per €1k	Peak system power	tok/s per W
RTX 3060 12GB	83.96	€429 (2026-10-16)	195.7	229.3 W	0.37
RTX A4000	93.55	€1,050 (2026-10-24)	89.1	199.4 W	0.47
Radeon AI Pro R9700	163.26	€1,848 (2026-10-24)	88.4	332.9 W	0.49
RTX 4090	279.65	€3,955 (2026-10-16)	70.7	509.1 W	0.55

Sources: #40, #36, #35, #43. The quant isn't stated in his summary table.

The cheap card wins on value and the fast card wins on efficiency. The €429 RTX 3060 has the best tok/s per euro in the dataset for this model. One caveat: gpt-oss 20B's weights are about 13 GB, more than the card's 12 GB, so part of the model may have run from system RAM. The 4090 draws more than twice the power, but gets the most tokens per watt.

2. Current 24–32 GB models: used 3090 vs 4090 vs 5090

Here are single-card results on current models, without speculative decoding. Each cell shows measured tok/s → tok/s per €1k.

Model	RTX 3090 (used, €1,248)	RTX 4090 (€3,955)	RTX 5090 (€7,140)	5090 ÷ 3090 speed
Qwen3.6 35B-A3B	146 → 117.0	160.6 → 40.6	258 → 36.1	1.77×
Gemma 4 31B	38.8 → 31.1	43.8 → 11.1	71.3 → 10.0	1.84×
Nemotron 3.5 Bolt 74B-A9B (2-bit)	87.75 → 70.3	108 → 27.3	154.7 → 21.7	1.76×
Qwen3.8 27B	40.4 → 32.4	—	75.2 → 10.5	1.86×

Sources per row:

Qwen3.6: 3090 llamabench (low end of 146–153), 4090 llm-speed, 5090 llamabench.
Gemma 4 31B: 3090, 4090, 5090.
Nemotron Bolt: llm-speed post for the 3090 and 5090, llamabench for the 4090.
Qwen3.8 27B: 3090 OpenJet README (llama.cpp, no speculation), 5090 llm-speed.

On all four models the used 3090 gives 3.1–3.2× more tok/s per euro than the 5090. The 5090 is consistently ~1.8× faster, which tracks its memory bandwidth (1,792 vs 936 GB/s). It also has 8 GB more VRAM, which matters for long context. If raw speed is the goal, buy the 5090. If value is the goal, the used 3090 remains the card to beat in late 2026.

3. The cheapest upgrade: speculative decoding

Here are ten before/after pairs where the same build ran the same model with the same engine and quant, and the only change was turning on a draft method (MTP, DSpark):

Setup	Model	Plain tok/s	With drafting	Speedup
RTX 3090, llama.cpp Q4_K_M, MTP 2 drafts (code prompt)	Qwen3.8 27B	40.4	72.5	1.79×
RTX 3090, llama.cpp Q4_K_M, MTP 2 drafts (reasoning prompt)	Qwen3.8 27B	40.4	50.9	1.26×
Strix Halo, llama.cpp Vulkan Q6_K, MTP n=2	Qwen3.8 27B	9.59	18.01	1.88×
Strix Halo, llama.cpp ROCm Q8_0, MTP n=3	Qwen3.8 27B	7.76	15.67	2.02×
Strix Halo, llama.cpp Vulkan Q8_0, MTP n=3	Qwen3.8 27B	7.77	13.19	1.70×
DGX Spark, vLLM, MTP k=2	Qwen3.8 27B	11	19	1.73×
DGX Spark, vLLM, MTP drafter k=3	Gemma 4 26B-A4B	30.8	56.5	1.83×
DGX Spark, vLLM NVFP4, MTP k=2	Qwen3.6 35B-A3B	78.1	102.3	1.31×
DGX Spark, vLLM, DSpark k=3	Nemotron 3.5 Lightning 30B-A3B	70.3	94.4	1.34×
2× Tesla V100, bnk Q8_0, MTP	Qwen3.8 27B	42.4	104	2.45×

Sources: OpenJet, Sleeping Robots, howquant.dev, Cristian Tala, bnk.

The speedups range from 1.26× to 2.45×, with a median of 1.76×. That's roughly the gap between a 3090 and a 5090, and it costs nothing. Two patterns show up:

Small-active-parameter MoEs gain least. The dense Qwen3.8 27B gained 1.70–2.45× in every pair except one reasoning-prompt run, and Gemma 4 26B-A4B gained 1.83×. The ~3B-active MoE models (Qwen3.6 35B-A3B, Nemotron Lightning) gained only 1.31–1.34×.
The prompt matters. On the same 3090, MTP gave 1.79× on a code prompt but 1.26× on a reasoning prompt. Predictable text gets more drafts accepted.

The catch is that drafting numbers are not comparable with plain decode across sources. That's why RigBase flags them ⚡ and lets you hide them.

4. Big models: where there's no good per-euro answer yet

For ~100B+ models, the hardware is mostly unified-memory boxes (Mac Studio, Strix Halo, DGX Spark), and I don't have comparable price data for them yet. So here are the raw measured speeds for gpt-oss 120B:

Hardware	tok/s	Engine
RTX Pro 6000 Blackwell (96 GB)	196.31	llama.cpp MXFP4	source
Apple M2 Ultra 76-core (192 GB)	79.68	llama.cpp MXFP4	source
Ryzen AI Max+ PRO 495 (Radeon 8065S)	55.8	llama.cpp Vulkan MXFP4	source
Ryzen AI Max+ PRO 395 (Radeon 8060S)	44.7	llama.cpp Vulkan MXFP4	source
DGX Spark (GB10)	44.4	vLLM, 128K ctx	source

A €16,885 card is 2.5× faster than a 2023 Mac Studio, and the Strix Halo boxes match the DGX Spark. If you know reliable current prices for these systems, I'd like to add them.

Takeaways

Up to ~20B MoE (gpt-oss 20B, Qwen3.5 9B, Gemma 4 12B): buy a 16 GB card. The RTX 5060 Ti and 5070 Ti tie on value at ~150 tok/s per €1k.
27–35B (Qwen3.8 27B, Qwen3.6 35B-A3B, Gemma 4 31B): a used RTX 3090 gives ~3× the value of a 5090. The 5090 is ~1.8× faster.
Before buying anything, turn on speculative decoding. In this data it was worth a median 1.76×.
Don't buy a halo card for value. The RTX Pro 6000 is at 17 tok/s per €1k on gpt-oss 20B, versus 152 for a 5070 Ti.

Get the data, add yours

Browse by GPU, by VRAM size, or check if a model fits your card.
Download everything: getrigbase.com/data (CSV + JSON, CC BY 4.0, attribution "RigBase").
Ran llama-bench on a current model? Submit it. It needs a public proof link, and that's the only way a number gets in.

Data snapshot: RigBase builds.json, 24 Oct 2026. Prices: billiger.de 16–24 Oct 2026; used RTX 3090 from PCPrice.Watch, 24 Oct 2026. All ratios are arithmetic on the sourced numbers. Corrections welcome.

What GPU do you need for Qwen3.8, Qwen3.6, Gemma 4 and gpt-oss locally? (measured, Oct 2026)

RigBase — Sat, 24 Oct 2026 19:12:56 +0000

Every time a new open model comes out, people ask the same thing: will it run on my card, and how fast? Spec-sheet calculators can tell you whether the weights fit. They can't tell you what speed you'll actually get. So here are measured generation speeds (decode tokens/sec) for the models people are running in October 2026, collected from public benchmarks. Every number is linked to the place it came from.

How to read the numbers

Speeds are generation (decode) tokens/sec at short context unless noted. Prompt processing is a different number and is usually much faster.
Sources use different engines, quants and llama.cpp builds. Treat gaps under ~10% as noise.
"llamabench community" rows are aggregated llama-bench tg128 runs from llamabench.ai. Open the source for the exact quant and build.

TL;DR

If you have…	What runs well (measured)
12 GB (RTX 3060)	Gemma 4 12B at 38.5 tok/s, gpt-oss 20B at 84 tok/s
16 GB (RTX 5060 Ti / 5070 Ti / 5080)	gpt-oss 20B at 112 / 189 / 205 tok/s
24 GB (RTX 3090 / 4090)	Qwen3.6 35B-A3B at 140–153 tok/s on a 3090; Qwen3.8 27B at 40.4 tok/s (72.5 with MTP) on a 3090; Gemma 4 31B at 43.8 tok/s on a 4090
32 GB (RTX 5090)	Qwen3.6 35B-A3B at 258, Qwen3.8 27B at 75.2, Gemma 4 31B at 70 tok/s
96 GB+ (RTX Pro 6000, Macs)	gpt-oss 120B at 196 tok/s (Pro 6000) / 79.7 tok/s (M2 Ultra)

Details and sources below.

1. gpt-oss 20B: the one model everyone has benchmarked

gpt-oss 20B runs in its native MXFP4 format, so these numbers compare well across cards. These are llama-bench tg128 results from the official llama.cpp gpt-oss guide (discussion #15396), plus Apple results:

Hardware	Memory	gpt-oss 20B tok/s	Source
RTX Pro 6000 (Blackwell)	96 GB	286.91	llama.cpp #15396
RTX 5090	32 GB	282.51	llama.cpp #15396
RTX 5080	16 GB	204.85	llama.cpp #15396
RTX 5070 Ti	16 GB	189.45	llama.cpp #15396
RTX 3090	24 GB	161.77	llama.cpp #15396
Apple M2 Ultra (76-core GPU)	192 GB	116.08	llama.cpp #4167
Apple M3 Ultra	512 GB	115.52	llama.cpp #15396
RTX 5060 Ti 16GB	16 GB	111.51	llama.cpp #15396
Apple M4 Max (MacBook)	36 GB	92.36	llama.cpp #15396
Apple M1 Max	64 GB	75.15	llama.cpp #15396

Takeaway: a 16 GB card is enough for gpt-oss 20B. Even the 5060 Ti does over 100 tok/s, which is far faster than you can read.

Speed and power: whole-system measurements

Jeff Geerling's ai-benchmarks records peak whole-system power during each run. That data is rare. (His summary table doesn't state the quant.)

System	gpt-oss 20B tok/s	Peak system power	tok/s per W (arithmetic)	Source
Core Ultra 265K + RTX 4090	279.65	509.1 W	0.55	#43
Core Ultra 265K + Radeon AI Pro R9700 (32 GB)	163.26	332.9 W	0.49	#35
Core Ultra 265K + RTX 4070 Ti	163.14	298.7 W	0.55	#45
Mac Studio M3 Ultra 512 GB	115.29	227 W	0.51	#42
Core Ultra 265K + RTX A4000	93.55	199.4 W	0.47	#36
Dell Pro Max GB10 (DGX Spark)	87.97	122.8 W	0.72	#34
Core Ultra 265K + RTX 3060	83.96	229.3 W	0.37	#40

The DGX Spark is the slowest box here on raw speed, but it gets the most tokens per watt. The 4090 is the fastest, at about 4× the Spark's peak draw.

2. gpt-oss 120B: you need ~96 GB of fast memory

Hardware	gpt-oss 120B tok/s	Source
RTX Pro 6000 (Blackwell, 96 GB)	196.31	llama.cpp #15396
Apple M2 Ultra 192 GB	79.68	llama.cpp #4167

3. Qwen3.6 35B-A3B: the 24 GB sweet spot

It's a mixture-of-experts model with only ~3B active parameters, so it runs very fast once it fits.

Hardware	Setup	tok/s	Source
RTX 5090 (32 GB)	llama-bench tg128	258	llamabench.ai
4× RTX 3090 (using 2)	vLLM, AWQ-INT4, TP=2 + MTP-3 speculative decoding	225–231	tfriedel/qwen3.6-rtx3090-lab
4× RTX 3090 (using 2)	vLLM, AWQ-INT4, TP=2	149	same
RTX 3090 (24 GB)	llama-bench tg128	146–153	llamabench.ai
RTX 3090 (24 GB)	Q4 GGUF, all layers on GPU, ~90K context	139.6	Giles Thomas
RTX 3090 (24 GB)	llama.cpp, IQ4_XS, 1 GPU	115–133	tfriedel lab
RTX 4090 (24 GB)	llama.cpp, Q4_K_M	160.6	llm-speed
Apple M5 Max (36 GB)	oMLX, 4-bit MLX	145.8	Rapid-MLX compare
Intel Arc Pro B70 (32 GB)	vLLM XPU, GPTQ Int4, no MTP	120	riceharvest cookbook
DGX Spark (GB10)	vLLM, NVFP4, 128K ctx, no spec. decoding	78.1	Cristian Tala
Strix Halo (Radeon 8060S, 96 GB)	llama-bench tg128	50.2–62.4	llamabench.ai

Two things stand out:

One used RTX 3090 is enough. Giles Thomas got 139.6 tok/s while keeping ~90K tokens of context on the GPU. At the full 262K context, with 12 layers of FFNs moved to the CPU, he still got about 66 tok/s (source).
A second 3090 helps through vLLM, not llama.cpp. Tensor parallel with AWQ went from 115–133 to 149 tok/s, and adding MTP speculative decoding pushed it to 225–231.

4. Qwen3.8 27B: the new default dense model

Qwen3.8 27B replaced Qwen3.6 27B and is now the most-benchmarked model in RigBase (50 results). It's dense, so every token reads all ~27B weights, and speed follows memory bandwidth. These are plain decode numbers, without speculative decoding:

Hardware	Setup	tok/s	Source
RTX 5090 (32 GB)	llama.cpp, Q4_K_M	75.2	llm-speed
RTX 3090 (24 GB)	OpenJet megakernel, Q4_K_M	42.9	OpenJet
RTX 3090 (24 GB)	llama.cpp, Q4_K_M	40.4	OpenJet
Apple M5 Max (128 GB)	MLX 4-bit	31	Baobab Tech
Radeon AI Pro R9700 (32 GB)	Ollama, Q4_K_M (includes hidden reasoning tokens)	30	vaditaslim
RTX 5060 Ti 16GB	llama.cpp, UD-IQ4_XS, 8K ctx	28.0	JESVS
Intel Arc Pro B70 (32 GB)	llama.cpp SYCL, Q4_K_M	27.8	b70-optimization-lab
Strix Halo (Radeon 8060S)	llama.cpp ROCm, Q4_K_M	12.6	AkitaOnRails
DGX Spark (GB10)	vLLM, 128K ctx	11.0	Cristian Tala
RTX 3060 12GB	llama-bench (doesn't fit, offloads)	5.2–6.7	llamabench.ai

Turn on MTP. Qwen3.8 supports multi-token-prediction (MTP) drafting, and in same-hardware tests it helps a lot. On the RTX 3090 it took llama.cpp from 40.4 to 72.5 tok/s on a code prompt (50.9 on a reasoning prompt) (OpenJet). On Strix Halo it took Vulkan Q6_K from 9.59 to 18.01 (Sleeping Robots), and on the DGX Spark it took vLLM from 11.0 to 19.0 (Cristian Tala).

5. Gemma 4 and Qwen3.6 27B: dense models, where bandwidth wins

Dense models read every weight for every token, so speed follows memory bandwidth. Here are llamabench community tg128 results:

Model	RTX 5090	RTX 4090	5090 ÷ 4090 (arithmetic)
Gemma 4 31B	70.0	43.8	1.60×
Qwen3.6 27B (legacy, now Qwen3.8 27B)	75.7	47.0	1.61×
Gemma 4 26B-A4B (MoE)	235	164	1.43×
Gemma 4 12B	142	98.1	1.45×
gpt-oss 20B	313	203	1.54×

Sources: RTX 5090, RTX 4090.

On dense ~30B models, the 5090 is about 1.6× faster than the 4090. On the MoE models the gap is smaller.

For the RTX 3090, llamabench lists 40.2 tok/s on Qwen3.6 27B (source). That row includes some runs with speculative decoding, so don't compare it directly with the table above.

Gemma 4 12B on smaller cards (llamabench community):

Card	Gemma 4 12B tok/s	Source
RTX 5070 Ti (16 GB)	87.6	llamabench.ai
RTX 3060 (12 GB)	38.5	llamabench.ai

So what should you buy?

Based only on the numbers above:

gpt-oss 20B / Gemma 4 12B: any 16 GB card works. A 12 GB RTX 3060 runs both at usable speeds.
Qwen3.6 35B-A3B: a single 24 GB card. A used RTX 3090 does 140–153 tok/s.
Dense ~30B (Qwen3.8 27B, Gemma 4 31B): 24 GB fits them at Q4. A used 3090 does ~40 tok/s on Qwen3.8 27B (≈72 with MTP); the RTX 5090 does 75.2 and is ~1.6× faster than a 4090 on Gemma 4 31B.
gpt-oss 120B: a 96 GB GPU or a big-memory Mac.
Lowest power: the DGX Spark had the best tokens-per-watt on gpt-oss 20B in Geerling's tests, though it was the slowest box.

Missing your card?

The full dataset has 117 builds and 298 measured results, with parts lists, power draw and a link to every source: RigBase. Browse by GPU or by VRAM size, check fit on the Can it run? calculator, or download it all free as CSV/JSON (CC BY 4.0).

If you've run llama-bench on a current model, submit it. It needs a proof link, and that's the only way a number gets in.

Data snapshot: RigBase builds.json, first published 19 Oct 2026, updated 24 Oct 2026. Corrections welcome. Every row links to its source, so check there first.