Languages in Design & Research
This page catalogs open-source language and compiler projects by intent: didactic implementations built to be read, experimental and hobby languages with bold designs, and professional, institutional, or enterprise compilers that millions rely on. For each project you get a short description, why it matters for your study, and a link to the repository or project page. Clone one, read its source, and change it — real compilers consolidate the grammar, parsing, implementation, and virtual-machine chapters of this roadmap.
Simple Didactic Projects
These projects exist to teach. Small enough to read in a sitting or two, they take you from source text to a running program without the noise of a production codebase — the ideal companions to the foundations and implementation phases of this roadmap.
| Project | What it is & why study it | Links |
|---|---|---|
| Make-A-Lisp (mal) | A Lisp interpreter implemented in nine incremental steps across 80+ languages. Every step adds a real feature — S-expressions, environments, functions, macros — so the exercises themselves assemble a complete evaluator. The fastest way to turn “how does a REPL work?” into working knowledge. | github.com/kanaka/mal |
| Crafting Interpreters (jlox & clox) | The open-source companions to a free book on interpreters: first a tree-walking interpreter in Java, then a bytecode VM in C with scanner, compiler, and generational garbage collector. Reading the pair shows the whole arc of a language — syntax to bytecode — one careful chapter at a time. | craftinginterpreters.com · github.com/munificent/craftinginterpreters |
| write-a-C-interpreter | A genuine C subset implemented in a couple of thousand lines: lexer, parser, and evaluator working together. It demonstrates how an untyped, imperative language is interpreted with plain data structures — a compact, concrete match for this roadmap's parsing and interpreter topics. | github.com/lotabout/write-a-C-interpreter |
| Wren | An embeddable, class-based scripting language by Bob Nystrom, written in roughly ten thousand lines of plain C designed to be small, fast, and readable. One of the best “whole compiler in a sitting” reads: a real language you can genuinely finish. | github.com/wren-lang/wren · wren.io |
| Lua | The classic small, clean C implementation shipped in games and embedded devices worldwide. Study its register-based bytecode VM, incremental garbage collector, and C API — proof that a tiny codebase can power serious products. | github.com/lua/lua · lua.org |
Experimental & Hobby Projects
Bold designs driven by small teams or a single developer. These languages trade production stability for freedom to explore — and their open development histories are as instructive as the code. Carbon and Odin lead the list because both are explicitly built to be studied: Carbon's design is negotiated in public, and Odin's compiler is self-hosted and readable.
| Project | What it is & why study it | Links |
|---|---|---|
| Carbon | Google's experimental “successor to C++”, built on Clang and LLVM. Its value to students is the open design process: every feature is debated in public design docs and issues before it lands, making it a live masterclass in language evolution — and its toolchain is a research-grade compiler front end you can read. | github.com/carbon-language/carbon-lang · carbon-language.org |
| Odin | A fast, data-oriented systems language for game engineering, developed by a small team around one lead with an open community. The compiler is self-hosted — Odin compiles itself — with readable x86-64 and ARM back ends, so you can follow a modern systems compiler end to end. | github.com/odin-lang/Odin · odin-lang.org |
| Janet | A Lisp with a tiny embeddable C core of roughly twenty thousand lines: closures, fibers, a PEG parser, and a clean evaluator. A compact but complete language kit that shows how far a small, focused implementation can go. | github.com/janet-lang/janet · janet-lang.org |
| V | A single-author language that compiles to C instead of targeting LLVM directly. Its translator-style front end is a deliberate simplicity bet — worth studying as a case study of how fast a pragmatic language can ship, and what it trades away. | github.com/vlang/v · vlang.io |
| Beef | A performance-focused language for game development, open-sourced together with its own IDE and debugger. Study it for its interactive hot-reload pipeline and a self-contained toolchain built for fast iteration. | github.com/beefytech/Beef · beeflang.org |
| Bend | An experimental functional language that parallelizes automatically on GPUs through interaction combinators. Early and niche today, it demonstrates an execution model radically different from the stack and heap of the virtual machines chapter — study it for the ideas, not the ecosystem. | github.com/HigherOrderCO/Bend |
Professional & Institutional Projects
Production compilers backed by companies, foundations, or research institutions. Their source is large, so read them selectively: pick one subsystem — the parser, the optimizer, or the runtime — and trace how the concepts of this roadmap appear at scale.
| Project | What it is & why study it | Links |
|---|---|---|
| Go | Google's production language with a deliberately small, fast compiler: gc, SSA-based optimization, escape analysis, and an enormous standard library. The best “read a real compiler” experience — compact enough to navigate, real enough to trust. | github.com/golang/go · go.dev |
| CPython | The reference interpreter millions run every day. Its bytecode compiler, adaptive specializing interpreter, garbage collector, and GIL answer “how does a dynamic language really execute?” — the definitive study object for runtime design. | github.com/python/cpython · python.org |
| Roslyn | Microsoft rebuilt the C# compiler in C# and shipped it as a reusable platform: parser, symbol tables, semantic model, and analyzers exposed as APIs. The blueprint for compiler-as-a-service — and the reason C# tooling got dramatically better. | github.com/dotnet/roslyn · Roslyn SDK docs |
| Swift | Apple's self-hosted, LLVM-based compiler with its own middle end (SIL) for ownership, generics, and optimization. A real-world example of the front-end to back-end pipeline at enterprise scale. | github.com/swiftlang/swift · swift.org |
| V8 | Google's JavaScript engine: the Ignition interpreter, the TurboFan optimizing JIT, and parallel garbage collection. Read it to learn how production JITs and adaptive optimization make dynamic code fast. | github.com/v8/v8 · v8.dev |
| GHC (Glasgow Haskell Compiler) | Decades of advanced compiler engineering: lazy evaluation through the STG machine, a rich type system, and aggressive optimization. The extreme case study — not to finish, but to see how far language implementation can go. | github.com/ghc/ghc · haskell.org/ghc |
| Lean 4 | A functional language and theorem prover from Microsoft Research and a large academic community, implemented in a comparatively small, self-hosting C++ codebase. The example of a concise, high-assurance compiler with state-of-the-art automation. | github.com/leanprover/lean4 · lean-lang.org |
| Q# | Microsoft's domain-specific language for quantum programming — a textbook example of a real production DSL, with compilers, simulators, and Jupyter integration in an open repository. | github.com/microsoft/qsharp · learn.microsoft.com/azure/quantum |
| Zig | A modern systems language governed by the Zig Software Foundation. The compiler is small enough to be read and bootstrapped from nothing — its IR and cross-compilation story teach a clean back end without vendor lock-in. | github.com/ziglang/zig · ziglang.org |
How to Study a Compiler
A project catalog is only half the lesson — the other half is knowing how to read a large codebase. A practical order that follows this roadmap:
- Start didactic. Work through mal step by step, then lox, while the grammar and parsing chapters are fresh — the exercises echo the theory directly.
- Trace one feature end to end. Pick a mid-size compiler (Wren, Lua, or Go) and follow a single feature — for example, how a local variable becomes a stack slot in Lua's bytecode.
- Compare front ends. ANTLR grammars, OCaml's parser, Carbon's Clang-based pipeline — the same parsing concepts, three different homes. The ANTLR and OCaml topics give you the vocabulary.
- Reuse a grammar. antlr/grammars-v4 holds hundreds of ready-to-read grammars to bootstrap your own language.
- Read the process, not just the code. Carbon's design docs and the review discussions around any of these projects show why decisions were made — the reasoning is the lesson.
- Run, don't skim. Clone one project, build it, set a breakpoint in the parser and another in the evaluator, and watch a program flow between them.
The goal is not to read everything. Choose one project per category, clone it, make a small change, and rebuild — that is how a catalog becomes expertise, and how you take the first concrete step toward designing and building your own language, the point of this roadmap.