Compiler Research Conferences are focused events that bring together members and contributors to share progress and insights on specific initiatives. These virtual gatherings provide an opportunity to present completed work, discuss outcomes, and explore the impact of research efforts in compiler technology and related areas. Such conferences typically feature presentations from contributors, including participants in programs like Google Summer of Code, showcasing developments in automatic differentiation, interpretative C/C++/CUDA, and other compiler infrastructure projects. These events promote knowledge exchange and celebrate the collaborative achievements of our research community.
If you are interested in our work you can join our compiler-research-announce google groups forum or follow us on LinkedIn.
CompilerResearchCon 2026 (day 1) – 03 November 2026 at 15:00 Geneva (CH) Time
Connection information: Link to zoom
Agenda:
CppJIT is an automatic Python–C++ interoperability layer and bindings generator, built on Clang and LLVM. This talk presents my work over the last three years on CppJIT, CppInterOp, ROOT, and LLVM: Numba support, AST-based reflection, CPython extension modernization, wrapper code generation (JitCall), runtime library dispatch, and recently, enhancements to clang-repl’s CUDA support. On the ROOT side, I was responsible for migrating the legacy type system and Python interoperability layer to CppInterOp and CppJIT, a major undertaking delivered in the latest release.
With the goal of developing the next generation of Python–C++ interoperability based on cppyy, CppJIT went from research to production — into ROOT at CERN, where it now supports LHC experiment code, and beyond to other sciences and communities as a general-purpose Python library.
I’ll walk through my ongoing work on the upcoming CppJIT GPU support for HPC and scientific applications: kernel expression support, zero-copy interoperability with foreign device arrays, CUDA streams, and graphs from CuPy and cuda.core, demonstrated in a topological data analysis of the cosmic web.
One of the things CppInterOp did not expose is memory ownership behaviour of the C++ functions. Therefore language binding tools such as CppJIT were not able to abstract memory management when objects cross between Python and C++. This talk will cover my work on CppInterOp to reflect memory ownership information of C++ functions in different ways, and how we adapt these new APIs in CppJIT.
clang-tidy and the Clang Static Analyzer carry a long backlog of incorrect diagnostics: false positives in widely used checks, fix-its that produce broken code, and an escape heuristic that silences real leak reports. This talk walks through a series of upstream fixes for these issues, the integration of query-based custom checks into clangd, and the analyzer patches currently in review.
Not available yet
In this talk, I will provide an overview of my fellowship work focused on Clang performance optimization. I will detail the tooling used to benchmark compilation speeds, my approach to finding and fixing performance regressions, and how these discoveries created a feedback loop that exposed even more areas for optimization.
At Chicago Trading Company, we are eagerly investing in the future of
cppjit and CppInterOp, and have built an ecosystem that makes use of these
technologies in non-trivial ways. To support users of this ecosystem, we have
added debugging support that attempts to make debugging “just work” across the
Python/C++ boundary, and have pushed an experimental version of this upstream
to cppjit and CppInterOp. Today we will walk through what that looks like
in VSCode.
In this talk we will make an overview of the various activities around the compiler research initiative in terms of people, projects, code and impact. We will outline our aspirational plans and perspective for 2027.
CompilerResearchCon 2026 (day 2) – 04 November 2026 at 15:00 Geneva (CH) Time
Connection information: Not available yet
Agenda:
A typical C++ translation unit includes a large number of headers, yet only a small fraction of the declarations they contain is ever used. Clang still parses all of it eagerly, spending time and memory on code that never reaches the final binary. This talk presents a prototype of on-demand parsing in Clang, where the bodies of function and class definitions are skipped during the initial pass, their token ranges are recorded on the declaration, and parsing is resumed lazily the first time the definition is actually needed. I will walk through how this is wired into the parser and problems faced during implementation, the benchmarks used to measure compilation time and peak memory against upstream Clang, the results the prototype achieves so far, and the work still ahead.
Not available yet
Not available yet
Not available yet
Not available yet
What does compiler optimisation have to do with cancer research? Perhaps more than you might expect.
Imagine simulating the development of a tumour, where computational performance determines which scientific questions we can realistically investigate. Similar challenges arise across disciplines, where increasingly complex data and models push the limits of existing technologies.
Drawing on examples from cancer research, including our work on CARTopiaX, I will explore how advances in computing can open new avenues for scientific discovery, and how stepping beyond our areas of expertise can reveal unexpected challenges, inspire new ideas and create opportunities for collaboration.
CompilerResearchCon 2026 (day 3) – 06 November 2026 at 17:00 Geneva (CH) Time
Connection information: Not available yet
Agenda:
Modular builds fill Clang’s 32-bit source-location space with duplicate entries for the same shared headers, and when large builds run out, compilation fails. This talk covers an upstream patch I made that stops writing the duplicates, redirecting a header’s locations to the module that already has them.
This talk presents my GSoC work on Clad to build a unified and robust GPU automatic differentiation infrastructure in Clad. I will discuss integrating existing CUDA support, extending differentiation for NVIDIA Thrust through custom derivative handlers, and bringing GPU applications such as LULESH, XSBench, and the in-tree CUDA ray tracer into a unified framework. I will also cover benchmarking Clad against other AD tools. I will conclude with the key challenges and lessons learned in building a more robust and maintainable foundation for GPU automatic differentiation in Clad.
This talk covers my fellowship work on Clang diagnostics. It follows the path of enabling -Wunused-template under -Wall, from a 20-PR cleanup campaign across the LLVM monorepo to its downstream impact in projects like Bitcoin Core, and the false positives that surfaced in the wild (such as templates used only in C++20 requires clauses) along with their fixes. It also covers diagnosing conflicting internal and external linkage in C (WG14 N3410), handling _Atomic types in __has_unique_object_representations to support -Wsuspicious-memcmp, and fixing long-standing Sema false positives and negatives (including C++20 destroying delete, VLA pointer subtraction, and function-reference null comparisons). I will close with lessons learned about getting diagnostics accepted and kept enabled upstream.
Parallel C++ and CUDA introduce challenges for automatic differentiation, from concurrency to complex control flow. This talk covers my work extending Clad’s support for these programs and applying it to differentiable rendering. I’ll discuss threading support, compiler correctness improvements, and integrating generated derivatives for selected computations into a 3D Gaussian Splatting training pipeline, including performance comparisons and remaining limitations.
CAR T-cell therapy has transformed the treatment of blood cancers, but it still struggles in solid tumors, where robust simulation models remain scarce. CARTopiaX is an open-source agent-based model built on BioDynaMo that simulates the interactions between tumor cells and CAR T-cells, enabling in silico hypothesis testing of CAR T-cell therapies. In this Google Summer of Code 2026 project, CARTopiaX was extended to replicate a state-of-the-art wet-lab experiment of CAR T-cell therapy in a hypoxic 3D tumor model. This required a new tumor geometry, glucose as a new nutrient, and new cell behaviors, together with a Bayesian optimization tool to calibrate the model against experimental data. The extended model reproduces the key trends of the experiment and offers an in silico explanation of the “non-contact” killing of cancer cells observed by the authors: competition between CAR T-cells and cancer cells for glucose and oxygen. These results demonstrate CARTopiaX as a flexible platform for fast, low-cost hypothesis testing in CAR T-cell research.
jank opens the world of C++ up to the world of Clojure. We get to enjoy Lisp macros, functional programming, immutable data structures, and world-class interactive development with REPL protocols. All of this is now available in your C++ programs, or standalone, using both JIT and AOT compilation. In this talk, you’ll learn about jank and how it’s utilizing the underlying clang-repl and CppInterOp features to build an unprecedented language.
We are partially funded by the
Princeton Department of Physics
and
Princeton Institute for Computational Science and Engineering
(PICSciE).
Contact: David Lange; Vassil Vassilev
This project is supported by the National Science Foundation under Grant OAC-1931408 (2020-2023) and OAC-2311471(2023-2026). Any opinions, findings, conclusions or recommendations expressed in this material are those of the authors and do not necessarily reflect the views of the National Science Foundation.
© 2019 Princeton University. Site made with Jekyll; Credit to Allan lab for this site template.
