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, €3,900 to €4,400 in Europe), 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, €3,900–4,400 EU ($1,999 MSRP) |
What the measurements say: bandwidth decides
The mechanism first, because it explains every line of measurement. LLM generation re-reads the entirety of the model’s weights for every produced token: output throughput is capped by how fast memory can be traversed, almost never by compute. The 5090 traverses its 32 GB at ~1,792 GB/s; the Spark traverses its 128 GB at ~273 GB/s. On the same model, the throughput ratio follows the bandwidth ratio, and that is exactly what the LMSYS measurements on the DGX Spark show: on GPT-OSS 20B, ~205 tokens/s of generation for the 5090 against ~50 for the Spark. Four times less, for a bandwidth ratio of 6.5: the measured gap is a little softer than raw physics, because with so few active weights per token the 5090 no longer saturates its bandwidth (fixed runtime costs take over), while the Spark stays pinned to its memory ceiling.
prefill The opening phase of LLM inference: every token of the prompt is processed at once. High arithmetic intensity, so the GPU saturates its Tensor Cores. The opposite of the decode phase that follows. (prompt ingestion) is the exception that proves the rule: that phase is compute-bound, and the Spark’s FP4 peak holds its own there. But an interactive session lives in decode The autoregressive generation phase of an LLM: one token is produced at a time, re-reading the whole KV cache. Arithmetic intensity is very low, so the GPU spends most of its time waiting on memory. A real inference service is almost always dominated by decode. , and decode reads the memory line of the spec sheet, not the FLOPS Floating-Point Operations Per Second. A raw throughput metric for floating-point compute, in tera or peta. For LLM inference it is rarely the limiting factor: memory bandwidth almost always comes first. line.
The verdict by model size
Up to ~30B: the 5090, no contest. A 30B in quantization Reducing the number of bits that encode each weight of a model (from 16 bits down to 8, 4, or fewer). It shrinks the memory footprint by the same factor, at the cost of a controlled accuracy loss, without changing the parameter count. (~17 GB) fits in 32 GB with room for the KV cache The stored key and value vectors an LLM has already computed for every token it has processed. It avoids recomputing attention over the whole history, at the cost of a memory footprint that grows with the context length. , and GDDR7 serves it at dozens of tokens/s. The Spark runs the same models four times slower, and nothing offsets that gap in interactive use. Same conclusion for 20B MoE Mixture-of-Experts. An architecture where the network is split into many experts, of which a router activates only a small subset per token. Per-token compute follows the number of active parameters; memory follows the total count, since every expert must stay resident in VRAM, ready to be called. models: measured by LMSYS, the gap stays one to four.
Dense 70B: the gap between the two. In Q4_K_M, its ~42 GB of weights overflow the 5090, which must offload layers to CPU RAM at collapsed throughput. The Spark hosts it effortlessly, then serves it at the pace its memory allows: a ~4 tokens/s physical ceiling in dense FP8, 2.7 measured by LMSYS once runtime overhead is paid. Neither machine is right for fast dense 70B; that need starts at 48 GB of fast memory, the territory of the RTX PRO 6000, dual GPUs, or rented datacenter cards.
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, half the speed of the desktop 5090; 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: same 128 GB unified pool, same 273 GB/s wall. Against the 5090 it will replay this article’s duel exactly, with a probably lower entry price; the analyst estimates in circulation ($2,899) cover its 16-32 GB entry configurations only.
How to decide
Ask the model question before the machine question. Does your largest model fit in 32 GB, weights and KV cache included? If yes, the 5090 is objectively superior: comparable money, four times the throughput. Are you targeting a 100B+ MoE locally? The Spark is the only contender under $5,000, and the experience stays comfortable as long as the model is MoE. Are you in between, on fast dense 70B? Neither: move up to fast 48 GB+ memory, or rent by the hour until you have measured your real need.
Conclusion
This duel has no winner; it has two winners on disjoint terrain, and a no man’s land in between. The 5090 is the machine for mid-size models served fast; the Spark is the machine for the big MoE you simply could not run at home before it. What to watch next: fall 2026, when the RTX Spark replays this match at a lower price, and the LPDDR6 generation, the only thing capable of moving the 273 GB/s wall that defines the capacity camp today. The day a unified SoC crosses 500 GB/s, this duel changes nature; until then, it is decided by model size.
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) and €3,900-4,400 in EU retail (bestvaluegpu, 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 70 GB ÷ 273 GB/s (memory 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. The LPDDR6 projection and the ~500 GB/s threshold in the conclusion are trend hypotheses, not a confirmed roadmap.
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.
