niklaslenzondigo-winder's recipe with NVIDIA's NVFP4 checkpoint: DeepSeek-V4.1-Flash-1017
4x NVIDIA DGX Spark class boxes, tensor parallel 4 over a switchless CX7 ring without diagonals: 2x ASUS Ascent GX10, 1x Gigabyte AI TOP ATOM, 1x Lenovo ThinkStation PGX. One box (an ASUS GX10) runs an older driver (580.173.02) and kernel (6.17.0-1031-nvidia) than the other three (580.178.04, 7.0.0-1019-nvidia). That is named openly.
Not ranked. This setup has no rank and no overall score. This page shows its speed results and two build tests. Quality tests for this setup follow. No rank until then.
What it builds as an agent
Task: Music machine (3D scene with sound, one HTML file). One attempt, no help. Counted: the final file counts.
The exact promptcopy it and try it yourself↓
This is the task prompt word for word, as we handed it to the agent harness. The harness adds its own system prompt and tools, and some harnesses add short context notes of their own. A run that goes past 90 minutes also gets a short “finish now” message, as the prompt says. To try it yourself, give it to your own coding agent: it needs a shell and a working folder.
Design and create the most impressive, creative, elaborate and detailed
physical music machine you are capable of: a 3D machine in which real
physics makes the music. Balls (marbles) roll, drop, bounce and get lifted
through the machine, and every hit on a tuned part (bars, bells, strings,
drums, pipes, anything you invent) plays a note. The look, the instruments
and the mechanics are ENTIRELY your choice — push it as far as you can:
scale, variety, detail, motion, sound quality, musicality. Surprise me.
The user composes by placing balls:
- Build mode: the machine stands still. The user picks balls from a tray
next to the machine and places them on their start positions in the
machine (click or drag), moves placed balls, and removes them. Where and
in which order the balls sit decides which notes play and when.
- The tray offers several kinds of ball that behave differently and look
different, for example heavy and fast, light and slow, bouncy, or big
with a deep sound. Their behaviour must come from the physics (mass,
size, bounce, friction), and the user must hear and see the difference.
- A big start switch or lever (visible in the 3D scene, also clickable)
releases all placed balls at once. They roll off and play the
instruments. A reset button puts every ball back on its placed position,
so the user can change the setup and start again.
- Four presets, one click each, load a complete, carefully composed setup:
all balls already lie on their positions. Each preset must sound really
good when started, like a short real piece of music with a clear melody
and rhythm, and the four must clearly differ in style, mood and tempo.
After loading a preset the user can still change it (move, add, remove
balls) before pressing start, to learn how the piece is built and to
rebuild or remix it.
- The music must come from the physics: a note sounds at the moment a ball
hits the part that makes it, never on a separate timer.
Hard requirements:
- Everything ends up in ONE single self-contained HTML file (game.html in
the current working directory) that opens and runs directly in Chrome.
Use WebGL, the Web Audio API and whatever libraries you like, but embed
everything — no internet access at view time, no external files, no
audio files (make all sound with the Web Audio API).
- The machine must present itself: on load it loads the first preset and
plays it once, with an automatic slow cinematic camera tour (orbiting the
machine, occasionally zooming in on the parts that are playing), plus
mouse controls (orbit/zoom) for manual viewing. If the browser blocks
sound until the first click, show a clear "click for sound" hint and
start the sound on that click; the machine already moves before it.
- All user-facing text (UI, HUD, titles, descriptions, hints) must be in
ENGLISH, regardless of the language of any project files you encounter.
When finished, verify your HTML actually loads and runs without console
errors, then state DONE with the absolute path of game.html.
Do not ask questions.
How you work (same for every model):
- You work alone in the folder /work (this is the current working directory). Nobody will answer questions. Aim to finish in about 60 minutes. After 90 minutes you will get a message to finish; then you have at most 30 more minutes. Hard stop after 120 minutes.
- Tools on this machine: shell, files, python3 with numpy and Pillow, ffmpeg, node, and `shot.sh game.html` (opens the page in a headless browser, saves a screenshot and prints console errors). There is no internet and no access to other machines.
- Keep a working /work/game.html at all times. If you are stopped, the last version that loaded without errors counts.
- JavaScript libraries available offline in the test browser, through an import map with these exact URLs: "three": "https://cdn.jsdelivr.net/npm/three@0.170.0/build/three.module.js", "three/addons/": "https://cdn.jsdelivr.net/npm/three@0.170.0/examples/jsm/", "simplex-noise": "https://cdn.jsdelivr.net/npm/simplex-noise@4.0.3/dist/esm/simplex-noise.js", "@tweenjs/tween.js": "https://cdn.jsdelivr.net/npm/@tweenjs/tween.js@25.0.0/dist/tween.esm.js", "cannon-es": "https://cdn.jsdelivr.net/npm/cannon-es@0.20.0/dist/cannon-es.js". No other external resources.
- After the machine is built, set `window.scene` to the Three.js scene (if you use Three.js) and `window.ready = true`.
- For the automatic test, also provide `window.machine` with: `presets` (the number of presets), `loadPreset(n)` (n from 0 to 3), `ballTypes` (an array of the ball kind names in the tray), `placeBall(type, x, y, z)` (places a ball of that kind there and returns an id), `moveBall(id, x, y, z)`, `removeBall(id)`, `balls` (an array of `{id, type, x, y, z}` for the placed balls), `start()` (the start switch), `reset()`, and `hits` (an array that gets one entry `{t, note, part}` for every note played, with `t` from `performance.now()`).
Play it yourself
Open full screenAI-generated The page this setup built, running live in your browser: click into it and use the controls it shows itself (usually drag to look around, scroll to zoom). It needs WebGL and can be slow on a weak graphics card.
Measured 2026-10-31. Raw files: run info · final choice · screenshot.
Other processes used up to 100 % CPU during the run. Thinking on (reasoning effort: the chat template's default), answer limit 131,072 tokens per request: the model card names 262,144, but the server refuses a request when the prompt plus the answer limit is above its context of 262,144 tokens, so we used half. The world played on this page is the file the agent made, unchanged, except that the copy played on this page loads its code libraries from this site (the same pinned versions) instead of a public CDN. The original file loads them from a public CDN, so it needs an internet connection there. Sound starts only after you click into the page.
Exact command we measured withfor reproducing↓
You do not need this to run the model. It is the exact command of our measurement, so anyone can repeat the result.
bash tools/quality2/measure_all.sh tools/quality2/cards/ds41-nvfp4-nvidia-vllm-engramdisk-ondigo-tp4-4x-e7b0d33.json --parts show --job nvfp4-4x-3110It also built this: Voxel world
Task: Voxel world (3D scene, one HTML file). One attempt, no help. Counted: the final file counts. This page has no rank, so neither build test is part of a score.
The exact promptcopy it and try it yourself↓
This is the task prompt word for word, as we handed it to the agent harness. The harness adds its own system prompt and tools, and some harnesses add short context notes of their own. A run that goes past 90 minutes also gets a short “finish now” message, as the prompt says. To try it yourself, give it to your own coding agent: it needs a shell and a working folder.
Design and create the most impressive, creative, elaborate and detailed
voxel art world you are capable of. The theme and style are ENTIRELY your
choice — pick whatever world you can execute best and push it as far as
you can: scale, variety, detail, color, animation, atmosphere, life.
Surprise me.
Hard requirements:
- Everything ends up in ONE single self-contained HTML file (game.html in
the current working directory) that opens and runs directly in Chrome.
Use WebGL and whatever libraries you like, but embed everything —
no internet access at view time, no external files.
- The scene must present itself: include an automatic slow cinematic
camera tour (orbiting the world, occasionally zooming in on highlights)
that starts on load, plus mouse controls (orbit/zoom) for manual viewing.
- All user-facing text (UI, HUD, titles, descriptions, hints) must be in
ENGLISH, regardless of the language of any project files you encounter.
When finished, verify your HTML actually loads and renders without
console errors, then state DONE with the absolute path of game.html.
Do not ask questions.
How you work (same for every model):
- You work alone in the folder /work (this is the current working directory). Nobody will answer questions. Aim to finish in about 60 minutes. After 90 minutes you will get a message to finish; then you have at most 30 more minutes. Hard stop after 120 minutes.
- Tools on this machine: shell, files, python3 with numpy and Pillow, ffmpeg, node, and `shot.sh game.html` (opens the page in a headless browser, saves a screenshot and prints console errors). There is no internet and no access to other machines.
- Keep a working /work/game.html at all times. If you are stopped, the last version that loaded without errors counts.
- JavaScript libraries available offline in the test browser, through an import map with these exact URLs: "three": "https://cdn.jsdelivr.net/npm/three@0.170.0/build/three.module.js", "three/addons/": "https://cdn.jsdelivr.net/npm/three@0.170.0/examples/jsm/", "simplex-noise": "https://cdn.jsdelivr.net/npm/simplex-noise@4.0.3/dist/esm/simplex-noise.js", "@tweenjs/tween.js": "https://cdn.jsdelivr.net/npm/@tweenjs/tween.js@25.0.0/dist/tween.esm.js", "cannon-es": "https://cdn.jsdelivr.net/npm/cannon-es@0.20.0/dist/cannon-es.js". No other external resources.
- After the scene is built, set `window.scene` to the Three.js scene (if you use Three.js) and `window.ready = true`.
Play it yourself
Open full screenAI-generated The page this setup built, running live in your browser: click into it and use the controls it shows itself (usually drag to look around, scroll to zoom). It needs WebGL and can be slow on a weak graphics card.
Measured 2026-10-31. Raw files: run info · final choice · screenshot.
Thinking on (reasoning effort: the chat template's default), answer limit 131,072 tokens per request, as for the music machine above. The world played on this page is the file the agent made, unchanged. It carries its code libraries inside the file and needs no internet connection.
Exact command we measured withfor reproducing↓
You do not need this to run the model. It is the exact command of our measurement, so anyone can repeat the result.
bash tools/quality2/measure_all.sh tools/quality2/cards/ds41-nvfp4-nvidia-vllm-engramdisk-ondigo-tp4-4x-e7b0d33-vx.json --parts show --job nvfp4-4x-vx-3110How fast it runs
| Measurement | Result |
|---|---|
| Decode | 31.9 tok/s |
| Words per second | 22.3 words/s |
| Characters per second | 144.7 chars/s |
| Decode, code prompt | 33.6 tok/s |
| Decode, prose prompt | 30.2 tok/s |
| Spread of the decode runs (CV) | 11.7 % |
| Spread of the code runs (CV) | 6.3 % |
| Spread of the prose runs (CV) | 11.7 % |
| Decode, window 1 | 34.5 tok/s |
| Prefill at 2K | 3182.8 tok/s |
| Prefill at 8K | 3733.1 tok/s |
| Prefill at 32K | 3884.6 tok/s |
| Time to first token at 2K | 0.6 s |
| Time to first token at 8K | 2.2 s |
| Time to first token at 32K | 8.4 s |
| Draft acceptance rate | 25.0 % |
| Mean accepted length | 2.5 tokens |
| 1 request at once (total) | 27.6 tok/s |
| 2 at once (total) | 46.6 tok/s |
| 4 at once (total) | 73.5 tok/s |
| 8 at once (total) | 114.8 tok/s |
| 1 request at once (per request) | 27.6 tok/s |
| 2 at once (per request) | 24.3 tok/s |
| 4 at once (per request) | 19.2 tok/s |
| 8 at once (per request) | 14.9 tok/s |
| Server slots (from the recipe) | 16 slots |
| Long answer, wall time | 107.5 s |
Long prompts
| Prompt length | Prefill | Time to first token | Decode, code prompt | Decode, prose prompt |
|---|---|---|---|---|
| 16K tokens | 3801.7 tok/s | 4.3 s | 32.7 tok/s | 30.7 tok/s |
| 32K tokens | 3874.7 tok/s | 8.5 s | 37.0 tok/s | 32.0 tok/s |
| 64K tokens | 3872.5 tok/s | 16.9 s | 34.7 tok/s | 30.7 tok/s |
| 128K tokens | 3648.0 tok/s | 35.9 s | 30.1 tok/s | 28.6 tok/s |
Method: code+prose; 2 run(s) each; 512 tokens; 1 warm-up(s); median; context steps: prompts of exactly 16K, 32K, 64K and 128K tokens (a filler log first, the code or prose task prompt last), 2 runs per step, 512 output tokens; decode = tokens after the first / time after the first token; prefill = prompt tokens / time to first token of the same request, median over its requests; requests at once: C1,C2,C4,C8 at once; 2 rounds each; 512 tokens per request; prose prompt; total = all tokens / wall time, per request = tokens / end-to-end time; median over the rounds. Measured 2026-10-31. Raw files: speed result.
Requests at once: the server has 16 slots (from the author's recipe). Setup: NVIDIA's NVFP4 checkpoint of DeepSeek-V4.1-Flash-1017 (revision 480550d3, 429 GB for 748 billion parameters, about 4.6 bits per weight, our calculation: file size times 8 divided by the parameters) with ondigo-winder's recipe for four GB10 boxes (revision e7b0d33) on vLLM, tensor parallel 4, DSpark draft with 6 tokens, context 262,144 tokens, 16 server slots. The recipe's three patches are applied. Changed from the recipe: (1) NVIDIA's checkpoint instead of LibertAIDAI's (same format and tensor names; the byte offsets of the Engram tables differ, and the recipe's first patch reads them from each shard header). (2) Stock NCCL 2.30.7 with CUMEM on instead of the recipe's patched NCCL build, with NCCL settings for our switchless ring (merge NICs on, 4 channels, no LL128 protocol). (3) Nodes 2 to 4 load their weights over the network instead of from a local copy. The setup text recorded with the run says the Engram tables are memory-mapped from the local NVMe, as in the recipe; we did not check that for nodes 2 to 4. One of the four boxes (an ASUS GX10) runs kernel 6.17.0-1031 and driver 580.173.02; the other three run kernel 7.0.0-1019 and driver 580.178.04. These versions are from our setup notes for the four boxes; they were not read from the boxes again for this run. Speed v2: median of 2 runs (prefill: 3), every answer cut at 512 tokens, temperature 1.0 and top-p 1.0 from NVIDIA's model card, thinking off, seed 42. At once = total tokens per second of all requests. The 32K first-token time appears twice: 8.5 s in the long-prompt table and 8.4 s in the prefill test (median of 3 runs). The DSpark draft was accepted for 25 % of its draft tokens on these prompts: 2.5 tokens per step. One long HTML answer from the same server (6,784 tokens, ended on its own, not cut off) ran at 63.3 tok/s with 4.95 tokens per step. That is one long answer, not an agent run. The load monitor of the speed tool was on. It voids a request and repeats it when another process holds over 25 % CPU for 2 samples in a row. In this run 7 of 38 steps were repeated and none ended invalid. The busiest other process was kcompactd0 (kernel memory compaction), at 18 to 92 % of one core. We did not look into why. The server reports no cached-token counts, so we cannot confirm from its numbers that no prompt cache was used. Each prefill run carries its own random salt, and the prefill speed is flat from 3,183 to 3,885 tok/s, which does not look like cache hits. The server's model name is nvidia/DeepSeek-V4.1-Flash-1017-NVFP4.
Exact command we measured withfor reproducing↓
You do not need this to run the model. It is the exact command of our measurement, so anyone can repeat the result.
python3 speed2.py --base-url http://127.0.0.1:41307/v1 --label nvfp4-4x-3110-speed-r1 --prompts $BENCH/repos/rigmark-v2/prompts-v2.json --output $RUN/raw/nvfp4-4x-3110-speed-r1/nvfp4-4x-3110-speed-r1/speed2 --contract $RUN/raw/nvfp4-4x-3110-speed-r1/nvfp4-4x-3110-speed-r1/speed2/speed-contract.json --parts decode,prefill,conc,l1,ctx --prefill-depths 2048,8192,32768 --prompt-ids code,prose --runs 2 --max-tokens 512 --warmups 1 --prefill-runs 3 --conc-levels 1,2,4,8 --conc-rounds 2 --conc-max-tokens 512 --conc-prompt prose --ctx-depths 16384,32768,65536,131072 --ctx-runs 2 --ctx-max-tokens 512 --tokenizer-json $HOME/hf-nvfp4-3010/hub/models--nvidia--DeepSeek-V4.1-Flash-1017-NVFP4/snapshots/480550d349ede47a048eb65a276c5c01a06256e2/tokenizer.json --tokenizer-python $HOME/not published --sampling {"temperature": 1.0, "top_p": 1.0} --sampling-source NVIDIA model card nvidia/DeepSeek-V4.1-Flash-1017-NVFP4 @480550d3 README.md:164: 'Ordinary benchmark requests used temperature=1.0, top_p=1.0, reasoning_effort=max, and max_new_tokens=262144.' The ondigo recipe sets no server sampling (vLLM default from generation_config, none in the checkpoint). Speed v2 runs thinking off (enable_thinking false per request), show thinking on. --model nvidia/DeepSeek-V4.1-Flash-1017-NVFP4 --no-cache-prompt --server-log $RUN/logs/server-A.log --engine-version-file $RUN/logs/engine-version.txt --server-slots 16 --server-slots-source ondigo-winder/deepseek-v4_1-1017-4-gb10@e7b0d33 config/cluster.env.example:28 (MAX_SEQS=16), scripts/node.sh:44 (--max-num-seqs "$MAX_SEQS") --server-ctx 262144 --server-ctx-source card GB10 box 3-ds41-nvfp4-nvidia-vllm-engramdisk-ondigo-tp4-4x-e7b0d33 field ctxQuality
Quality tests for this setup follow. No rank until then.
Also made this possible
- Model
DeepSeek@deepseek_ai Hugging Face GitHub Website - NVFP4 checkpoint (revision 480550d3)
NVIDIA@nvidiadeveloper Hugging Face GitHub Website - Engine (vLLM nightly 0.30.1rc1.dev558)
vLLM@vllm_project GitHub
Run it yourself
What you need and how to start it, step by step. The results below come from exactly this setup.
What you need
- Hardware
- 4x NVIDIA DGX Spark class boxes, tensor parallel 4 over a switchless CX7 ring without diagonals: 2x ASUS Ascent GX10, 1x Gigabyte AI TOP ATOM, 1x Lenovo ThinkStation PGX. One box (an ASUS GX10) runs an older driver (580.173.02) and kernel (6.17.0-1031-nvidia) than the other three (580.178.04, 7.0.0-1019-nvidia). That is named openly.
- Model
- nvidia DeepSeek-V4.1-Flash-1017-NVFP4 (rev 480550d3, NVFP4 experts + MXFP4 Engram, as published) + checkpoint DSpark drafts
- NVFP4 checkpoint (revision 480550d3)
- huggingface.co/nvidia/DeepSeek-V4.1-Flash-1017-NVFP4
- Engine
- vLLM, tensor parallel on 4 GB10 boxes (switchless ring), NVIDIA NVFP4 checkpoint with DSpark drafts, context 262,144 tokens — the program that loads the model and answers requests · github.com/vllm-project/vllm
- Recipe for four GB10 boxes (vLLM image, three patches, start scripts)
- github.com/ondigo-winder/deepseek-v4_1-1017-4-gb10 by ondigo-winder
Steps
Get the recipe, the engine and the model files from the list above.
Start the server with this command. It loads the model into memory.
bash ds41e-4x.sh start (runs ds41e-node.sh on box-4, box-1, box-2, then box-3; container ds41-nvfp4-vllm; vllm serve /model \ --tensor-parallel-size 4 \ --nnodes 4 \ --distributed-executor-backend mp \ --max-model-len 262144 \ --gpu-memory-utilization 0.80 \ --max-num-batched-tokens 8192 \ --max-num-seqs 16 \ --trust-remote-code \ --language-model-only \ --kernel-config {"enable_flashinfer_autotune":false} \ --chat-template no-merge.jinja \ --speculative-config {"method":"dspark","num_speculative_tokens":6,"draft_sample_method":"greedy"} \ --engram-config {"disk_offload": true, "disk_offload_threads": 64} \ --reasoning-parser deepseek_v41 \ --enable-auto-tool-choice \ --tool-call-parser deepseek_v41); rank order box-3=0 box-2=1 box-1=2 box-4=3The file names are the ones we used. Run the command in the folder that holds them, or put the full path in front of each name.
Exact command we measured withfor reproducing↓
You do not need this to run the model. It is the start text exactly as our run recorded it, with the engine build in front, so anyone can repeat the result.
vLLM nightly 0.30.1rc1.dev558+g0cbac6cd1 + ondigo-winder patches 0001-0003 (Engram tables memory-mapped from the local NVMe, 64 threads), TP=4 over 4 nodes (mp backend), DSpark 6 draft tokens (greedy), NCCL 2.30.7 ring; bash $HOME/ds41-engram-3110/ds41e-4x.sh start (runs ds41e-node.sh on box-4, box-1, box-2, then box-3; container ds41-nvfp4-vllm; vllm serve /model --tensor-parallel-size 4 --nnodes 4 --distributed-executor-backend mp --max-model-len 262144 --gpu-memory-utilization 0.80 --max-num-batched-tokens 8192 --max-num-seqs 16 --trust-remote-code --language-model-only --kernel-config {"enable_flashinfer_autotune":false} --chat-template no-merge.jinja --speculative-config {"method":"dspark","num_speculative_tokens":6,"draft_sample_method":"greedy"} --engram-config {"disk_offload": true, "disk_offload_threads": 64} --reasoning-parser deepseek_v41 --enable-auto-tool-choice --tool-call-parser deepseek_v41); rank order box-3=0 box-2=1 box-1=2 box-4=3Context and sampling: 262,144 tokens (the recipe's setting; the model's own window is 1,048,576), 16 server slots, up to 8,192 tokens per batch, GPU memory utilization 0.80, DSpark draft with 6 tokens (greedy), seed 42. Sampling as on NVIDIA's model card: temperature 1.0, top-p 1.0, the same for thinking on and off. The speed test ran with thinking off (set per request). The build tests ran with thinking on and an answer limit of 131,072 tokens per request: the model card names 262,144, but the server refuses a request when the prompt plus the answer limit is above the context, so 262,144 would refuse every request. Agent for the build tests: DeepSeek Harness 0.2.1-rc.2, headless. Hardware: 4x NVIDIA DGX Spark class boxes, tensor parallel 4 over a switchless CX7 ring without diagonals: 2x ASUS Ascent GX10, 1x Gigabyte AI TOP ATOM, 1x Lenovo ThinkStation PGX. One box (an ASUS GX10) runs an older driver (580.173.02) and kernel (6.17.0-1031-nvidia) than the other three (580.178.04, 7.0.0-1019-nvidia). That is named openly. All raw files of this setup: raw/v2/deepseek-v41-flash-4sparks-ondigo-vllm-nvfp4.