Citation and evidence

Triton (OpenAI GPU programming language)

21 min full readUpdated 33 references

This article's verification

Report a problem with this article

Edit article
More

Use this article

Raw MarkdownExplore connections

Improve this page

Revision historyDiscuss this article

Topics

Developer ToolsOpenAIProgramming Languages

Cite this article

Triton is an open-source, Python-embedded programming language and compiler, originally created by Philippe Tillet and released by OpenAI in July 2021, that lets researchers write high-performance custom GPU kernels without writing CUDA C++. It is widely described as a more portable, productivity-oriented complement to CUDA: a Triton kernel is a Python function annotated with @triton.jit in which the programmer reasons about block-level tiles while the compiler handles memory coalescing, shared-memory management, and thread scheduling automatically.[1][2] Triton was created by Tillet during his PhD at Harvard University and presented at the MAPL 2019 workshop, then re-implemented at OpenAI and released as Triton 1.0 on 28 July 2021 under an MIT license.[1][2] Since 2022 the compiler has been rebuilt on top of MLIR, and it now lowers Triton-IR through a Triton-GPU IR and LLVM-IR to NVIDIA PTX or AMD AMDGCN device code.[4] Triton is the kernel-generation backend used by PyTorch's TorchInductor in PyTorch 2.0 (March 2023), and it underpins a large family of community kernel libraries including FlashAttention's Triton reference kernels, LinkedIn's Liger Kernel, FBGEMM_GPU's GenAI kernels, and the vLLM attention backend.[5][6][7][8][9]

Note: This article covers the Triton GPU programming language. It is distinct from NVIDIA Triton Inference Server, an unrelated model-serving product.

What is Triton and where did it come from?

