awesome-compilers

General treatment of Computer Systems including Compilers, Interpreters and Runtimes

How to build a computer from Nand Gates all the way to Compilers and Operating Systems

Study the building blocks of computation using Scheme by building a Scheme interpreter in a Scheme!

Other editions:

Provides a short treatment of the basic concepts

How to make your own Programming Language with Racket

Learn C and build your own Lisp Programming Language in 1000 LoC

The Dragons Book. A classic textbook on Compiler Construction

An all-stop-shop for learning (nearly) everything you need to learn to build an interpreted, full-featured, efficient scripting language

Discussions:

Example-driven approach to building your own programming language with video tutorials and source code projects

Discussions:

The modern textbook on Compilers Construction, covering SSA-Form and recent research on Code Generation

Fundamental concepts of programming languages with a focus on Semantics, Interpretation and CPS (Continuation Passing Style)

Learn the patterns behind building programming languages and build an interpreter yourself, using ANTLR

Build a compiler using ML (MetaLanguage) with a textbook that has one of the best coverage on all compiler stages. The book comes with a reference compiler implementation to guide your software development process

Other editions: ,

Integrated treatement of language design and implementation, the examples feature famous architectures like ARM and x86 64-bit

Excellent introduction to the subject that uses an incremental approach to building programs. The mistakes are included too to highlight key concepts

Collected lecture notes for the course taught at Carnegie Mellon University, most suitable as an introductory text on the subject

The design of an operating system and compiler

Other editions:

The BEAM Book

Description of the ERTS (Erlang Runtime System) and the BEAM Virtual Machine

Good book on how to build Virtual Machines especially tailored for the topic of building Programming Languages

Key textbook on the subject of Virtual Machines which examines virtual machine technologies across the disciplines that use them, e.g.: OS and Programming Languages

Well-known introduction to the Go programming language and its ecosystem through building a Compiler project

Successor of the "Write a Compiler in Go" book, but this one builds an interpreter project instead

How to build Compilers using Java, this book is tailored for the working Software Engineer

Other editions: ,

If you want to learn how to write interpreters and compilers, and at the same time learn how Python, Python bytecode, assembly language, and dynamic typing work, this is the book for you

In-depth treatement of advanced design topics such as: Intermediate Representation, SSA, Code Optimization and the various processor architectures

Step-by-step hollistic introduction to the design of Virtual Machine architectures, topics and algorithms. Contains illustrated figures and implementations for the algorithms in the book

Intensive study of Type Systems, covering topics such as, but not limited to: Precise Type Analyses; Type Systems for Low-Level Languages and Advanced Techniques in ML-style Type Inference

Examines the design and implementation of Icc, a production-quality, retargetable compiler, designed at AT&T Bell Labs for the ANSI C programming language

Fills the gap in the domain of code optimization. This book provides a high level design for a thorough optimizer, code generator, scheduler and register allocator for a generic modern RISC processor

Introduction to CPS (Continuation-Passing Style) as an Intermediate Representation in Compiler for doing optimizations and program transformations

Systematic exploration of techniques and ideas used in Programming Language Design, covers topics such as: Operational and Denotational Semantic techniques, Dynamic Semantic techniques and Static Semantic techniques

This book precisely formulates and simplifies the presentation of Instruction Level Parallelism (ILP) compilation techniques

Definitive text on the compile-time and runtime processes of linking and loading

Optimizing program generation based on recent gains and breakthroughs in modern high-performance CPU architectures

Definitive guide on parsing algorithms and techniques, also contains an introduction to Formal Grammar and Parsing Theory

The living-classic and definitive text on the topic of Garbage Collection, also covers hardware-based optimizations in light of modern advances in CPU architectures

Classic textbook on implementing Functional Languages, covers Structured Types, Pattern Matching Semantics, Lambda Calculus Transformation, Polymorphic Type Checking and many other topics

The only in-depth study of SSA-form (Static Single Assignment Form) in book format

Comprehensive introduction to the topic of Type Systems and Programming Languages from a Type-Theoretic perspective

Introduction to WAM from Logic Programming in Prolog

Neat and nice typeset

Other editions:

About security issues related to Dynamic Loading

Discussions: ,

Introduction to compiler construction course from the University of Cambridge

Introduction to compiler construction and language translators course from the RICE University

Compilers Theory, Stanford - , , -Introduction to Compilers theory and construction course from Stanford

Design and construction of compilers including lexical analysis, parsing, code generation techniques, error analysis and simple code optimizations

Lecture Notes: ,

Summer School program on the topics of DSL Design and Implementation hosted by the EPFL University

Concepts that underlie the design, definition, implementation and use of modern programming languages from a formal standpoint

This 2nd part of the Nand2Tetris course covers basic language design and elementary compiler construction concepts in addition to many other topics on a basic level

Introductory course from NPTEL on Compiler Design

