BuildIt: A framework for rapidly developing high-performance Domain Specific Languages (DSLs) with little to no compiler knowledge. Source

gel: Generic Extensible Language (PDF)

One of the things I like about this paper is that it points out that Lisp and XML are essentially the same creature: Lisp: (if (< x 3) (print x)) == XML: <if><test op="lt"><var name="x"/><const>3</const></test><then><call fun="print"><arg>x</arg></call></then></if> I kinda love that.

coAST: coAST is a universal abstract syntax tree that allows to easily analyze each programming language. Especially adding new languages should be easy and generic. (Last update Dec 2018)

MLIR: Creating a Toy Language and AST

Creating a DSL Step by Step, Part 1

Create a programming language that the whole company can understand

Creating a Ruby DSL: A Guide to Advanced Metaprogramming

Towards Dynamically Extensible Syntax: introduces CherryLisp -- a Lisp dialect with dynamically user-definable syntax that suffers from neither of [drawbacks listed in the abstract].


"Three Things I Wish I Knew When I Started Designing Languages"

"The Naked Truth About Writing a Programming Language"

"How Big Should a Programming Language Be?": "... a long-held opinion I have about programming language design: we have a tendency to keep adding features to a language until it becomes so big that its sheer size makes it difficult to use reliably." Yes!

Open, extensible object models: "The artificial distinction between implementation language and end-user language can be eliminated by implementing the language using only end-user objects and messages, making the implementation accessible for arbitrary modification by programmers. We show that three object types and five methods are sufficient to bootstrap an extensible object model and messaging semantics that are described entirely in terms of those same objects and messages."

Intrinsically-Typed Definitional Interpreters for Linear, Session-Typed Languages

Interview with Jesper Louis Andsersen about a ton of languages.

"Less is more: language features"

"Languages I want to write"

"A wish list for a new programming language"

A Generic Framework for Automated QA of Software Models: references the OMG's Generic AST Model (GASTM) which I think is related to Abstract Syntax Tree Metamodeling (ASTM), here (PDF) This kinda looks like the generic AST I was futzing about with.

The Super Tiny Compiler (JS)

Program Analysis

Nanopass: A framework for compiler education | Source in Racket or Scheme

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

Principles of Programming Languages (course) (Source)

Flattening ASTs (and Other Compiler Data Structures)


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.

mal (Make A Lisp): Steps (and collection of implementations) to make your own Lisp.

Writer your own C compiler from scratch with Python


Writing your own toy language using flex, bison, LLVM; code

Implementing a JIT Compiled Language with Haskell and LLVM

A Tutorial on How to Write a Compiler Using LLVM


How to Design Worlds (PDF)

learn-programming-languages: Resources for the working programmer to learn more about the fundamentals and theory of programming languages. (Jean Yang)

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

Presentation - Write your own domain specific language with F#

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."


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

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

joeq: A Virtual Machine and Compiler Infrastructure (PDF) (Source): entirely implemented in JavaTM, 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!

Scripting and Dynamic Interaction in Java

Video: Nashorn: implementing a dynamic language runtime on JVM (Attila Szegedi)



Create Your Own Programming Language with Rust: Incomplete but interesting first steps




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.


From "Crafting Interpreters":





Learning Paths



Programming Language Design / PLT


PL Paradigms


PL Research

Type System



Program Synthesis

Parallel/Concurrent Programming

Language Learnings







Web UI




People in PL

Tags: reading   langdev  

Last modified 05 February 2024