Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Programming Languages, Compilers & Runtimes Reference Library

This page is a verified index of primary sources for compilers: official documentation, developer and API portals, source repositories, SDKs, downloadable or offline documentation, a two-track learning path, and free-access research literature.

It is a navigation layer, not a tutorial. Where the rest of this book explains a concept, this page tells you which document to open to get the authoritative answer, and in what order to read things. Every link was HTTP-verified on the date shown below; sources that block automated checkers but work in a browser are flagged rather than silently dropped.

Compiler infrastructure, language specifications, managed runtimes and JITs, WebAssembly, parsing tooling, and a two-track path from Crafting Interpreters to reading V8, rustc and MLIR.

82 entries across 8 categories, plus 59 education & reference-implementation resources (24 basic / 35 advanced), plus 12 video resources and 5 conference sources.

Every link HTTP-verified on 2026-10-07.

www.gnu.org (the Bison manual) did not respond to our checker — the host blocks our verification network. The project is live: ftp.gnu.org/gnu/bison and savannah.gnu.org both returned 200, and the manual loads normally in a browser.

Contents

1. Compiler infrastructure

LLVM

  • Docs: llvm.org/docs
  • Developer / API: llvm.org/docs/LangRef.html
  • Source: github.com/llvm/llvm-project
  • SDKs & repos: Clang, LLD, libc++, MLIR, Polly — one monorepo
  • Downloadable / offline: Docs build from source; released as HTML per version
  • Note: The dominant compiler infrastructure. LangRef.html is the IR specification and the single most useful document here.

Clang

MLIR

  • Docs: mlir.llvm.org
  • Developer / API: mlir.llvm.org/docs
  • Source: github.com/llvm/llvm-project
  • SDKs & repos: Dialect infrastructure; used by XLA, TVM, Triton, CIRCT, Flang
  • Downloadable / offline: Docs site + tutorials
  • Note: The most important compiler-infrastructure development of the last decade. The Toy tutorial is the way in.

GCC

  • Docs: gcc.gnu.org/onlinedocs
  • Developer / API: gcc.gnu.org/onlinedocs/gccint
  • Source: gcc.gnu.org/git
  • SDKs & repos: GIMPLE and RTL internals; plugins
  • Downloadable / offline: Full manuals as HTML, PDF and info
  • Note: The internals manual (gccint) is dense but authoritative. Still the reference for many targets LLVM handles less well.

Cranelift

QBE

  • Docs: c9x.me/compile
  • Developer / API: c9x.me/compile/doc/il.html
  • SDKs & repos: A compact backend aiming for 70% of LLVM’s performance at 10% of the complexity
  • Downloadable / offline: Docs on site
  • Note: Small enough to read entirely. Excellent if LLVM is too large to approach.

chibicc

  • Docs: github.com/rui314/chibicc
  • Source: github.com/rui314/chibicc
  • SDKs & repos: A small C compiler developed in readable, incremental commits
  • Downloadable / offline: Read the git history commit by commit
  • Note: Rui Ueyama’s teaching compiler. The commit sequence is the tutorial.

2. Systems languages & their implementations

Rust

  • Docs: doc.rust-lang.org/book
  • Developer / API: doc.rust-lang.org/reference
  • Source: github.com/rust-lang/rust
  • SDKs & repos: Cargo, rustup, clippy, rust-analyzer; MIR and borrow checker in-tree
  • Downloadable / offline: All books ship offline with rustup (rustup doc)
  • Note: The rustc dev guide is one of the best explanations of a modern compiler’s internals ever published openly.

rustc dev guide

  • Docs: rustc-dev-guide.rust-lang.org
  • Source: github.com/rust-lang/rustc-dev-guide
  • SDKs & repos: Query-based compilation, HIR, MIR, borrow checking, codegen
  • Downloadable / offline: mdBook, downloadable
  • Note: Read this even if you never touch Rust. It explains incremental and query-based compiler architecture better than any textbook.

Go

  • Docs: go.dev/doc
  • Developer / API: go.dev/ref/spec
  • Source: github.com/golang/go
  • SDKs & repos: Full toolchain in-tree; the compiler is written in Go
  • Downloadable / offline: go doc offline; spec is one readable page
  • Note: The Go spec is short enough to read in a sitting — a rare virtue. The runtime source (scheduler, GC) is also unusually approachable.

Zig

C++ standardization (WG21)

C standardization (WG14)

  • Docs: open-std.org/jtc1/sc22/wg14
  • SDKs & repos: Working drafts are free; the final standard is not
  • Downloadable / offline: Drafts as PDF
  • Note: The latest working draft is functionally the standard for most purposes.

