# TileGym is NVIDIA's teaching ground for tile-based GPU kernels > TileGym is a CUDA Tile kernel library from NVIDIA that ships tutorials, runnable examples and micro-benchmarks for common deep learning operators, with three interchangeable backends and end-to-end integration examples for Llama 3.1 and DeepSeek V2. It is MIT licensed, and it will only run on a Blackwell GPU, or on Ampere with a newer CUDA. **NVIDIA/TileGym** — Helpful kernel tutorials, examples and SKILLs for tile-based GPU programming - Repository: https://github.com/NVIDIA/TileGym - Stars: 830 · Forks: 92 - Language: Python - License: NOASSERTION - Published: 2026-10-20 · Updated: 2026-10-20 · Language: en - Canonical page: https://hysenlabs.com/projects/nvidia-tilegym ## A playground, dressed as a library TileGym is a CUDA Tile kernel library that provides a collection of kernel tutorials and examples for tile-based GPU programming, published by NVIDIA. The version in the setup file is 1.5.1, with tagged releases v1.5.0 and v1.5.1 in September 2026 and v1.4.0 in July 2026. The repository is not archived, and the last push was on 2026-10-20. The README describes the intent directly. It aims to provide helpful kernel tutorials and examples for tile-based GPU programming, and it calls the repository a playground for experimenting with CUDA Tile, where you can learn how to build efficient GPU kernels and explore their integration into real world large language models such as Llama 3.1 and DeepSeek V2. The feature list is four items: a rich collection of CUDA Tile kernel examples, practical kernel implementations for common deep learning operators, performance benchmarking to evaluate kernel efficiency, and end-to-end integration examples with popular LLMs. The practical reading is that this is a learning and prototyping repository with a package around it. The setup file marks the project as Development Status :: 4 - Beta, the package ships a small set of data files alongside the code, including CUDA headers, Rust sources, TOML, JSON and JSON Lines files, and the repository is topped up with a ROADMAP.md, a SECURITY.md, a wiki/ directory, a blog/ directory and a skills/ directory. ## The hardware floor is the first thing to check The prerequisites section is the first thing to read, because it is restrictive and stated without hedging. TileGym requires CUDA 13.1 or later and a Blackwell GPU, with examples given of the B200, the RTX 5080 and the RTX 5090. NVIDIA Ampere, such as the A100, is also supported, but with CUDA 13.2 or later. The README states that all released kernels are validated on both architectures, and that TileGym is built and tested exclusively on CUDA 13.1 and later. The software side asks for PyTorch 2.9.1 or a compatible version, and Triton, which is included with the PyTorch installation. The kernel programming itself goes through cuda-tile, at version 1.5.0 or later, which depends on the tileiras compiler at runtime. The Ampere caveat is worth pausing on. An A100 owner is supported, but only with a CUDA version that is newer than the Blackwell requirement, which is the opposite of the usual pattern where older hardware needs older stacks. If you have an A100 and your CUDA is 13.1, the README's own rules rule you out. There is also a note about the requirements file pinning filelock and pillow to versions that carry CVE fixes, with the advisory identifiers given for both, which is a small sign of how the dependency set is being watched. ## Installing torch, then tilegym, then the compiler The setup is two steps, and the first one is about the environment rather than about TileGym. If you already have torch and triton, the README says to skip this step. Otherwise, the pre-release PyTorch build for the required CUDA version is installed like this. ```bash pip install --pre torch --index-url https://download.pytorch.org/whl/cu130 ``` The README says torch 2.9.1 is verified to work, and that the triton packages come along with torch. Then TileGym itself. The recommended form installs the extra that bundles the compiler. ```bash pip install tilegym[tileiras] ``` That installs TileGym and all runtime dependencies, including cuda-tile with the tileiras extra, which bundles the tileiras compiler directly into your Python environment. If you already have tileiras on the system, for example from the CUDA Toolkit 13.1 or later, you can omit the extra. ```bash pip install tilegym ``` The source route is the usual clone and install, and the README is explicit about the editable variants for development. ```bash git clone https://github.com/NVIDIA/TileGym.git cd TileGym pip install .[tileiras] # or: pip install . (if you have system tileiras) ``` For editable mode, use pip install -e . or pip install -e .[tileiras]. All runtime dependencies are declared in requirements.txt and are installed automatically by both pip install tilegym and pip install .. ## Three backends behind one set of operations TileGym provides kernels for several backends, each in its own folder under src/tilegym/ops/, which is the most interesting structural decision in the repository. The default is cuTile, in src/tilegym/ops/cutile, with details in the cutile-python project. The second is CUDA Tile C++, in src/tilegym/ops/tilecpp, documented in README.tilecpp.md at the root of the repository. The third is Triton CUDA Tile IR, in src/tilegym/ops/triton, which uses the Triton-to-tile-IR project. The third backend has a slightly awkward installation story, and the README is upfront about it. To use the Triton CUDA Tile IR backend, you install its wheel into a separate directory and select it at runtime with ENABLE_TILE=1, and wheels for CPython 3.12 and 3.13 are available on that project's releases page. ```bash # Install into a separate directory, kept apart from the default environment pip install --target /opt/triton_tileir .whl # Select the Triton CUDA Tile IR backend at runtime PYTHONPATH=/opt/triton_tileir ENABLE_TILE=1 python your_script.py ``` The separate directory is the point. A backend that pulls a different Triton into the main environment would break the rest of your stack, so the wheel is quarantined and selected with an environment variable and a path. That is a small amount of friction that buys a working environment. The result is that the same operation, say a standard deep learning operator, can be written once in the cuTile style, once as CUDA Tile C++, and once as Triton tile IR, and compared. ## Three ways to use it: examples, benchmarks, and a real model The Quick Start section lays out three main ways to use TileGym, and they correspond to three levels of ambition. The first is to explore the kernel examples. All kernel implementations are in the src/tilegym/ops/ directory, individual operations can be tested with minimal scripts, and the function level usage and those minimal scripts are documented in tests/ops/README.md. The second is to run the benchmarks, which are micro-benchmarks for evaluating kernel performance. ```bash cd tests/benchmark bash run_all.sh ``` A complete benchmark guide sits in tests/benchmark/README.md, so the numbers are reproducible rather than quoted in prose. The third is to run the LLM transformer examples, which use TileGym kernels in end-to-end inference scenarios, with runnable scripts and instructions for transformer language models such as Llama 3.1-8B accelerated using TileGym kernels. The extra dependency for that path is pinned. ```bash pip install accelerate==1.13.0 --no-deps ``` The containerised setup builds an image from the Dockerfile in the modeling directory and runs it with GPU access. ```bash docker build -t tilegym-transformers -f modeling/transformers/Dockerfile . docker run --gpus all -it tilegym-transformers bash ``` The layering is sensible: start with a single op and a minimal script, move to a benchmark to see whether your change did anything, and only then wire it into a model. The order in the README is the order you should follow. ## Two optional backends that live outside the Python package Two optional backends sit outside the main install, and both are worth knowing about if you are the kind of person who would rather read Julia or Rust than Python. The first is the Julia set of kernel implementations, in the julia/ directory, based on cuTile.jl. The README calls them experimental, and says they are self-contained in that directory and do not require the Python TileGym package at all. The prerequisites are Julia 1.12 or later, CUDA 13.1 and a Blackwell GPU. ```bash # Install Julia (if not already installed) curl -fsSL https://install.julialang.org | sh # Install dependencies julia --project=julia/ -e 'using Pkg; Pkg.instantiate()' # Run tests julia --project=julia/ julia/test/runtests.jl ``` The julia/Project.toml holds the full dependency list. The second is the cuTile-rs backend, in src/tilegym/ops/cutile_rs, where a subset of the operations ship kernels authored in Rust with cutile-rs and loaded through a C-ABI library called libcutile_kernels.so. Two constraints stand out: it is opt-in, and it is only usable from a source checkout, so a pip install will not give you it. That restriction is not accidental. A Rust backend that has to be compiled and loaded as a shared object cannot be distributed inside a wheel in the same way as a Python or Triton implementation, so the project keeps it out of the packaged path and leaves it to people working from a clone. The build requires Rust 1.89 or newer, on top of the base install. ## Where TileGym is the wrong tool Three situations rule it out. The first is hardware. The whole stack is built and tested exclusively on CUDA 13.1 and later, and the supported GPU list is Blackwell plus Ampere with an even newer CUDA. On a machine with an older driver, or a consumer GPU from before the supported generations, the install succeeds and the kernels do not run, which is a worse failure than a refusal to install. The second is a production dependency. The package classifier says Beta, the repository's own description says playground, and the README frames the whole thing around learning to build efficient GPU kernels and exploring integration into large language models. If you want a dependency you can pin and support, this is a tutorial repository that happens to be pip installable, and the version numbers move quickly, with two releases in September 2026 alone. The third is a project that does not want three backends. The cuTile, CUDA Tile C++ and Triton tile IR paths are the interesting part of the design, but each one is an extra language, an extra toolchain and an extra way for a kernel to behave slightly differently on a different machine. A team that just needs working kernels will take the default and ignore the rest. For its intended audience, though, the value is high. Few projects ship runnable examples, micro-benchmarks and a model integration path together, and fewer still let you compare three kernel authoring styles for the same operator. ## Conclusion TileGym fits a developer who wants to learn tile-based GPU programming on real kernels, or who wants a working reference for a common deep learning operator before writing their own, because the examples are runnable and the benchmarks are included rather than described. It is the wrong tool if you do not have a Blackwell GPU or a recent CUDA install, since the whole stack is built and tested on CUDA 13.1 and up, and it is the wrong tool for a production dependency because the project classifies itself as Beta and its purpose is teaching. Before you start, install the pre-release torch build the README specifies, then install tilegym with the tileiras extra so the compiler is bundled, and read the backends section to decide whether the default cuTile path is the one you want. ## FAQ ### What are the hardware requirements for TileGym? TileGym requires CUDA 13.1 or later and a Blackwell GPU such as the B200, RTX 5080 or RTX 5090. NVIDIA Ampere, for example the A100, is supported as well, but with CUDA 13.2 or later, and the README says all released kernels are validated on both architectures. ### How do I install TileGym? Install the pre-release PyTorch build first with pip install --pre torch --index-url https://download.pytorch.org/whl/cu130, then install the package with pip install tilegym[tileiras], which bundles the tileiras compiler, or pip install tilegym if you already have that compiler on the system. ### Which backends does TileGym support? Three, each in its own folder under src/tilegym/ops/: cuTile as the default, CUDA Tile C++, and Triton CUDA Tile IR, the last selected at runtime with ENABLE_TILE=1 and a wheel installed into a separate directory. ### How do I run the TileGym benchmarks? Change into the benchmark directory and run the script, with cd tests/benchmark followed by bash run_all.sh. The full guide is in tests/benchmark/README.md, and individual operations can also be tested with minimal scripts described in tests/ops/README.md. ### Is TileGym usable as a production dependency? The setup file classifies it as Development Status :: 4 - Beta, and the README describes the repository as a playground for learning and experimentation rather than a supported library. The current version is 1.5.1, with v1.5.0 and v1.5.1 both published in September 2026. ## Sources - [Issues](https://github.com/NVIDIA/TileGym/issues) - [NVIDIA/TileGym on GitHub](https://github.com/NVIDIA/TileGym) - [README](https://github.com/NVIDIA/TileGym/blob/main/README.md) - [Releases](https://github.com/NVIDIA/TileGym/releases) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/nvidia-tilegym