Reading

• Implementing a Simple Compiler on 25 Lines of JavaScript

Compiler

• A miniature model of the Typescript compiler
• Alias analysis
• An Introduction to Interpreters and JIT Compilation
• AST (Abstract Syntax Tree)
• Anders Hejlsberg on Modern Compiler Construction
• Compilers Resources
• Compilers: Nuts and bolts of Programming Languages
• Compiling Scheme to C with closure conversion
• Compiling to Java
• Compiling to lambda-calculus
• Flattening ASTs (and Other Compiler Data Structures)
• Fredrik Lundh - Simple Town-Down Parsing In Python
• How To Build A Programming Language From Scratch
• How to Compile Your Language
• How to implement a programming language in JavaScript
• How would compilers change in the next 10 years?
• Implementing a bignum calculator
• Interpreter, Compiler, JIT - Nick Desaulniers
• IU Compiler Course
• JavaScript ∩ WebAssembly
• JavaScript implementation in SpiderMonkey
• KAIST CS420: Compiler Design
• Language grammar
• Lessons from Writing a Compiler
• Lexical Scanning in Go
• Lexing in JS style
• Mozilla Hacks Compiler Compiler
• Quick look at the TypeScript Compiler API
• Pursuit of Performance on Building a JavaScript Compiler
• Rethinking compiler technology in a heterogeneous world
• Scheme from Scratch - Introduction
• The business of selling compilers
• Top Down Operator Precedence - Douglas Crockford
• Understanding compiler optimization
• Understanding GC in JSC From Scratch
• Write you a Haskell
• The Pipefish Type System Part 1 | part 2 | Compiler Implementation

Interpreters

• Which Interpreters are Faster, AST or Bytecode?
• Building an Interpreter
• Building an Interpreter from scratch
• Cheaply writing a fast interpreter
• Compiling Lisp to bytecode
• Crafting an Interpreter
• Crafting Interpreters by Bob Nystrom (Github): A neo-classic book, walking through the construction of an interpreted language, Lox:
  • C++: CppLox
  • Rust: rlox
  • Rust: "My Experience Crafting an Interpreter with Rust": Book material ported to Rust.
  • Swift: slox

Tutorials/Walkthroughs

• Build Your Own Programming Language (source)
• How languages work #1: String interpolation

Compilers

• Creating the Bolt compiler (series):

  • Source
  • Part 1: How I wrote my own "proper" programming language;
  • Part 2: So how do you structure a compiler project?;
  • Part 3: Writing a Lexer and Parser using OCamllex and Menhir;
  • Part 4: An accessible introduction to type theory and implementing a type-checker;
  • Part 5: A tutorial on liveness and alias dataflow analysis;
  • Part 6: Desugaring - taking our high-level language and simplifying it!;
  • Part 7: A Protobuf tutorial for OCaml and C++;
  • Part 8: A Complete Guide to LLVM for Programming Language Creators;
  • Part 9: Implementing Concurrency and our Runtime Library;
  • Part 10: Generics - adding polymorphism to Bolt;
  • Part 11: Adding Inheritance and Method Overriding to Our Language;

• LLVM Tutorial: Kaleidoscope

• Let's build a compiler (4 parts)
• Let’s Build a Compiler! - Jack W. Crenshaw
• Let's make a Teeny Tiny compiler
  • Part 1
  • Part 2
  • Part 3

• Let’s Build a Programming Language (Series):

  • Part 1
  • Compilers and Interpreters
  • Lexical Analysis

• Minsk: Immo Landwerth has done a collection of videos on building a language for the CLR platform in a live-streaming style: Source:

  • Episode 1
  • Episode 2
  • Episode 3
  • Episode 4
  • Episode 5
  • Episode 6
  • Episode 7
  • Episode 8
  • Episode 9
  • Episode 10
  • Episode 11
  • Episode 12
  • Episode 13
  • Episode 14
  • Episode 15
  • Episode 16
  • Episode 17
  • Episode 18
  • Episode 19
  • ... more are likely on the way