Swift

  • Docs: swift.org/documentation
  • Source: github.com/swiftlang/swift
  • SDKs & repos: SwiftPM, swift-syntax; SIL is a documented intermediate language
  • Downloadable / offline: Docs site; The Swift Programming Language book free
  • Note: SIL (Swift Intermediate Language) is well documented and worth studying as a high-level IR design.

3. Managed runtimes & virtual machines

CPython

PyPy

  • Docs: doc.pypy.org/en/latest
  • Source: foss.heptapod.net/pypy/pypy
  • SDKs & repos: RPython toolchain; meta-tracing JIT
  • Downloadable / offline: Sphinx docs
  • Note: Generating a JIT from an interpreter specification is a genuinely different idea. Read the architecture docs.

OpenJDK

GraalVM

  • Docs: graalvm.org/latest/docs
  • Source: github.com/oracle/graal
  • SDKs & repos: Truffle language framework, native image, Graal JIT
  • Downloadable / offline: Docs site
  • Note: Truffle — building languages as AST interpreters that partial-evaluate into fast code — is the most interesting runtime research shipping in production.

.NET runtime

Roslyn

V8

  • Docs: v8.dev/docs
  • Source: github.com/v8/v8
  • SDKs & repos: Ignition interpreter, TurboFan and Maglev JITs, Orinoco GC
  • Downloadable / offline: Docs site + the V8 blog
  • Note: The V8 blog posts on hidden classes and inline caches are the standard explanation of dynamic-language optimization.

SpiderMonkey

Node.js

Deno

Bun

LuaJIT

Lua

  • Docs: lua.org/manual/5.4
  • Source: github.com/lua/lua
  • SDKs & repos: The whole language in a ~25,000-line C codebase
  • Downloadable / offline: Single-page manual
  • Note: One of the most readable language implementations in existence. A good first real interpreter to study.

4. Functional languages & type systems

GHC (Haskell)

  • Docs: downloads.haskell.org/ghc/…
  • Source: github.com/ghc/ghc
  • SDKs & repos: Core, STG and Cmm intermediate languages, all documented
  • Downloadable / offline: User guide as HTML/PDF
  • Note: The Core-to-STG-to-Cmm pipeline is the reference for compiling lazy functional languages.

OCaml

  • Docs: ocaml.org/docs
  • Developer / API: ocaml.org/manual
  • Source: github.com/ocaml/ocaml
  • SDKs & repos: Dune, opam; the compiler is small and readable
  • Downloadable / offline: Manual as HTML/PDF
  • Note: Frequently the implementation language of choice for compiler research, for good reasons.

Erlang/OTP

  • Docs: erlang.org/docs
  • Developer / API: erlang.org/doc
  • Source: github.com/erlang/otp
  • SDKs & repos: BEAM VM, OTP behaviours
  • Downloadable / offline: Docs per release
  • Note: BEAM’s scheduler and process isolation design is unlike anything else in this list.

Elixir

Kotlin

5. WebAssembly & language specifications

WebAssembly spec

  • Docs: webassembly.github.io/spec/core
  • Source: github.com/WebAssembly/spec
  • SDKs & repos: Formal semantics, with a reference interpreter in OCaml
  • Downloadable / offline: Spec as HTML and PDF
  • Note: A fully formally specified mainstream VM — rare, and worth reading as an example of how to specify one.

Wasmtime

Wasmer

WAMR

ECMAScript specification

  • Docs: tc39.es/ecma262
  • Source: github.com/tc39/ecma262
  • SDKs & repos: The normative JavaScript language definition
  • Downloadable / offline: Single HTML document
  • Note: Surprisingly readable once you learn the abstract-operation notation.

TC39 proposals

Java Language & VM Specifications

6. Parsing, tooling & language engineering

tree-sitter

ANTLR

  • Docs: antlr.org
  • Developer / API: github.com/antlr/…
  • Source: github.com/antlr/antlr4
  • SDKs & repos: ALL(*) parsing; targets Java, C#, Python, Go, C++, JS
  • Downloadable / offline: Documentation in-repo; reference book available
  • Note: The practical choice when you need a parser for a real grammar quickly.

GNU Bison

LLVM Kaleidoscope tutorial

7. Proof assistants, verification & teaching material

