NVIDIA DGX Spark review: 128GB of unified memory at a reseller premium

128GB unified memory and a 4TB SSD for running large open-weight LLMs on your desk
- Chip
- NVIDIA GB10
- Unified Memory
- 128 GB
- Memory Bandwidth
- 273 GB/s
- Tokens/sec (70B)
- 4.5 tok/s
- 128GB memory: larger models fit
- 4TB SSD stores many models
- Upgrade voids NVIDIA's original warranty
The DGX Spark puts 128GB of unified memory behind a GB10 chip, enough to hold quantized open-weight models in the 70B-parameter class. This listing is a reseller-upgraded unit with a 4TB SSD at $8,699.99, and its warranty terms matter as much as its specs.
| Chip | NVIDIA GB10 |
|---|---|
| Unified Memory | 128 GB |
| Memory Bandwidth | 273 GB/s |
| Tokens/sec (70B) | 4.5 tok/s |
Design and build quality
The DGX Spark is a mini desktop, not a workstation. The GB10 processor, its 128GB of unified memory and the storage all sit in one compact chassis that fits on a desk beside a monitor, on a bookshelf, or in a small rack shelf. A tower workstation built to hold a comparable amount of model memory would need multiple discrete GPUs, each with its own VRAM, plus a large case, a high-wattage internal PSU and enough airflow to keep those cards cool. If you work from a home office or a shared lab bench, that difference decides whether the machine lives next to you or in a closet.
The compact chassis also changes how you think about local LLM hardware. With unified memory, the CPU and GPU draw from the same pool, so there are no GPU cards to slot, cable or upgrade later. You give up expandability compared with a tower: you cannot add a second GPU in a year. In return you get a single, self-contained box that is easy to move between desks or carry to a client site.
The power brick trade-off
NVIDIA keeps the chassis small by moving power conversion outside it. The unit runs from an external power adapter, and this listing includes the original adapter and cord. That matters because a third-party replacement for an AI workstation is not something you want to source in a hurry.
The downside is practical. You have a brick to place, usually on the floor or clipped under the desk, and an extra cable to route. If you move the Spark between desks or to a client site, the adapter travels with it, so count it as part of the footprint.
| Physical aspect | Mini desktop (DGX Spark) | Multi-GPU tower workstation |
|---|---|---|
| Where it fits | Desk, shelf or small rack shelf | Floor or dedicated rack space |
| Model memory | One 128GB unified memory pool | VRAM split across separate GPU cards |
| Power delivery | External adapter plus cord | Internal PSU |
| Upgrade path | Effectively fixed at purchase | Add or swap GPUs, RAM and drives |
| Portability | Easy to relocate with its adapter | Heavy, and awkward to move |
What this upgraded configuration changes
On the outside, this unit looks the same as any other DGX Spark. The difference is inside: the seller has fitted a 4TB NVMe SSD. That capacity is useful for this kind of machine. Quantized open-weight models in the 70B-parameter class take up tens of gigabytes each. Once you keep several model variants, quantization levels, datasets and a local knowledge base on the drive, a smaller SSD fills up quickly.
That upgrade is also why the original manufacturer's warranty is void. Fitting the drive meant opening the unit and changing NVIDIA's factory hardware configuration. The listing states this plainly and replaces NVIDIA's coverage with a 6-year seller warranty and lifetime seller tech support from the date of purchase.
Any repair or replacement claim on this unit goes through the seller, not NVIDIA. The GB10 board, memory and original power adapter are unchanged; only the SSD differs. What changes is who honors a fault and how long they stay in business. Before buying, confirm the seller's claim process and whether a failed unit is repaired or replaced. This matters most if the Spark will be a production machine rather than a test box.
The physical summary is straightforward. The Spark's design suits a desk or shelf far better than any multi-GPU tower that offers similar model memory. The external brick is a minor nuisance that you plan around once. The 4TB drive solves a real storage problem for anyone who keeps a library of local models. The trade-off is in the paperwork, not the hardware: you get more storage but lose NVIDIA's warranty, and the verdict below weighs whether that exchange is worth the premium.
Local LLM performance: capacity versus speed
The DGX Spark's 128GB of unified memory determines which models you can load. Whether those models feel responsive depends on something else. Keep those two questions separate when you shop, because headline specs tend to blur them.
What 128GB actually lets you load
At 4-bit quantization, a model needs roughly half a byte per parameter for its weights, plus room for the KV cache that grows with the context window. A 70B-class dense model at Q4_K_M lands around 40GB before context. A 24–32GB discrete GPU cannot hold that whole, so it has to offload layers to system RAM, which slows it sharply, or drop to a smaller or more aggressively quantized model. On the Spark, the same 70B model fits with tens of gigabytes left for a long context, a second model, or an embedding model for a local knowledge base.
| Model class (4-bit) | Approx. weight footprint | Fits whole in a 24–32GB GPU | Fits in 128GB unified memory |
|---|---|---|---|
| 8B–14B dense | ~5–9GB | Yes, comfortably | Yes, with lots of headroom |
| 30B-class dense or MoE | ~17–20GB | Yes, with limited context | Yes, with long context |
| 70B-class dense | ~40GB | No | Yes |
| 100B+ mixture-of-experts | ~60GB+ | No | Yes, depending on quantization |
Range across the products compared here
Why memory bandwidth, not capacity, sets tok/s
Generating each output token means reading the model's active weights from memory. The memory bandwidth figure (in GB/s) therefore puts a hard ceiling on tokens per second: divide bandwidth by the bytes read per token and you get the best case. A 70B dense model reads roughly 40GB for every token, so it runs, but it is not fast. It is fine for drafting or batch summarization where you can wait, and noticeably sluggish for back-and-forth chat. More capacity doesn't raise that ceiling. It only lets you load something bigger, which reads more bytes per token and generates more slowly.
Long inputs add a second cost. Prompt processing (prefill) has to read the entire prompt before output starts, so time to first token (TTFT) grows with context length. Pasting a long contract or a large chunk of a codebase into a 70B model means waiting before anything appears, and the growing KV cache eats into the memory you thought was spare.
A machine with less memory but higher bandwidth can generate faster on models it can hold. The Spark's advantage shows up only once a model outgrows a 24–32GB card. If your models fit on a discrete GPU, the GPU is likely to feel faster.
Mixture-of-experts models make better use of the capacity
Mixture-of-experts (MoE) open-weight models suit this hardware better than large dense ones. Every expert has to sit in memory, which is where 128GB pays off. For each token, though, only a small subset of parameters is active. GPT-OSS-120B, for example, activates only around 5B parameters per token, and MoE Qwen variants such as the 30B-A3B design work the same way. The machine then reads far fewer bytes per token than a dense model of similar total size, so you get large-model knowledge at speeds closer to a mid-size model's.
For most buyers that makes MoE the sensible default. Dense 70B models are worth running when a specific fine-tune or a quality difference justifies the slower output.
Plan around one model, not the spec sheet
The seller's listing itself notes that model capacity and performance vary with quantization, context length and configuration. A Q8 build of the same model roughly doubles its footprint compared with 4-bit. A 128K-token context window reserves far more KV cache than an 8K one. The choice of inference software also changes both memory use and throughput.
Before spending $8,699.99, pick the actual model, quantization and context length you plan to run. Then check community-reported tok/s and TTFT figures for GB10 systems against that exact setup. If your target is a 70B dense model in interactive chat, set your expectations for a capable but deliberate pace. If it's a large MoE model, or several models loaded side by side, this is the workload the 128GB pool was built for.
Setup, software and daily handling
The DGX Spark arrives as hardware, not a turnkey assistant. The listing states plainly that local AI workflows require compatible models and inference software, so budget time to assemble a software stack before you get a useful answer. It works with Qwen, GPT-OSS and other open-weight models through supported inference software, but you choose the runtime (common options in the CUDA world include llama.cpp, Ollama, vLLM and TensorRT-LLM), download the weights, and pick a quantization that fits your context window.
That last choice matters more than it seems, as the performance section above shows. A 4-bit build of a large model leaves room in the 128GB pool for a long context, while a higher-precision build of the same model may not. The 4TB NVMe SSD helps here: you can keep several quantized variants of the same model on disk and switch between them, instead of re-downloading tens of gigabytes each time you want to compare a Q4_K_M build with an 8-bit one.
What you actually do with it day to day
Once the stack runs, the use cases sort into a few patterns, and each needs a different amount of plumbing:
| Use case | What you need to add | Practical note |
|---|---|---|
| Personal assistant / chat | An inference server plus a chat front end | Easiest starting point. MoE models such as GPT-OSS respond fastest |
| Document summarization | A runtime with a long context window | Long inputs stress prompt processing (prefill), so TTFT grows with document length |
| Local knowledge base | Embedding model, vector store, retrieval layer | Your documents stay indexed on the 4TB SSD, never uploaded |
| Coding assistance | OpenAI-compatible local endpoint wired into your IDE or agent tooling | Lets dev tools that expect a cloud API point at your own box instead |
The coding workflow is where the CUDA foundation pays off most directly. Many inference servers expose an OpenAI-compatible API, so editor plugins and agent frameworks built for cloud endpoints can often be redirected to the Spark with a URL change. For a small team, one unit on the network can serve as a shared inference host instead of every developer running models on their laptop.
Pro tip
Start with a mixture-of-experts open-weight model such as GPT-OSS or a Qwen MoE variant before trying a dense 70B-class model. Their faster generation gives you a usable tok/s rate while you confirm your drivers, runtime and front end all work. Move to larger dense models once the pipeline is stable.
Control over your data

