NVIDIA DGX Spark hardware

Great and practical post on DGX Spark configuration and use.

AlexAImaginator (@TraffAlex)

Outgrown 32–64 GB VRAM and unsure
what's next? (myself included 😅)

The answer: DGX Spark.
128 GB unified memory. $4,699.
Runs models your GPU can't even load.

Here's everything — 2x Spark cluster
setup, best models with benchmarks,
working docker commands, and the flags
that actually matter. All sourced from
tested community results on x.com +
official NVIDIA docs.

🔩 HARDWARE — DGX Spark

• SoC: NVIDIA GB10 Grace Blackwell
• Memory: 128 GB unified (CPU + GPU
shared pool)
• Price: $4,699 / unit
• Network: ConnectX-7 (CX7) 200GbE
QSFP ports
• Storage: 4TB NVMe M.2 (encrypted)
• Size: 150mm x 150mm x 50.5mm
• Performance: 1 PFLOPS FP4

🔗 2x SPARK CLUSTER — "Sweet Spot"

(Tested and verified by @MiaAI_lab)

Hardware needed:
• 2x NVIDIA DGX Spark
• 1x QSFP cable (direct 200GbE
link — full bandwidth, 1 cable)

Setup (from official NVIDIA
dgx-spark-playbooks on GitHub):

Make sure both units have the
same username:
$ whoami
(if not: sudo useradd -m nvidia
&& sudo usermod -aG sudo nvidia
&& sudo passwd nvidia
&& su - nvidia)
Physically connect QSFP cable,
identify active interface:
$ ibdev2netdev
(look for "Up" — each port has
2 names, use enp1s0f... not
enP2p...)
Network config — choose ONE:

A) Automatic (link-local) —
1 QSFP cable only:
$ sudo tee /etc/netplan/
40-cx7.yaml > /dev/null
<<EOF
network:
version: 2
ethernets:
enp1s0f0np0:
link-local: [ ipv4 ]
enp1s0f1np1:
link-local: [ ipv4 ]
EOF
$ sudo chmod 600 /etc/netplan/
40-cx7.yaml
$ sudo netplan apply

B) Manual static IPs
(recommended):
# Node 1:
$ sudo tee /etc/netplan/
40-cx7.yaml > /dev/null
<<EOF
network:
version: 2
ethernets:
enp1s0f0np0:
addresses:
- 192.168.100.10/24
dhcp4: no
enp1s0f1np1:
addresses:
- 192.168.200.12/24
dhcp4: no
EOF
# Node 2:
$ sudo tee /etc/netplan/
40-cx7.yaml > /dev/null
<<EOF
network:
version: 2
ethernets:
enp1s0f0np0:
addresses:
- 192.168.100.11/24
dhcp4: no
enp1s0f1np1:
addresses:
- 192.168.200.13/24
dhcp4: no
EOF
$ sudo chmod 600 /etc/netplan/
40-cx7.yaml
$ sudo netplan apply

C) Manual CLI (temporary —
resets on reboot):
# Node 1:
$ sudo ip addr add
192.168.100.10/24
dev enp1s0f1np1
$ sudo ip link set
enp1s0f1np1 up
# Node 2:
$ sudo ip addr add
192.168.100.11/24
dev enp1s0f1np1
$ sudo ip link set
enp1s0f1np1 up
Passwordless SSH:
$ ssh-keygen -t ed25519
$ ssh-copy-id user@192.168.100.11

Or use official script:
$ bash ./discover-sparks
(from dgx-spark-playbooks)
Verify connectivity both
directions:
$ ssh 192.168.100.11 hostname
$ ssh 192.168.100.10 hostname
NCCL test — confirm distributed
communication works
(driver versions must match on
both units)

🔙 Rollback (if something breaks):
$ sudo rm /etc/netplan/
40-cx7.yaml
$ sudo netplan apply
Or for CLI method:
$ sudo ip addr del
192.168.100.10/24
dev enp1s0f0np0

🐛 Troubleshooting:
"Network unreachable"
→ verify netplan YAML,
run sudo netplan apply
SSH failures
→ re-run ./discover-sparks,
enter passwords
Node 2 not visible
→ check QSFP cable,
confirm IP config
NCCL fails
→ driver versions MUST be
identical on both units

🏆 BEST MODELS — What Runs

1x DGX Spark:
• Qwen 3.6 35B NVFP4
→ 256k ctx, 110 tok/s
(Alibaba, April 2026,
Apache 2.0 license)
• DeepSeek V4 Flash REAP
→ HF: 0xSero/
DeepSeek-v4-Flash-REAP
• Qwen 3.6 27B
→ 256k ctx, 19 tok/s
• Nemotron Super
→ NVIDIA's own model,
optimized for DGX Spark

2x DGX Sparks ← SWEET SPOT
(recommended by @MiaAI_lab):
• DeepSeek V4 Flash
→ 1M ctx, 40-45 tok/s
(1 session)
~79 tok/s with 3 concurrent
sessions (NVFP4 quantization)
Repo: huggingface.co/
deepseek-ai/
DeepSeek-V4-Flash-DSpark
• Step-3.7-Flash (StepFun)
→ 256k ctx, image support,
30 tok/s
Available via NVIDIA NIM

