Episode 31 · Engineering Deep Dives
Compilers and MLIR: From LLVM to the Triton and XLA Kernels That Make GPUs Fast
A slow neural-network layer becomes a question about what a compiler can see. Begin with the compiler pipeline and LLVM, then explore why machine-learning workloads need additional representations and transformations. XLA, MLIR and kernel-generation ideas connect graph-level structure to memory movement and hardware execution. Portability and verification raise the next questions: how much optimization can be shared across accelerators, and how do we know a transformed program remains correct?
Listen to the show on your preferred podcast platform.
Listen on Spotify ↗Listen on Apple Podcasts ↗Listen on Pocket Casts ↗Listen on Podcast Addict ↗Listen on Castbox ↗Listen on TuneIn ↗
See it work
Explore the working principle
Inside this episode
- Cold open: the slow layer
- What a compiler actually does
- LLVM: the universal middle
- The problem LLVM could not solve
- The memory wall in one layer
- XLA: compiling the whole graph
- MLIR: a compiler that speaks many languages
- Triton: GPU programming for the rest of us
- Ines writes her kernel
- torch.compile: the compiler writes Triton for you
- Ahead of time, just in time, and the launch tax
- Compiling for inference
- Tiling: the art of fitting things on the counter
- FlashAttention: when the compiler is a person
- Down in the back end: registers and schedules
- Autotuning: let the machine try
- Many chips, one model
- Beyond NVIDIA: the portability question
- Can we trust the compiler?
- The frontier
- Epilogue: eleven lines, one kernel
Production credits & AI disclosure
Scripts generated with Claude Opus. Synthetic narration generated with Edge TTS. Reviewed, listened to, and approved by Sankalp Thakur.