Slightly more advanced course than their Principles of Compiler Design course, covers SSA Form to a good degree

Part 1 of a 3-part course series to the basic concepts of programming languages, with a strong emphasis on functional programming

Part 2 of a 3-part course series to the basic concepts of programming languages, with a strong emphasis on functional programming

Part 3 of a 3-part course series to the basic concepts of programming languages, with a strong emphasis on functional programming

Summer School program that consists of 80 minute lectures presented by internationally recognized leaders in programming languages and formal reasoning research

Introductory course on Virtual Machines and Managed Runtimes from the University of Berkeley

VMSS is a Summer School program that aims to give an overview of the field, targeted at early career researchers

Programming Languages Conference

Terence Parr gives an idea of the core mechanisms behind virtual machines by building one, in front of your eyes, from scratch. It is the same kind of commercial interpreter he made for Renault cars

Metascala is a tiny metacircular Java Virtual Machine (JVM) written in the Scala programming language

Tutorial on the Truffel technology

StrangeLoop Talk on Reflective Programming and Kenichi Asai's Black Programming Language

Introductory seminar on SSA Form, Compiler Optimizations under it and its applications in other areas such as Program Analysis and Verification

William Byrd on a Lisp interpreter written in 15 lines of Lisp

Discussions: ,

Obscure research project could radically accelerate innovation in programming language design

Discussions:

Chapter from the book Architecture of Open Source Applications

Introduction to doing research with the LLVM compiler infrastructure

Tutorial for helping C & C++ programmers understand the essentials of what the linker does

Hindley-Damas-Milner Tutorial

Extensively documented walkthrough for typechecking a basic functional language using the Hindley-Damas-Milner algorithm

Discussions:

How to implement a programming language in JavaScript

Interpreter that supports function invocation, lambdas, lets, ifs, numbers, strings, a few library functions, and lists in under 120 lines of JavaScript

Tutorial by Peter Norvig on writing a simple Lisp interpreter

Follow-up tutorial by Peter Norvig on making slightly better

Chapter 11 from the book , 2nd Edition

Interpreter development tutorial using Truffel, by Cristian Esquivias

StackExchange thread criticising the in favor of alternatives

Does a compiler use all x86 instructions? - , - Article discussions on HN and Reddit

Article discussion on Reddit

Discussions:

WebKit's optimizing JIT Compiler for procedures containing C-like code

Capstone

Lightweight multi-platform, multi-architecture disassembly framework with bindings to various famous programming languages

Keystone

Lightweight multi-platform, multi-architecture assembler framework with bindings to various famous programming languages

LLILCL

LLVM-based Compiler Backend for .NET Core

The LLVM Compiler-Backend Framework

The "Mu" Framewrok for Programming Languages development based on the MuVM Specification

Movfuscator Compiler

The compiles programs into "mov" instructions, and only "mov" instructions

Pure C embeddable SSA-based compiler backend

Rubinius

Programming Languages Development Platform

Summus

Basic, reusable, compiler-frontend implementation using LLVM as a backend

ZetaVM

Multi-Language Platform for Dynamic Programming Languages

AsmJIT

Complete x86/x64 JIT and Remote Assembler for C++

The GNU Compiler Collection (C as a Backend)

LCC

The lcc retargetable ANSI C compiler (C as a Backend)

C-library that provides a graph-based intermediate representation, optimizations, and assembly code generation suitable for use in compilers

Library for generic Just-In-Time compiler functionality independent of any particular bytecode, language, or runtime

Library for machine-code generation and execution at run-time

Win32 C11/C++2014 compiler and toolchain

The Portable C Compiler (C as a Backend)

Ragel State Machine Compiler

The Tiny C Compiler (C as a Backend)

Library to generate and inspect programs and libraries in the ECMA CIL format

DotNetPELib

Library to read and write .net assemblies in C++11

.NET Decompiler

.NET Decompiler

Assembly code editor which can be used as a plugin with other .NET/CLR tools

dunnart

LALR(1) Parser Generator

FancyPars-lite

Fast parser generator

libdparse

Library allowing to build lexers and parsers. Contains a lexer and a parser for the D language itself

llvm-d

D bindings for LLVM

Pegged

design, test and generate parsers for PEG grammars

YACC Implementation in Go. Standard LALR(1) parser generator

Official Go LLVM binding

Graal

High-Performance Polyglot Runtime

Compiler and Truffel Partial Evaluator

Graal's multi-language VM distribution

Bound

/ / - Libraries for manipulating bound variables

Hoopl

Higher-order optimization library

Haskell bindings for LLVM

Parsec

/ / / / + - Parsers for every use case

wl-pprint-text

/ - Walder-style pretty-printing libraries

Tool for displaying intermediate representations used by V8 and Dart VM optimizing compilers

Context-free grammar parser generator for JavaScript

GerHobbelt/jison

active fork of jison with bunch of improvements

Nearley