Compiler Explorer (godbolt)

  • Docs: godbolt.org
  • Source: github.com/compiler-explorer/compiler-explorer
  • SDKs & repos: Live compilation to assembly across dozens of compilers and languages; self-hostable
  • Downloadable / offline: Whole site runs locally from the repo
  • Note: The single most useful interactive tool in this field. Also shows LLVM IR, MIR and GIMPLE, not just assembly.

cppreference

  • Docs: en.cppreference.com/w
  • SDKs & repos: The practical C and C++ reference, tracking the standard closely
  • Downloadable / offline: Full offline archive available for download
  • Note: 403s to bots, fine in a browser. More usable than the standard itself for day-to-day work.

Rustonomicon

Racket

R7RS Scheme

  • Docs: small.r7rs.org
  • SDKs & repos: The small Scheme standard
  • Downloadable / offline: Free PDF, about 80 pages
  • Note: A complete language specification you can read in an evening. Excellent calibration for what a spec can be.

SICP

Essentials of Compilation

  • Docs: github.com/IUCompilerCourse/…
  • Source: github.com/IUCompilerCourse/…
  • SDKs & repos: Jeremy Siek’s incremental compiler course book, in Racket and Python editions
  • Downloadable / offline: Drafts free from the repo
  • Note: Builds a compiler in small verified increments. A strong complement to Crafting Interpreters.

Lean 4

Rocq (formerly Coq)

Agda

Dafny

matklad’s blog

  • Docs: matklad.github.io
  • SDKs & repos: Aleksey Kladov on parsers, IDEs, build systems and rust-analyzer internals
  • Downloadable / offline: Free archive
  • Note: The Pratt parsing article and the IDE-architecture posts are essential reading for anyone building language tooling.

8. Research papers & open-access literature

arXiv

  • Docs: arxiv.org
  • Developer / API: info.arxiv.org/help/api/index.html
  • SDKs & repos: Preprints across all of CS; most systems, ML and PL work appears here before publication
  • Downloadable / offline: Every paper is a free PDF. Bulk access documented at info.arxiv.org/help/bulk_data/index.html; a full-text API at export.arxiv.org
  • Note: Not peer-reviewed. Treat an arXiv-only paper as a claim, not a result — but it is where you will read almost everything first.

ar5iv

  • Docs: ar5iv.labs.arxiv.org
  • SDKs & repos: Renders any arXiv paper as responsive HTML instead of PDF
  • Downloadable / offline: Free; swap arxiv.org/abs/ID for ar5iv.labs.arxiv.org/html/ID
  • Note: Makes papers readable on a phone and searchable in-page. Underused.

alphaXiv

  • Docs: alphaxiv.org
  • SDKs & repos: arXiv papers with a public comment and discussion layer
  • Downloadable / offline: Free
  • Note: Useful when a paper is contested — the discussion often contains the critique you were looking for.

Semantic Scholar

  • Docs: semanticscholar.org
  • Developer / API: api.semanticscholar.org/graph/v1
  • SDKs & repos: 200M+ papers with citation graph, influential-citation scoring and TLDR summaries
  • Downloadable / offline: Free Graph API (semanticscholar.org/product/api), bulk datasets available on request
  • Note: The best free citation graph. ‘Highly influential citations’ is a genuinely useful filter for finding what actually mattered.

OpenAlex

  • Docs: openalex.org
  • Developer / API: api.openalex.org/works
  • SDKs & repos: Fully open catalogue of works, authors, venues and institutions; successor to Microsoft Academic Graph
  • Downloadable / offline: Entirely free API with no key required; complete database snapshots downloadable
  • Note: The only large-scale bibliographic database that is open all the way down, including bulk snapshots.

DBLP

  • Docs: dblp.org
  • Developer / API: dblp.org/faq/13501473.html
  • SDKs & repos: Authoritative CS bibliography — complete author and venue listings
  • Downloadable / offline: Free; full XML dump downloadable
  • Note: The fastest way to find everything a given researcher has published, and to see a conference’s full programme by year.

OpenReview

  • Docs: openreview.net
  • Developer / API: docs.openreview.net
  • Source: github.com/openreview
  • SDKs & repos: ICLR, NeurIPS, COLM and dozens of other venues — papers plus the full review threads
  • Downloadable / offline: Free; REST API
  • Note: Reading the reviews and author rebuttals teaches you how the field evaluates work. Nothing else exposes this.

CORE

  • Docs: core.ac.uk
  • Developer / API: core.ac.uk/services/api
  • SDKs & repos: Aggregates 300M+ open-access papers from repositories worldwide
  • Downloadable / offline: Free API and bulk datasets
  • Note: Good for finding the green open-access copy when a publisher’s version is paywalled.

