TL;DR: The RTX 5090 (32GB at 1,792 GB/s) decodes small and mid-size models 4–7× faster than a DGX Spark, but at October 2026 street prices it costs $4,300–$5,000+ and still can’t hold anything over ~28GB. The Spark (64GB/$4,999 or 128GB/$6,950, 273 GB/s) runs 60–120GB models the 5090 physically can’t — at speeds a used Strix Halo box matches for $2,000–$4,000 less.

	RTX 5090	DGX Spark 128GB	Strix Halo 128GB (reference)
Memory / bandwidth	32GB GDDR7 @ 1,792 GB/s	128GB LPDDR5X @ 273 GB/s	128GB @ 256 GB/s
Llama 3.1 8B Q4 decode	~150 tok/s	~38 tok/s	30–33 tok/s
gpt-oss-120b (61GB)	8–30 tok/s, CPU-offload hack	38.5 tok/s, just works	31–56 tok/s
Real price, Oct 2026	$4,299 (Micro Center) – $5,050 avg; MSRP $1,999 is fiction	$6,950 FE ($4,999 for 64GB)	$2,959–$3,649 complete
The catch	Needs a $1,500+ host PC; 70B+ models don’t fit	Slowest $7K you can spend on models that fit in 32GB	No CUDA; weak prefill

Honest take: If your daily models fit in 24–32GB, the 5090 is the fastest consumer card ever made — and still a bad buy at 2.2–2.5× MSRP when a used RTX 3090 runs the same models at a quarter of the price. If you need 100GB-class capacity, the Spark works out of the box, but you’re paying roughly double a Strix Halo box for CUDA and prompt-processing speed, not for tokens per second.

NVIDIA’s $4,999 64GB DGX Spark goes on sale today, October 23, through Acer, ASUS, Dell, Gigabyte, HP, and MSI — which makes this the first week you can walk into the decision with both machines actually purchasable at roughly the same money. An RTX 5090 from Micro Center’s in-store stock runs $4,299; the partner Sparks start at $4,999. Same budget, two completely different answers to “what should my home lab run?”

They are not competitors in any spec sheet. One is a 575W graphics card with the highest memory bandwidth ever shipped to consumers; the other is a 240W desktop appliance with 2–4× the memory at 15% of the bandwidth. But they compete for the same ~$5,000, and r/LocalLLaMA has spent October arguing about exactly this trade-off. Here’s the version with checked numbers.

The one formula that decides everything

Decode speed — the rate at which tokens appear after the model starts answering — is memory-bandwidth-bound. The hard ceiling is bandwidth divided by the gigabytes of weights read per token, and measured results land at 40–95% of it depending on stack maturity:

	RTX 5090	DGX Spark
Bandwidth	1,792 GB/s	273 GB/s
Ceiling, 8B Q4_K_M (4.9GB/token)	~366 tok/s	~56 tok/s
Measured (Ollama, Spheron test)	150 tok/s	38 tok/s
Measured (tuned llama.cpp)	up to 213 tok/s	—

That 4–6× decode gap holds for every model that fits in both machines. On gpt-oss-20b, llama.cpp’s community benchmark thread puts the 5090 at 282.5 tok/s where the Spark measures around 60. On the Qwen3.5-35B-A3B MoE, the 5090 decodes at 194 tok/s; the GB10 platform lands in the mid-40s on the comparable 30B-class Q8. If a model fits in 32GB, the 5090 isn’t somewhat faster — it’s a different category of machine.

The Spark’s counter is capacity. Its 128GB holds gpt-oss-120b (61GB in native MXFP4), GLM-4.x-class MoE quants, and dense 70B models whole. The 5090’s 32GB holds none of them. And capacity, not speed, decides whether a model runs at all.

Where the 5090 wins: everything under ~28GB

The 32GB card owns the tier where most daily local-AI work actually happens:

• Coding models. Qwen3.6-27B at Q4_K_M (~16.5GB) fits with 60K+ tokens of context headroom. As a local backend for Cline or Continue.dev, the 5090’s throughput means a coding agent that re-reads and regenerates constantly simply waits less — 1.9× less than a 5080, 4× less than any 273 GB/s box.
• Prompt processing. Hardware Corner clocked the 5090 near 10,000 tok/s prefill on gpt-oss-20b. The Spark’s Blackwell tensor cores are no slouch (~1,723 tok/s prefill on the much larger gpt-oss-120b, about 5× a Strix Halo), but on same-size models the 5090 chews through long contexts several times faster. For RAG and agentic loops over 50K-token prompts, prefill is the wait you actually feel.
• Image and video generation. FLUX-class diffusion models and ComfyUI video workflows are compute- and bandwidth-hungry but fit comfortably in 32GB, where the 5090 is the fastest thing a consumer can plug in — when it’s in stock.

