SenseNova-6.8-Code2Video-NVFP4-GGUF

An NVFP4 GGUF of SenseNova 6.8 Code2Video for llama.cpp and LM Studio, built from SenseNova's official BF16 weights. It writes and renders videos in code the same way the original does, fits on one 32 GB card with 131k context, and keeps a full-precision multi-token-prediction head for fast decoding.

All credit for the model goes to SenseNova (sensenova/SenseNova-6.8-Code2Video), a fine-tune of Qwen3.8-27B. Their production skill, prompts and showcase films are on GitHub.

The short version

	This file	Q4_K_M (imatrix)	Q4_K_M (plain)
File size	19.38 GB	16.81 GB	16.81 GB
KLD vs BF16 (lower is better)	0.124	0.147	0.184
99th percentile KLD	3.13	3.98	4.94
Same top token as BF16	92.4%	92.0%	90.6%
Decode with MTP (n 3, p-split 0.2)	157 tok/s	153 tok/s	153 tok/s
MTP draft acceptance	75.3%	71.0%	71.0%
Decode without MTP	74.5 tok/s	79.9 tok/s	79.9 tok/s

Measured on my RTX 5090 with llama.cpp b12015 (official CUDA 13.4 build), all files back to back in one sitting. Both Q4_K_M files are mine too, made from the same official BF16 with stock llama-quantize (the imatrix one calibrated on the same text as this file), so the comparison is like for like. KLD is over 61,440 tokens: half wikitext-2 test, half held-out SenseNova production trajectories that were never used for calibration. Speed is greedy, 512 tokens, median over three code-video prompts x 3 runs.

Files

File	Size	What
SenseNova-6.8-Code2Video-NVFP4.gguf	19,378,918,112 B	the model (NVFP4 + Q8_0 mix, BF16 MTP head)
mmproj-SenseNova-6.8-Code2Video-BF16.gguf	931,146,048 B	vision projector (BF16), from the same SenseNova checkpoint. The model reviews its own rendered frames, so keep it
chat_template-claude-code.jinja		SenseNova's template with one line changed so Claude Code works (see below)

sha256 in SHA256SUMS. The chat template inside the GGUF is SenseNova's chat_template.jinja, byte for byte.

Run it

llama.cpp (b12015 or newer):

llama-server -m SenseNova-6.8-Code2Video-NVFP4.gguf --mmproj mmproj-SenseNova-6.8-Code2Video-BF16.gguf \
  --spec-type draft-mtp --spec-draft-n-max 3 --spec-draft-p-split 0.2 \
  -ngl 999 -fa on -ctk q8_0 -ctv q8_0 --jinja -c 131072 -np 1

• 131k context fits on a 32 GB card with q8_0 KV (about 26 GB used). SenseNova trained it for 512K; that needs more memory than one consumer card has.
• MTP is the fast path. Leave it on: 157 tok/s vs 74.5 without.
• LM Studio: loads in 11 s on the CUDA 12 llama.cpp runtime 2.67.0 with MTP on (max draft 3, min continue probability 0.2) and runs about 120 tok/s on code. It passed my code test. The table numbers are from llama-server.
• Every NVFP4 tensor is tagged W4A16 (general.tensor_extra.prec_a4 = false), so Blackwell runs it with 8-bit activations. All numbers here use that.
• Claude Code: SenseNova's recommended harness. Claude Code sends system messages after the first turn, and the stock template rejects those (System message must be at the beginning). Start the server with --chat-template-file chat_template-claude-code.jinja, which renders them as system turns instead (one line changed, nothing else).

How it was made

1. Calibration from the model's own work. 512 windows x 2,048 tokens cut from SenseNova's published production trajectories (4 of the 6 films; the other 2 are held out for evaluation), rendered through their chat template with reasoning and tool calls kept, exactly as the model sees a real run.
2. Full-precision Hessians on one 32 GB card. The 55.7 GB BF16 model never sits on the GPU at once: the calibration activations stream through one decoder layer at a time, in BF16, and every linear's GPTQ Hessian is accumulated in FP32.
3. GPTQ + Schur Replay NVFP4 (arXiv 2609.36654) on every 4-bit tensor. Inside the GPTQ loop, each 16-weight block tries a window of nine E4M3 scale codes around the usual one plus the Four Over Six point (arXiv 2512.02010). Every candidate replays the block's 16 GPTQ steps, and each row keeps the scale with the lowest real GPTQ loss. Same solver as my FLUX.3 Klein Base NVFP4.
4. Our own GPTQ Q8_0 for the sensitive tensors. The 8-bit tensors are not plain round-to-nearest: GPTQ again, with each 32-weight block's scale picked from candidates the same replay way.
5. Which tensors get 8-bit was measured, not guessed. A sensitivity scan flipped 16 groups of layers and 8 tensor types to Q8_0 one at a time and measured real KLD in llama.cpp. The winners per extra GB were the full-attention K/V, the DeltaNet output and input projections. I then built candidates at five sizes and shipped the most protected one that still decodes at least as fast as Q4_K_M with MTP on.
6. MTP head in full precision. SenseNova's checkpoint does not include its multi-token-prediction layer, so this file carries the official one from Qwen/Qwen3.8-27B, kept in BF16. It accepts 75% of drafts here, vs 71% for a Q4_K_M with a quantized head.

Checks: the streamed BF16 chain matches llama.cpp's BF16 perplexity to 4 digits, every packed tensor reads back bit-exact against the solver, and the shipped tensors are byte-identical to the measured candidate.

Quality

KLD vs BF16, same 61,440 held-out tokens:

Build	Size	Mean KLD	99th pct	Same top
Q4_K_M, plain llama-quantize	16.81 GB	0.184	4.94	90.6%
Q4_K_M, imatrix	16.81 GB	0.147	3.98	92.0%
All tensors Schur Replay NVFP4 (no 8-bit)	17.28 GB	0.146	3.71	91.7%
+ measured Q8_0 tensors (this file)	19.38 GB	0.124	3.13	92.4%

Tensor map

Type	Tensors	Where
NVFP4 (+ F32 .scale)	272	DeltaNet gate projections, full-attention q/o, every FFN gate/up/down
Q8_0 (our GPTQ)	225	DeltaNet qkv and output projections, DeltaNet alpha/beta, full-attention k/v, lm_head
Q8_0	1	token embeddings
BF16	8	MTP head (blk.64), grafted from Qwen3.8-27B
F32	632	norms, convolution, state params, per-tensor NVFP4 scales

Proof it still makes videos

This 12-second film was made end to end by this NVFP4 file on one RTX 5090: SenseNova's unchanged code-video skill, driven through Claude Code (the harness SenseNova trained it in) against llama-server, 131k context, MTP on. I wrote the brief (examples/dense_prompt.md) the way SenseNova's prompt-enhancement step does. The model did everything else: the spec, the Canvas code, 11 rounds of stills it reviewed and fixed, 3 full cuts, the synthesized soundtrack and its own verification report.

• 1920x1080, 30 fps, 12.0 s, AAC stereo, -16.0 LUFS, true peak -1.7 dBTP
• Every on-screen string and number exact. The 16 snapped bar heights measure 0 px off, and all 16 snap ticks land within 1 frame of their bars (its own verification, re-checked by me on the file)
• About 71 minutes of agent time in two sessions (I paused it once), no crashes, no human edits

License

Apache 2.0, same as SenseNova 6.8 Code2Video. The MTP head comes from Qwen3.8-27B, also Apache 2.0.