NVIDIA DGX Spark · GB10 Grace Blackwell

The machine on the clock.

Every official run executes on one physical computer: a single NVIDIA DGX Spark, frozen down to its kernel build and driver version for the duration of the contest. Nobody gets a bigger GPU, a second node, or a cooler room. This page explains what a DGX Spark is and what it means for an entrant. The short version: a familiar CUDA machine, enough memory that a run never fights for it, and a clear map of where speed is won.

From Project DIGITS to the lab bench

• Previewed as Project DIGITS. NVIDIA showed this machine at CES in January 2025 as a "personal AI supercomputer" the size of a thick paperback.
• Shipped as the DGX Spark. It took that name at GTC in March 2025, as the smallest member of a DGX family whose other members fill racks, and reached buyers in October 2025 at $3,999.
• It fits on a desk. 150 mm square, 50.5 mm tall, 1.2 kg, and up to 240 W through a USB‑C connector.
• The software is ordinary. DGX OS, NVIDIA's Ubuntu-based distribution, with the standard CUDA 13 stack.
• The CPU is Arm, not x86. Its 20 cores are why this platform builds and validates ARM64 container images and nothing else.

GB10: two processors, one memory

• One package, two processors. The GB10 Grace Blackwell superchip, co-designed with MediaTek, carries a 20-core Arm CPU and a Blackwell-generation GPU.
• NVLink‑C2C joins them, a chip-to-chip link with roughly five times the bandwidth of PCIe Gen 5.
• Both processors share one 128 GB pool of LPDDR5x. That coherent unified memory is the defining architectural fact of this machine: no VRAM, no PCIe hop, and no host-to-device copy between the cores that decode your JPEGs and the tensor cores that run your attention kernels.
• None of it demands new habits. A pipeline written for a discrete GPU runs unchanged: cudaMemcpy degenerates to traffic within the same DRAM, the transfer stage you would normally work to hide costs nearly nothing, and zero-copy access to decoded pixels becomes an optional bonus.
• The layout may already be familiar if you have tuned on a Grace‑Hopper node or an Apple‑silicon Mac.

The serious networking is beside the point here: scored containers run with --network none, so the ConnectX‑7 spends the whole contest doing nothing.

Ample by design: 128 GB for the GPU

• All 128 GB is GPU-addressable, because the pool is unified: four times the VRAM of an RTX 5090 and more than an 80 GB H100.
• Out of a 240 W box. That is the whole machine's draw at the wall, not a rack's.
• The point of that margin is not bragging rights. It is what keeps a one-shot contest fluent.

• Nothing has to be paged, streamed, or sharded.
• The pool swallows the entire problem at once: the FP32 reference checkpoint (1.2 GB), your runtime, activations at any batch size worth running, and all 10,000 cohort JPEGs.
• Those JPEGs are prewarmed into the page cache before the clock starts, so every run begins from the same warm state. Submission-writable caches begin empty.
• The boring nightmares of memory-tight optimization never start: VRAM budgeting, spill-and-recompute tricks, an out-of-memory crash consuming one of your official attempts. Attempts get spent on ideas instead.

Where the time goes: 273 GB/s

• On paper the GPU is enormous: up to a petaFLOP of sparse 4-bit tensor throughput.
• The memory system feeding it is sized for the power envelope rather than the spec sheet, at 273 GB/s, roughly a seventh of one RTX 5090.
• That trade is how a petaflop and 128 GB fit in 1.2 kg and 240 W.
• It is the most useful fact on this page, because it tells you where a fast submission will spend its time.

• Compilation fuses kernels so activations stay on chip, and nineteen CPU cores decode JPEGs in parallel.
• One accounting note: the decoders share the same 273 GB/s the GPU draws from, so overlap preprocessing and inference thoughtfully. That is ordinary pipeline hygiene, applied to one memory system instead of two.

The host, frozen

A benchmark on one machine is only fair while it stays the same machine. Production configuration pins the host software stack by exact version; the doctor gate and the scorer's pre-run attestation refuse to time anything on a host that has drifted:

• Physical state is gated too. A run may not start until the host passes every check below.
• The GPU must be idle and at or below 50 °C.
• Instantaneous host CPU utilization must be under 10%.
• At least 16 GiB of host memory must remain free.
• A submission scored right after someone else's three-hour attempt therefore meets the same silicon at the same temperature as one scored at dawn.

What your container actually gets

An official run never sees the whole machine; it sees a deliberately carved slice that is identical for every entrant:

• CPU: cores 1-19. All ten performance cores and nine of the ten efficiency cores. Core 0 is reserved for the platform's own control plane, so runner polling never steals contestant cycles.
• GPU: all of it. The Blackwell GPU is exclusively yours for the run; the scorer refuses to start while any foreign process holds the GPU.
• Memory: a 96g container limit out of the 128 GB pool, leaving headroom for the page-cached cohort and the host's protected 16 GiB reserve.
• Scratch: 16g tmpfs, 8g /dev/shm, a tiny 4m output tmpfs. Everything else, including the image root and the benchmark mounts, is read-only.
• Boundaries: no network, no capabilities, a non-root UID, a 4,096-process cap, and a 0-hour watchdog around the trusted in-container timer.

Why one small machine

• Headline inference numbers are usually bought with fleets, which makes them statements about budgets. This contest inverts that: one fixed, affordable box, the same frozen EVA‑02‑L reference for everyone, and a single clock.
• Enough memory that nobody's attempt dies to an allocation.
• A familiar CUDA stack where discrete-GPU experience transfers directly.
• A petaflop engine whose remaining headroom lives in the interesting techniques of precision, kernels, compilation, and pipeline overlap.
• Read the rules, take the starter kit, whose FP32 baseline runs on this exact machine, and make the little box earn its name.