NVIDIA DGX Spark · GB10 Grace Blackwell

The DGX Spark, measured.

128 GB of unified memory, 273 GB/s of bandwidth, and what NVIDIA's spec sheet leaves out: what fits, what it measures on GPUwerk's fleet, and where it loses.

Deploy now See the benchmarks
128GBUnified memory, with 273 GB/s of memory bandwidth
$0.79Per hour on GPUwerk, billed per minute, or $1.79 per hour for a 256 GB two-node cluster
1PFLOPFP4 AI compute, sparse, from the NVIDIA GB10 Grace Blackwell Superchip
2×200Gb/sConnectX-7 QSFP ports. Two linked machines handle models of up to 405B parameters

Buying one in the EU runs €3,800 to €4,800. Or buy a GB10 machine from eight makers, and have GPUwerk host it →

Specifications

Full specifications.

Per node. Every GPUwerk instance is one whole machine, so these numbers are all yours.

NVIDIA DGX Spark
SuperchipGB10 Grace Blackwell
AI performance1 PFLOPS FP4 (sparse)
Memory128 GB unified LPDDR5x
Memory bandwidth273 GB/s
CPU20-core Arm (10× X925 + 10× A725)
Storage1 TB NVMe
NetworkConnectX-7 · 200 Gb/s
Power240 W max
OSDGX OS 7 · Ubuntu 24.04
CUDAFull stack preinstalled

273 GB/s memory bandwidth is the constraint that matters for single-stream LLM generation speed. The Spark's strength is capacity: models that simply don't fit on consumer GPUs, plus FP4 compute for batch serving and fine-tuning, where throughput scales far better than the single-stream numbers suggest.

Measured on GPUwerk's fleet

Fleet benchmarks.

The two models staged on every node in the fleet, measured with vllm bench serve on one of GPUwerk's own nodes with nothing else on its GPU. Raw logs are below. Third-party figures for other models are collected and argued with in the buying guide.

Fleet benchmark results on one DGX Spark node
ModelQuantizationFrameworkPrefill tok/sGenerate tok/sMax context
Qwen3-Coder 30B-A3BAWQvLLM 0.27.15,705 tok/s80.9 tok/s262,144
Llama 3.3 70BAWQvLLM 0.27.1391 tok/s6.0 tok/s131,072

How to read this.

Prefill is the median time to first token on an 8,192-token prompt. Generate is one stream, 128 in and 512 out, with nothing else in flight. Max context is a prompt of that length that was actually served, not a figure inferred from the KV-cache size. Prefill gets slower as the prompt grows, because attention cost is quadratic: the 30B does 5,705 tok/s at 8k and 586 tok/s filling its full 262,144.

Batch size changes the answer completely.

One stream is the worst case on this hardware, and it is the number most comparisons stop at. With requests in flight the 30B reaches 3,235 tok/s aggregate at 256 concurrent, and the 70B reaches 485 tok/s at 128, then falls to 300 at 256, with median time to first token going from 8 to 40 seconds. The mixture-of-experts model saturates past its knee; the dense one collapses past its. Both curves are in the logs.

Withdrawn once, then re-run.

GPUwerk published this table once before, on 2 September 2026, and withdrew it the same day: the node had been serving another GPUwerk model on the same GPU throughout, which came to light only afterwards. The node was emptied and every run repeated. Re-running was the right call rather than annotating the old numbers: single-stream generation on the 30B nearly doubled, and the concurrency curve changed shape rather than merely shifting, so the conclusion drawn from the first run was wrong, not just imprecise. Every log below opens with the GPU’s process list and free memory at the instant the run started, so you can check the claim rather than take it.

Raw logs, every run, unedited apart from collapsing progress-bar redraws: Qwen3-Coder 30B-A3B · Llama 3.3 70B. To run your own: top up $10 the first time and get $20 in credit, enough for an evaluation day on a dedicated node.

Workloads

What should I run on it?

Opinionated guidance from operating a fleet of these.

Team coding assistant

Qwen3-Coder 30B-A3B (AWQ, the model GPUwerk benchmarks) leaves room for long contexts and several concurrent users. Serve with vLLM behind an OpenAI-compatible endpoint and point your editors at it.

Private chat + RAG

