Triton

Triton is an open-source language and compiler for writing highly efficient custom deep-learning primitives directly in Python. It lets you author GPU kernels with a NumPy-like, block-based programming model and a @triton.jit decorator, then compiles them through an MLIR-based pipeline to fast machine code, aiming for higher productivity than CUDA while offering more flexibility than other DSLs.

Widely used as the kernel backend for frameworks like PyTorch, Triton handles low-level concerns such as memory coalescing, shared-memory management, and intra-SM scheduling automatically, so researchers and engineers can write competitive GPU code without deep CUDA expertise.

What You Get

• A Python-embedded DSL for writing GPU kernels with a NumPy-like, block-based model
• An MLIR-based JIT compiler that lowers kernels to optimized machine code
• Automatic handling of memory coalescing, shared memory, and intra-SM scheduling
• A rich set of tutorials (vector add, fused softmax, matmul, fused attention) to learn from
• Prebuilt binary wheels for CPython 3.10-3.14 and integration as PyTorch’s kernel backend

Common Use Cases

• Writing custom high-performance GPU kernels (fused attention, GEMM, normalization) for deep learning
• Optimizing model training and inference hotspots without hand-writing CUDA
• Prototyping and researching new neural-network primitives with competitive performance

Under The Hood

Architecture - Triton is a compiler stack: Python-facing code in python/triton (language/, compiler/, runtime/, backends/) defines the DSL and JIT driver, while the core compiler is built in C++/MLIR (include/, lib/, third_party/) via CMake. A kernel decorated with @triton.jit is traced into Triton IR, progressively lowered through MLIR dialects with optimization passes that manage tiling, memory coalescing, and shared-memory allocation, and finally emitted to target GPU code through pluggable hardware backends. A binary extension (python/triton/_C) bridges Python to the compiled core.

Tech Stack - The performance-critical compiler is C++ on top of LLVM/MLIR, built with CMake; the Python layer targets CPython 3.10-3.14 and ships prebuilt wheels. The build uses setup.py plus pyproject.toml and vendors backends under third_party/. Tutorials and examples are pure Python.

Code Quality - The repository is large, mature, and heavily engineered, with dedicated test/ and python/test directories, pytest configuration, a filecheck harness for compiler IR, CONTRIBUTING docs, and a very active contributor community including hardware vendors. The MLIR-based design reflects a rigorous, layered compiler architecture.

API Design - The public Python API is compact and expressive: @triton.jit plus triton.language primitives let you express block-level GPU programs with NumPy-like semantics, and a rich tutorial series (vector add through fused attention) lowers the barrier to entry. The conceptual model still demands GPU-programming familiarity, so the learning curve is real, but far gentler than writing raw CUDA.