KBench — GPU kernel-generation benchmark

400 tasks. Each hands the agent a correct-but-slow reference implementation and an empty stub; the agent writes a fast GPU kernel.

reward = 0                          if the submission is incorrect
reward = achieved TFLOP/s or GB/s   otherwise, UNCAPPED

Correctness is the gate; speed is the reward. There is no oracle and no gold solution — the score is an absolute hardware metric, so it is hardware-portable by construction and nothing has to be re-benchmarked when the hardware changes.

Layout

tasks/<family>/<task>/
    instruction.md      what the agent reads
    task.toml           metadata (timeouts, GPUs, keywords)
    environment/        Dockerfile, reference.py, the stub the agent edits, measure.py
    tests/              the grader (verify_env.py) + test.sh
tools/                  the generators that produce these tasks
agent/                  a kernel-optimization skill + subagents for solving these tasks

Running one task

cd tasks/<family>/<task>
docker build -t mytask environment
docker run --rm --gpus device=0 -v $PWD/tests:/tests:ro mytask bash /tests/test.sh

The grader writes reward.json / details.json to /logs/verifier/. Running it as above with the untouched stub scores 0; that is the intended starting point.

Families

family	tasks	what it covers
megakernel	26	Whole-model decode fused into one persistent kernel, plus the primitives that make it possible.
image-flux-sd3-mmdit	16	FLUX.
video-cogvideox-mochi-ltx	14	Video DiTs with structurally different designs from Wan and HunyuanVideo: CogVideoX's separate LayerNorm experts for text vs video, Mochi's asymmetric joint attention over unequal per-stream head dims, and LTX's very high compression VAE.
video-wan-dit	15	Wan 2.
video-hunyuanvideo-mmdit	15	HunyuanVideo's MMDiT: dual-stream blocks (separate QKV/norm/FFN for text and video, joint attention) then single-stream.
video-3d-causal-vae	22	The 3D causal VAE / tokenizer both Wan and HunyuanVideo use — 4x8x8 compression, one-sided temporal padding, tiled decode.
video-sparse-attention	26	Published sparse-attention schemes for video diffusion: Sliding Tile Attention, Sparse VideoGen head routing, Radial Attention, and block-sparse / caching variants.
diffusion-sampling	14	Flow-matching and DPM-Solver++ steps, TeaCache-style skip decisions, latent blending.
multimodal-audio	16	Vision encoders, multimodal RoPE, and audio/speech synthesis kernels.
linear-attention-ssm	48	Linear-attention and state-space architectures: Gated DeltaNet, Mamba-2, RWKV-7, GLA, GSA, Comba, MesaNet, TTT, Titans and relatives.
attention-text-llm	28	Attention variants from text LLMs: MLA, NSA, MoBA, DSA, cascade, chunked prefill.
quantization-gemm	44	FP8, MXFP4, NVFP4, AWQ, GPTQ, INT8 and INT4 GEMM and quantisation kernels.
moe	20	Mixture-of-experts routing, permutation, grouped GEMM and combine.
kv-cache-paging	25	Paged KV allocation, append, compaction, eviction and quantisation.
training-optimizer-rl	34	Backward passes, fused optimisers, and RLHF / distillation losses.
sampling-speculative-decoding	10	Top-k/top-p/min-p filtering, beam search, and speculative decoding.
norm-rope-fusion	7	RMSNorm / LayerNorm and RoPE fusions.
distributed-multi-gpu	8	Two-GPU tasks.
raw-cuda	12	Raw-CUDA tasks.

CATALOG.json has the same information machine-readably: family, metric, roofline, GPU count and keywords for every task.

How tasks are graded

Correctness is checked against a private copy of the reference embedded in the grader, so editing environment/reference.py cannot affect the score. Every timed repetition runs on freshly generated inputs and the last one is re-validated, so memoising a result and replaying it fails the gate instead of posting an inflated number.

Work is attributed by a formula that depends only on the shape, never on the implementation, so every submission is credited identically and the ranking is a pure speed ranking.

Tolerances are measured, not guessed. Each one is set from the relative error between the reference and an independent correct implementation (the numerical floor), and checked against a variant that ignores the task's distinguishing feature. The measured numbers are written into each task's precision section.

Sizing. Every task's roofline time at its largest graded shape is above 250 us, so the kernel dominates rather than launch overhead.

Toolchain

Tasks are offline: no internet at run time, and no flashinfer, vLLM, flash-attn or TensorRT-LLM is installed. Agents are expected to write CUDA C++ (nvcc and CUTLASS are present) or Triton. torch is available for setup and where there is no efficient direct alternative. Nothing scans submitted source — restrictions are enforced by what is installed and, for the megakernel family, by measuring how the submission actually executes.