• Subtype Inference by Example (series):

  • Part 1: Introducing CubiML;
  • Part 2: Parsing and Biunification;
  • Part 3: The Typechecker Frontend;
  • Part 4: The Typechecker Core;
  • Part 5: Incremental Reachability;
  • Part 6: Numeric Types and Operators;
  • Part 7: Spanned Error Messages;
  • Part 8: Mutability;
  • Part 9: Match Wildcards, Record Extension and Row Polymorphism;
  • Part 10: Let Polymorphism;
  • Part 11: The Value Restriction and Polymorphic Recursion;
  • Part 12: Flow Typing and Mixed Comparison Operators;
  • Part 13: Conditional Flow Constraints, Presence Polymorphism, and Type Level Computation;
  • Part 14: Type Annotations— What are they good for?;
  • Part 15: Monomorphic Type Annotations;

Compilers

• Let's Build an Interpreter:

  • Part 1
  • Part 2
  • Part 3
  • Part 4
  • Part 5
  • Part 6
  • Part 7
  • Part 8
  • Part 9
  • Part 10
  • Part 11
  • Part 12
  • Part 13
  • Part 14
  • Part 15
  • Part 16
  • Part 17
  • Part 18
  • Part 19
  • may be more...?

• LittleBasic

• Little lisp interpreter
• Little Lisp interpreter
• mal (Make A Lisp): Steps (and collection of implementations) to make your own Lisp.
• Write Yourself a Scheme in 48 Hours
• Write Yourself a Scheme in 48 Hours using F#

Native/raw

• AsmInterpreter: A simple assembly interpreter to help people with understanding the language without the hassle of setup.
• Build your own Lisp teaches C by building a Lisp.
• luax: Lua-like programming language for studying compiler and interpreter courses.
• Square: A tiny programming language under 200kb.
• Write your own C compiler from scratch with Python

LLVM

• A Tutorial on How to Write a Compiler Using LLVM
• Implementing a JIT Compiled Language with Haskell and LLVM
• Writing your own toy language using flex, bison, LLVM; code
• Mapping high level constructs to LLVM IR
• Kaleidoscope AST

CLR

• Concatenative Thinking (wiki): We are interested in both theoretical results and practical programming advice, especially as it pertains to any Concatenative language. We want to bring together disparate language communities and build a common knowledge repository that people can consult to learn more about this family of languages.
• Video - Creating a domain specific language for .NET Application
• How to Design Worlds (PDF)
• Kaleidoscope: Implementing a language with LLVM in CSharp: "By the end of the tutorial, we’ll have written a bit less than 1000 lines of non-comment, non-blank, lines of code. With this small amount of code, we’ll have built up a very reasonable compiler for a non-trivial language including a hand-written lexer, parser, AST, as well as code generation support with a JIT compiler. While other systems may have interesting “hello world" tutorials, I think the breadth of this tutorial is a great testament to the strengths of LLVM and why you should consider it if you’re interested in language or compiler design."
• learn-programming-languages: Resources for the working programmer to learn more about the fundamentals and theory of programming languages. (Jean Yang)
• Presentation - Write your own domain specific language with F#

JVM

• joeq: A Virtual Machine and Compiler Infrastructure (PDF) (Source): entirely implemented in Java, leading to greater reliability, portability, maintainability, and efficiency. It is also language-independent, so code from any supported language can be seamlessly compiled, linked, and executed --- all dynamically!
• Video - Nashorn: implementing a dynamic language runtime on JVM (Attila Szegedi)
• Scripting and Dynamic Interaction in Java
• write_your_own_dynamic_language_runtime: How to write interpreters or dynamic compilers for dynamically typed languages on top of the JVM. This repository provides the basis to implement your own
  • Abstract Syntax Tree Interpreter
  • Stack based Interpreter
  • Java Virtual Machine based Interpreter

  of a dynamically typed language named smalljs which is almost a subset of JavaScript.

Python