The honest caveat we keep repeating in the 5090 vs 4090 vs 3090 breakdown: at 150–282 tok/s you are a full order of magnitude past human reading speed (~7–10 tok/s). For interactive chat, a $1,456–$1,558 used RTX 3090 delivers the same subjective experience on the same models. The 5090’s speed only converts to value in batch, agentic, or multi-user work.

Where the Spark wins: the models that don’t fit

Load gpt-oss-120b on both machines and the picture inverts.

On the Spark 128GB, it loads and decodes at 38.5 tok/s, fully resident, no configuration beyond ollama run. On the 5090, the 61GB model doesn’t fit, so you reach for llama.cpp’s --n-cpu-moe flag: keep attention layers on the GPU, spill expert weights to system RAM. Now your “1,792 GB/s GPU” is actually bottlenecked by your motherboard’s dual-channel DDR5 — and the results show it:

• Hardware Corner measured 8.1–9.6 tok/s with --n-cpu-moe 21 on the F16 GGUF
• A llama.cpp user with the MXFP4 build and fast DDR5 reported ~30 tok/s at zero context
• RAM speed dominates: one documented tuning case tripled generation (10 → 30 tok/s) just by enabling XMP, taking DDR5 from 2000 to 6000 MT/s

So on the one model every Spark benchmark is built around, a well-tuned 5090 rig approaches the Spark; a default one gets crushed by it. Either way nobody wins by much — both land in the 10–40 tok/s band, and the Spark gets there with zero flags on a 240W power budget instead of a 575W card plus a 1,000W PSU.

There’s also a workload where the Spark’s number isn’t the single-stream one at all. Spheron’s October testing found a single Spark serving 8 concurrent vLLM requests at 289–313 tok/s aggregate, and an independent test pushed small-model aggregate throughput past 1,400 tok/s at 64 concurrent requests. A family AI server or a team tool behind Open WebUI cares about aggregate, not single-stream — concurrency is the Spark’s quiet redemption. Fine-tuning is the loud one: QLoRA on 70B has been measured north of 5,000 tok/s training throughput on the GB10, with the full CUDA/DGX OS container stack behind it. That is work a 32GB card can’t hold and a Strix Halo can’t CUDA.

One capacity trap to be clear about: dense 70B at Q4_K_M (42.5GB) fits in the Spark and runs at ~2.6 tok/s — bandwidth strangles it. The 5090 with CPU offload actually does better (ModelFit measured 14–22 tok/s, stuttery). Neither machine is a good 70B-dense box; that tier belongs to dual used 3090s. The Spark’s capacity only pays off on MoE models, where 128GB of weights sit resident but only ~3GB cross the bus per token.

What they actually cost in October 2026

Neither machine sells at its famous number.

RTX 5090: the $1,999 MSRP has not existed at retail all year. First-party online stock collapsed in mid-September — we tracked the disappearance — and in mid-October third-party marketplace asks ran $8,000–$10,000 on Amazon and Newegg. Realistic buying paths: Micro Center in-store from ~$4,299, brief first-party windows around $4,999 (B&H, per BestValueGPU’s October log), Pangoly’s US average at ~$5,050 and climbing ~9% month-over-month. Used cards trade around $3,822 on eBay.

DGX Spark: $4,999 for the new 64GB partner SKUs (storage varies by partner — treat it as the floor), $6,950 for the 128GB Founders Edition after the October 2 hike. That’s 74% above its original $3,999 list; NVIDIA blames the same DRAM squeeze that has 64GB DDR5 kits at $680–$1,070. And the 64GB model can’t hold gpt-oss-120b, which we covered when the SKU was announced — for local inference it’s the wrong config to buy.

The totals diverge further because the 5090 is a component and the Spark is a computer. A 5090 needs a host: CPU, motherboard, 32–64GB of crisis-priced DDR5, a 1,000–1,200W PSU, case, storage — $1,500–$2,500 on top at current memory prices, for a true total of $5,800–$7,500. The Spark is $6,950, done, with 4TB of encrypted NVMe included. Measured by all-in cost, they’re the same money. Power diverges the other way: 575W for the card alone versus 240W for the whole Spark — at the $0.12/kWh rate from our home-server power math, $0.069/hr versus $0.029/hr under load.

The problem both of them have: the $3,000 box in the corner

Every comparison of these two machines has a third column it tries not to look at. A 128GB Strix Halo mini-PC — Minisforum MS-S1 Max at ~$2,959, Framework Desktop at $3,449, GMKtec EVO-X2 at $3,499–$3,649 — moves 256 GB/s, within 7% of the Spark’s bandwidth. On gpt-oss-120b it decodes at 31–56 tok/s depending on stack: statistically tied with the $6,950 Spark on the workload the Spark is marketed on.

What the Spark premium buys over Strix Halo is real but specific: CUDA and the DGX container stack, ~5× prefill, NVFP4 kernels, fine-tuning that actually works, and ConnectX-7 clustering. What the 5090 premium buys over a used 3090 is equally specific: 1.9× bandwidth, 8GB more VRAM, FP4 support, and a warranty. If neither list of specifics describes your work, the cheaper machine in each category delivers the same tokens. The full breakdown by VRAM tier shows what each capacity class actually unlocks.

