Nemotron 3.5 Super VL on a DGX Spark

NVIDIA's Nemotron 3.5 Super ships as Nemotron-3.5-Super-VL-120B-A12B, a vision-language MoE with 120B total and 12B active parameters, released on Hugging Face on 15 October 2026. The NVFP4 build is 75.0 GB of weights and NVIDIA's model card lists one DGX Spark as a deployment target, with a Spark-only vLLM configuration that serves one request at a time. NVIDIA publishes no Spark tokens-per-second figure for it, and GPUwerk has not measured it.

What is Nemotron 3.5 Super?

There is no text-only "Nemotron 3.5 Super" checkpoint from NVIDIA. The three released weights are all VL: NVFP4, BF16 and a Base BF16, plus a separate LiLiCorr speculative drafter tuned for the Spark.

Checked 18 October 2026 on the NVFP4 model card. NVIDIA links a technical report from the card. On Blackwell, the card says NVFP4 runs as W4A4; the GB10 in a Spark is Blackwell.

Does it fit in a DGX Spark's 128 GB?

At NVFP4, yes, with room for context. A Spark has about 121.6 GiB addressable (see the models index). File totals from each Hugging Face repository, checked 18 October 2026:

Sizes summed from the file listings of NVIDIA's NVFP4, BF16 and LiLiCorr repos and the ggml-org GGUF repo. The GGUF vision projector (mmproj) adds 1.0 GB at Q8_0 or 1.7 GB at BF16. The leftover column is my arithmetic (GB converted to GiB), not a measurement.

NVIDIA's own Spark settings are conservative. The vLLM quick start caps GPU memory use at 75% with --gpu-memory-utilization 0.75 and allows one sequence at a time. The TensorRT-LLM Spark config limits the KV cache to 5 GiB and the context to 131,072 tokens, and the LiLiCorr card's serving config sets 114,688 tokens. The card's deployment table still lists a 1M-token context for the Spark under vLLM and SGLang; with one sequence and about 50 GiB left after weights, test the context you need rather than assume it.

Which engine should you use on a Spark?

The NVFP4 model card gives Spark configurations for three engines and points to llama.cpp for local use. All Spark recipes on the card target a single user.

• vLLM: the card's quick start is labelled "DGX Spark (GB10) only" and pins vllm/vllm-openai:v0.32.0 or a specific nightly. Docker Hub lists an arm64 build of the v0.32.0 tag (checked 18 October 2026). It drafts 7 tokens per step with the LiLiCorr model and the card recommends LiLiCorr "for DGX Spark deployments in all scenarios".
• SGLang: a Spark config with the same drafter and --max-running-requests 1, using the lmsysorg/sglang:nemotron3-5-super image, which Docker Hub also lists for arm64.
• TensorRT-LLM: version 1.3.0rc28 built from a pinned commit with a Mamba cache patch, so it is the most work to set up. The card's Spark section tells you to save the config as super-vl-gb200.yaml but the serve command loads super-vl-spark-lilicorr.yaml; use one name for both.
• llama.cpp: the card links ggml-org's GGUF collection for DGX Spark and other local hardware, and Unsloth's guide. The card itself gives no llama.cpp command.

My pick for a first test is vLLM with NVIDIA's Spark config: it is the one the card leads with, it loads the NVFP4 safetensors directly, and the arm64 image exists. One inconsistency to know about: the card's deployment table lists the Spark vLLM setup as text and image with MTP drafting 5 tokens, while the quick start uses the LiLiCorr drafter with 7 tokens and passes video flags. The card does not explain the difference.

How fast is it on a DGX Spark?

No tokens-per-second figure for the Spark appears on NVIDIA's model card or the drafter card as of 18 October 2026, and GPUwerk has not run the model. I have left out secondhand speed claims that I could not trace to a first-party Spark measurement.

What NVIDIA does publish is the drafter's acceptance length: with a 7-token draft on SPEED-Bench, the LiLiCorr card reports 4.74 accepted tokens per step on average at temperature 0 and 4.36 at temperature 1, with coding and RAG prompts highest (about 5.3 to 5.7) and roleplay lowest (about 3.5 to 3.8). The card lists DGX Spark as test hardware but states the benchmark ran at concurrency 64. Acceptance length tells you how much of each draft survives verification. It is not a decode speed, and a multiplier on an unknown baseline is still unknown.

