triton-lang — скилл для Claude Code: GPU-ядра на Python
Скилл triton-lang учит агента писать GPU-ядра на Triton: @triton.jit, блочные tl.load/tl.store с масками, атомарные операции, автотюнинг и интеграцию в PyTorch.
MIT 358 установок ★ 298 обновлён 2026-06-27
npx skills add mohitmishra786/low-level-dev-skills --skill triton-lang -a claude-codeЧто делает triton-lang
Триггерит на запросы про Triton, tl.constexpr, block pointers, triton.testing или кастомные PyTorch ops. Агент пишет ядра с декоратором @triton.jit, где tl.program_id(0) даёт индекс блока, tl.arange(0, BLOCK) — вектор потоков внутри блока, mask отсекает хвостовые элементы без отдельного ядра. BLOCK: tl.constexpr — константа времени компиляции, разворачивает циклы и резервирует shared memory.
Автотюнер @triton.autotune бенчмаркает конфиги при первом запуске и кеширует лучший для каждой формы массива (ключ key). Для интеграции в torch.compile скилл регистрирует @custom_op с fake-функцией. Агент умеет писать атомарные операции (tl.atomic_add), бенчмаркить через triton.testing.Benchmark и дампить PTX/LLVM IR через TRITON_PRINT_AUTOTUNING=1.
Если BLOCK слишком велик, компиляция падает с OutOfResources — снижай BLOCK или num_warps. Без маски в tl.load/tl.store на хвосте массива результат неверен. NaN в выходе — незаинициализированные masked lanes: передавай other=0.0 в tl.load.
Какие задачи решает
- написать GPU-ядро на Python без сырого CUDA
- собрать fused kernel (softmax + scale + bias в один проход)
- портировать NumPy-операции на GPU с блочной загрузкой
- автоматически подобрать размер блока и число warp через autotuner
- встроить Triton-ядро в PyTorch как кастомную операцию
Примеры запросов агенту
- Напиши Triton-ядро для поэлементного сложения массивов с маской для хвоста
- Сделай автотюнинг для
BLOCKот 128 до 512 и выбери лучший конфиг - Зарегистрируй это ядро как
torch.library.custom_opдляtorch.compile
Как установить triton-lang
1Через Skills CLI (Vercel)
npx skills add mohitmishra786/low-level-dev-skills --skill triton-lang -a claude-code2Вручную: положить файлы
~/.claude/skills/triton-lang/SKILL.mdПапка скилла целиком; для одного проекта — .claude/skills/triton-lang/
1Через Skills CLI (Vercel)
npx skills add mohitmishra786/low-level-dev-skills --skill triton-lang -a codex2Вручную: положить файлы
.agents/skills/triton-lang/SKILL.mdДля всех проектов — ~/.agents/skills/
1Через Skills CLI (Vercel)
npx skills add mohitmishra786/low-level-dev-skills --skill triton-lang -a cursor2Вручную: положить файлы
.cursor/skills/triton-lang/SKILL.mdCursor читает и .agents/skills/, и .claude/skills/
1GitHub CLI
gh skill install mohitmishra786/low-level-dev-skills skills/gpu/triton-lang2Вручную: положить файлы
.github/skills/triton-lang/SKILL.md1Через Skills CLI (Vercel)
npx skills add mohitmishra786/low-level-dev-skills --skill triton-lang -a gemini-cli2Командой платформы
gemini skills install https://github.com/mohitmishra786/low-level-dev-skills --path skills/gpu/triton-langВручную: положить файлы
.devin/skills/triton-lang/SKILL.mdСтарый путь .windsurf/skills/ тоже читается
Через Skills CLI (Vercel)
npx skills add mohitmishra786/low-level-dev-skills --skill triton-lang -a opencodeClaude.ai
Упакуйте папку в zip и загрузите в Settings → Capabilities → Skills
По шагам, с командами для каждой платформы: Как установить скилл в Claude Code: пять способов
Вопросы о triton-lang
Как установить triton-lang в Claude Code?
Выполни npx skills add mohitmishra786/low-level-dev-skills --skill triton-lang -a claude-code, скилл появится в ~/.claude/skills/triton-lang/SKILL.md.
Что делает triton-lang?
Учит агента писать GPU-ядра на Triton: блочные загрузки с tl.load, маскирование, атомарные операции, автотюнинг через @triton.autotune и интеграцию в PyTorch. Позволяет создавать кастомные ops быстрее чистого PyTorch без сырого CUDA.
Почему компиляция падает с OutOfResources?
Слишком большой BLOCK или num_warps. Снизь BLOCK (например, с 512 до 256) или уменьши num_warps в конфиге @triton.autotune.
Исходный текст
SKILL.md · MIT
---
name: triton-lang
description: Triton language skill for Python GPU kernel authoring. Use when writing Triton kernels with @triton.jit, tl.load/store, masking, atomics, benchmarking with triton.testing, or integrating kernels into PyTorch. Activates on queries about Triton, tl.constexpr, block pointers, Triton benchmarking, or PyTorch custom ops.
---
# Triton
## Purpose
Guide agents through writing GPU kernels in OpenAI Triton: the `@triton.jit` decorator, block-oriented `tl.load`/`tl.store` with masking, atomic operations, shared memory via `tl.constexpr`, benchmarking with `triton.testing.Benchmark`, PyTorch integration, and debugging with barriers.
## When to Use
- Writing custom PyTorch ops faster than pure PyTorch but without raw CUDA
- Prototyping fused kernels (e.g., softmax + scale + bias)
- Comparing block sizes and warp counts with Triton's autotuner
- Porting NumPy-style elementwise ops to GPU
- Learning GPU programming with higher-level Python syntax
- Benchmarking kernel variants systematically
## Workflow
### 1. Minimal Triton kernel
```python
import torch
import triton
import triton.language as tl
@triton.jit
def add_kernel(x_ptr, y_ptr, out_ptr, n, BLOCK: tl.constexpr):
pid = tl.program_id(0)
offsets = pid * BLOCK + tl.arange(0, BLOCK)
mask = offsets < n
x = tl.load(x_ptr + offsets, mask=mask)
y = tl.load(y_ptr + offsets, mask=mask)
tl.store(out_ptr + offsets, x + y, mask=mask)
def add(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
n = x.numel()
out = torch.empty_like(x)
grid = lambda meta: (triton.cdiv(n, meta["BLOCK"]),)
add_kernel[grid](x, y, out, n, BLOCK=1024)
return out
```
Key concepts:
- `tl.program_id(0)` — block index (like `blockIdx.x`)
- `tl.arange(0, BLOCK)` — vector of thread indices within block
- `mask` — predication for tail elements (no separate bounds kernel)
- `BLOCK: tl.constexpr` — compile-time constant, enables unrolling
### 2. Load/store and masking
```python
@triton.jit
def masked_load_example(ptr, n, BLOCK: tl.constexpr):
pid = tl.program_id(0)
offs = pid * BLOCK + tl.arange(0, BLOCK)
mask = offs < n
# masked load returns 0 for masked-off lanes
vals = tl.load(ptr + offs, mask=mask, other=0.0)
return vals
```
Block pointers (Triton 2.x+) for structured 2D access:
```python
@triton.jit
def matvec_kernel(a_ptr, x_ptr, y_ptr, M, N, BLOCK_M: tl.constexpr, BLOCK_N: tl.constexpr):
pid_m = tl.program_id(0)
offs_m = pid_m * BLOCK_M + tl.arange(0, BLOCK_M)
acc = tl.zeros((BLOCK_M,), dtype=tl.float32)
for start_n in range(0, N, BLOCK_N):
offs_n = start_n + tl.arange(0, BLOCK_N)
a = tl.load(a_ptr + offs_m[:, None] * N + offs_n[None, :])
x = tl.load(x_ptr + offs_n)
acc += tl.sum(a * x[None, :], axis=1)
tl.store(y_ptr + offs_m, acc, mask=offs_m < M)
```
### 3. Atomic operations
```python
@triton.jit
def atomic_histogram(data_ptr, hist_ptr, n, BLOCK: tl.constexpr):
pid = tl.program_id(0)
offs = pid * BLOCK + tl.arange(0, BLOCK)
mask = offs < n
data = tl.load(data_ptr + offs, mask=mask)
bucket = (data % 256).to(tl.int32)
tl.atomic_add(hist_ptr + bucket, 1, mask=mask)
```
Use atomics sparingly — they serialize memory updates. Prefer block-level reduction then single atomic per block.
### 4. Shared memory via constexpr
```python
@triton.jit
def reduce_kernel(x_ptr, out_ptr, n, BLOCK: tl.constexpr):
pid = tl.program_id(0)
offs = pid * BLOCK + tl.arange(0, BLOCK)
mask = offs < n
x = tl.load(x_ptr + offs, mask=mask, other=0.0)
# Block reduction
x = tl.sum(x, axis=0)
tl.atomic_add(out_ptr, x)
```
`BLOCK` as `tl.constexpr` lets the compiler allocate shared memory and unroll loops at compile time.
### 5. Autotuning
```python
@triton.autotune(
configs=[
triton.Config({"BLOCK": 128}, num_warps=4),
triton.Config({"BLOCK": 256}, num_warps=4),
triton.Config({"BLOCK": 512}, num_warps=8),
],
key=["n"],
)
@triton.jit
def tuned_kernel(x_ptr, y_ptr, out_ptr, n, BLOCK: tl.constexpr):
# ... kernel body ...
pass
```
Autotuner benchmarks configs on first run and caches the best for each `key` shape.
### 6. Benchmarking
```python
from triton.testing import Benchmark
def benchmark_add():
n = 1024 * 1024
x = torch.randn(n, device="cuda")
y = torch.randn(n, device="cuda")
def triton_add():
return add(x, y)
def torch_add():
return x + y
bench = Benchmark(
x_names=["n"],
x_vals=[2**i for i in range(10, 24)],
line_arg="provider",
line_vals=["triton", "torch"],
line_names=["Triton", "PyTorch"],
plot_name="add-bench",
args={},
)
bench.run(lambda n, provider: {
"triton": lambda: add(x[:n], y[:n]),
"torch": lambda: x[:n] + y[:n],
}[provider](), quantiles=[0.5, 0.9])
```
```bash
# Quick timing in REPL
import triton.testing as tt
ms = tt.do_bench(lambda: add(x, y))
print(f"{ms:.3f} ms")
```
### 7. PyTorch integration
```python
import torch
from torch.library import custom_op
@custom_op("mylib::triton_add", mutates_args=())
def triton_add_op(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
return add(x, y)
@triton_add_op.register_fake
def _(x, y):
return torch.empty_like(x)
# Use in model
class MyModule(torch.nn.Module):
def forward(self, x, y):
return triton_add_op(x, y)
```
For `torch.compile` compatibility, register fake/meta kernels and avoid Python side effects in the JIT function.
### 8. Debugging
```python
@triton.jit
def debug_kernel(x_ptr, n, BLOCK: tl.constexpr):
pid = tl.program_id(0)
offs = pid * BLOCK + tl.arange(0, BLOCK)
mask = offs < n
x = tl.load(x_ptr + offs, mask=mask)
# Synchronize threads within block for inspection
tl.debug_barrier()
tl.store(x_ptr + offs, x * 2.0, mask=mask)
```
```bash
# Dump generated PTX/LLVM IR
TRITON_PRINT_AUTOTUNING=1 python script.py
# Set cache dir to inspect compiled kernels
export TRITON_CACHE_DIR=/tmp/triton_cache
```
Compare against PyTorch reference on small inputs before scaling up.
## Common Problems
| Symptom | Cause | Fix |
|---------|-------|-----|
| `OutOfResources` | BLOCK too large | Reduce BLOCK or num_warps |
| Wrong results on tail | Missing mask | Add `mask=offs < n` to load/store |
| Slower than PyTorch | Suboptimal BLOCK | Use `@triton.autotune` |
| `CompilationError` | Type mismatch | Ensure consistent dtypes; use `.to(tl.float32)` |
| NaN in output | Uninitialized masked lanes | Pass `other=0.0` to masked loads |
| torch.compile fails | No fake kernel | Register `register_fake` meta function |
## Related Skills
- `skills/gpu/cuda` — underlying CUDA concepts when Triton limits are hit
- `skills/gpu/cuda-profiling` — Nsight profiling of Triton-compiled kernels
- `skills/gpu/gpu-memory-model` — coalescing and occupancy theory
- `skills/gpu/hip-rocm` — AMD GPU path (Triton supports ROCm)
- `skills/hpc/openmp` — CPU parallelism alongside GPU kernels
© mohitmishra786 · MIT · mohitmishra786/low-level-dev-skills