Notes

• ​Lessons learned on compiler development: 1. Group functions by AST node, not by pass. 2. Have a formal theory for checking types worked out in advance. 3. Don't dump the metadata for each pass directly into AST nodes.​

Links

• ​Haskell to WebAssembly​

• ​Awesome compilers​

• ​Compiler Optimization examples​

• ​Compiler Explorer - Run compilers interactively from your web browser and interact with the assembly. (HN) (Code)

• ​ShivyC - C compiler created in Python.

• ​swc - Super-fast TS / JS compiler written in rust. (Docs)

• ​Introduction to Compilers - Swift Playground giving an overview over the inner workings of modern compilers.

• ​ccache - Fast compiler cache.

• ​Starlark in Go - The Starlark configuration language, implemented in Go.

• ​Modern CMake Examples​

• ​sccache - Shared Compilation Cache.

• ​Compilers: Principles, Techniques, and Tools book (1986)​

• ​Short overview of "C--"​

• ​The C-- Language Specification​

• ​How to become an expert in compilers the long way? (2019)​

• ​So You Want to Be a (Compiler) Wizard (2016) (HN)

• ​tal - Implementation of Typed Assembly Language (Morrisett, Walker, Crary, Glew).

• ​microml - Minimal ML, type-inferred, compiled, and/or interpreted in less than 800 lines.

• ​libffi - Portable foreign-function interface library.

• ​go2ll - Toy go compiler to LLVM.

• ​Where does YOUR compiler come from? - Vincent Ambo (2018)​

• ​libFirm - Graph based intermediate representation and backend for optimising compilers.

• ​mimalloc - Compact general purpose allocator with excellent performance.

• ​BOLT - Binary Optimization and Layout Tool - A linux command-line utility used for optimizing performance of binaries. (HN)

• ​Propeller - Profile Guided Optimizing Large Scale LLVM-based Relinker.

• ​Intel(r) SPMD Program Compiler - Compiler for a variant of the C programming language, with extensions for single program, multiple data programming.

• ​hobbes - Language and an embedded JIT compiler.

• ​Crafting Interpreters book (Code) (Lox in Rust) (Lox in OCaml)

• ​Compiling a Functional Language Using C++, Part 0 - Intro (2019)​

• ​Compiling at Compile Time (2019)​

• ​MLIR: Multi-Level Intermediate Representation for Compiler Infrastructure - Tatiana Shpeisman, Chris Lattner (2019)​

• ​How an Optimizing Compiler Works (2019)​

• ​Dive into Deep Learning Compiler​

• ​A Survey of Compiler Testing (2019)​

• ​Functional Language Research Compiler (FLRC) - Designed to be a general compiler framework for functional languages.

• ​Compiling pattern matching (2013)​

• ​dino - Compiler / PL Experimentation in Rust.

• ​Advanced Compilers course (2019)​

• ​GRIN - Compiler back-end for lazy and strict functional languages with whole program optimization support. (Website)

• ​Compiler Writing Journey​

• ​Listing of compiler, language and runtime teams for people looking for jobs in this area​

• ​Computer Language Engineering course (2019)​

• ​Dive into Deep Learning Compiler​

• ​Compiler Auto-Vectorization with Imitation Learning (HN)

• ​Clang Build Analyzer - Can be useful to figure out what takes time during compilation of one source file.

• ​CS 6120: Advanced Compilers course (Code)

• ​A Survey on Compiler Autotuning using Machine Learning (2018)​

• ​Compilers for humans​

• ​Compiler notes​

• ​Adventures of a Haskell compiler - Main goal is to continually level-up a self-hosting Haskell compiler. (Code)

• ​Compiler Design course by Frank Pfenning (2014)​

• ​HOT Compilation course (2015)​

• ​Compiler Design course (2020)​

• ​CMSC430: Introduction to Compilers (2017)​

• ​Book about compiling Racket to x86-64 assembly​

• ​Principles of Compiler Design​

• ​Essentials of Interpretation (2019) - Course on implementing an interpreter for a programming language similar to Python or JavaScript, from scratch.

• ​htcc - Tiny C language compiler (x86-64).

• ​Termite - Generic distributed compilation system.

• ​A Simple Graph-Based Intermediate Representation (1995) (HN)

• ​CS164: Introduction to the design of programming languages course (2019)​

• ​Let's Build a Compiler, by Jack Crenshaw (HN)

• ​Automatic peephole optimizer for Cranelift JIT compiler​

• ​Let's Build A Simple Interpreter​

• ​Introduction to Static Analysis - An Abstract Interpretation Perspective (2020)​

• ​Zig cc: A drop-in replacement for GCC/Clang (2020) (HN) (Lobsters) (HN)

• ​Basics of Compiler Design (2000) (HN) (PDF)

• ​Modern Compiler Implementation in ML book (1998) (Rust code)

• ​Efficient Deconstruction with Typed Pointer Reversal (2019)​

• ​Scripts for building compilers that run anywhere, which build things that run anywhere​

• ​ugdb - Alternative TUI for gdb.

• ​Writing a Compiler in Rust (2019)​

• ​Trybuild - Test harness for ui tests of compiler diagnostics.

• ​Secure Delivery of Program Properties through Optimizing Compilation (2020)​

• ​Carpentry Compiler​

• ​Icecream - Distributed compiler with a central scheduler to share build load.

• ​MIR Project - Light-weight JIT compiler based on MIR (Medium Internal Representation).

• ​Incremental/query driven compiler architectures​

• ​Speeding up the Sixty compiler (2020)​

• ​A hands-on introduction to static code analysis (2020) (HN)

• ​Teaching Compilers (2020)​

