Datasets:
NVFP4 vs GGUF quants — does Blackwell-native FP4 pay off? (Qwen3.6-27B)
Model: Qwen3.6-27B · Engine: llama.cpp llama-server/llama-bench b9365 (BLACKWELL_NATIVE_FP4=1)
Hardware: RTX 5090 32GB · Ryzen 5 9600 · 64GB DDR5 · Ubuntu 26.04
Arms: NVFP4 (4-bit, 14.6GB) · Q4_K_M (4-bit, 15.7GB) · Q6_K (6.5-bit, 21GB) · think-off, 50% quality sample
Comparison is quant-only: spec decoding off on all arms (the NVFP4 file ships MTP heads, but bench.py does not enable draft-mtp; the Q6 baseline is plain Q6). So this isolates the quantization, not MTP.
Speed (tok/s)
| metric | NVFP4 | Q4_K_M | Q6_K |
|---|---|---|---|
| prefill pp128 | 3486 | 2973 | 2580 |
| prefill pp512 | 5415 | 3826 | 3222 |
| prefill pp2048 | 5254 | 3741 | 3187 |
| prefill pp4096 | 5073 | 3645 | 3115 |
| prefill pp8192 | 4753 | 3485 | 2992 |
| prefill pp16384 | 4176 | 3162 | 2751 |
| decode tg128 | 84.3 | 77.1 | 61.9 |
| peak VRAM | 17.3 GB | (not captured) | 23.5 GB |
NVFP4 deltas:
- vs Q4_K_M (equal ~4-bit): prefill +32% to +42%, decode +9%
- vs Q6_K (production reference): prefill +52% to +68%, decode +36%, VRAM −30%
Quality (think-off, 50% sample)
| task | NVFP4 | Q6_K | Δ |
|---|---|---|---|
| mmlu | 87.0 | 87.9 | −0.9 |
| arc_challenge | 96.7 | 96.9 | −0.2 |
| hellaswag | 94.9 | 95.4 | −0.5 |
| humaneval | 90.2 | 92.7 | −2.5 |
| gsm8k | 97.1 | 97.3 | −0.2 |
| q_avg | 93.2 | 94.0 | −0.8 |
(Q4_K_M quality not measured — that arm had speed only. NVFP4-vs-Q4 quality at equal bitrate is the obvious follow-up.)
Findings
1. At equal bitrate, NVFP4 clearly beats standard Q4_K_M — on prefill. +32% to +42% prompt-processing throughput, purely from the Blackwell FP4 tensor cores (both models are ~4-bit / ~15GB, so footprint is held roughly constant and only the compute path differs). This is the real "is NVFP4 worth it" answer: yes, for prefill-heavy workloads.
2. The "+43–68% prefill, ~0% decode" claim is half-right — and the other half is the lesson. Our prefill numbers land squarely in that band (+52–68% vs Q6). But decode is not unchanged: +9% vs Q4, +36% vs Q6. The reason the original r/LocalLLaMA figure showed ~0% is that it was a same-model, kernel-vs-kernel comparison (b8966→b8967), where the native FP4 kernel only helps the compute-bound prefill. Across quants, decode is memory-bandwidth-bound, so it tracks model size: vs equal-size Q4 the decode gain is small (+9%); vs the heavier Q6 it's large (+36%). Prefill = compute (FP4 cores); decode = footprint.
3. The 4-bit tax is tiny. NVFP4 lands within 0.8 q_avg of Q6_K (93.2 vs 94.0), with HumanEval the only real casualty (−2.5). Code generation is the first thing to degrade under aggressive quantization — consistent with prior runs on this rig.
Worth it if / not if
- Worth it — almost always, on this card. vs Q6_K you get ~+60% prefill, +36% decode, −30% VRAM for −0.8 q_avg. For an always-on agent like a local Hermes, that's faster responses, longer context headroom, and 6GB of VRAM back, at a quality cost you'd struggle to feel outside code.
- Watch — if your workload is code-heavy, the −2.5 HumanEval is the one place to A/B before committing. And if you're decode-bound at a fixed model size (vs an equal-size Q4), NVFP4's win shrinks to ~+9% — the prefill is where it shines.
Reproduce
# NVFP4 GGUF (text, MTP heads dormant under bench.py): s-batman/Qwen3.6-27B-NVFP4-MTP-GGUF
./run_treatment.sh ~/models/qwen36-27b-nvfp4/Qwen3.6-27B-NVFP4-MTP.gguf # speed sweep + 5 quality tasks
python3 scripts/chart_nvfp4_vs_q6.py # EV+ chart from results/
Baselines reused: results/qwen3-6-27b-q6-k (speed+quality), results/qwen3-6-27b-q4-k-m (speed). Comparison data: results/nvfp4-vs-q6-q4-compare.json.