Unpaywall

  • Docs: unpaywall.org
  • Developer / API: api.unpaywall.org
  • SDKs & repos: Finds legal free copies of paywalled papers via DOI
  • Downloadable / offline: Free API; browser extension
  • Note: Legal, author-deposited copies only. Install the extension and most paywalls simply stop appearing.

Papers We Love

  • Docs: paperswelove.org
  • Source: github.com/papers-we-love/papers-we-love
  • SDKs & repos: A curated, categorised repository of classic CS papers with local meetup talks
  • Downloadable / offline: Repo cloneable; many PDFs mirrored in-repo
  • Note: The best starting point if you do not yet know which papers matter in a subfield.

The Morning Paper (archive)

  • Docs: blog.acolyer.org
  • SDKs & repos: Adrian Colyer’s daily paper summaries, 2014-2021
  • Downloadable / offline: Free archive, still online
  • Note: No longer updated, but the back catalogue of ~1000 summarised papers is one of the great free CS resources.

USENIX Proceedings

  • Docs: usenix.org/publications/proceedings
  • SDKs & repos: OSDI, SOSP (co-published), NSDI, ATC, FAST, Security — the core systems venues
  • Downloadable / offline: Every paper free, immediately, with no membership. Often with recorded talks
  • Note: USENIX made everything open access years before the rest of the field. If a systems paper exists, check here first.

ACM Digital Library

  • Docs: dl.acm.org
  • SDKs & repos: SIGMOD, ASPLOS, PLDI, POPL, SoCC and the ACM journals
  • Downloadable / offline: Partly open: ACM Open and author-paid OA papers are free; others are paywalled
  • Note: 403s to automated clients; loads in a browser. For paywalled items, check arXiv, the author’s homepage or Unpaywall first — the free copy usually exists.

IEEE Xplore

  • Docs: ieeexplore.ieee.org
  • SDKs & repos: ISCA, MICRO, HPCA and the IEEE journals
  • Downloadable / offline: Mostly paywalled; abstracts free
  • Note: Almost always worth searching the author’s page or arXiv instead. Architecture authors in particular post preprints widely.

DROPS / LIPIcs (Dagstuhl)

  • Docs: drops.dagstuhl.de
  • SDKs & repos: ECOOP, ITP, CONCUR, SAT and many theory venues
  • Downloadable / offline: 100% open access, free PDFs, Creative Commons licensed
  • Note: A fully open publisher. Every paper, always free, no exceptions.

arXiv cs.PL (Programming Languages)

SIGPLAN OpenTOC

  • Docs: sigplan.org/OpenTOC
  • SDKs & repos: Free, sanctioned access to the tables of contents and papers of PLDI, POPL, ICFP, OOPSLA and SPLASH
  • Downloadable / offline: Free via the OpenTOC links
  • Note: The official free route into SIGPLAN proceedings. Most people do not know this exists and pay or give up instead.

ACM SIGPLAN

  • Docs: sigplan.org
  • SDKs & repos: The PL special interest group; PACMPL is its open-access journal
  • Downloadable / offline: PACMPL papers are open access
  • Note: Proceedings of the ACM on Programming Languages is gold open access — POPL, PLDI, ICFP and OOPSLA papers are free.

PLDI

  • Docs: pldi25.sigplan.org
  • SDKs & repos: Programming Language Design and Implementation — the compiler-heavy venue
  • Downloadable / offline: Papers free via PACMPL/OpenTOC
  • Note: If you care about compilers rather than type theory, start here.

POPL

  • Docs: popl25.sigplan.org
  • SDKs & repos: Principles of Programming Languages — the theory venue
  • Downloadable / offline: Free via PACMPL

ICFP

  • Docs: icfp25.sigplan.org
  • SDKs & repos: International Conference on Functional Programming
  • Downloadable / offline: Free via PACMPL

SPLASH / OOPSLA

  • Docs: 2025.splashcon.org
  • SDKs & repos: Object-oriented, applied and practice-oriented PL research
  • Downloadable / offline: Free via PACMPL

ECOOP

  • Docs: 2025.ecoop.org
  • SDKs & repos: European Conference on Object-Oriented Programming
  • Downloadable / offline: 100% open access via LIPIcs/DROPS
  • Note: Published through Dagstuhl, so every paper is free and Creative Commons licensed.