• ast: The Python official documentation of the ast module that ships as part of Python. "The ast module helps Python applications to process trees of the Python abstract syntax grammar. The abstract syntax itself might change with each Python release; this module helps to find out programmatically what the current grammar looks like. An abstract syntax tree can be generated by passing ast.PyCF_ONLY_AST as a flag to the compile() built-in function, or using the parse() helper provided in this module. The result will be a tree of objects whose classes all inherit from ast.AST. An abstract syntax tree can be compiled into a Python code object using the built-in compile() function."
• Code Transformer: "The CodeTransformer is a Transformer based architecture that jointly learns from source code (Context) and parsed abstract syntax trees (AST; Structure). It does so by linking source code tokens to AST nodes and using pairwise distances (e.g., Shortest Paths, PPR) between the nodes to represent the AST. This combined representation is processed in the model by adding the contributions of each distance type to the raw self-attention score between two input tokens (See the paper for more details)."
• Green Tree Snakes: The Missing Python AST docs. Points out a few projects using the Python AST:
  • pytest (uses the AST to produce useful assertion error messages)
  • astsearch (search the semantics, not the syntax)
  • astpath (XPath over an AST)
  • bellybutton readily customised linter

• (How to Write a (Lisp) Interpreter (in Python)): Norvig builds a simple Scheme in simple Python

• https://github.com/jonpry/Pill: Pill is an open source interpreter for the Cadence Skill language. Its purpose is to run PCell generator codes used in VLSI. Pill is written in Python and compiles the source into Python bytecode where it is then executed alongside regular python functions at similar speed to "native" python codes. (This is an intriguing idea, and one that deserves some further exploration--if I can go from source to Py bytecode, we skip much of the parsing and get a startup speed benefit.)
• https://github.com/jszheng/py3antlr4book: Covert ANTLR4 book source code to Python3 version.
• https://github.com/maxmalysh/tiny-py-interpreter: Python interpreter written in Python; uses ANTLR4
• A Python Interpreter Written in Python
• Compiler Hacking (using Chocopy)
  • Part 1: Building a Compiler Front-end in Python
  • Part 2: Building a JVM back-end
  • Part 3: Building a CIL back-end
  • Part 4: Building a WASM back-end
  • Part 5: Building a LLVM back-end

Rust

• Create Your Own Programming Language with Rust: Incomplete but interesting first steps
• Make A Language:
  • Part Twenty: Testing
  • Part Nineteen: Code Representations
  • Part Eighteen: Errors
  • Part Seventeen: Crates
  • Part Sixteen: Refactoring
  • Part Fifteen: Markers
  • Part Fourteen: Comments
  • Part Thirteen: Whitespace & Events
  • Part Twelve: Terminology
  • Part Eleven: Refinements
  • Part Ten: Starting Again
  • Part Nine: Function Calls
  • Part Eight: Function Definitions
  • Part Seven: A REPL
  • Part Six: Blocks
  • Part Five: Binding Usages
  • Part Four: Backtracking
  • Part Three: Defining Variables
  • Part Two: Whitespace Support
  • Part One: A Basic Parser
  • Part Zero: Getting set up

Go

A simple Hindley-Milner type system in Go

Haskell

Write You a Haskell

Learning/AI-related

• https://openreview.net/pdf?id=Xh5eMZVONGF : LANGUAGE-AGNOSTIC REPRESENTATION LEARNING OF SOURCE CODE FROM STRUCTURE AND CONTEXT
• Sudolang: A powerful programming language for LLMs

Toy/experimental

• Language Incubator: Repo of language experiments/explorations; "An incubator/sandbox for learning compilers, interpreters, code generation, virtual machines, assemblers, JITs, etc."

• Bhai: A toy programming language written in Typescript

• Blink
• Bob: A Tiny Object-Oriented Language
• Dwarf: A very small scripting language written in Elixir.
• Epic: interpreter for Python-like programming language with braces
• Eval: a lightweight interpreter framework written in Swift, evaluating expressions at runtime.
• Imp:
  • IMP: A minimal interpreter for the toy language, IMP, used as an example for building interpreters.
  • https://github.com/nandor/utcn-imp: Imp Language and Interpreter