The strongest practical argument for this box is fully local inference. Prompts, uploaded files and retrieval indexes stay on your own hardware, and you decide who can reach the models and applications running on it. For legal, medical, financial or proprietary source-code work, that can be the difference between being allowed to use an LLM at all and being blocked by policy. It also reduces reliance on cloud inference services, which means no per-token billing, no rate limits and no exposure to a provider changing or retiring the model you depend on.
The trade-off is that you also become the operations team. Updating runtimes, tracking new model releases and keeping access controls sensible are your responsibility, and no provider handles them for you.
Who handles support: the warranty caveat
As the design section explains, all service on this unit runs through the seller rather than NVIDIA. For software setup specifically, the lifetime seller tech support could help a first-time user stuck on a driver or runtime issue.
Two practical consequences are worth weighing before checkout:
- Hardware faults go to the reseller, not NVIDIA. Turnaround and parts sourcing depend entirely on that seller staying in business and honoring the terms.
- Software help from a reseller may not reach as deep as NVIDIA's own channels on CUDA or GB10-specific problems. Expect to lean on community forums and runtime documentation for inference-stack issues anyway.
Check before you buy
Read the seller's warranty terms for what counts as a covered defect, who pays return shipping, and whether repairs or replacements are handled domestically.
How it compares to Apple silicon and Strix Halo
| Product | Rating | Price | Buy |
|---|---|---|---|
Apple Mac Studio (M3 Ultra) Up to 512GB of unified memory for very large local LLMs on one desk +512GB memory fits huge quantized models+80-core GPU speeds token generation -No CUDA: some AI tools unsupported | Buy → | ||
Apple Mac mini (M4 Pro, 64GB) 64GB unified memory for 70B-class local models in a desk-sized box +64GB shared memory fits 70B-class quants+Small chassis runs quietly on a desk -No CUDA, so fewer fine-tuning tools | Buy → | ||
Apple Mac Studio (M4 Max) Up to 128GB unified memory in a 7.7-inch box for large local models +128GB unified memory loads large models+7.7-inch square fits under monitors -No CUDA: some AI tools unsupported | $3,399.00 | Buy → | |
GMKtec EVO-X2 (Ryzen AI Max+ 395, 128GB) 128GB unified memory to run 70B-class models locally +128GB shared memory: fits 70B models+120W mode for long inference runs -Soldered memory: cannot upgrade beyond 128GB | $3,499.99 | Buy → | |
Minisforum MS-S1 Max Best Value Ryzen AI Max+ 395 mini PC with dual 10GbE and a PCIe x16 slot for LLM clusters +64GB shared memory sidesteps VRAM limits+Dual 10GbE for multi-unit clustering -235B Q4 needs two units | $2,599.00 | Buy → | |
NVIDIA DGX Spark 128GB unified memory and a 4TB SSD for running large open-weight LLMs on your desk +128GB memory: larger models fit+4TB SSD stores many models -Upgrade voids NVIDIA's original warranty | $8,699.99 | Buy → |
Prices as of Nov 16, 2026; they may have changed since.
Pros
- 128GB memory: larger models fit
- 4TB SSD stores many models
- 6-year seller warranty included
- Lifetime seller tech support
- Local inference keeps documents private
Cons
- Upgrade voids NVIDIA's original warranty
- Slower tokens than high-end discrete GPUs
- Speed varies with quantization, context
Who should buy it and who should skip it
The DGX Spark solves one specific problem: getting 128GB of unified memory onto NVIDIA's CUDA stack in a box that fits on a desk. If that problem is yours, this machine is worth considering. If it isn't, you are paying $8,699.99 for capacity you won't use, on a listing that has replaced NVIDIA's warranty with a seller's.
Good for
- CUDA-dependent developers whose code, kernels or tooling assume NVIDIA hardware and won't run on Apple silicon or Strix Halo without rework
- Teams handling client, medical, legal or proprietary data that must stay on-premises, where cloud inference APIs are ruled out by policy
- Engineers prototyping locally before deploying on larger NVIDIA infrastructure, so the same software stack runs on the desk and in the data center
- Anyone who needs to load 70B-class models at 4-bit quantization, or large mixture-of-experts models such as GPT-OSS and Qwen variants, on a single machine
Not for
- Readers who mainly want fast chat with 8B–14B models
- Buyers whose procurement rules require manufacturer warranty coverage
- Gamers or anyone wanting a general-purpose desktop
- Mac-first users who don't depend on CUDA
Buy it if CUDA is the requirement, not just a preference
The main reason to buy this over a cheaper unified-memory machine is software compatibility. If your workflow relies on CUDA-specific libraries, NVIDIA's inference containers or code you plan to move later to NVIDIA servers, the Spark lets you develop against that stack locally. Apple silicon and Strix Halo machines can't fully replace it. For a team, avoiding porting and debugging on a different backend can justify a hardware premium more easily than any tok/s figure.
Data residency is the second strong case. A firm that wants a local knowledge base over contracts, patient notes or unreleased source code can run document summarization and retrieval entirely on its own hardware. The 4TB NVMe SSD on this listing helps here, because it holds several large open-weight models alongside the document corpus without needing external storage.
Skip it if you mostly chat with small models
For 8B–14B models, the 128GB pool is mostly empty, and memory bandwidth limits generation speed. A conventional PC with a discrete GPU has much higher memory bandwidth and will produce more tokens per second on those models, often with a shorter time to first token. It also costs far less than $8,699.99. If your daily use is a coding assistant or chat on a quantized 8B model, a midrange discrete-GPU desktop will feel faster and leave thousands of dollars for other things.
The same reasoning applies to anyone attracted by "128GB" without a concrete large-model use. Capacity only pays off when you actually load the 70B-class or large MoE models that need it.
Skip this listing if warranty terms are non-negotiable
The seller's 4TB SSD upgrade voids the original manufacturer's warranty. The 6-year seller warranty that replaces it is only as reliable as the seller's ability to honor it years from now. Many corporate and university procurement policies require OEM coverage or authorized-reseller purchases, and this unit would fail that check.
To sum up: buy this specific listing only when both of these hold true. You need CUDA-native local inference at large model sizes, and a standard-warranty DGX Spark isn't available to you through another channel.
Verdict
The DGX Spark does what NVIDIA built it to do. It puts 128GB of unified memory on the CUDA stack in a box that fits on a desk, so 70B-class open-weight models at 4-bit quantization load locally without a multi-GPU tower. Your existing CUDA tooling, inference servers and fine-tuning scripts work without porting. Apple silicon and Strix Halo machines can match the memory pool, but neither can offer that native CUDA path. That is why the Spark exists.
The open question is this listing, not the hardware. At $8,699.99, you pay a reseller premium for two things: a 4TB NVMe SSD and a 6-year seller warranty with lifetime seller tech support. The cost of that bundle is the original manufacturer's warranty, which is void because of the storage upgrade. You are swapping NVIDIA's coverage for a promise that is only as durable as the seller behind it.
Strong hardware for running large open-weight models locally on CUDA, but this seller-upgraded listing only makes sense if you specifically want the 4TB SSD and 6-year seller coverage, or can't source a standard-warranty unit elsewhere.
Where the premium earns its keep
The extra storage has real value for model-heavy work. A library of quantized weights fills drives quickly once you keep several 70B-class files, mixture-of-experts models such as GPT-OSS and a few Qwen variants side by side, plus a local knowledge base for document retrieval. If you would otherwise manage external drives or delete models to make room, 4TB on the internal NVMe removes a daily annoyance.
The 6-year term is also longer than typical manufacturer coverage. For a solo developer or small lab without an IT department, lifetime seller tech support has practical value as well. Two conditions apply:
- The seller has to still be around in year four.
- Its claims process has to be workable when you need it.
Where it doesn't
Generation speed stays the same no matter who sells the unit: memory bandwidth still caps tokens per second, so a dense 70B model runs at a deliberate pace while MoE models make better use of the hardware. If your daily workload is quick back-and-forth with 8B–14B models, a cheaper discrete-GPU PC will reach the first token sooner and generate faster for much less money.
Procurement is the other hard stop. Many organizations require manufacturer warranty coverage on capital equipment, and a seller warranty on modified hardware will not pass that check.
| Your situation | Call on this listing |
|---|---|
| CUDA-dependent workflow, need 128GB locally, and standard units are unavailable to you | Reasonable buy. The seller warranty and 4TB SSD are a fair trade for getting the hardware now. |
| Same needs, but a standard-warranty unit is in stock elsewhere | Buy the standard unit and add storage later if you need it. |
| Data must stay on-premises, and the seller's terms pass your review | Sound buy. Fully local inference keeps prompts and files on your own hardware. |
| Mostly fast chat on 8B–14B models | Skip. A discrete-GPU PC is quicker and far cheaper. |
| Manufacturer warranty is mandatory | Skip. The original warranty is void on this unit. |
| Happy outside CUDA and want polish or a lower entry price | Look at Apple silicon or Strix Halo at 128GB of unified memory. |
Before you check out
Confirm three things in writing:
- Who services the unit under the 6-year seller warranty.
- Whether shipping for repairs is covered.
- What happens to the NVMe SSD and your data during a claim.
Because the manufacturer's warranty is void, the seller's answers to these questions are your only protection.
Bottom line
The DGX Spark is a sound buy for CUDA-native local inference: developers, small teams with sensitive data, and anyone whose tooling assumes NVIDIA. This $8,699.99 configuration is a narrower recommendation. Choose it if the 4TB SSD and six years of seller-backed support are worth the premium to you, or if it is the only DGX Spark you can actually get. If a standard-warranty unit is available at a normal price, that is the better purchase. The memory, the GB10 chip and the CUDA stack are identical, and you keep the manufacturer's coverage.
Disclosure: we may earn a commission if you buy through links on this page, at no extra cost to you.