The Art, Science, and Engineering of Programming

  • Docs: programming-journal.org
  • SDKs & repos: Open-access PL journal with an unusually broad remit
  • Downloadable / offline: Free, Creative Commons
  • Note: Publishes work that does not fit the conference mould, including essays and artifacts.

conf.researchr.org

  • Docs: conf.researchr.org
  • SDKs & repos: The hosting platform for most PL and SE conferences — programmes, artifacts, recorded talks
  • Downloadable / offline: Free
  • Note: Browse any recent conference programme here; artifact links are often more useful than the papers.

DROPS / LIPIcs

  • Docs: drops.dagstuhl.de
  • SDKs & repos: ECOOP, ITP, CONCUR, FSCD and other formal-methods venues
  • Downloadable / offline: Fully open access

LLVM Weekly

  • Docs: llvmweekly.org
  • SDKs & repos: Weekly digest of LLVM development
  • Downloadable / offline: Free archive
  • Note: The best way to track what is actually changing in the dominant compiler infrastructure.

Education & reference implementations

Two tracks: Basic builds the foundations, Advanced is about reading and extending real implementations. Everything listed is free and publicly accessible.

Basic

24 resources across 6 topics.

The book to start with

  • Crafting Interpreters — Build two complete interpreters — a tree-walker in Java and a bytecode VM in C — with every line of code in the text. Free online, beautifully written. The best introduction to this field by a wide margin.
  • Crafting Interpreters source — Reference implementations of both interpreters.
  • Writing a C Compiler — Nora Sandler’s incremental C compiler book; the free blog series it grew from is also still online.
  • Write a Compiler (blog series) — The free predecessor to the book. A complete staged project.

Small implementations to read end to end

  • chibicc — A C compiler built in readable incremental commits. Walk the git history as a tutorial.
  • Lua source — A complete, fast, widely deployed language in ~25k lines of exceptionally clean C.
  • QBE — A compiler backend small enough to actually read, aiming at most of LLVM’s performance with a fraction of the complexity.
  • Let’s Build a Compiler (Crenshaw) — Dated in its target, timeless in its method. Still one of the gentlest introductions.

Courses with public materials

Specifications worth reading early

Tools to pick up alongside

  • tree-sitter — Write a grammar and get incremental parsing plus editor integration for free.
  • ANTLR — When you need a working parser fast.
  • GNU Bison — Learn LALR parsing properly once.
  • LLVM LangRef — Learn to read LLVM IR. It is a lingua franca across the whole field.

Finding and reading papers

  • Papers We Love — Start here when you do not yet know which papers matter. Curated by subfield, with recorded talks.
  • The Morning Paper archive — Around a thousand papers summarised in plain language. No longer updated; still one of the best free CS resources.
  • Semantic Scholar — Free citation graph. The ‘highly influential citations’ filter is the fastest way to find what a paper actually changed.
  • Unpaywall — Install the extension. Most paywalls stop appearing, legally, because the author deposited a copy.
  • ar5iv — Read any arXiv paper as HTML instead of a two-column PDF. Swap arxiv.org/abs for ar5iv.labs.arxiv.org/html.

Advanced

35 resources across 6 topics.

Production compiler internals

  • rustc dev guide — Query-based incremental compilation, MIR, borrow checking — explained unusually well. Read it regardless of your language.
  • Clang Internals Manual — How an industrial C/C++ frontend is actually organised.
  • LLVM documentation — Pass infrastructure, the pass manager, and writing your own passes.
  • GCC internals (gccint) — GIMPLE and RTL. Dense, but the only authoritative source.
  • Roslyn — Incremental, IDE-first compiler design — a different set of constraints from batch compilation.
  • Cranelift — A backend optimized for compile speed and verifiability instead of peak output.

MLIR & modern compiler infrastructure

  • MLIR docs — Dialects, regions, the pattern rewriting infrastructure.
  • MLIR — Start with the Toy tutorial, then read a real dialect.
  • LLVM monorepo — MLIR lives here alongside LLVM proper; read them together.
  • Apache TVM — Domain-specific compilation with autotuning.
  • OpenXLA — A production ML compiler with genuinely good internal documentation.

Runtimes, JITs & garbage collection

  • V8 docs and blog — Hidden classes, inline caches, and the tiering between Ignition, Maglev and TurboFan.
  • V8 source — Large but navigable if you enter through a blog post’s named files.
  • OpenJDK — HotSpot’s C2, plus G1 and ZGC — the most mature GC implementations available to read.
  • JVM Specification — Read the spec before the implementation.
  • GraalVM — Truffle and partial evaluation: build an AST interpreter, get a JIT. A genuinely different approach.
  • .NET runtime design docs — docs/design/ contains real engineering writing on RyuJIT and the GC.
  • PyPy — Meta-tracing — generating a JIT from an interpreter definition.
  • LuaJIT — Trace compilation at its most refined.
  • CPython developer guide — The bytecode VM, the specializing adaptive interpreter, and the C API.