A 70B-class instruct model at Q4 fits in one node with headroom for an embedding model and a vector store on the same box, a whole private assistant on one machine. See the private ChatGPT setup →

Fine-tuning

LoRA fine-tunes of 70B-class models fit in unified memory without model-parallel gymnastics. Slower per step than a datacenter GPU, but it runs where consumer cards simply can't.

Comparisons

How it compares.

Verdict-first comparisons against the machines buyers actually cross-shop. Each one says where the rival wins.

DGX Spark vs Mac Studio

Unified memory both ways, CUDA ecosystem vs raw bandwidth. Updated for Apple's M5 Ultra Mac Studio: the Mac wins decode, the Spark wins prefill and CUDA portability.

9 min read

DGX Spark vs RTX 5090

32 GB of fast VRAM vs 128 GB of capacity. Not a close fight on speed: the whole question is whether your model fits.

6 min read

DGX Spark vs Strix Halo

Near-identical token generation, a 2-3x prefill gap, and roughly $1,000. What The Register's hands-on test found.

5 min read

DGX Spark cloud providers compared

Every hourly Spark rental with a public listing, with price, location, billing granularity and what happens to your data on stop. Quoted from each provider's own page, GPUwerk's included.

7 min read

DGX Spark vs H100 for LLM inference

When 128 GB and per-minute billing beat a datacenter card, and when memory bandwidth and batch throughput mean you need the H100 instead.

8 min read

DGX Spark vs H200 for LLM inference

The widest bandwidth gap on this site, 273 GB/s against roughly 4.8 TB/s. Where that matters, and where it doesn't.

7 min read

DGX Spark vs Jetson AGX Thor: two different jobs

Why these are not really competing for the same buyer, with target market, form factor and software stack compared.

7 min read

DGX Spark vs RTX PRO 6000 Blackwell

128 GB of unified memory at 273 GB/s against 96 GB of GDDR7 at about 1.8 TB/s: which models fit on each, and what decode speed the bandwidth allows.

Comparison

ASUS Ascent GX10 vs DGX Spark

The same GB10 chip and 128 GB. What differs is storage, price, size and firmware, each with its source.

Comparison

Every GB10 machine compared

DGX Spark, ASUS, Dell, HP, Lenovo, MSI, Gigabyte and Acer side by side: one chip, and the differences that remain.

Comparison

Guides

Guides & analysis.

For anyone evaluating, buying, or setting up a DGX Spark, written from the fleet room, not a press kit.

DGX Spark setup: unboxing to first token

DGX OS first boot, SSH, drivers, and serving your first model: the guide I wish had existed when I racked my first unit.

Setup · 4 min read

What to know before buying a DGX Spark

Power, noise, networking two units, what it's genuinely good at, and the total cost of ownership against a 5090 rig or the cloud.

Buying analysis · 11 min read

Rent or buy a DGX Spark

Hours per week, purchase price, and the break-even math, with a calculator for your own numbers.

Buying analysis · 8 min read

Serve Qwen3 with vLLM on a Spark

Copy-paste path to an OpenAI-compatible endpoint on your own hardware, Open WebUI frontend and systemd included.

Setup · 6 min read

The best models you're not allowed to send your data to

Which large open models fit in 128 GB / 256 GB, and how far behind the frontier they really are.

Private AI · 7 min read

Fine-tune a model on your company's data

LoRA on 70B-class models fits in 128 GB unified memory, with the training set staying on the node's local NVMe.

Fine-tuning · 11 min read

An AI employee needs an office. Give it one you own.

OpenClaw, Hermes, and why an agent that reads your inbox belongs on hardware you control.

AI Agents · 9 min read

Automate the boring 80%

Batch document processing on a flat-rate machine: the marginal token is free, so run the model over everything.

Automation · 7 min read

DGX Spark two-node cluster: setup and what it actually buys you

Linking two Sparks over ConnectX-7 200 GbE, what NVIDIA's own documentation says, and an honest read on what pairing does and does not buy you.

Setup · 9 min read

How to earn money with your DGX Spark

Rent out a Spark you own through GPUwerk Platform: the 70% share, what earns nothing, an example at stated hours, and your costs.

Owners · 7 min read

DGX Spark power consumption and running cost

The published power figures, what they mean at the wall socket, and how to work out your own electricity cost per hour.