• Kaleidoscope: the classic from the LLVM website

• Lepton: Simple Programming Language
• ModLang: A minimal, toy programming language implemented in C++ and STL
• Maverick
• miniUni: A concurrent scripting language
• Pointless (Source): a scripting language for learning and fun.
• The Super Tiny Compiler (JS)
• TinyML: A tiny functional language interpreter (Tomas Petricek)
• uza: a simple statically-typed programming language
• X-expressions in XMLisp: S-expressions and Extensible Markup Language Unite: "XMLisp unites S-expressions with XML into X-expressions that unify the notions of data sharing with computation. Using a combination of the Meta Object Protocol (MOP), readers and printers, X-expressions uniquely integrate XML at a language, not API level, into Lisp in a way that could not be done with other programming languages."

• https://github.com/yangtau/hedgehog: a toy programming language

• https://github.com/mattgreen/hython: Haskell-powered Python 3 interpreter
• https://github.com/proglangclass/interpreter: Language built during the Programming Language Masterclass.
• https://github.com/hisystems/Interpreter: Simple language interpreter written in pure C#.
• https://github.com/jamesdhutton/Interpreter: Interpreter for a simple language
• https://github.com/progschj/jtc: A toy programming language interpreter that has no dependencies and sits in a single C++ file. C++11 capable compilers should compile it without extra options other than enabling C++11.
• https://github.com/airtrack/luna: A toy interpreter of lua-like language
• https://github.com/hijkzzz/mini-interpreter: A simple scripting language (supports anonymous functions and clases)
• https://github.com/drmenguin/minilang-interpreter: Interpreter and Read-Eval-Print-Loop for a simple programming language called "MiniLang", written in C++
• https://github.com/JohnEarnest/ok: An open-source interpreter for the K5 programming language.
• https://github.com/oriontransfer/PL0-Language-Tools: An implementation of PL/0 including a tree-based interpreter and virtual machine. http://programming.dojo.net.nz/study/pl0-language-tools/index
• https://github.com/bbu/simple-interpreter: A hackable and extensible lexer, parser and interpreter for a minimalistic, imperative, C-like language.
• https://github.com/totalspectrum/tinyscript
• https://github.com/sam-astro/Z-Sharp: Custom programming interpreter for ZSharp (Z#), a language I made up.

Monkey

This is the language described by the book "Writing an Interpreter in Go". Also has a paired book, "Writing a Compiler in Go" which appears to include the creation of a virtual machine for executing the compiled code.

• Source (archived)
• C++
• C++
• C++
• Go: Monkey in Go
• Haskell
• Rust
• Rust
• Rust: https://github.com/JoshMcguigan/monkey
• Rust: https://github.com/shuhei/cymbal
• Rust: https://github.com/hatashiro/monkey-rs
• Rust: Monkey in Rust
• TypeScript: Monkey in TypeScript
• Gadget: The 'Gadget' interpreter language, implemented in Go, using the Writing An Interpreter In Go book. This language is based off the Monkey interpreter language described in the book, and will be implemented as I progress through the book.
• An interpreter for the Monkey programming language

Esolangs

• https://github.com/nickdesaulniers/bf_interpreter_jit_compiler: Teach myself about interpreters, JITs, and compilers using the Brainfuck language as the toy language -- https://nickdesaulniers.github.io/blog/2015/05/25/interpreter-compiler-jit/

Uncategorized

• ALIVe: Automatic LLVM InstCombine Verifier
  • http://rise4fun.com/Alive
  • https://github.com/nunoplopes/alive
  • http://blog.regehr.org/archives/1170
  • https://www.cs.utah.edu/~regehr/papers/pldi15.pdf
  • http://llvm.org/devmtg/2014-10/Slides/Menendez-Alive.pdf
• Automatic Feedback Directed Optimizer (AutoFDO)
  • https://gcc.gnu.org/wiki/AutoFDO
  • https://github.com/google/autofdo
