Two objects with nothing in common, one buying question
On one side, a 575 W card that demands a case, an oversized power supply and serious airflow. On the other, a golden cube the size of a book, complete, silent, sitting next to the monitor. Everything separates them except the moment you price them: with the shortage pushing the RTX 5090 far above MSRP (from ~$3,000 on the US street), the DGX Spark at $4,699 now plays in a comparable envelope. At overlapping budgets, you have to choose. And the right criterion is neither the petaflop nor the core count: it is the shape of your workload.
The whole duel reduces to one trade-off: memory eliminates, bandwidth ranks. Here are the two spec sheets side by side, then what the measurements say.
| DGX Spark (GB10) | RTX 5090 (desktop) | |
|---|---|---|
| Memory | 128 GB unified LPDDR5X | 32 GB GDDR7 |
| Bandwidth | ~273 GB/s | ~1,792 GB/s (6.5×) |
| CUDA cores | 6,144 (RTX 5070 class) | 21,760 |
| Power | whole machine, 240 W max (~170 W measured under load) | card alone, 575 W |
| Form factor | standalone mini PC (Linux DGX OS) | a card to integrate (full PC required) |
| Observed price | $4,699 (official MSRP) | $2,999+ US street ($1,999 MSRP) |
What the measurements say: bandwidth decides
For a dense model generating one sequence, each decode step reads the active weights and cache; memory traffic often limits throughput. MoE reads only the selected experts, and batching shares weight reads across requests. LMSYS measured about 205 tokens/s on the 5090 versus 50 on DGX Spark for GPT-OSS 20B with Ollama. That approximately fourfold gap does not establish a universal scaling law, nor isolate bandwidth from kernels, scheduling and runtime overhead.
prefill The opening phase of LLM inference: prompt tokens are processed in parallel to build the context state. That reuse raises arithmetic intensity and can make the phase compute-bound; the exact regime depends on the model, batch, context and backend. has higher arithmetic intensity, but that does not make DGX Spark faster. On the same cited 20B Ollama test, the 5090 also leads at prompt processing. Measure time to first token separately from decode The autoregressive generation phase of an LLM: one token is produced at a time while rereading weights and the relevant context state. At low batch sizes, that traffic can make decode memory-bandwidth-bound. Its share of total cost still depends on input and output lengths, batching and cache reuse. latency and total throughput.
The verdict by model size
Models that fit completely in 32 GB: the 5090 is a strong candidate for interactive generation. Check the actual quantized file, context, batch and runtime allocation. Parameter count alone does not guarantee that a 30B model fits, and the fourfold GPT-OSS 20B result cannot be copied to every model.
Dense 70B: roughly 42 GB of Q4_K_M weights already exceed a single 5090. Spark can hold that weight budget, but context and buffers still matter. The cited 2.7 tokens/s measurement uses FP8, not Q4_K_M; it must not be presented as Q4 speed. With a hypothetical 70 GB FP8 weight payload, 273 / 70 gives a simplified ceiling of 3.9 tokens/s at batch one. Measure your chosen quantization before deciding whether its latency is acceptable.
100B+ MoE: the Spark, by forfeit. A GPT-OSS 120B (~65 GB of MXFP4 weights, ~80 GB loaded) does not fit in any consumer card, 5090 included. The Spark loads it and serves it at ~38 tokens/s measured in llama.cpp (~50 with SGLang: the figure is runtime-dependent), because a MoE only reads a fraction of its weights per token: capacity pays, bandwidth strangles less. It is the only segment where the duel has a single contender, and it is precisely what the Spark exists for.
The extended duel: RTX 5070, RTX 5090 Laptop and RTX Spark
Searches attach other names to this duel, and dismissing them properly avoids several buying mistakes. The first hides in the name itself: the RTX 5090 Laptop is not a shrunken desktop 5090, it is a different chip (GB203, the desktop 5080’s die) with 24 GB of GDDR7 at ~896 GB/s and 10,496 cores within 95 to 150 W. For LLMs, read it as a very good 24 GB card, with half the nominal memory bandwidth of the desktop 5090, not necessarily half its application speed; every “5090” figure in this article refers to the desktop card. The RTX 5070 shares its CUDA core count (6,144) with the Spark’s GPU, which makes it the “compute equivalent” on paper; but its 12 GB of GDDR7 (~672 GB/s) confine it to ~13B models in 4-bit. It is an honorable entry into local LLMs, not a Spark rival: you do not compare 12 GB to 128. The RTX Spark (N1X), expected in fall 2026 on Windows on Arm, is the DGX Spark’s consumer cousin: up to 128 GB unified, but bandwidth and throughput remain unconfirmed. A lower price at equal capacity is not established; the analyst estimates in circulation (~$2,899) cover its 16-32 GB entry configurations only.
How to decide
Start with a complete memory budget. If weights, KV cache and runtime fit in 32 GB, benchmark a 5090 on the latency target you need. If they do not, Spark’s larger pool is useful, particularly for a large MoE. A dense 70B decision needs a measurement in the chosen quantization. Compare a complete PC against a complete Spark, including power supply, host memory, electricity and your existing hardware, rather than comparing a GPU sticker price with a whole system.
Conclusion
The evidence supports a capacity-versus-latency decision, not a universal winner by parameter count. Record the model revision, quantization, context, concurrency, runtime version and total system cost. RTX Spark remains a separate Windows platform: neither its bandwidth nor a lower 128 GB system price is established by the measurements above.
Sources and method
This article is the “Spark versus GeForce” spoke of our Spark coverage: the shared figures (GB10 datasheet, measurements, prices) are established and sourced in RTX Spark vs DGX Spark and were re-verified on July 4, 2026. A French version of this article, published July 8, 2026, is the original.
Verified facts. DGX Spark bandwidth and memory (~273 GB/s, 128 GB LPDDR5X, 256-bit bus): DGX Spark / GB10 datasheet. RTX 5090 (32 GB GDDR7, ~1,792 GB/s, 21,760 cores, 575 W) and RTX 5070 (12 GB, ~672 GB/s, 6,144 cores): NVIDIA spec sheets. DGX Spark MSRP at $4,699: raised from $3,999 in February 2026 (Tom’s Hardware, VideoCardz). GPT-OSS 120B weights (~65 GB MXFP4, ~80 GB loaded): OpenAI model card. DGX Spark power: 240 W peak system, GB10 SoC at 140 W TDP (NVIDIA hardware guide); the ~170 W under AI load is a press observation (StorageReview, NVIDIA forums), workload-dependent.
Measurements (proxy). GPT-OSS 20B throughput (5090 ≈ 205 tokens/s; DGX Spark ≈ 50), GPT-OSS 120B on Spark (≈ 38 tokens/s in llama.cpp, ≈ 50 in SGLang) and Llama 3.1 70B FP8 on Spark (2.7 tokens/s decode): LMSYS review of October 13, 2025 and community benchmarks, detailed in the Spark deep dive. Measured under Linux (DGX OS); read as orders of magnitude.
Credible estimates. RTX 5090 street prices: ~$2,999+ on the US secondary market (gpudrip, videocardz), observed early July 2026 in a DRAM-shortage market. RTX Spark N1X (~$2,899 for 16-32 GB entry configurations): Morgan Stanley estimates, June 2026, unconfirmed by NVIDIA.
Stated assumptions. The ~4 tokens/s ceiling for dense 70B FP8 on the Spark is the division 273 GB/s ÷ 70 GB (throughput ceiling, single sequence); the matching LMSYS measurement is 2.7 tokens/s, below the ceiling as expected (runtime overhead, KV cache traffic). The ~4× throughput ratio between the 5090 and the Spark is measured on GPT-OSS 20B; it varies with model, runtime and batch. Future memory projections are not measurements of current products.
Image credit. Header photo: KXRORS S300 SFF PC with GeForce RTX 5070 Founders Edition next to NVIDIA DGX Spark by Daniel Lu, CC BY-SA 4.0, via Wikimedia Commons, cropped.