Buying analysis · 6 min read

ComfyUI and Stable Diffusion on a DGX Spark

NVIDIA's ComfyUI playbook on ARM64, reported image times per model, and sharing unified memory with an LLM.

Models

Best open-weight models to run on a DGX Spark

Which model fits chat, coding, batch and agent work, and a dense-model reality check, using only measured tok/s figures.

Models · 8 min read

Total cost of ownership: GPU rental vs a cloud AI API

A per-token cloud API, a rented dedicated GPU, and buying hardware outright, compared side by side with figures already published on this site.

Buying analysis · 9 min read

How GPUwerk benchmarks the DGX Spark

What gets measured, single-stream versus concurrency, which engines and settings, and why the raw logs are published rather than just the summary table.

Benchmarks · 4 min read

DGX Spark noise and cooling: what to expect

What's documented about fan noise and cooling for a desk or home office, what hasn't been independently measured, and where to check before buying.

Buying analysis · 4 min read

Running vision and multimodal models on a DGX Spark

What's plausible on 128 GB of unified memory for vision-language models and image understanding, and why dedicated VLM benchmarks haven't been published yet.

Models · 3 min read

DGX Spark driver and firmware updates: what GPUwerk manages

What gets kept updated at the host and node level on a rented Spark, and what's inside your own root container and stays entirely your responsibility.

Setup · 4 min read

DGX Spark storage: what's persistent and what to back up

The 1 TB NVMe on a rented Spark, exactly what survives a stop versus a terminate, and why you need your own backup: GPUwerk's copy is for hardware failure recovery, not a backup service.

Setup · 4 min read

Monitoring and observability for a self-hosted LLM

What to track on a Spark serving production traffic, from GPU memory to per-request latency.

Operations · 6 min read

Backup and disaster recovery for your DGX Spark workload

What actually needs a backup on a rented Spark, and how to restore it after a failure.

Operations · 6 min read

Team and multi-user access to a shared DGX Spark

Giving a team shared access to one Spark without everyone sharing one API key.

Operations · 5 min read

Rate limiting and quotas for an internal LLM deployment

Keeping one team or one script from starving everyone else's requests on a shared endpoint.

Operations · 5 min read

Updating or swapping models without downtime

Rolling a new model or model version into production on a Spark without an outage window.

Operations · 6 min read

Scaling from one DGX Spark to a fleet

When renting more single Sparks beats a two-node cluster, how to load balance across independent nodes, and the operational tradeoffs of running a small fleet.

Operations · 7 min read

Quantized vs full-precision models in production

How to decide between a quantized and full-precision model for a production self-hosted deployment: memory fit, quality risk by task, and when to test both.

Operations · 6 min read

Cost forecasting and budgeting for AI infrastructure

How to estimate monthly AI infrastructure spend when self-hosting vs metering an API, with GPUwerk's $0.79/hour rate as a worked example and a budgeting checklist.

Buying analysis · 7 min read

Security hardening a rented GPU instance

Practical in-instance hardening for a rented GPU: SSH key management, network exposure, running services without root, secrets, and ephemeral vs persistent state.

Operations · 6 min read

Migrating an existing self-hosted AI deployment to a DGX Spark

A practical migration path from a workstation or another cloud GPU to a rented DGX Spark: re-quantizing for unified memory, moving data, and a cutover plan.

Setup · 7 min read

GPU memory management for multiple models on one Spark

Budgeting 128 GB of unified memory across several models or containers on a single DGX Spark, and when the math says split to a two-node cluster instead.

Operations · 6 min read

llama.cpp vs vLLM vs SGLang on a DGX Spark: flags and startup

A hands-on companion to picking an inference engine: exact flags, startup commands, and where llama.cpp, vLLM, and SGLang actually differ on GB10 unified memory.

Setup · 6 min read

Testing your disaster recovery plan for a self-hosted LLM

A backup plan you haven't restored from is a hypothesis. Restore drills, game days, and RTO/RPO measurement for a self-hosted LLM deployment.

Operations · 6 min read

API key rotation best practices for a private LLM deployment

Rotating API keys and credentials for a self-hosted inference endpoint: scoping, rotation schedules, revocation, and what to automate versus do by hand.

Operations · 6 min read

