See what fits.
Before you launch.
Estimate weights, runtime overhead and KV cache against available memory. Tune context and concurrency before starting a run.
Explore model runsOPEN SOURCE · BUILT FOR NVIDIA DGX SPARK
Your Spark.
Your models.
One control plane.
Run vLLM models and see how they perform. Plan memory, launch recipes, and monitor every Spark node from one dashboard.
Free & MIT licensed · No GPU needed for the demo
THE FULL PICTURE.
Try the DGX Spark dashboard
DEMO DATAExplore GPU load, unified memory and inference performance across three simulated nodes. Enable JavaScript to use the interactive preview, or try the local demo below.
MONITOR YOUR INFERENCE STACK
- vLLM
- llama.cpp
- SGLang
- TGI
- Ollama
Metrics vary by backend. Model launching uses vLLM recipes.
LESS GUESSWORK. MORE INFERENCE.
Make the most
of your hardware.
From your first model to a fleet of nodes, keep the decisions and the details in one place.
See what fits.
Know what your
model is doing.
Track decode and prefill separately, alongside GPU load, unified memory, temperatures and power. Keep a clear view of inference performance.
See inference metricsYour nodes.
Under one roof.
Start and stop containers, inspect model caches, and watch CPU, storage and network activity across your connected NVIDIA hosts.
Try the node overviewTHE MODEL RUNNER
From “will it fit?”
to a serving endpoint.
A recipe brings the weights, container image and vLLM flags together. You choose the workload. The dashboard handles the launch sequence.
- 01
Choose a recipe
Start with a complete serving configuration from the catalog.
- 02
Plan your memory
Set context length and concurrency. See estimated memory use and conflicts before launch.
- 03
Launch and follow along
Track the download, image, container and loading phases until the endpoint responds.
Runs continue on the node even when you close the dashboard.
Read the model runner docs ↗Adjust context length and concurrency to explore an illustrative memory plan. Enable JavaScript to use the controls.
START HERE
Take it for
a local test run.
Explore three simulated nodes. Connect your own hardware when you’re ready.
- No GPU needed for demo mode
- No monitoring agent on your nodes
- Installer supports Linux and macOS
1 Install the dashboard
Run this on the machine that will host the dashboard.
Install
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/garykww/spark-control-plane/main/install.sh)"The installer fetches Node.js if needed and offers to set up a background service. Inspect the installer ↗
2 Start demo mode
Start demo
DEMO_MODE=1 spark-control-planeOpen http://127.0.0.1:5555 in your browser.
Ready to connect your own Spark?
Stop demo mode, then start the dashboard normally:
Start dashboard
spark-control-planeSelect Add node, enter the host and SSH credentials, and use Test before saving. The nodes need SSH access and nvidia-smi.
Prefer Docker or a source checkout?
Clone the repository first:
Clone source
git clone https://github.com/garykww/spark-control-plane.git
cd spark-control-planeDocker
docker compose up --build -dFrom source
npm install
npm run build
npm startSee the Docker instructions for SSH mounts and networking.
OPEN BY DESIGN
Your infrastructure.
Your source code.
Self-host it, inspect it, make it your own. Spark Control Plane is an MIT-licensed project by Gary Wong.
Explore the repository ↗Monitoring over SSH
Read-only commands collect metrics. Actions you choose—like launching models, managing containers or rebooting—make changes on your nodes.
Clear about what is measured
Missing metrics show as not reported. Memory plans are estimates, memory bandwidth is a specification, and the SM occupancy view is proportional.
Built for a trusted network
The API has no built-in authentication. Keep it behind Tailscale, a VPN or an authenticating reverse proxy.
What is Spark Control Plane?
Spark Control Plane is a free, open-source web dashboard for NVIDIA DGX Spark and other Linux hosts with NVIDIA GPUs. It combines hardware monitoring, inference metrics, container management, and a recipe-based vLLM model runner.
Can I try it without a DGX Spark?
Yes. Install the dashboard and run DEMO_MODE=1 spark-control-plane. Demo mode provides synthetic metrics for three example nodes, so you can explore the interface without a GPU or an SSH connection.
What do I need to connect my own nodes?
The dashboard needs Node.js 20 or newer, or Docker. The installer can download its own Node.js copy. Monitored nodes need SSH access and nvidia-smi. Monitoring does not require an agent on the nodes; model runs need the container runtime and tools required by the recipe.
Which inference servers does it support?
Spark Control Plane auto-detects vLLM, llama.cpp, SGLang, TGI, and Ollama. Available metrics depend on what each server exposes. A missing counter appears as not reported, rather than zero. Recipe-based model launching uses vLLM.
Does the memory planner guarantee a model will run?
No. The planner estimates memory for model weights, runtime overhead, and KV cache using the recipe, context length, concurrency, and available node memory. It flags fit and port conflicts before launch, but runtime conditions can still cause a run to fail.
Does it change anything on my nodes?
Monitoring uses read-only SSH commands and installs no monitoring agent. Actions you choose, including launching models, downloading or deleting cached models, controlling containers, rebooting, and shutting down, make changes on the nodes.
Can I expose the dashboard to the internet?
The dashboard API has no built-in authentication and assumes a trusted network. Keep it behind Tailscale, a VPN, or an authenticating reverse proxy. Docker control grants powerful access to the node.
Is Spark Control Plane free and open source?
Yes. Spark Control Plane is released under the MIT license. You can inspect, modify, and self-host the source code. The project is maintained by Gary Wong and is not an official NVIDIA product.
READY WHEN YOU ARE
Put your Spark to work.
Start with the demo. Bring your own hardware next.