1. Deploying BOLT at Datacenter Scale — Jinjie Huang
This talk presents the technical foundations behind ByteDance's datacenter-scale deployment of BOLT across server-side applications, where profile freshness, binary size, debug information handling, and deployment cost become first-order concerns. We will describe our production profile-refresh pipelines, including a lightweight automated BOLT-only refresh on top of an existing PGO baseline for routine updates and a synchronized zero-gap PGO+BOLT refresh for major updates when profile staleness causes meaningful performance degradation. We will then cover infrastructure improvements for large production binaries, including upstreamed deterministic parallel DWARF processing with 2.6x to 5.1x speedups, upstreamed DWARF64 support for binaries exceeding the 4GB debug information limit, multi-input perf2bolt support developed in collaboration with the community, and ongoing split-relocations work to reduce deployment cost. Finally, we will discuss future opportunities to broaden BOLT's production applicability, including RISC-V support, performance-advisor tooling, shared-library co-optimization, and data layout optimization on production workloads.

2. Why Is My MatMul Slow? Tracing ML Model Operations Through MLIR Compiler Passes to Runtime — Przemyslaw Delewski
ML compilers built on MLIR aggressively transform model graphs through fusion, lowering, and optimization, breaking the connection between source-level operations and compiled artifacts. Developers face two disconnected worlds: compile-time IR dumps and runtime profilers, with no way to connect them. We present a practical approach to closing this gap by joining compile-time provenance with runtime measurements, demonstrate it with a small real model, and discuss the tradeoffs and what's missing in MLIR to build first-class observability. 

3. Beyond Module-Level Parallelism: Multi-Threaded ThinLTO for Large Modules — Yangguang Li
ThinLTO scales link-time optimization by compiling modules in parallel, but very large modules can still become serial bottlenecks that limit build-time improvements on modern high-core-count machines. This talk presents Multi-Thread Parallel Compilation, an extension to the ThinLTO backend that exposes additional parallelism within a single large module. We will discuss the motivation for intra-module parallelism, the use of CallGraph-aware partitioning to divide backend work safely and effectively, and the engineering tradeoffs involved in preserving correctness, determinism, and code quality while improving compile-time scalability. Attendees interested in LLVM optimization pipelines, LTO, backend compilation, and large-scale build performance will learn how this approach fits into the existing ThinLTO model and what future opportunities it opens for scaling LLVM on increasingly parallel hardware.

4. Preventing Silent Relocation Overflow with a Per-JITDylib Slab Allocator — Milica Kovacevic
ORC's default allocator can silently place two objects in the same JITDylib more than 2 GiB
apart, overflowing 32-bit PC-relative relocations. A new per-JITDylib slab mode in
MapperJITLinkMemoryManager fixes this with a single opt-in line in LLJITBuilder.

5. Breaking the LLDB/Python Revlock — Jonas Devlieghere
Python has been LLDB's main scripting language since its inception, powering data formatters, breakpoint callbacks, and a two-way bridge that lets you script LLDB from Python or drive LLDB from an existing interpreter. That power came with a hard constraint: an LLDB binary was locked to the exact Python version it was built against. The coupling was more than an inconvenience. A mismatched libpython crashed the dynamic loader before LLDB could report anything, and importing lldb into an existing interpreter risked a dangerous second copy of Python. This talk covers how we broke that lock so a single LLDB binary now works against any Python from 3.8 up. First, we moved the Python-dependent interpreter into a dynamically loaded plugin whose Python symbols are resolved at runtime by a cross-platform loader that finds a suitable Python, binds to one already mapped, or reports an error instead of crashing. Second, we built against the Stable Python C API, whose abi3 ABI, now usable from SWIG, sets a single floor at 3.8 and produces one version-agnostic extension instead of a per-version binary.