Evaluating model quality before switching models

Holdout test sets, A/B approaches, and regression checks for benchmarking a candidate model against your current one before switching in production.

Operations · 6 min read

Prompt caching to cut inference cost

How prefix and KV cache reuse cut repeated compute on a self-hosted deployment: what qualifies for a cache hit, how to structure prompts for it, and where the savings actually show up on an hourly-rented Spark.

Operations · 6 min read

Structured output and function calling on a self-hosted LLM

Setting up JSON-mode structured output and tool/function calling on self-hosted models with vLLM and llama.cpp, including which models support it and how to debug malformed calls.

Setup · 5 min read

Running embeddings and vector search on a DGX Spark

Self-hosting an embedding model alongside a vector database for a RAG pipeline on a single Spark: memory budgeting, serving the embedding model, and choosing a vector store.

Models · 5 min read

Batch processing large inference jobs on a rented Spark

Running bulk document processing and large-scale dataset labeling on an hourly-rented DGX Spark: throughput settings, job sizing, and how batch inference cost compares to interactive serving.

Operations · 5 min read

GPU utilization monitoring and right-sizing your deployment

How to read actual GPU and memory utilization on a rented DGX Spark and use it to decide between staying put, scaling up to a two-node cluster, or scaling out to a fleet.

Operations · 5 min read

Audit logging for a compliance-sensitive self-hosted LLM deployment

Setting up request and response audit logs inside your own container on a rented DGX Spark: what to capture, where to store it, and where GPUwerk's responsibility ends.

Operations · 6 min read

Model versioning and rollback strategy for a self-hosted deployment

Tracking which model weights and configs are actually running, and rolling back cleanly when a new version underperforms.

Operations · 6 min read

Cold start vs always-on: choosing an instance uptime pattern

Stopping a DGX Spark between uses vs keeping it running around the clock: cost, latency, and data tradeoffs.

Buying analysis · 5 min read

Setting up SSO and access control for a team LLM deployment

Putting an auth layer in front of a self-hosted inference endpoint so a team signs in with existing identities instead of sharing SSH keys or API tokens.

Setup · 5 min read

Running multiple containers and services on a DGX Spark

Docker container patterns for a single DGX Spark: when a plain docker-compose file is enough, and when the workload has outgrown it.

Setup · 5 min read

Questions.

Do I get a whole DGX Spark to myself?

Yes. Every GPUwerk instance is one dedicated node, not a slice of a shared GPU. The 128 GB of unified memory, the full 273 GB/s of bandwidth, and the 1 PFLOPS of sparse FP4 compute are yours for the duration of the rental, with nothing else running on the box.

How is a DGX Spark different from renting a cloud GPU instance?

A typical cloud GPU instance gives you 24 to 80 GB of VRAM on a datacenter card. A DGX Spark gives you 128 GB of unified memory on one machine, enough for 70B-class models without splitting them across GPUs, and GPUwerk runs it from EU-Central with per-minute billing.

What's the catch with 273 GB/s of memory bandwidth?

It's the ceiling on single-stream generation speed: fewer tokens per second than a discrete GPU with faster VRAM, which is why the buying guide and the vs. RTX 5090 comparison both lead with it. The Spark's advantage is capacity and batch throughput, not single-user raw speed.

Can I buy a DGX Spark instead of renting one?

Yes. GPUwerk's GB10 store sells the same GB10 machine from eight makers, the Lenovo ThinkStation PGX from €5,330 excluding VAT, ships it to you, or, if you choose, houses it in its datacenter and rents it out for you. You can also buy from NVIDIA or its partners, or ask GPUwerk about a machine for your own site. Renting by the minute first tells you whether the hardware fits your workload before a purchase of around €4,000 or more, and every GPUwerk cloud instance runs the identical GB10 hardware.

Everything about the DGX Spark on this site.

Every page on GPUwerk that covers the DGX Spark, grouped by what you're trying to do.

Buying and renting

Already own a Spark?

Comparisons

Benchmarks and models

Guides: Getting started

Guides: Serving and models

Guides: Operations

Guides: Cost and planning

Stop reading benchmarks.
Run your own.

Rent a dedicated Spark for $0.79/h, billed by the minute. First top-up: pay $10, get $20 in credit, about 25 hours of compute.

Create account