Type systems & programming language theory

WebAssembly in depth

  • WebAssembly core specification — Formal semantics with a reference interpreter.
  • Wasmtime — The reference runtime; read it with Cranelift.
  • Wasmer — Alternative backends and a different design philosophy.
  • WAMR — Wasm on microcontrollers.

Research & community

  • Cornell CS6120 — Advanced Compilers — Adrian Sampson’s self-guided PhD course. All materials, readings and a working IR are public. Outstanding.
  • SIGPLAN — The umbrella for PL conferences, with open-access policies.
  • PLDI — Implementation-focused.
  • POPL — Theory-focused.
  • WG21 papers — Language design argued in public, at length.
  • TC39 proposals — The same, for JavaScript, and easier to follow.

Video courses, channels & talks

12 resources across 2 groups. Every channel and playlist below was fetched and title-verified on 2026-10-09. Handles drift and several plausible-looking handles resolve to the wrong channel, so a 200 response is not proof of identity — the links here were each checked against the channel title.

Channels & conference recordings

  • Tsoding Daily — Livestreamed low-level building: compilers, interpreters, OS-ish projects in C and Zig.
  • CppCon — The C++ conference — where the memory-model and atomics talks live.
  • Strange Loop Conference — The Strange Loop channel: distributed systems, databases and language talks from the conference.
  • Computerphile — Short, well-made explainers; the right first stop before a spec.
  • Neso Academy — Unit-by-unit university course playlists (OS, compiler design); verify against OSTEP and the dragon book.
  • USENIX — Conference recordings for most USENIX papers — free video, the fastest route into a systems paper.
  • InfoQ — Conference keynotes and architecture talks — good for orientation, verify specifics elsewhere.
  • Papers We Love — Recorded paper walkthroughs — watch one before you read the PDF.
  • PyCon US — The full PyCon archive: CPython internals, JIT work, type systems, packaging.
  • C++Now — The Boost-flavoured C++ conference; more language-design and metaprogramming than CppCon.
  • Meeting C++ — European C++ conference recordings, including standardisation talks.

Lectures & playlists

Note: Compiler video is thin and fragmented: livestream build-alongs and conference talks, with no single canonical course. The playlists in the education section above still beat it for rigour.

Conference videos, notes & archives

5 resources across 2 groups. Conference recordings are the primary-source tier of video: the speaker is usually an author of the paper, and where a talk exists the proceedings entry is often open at the same link. Every URL here returned 200 on 2026-10-09 unless the note says otherwise.

Compiler video is scattered across language conferences; LLVM and PyCon are the two archives that are actually complete.

Conference channels & video archives

  • LLVM Developers’ Meetings — Slides and recordings for every LLVM dev meeting going back years — the single best compiler-implementation archive.
  • PyCon US — Full talk archive on the site and on the PyCon US channel; interpreter internals talks every year.
  • Strange Loop — Language-design and implementation talks, free.
  • FOSDEM video archive — Programming-language and compiler devrooms.

Notes, proceedings & paper-adjacent archives

  • No official channel for PLDI, POPL or ICFP — Checked on 2026-10-09. Papers live in the ACM DL and PACMPL (open); talks surface on author pages and at Strange Loop.

If you only do three things

  1. Work through Crafting Interpreters. Both halves. Free, and nothing else in this field comes close as an introduction.
  2. Read the rustc dev guide. It is the best public explanation of how a modern incremental compiler is architected — useful even if you never write Rust.
  3. Do the LLVM Kaleidoscope tutorial, then the MLIR Toy tutorial. Two weekends, and the modern compiler stack opens up.

Honest notes

  • Read a small implementation before a large one. Lua (~25k lines) or chibicc, then LLVM. Starting at LLVM is how people bounce off this field.
  • The Go spec and the JVM spec are short and excellent. Most engineers have never read a language specification; these two are the easiest places to start.
  • MLIR is where the field is moving. Nearly every new ML and hardware compiler is built on it.
  • Cornell CS6120 is designed for self-study — public materials, a working IR, and real assignments. Rare for a graduate course.
  • LLVM IR is a lingua franca. Learning to read LangRef pays off across compilers, security work and performance engineering.