• ​CReduce - it’s a kind of magic! (2020)​

• ​Compact lexer table representation (2020)​

• ​Reflections on Trusting Trust by Ken Thompson - Creating a version of C compiler that, when presented with the source code for the "login" program, would automatically compile in a backdoor to allow him entry to the system.

• ​Synthesizing JIT Compilers for In-Kernel DSLs​

• ​Diagrams for Composing Compilers (2020)​

• ​One-pass Compiler Primer (2020) (HN)

• ​SPARTA - Library of software components specially designed for building high-performance static analyzers based on the theory of Abstract Interpretation.

• ​Nand2Tetris Hack assembler implemented in Rust (HN)

• ​Let's make a Teeny Tiny compiler (2020) (HN)

• ​PPCI - Compiler for ARM, X86, MSP430, xtensa and more implemented in pure Python.

• ​Awesome JIT​

• ​ELVM - Similar to LLVM but dedicated to Esoteric Languages.

• ​An Intro to Compilers (2017) - How to Speak to Computers. (HN)

• ​Query-based compiler architectures (2020) (HN) (Video)

• ​What every scientific programmer should know about compiler optimizations (2020) (HN)

• ​Circuit IR Compilers and Tools​

• ​A crash course in just-in-time (JIT) compilers (2017)​

• ​A Deep Introduction to JIT Compilers: JITs are not very Just-in-time (2020) (HN)

• ​How JIT Compilers are Implemented and Fast: Julia, Pypy, LuaJIT, Graal and More (2020)​

• ​Compilers Resources by Yosh​

• ​The Super Tiny Compiler - Ultra-simplified example of all the major pieces of a modern compiler written in easy to read JavaScript.

• ​Awesome machine learning for compilers and program optimisation​

• ​Compiler Fuzzing: How Much Does It Matter? (2019)​

• ​SOIL: Single Open Intermediate Language (Lobsters)

• ​A Quick Introduction to Register Allocation (2020) (Lobsters)

• ​Effective Function Merging in the SSA Form (2020) (Tweet)

• ​Compiler Construction - Niklaus Wirth​

• ​Beyond Code: New Signals for Static Analysis (2020)​

• ​HPVM - Heterogeneous Parallel Virtual Machine​

• ​GraalVM - Run Programs Faster Anywhere. (Web) (HN)

• ​Write your Own Virtual Machine (Code)

• ​Deep learning for compilers (2020)​

• ​MLIR Tutorial​

• ​Does register selection matter to performance on x86 CPUs? (2020)​

• ​Self hosting compiler (2020)​

• ​Bootstrapping compilers - Building up compilers and interpreters and tools from nothing.

• ​Linkers go brrrrr (2020)​

• ​Hex Rays - State-of-the-art binary code analysis solutions.

• ​HexRaysDeob - Hex-Rays microcode API plugin for breaking an obfuscating compiler.

• ​Compiler notes (focusing on Haskell)​

• ​Minicompiler: Lexing (2020)​

• ​Awesome Symbolic Execution​

• ​Grammar-Based Testing for Little Languages: An Experience Report with Student Compilers (2020)​

• ​Automatic Syntax Error Recovery (2020)​

• ​What to read to learn compilers (RU)​

• ​HN: Best Resources for Compiler Construction (2020)​

• ​Advanced Compilers: The Self-Guided Online Course (2020) (HN) (Web)

• ​Advice on how to best approach learning compilers (2020)​

• ​Post-Modern Compiler Design (2019)​

• ​Inline caching (2021)​

• ​Bril: A Compiler Intermediate Representation for Learning (Code)

• ​Compilers are hard (HN)

• ​Compiler Video Series​

• ​SymQEMU - Compilation-based symbolic execution for binaries. (Web)

• ​Compiler Class (2021) (HN)

• ​Toolchains.net - Collection of toolchain resources.

• ​Calculating Correct Compilers II: Return of the Register Machines (Code)

• ​Teaching Compilers Backward (2021) (HN)

• ​Compiler versus Transpiler: what is a compiler, anyway?​

• ​Inlining and Compiler Optimizations (2021)​

• ​How to write a JIT compiler​

• ​JitFromScratch - Example project from my talks in the LLVM Social Berlin and C++ User Group.

• ​Interpreter, Compiler, JIT (2015) (Code)

• ​A simple program reducer for any language (2021)​

• ​Resources for Amateur Compiler Writers​

• ​The Golden Age of Compiler Design in an Era of HW/SW Co-Design – Chris Lattner (2021) (HN) (Slides)

• ​Phism: Polyhedral High-Level Synthesis in MLIR (2021)​

• ​Gibbon - Compiler for functional programs on serialized data. (Web)

• ​Amsterdam Compiler Kit (Web)

• ​Awesome Decompilation​

• ​Tiny compiler for a simple synthetic language featuring LL(2) grammar, written in pure C​

• ​The compiler will optimize that away (2021) (HN)

• ​Machine Learning in Compiler Optimization (2021)​

• ​Noise-Aware Dynamical System Compilation for Analog Devices with Legno (2020)​

• ​yair - High-level compiler IR entirely written in Rust.

• ​Tiramisu - Compiler for expressing fast and portable data parallel computations. (Web)

• ​A Brief History of Just-in-Time (2003)​

• ​Essentials of Compilation: An Incremental Approach (2018)​

• ​How JIT Compilers are Implemented and Fast: Pypy, LuaJIT, Graal and More (2020)​

• ​Software and Hardware Techniques for Efficient Polymorphic Calls (1999)​

• ​The Octagon Abstract Domain (2007)​

• ​Compilers as Teachers (2021)​

• ​Do Developers Read Compiler Error Messages? (2017) (HN)