How do you run it on a rented GPUwerk Spark?

Nemotron 3.5 Super VL is not a console preset. Deploy a Spark with a base image (DGX OS or Ubuntu 24.04) and open the browser terminal. Docker does not run inside a GPUwerk instance (see the tenant environment), so install vLLM natively with a CUDA 13 PyTorch build as the vLLM doc describes, at the version the model card pins (v0.32.0), and keep the weights under /workspace:

hf download nvidia/NVIDIA-Nemotron-3.5-Super-VL-120B-A12B-NVFP4 \
  --local-dir /workspace/models/nemotron-3.5-super-vl
hf download nvidia/NVIDIA-Nemotron-3.5-Super-VL-120B-A12B-NVFP4-LiLiCorr \
  --local-dir /workspace/models/nemotron-3.5-super-vl-lilicorr

vllm serve /workspace/models/nemotron-3.5-super-vl \
  --host 127.0.0.1 --port 8000 \
  --served-model-name nemotron-3.5-super-vl \
  --max-num-seqs 1 \
  --trust-remote-code \
  --gpu-memory-utilization 0.75 \
  --max-num-batched-tokens 8192 \
  --speculative_config.model /workspace/models/nemotron-3.5-super-vl-lilicorr \
  --speculative_config.num_speculative_tokens 7 \
  --speculative_config.method dflash \
  --mamba-backend flashinfer \
  --mamba-ssm-cache-dtype float16 \
  --enable-mamba-cache-stochastic-rounding \
  --mamba-cache-philox-rounds 5 \
  --enable-mamba-shared-prefix-checkpoint \
  --video-pruning-rate 0.5 \
  --media-io-kwargs '{"video": {"fps": 2, "num_frames": 256}}' \
  --block-size 64 \
  --prefix-match-unit 64 \
  --enable-auto-tool-choice \
  --tool-call-parser qwen3_coder \
  --reasoning-parser nemotron_v3

Expected result: after about 76 GB of downloads and kernel compilation, curl http://127.0.0.1:8000/v1/models lists nemotron-3.5-super-vl. The serve flags are NVIDIA's Spark quick start with local paths and a loopback bind added. I bound it to 127.0.0.1; binding to all interfaces exposes the port on a GPUwerk instance, so add --api-key if you open it up. GPUwerk has not run this command. To start it with the instance, put it in the startup hook described in the vLLM doc.

On a Spark of your own, where Docker works, run the same arguments inside vllm/vllm-openai:v0.32.0. For llama.cpp, the ggml-org repo's own README gives a one-line start with llama.app, llama serve -hf ggml-org/NVIDIA-Nemotron-3.5-Super-VL-120B-A12B-GGUF; check which quant it picks, since the repo also holds the 128.5 GB Q8_0 and the BF16 file. The llama.cpp doc covers building for sm_121 on a GPUwerk instance.

How does it compare with Nemotron 3 Super?

Same size class, different job. Nemotron-3-Super-120B is text only and has a reported Spark speed; the 3.5 VL model adds image and video input and a Spark-specific drafter, but has no Spark speed figure yet.

Checked 18 October 2026 on the 3.5 Super VL NVFP4 card and the 3 Super NVFP4 card. Repo totals count every safetensors file and can differ from the weight figure on the Nemotron 3 Super page. The 3 Super speed is the vLLM project's figure as quoted on that page.

If you only need text and want a number to plan around, take Nemotron 3 Super today. If you need to read screenshots, document pages or short video, the 3.5 VL model is the one of the two that can, and it fits the same box. Run both on your own prompts before deciding; the 3.5 card's own benchmark table shows the NVFP4 build within about a point of BF16 on most rows, but MMLU-ProX is about 3 points lower and some rows the card marks offline drop further (DeepSWE about 6 points, WebVoyager about 11). That is a quantization question you can only settle with your workload.

Try it

A Spark rents for $0.79/hour, billed per minute against a prepaid balance (see the pricing page). The download and first load take a while at 76 GB; after that, timing your own prompts is the quickest way to get the Spark speed figure NVIDIA has not published.

FAQ