---
license: [apache-2.0, bsd-3-clause, mit]
language: [en, code]
pretty_name: Kernel-Opt RL (vLLM / SGLang / FlashInfer)
size_categories: [10K<n<100K]
task_categories: [text-generation]
tags: [cuda, triton, gpu-kernels, kernel-optimization, reinforcement-learning, autotuning, vllm, sglang, flashinfer]
configs:
  - config_name: tuned_configs
    data_files:
      - {split: train, path: tuned_configs/train-*}
      - {split: test, path: tuned_configs/test-*}
  - config_name: kernel_commits
    data_files:
      - {split: train, path: kernel_commits/train-*}
      - {split: test, path: kernel_commits/test-*}
---

# Kernel-Opt RL

Real-world GPU kernel optimization data mined from production LLM inference engines
([vLLM](https://github.com/vllm-project/vllm), [SGLang](https://github.com/sgl-project/sglang),
[FlashInfer](https://github.com/flashinfer-ai/flashinfer)). It's built for RL: given a base kernel and a
concrete deployment (model shape, GPU, dtype, batch size), choose the optimization.

Inference engines ship one generic kernel and specialize it per model and per GPU. Most of that
specialization is not new code. It is **autotuned launch parameters** checked in as JSON
(`E=8,N=14336,device_name=NVIDIA_H100_80GB_HBM3.json`), plus a stream of **perf commits** that rewrite
kernels for specific models and hardware. This dataset turns both into RL tasks, with the **benchmark
gains reported in each PR description** extracted as structured measurements.

## Subsets

### `tuned_configs`: kernel + deployment → best launch config

| | |
|---|---|
| rows | 19,287 (17,561 train / 1,726 test) |
| tuned config files | 1,138 |
| GPUs | 48 (NVIDIA A100 → B300/GB300, AMD MI300X/MI325X/MI355X, Intel Arc, …) |
| kernels | `fused_moe_kernel` (vLLM + SGLang), `fused_moe_kernel_gptq_awq`, `_w8a8_triton_block_scaled_mm`, `_w8a8_block_fp8_matmul`, `_w8a8_block_int8_matmul`, `_selective_scan_update_kernel` |
| dtypes | bf16/fp16, fp8_w8a8 (per-tensor + 128×128 block), int8_w8a8, int8_w8a16, int4_w4a16 |
| M (tokens) | 1 … 262,144 |
| documented gains | 148 tuning PRs traced, 66 with benchmark tables; `speedup_vs_default` on 399 rows from 46 config files (median 1.30×, p10 1.03×, p90 1.98×) |

One row is one (config file, batch size M) entry. `prompt` contains the Triton kernel source, the
hardware, the problem shape and the MoE models whose shape matches under TP/EP (`candidate_models`,
resolved against 32 MoE model configs on the Hub). It asks for a JSON config. `best_config` is the
autotuned answer.

Gain fields: `config_pr_url` is the newest PR that added or changed the config file. `config_pr_gains`
holds all measurements extracted from that PR. `speedup_vs_default` is the documented speedup of the
tuned config over vLLM/SGLang's default heuristic at this exact M. It is set only when the attribution
is unambiguous: the GPU and shape match, and multiple matching rows agree within 5%.

**Split:** grouped by config filename (hash), so a given (shape, GPU, dtype) never appears in both
train and test, whatever the repo, Triton version or M.

### `kernel_commits`: optimize a kernel file the way the real perf PR did

| | |
|---|---|
| rows | 1,517 file-level tasks (1,365 train / 152 test) from 850 PRs |
| languages | CUDA (`.cu/.cuh`), C++, Triton, CuTe DSL |
| date range | 2023-04 → 2026-10 |
| documented gains | 529 PRs with benchmark numbers → 913 rows; `kernel_speedup` on 596 rows (median 1.33×, p10 1.02×, p90 4.25×), `e2e_speedup` on 556 rows |

Selected from non-merge commits that touch kernel directories and carry a performance signal in the
title (`[Perf]`, optimize, speedup, faster, tune, throughput, latency, …), excluding build, CI, docs,
tests and reverts. Only modified kernel files are kept: ≤10 per commit, ≤120 KB per file, ≤800 changed
lines.

`prompt` gives the goal (the PR title, which plays the role of the issue in SWE-RL), the target hardware
and models, and the full `before_code`. It asks for **SEARCH/REPLACE edits**. The PR body is withheld
from the prompt because it usually describes the fix. The reference answer is `after_code` / `diff`.
Prompt lengths: median ~21K chars (~6K tokens), p90 ~74K chars. Filter on `len(prompt)` for short-context
RL.

Other fields: `models_mentioned`, `hardware_mentioned`, `speedup_claims` (regex over the commit
message), `pr_body`, `gains` (structured measurements from the PR), `kernel_speedup` / `e2e_speedup`
(median documented speedup at kernel and end-to-end scope), `license`.

**Split:** temporal. The newest ~10% of rows are test (2026-10-18 onward), the code least likely to be in
a model's pretraining data.

### `gains` / `config_pr_gains` format

A JSON list of measurements extracted from the PR description:
`{scope: "kernel"|"e2e", hardware, model, shape, batch_size, metric, unit, higher_is_better, baseline,
optimized, stated_speedup, speedup}`. `speedup` is computed in code from baseline/optimized and
normalized so that > 1 means the PR is better. When a PR states only a ratio, `stated_speedup` is used.
Extraction was done by `Qwen3-235B-A22B-Instruct-2507`, with `gpt-oss-120b` as a fallback for very long
tables, using an extract-only prompt (no computed numbers). Audit: in 98.8% of extracted
baseline/optimized pairs, both values appear verbatim in the PR text. The remainder were mostly averages
of repeated runs. Extraction failed for 5 PRs (malformed model output), which have empty `gains`.

## Using it for RL

Rewards live in [`code/reward.py`](code/reward.py):

- **`tuned_configs`**: `config_reward` is deliberately a stub, because the partial-credit scheme is a design choice. Compare the parsed JSON config to `best_config` as an offline proxy (exact match is
  sparse, so use partial credit or log-distance on the power-of-two tile sizes). `speedup_vs_default`
  tells you how much a config actually matters for that row and can weight the reward. On hardware,
  launch `kernel_source` with the predicted config and reward `t_best / t_pred`. The tuned config is
  only the best within the tuner's search space, so it can be beaten.
- **`kernel_commits`**: `patch_reward(completion, before_code, after_code)` follows SWE-RL. It returns −1 if
  the edits are malformed or don't apply, and otherwise the `difflib` similarity between the changed lines
  and the real commit's. Validated on this data: the oracle edit scores 1.0 on 98.7% of rows and ≥ 0.95 on
  all but one. For an execution reward, run through an environment such as
  [KernelGYM](https://github.com/hkust-nlp/KernelGYM). Watch for reward hacking (timer exploits, cached
  outputs; see the [CUDA-L1](https://github.com/ornith-ai/CUDA-L1) notes).

```python
from datasets import load_dataset
ds = load_dataset("guychuk/kernel-opt-rl", "kernel_commits", split="train")
ds = ds.filter(lambda r: len(r["prompt"]) < 32_000 and r["kernel_speedup"])  # short, with documented gains
```

Both subsets have a plain-string `prompt` column. TRL's `GRPOTrainer` forwards the other columns
(`best_config`, `before_code`, `after_code`, …) to reward functions as keyword arguments.

## Limitations

- Tuned configs record only the *winner*, not the full latency table, so offline config rewards are a
  proxy. `speedup_vs_default` covers only rows whose PR documented that exact M.
- `candidate_models` comes from shape matching (`E == experts`, `N == intermediate / TP`, or
  `E == experts / EP`). Shapes are shared across models, e.g. DeepSeek-V3, Kimi-K2 and MiMo-V2-Flash.
- PR gains are self-reported by the authors, on their hardware and benchmark setup, and are not reproduced.
- Snapshots are from each repo's HEAD at build time (see `commit`). Rebuild for fresher data.

## Licensing

All code comes from vLLM, SGLang and FlashInfer (all Apache-2.0). Some vendored files carry their own
licenses. Each row has a `license` field taken from the file header (Apache-2.0: 1,481 commit rows and all
config rows; BSD-3-Clause / BSD: 35; MIT: 1). Files under non-open-source licenses (the NVIDIA TensorRT
Source Code License Agreement and NVIDIA proprietary headers) are **excluded**. License and copyright
headers in the code are kept verbatim. The upstream `LICENSE` and `NOTICE` files are in
[`licenses/`](licenses/), as Apache-2.0 §4 requires. The compilation itself is released under
Apache-2.0. PR descriptions are quoted from public GitHub PRs and linked via `pr_url`.

## Related datasets

[KernelBench](https://huggingface.co/datasets/ScalingIntelligence/KernelBench) (eval; keep held out),
[KernelBook](https://huggingface.co/datasets/GPUMODE/KernelBook) (PyTorch→Triton pairs),
[Nemotron-SFT-CUDA-v1](https://huggingface.co/datasets/nvidia/Nemotron-SFT-CUDA-v1) (CUDA SFT with tests),
[CUDA-L1](https://github.com/ornith-ai/CUDA-L1) (RL-optimized KernelBench solutions per GPU).

## Reproduce

The build code is in [`code/`](code/). `uv run build.py --push <repo_id>` clones the three repos as blobless clones, mines configs and commits,
fetches PR descriptions with `gh`, extracts gains via HF Inference Providers (cached), and pushes.