1. A Multi-Dimensional, Per-Pass Empirical Study of the LLVM Optimization Pipeline — Federico Bruzzone

2. DialGAN: Relational Bipartite Graph Attention Network for Dialect Agnostic MLIR Equality Saturation — Abhilash Majumder

3. How I Automated 400+ LLVM Libc Refactoring PRs — Ezzeldin Ibrahim

4. Static Sparsity Inference for MLIR — Petros Avgerinos

5. Transfer Learning Across MLIR Dialects — Douglas Viana Coutinho

6. Belalang: Bridging MLIR and GC Runtimes — Vito Secona

7. Universal Profile-Guided Automatic Software Loop Data Prefetcher for LLVM — Sergey Shcherbinin, Madhur Amilkanthwar, Neil Hickey

8. Can LLVM Power the WebGPU Ecosystem? — Rithik Sharma

9. Extending Code Idiom Recognition to 100k+ Patterns via the OEIS — Matthew Davis, Benjamin Mikek

1. A Multi-Dimensional, Per-Pass Empirical Study of the LLVM Optimization Pipeline — Federico Bruzzone
Quantifying the impact of individual compiler optimizations is essential for improving optimization pipelines, pass selection, and autotuning. This talk presents a large-scale empirical study of the LLVM -O3 pipeline, examining how each stage contributes to execution time, compile time, binary size, energy consumption, and hardware performance. By evaluating every cumulative prefix of the -O3 pipeline on 30 PolyBench/C kernels, we reveal that optimization progress is often non-monotonic and that most performance gains come from a surprisingly small subset of passes. We also show that commonly used metrics such as IR instruction count are weak predictors of runtime performance. These findings provide practical insights for compiler engineers and researchers working on optimization pipeline design and tuning.

2. DialGAN: Relational Bipartite Graph Attention Network for Dialect Agnostic MLIR Equality Saturation — Abhilash Majumder
MLIR's strength is optimizing IR across multiple abstraction levels, but sequencing those optimizations is brittle: passes interfere destructively and ordering choices yield unpredictable results — the phase-ordering problem. Equality saturation sidesteps this by applying all rewrites non-destructively into an e-graph and extracting the best equivalent program, a capability MLIR lacks natively. We present DialGAN, a novel framework that drives dialect-agnostic MLIR phase ordering and IR rewriting with a Relational Bipartite Graph Attention Network as a learned, runtime-trained extraction cost model over the saturated e-graph. Unlike static-cost extractors, DialGAN learns which equivalent IR is genuinely fastest on hardware. It achieves up to 6.37× over MLIR's hand-written passes and 1.05× over the SOTA DialEgg framework (CGO 2025) on 3MM, with comparable results on Polynomial. Crucially, where DialEgg omits dialects like tosa and transform, DialGAN generalizes: on lowered ML graphs (ResNet, BERT) its e-graph exploration and RB-GAT extraction deliver the most-optimal canonicalization of linalg/tosa IR, yielding 1.6× over the IREE baseline, and a cumulative 15–20% speedup across PolyBench gemm configurations versus existing MLIR DSLs. (Paper is attached).

3. How I Automated 400+ LLVM Libc Refactoring PRs — Ezzeldin Ibrahim
Manually refactoring 400+ libc functions for the Clang constexpr math initiative is exactly as tedious as it sounds. After two PRs, I automated the entire process. This talk walks through building refactinator a small tool that manipulates C++ source files at the AST level and automates CMake/Bazel edits.

4. Static Sparsity Inference for MLIR — Petros Avgerinos
Sparsity, the presence of tensor or matrix elements that are known to be zero, is a key property exploited by machine learning compilers to reduce memory usage and computational cost. Although essential for enabling many optimizations, the MLIR ecosystem currently lacks a sparsity inference analysis. This work addresses this shortcoming by presenting Proteus, an MLIR implementation of the recently proposed Sparsity Propagation Analysis (SPA). Proteus infers and propagates sparsity in computational graphs represented in the linalg dialect. This talk discusses the underlying lattice design, the dataflow analysis, its soundness, and how the inferred sparsity enables optimizations in the linalg dialect. The new implementation of SPA infers non-trivial sparsity in 15 convolutional models curated from the ONNX Model Zoo, enabling optimizations that would not be possible otherwise.

5. Transfer Learning Across MLIR Dialects — Douglas Viana Coutinho
MLIR dialects rarely have the large benchmark datasets needed to train machine-learning models for compilation tasks, and the problem compounds as dialects evolve: every change can invalidate a trained model and force expensive retraining from scratch. This poster shows how to break that cycle with cross-dialect transfer learning. Pre-train a Graph Neural Network once on a data-rich dialect, then adapt it to any related dialect by selectively fine-tuning only the dialect-specific components, turning the cost of supporting a new or changed dialect into a short fine-tuning step rather than a full retrain. Using ProGraML graph representations extracted at the MLIR level, we show that a model pre-trained on stablehlo and fine-tuned on 10x less linalg data achieves roughly 50% lower prediction error than training from scratch, while revealing which GNN components encode universal program structure and where along the lowering pipeline transfer stops working. The full toolchain (MLIR-to-ProGraML converter plus training pipeline) is open source and dialect-agnostic.

6. Belalang: Bridging MLIR and GC Runtimes — Vito Secona
Belalang is an experimental, work-in-progress AOT compiler utilizing a custom MLIR-to-LLVM pipeline to target a garbage collected runtime. This talk explores the challenges of this architecture: leveraging MLIR to perform high-level GC analysis and lowering, while navigating the limitations of using LLVM IR for AOT code generation for GC runtimes.

7. Universal Profile-Guided Automatic Software Loop Data Prefetcher for LLVM — Sergey Shcherbinin, Madhur Amilkanthwar, Neil Hickey
We present a universal profile-guided software loop data prefetching framework for LLVM that can prefetch any load whose target address is computable ahead of time, regardless of the structural complexity of the address-producing control flow and dataflow. Driven by load-latency and branch profiles, it emits dependency-aware prefetch pipelines, uses safety mechanisms to prevent trapping instructions from faulting when executed early, and can reduce duplicated computation through semantic hoisting with ring buffers. Its goal is a general, safe, and overhead-aware replacement for pattern-specific automatic prefetching. The current AArch64 implementation shows strong gains on internal and public workloads, while the core framework is architecture-neutral and reusable across targets.

8. Can LLVM Power the WebGPU Ecosystem? — Rithik Sharma
WebGPU brings real GPU compute to the browser with no install, and it already powers inference engines like llama.cpp and ONNX Runtime, and even MLIR-based compilers like IREE. Yet LLVM cannot reach it. WebGPU runs only one language, WGSL, and neither of the compilers that produce it, Tint and Naga, builds on LLVM. LLVM already compiles C++ and Rust into the browser as WebAssembly, but it cannot produce the WGSL that WebGPU requires. This talk shows how close MLIR already is. We lower an MLIR kernel through SPIR-V and the one in-tree WebGPU pass, spirv-webgpu-prepare, run the result live in a browser, and find that the only missing piece is a native WGSL backend.

9. Extending Code Idiom Recognition to 100k+ Patterns via the OEIS — Matthew Davis, Benjamin Mikek
LLVM's loop idiom recognition pass replaces a fixed set of loop patterns with optimized forms, yielding significant performance improvements but handling only a small number of loops and requiring manual engineering for every pattern. We extend code idiom recognition by harnessing the Online Encyclopedia of Integer Sequences (OEIS), allowing for handling of more than 100k new loop patterns. To realize OEIS-based idiom recognition, we develop a new idiom detection strategy that can handle recursion and cross-function nested loops.