# Block diffusion vs its autoregressive twin on one RTX 5090: the hyped speedup doesn't show — AR wins at every length

**Rig:** one RTX 5090 32GB · llama.cpp diffusion-gemma build (PR #24427, sm_120 CUDA) ·
**gemma-4-26B-A4B-it** (autoregressive) vs **diffusiongemma-26B-A4B-it** (block diffusion) ·
both **Q4_K_M**, both **source-converted through the same pipeline** · batch 1 · temp 0.4

**Setup:** These are the same Gemma-4 26B-A4B checkpoint family — one trained autoregressive, one as a
block-diffusion variant — so the only variable is the *generation paradigm*. Both were converted from the
original `google/…` safetensors with the **same** `convert_hf_to_gguf.py` and **plain** `Q4_K_M` (no imatrix),
run on the **same** llama.cpp build, same GPU. AR is served via `llama-server` (reasoning off → clean final
answers); diffusion via `llama-diffusion-gemma-cli` (128 steps, entropy-bound early-stop to ~48). Throughput
is each runtime's own **load-excluded** generation timing. **Effective answer tok/s = answer_tokens /
generation_seconds** — the fair cross-paradigm metric, because diffusion pays a *fixed* canvas cost
regardless of how long the answer is.

## The board

| prompt | answer len | AR tok/s | diffusion **eff** tok/s | diffusion raw canvas tok/s | AR faster by |
|---|---|---|---|---|---|
| factual-short | 2 | 114\* | 0.8 | 104 | **142×** |
| factual | 32 | 242 | 9.0 | 72 | **27×** |
| math | 16 | 249 | 4.5 | 73 | **55×** |
| reasoning | 256 | 248 | 107.6 | 107 | **2.3×** |
| explain-med | 256 | 245 | 72.5 | 72 | **3.4×** |
| generate-long | 256 | 251 | 71.9 | 72 | **3.5×** |

\* factual-short's AR rate is cold-start / 3-token measurement noise; AR steady-state is ~248 tok/s.
**VRAM: AR 17.6 GB · diffusion 19.6 GB.**

## The finding

**On its own autoregressive twin — identical training family, params, quant, hardware — block diffusion is
slower at every answer length, and uses more VRAM.** AR holds a rock-steady **~248 tok/s**. Diffusion pays a
fixed **~2.5–3.5 s** cost to denoise a 256-token canvas no matter how short the answer is, so:

- **Short answers are catastrophic** — a 2-token reply ("Canberra") still costs the whole canvas: **0.8 eff
  tok/s vs ~240** (≈140–300× slower).
- **Even its best case loses** — a reasoning answer that *fills* the 256 canvas peaks at **107 tok/s, still
  2.3× slower than AR**.
- **The raw canvas rate (72–108 tok/s) never reaches AR's ~248 either** — so the gap isn't only wasted canvas;
  the paradigm is intrinsically slower at this scale.

The widely-shared day-0 claim ("~120+ t/s, *faster* than autoregressive") **does not reproduce** on a single
5090 at Q4_K_M, batch 1.

## Quality

Both answer the factual prompts correctly (Canberra; Leonardo da Vinci, ~1503). In no-think mode **AR produced
clean, correct, complete answers on all six — including the bat-and-ball trap (`$0.05`, correct, with no
thinking channel)**. Diffusion **can't** be put in no-think mode (the CLI exposes no thinking control), so on
the four reasoning-heavy prompts it dumped raw `<|channel>thought` into the canvas and never resolved a clean
final answer (math truncated mid-formula at 16 tokens). So in practice AR was both faster *and* cleaner — with
the honest caveat that the diffusion CLI's lack of no-think control handicaps it on those prompts.

## Why diffusion might still matter (just not here)

Block diffusion's theoretical win is **parallelism** — denoising many tokens at once should amortize on long
outputs and, especially, under heavy **batching**. This test is **batch 1** on one GPU — the worst case for
it. The honest read: any throughput advantage needs serving load this rig didn't test, or more mature kernels
(PR #24427 is a draft). What's *measured*: at the single-stream interactive scale most people run locally,
autoregressive wins decisively.

## Caveats

- Single RTX 5090, **batch 1**, Q4_K_M, temp 0.4 — no batching/concurrency (diffusion's best case is untested).
- diffusion-gemma support is an **unmerged draft PR (#24427)** with an experimental sampler — kernels may improve.
- Both models were **converted from source** with the PR's own converter, because *every* public GGUF (unsloth,
  AlexAtomic, …) is missing the PR's self-conditioning tensors and won't load.
- AR forced no-think (clean answers); diffusion has **no** no-think control — the quality comparison is
  asymmetric on reasoning prompts.

## Worth it?

For **local single-stream use on a 5090 today: autoregressive Gemma-4 is the pick** — 2–300× faster and
cleaner output. Block diffusion is a genuinely interesting paradigm worth re-testing under batching and once
the kernels mature — but the day-0 "faster than AR" hype isn't real at this scale.

**Sources**
- llama.cpp diffusion-gemma PR: https://github.com/ggml-org/llama.cpp/pull/24427
- google/diffusiongemma-26B-A4B-it: https://huggingface.co/google/diffusiongemma-26B-A4B-it
- runner + chart: https://github.com/notwitcheer/llm-bench-rig (`scripts/diff_vs_ar.py`, `scripts/chart_diff_vs_ar.py`)