Simple, fast, powerful parser toolkit for JavaScript

Ohm

A library and language for building parsers, interpreters, compilers, etc

Simple parser generator for JavaScript

Parser generator for reading, processing, executing, or translating structured text or binary files

BYACC/Java is an extension of the Berkeley v 1.8 YACC-compatible parser generator for Java

CGLIB

High level API library for generating and transforming Java Byte Code

JVM Backend for generating Java Byte Code that conforms to the JDK v1.5+ Specification and the Dalvik VM

Java Compiler Construction and Parser Generator Toolkit

JavaCPP Presets for LLVM

Library for easily interacting with the LLVM API

JFlex is a lexical analyzer generator for Java with full Unicode support

JLex is a lexical analyzer generator, that can be used in combination with CUP

The Whimsy Compiler Framework

Compiler framework research project in Kotlin

Python's builtin Abstract Syntax Tree package

Python's builtin Disassembler package

Pure-Python module that implements an LR(1) parser generator, as well as CFSM and GLR parser drivers

Implementation of lex and yacc parsing tools for Python

Alternative approach to creating and executing simple grammars, vs. the traditional lex/yacc approach, or the use of regular expressions

RPLY

Port of the PLY project to RPython

RPython is a framework for the implementatation of dynamic languages

Combine

Parser Combinator Library for Rust

IronLLVM

Safe LLVM bindings for Rust

LALRPOP

LR(1) parser generator for Rust

Nom

Parser Combinator Framework

PEG

PEG Parser Generator

Pest

PEG Parser Generator

RLS

The Rust Language Server implementation (aka RLS)

Babel.js

Next-generation JavaScript Compiler

BOLT

Binary Optimization and Layout Tool

ChezScheme's Compiler

ChezScheme Language Compiler

ELENA Compiler

Elena programming language

Eta' Compiler

JVM-based Compiler for the Eta Programming Language

Frege's Compiler

JVM-based Compiler for the Frege Programming Language

Gluon's Compiler

Embedded Language Compiler written in Rust

HHVM

Virtual Machine for running programs written in Hack and PHP

Lua's Interpreter

Official Lua Language Interperter

Annotated source code of the Lua Programming Language Interpreter v5.1.4

Mirah's Compiler

JVM-based Compiler for the Mirah Programming Language

P Lang

The P Programming Language Runtime

Roslyn

The .NET "Roslyn" Compiler Platform

C compiler that compiles to CLR

Zig's Compiler

Zig Language Compiler

Akilang

A compiler for a simple language, built with Python and LLVM

amacc

Small C Compiler generating ELF executable for Arm architecture

Discussions:

Scheme interpreter for the Reflective Programming Language "Black", by Kenichi Asai's

GitHub Mirror

Other sources:

C4

C Lang in 4 Functions

Discussions:

CarpVM

Experimental VM implementation in C

Charly

Interpreter for a dynamically typed language written in Crystal

Dale

Lisp-flavoured C: a system programming language

EasyLang

Easy Programming Language / VM

Eschelle

Open source cross platform multi-paradigm language with VM & JIT

Gecho

Simple-stack language implementation in C

gocaml

Minimal functional programming language implementation in Go and LLVM

gone

Compiler for a tiny programming language called Gone, implemented using Python 3.6, SLY and llvmlite. Developed as part of the January 2018 , under the supervision of David Beazly

Hython

Haskell-powered Python 3 interpreter

Discussions:

llgo

Go frontend for LLVM written in Go

MAL

: Make a Lisp - Clojure-inspired Lisp interpreter implemented in 64 languages

MetaScala

Metacircular JVM implementation in Scala

mini-js

Experimental self-hosted JavaScript compiler in 1K LoC

MunVM

Lua VM & Compiler in C

MY-BASIC

An embeddable BASIC dialect interpreter in C with modern paradigms

oberonc

A single pass, self-hosting compiler for the Oberon-07 programming language. It targets the JVM

Poprc

Compiler for the Popr Language

PyCOOLC

Compiler for the COOL Programming Language written in Python 3

RabbitVM

RISC-based VM implementation in C

Squint

A peephole optimizer for educational compilers generating stack based assembly

StackVM

Virtual Machine with an integrated VRAM display

stack_cpu

Stack-machine simulator

The Super Tiny Compiler

Tiny educational compiler project in JavaScript

Discussions:

Tiny-C language compiler in C

tisp

"Time is Space" Programming Language Interpreter

Ultra Tiny Compiler

Another tiny compiler in less then 90 lines of code

CoreCLR

The .NET's Common Language Runtime

HHVM

Facebook's Open Source VM for running Hack and PHP programs

Weekly newsletter about LLVM

Subreddit community about the theory and development of compilers

Subreddit community that is dedicated to discussion of programming languages, programming language theory, design, their syntax and compilers

Papers, Talks and Implementations of miniKanren and microKanren