4x DGX Sparks:
• GLM 5.2 NVFP4 (Zhipu)
→ ~20 tok/s, 1M context
• 2x DeepSeek V4 Flash
(each on its own 2x Spark pair)

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🚀 HOW TO RUN — vLLM Docker
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

A) Single Spark — Best model:

 $ docker run -d --name vllm \
   --ipc=host \
   --restart unless-stopped \
   --gpus all -p 8000:8000 \
   -e HF_TOKEN="$HF_TOKEN" \
   -v ~/.cache/huggingface:\
   /root/.cache/huggingface \
   vllm/vllm-openai:cu130-nightly \
   vllm serve nvidia/\
   NVIDIA-Nemotron-3-Super-\
   120B-A12B-NVFP4 \
   --served-model-name \
     nemotron-3-super \
   --trust-remote-code \
   --max-model-len 131072 \
   --gpu-memory-utilization 0.85 \
   --max-num-seqs 4 \
   --reasoning-parser \
     nemotron_v3 \
   --enable-auto-tool-choice \
   --tool-call-parser \
     qwen3_coder

B) 2x Spark — Distributed
inference:

 Add --tensor-parallel-size 2
 to the serve command.

 # Node 1:
 $ docker run -d --name vllm \
   --ipc=host --network=host \
   --gpus all \
   -e HF_TOKEN="$HF_TOKEN" \
   -v ~/.cache/huggingface:\
   /root/.cache/huggingface \
   vllm/vllm-openai:cu130-nightly \
   vllm serve deepseek-ai/\
   DeepSeek-V4-Flash-DSpark \
   --tensor-parallel-size 2 \
   --max-model-len 1048576 \
   --gpu-memory-utilization 0.85 \
   --max-num-seqs 4 \
   --trust-remote-code

 # Node 2 — same model + same
 --tensor-parallel-size 2
 (vLLM auto-discovers the second
  node over 200GbE link)

C) Quick start — Qwen 3.6 35B
NVFP4 (1x Spark):

 $ docker run -d --name vllm \
   --ipc=host \
   --gpus all -p 8000:8000 \
   -e HF_TOKEN="$HF_TOKEN" \
   -v ~/.cache/huggingface:\
   /root/.cache/huggingface \
   vllm/vllm-openai:cu130-nightly \
   vllm serve Qwen/\
   Qwen3.6-35B-NVFP4 \
   --max-model-len 262144 \
   --gpu-memory-utilization 0.85 \
   --max-num-seqs 4 \
   --trust-remote-code

💡 CRITICAL FLAGS & TIPS

• --gpu-memory-utilization 0.85
→ leaves room for OS, kernel
page cache, container

• --max-num-seqs 4
→ above 4 concurrent streams,
bandwidth tax outweighs
batching gains

• --max-model-len
→ set per model
(131072 / 262144 / 1048576)

• --kv-cache-dtype fp8
→ optional, eases memory strain
(may affect predictability)

• NVFP4 → pre-quantized, NEVER
add --quantization flag, engine
auto-detects

• Keep CUDA graphs active
→ default behavior, don't
disable

• Quantization/MoE backends
→ default to auto, usually
optimal

• Cache models before serving
→ download weights first
(safetensors = 10-15 min
default load)

• Try InstantTensor /
fastsafetensors
→ faster weight loading

• Warm-up request after boot
→ fire a tiny request to warm
JIT kernels (~25s cold start)

• Pin specific image digest
→ don't rely on moving nightly
tags in production

🔌 EXPANDING TO BIGGER CLUSTERS

For 4-8 Sparks, you'll need
a 200GbE switch:

• MikroTik CRS504
→ up to 4 Sparks
(~1% slower vs direct 200Gb)
• Check MikroTik's lineup for
8-port 200GbE options

(Note: specific switch model
numbers from original source
could not be independently
verified — check MikroTik.com
for current 200GbE lineup)

📚 OFFICIAL RESOURCES

• NVIDIA DGX Spark page:
nvidia.com/en-us/products/
workstations/dgx-spark/

• Buy ($4,699):
marketplace.nvidia.com/en-us…
developer/dgx-spark/

• Playbooks (GitHub):
github.com/NVIDIA/
dgx-spark-playbooks

• 2x Connect guide:
nvidia/connect-two-sparks/

• vLLM guide:
vllm.ai/blog/2026-06-01-
vllm-dgx-spark

• User Manual:
docs.nvidia.com/dgx/
dgx-spark/

• Quick Start PDF:
nvidia.com/content/dam/en-zz…
Solutions/dgx-spark/
DGX-Spark-Quick-Start-Guide.pdf

🐦 KEY SOURCES (x.com)

• @MiaAI_lab
— tested models, benchmarks,
2x sweet spot config
(34K views on original tweet)

• @WescheNex1q
— cluster switch recommendations

• @mr_r0b0t
— GitHub playbooks, NCCL tips

• @sudoingX
— DGX Spark vs AMD Strix Halo
benchmarks

• @aijoey
— real setup photos + experience

— https://nitter.net/TraffAlex/status/2071020631072616698#m

NVIDIA DGX Spark hardware

Brief

Why it matters

Key details