Writing efficient custom kernels for graphics processing units has long required CUDA C++ expertise: programmers manually tile work across thread blocks, stage data into shared memory, coordinate warp-level scheduling, and tune for specific compute capabilities. The first formal description of Triton, "Triton: An Intermediate Language and Compiler for Tiled Neural Network Computations" by Philippe Tillet, H.T. Kung, and David Cox, was published in the Proceedings of the 3rd ACM SIGPLAN International Workshop on Machine Learning and Programming Languages (MAPL '19), held on 22 June 2019 in Phoenix, Arizona alongside PLDI.[1] Tillet, then a Harvard PhD student under Kung and Cox, had begun the project in 2018 after working on auto-tuners for matrix multiplications in CUDA and on the ViennaCL OpenCL library; he completed his PhD in 2020 with a dissertation on compilers for blocked algorithms on GPUs.[25]

The MAPL paper argued that "tile-level operations and optimizations" should be first-class concepts inside a compiler intermediate representation, and showed that adding "just a few data- and control-flow extensions to LLVM-IR could enable various tile-level optimization passes which jointly lead to performance on-par with vendor libraries."[1] The original prototype shipped as a C++/Python library and was hosted at github.com/ptillet/triton and later github.com/openai/triton.[2]

Tillet joined OpenAI full-time in 2020 to continue Triton's development.[25] On 28 July 2021 OpenAI announced Triton 1.0 in the blog post "Introducing Triton: Open-source GPU programming for neural networks," authored by Philippe Tillet.[2] The post described Triton as "an open-source Python-like programming language which enables researchers with no CUDA experience to write highly efficient GPU code" and highlighted that "it can be used to write FP16 matrix multiplication kernels that match the performance of cuBLAS in under 25 lines of code" on recent NVIDIA hardware.[2] The announcement positioned Triton as a complement rather than a wholesale replacement for CUDA: researchers writing custom fused activations, normalisation kernels, or attention variants would no longer need to manage thread-level shared-memory tiling or warp-synchronous reductions by hand, while still being able to target the same NVIDIA tensor cores used by cuBLAS and cuDNN.[2]

Between late 2022 and 2023 the Triton compiler underwent a major internal rewrite to use the MLIR infrastructure. The Triton 2.0 release notes describe a "backend rewritten to use MLIR" along with support for kernels that contain back-to-back matmuls (the FlashAttention pattern).[3] PyTorch 2.0, released on 15 March 2023, made Triton the default GPU code-generator inside the new TorchInductor backend of torch.compile.[5] The repository was moved from the openai/ GitHub organization to a community triton-lang/ organization, where development continues with engineers from companies including Meta, AMD, Intel, NVIDIA, Microsoft and Google presenting their Triton work at its developer conferences.[27]

MilestoneDateNotes
MAPL '19 paper22 June 2019Tillet, Kung, Cox introduce Triton-IR and tile-level optimization passes[1]
Tillet joins OpenAI2020Full-time work on Triton begins inside OpenAI; PhD completed at Harvard University[10]
Triton 1.0 release28 July 2021OpenAI blog post by Phil Tillet; Python-embedded DSL; FP16 GEMM matching cuBLAS in under 25 lines[2]
MLIR-based rewrite2022, into Triton 2.xBackend rewritten on MLIR; supports back-to-back matmuls for FlashAttention[3][4]
PyTorch 2.0 / TorchInductor15 March 2023Triton becomes default GPU code-generator for torch.compile on NVIDIA and AMD[5]
AMD GPU support2023 onwardAMD presents its Triton backend at the first developer conference; current releases require ROCm 6.2 or newer and lower to AMDGCN[27][3][15]
Liger Kernel releaseAugust 2024LinkedIn open-sources Triton kernel library for LLM training[8][20]
First Triton Developer Conference20 September 2023Hybrid event at Microsoft's Silicon Valley campus with talks from Microsoft, OpenAI, NVIDIA, AMD, Intel, Qualcomm, Meta and Google[27]
Gluon lower-level dialect2025Gluon programming model exposing layouts, shared memory and warp specialization as a sibling to Triton[12]

Expanded article table

"Lightning Talk: Triton Compiler - Thomas Raoux, OpenAI", video from PyTorch, published October 24, 2023. Watch on YouTube.

How does the Triton programming model differ from CUDA?

Triton flips the conventional CUDA model. CUDA programs are written as scalar functions executed by individual threads inside thread blocks, with the programmer responsible for memory layouts, coalescing, shared-memory staging and warp-level synchronization. A Triton kernel, by contrast, is written from the perspective of an entire program instance, and the unit of data is a block (or tile): a statically shaped multi-dimensional array distributed across threads automatically by the compiler.[1][2]

The Triton documentation characterises the difference as "blocked program, scalar threads" rather than CUDA's "scalar program, blocked threads"[24]: the programmer reasons about whole tiles, while the Triton compiler decides which threads in a warp will own which elements and inserts the necessary loads, stores, and synchronizations.[2] This abstraction is what the original paper called the "tile" abstraction; it lets the compiler apply optimisations such as automatic shared-memory staging of operands to computationally intensive block operations, automatic vectorisation of memory accesses, and coalescing of contiguous loads and stores.[1][2]

Kernels are written as ordinary Python functions decorated with @triton.jit. A canonical example from the Triton tutorial implements element-wise vector addition:[13]

@triton.jit
def add_kernel(x_ptr, y_ptr, output_ptr, n_elements,
               BLOCK_SIZE: tl.constexpr):
    pid = tl.program_id(axis=0)
    block_start = pid * BLOCK_SIZE
    offsets = block_start + tl.arange(0, BLOCK_SIZE)
    mask = offsets < n_elements
    x = tl.load(x_ptr + offsets, mask=mask)
    y = tl.load(y_ptr + offsets, mask=mask)
    output = x + y
    tl.store(output_ptr + offsets, output, mask=mask)

Several language conventions are visible in this listing.[13] tl.program_id(axis=0) returns the index of the kernel instance along a launch grid axis. BLOCK_SIZE: tl.constexpr marks a compile-time constant, enabling shape-specialised code generation. tl.arange, tl.load, and tl.store operate on tile-shaped tensors; the optional mask argument prevents out-of-bounds memory accesses on the boundary of the input. The kernel launch grid is computed in Python and passed to the JIT-compiled callable.[13]

The Triton standard library exposes block-level primitives such as tl.dot (which the compiler lowers to architecture-specific tensor-core MMA or WMMA instructions), tl.atomic_* operations, reductions like tl.sum, broadcasting, and pointer arithmetic on tensor-shaped pointers. Performance tuning is done primarily through triton.autotune, which compiles and benchmarks a kernel across a list of configuration dictionaries (block sizes, number of warps, number of pipeline stages) and caches the winner.[14] The blog post notes that the "purpose of Triton is to fully automate these optimizations, so that developers can better focus on the high-level logic of their parallel code."[2]

Visually, Triton kernels have an ASCII-art-like syntax in which 1-D and 2-D index ranges are constructed with tl.arange and then broadcast against each other to form 2-D tile coordinates. A typical matrix multiplication kernel computes a BLOCK_M-by-BLOCK_N output tile by sweeping the K dimension in BLOCK_K-sized chunks, accumulating into a BLOCK_M-by-BLOCK_N accumulator and invoking tl.dot once per iteration; the compiler is responsible for pipelining global-memory loads through shared memory and for issuing the appropriate tensor-core instructions on the target architecture.[13][4] Programmers express only the tile-level dataflow; they do not write code per CUDA thread, per warp, or per memory bank.[2]

How does the Triton compiler work?

The Triton compiler is organised as a multi-stage lowering pipeline through several MLIR dialects, before exiting to LLVM-IR and then to vendor-specific assembly.[4]

  1. Python AST to Triton-IR. The @triton.jit decorator captures the Python function's AST and translates it into Triton-IR, an unoptimised, machine-independent dialect inspired by LLVM IR but with first-class tile-typed values such as tensor<1024x!tt.ptr<f32>>.[4] Triton-IR has been an MLIR dialect since the 2022 rewrite.[4]
  2. Triton-IR to Triton-GPU IR. The optimiser lowers Triton-IR to Triton-GPU IR (TritonGPU dialect), which annotates tensors with hardware-specific layouts such as #blocked, slice, dot_op, shared, nvidia_mma, amd_mfma, and amd_wmma.[4] Passes at this level distribute tensors across warps or wavefronts, schedule loads through shared memory, and pipeline matmul-heavy loops.[4]
  3. Triton-GPU IR to LLVM-IR. Triton-GPU IR is converted to LLVM-IR with explicit pointer arithmetic, vector extracts, and inline assembly for non-portable memory operations.[4]
  4. LLVM-IR to device code. LLVM compiles to NVIDIA PTX (further assembled into cubin) or to AMD AMDGCN assembly (compiled to a hsaco binary), depending on the active backend.[4][15] Vendor backends contribute additional dialects (for example, the Intel XPU backend adds the GenX dialect) to help with lowering.[16]

Intermediate forms at every stage can be inspected programmatically via the compiled kernel's asm dictionary, which exposes the Triton-IR, Triton-GPU IR, LLVM-IR, PTX, and final binary.[4]

Internal optimisation passes performed during these lowerings include software pipelining of matmul loops (overlapping global-memory loads, shared-memory stores, and tensor-core operations), allocation of shared-memory buffers, layout conversion to insert minimal data movement between layouts, register pressure analysis, and architecture-specific instruction selection for tl.dot such as Ampere mma.sync.m16n8k16, Hopper wgmma.mma_async, and AMD MFMA/WMMA intrinsics.[4][17] These passes are written as MLIR rewrites and are gated on hardware capabilities so that the same Triton source can produce different (and architecturally appropriate) device binaries depending on the target.[4]

Which hardware backends does Triton support?

Triton ships first-class backends for NVIDIA and AMD GPUs, and several vendor-maintained out-of-tree backends extend it to other accelerators.[11]

NVIDIA. The reference backend targets compute capability 8.0 and above (Ampere and newer).[3] On NVIDIA Hopper H100 hardware Triton uses the asynchronous warp-group wgmma instruction for FP8 and FP16 tensor-core operations, which is required to extract peak throughput from H100's tensor cores.[17] In January 2026 NVIDIA also described Triton-to-TileIR, an incubator project in the triton-lang organization that lets Triton kernels target its CUDA Tile IR instead of PTX on Blackwell GPUs, ahead of any integration into the main compiler.[18]

AMD. Triton's AMD backend targets ROCm 6.2 and newer; it lowers Triton-GPU IR through LLVM-IR to AMDGCN assembly and produces hsaco binaries through the AMD ROCm toolchain.[3][15] AMD's ROCm blog describes Triton as offering greater productivity than either NVIDIA CUDA or AMD HIP.[15] In vLLM, a Triton attention backend developed by teams at IBM Research, Red Hat and AMD is the default on AMD GPUs.[7]

Intel. Intel maintains an out-of-tree backend at intel/intel-xpu-backend-for-triton that targets Intel GPUs through an Intel-specific GenX MLIR dialect, lowering to LLVM and SPIR-V; it uses 2D block I/O and DPAS tensor-core operations for tl.dot.[16]

CPU and other targets. Microsoft's microsoft/triton-shared repository integrates MLIR's linalg dialect to enable CPU lowering through standard MLIR passes, and triton-lang/triton-cpu is an experimental CPU backend hosted in the official organization.[29] Researchers have also presented work on compiling Triton kernels to RISC-V CPUs through MLIR.[30]

What is Triton used for?

Triton has become a foundational layer across multiple parts of the deep-learning stack.

PyTorch and TorchInductor

PyTorch 2.0, released on 15 March 2023, introduced torch.compile and its new TorchInductor backend.[5] TorchInductor uses what the PyTorch team described as "a pythonic define-by-run loop level IR to automatically map PyTorch models into generated Triton code on GPUs and C++/OpenMP on CPUs."[26] The release post explicitly states: "As an underpinning technology of torch.compile, TorchInductor with NVIDIA and AMD GPUs will rely on OpenAI Triton deep learning compiler to generate performant code and hide low level hardware details. OpenAI Triton-generated kernels achieve performance that's on par with hand-written kernels and specialized CUDA libraries such as cuBLAS."[5] The integration was previewed at the PyTorch Conference on 2 December 2022, and the choice of Triton was motivated by the PyTorch team observing that custom-kernel authors were increasingly adopting Triton over hand-written CUDA.[5][26]

TorchInductor's Triton code path is implemented in torch/_inductor/codegen/triton.py; PyTorch also exposes torch.library.triton_op and tutorials for using user-defined Triton kernels alongside torch.compile.[5]

FlashAttention reference kernels

FlashAttention, the IO-aware exact attention algorithm by Tri Dao and collaborators, ships a Triton-based reference implementation alongside its CUDA kernels. Phil Tillet wrote an early FlashAttention-style fused-attention tutorial inside the Triton repository at python/tutorials/06-fused-attention.py, which demonstrates the back-to-back matmul pattern that Triton 2.0 was extended to support.[3][6] The Dao-AILab/flash-attention repository also includes its own experimental Triton implementation at flash_attn/flash_attn_triton.py, supporting attention biases such as ALiBi; the documentation notes that the Triton port is often easier to read and modify than the hand-tuned CUDA kernels.[6] For AMD GPUs, the repository's ROCm build offers a Triton backend for CDNA and RDNA GPUs alongside its default Composable Kernel backend.[6]

Liger Kernel

Liger Kernel is an open-source collection of Triton kernels for large-language-model training released by LinkedIn in August 2024, with an accompanying arXiv technical report "Liger Kernel: Efficient Triton Kernels for LLM Training" by Pin-Lun Hsu and colleagues posted on 14 October 2024.[8][20] The kernels cover RMSNorm, LayerNorm, RoPE, SwiGLU, GeGLU, CrossEntropy, FusedLinearCrossEntropy, Softmax, KLDivergence, alignment losses (DPO, ORPO, SimPO, KTO), and several distillation losses.[8] The paper reports an average 20 percent training-throughput increase and roughly 60 percent GPU-memory reduction for popular LLMs relative to HuggingFace reference implementations.[20]

FBGEMM_GPU

Meta's FBGEMM_GPU library, hosted at pytorch/FBGEMM, includes Triton kernels in its experimental GenAI module covering high/low-precision conversions between FP32, BF16 and FP8 with tensor-wise, row-wise and block-wise scaling, as well as Triton matmuls used in recommendation-system and generative AI workloads on both NVIDIA H100 and AMD MI300X GPUs.[9] FBGEMM_GPU 1.7.0, released in May 2026, added a Triton "IKBO LCE" kernel and a TLX IKBO flash-attention variant.[32]

vLLM

vLLM's inference engine uses Triton extensively. A Triton-based attention backend developed jointly by IBM Research, Red Hat and AMD provides a portable replacement for vendor-specific attention kernels; this Triton backend is the default on AMD GPUs and acts as a fallback on Intel and pre-Hopper NVIDIA cards.[7] vLLM's paged-attention path includes a Triton kernel paged_attention_2d for decode-time attention over the block-table representation of the KV cache.[7]

Other downstream users

Triton kernels are also used in DeepSpeed-based training stacks, for example through Liger Kernel, and in numerous research codebases.[8] Because the same kernel source can compile to NVIDIA, AMD and (via vendor backends) Intel hardware, the vLLM team describes Triton as a way to write performance-portable kernels instead of maintaining hundreds of hardware-specific ones.[7] AMD's AOTriton project, presented in a PyTorch Conference 2024 lightning talk, packages ahead-of-time compiled Triton kernels in a linkable archive, which PyTorch on ROCm uses for scaled dot product attention.[31]

What kinds of workloads run on Triton?

Triton has become a foundational layer across multiple parts of the deep-learning stack. In training, it powers fused-kernel libraries such as Liger Kernel and the kernels embedded in Hugging Face Transformers' optimised attention paths, where it reduces both memory consumption and step time relative to PyTorch-eager implementations.[8][20] In inference, Triton is the kernel-generation backend for torch.compile and is used by vLLM for paged attention, by FBGEMM_GPU for FP8 matrix multiplications, and by quantised-inference libraries for low-bit GEMMs and dequantisation kernels.[5][7][9] In research, Triton is widely used to prototype novel attention variants, mixture-of-experts routing, low-rank adapters, and custom activations, because authors can express algorithmic ideas in roughly Python-like syntax and obtain near-vendor-library performance without writing CUDA.[1][2]

A second class of applications is portability. Because the same Triton source compiles to NVIDIA, AMD, and (via Intel's out-of-tree backend) Intel GPUs, organisations can avoid maintaining separate hand-tuned codepaths per vendor; vLLM's Triton attention backend, developed by teams at IBM Research, Red Hat and AMD, runs the same source code on NVIDIA, AMD and Intel GPUs.[7] Triton kernels can also target experimental CPU backends, and researchers have compiled them for RISC-V CPUs, broadening the scope of "GPU programming language" to include accelerator-style CPU code.[19][29][30]

A third application area is education and rapid prototyping. The official Triton tutorial set walks through vector addition, fused softmax, matrix multiplication with autotuning, low-memory dropout, layer-norm forward and backward, and a fused-attention example from Phil Tillet that implements the FlashAttention algorithm.[13][6][10] University courses and online lecture series (such as the GPU MODE / CUDA MODE lecture sequence) use Triton as a stepping stone between PyTorch-eager code and CUDA, because the gap from "tensor operation" to "tile-level kernel" is much smaller than from PyTorch to a hand-written CUDA kernel.

How does Triton compare with CUDA, Halide, TVM, and XLA?

SystemProgramming abstractionCompiler IRPrimary backends
CUDA / CUDA C++Scalar threads in blocks; manual shared memoryNVVM/PTXNVIDIA only[2]
TritonBlock-level tiles; automatic coalescing and shared-memory stagingTriton-IR and Triton-GPU IR on MLIRNVIDIA, AMD, Intel (out-of-tree), CPU (experimental)[4][11]
Halide / Apache TVMAlgorithm and schedule split with explicit loop-nest transformationsHalide IR / TIRCPU, GPU, accelerators[21]
XLAGraph-level fusion over HLOHLO and StableHLOTPU, GPU, CPU
GluonLower-level tile DSL exposing layouts, shared memory, warp specializationReuses Triton's MLIR stackNVIDIA, AMD[12]

Expanded article table

The MAPL paper specifically contrasted Triton with Halide and TVM, observing that Halide and TVM use loop synthesizers to transform tensor computations into loop nests that are then optimised by user-defined schedules, whereas Triton operates directly on blocks of data; the 2021 OpenAI announcement says it "effectively abstracts away all the issues related to concurrency within CUDA thread blocks (e.g., memory coalescing, shared memory synchronization/conflicts, tensor core scheduling)."[2] Triton also supports irregular and sparse iteration spaces more readily than polyhedral or schedule-based systems because its block-structured representation lets programmers handle load-balancing manually.[21]

Several newer projects build on Triton's core ideas. Gluon, mentioned above, is the explicit-performance escape hatch for advanced kernel authors.[12] ML-Triton is a research extension that adds multi-level compilation layers between the user kernel and the existing Triton-GPU IR. TileLang and CUDA Tile IR are independent industry efforts that target the same "tile-as-IR" abstraction. NVIDIA's Triton-to-TileIR, an incubator project announced in January 2026, lets existing Triton kernels target CUDA Tile IR on Blackwell GPUs instead of PTX, without requiring users to learn a separate language.[18]

What are Triton's limitations?

Despite its strong adoption Triton has documented limitations.[21] Performance, while close to vendor libraries for standard GEMM and attention shapes, can still trail hand-written CUTLASS or hand-tuned CUDA kernels for memory-bound workloads; Modular, which sells a competing stack, has written that it is "common to lose 20%" on NVIDIA's H100 compared with CUDA C++.[22] Debugging is constrained because Triton kernels are JIT-compiled into device code; the official documentation recommends setting TRITON_INTERPRET=1 to bypass compilation and execute kernels under a NumPy-based interpreter, and using NVIDIA's compute-sanitizer for race detection.[23] Triton's block sizes and shapes are largely treated as compile-time constants, which can lead to recompilation overhead when input shapes vary widely. The cross-vendor abstraction also imposes constraints: features that depend on architecture-specific instructions (warp specialization, cluster launch, tensor memory accelerator descriptors) historically required custom intrinsics until the Gluon lower-level dialect was added in 2025 to expose them explicitly.[12]

The Modular team's critique of Python embedded DSLs notes that "Triton trades performance for productivity" and that, while this "makes it easier to write GPU code, it also prevents Triton from achieving peak efficiency," and observes that the same trade-off plays out across other Python eDSLs that abstract away thread-level control.[22] Because Triton kernels are JIT-compiled and autotuned at run time, AMD instead ships ahead-of-time compiled Triton kernels for PyTorch on ROCm through its AOTriton project.[31]

Who governs Triton and is it open source?

The project is licensed under the MIT license and was originally hosted at github.com/openai/triton. Around 2024 the repository was moved to the community-style triton-lang/triton GitHub organization; as of November 2026 the codebase was roughly 41 percent MLIR, 33 percent Python and 25 percent C++.[3] An annual Triton Developer Conference began on 20 September 2023 at Microsoft's Silicon Valley campus in Mountain View, with talks from Microsoft, OpenAI, NVIDIA, AMD, Intel, Qualcomm, Meta and Google; the third edition was held there on 21 October 2025, and the 2026 edition was scheduled for 19 October 2026 at the San Jose Convention Center, just before the PyTorch Conference.[27][28][3] Vendor-specific backends are maintained in separate repositories: intel/intel-xpu-backend-for-triton, microsoft/triton-shared, and triton-lang/triton-cpu.[16][19]

The release cadence has been steady. Triton 2.0 introduced the MLIR rewrite and flash-attention-style back-to-back matmul support. Subsequent 2.x and 3.x releases brought Hopper FP8 tensor-core support via wgmma, the AMD ROCm backend, autotuning improvements, an interpreter mode for debugging, and incremental work on cluster launch and tensor memory accelerator support.[3] Binary wheels are published on PyPI for CPython 3.10 through 3.14.[3] As of November 2026 the latest release was Triton 3.9.0, published on 27 October 2026.[33] The Gluon programming model, introduced in 2025, reuses Triton's MLIR stack but exposes layouts, shared-memory allocations, warp specialization and per-thread operations through Linear Layout, providing a lower-level escape hatch for kernels that need to reach the last few percent of hardware peak.[12]

  • PyTorch integrates Triton through TorchInductor in torch.compile.[5]
  • CUDA is the dominant NVIDIA-only alternative; Triton is positioned as a more portable, productivity-oriented complement.[2]
  • FlashAttention and FlashAttention 3 ship Triton reference implementations alongside their hand-tuned CUDA kernels.[6]
  • XLA and Apache TVM occupy adjacent points in the design space, operating at the graph level rather than the kernel level.[21]
  • vLLM's attention backend uses Triton kernels for paged attention and quantised inference.[7]
  • DeepSpeed training pipelines interoperate with Triton-based fused kernels such as Liger Kernel.[8]

Continue reading

More to read

Topics:Developer ToolsOpenAIProgramming Languages

References

  1. ^1 ^2 ^3 ^4 ^5 ^6 ^7 ^8Tillet, Philippe; Kung, H. T.; Cox, David. "Triton: An Intermediate Language and Compiler for Tiled Neural Network Computations." Proceedings of the 3rd ACM SIGPLAN International Workshop on Machine Learning and Programming Languages (MAPL '19), 2019-06-22. doi.org/...3315508.3329973. Accessed 2026-05-21.
  2. ^1 ^2 ^3 ^4 ^5 ^6 ^7 ^8 ^9 ^10 ^11 ^12 ^13 ^14 ^15 ^16Tillet, Philippe (OpenAI). "Introducing Triton: Open-source GPU programming for neural networks." OpenAI Blog, 2021-07-28. openai.com/...triton. Accessed 2026-05-21.
  3. ^1 ^2 ^3 ^4 ^5 ^6 ^7 ^8 ^9 ^10triton-lang. "README.md, Triton repository." GitHub, accessed 2026-05-21. github.com/...triton. Accessed 2026-05-21.
  4. ^1 ^2 ^3 ^4 ^5 ^6 ^7 ^8 ^9 ^10 ^11 ^12 ^13 ^14PyTorch Foundation. "Triton Kernel Compilation Stages." PyTorch Blog, 2024-10-30. pytorch.org/...triton-kernel-compilation-stages. Accessed 2026-05-21.
  5. ^1 ^2 ^3 ^4 ^5 ^6 ^7 ^8 ^9PyTorch Foundation. "PyTorch 2.0: Our next generation release that is faster, more Pythonic and Dynamic as ever." PyTorch Blog, 2023-03-15. pytorch.org/...pytorch-2-0-release. Accessed 2026-05-21.
  6. ^1 ^2 ^3 ^4 ^5 ^6Dao-AILab. "flash-attention repository README." GitHub, accessed 2026-05-21. github.com/...flash-attention. Accessed 2026-05-21.
  7. ^1 ^2 ^3 ^4 ^5 ^6 ^7 ^8vLLM Project. "vLLM Triton Attention Backend Deep Dive." vLLM Blog, 2026-03-04. blog.vllm.ai/...vllm-triton-backend-deep-dive. Accessed 2026-05-21.
  8. ^1 ^2 ^3 ^4 ^5 ^6 ^7LinkedIn. "Liger-Kernel: Efficient Triton Kernels for LLM Training, repository README." GitHub, accessed 2026-05-21. github.com/...Liger-Kernel. Accessed 2026-05-21.
  9. ^1 ^2 ^3PyTorch (Meta). "FBGEMM_GPU experimental GenAI README." GitHub, accessed 2026-05-21. github.com/...README.md. Accessed 2026-05-21.
  10. ^1 ^2MLSys. "Chat with Philippe Tillet, Author of Triton." mlsys.ai, accessed 2026-05-21. mlsys.ai/...tillet. Accessed 2026-05-21.
  11. ^1 ^2DigitalOcean Community. "Programming AI Accelerators with Triton." DigitalOcean Tutorials, accessed 2026-05-21. digitalocean.com/...oduction-to-triton-programming. Accessed 2026-05-21.
  12. ^1 ^2 ^3 ^4 ^5triton-lang. "Gluon Overview." Triton Documentation, accessed 2026-05-21. triton-lang.org/...gluon. Accessed 2026-05-21.
  13. ^1 ^2 ^3 ^4 ^5triton-lang. "Vector Addition tutorial." Triton Documentation, accessed 2026-05-21. triton-lang.org/...01-vector-add. Accessed 2026-05-21.
  14. ^triton-lang. "triton.autotune API reference." Triton Documentation, accessed 2026-05-21. triton-lang.org/...triton.autotune. Accessed 2026-05-21.
  15. ^1 ^2 ^3 ^4AMD ROCm. "Unlock Peak Performance on AMD GPUs with Triton Kernel Optimizations." ROCm Blogs, accessed 2026-05-21. rocm.blogs.amd.com/...README. Accessed 2026-05-21.
  16. ^1 ^2 ^3Intel. "intel-xpu-backend-for-triton README and ARCHITECTURE." GitHub, accessed 2026-05-21. github.com/...intel-xpu-backend-for-triton. Accessed 2026-05-21.
  17. ^1 ^2PyTorch Foundation. "Accelerating Llama3 FP8 Inference with Triton Kernels." PyTorch Blog, accessed 2026-05-21. pytorch.org/...accelerating-llama3. Accessed 2026-05-21.
  18. ^1 ^2NVIDIA. "Advancing GPU Programming with the CUDA Tile IR Backend for OpenAI Triton." NVIDIA Technical Blog, accessed 2026-05-21. developer.nvidia.com/...-backend-for-openai-triton. Accessed 2026-05-21.
  19. ^1 ^2Microsoft. "triton-shared: Shared Middle-Layer for Triton Compilation." GitHub, accessed 2026-05-21. github.com/...triton-shared. Accessed 2026-05-21.
  20. ^1 ^2 ^3 ^4Hsu, Pin-Lun; Dai, Yun; Kothapalli, Vignesh; Song, Qingquan; Tang, Shao; Zhu, Siyu; Shimizu, Steven; Sahni, Shivam; Ning, Haowen; Chen, Yanning. "Liger Kernel: Efficient Triton Kernels for LLM Training." arXiv:2410.10989, 2024-10-14. arxiv.org/...2410.10989. Accessed 2026-05-21.
  21. ^1 ^2 ^3 ^4triton-lang. "Related Work." Triton Documentation, accessed 2026-05-21. triton-lang.org/...related-work. Accessed 2026-05-21.
  22. ^1 ^2Modular. "What about Triton and Python eDSLs? (Democratizing AI Compute, Part 7)." Modular Blog, accessed 2026-05-21. modular.com/...-what-about-triton-and-python-edsls. Accessed 2026-05-21.
  23. ^triton-lang. "Debugging Triton." Triton Documentation, accessed 2026-05-21. triton-lang.org/...debugging. Accessed 2026-05-21.
  24. ^triton-lang. "Introduction." Triton Documentation, accessed 2026-11-05. triton-lang.org/...introduction. Accessed 2026-11-05.
  25. ^1 ^2NVIDIA. "Author: Philippe Tillet." NVIDIA Technical Blog, accessed 2026-11-05. developer.nvidia.com/...philopenai. Accessed 2026-11-05.
  26. ^1 ^2PyTorch Foundation. "Get Started: PyTorch 2.x." PyTorch, accessed 2026-11-05. pytorch.org/...pytorch-2-x. Accessed 2026-11-05.
  27. ^1 ^2 ^3 ^4triton-lang. "Triton Developer Conference" (2023 meetup notes). GitHub, accessed 2026-11-05. github.com/...dev-meetup-2023.md. Accessed 2026-11-05.
  28. ^triton-lang. "README.md" (v3.8.0, Triton Conference 2025). GitHub, accessed 2026-11-05. github.com/...README.md. Accessed 2026-11-05.
  29. ^1 ^2triton-lang. "triton-cpu: An experimental CPU backend for Triton." GitHub, accessed 2026-11-05. github.com/...triton-cpu. Accessed 2026-11-05.
  30. ^1 ^2RISC-V Summit 2024. "Bridging the Gap: Compiling and Optimizing Triton Kernels onto RISC-V Targets Based on MLIR." Sched, 2024-10-22. riscvsummit2024.sched.com/...nes-technology-co-ltd. Accessed 2026-11-05.
  31. ^1 ^2PyTorch Conference 2024. "Lightning Talk: AOTriton: Ahead of Time Triton Kernel Libraries on ROCm - Jeff Daily, AMD." Sched, 2024-09-19. pytorch2024.sched.com/...es-on-rocm-jeff-daily-amd. Accessed 2026-11-05.
  32. ^PyTorch (Meta). "FBGEMM v1.7.0 release notes." GitHub, 2026-05-18. github.com/...v1.7.0. Accessed 2026-11-05.
  33. ^triton-lang. "Triton 3.9.0 Release Notes." GitHub, 2026-10-27. github.com/...v3.9.0. Accessed 2026-11-05.

Improve this article

Add missing citations, update stale details, or write a clearer explanation. Anyone can edit: changes go live when you publish, and every edit is checked by an editor.

7 revisions by 1 contributor · v7 · 4,260 words · full history

Fact-checks are independent of edits: a reviewer re-verifies the article against its sources and stamps the date. How we verify

Research and drafting on this wiki are AI-assisted, under named human editorial standards. How AI is used here

Reviewer note: Independent fact-check of the full article against its cited sources (130 claims, 36 sources fetched); 10 material + 22 minor fixed

Cite this page: AI Wiki. "Triton (OpenAI GPU programming language)." aiwiki.ai, updated 23 Jun 2026, fact-checked 4 Nov 2026. CC BY 4.0. https://aiwiki.ai/wiki/openai_triton

Edit article