• Compiler Optimizations for Reverse Engineers by Rolf Rolles
  • http://www.msreverseengineering.com/blog/2014/6/23/compiler-optimizations-for-reverse-engineers
  • http://www.msreverseengineering.com/s/Binary-Literacy-Static-6-Optimizations.ppt
• Compiler Optimization Options
  • GCC: https://gcc.gnu.org/onlinedocs/gcc/Optimize-Options.html
  • Clang: http://clang.llvm.org/docs/CommandGuide/clang.html#cmdoption-O0 - https://stackoverflow.com/questions/15548023/clang-optimization-levels
  • Visual C++: https://msdn.microsoft.com/en-us/library/19z1t1wy.aspx
• Devirtualization in C++
• GoingNative 50: New Visual C++ Code Optimizer
• Link time optimization (LTO)
• Optimizations in C++ Compilers: A practical journey, by Matt Godbolt; ACM Queue vol. 17, no. 5 (2019)

CLang

• Understanding the Clang AST

Escape analysis

Escape analysis is an optimization for identifying objects which do not escape the dynamic extent of a function; such objects can be stack-allocated, or 'flattened' so that usages of them are replaced with a series of local variables (the latter optimization is known as "scalar replacement").

An overview of the escape analysis algorithm used in Factor's Optimizing compiler: http://factor-language.blogspot.com/2008/08/algorithm-for-escape-analysis.html http://en.wikipedia.org/wiki/Escape_analysis

Register allocation

• Linear scan: The linear scan algorithm sacrifices code quality for compilation speed; it only needs to make one or two passes over the intermediate representation to assign registers, and therefore runs in O(n) time; therefore it is much faster than graph coloring, which runs in O(n2) time.

  • Linear Scan Register Allocation, Massimiliano Poletto and Vivek Sarkar, http://www.cs.ucla.edu/~palsberg/course/cs132/linearscan.pdf

  • Linear Scan Register Allocation for the Java HotSpot Client Compiler, by Christian Wimmer, http://www.ssw.uni-linz.ac.at/Research/Papers/Wimmer04Master/

  • Quality and Speed in Linear-scan Register Allocation, by Omri Traub, Glenn Holloway, Michael D. Smith, http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.34.8435

• Graph coloring

  • Graph coloring is traditionally implemented by building an interference graph, attempting to color it, and if coloring fails, spilling some values and building the interference graph again. Building the graph is pretty expensive; if your program is in SSA form, it turns out you can perform spilling, build the graph and color it all in one shot. Register allocation for programs in SSA form using chordal graph coloring, Sebastian Hack, http://digbib.ubka.uni-karlsruhe.de/volltexte/documents/6532

Static Single Assignment (SSA)

• Static Single Assignment (SSA) Book (PDF) and online

Instruction selection

• Instruction Selection: Principles, Methods, & Applications: Gabriel Hjort Blindell (2016)
• Universal Instruction Selection: 2018 PhD Dissertation; Gabriel Hjort Blindell Github and also here
• Notes on Graph Algorithms Used in Optimizing Compilers - Carl Offner

Superoptimization

• GNU Superoptimizer Version 2 - https://github.com/embecosm/gso2
• Souper - a superoptimizer for LLVM IR - https://github.com/google/souper
• Stochastic Superoptimization - http://blog.regehr.org/archives/923
• STOKE: A stochastic superoptimizer and program synthesizer - http://stoke.stanford.edu - https://github.com/StanfordPL/stoke
• Superoptimizing Compilers - http://superoptimization.org/wiki/Superoptimizing_Compilers
• Superoptimization - James Pallister - FOSDEM 2015 - https://archive.fosdem.org/2015/schedule/event/superoptimization/

Scheduling languages

• Scheduling Languages: A Past, Present, and Future Taxonomy - https://arxiv.org/pdf/2410.19927

---

Tags: langdev   reading   language   llvm   native  

Last modified 11 December 2025

---

© 2020-2025 Ted Neward | Generated on 11.12.2025 20:31:49 | Mixed with Bootstrap v3.1.1 | Baked with JBake v2.6.5