About the Course

This course will cover advanced topics in compiler construction. The range of topics is open-ended and will largely be driven by student interest, but we expect to cover topics such as the following: intermediate representations (e.g., graph IRs), type systems and advanced static checking, advanced program analysis and transformation (e.g., tree fusion, supercompilation), program optimization, advanced control abstractions (e.g., continuations, coroutines, algebraic effects), compilation for non-standard and emerging architectures (e.g., GPU, TPU, FPGA, CGRA), compilation for data processing and ML systems, applying ML techniques to compiler problems.

The course will be research oriented and hands-on: we will read and discuss original papers from the forefront of research, and participants will propose and complete a course project.


Throughout the semester, students will present papers that represent the state of the art in research. For each presented paper, two other students will serve as facilitators to guide the discussion in class. Every student will submit a 4-sentence summary of each presented paper. We plan to invite the original authors of selected papers to participate in the discussion.

In addition, each student will propose and implement a project. Project topics are first discussed informally with the instructor, and then formalized in a 1-page proposal due by week 3. Project deliverables include definition of weekly SMART tasks ahead of each week and continuous progress updates, as well as a final presentation, a working implementation and reproducible experiments, and a final report (4 pages, excluding bibliography), all accessible in a git repo.

Learning Goals

The goal of the class is to kick off a set of research projects at the forefront of compiler research. For students that do well in class, the expected outcome is to set the student on a successful research trajectory in this area. Ideally, the class project will lay the foundation for a future conference submission.

Besides the technical material the course will be a great training ground for presenting, writing, reviewing, task management, risk management, and other important research skills.



  • 70% project
  • 30% paper presentations, summaries, and participation in class
  • In each of the two categories, 50% are required for a passing grade

Course Policies


  • No formal prerequisites, but undergrad-level exposure to PL/compilers will be helpful


  • Attendance is required. Students may skip class 3 times for any reason.
  • Meetings will be in-person or via Zoom, according to instructor/departmental/university policies
  • Other communication is via Piazza


TU 08/24 (W1) Introduction & logistics
TH 08/26 ...


Below is a tentative and non-exhaustive list of papers that will be presented and discussed in class. More will be sourced from recent conferences such as PLDI, POPL, OOPSLA, ICFP, etc.

  • Reticle: A Virtual Machine for Programming Modern FPGAs
  • Dependent Type Systems as Macros
  • egg: Fast and Extensible Equality SaturationDistinguished Paper
  • Compiler and Runtime Support for Continuation Marks
  • From Folklore to Fact: Comparing Implementations of Stacks and Continuations
  • LLHD: A Multi-level Intermediate Representation for Hardware Description Languages
  • Perceus: Garbage Free Reference Counting with Reuse
  • AKG: Automatic Kernel Generation for Neural Processing Units using Polyhedral Transformations
  • An Efficient Interpreter for Datalog by De-specializing Relations
  • Automated Conformance Testing for JavaScript Engines via Deep Compiler Fuzzing
  • Bliss: Auto-tuning Complex Applications using a Pool of Diverse Lightweight Learning Models
  • Chianina: An Evolving Graph System for Flow- and Context-Sensitive Analyses of Million Lines of C Code
  • DNNFusion: Accelerating Deep Neural Networks Execution with Advanced Operator Fusion
  • Learning Nonlinear Loop Invariants with Gated Continuous Logic Networks
  • The Essence of Bluespec: A Core Language for Rule-Based Hardware Design
  • Synthesizing Structured CAD Models with Equality Saturation and Inverse Transformations
  • A Sparse Iteration Space Transformation Framework for Sparse Tensor Algebra
  • Handling Bidirectional Control Flow
  • Getting to the Point: Index Sets and Parallelism-Preserving Autodiff for Pointful Array Programming
  • Achieving High-Performance the Functional Way - A Functional Pearl on Expressing High-Performance Optimizations as Rewrite Strategies


Reviews, Papers, and Talks