Recursive's Flint 40B recipe: NVFP4 GGUF

What it builds as an agent

Task: Airship dock (3D scene, one HTML file). One attempt, no help. Counted: the final file counts.

Design and build the most impressive, creative, elaborate and detailed steampunk airship dock voxel world you are capable of. Theme: a steampunk airship dock. Everything else (style, story, extra details) is your choice.

How you work:
- You work alone in the folder /work. 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. Spend the time where it shows in the result.
- Tools on this machine: shell, files, python3 with numpy and Pillow, ffmpeg, node, and `shot.sh index.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.
- You may create your own assets locally with these tools (textures, sky, sounds, music) and embed them in the file as data URIs. Do not download anything.
- Keep a working /work/index.html at all times: write a first working version early, then improve it step by step. If you are stopped, the last version that loaded without errors counts.
- Check your work with `shot.sh` as often as you like, fix every error, and keep improving until you are satisfied. Then stop.

Deliverable: ONE self-contained file /work/index.html that opens and runs in Chrome.
- JavaScript libraries: only these, through an import map with these exact URLs (they work offline in the test browser). Use whatever helps, including all Three.js addons (post-processing, sky, water, noise and so on):
  - "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. Build every object from cubes (voxels); InstancedMesh is allowed.
- The page fills the whole window and resizes with it. All visible text is in English.
- After the scene is built, set `window.scene` to the Three.js scene and `window.ready = true`.
- An automatic slow cinematic camera tour starts on load. Mouse input switches to OrbitControls (drag to rotate, scroll to zoom).
- Sound, if any, starts only after the first click (browsers block autoplay).
- A small label in the top-left corner: "Steampunk Airship Dock".

Minimum content (go far beyond it):
1. A tall iron docking tower with platforms, stairs or ladders, and a mooring arm at the top.
2. At least two airships, each with a balloon envelope, a gondola and propellers.
3. Big brass gears on the tower or the buildings.
4. Pipes and at least three chimneys that emit rising steam particles.
5. At least one crane and a stack of cargo crates.
6. A ground area with a workshop building and a small rail track.
7. Propellers and gears rotate, steam rises and fades, and one airship slowly approaches the tower, docks, waits and leaves again, in a loop.
8. Warm sunset lighting with shadows.

The browser check

• page loads without page error1 / 1
• window.ready === true within 30 s1 / 1
• no console errors (whole session)1 / 1
• frame is not blank1 / 1
• frame rate in software GL (rAF over 5 s)1 / 1
• required objects (voxel mass, >=3 steam emitters, >=2 airships, label)1.5 / 2
• motion: pixel diff 0.5, >=3 rotating nodes 0.5, large group translating 12 / 2
• OrbitControls: drag and wheel change the picture beyond the animation baseline1 / 1

Measured 2026-10-22. Raw files: check · run info · command · final choice · contract · sampling · gate stats · screenshot · clip.mp4.

The run's own headless check browser, which renders the page the model built, used up to 1590 % CPU. The load monitor counted it as another process. Browser check 9.5 out of 10 (the first check and the newer v3 check both gave 9.5): the page loads, runs without console errors, is not blank, runs at 21.6 frames per second in software rendering, moves on its own and answers to mouse drag and wheel; 1.5 of 2 points for the required objects: the check counted 2 steam sources, the task asks for 3 (the file has 3). The agent (Pi 0.73.1, the harness Recursive recommends for local Flint) finished by itself after 93.2 minutes, one try, no help; the “finish now” message (from 90 minutes) was sent in 2 requests, at 90.5 minutes. 17 of 20 versions of the page loaded without errors, and the last one counts. The limit per answer was 81,920 tokens, the highest value the maker names (Flint model card, sglang README line 165); the maker's client configuration uses 65,536. llama.cpp has no answer limit set in the recipe. 95 requests, no error, no cut-off tool call (131,540 answer tokens; the longest answer had 30,083 tokens). In 21 late requests my test gate shortened the limit to the room left in the context (from 80,725 down to about 60,000); it never became the limit. Sampling as the maker gives it (temperature 1.0, top_p 0.95, top_k 20, min_p 0); the context was 262,144 tokens. Flint has no switch for thinking: its reasoning is always on (the maker's guide says so, and the chat template has no thinking flag). My tests labelled “thinking off” send the usual request flag for no thinking, but Flint ignores it and starts every reply with its reasoning. So “thinking off” on this page means that the flag was sent, not that Flint did not think.

run_showcase.sh --harness pi --task K1 --upstream http://127.0.0.1:38679/v1 --model flint --sampling-file $HOME/quality2-runs/quality-v2-261022-flint-nvfp4-5090/sampling-show.json --out $RUN/quality-v2-261022-flint-nvfp4-5090-show-r0/show --limit-s 7200 --inject-after-s 5400 --poll-s 20 --ctx 262144

How fast it runs

Method: code+prose; 2 run(s) each; 512 tokens; 1 warm-up(s); median; 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-22. Raw files: speed result · speed contract · log · long answer.

Requests at once: the server has 1 slot (from the author's recipe). C2, C4, C8 exceed the slots: the extra requests wait in the queue, and they were measured anyway. The speed test ran with the maker's server flags (README of the NVFP4 repo: 262,144 tokens of context, one slot, flash attention, F16 cache), the maker's sampling, seed 42, no speculation. The headline 224.88 tok/s is the mean of the code prompt (224.82) and the prose prompt (224.94). Flint has no switch for thinking: its reasoning is always on (the maker's guide says so, and the chat template has no thinking flag). My tests labelled “thinking off” send the usual request flag for no thinking, but Flint ignores it and starts every reply with its reasoning. So “thinking off” on this page means that the flag was sent, not that Flint did not think. Because every reply is reasoning text, the visible words per second are 0, so no “500 words” estimate is shown. The memory test ends at 262,144 tokens, the maker's context; its decode value is the speed at that size.

python3 speed2.py --base-url http://127.0.0.1:36349/v1 --label quality-v2-261022-flint-nvfp4-5090-speed-r1 --prompts $BENCH/repos/rigmark-v2/prompts-v2.json --output $RUN/quality-v2-261022-flint-nvfp4-5090-speed-r1/quality-v2-261022-flint-nvfp4-5090-speed-r1/speed2 --contract $RUN/quality-v2-261022-flint-nvfp4-5090-speed-r1/quality-v2-261022-flint-nvfp4-5090-speed-r1/speed2/speed-contract.json --parts decode,prefill,conc,l1 --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 --sampling {"temperature": 1.0, "top_p": 0.95, "top_k": 20, "min_p": 0.0} --sampling-source RecursiveSI/flint sglang/README.md:159-161 'Sampling: temperature 1.0, top_p 0.95, top_k 20 ... Greedy decoding is not validated' @2a247be0c0, README.md:86-89, generation_config.json:11-13; min_p 0 from RecursiveSI/flint-int4-gguf README.md:35 (--min-p 0) @9c47151. Flint has no non-thinking mode, so the instruct and thinking profiles are identical (copies in $HOME/engines/llamacpp-flint-2110/author-files-2a247be/ and $HOME/models/flint-40b-q4_1-9c47151/author-files/) --model flint --no-cache-prompt --server-log $RUN/server-A.log --engine-version-file $RUN/engine-version.txt --server-slots 1 --server-slots-source RecursiveSI/flint-nvfp4-gguf README.md:30 (-np 1) @6ec43e19 (llama-server command README.md:29-33), local copy the RTX 5090 box:$HOME/models/flint-nvfp4-6ec43e19/author-files/README.md:30 (Mac copy: $HOME/bench/README.md:30)

How well it answers

Thinking off, except the last test. Seed 42. Sampling from the model card. A cut-off answer counts as wrong. Measured 2026-10-22.

Note from the run: Flint has no switch for thinking: its reasoning is always on (the maker's guide says so, and the chat template has no thinking flag). My tests labelled “thinking off” send the usual request flag for no thinking, but Flint ignores it and starts every reply with its reasoning. So “thinking off” on this page means that the flag was sent, not that Flint did not think. That is why the short-answer tests are cut: MMLU-Pro and GPQA allow 48 tokens for the letter, and Flint spends them on reasoning. 369 of 400 MMLU-Pro answers and all 198 GPQA Diamond answers were cut off and count as wrong (7.5 % and 0.0 %); 11 of 200 IFEval answers (limit 4,096 tokens), 9 of 40 LiveCodeBench answers (limit 32,768), 57 of 80 long-text answers (limit 128) and 9 of 30 GPQA answers with thinking (limit 16,384) were cut off too. The scores of the cut tests say that Flint cannot skip its thinking more than they say what Flint knows. GPQA Diamond ran on the public mirror fingertap/GPQA-Diamond (the original is gated). These are my own tests.

bash tools/quality2/measure_all.sh tools/quality2/cards/flint-40b-nvfp4-llamacpp-b11803-5090.json --parts mmlupro --job quality-v2-261022-flint-nvfp4-5090

bash tools/quality2/measure_all.sh tools/quality2/cards/flint-40b-nvfp4-llamacpp-b11803-5090.json --parts gpqa --job quality-v2-261022-flint-nvfp4-5090

bash tools/quality2/measure_all.sh tools/quality2/cards/flint-40b-nvfp4-llamacpp-b11803-5090.json --parts ifeval --job quality-v2-261022-flint-nvfp4-5090

bash tools/quality2/measure_all.sh tools/quality2/cards/flint-40b-nvfp4-llamacpp-b11803-5090.json --parts lcb --job quality-v2-261022-flint-nvfp4-5090

bash tools/quality2/measure_all.sh tools/quality2/cards/flint-40b-nvfp4-llamacpp-b11803-5090.json --parts ruler --job quality-v2-261022-flint-nvfp4-5090

bash tools/quality2/measure_all.sh tools/quality2/cards/flint-40b-nvfp4-llamacpp-b11803-5090.json --parts ruler --job quality-v2-261022-flint-nvfp4-5090

bash tools/quality2/measure_all.sh tools/quality2/cards/flint-40b-nvfp4-llamacpp-b11803-5090.json --parts think --job quality-v2-261022-flint-nvfp4-5090

How much context fits

Memory test. For each context size (4K, 8K, 16K ... up to the largest size tested for the setup) the server is started again with that context, one prompt that fills about 95 % of the context is sent, and the model must answer. The largest size that loaded and answered counts. Decode speed is measured on that answer at the largest size. Peak memory is the GPU memory in use (nvidia-smi); the GPU was empty before each start. Measured 2026-10-22. Raw files: result of every step · log · contract.

Note from the run: The largest size tested is 262,144 tokens, the maker's own context, so it is the largest size tested, not necessarily the largest the engine could load. Every size from 4K to 256K loaded and answered. The memory number is the GPU memory in use (the model weights are 22.9 GB and the F16 cache grows with the context); the number is for the whole 5090. The maker's README recommends at least 48 GB of GPU memory and lists other graphics cards; the 5090 has 32 GB and it worked at the full context.

bash tools/quality2/measure_all.sh tools/quality2/cards/flint-40b-nvfp4-llamacpp-b11803-5090.json --parts fit --job quality-v2-261022-flint-nvfp4-5090

Also made this possible

• Engine (llama.cpp, with the Flint support)ggml-org (llama.cpp)GitHub @ggml_org Hugging Face Website

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

1x NVIDIA GeForce RTX 5090 32 GB

Model

Recursive Flint 40B (39.8B MoE, ~2.5B active) NVFP4 GGUF (RecursiveSI/flint-nvfp4-gguf @6ec43e19)

Model, NVFP4 GGUF and recipe

huggingface.co/RecursiveSI/flint-nvfp4-gguf

Engine

llama.cpp b11803, one RTX 5090 (the maker's llama-server flags) — the program that loads the model and answers requests · github.com/ggml-org/llama.cpp/releases/tag/b11803

Steps

1. Get the engine and the model files from the list above.

2. Start the server with this command. It loads the model into memory. When the model has loaded, the server waits for requests on port 8888, only from this computer.

   Copy

   CUDA_VISIBLE_DEVICES=0 llama-server \
     -m flint-nvfp4.gguf \
     --alias flint \
     -ngl all \
     -c 262144 \
     -np 1 \
     -fa on \
     -ctk f16 \
     -ctv f16 \
     --jinja \
     --temp 1 \
     --top-p 0.95 \
     --top-k 20 \
     --min-p 0 \
     --host 127.0.0.1 \
     --port 8888

   The 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.

   What the parts mean

   • CUDA_VISIBLE_DEVICES=0which NVIDIA GPU the program may use: the number of the GPU in our machine (with one GPU it is 0)
   • -m flint-nvfp4.ggufthe model file it loads
   • -c 262144the context window in tokens: how much text the model can see at once
   • -np 1how many requests it answers at the same time
   • --jinjauses the chat template that comes with the model
   • -fa onturns on FlashAttention, a faster way to compute attention
   • --temp 1sampling temperature: how random the answers are
   • --top-p 0.95top-p sampling: only the most likely next tokens that together reach this probability are considered
   • --host 127.0.0.1who can connect: only this computer
   • --port 8888the network port the server listens on
   • --alias flintthe model name clients use in their requests

llama.cpp b11803 @a37cc4610 (official prebuilt release asset llama-b11803-bin-ubuntu-cuda-12.8-x64, includes Flint PR #30928; host CUDA 12.8 runtime), F16 KV, no speculation; CUDA_VISIBLE_DEVICES=0 llama-server -m $HOME/models/flint-nvfp4-6ec43e19/flint-nvfp4.gguf --alias flint -ngl all -c 262144 -np 1 -fa on -ctk f16 -ctv f16 --jinja --temp 1 --top-p 0.95 --top-k 20 --min-p 0 --host 127.0.0.1 --port 8888

Mia's own benchmark, run unchanged

This is Mia's own benchmark tool (commit 21a3511), run unchanged. It has its own section on this page, and it is never mixed with my numbers. A cut-off answer counts as wrong here, so a value can differ from sparkDash's own screen.

Seed 1234 applies to the two quality tests; decode, prefill and tool eval send no seed. The benchmark client ran on a separate machine that is never part of the measured group. Measured 2026-10-22. Version 2.50.0, commit 21a3511.

QA. Quality QA, 150 items, seed 1234, temperature 0, thinking off, 4 requests at once (Mia's default). An answer cut off at the token limit counts as wrong. ± is the 95 % margin (Wilson).

MMLU. Quality MMLU, 285 items (5 for each of 57 subjects, 4 answers), seed 1234, temperature 0, thinking off. An answer cut off at the token limit counts as wrong. ± is the 95 % margin (Wilson).

Decode. Decode bench, 1 request at once, 400 tokens, prompt type structured, temperature 0, thinking off. No seed is sent.

Prefill. Prefill bench at 4K, 8K, 16K and 32K tokens. sparkDash skips a size that does not fit into the context. No seed is sent.

Tool Eval Quick. Tool Eval Quick: tool-eval-bench (SeraphimSerapis, commit c61319b), 15 core scenarios (--short), --no-think, --timeout 120. Score 0 to 100. No seed is sent.

Note from the run: Flint has no switch for thinking: its reasoning is always on (the maker's guide says so, and the chat template has no thinking flag). My tests labelled “thinking off” send the usual request flag for no thinking, but Flint ignores it and starts every reply with its reasoning. So “thinking off” on this page means that the flag was sent, not that Flint did not think. In sparkDash this shows clearly: 109 of 150 QA answers and 38 of 285 MMLU answers hit sparkDash's token limit while still reasoning and count as wrong, so the QA and MMLU scores below are lower bounds. The sparkDash client ran on another machine and was never part of the measured group.

python3 tools/quality2/sparkdash_client.py tools/quality2/cards/flint-40b-nvfp4-llamacpp-b11803-5090.json <box> --client <client machine> --job flint-5090-sparkdash-2210 --out $RUN

tool-eval-bench --base-url http://127.0.0.1:<port> --model flint --short --no-think --timeout 120 --json-file $BENCH/sparkdash-client/runs/flint-5090-sparkdash-2210-sparkdash-r1/tooleval/result.json --no-live