What to actually buy

Prices as of October 2026, all verified in the comparison above:

Your situation	The machine	Price	Where
Daily driver for 8B–35B models, agents, image gen — and the price does not stop you	RTX 5090	$7,000–$9,000	Check price
You need 60–120GB MoE models plus CUDA for fine-tuning or dev work that ships to datacenter GPUs	DGX Spark 128GB	$6,950	Check price
You want 100B-class models at home and only care about inference	GMKtec EVO-X2 128GB (Strix Halo)	$3,499–$3,649	Check price
Everything you run fits in 24GB (most readers)	Used RTX 3090	$1,456–$1,558	Check price
Undecided — benchmark your actual workload on both classes first	Rented 5090, from $0.25/hr	pay per hour	Vast.ai

Run your exact model-plus-context combination through the VRAM calculator before committing — the 32GB-vs-128GB line is the entire decision, and it’s cheaper to find out where your workload sits before spending $5,000. Renting both tiers for an evening costs less than a pizza.

FAQ

Is the DGX Spark faster than an RTX 5090 at anything?

Three things: models over 32GB (they simply don’t run resident on the 5090), aggregate throughput under heavy concurrency (289–313 tok/s at 8 vLLM streams, where the 5090’s 32GB limits batch+KV-cache room on bigger models), and performance-per-watt (240W system versus 575W card). Single-stream on any model that fits in 32GB, the 5090 wins by 4–7×.

Can the RTX 5090 run gpt-oss-120b at all?

Yes, via llama.cpp --n-cpu-moe offload — but generation speed is then set by your system RAM, not the GPU. Measured results span 8–30 tok/s depending on RAM speed and quantization, versus the Spark’s 38.5 tok/s fully resident. Enable XMP before concluding your setup is broken; stock-clocked DDR5 has been documented costing two-thirds of offloaded throughput.

Should I buy the $4,999 64GB Spark instead of the 128GB?

For local LLM inference, no. It has identical bandwidth (so identical speed) and it can’t hold gpt-oss-120b — the main reason to own a Spark. It makes sense as a CUDA dev appliance for sub-50GB workloads. Two clustered 64GB units cost $9,998 against $6,950 for one 128GB machine.

Does the 5090’s FP4 support matter?

On Blackwell, NVFP4 quants run roughly 2× the Q4_K_M speed on supported models (160 vs 70 tok/s on Qwen3.6-27B in our earlier testing), and the Spark shares the same Blackwell generation so both benefit. The 5090’s advantage is that its bandwidth makes NVFP4 gains land on top of an already-fast baseline.

Is either machine a good value right now?

Bluntly: no. Both carry crisis pricing — the 5090 at 2.2–2.5× MSRP, the Spark 74% over launch list. The value picks remain the used RTX 3090 for the ≤24GB tier and Strix Halo boxes for the 128GB tier. Buy the 5090 or Spark when your workload specifically needs what only they do: top-tier bandwidth with CUDA, or big-MoE capacity with CUDA, respectively.

Recommended Gear

Only products linked above:

• RTX 5090 32GB — $4,299 in-store Micro Center to ~$5,050 average online; never pay third-party $8K asks
• NVIDIA DGX Spark — buy the 128GB ($6,950) or don’t buy one
• GMKtec EVO-X2 128GB — $3,499–$3,649, the inference-only capacity pick
• Used RTX 3090 24GB — $1,456–$1,558, still the default answer

Sources

• DGX Spark vs RTX 5090 for local LLMs: tokens per second — Spheron
• NVIDIA DGX Spark 64GB launches at $4,999, 128GB rises to $6,950 — WindowsForum
• NVIDIA DGX Spark 64GB price and partner launch — tbreak
• GPT-OSS 120B: offloading MoE layers to CPU on RTX 3090 and 5090 — Hardware Corner
• RTX 5090 LLM benchmarks: ~10K tok/s prompt processing — Hardware Corner
• Running gpt-oss with llama.cpp, community benchmarks — ggml-org discussion #15396
• Optimizing gpt-oss-120b on consumer hardware: XMP tripled generation speed — carteakey.dev
• RTX 5090 price history: $4,999 new / $3,822 used, October 2026 — BestValueGPU
• RTX 5090 US price trend, ~$5,050 average — Pangoly
• RTX 5090 shortage: third-party asks to $8,500+, Micro Center from $4,299 — Tech Insider
• RTX 5090 vs 5080: 213 vs 132 tok/s on 8B models — Local AI Master
• Which inference engine wins on the DGX Spark: vLLM concurrency scaling — Michael Hannecke, Medium

Last updated October 23, 2026. Prices and specs change; verify current rates before purchasing.

Get the numbers before you buy

New GPU and mini-PC benchmarks, VRAM thresholds, and price checks — sent when there's something worth acting on, not on a schedule. No spam, unsubscribe anytime.

Email address Subscribe