Programming Languages on Thunderseethe's Devlog

Compiler Education Deserves a Revolution

Thu, 19 Feb 2026 00:00:00 +0000

Note

I was invited to write an article for the Paged Out magazine. If you would like to see this article in glorious HD color, with some fun diagrams, check out issue 8 . I think it’s pretty neat.

Crack open any compiler tome from the last century and you’ll find some variant of the same architecture. A pipeline that runs each pass of the compiler over your entire code before shuffling its output along to the next pass. The pipeline halts at the first error, throwing away any work that’s been completed.

How to Choose Between Hindley-Milner and Bidirectional Typing

Sun, 15 Feb 2026 00:00:00 +0000

This question is common enough you’ve probably heard it posed countless times: “Should my new programming language use a Hindley-Milner (HM) type system or a Bidirectional (Bidir) one?” What’s that? I need to understand friends don’t just bring up type inference in casual conversation?

OK, ouch, fair enough. But…whatever. This is my blog. We’re doing it anyway! I don’t know what you expected when you clicked on a programming languages blog.

Making an LSP for great good

Wed, 21 Jan 2026 00:00:00 +0000

Making a Language

This post is part of the making a language series . A series that teaches you how to implement a programming language using Rust.

This post brings together all our passes to build a language server. It mainly relies on the output of the frontend passes (parsing, desugar, nameres, and types).

We’ve talked a big game about resilience this and interactive that. With name resolution done, it’s finally time to put our money where our mouth is. It’s time to tie our passes together into a compiler, but not just any compiler. Sure, we could string together a batch compiler if we really had to:

Resolving Names Once and for All

Sat, 27 Dec 2025 00:00:00 +0000

Making a Language

This post is part of the making a language series . A series that teaches you how to implement a programming language using Rust.

This post covers name resolution. Desugaring left us with an Ast<String> that we can’t yet feed to type inference. Name resolution will turn that into a Ast<Var> that is ready for type checking by figuring out what the names in our program mean.

Why do we name things? A silly question, perhaps. No one had to tell me to name my pet rock Francis. One look at his sedimentary exterior was all it took to christen him.

Desugaring the Relationship Between Concrete and Abstract Syntax

Tue, 02 Dec 2025 00:00:00 +0000

Previously, we, begrudgingly, parsed some syntax into a Concrete Syntax Tree (CST) . With that tarpit deftly dodged, we can proceed to our next pass desugaring. Desugaring removes syntax sugar and maps our CST onto our Abstract Syntax Tree (AST). Our CST leaves us with a lot of cruft, such as | or =. This stuff was important for telling head from tail in our initial source file, and we’ll want to have it around when we’re reporting diagnostics, but the rest of the compiler doesn’t really care about such mundane affairs. Desugaring helps us strip away all the syntax and focus in on what’s important, lightening the cognitive load for following compiler passes.

Reproachfully Presenting Resilient Recursive Descent Parsing

Wed, 12 Nov 2025 00:00:00 +0000

Making a Language

This post is part of the making a language series . A series that teaches you how to implement a programming language using Rust.

This post covers parsing. Parsing is the first pass of the compiler, so it doesn’t depend on anything from the previous posts.

I must profess a certain disdain for the parsing tutorial. I won’t insult you by pretending it’s fair or rational. This may not come as a surprise, given that the Making a Language series has covered every part of the compiler it can before parsing. Parsing tutorials just feel so futile. Thousands of tutorials written about parsing, and yet PL projects still die bikeshedding syntax. What are the chances tutorial 1001 changes that?

Pushing Past the First Error During Type Inference

Mon, 10 Nov 2025 00:00:00 +0000

Making a Language

This post is part of the making a language series . A series that teaches you how to implement a programming language using Rust.

Today’s post builds on the previous type inference post for the base language.

Last we left off , we had a complete and working type inference system. An admirable achievement and at the time our completed product. I went off to write the remainder of the making a language series, and you went off to read it (I hope). As I’ve written more of the language, my ambitions have focused. Originally this series set out to write a compiler, pretty much any compiler would do and be challenging enough. Now, however, it won’t be any old compiler, but a query-based compiler, supporting the Language Server Protocol (LSP) .

Wasm Does not Stand for WebAssembly

Tue, 15 Jul 2025 00:00:00 +0000

“Wasm does not stand for WebAssembly” might sound like an outrageous claim. A glance at webassembly.org confirms it’s not just how it sounds:

Fortunately, I’ve never been one to let reason stand in the way of a good point. Let’s talk about Wasm’s relationship to the name WebAssembly.

As a proponent of Wasm (lengthened WebAssembly), I spend a lot of time preaching its positives to the people. Whilst standing on my soapbox, I encounter two common misunderstandings about Wasm:

Skipping the Backend by Emitting Wasm

Fri, 13 Jun 2025 00:00:00 +0000

Making a Language

This post is part of the making a language series . A series that teaches you how to implement a programming language using Rust.

Today’s post is preceded by the base closure conversion pass . Code emission turns our closure conversion IR into our executable target: WebAssembly.

Today is a great day. We stand together on the precipice of execution. All the work we’ve done till now culminates in our final compilation pass: Code Generation. Our compiler’s tires meet road, as we take our closure converted IR and turn it into executable code, driving off into the sunset.

Closure Conversion Takes the Function out of Functional Programming

Wed, 14 May 2025 00:00:00 +0000

Making a Language

This post is part of the making a language series . A series that teaches you how to implement a programming language using Rust.

Today’s post is preceded by the base monomorphization pass . Like monomorphization, closure conversion does not rely on anything from its prior pass. It relies on the IR (and accompanying types) introduced in lowering . We’ll review IR before the action starts.

Our previous pass , monomorphization, stripped polymorphism away from our intermediate representation (IR). Today we’ve come to cut down an even closer confidant, functions. How many friends must we lose on our conquest of compilation. This may come as a shock, functions are entwined deeply in our language. I mean it’s right there in the name, functional programming. I don’t know what al programming is, and I don’t want to.

Casting out Polymorphism with Monomorphization

Sun, 11 May 2025 00:00:00 +0000

Making a Language

This post is part of the making a language series . A series that teaches you how to implement a programming language using Rust.

Today’s post is preceded by the base simplify pass . That pass, however, is not a prerequisite to understanding monomorphization. Monomorphization relies only on the IR introduced in lowering . We’ll review IR before the action starts.

As we press deeper into the compiler, we strip away high level features that stand between us and machine code. Many of our language’s features have no direct instructions in the hardware, and we must either remove them or translate them into something that does. The feature on today’s chopping block is polymorphism.

Back to Basics by Simplifying our IR

Wed, 30 Apr 2025 00:00:00 +0000

Making a Language Series

This post is part of the making a language series . A series that teaches you how to implement a programming language using Rust.

Today’s post is preceded by the base lowering pass . From that post we’ll need our IR, and it’s accompanying data types. These will be covered in a refresher below.

Today we’re talking about a magical aspect of compilation: optimization. Magic both in its ability to peel away abstractions, leaving only efficient machine code, and its inscrutable behavior. Optimizers are known for being black boxes with a million knobs, each serving as butterfly wings flapping towards the final result.

Function Application Needs to Grow a Spine Already

Mon, 31 Mar 2025 00:00:00 +0000

Function application can be found nestled into the heart of basically every functional language. At the risk of hyperbole, I would even say every programming language. Unlike languages inheriting from the C family, function application in functional languages makes use of currying . Currying lets us eschew multi argument functions in favor of a bunch of single argument functions that return more functions. Function application (and currying) herald all the way back to the dawn of the lambda calculus:

Lowering Top Level Items

Tue, 04 Mar 2025 00:00:00 +0000

Making a Language

This post is part of the making a language series . A series that teaches you how to implement a programming language using Rust.

This post lowers top level functions from our prior pass . It extends the row language with support for items (top level functions) in our IR.

Last time saw us endeavoring upon a trilogy to bring rows crashing down from their high-flying AST nodes into the realities of our lowly IR. Our goals this time are less highfalutin. We’re going to be lowering items. I can’t tell you how relieved I am to see this titled “.Items”, not “.Items[0]”.

The Heart of Lowered Rows

Wed, 26 Feb 2025 00:00:00 +0000

Making a Language

This post is part of the making a language series . A series that teaches you how to implement a programming language using Rust.

This post continues lowering rows from our previous post .

Last time we upgraded lower_ty_scheme to support rows and saw how we’d use it’s evidence to inform lower_ast. We’re getting to the heart of lowering rows this time: generating and applying our evidence terms.

The Types of Lowered Rows

Tue, 18 Feb 2025 00:00:00 +0000

Making a Language

This post is part of the making a language series . A series that teaches you how to implement a programming language using Rust.

This post continues lowering rows from our previous post .

Last time we learned how we’re going to lower row types and made some row addendums for IR and Type. Today, we’ll update lower_ty_scheme, using those addendums, to generate types for Evidence.

Quick Refresher

Here’s a quick rundown of the stuff we’ll need from types/rows .

Lowering Row Types, Evidently

Tue, 11 Feb 2025 00:00:00 +0000

Making a Language

This post is part of the making a language series . A series that teaches you how to implement a programming language using Rust.

This post undertakes lowering rows building on our previous pass that inferred row types. It extends the lowering we did for the base language.

Last time , we lowered types/base into our IR. That was exciting, but I professed some anxieties that all we had really done is swap an Ast:: prefix for an IR:: prefix. Today, we’re going to assuage those concerns by lowering types/rows . A more seismic lowering. Recall that row types provide data types for our language. Rows are great in the surface language and the type checker but start to lose their luster once we need to represent them in memory.

Escaping the Typechecker, an Implementation

Tue, 04 Feb 2025 00:00:00 +0000

Making a Language

This post is part of the making a language series . A series that teaches you how to implement a programming language using Rust.

This post builds on the previous lowering post . Now that we have some more theory about lowering we undertake Implementation this time around.

Armed with the knowledge of IR and Type from last time , we can finally write some code:

fn lower(
 ast: Ast<TypedVar>, 
 scheme: ast::TypeScheme
) -> (IR, Type) {
 let (ir_ty, types) = lower_ty_scheme(scheme);

 todo!()
}

One line down. That’s great progress (especially compared to last post)!

Lowering our AST to Escape the Typechecker

Tue, 28 Jan 2025 00:00:00 +0000

Making a Language

This post is part of the making a language series . A series that teaches you how to implement a programming language using Rust.

This post covers turning our typed AST into our intermediate representation for our base language. It builds on the outputs of the previous pass where we inferred types for the base language.

We’ve been in type checking so long it’s becoming a tar pit deep enough to rival picking a parser. Our only hope of escape is to delve deeper, lest we find ourselves fretting over the endlessly enticing type checker features available to adjoin. We’re always free to return to our type checker older and wiser. But this series is called making a language, not type check until our motivation evaporates.

DeBruijn Indices: Picking Equatable Names

Thu, 23 Jan 2025 00:00:00 +0000

Naming things is hard. It’s one of two hard problems in computer science, alongside cache invalidation and off by one errors. Humans struggle to come up with good names. Personally, I can never remember if it’s AbstractProducerFactory or AbstractFactoryProducer.

Perhaps more surprisingly, computers are also stumped by this task. Compilers often need to come up with names and find themselves at a loss just like you and me. Sure, some of the names will be given to the compiler by the user writing code:

Traits are a Local Maxima

Mon, 18 Nov 2024 00:00:00 +0000

Today we’re talking about Rust traits . As you might’ve guessed from the title, we will not be talking about them positively. Woah woah, hang on, put down your pitchfork. A local maximum is still a maximum, I love traits as much as anyone.

Traits are one of the few programming language concepts beloved enough to earn multiple names. You might have heard about typeclasses in Haskell or protocols in Swift. Heck, if the teacher’s not watching, even interfaces can be considered a kind of trait. Elm famously left out traits, and it was so requested it spawned an FAQ explaining their absence.

Checking Types of Top Level Functions

Fri, 05 Jul 2024 00:00:00 +0000

Making a Language

This post is part of the making a language series . A series that teaches you how to implement a programming language using Rust.

This post covers type checking for top level functions. It extends the row language with top level functions and type checking.

Last season , boy how time flies, we added support for algebraic datatypes using row types. With both product and sum types, our type inference must be near completion. It’s a little lacking in scope though. We don’t have a way to call top-level functions.

I'm Betting on Call-by-Push-Value

Sat, 09 Mar 2024 00:00:00 +0000

You come upon a function argument at a fork in the road. If it takes the left road, it’ll evaluate itself and then be passed to its function. If it takes the right road, it’ll pass itself to the function to be evaluated somewhere down the road (🥁🐍). Let’s bet on which road will be faster.

We might suspect this is a rather boring bet. All we have to do is look down each road and see which one is shorter. Fortunately for our wager (and to the dismay of theorists everywhere), this is not the case. We can always construct a situation where evaluating either eagerly or lazily is better.

In Search of the Perfect Fold

Mon, 27 Nov 2023 00:00:00 +0000

I’m writing a compiler in Rust. Which is to say, I do a lot of tree folds in Rust. Rust shines at a lot of things. Overall, I’m happy with my choice to use it. It’s just…for the life of me I can’t write a satisfactory fold over trees.

Perhaps it’s a personal failing. The perfect fold is out there, and I’m simply ignorant of its divine design. If you’re reading this and thinking that, please I beg of you, enlighten me. If you’re reading this and not thinking that, first off thank you, and second off welcome to my tar pit.

Rowing Afloat Datatype Boats

Sat, 21 Oct 2023 00:00:00 +0000

Making a Language

This post is part of the making a language series . A series that teaches you how to implement a programming language using Rust.

This post covers type inference for row types, a method for adding data types to our language. It extends the base language with support for row types and their constructs.

Last episode we assembled a simple type inference engine end to end. Powerful enough to check both functions and integers, without any annotations at all. Perfect as it is, our type inference (and language) lacks one teensy feature. It doesn’t have any data types. We’ll rectify that on today’s episode by adding support for row types.

What's in a Module?

Mon, 31 Jul 2023 00:00:00 +0000

That Which We Call a Module Link to heading

A module by any other namespace would encapsulate just as sweet

Shakespeare…mostly

Modular programming has become a cornerstone of modern software development. Software projects are only getting larger, and as they do the need to divide up monolithic codebases becomes indispensable. It is no surprise then, that some form of modules show up in all modern programming languages in use today:

Tying up Type Inference

Sat, 01 Jul 2023 00:00:00 +0000

Making a Language

This post is part of the making a language series . A series that teaches you how to implement a programming language using Rust.

This is the capstone of type inference we built towards with constraint generation .

Constraint Solving Link to heading

On last week’s episode we generated a set of constraints with our bidirectional type system. Now that we’ve got our set of constraints, we can attempt to solve them. So what does it mean to solve a constraint? A constraint is something that has to be true about our types. If we can prove whatever our constraint wants true, we have solved the constraint. Since our Constraint datatype is just type equality, we can solve all our constraints by proving their types equal. If we fail to prove two types equal, we have a type error, and we can bail out early.

Turning our AST Into Type Constraints

Sat, 24 Jun 2023 00:00:00 +0000

Making a Language

This post is part of the making a language series . A series that teaches you how to implement a programming language using Rust.

Today’s post builds on the previous type inference post for the base language.

Last time , we laid out the AST and Type for the language we are building. We also got a bird’s-eye view of our type inference algorithm: constraint generation, constraint solving, substitute our solved types. This time we’re implementing the constraint generation portion of our type inference algorithm.

Typechecking a Language Without a Parser

Sat, 17 Jun 2023 00:00:00 +0000

Making a Language

This post is part of the making a language series . A series that teaches you how to implement a programming language using Rust.

This is the first post in the series, talking about type inference for a simple functional language.

I’d like to design a language, more specifically implement a compiler for a programming language I’ve made up. This is not the first time I’ve wanted to do this. In fact, I’ve had the itch quite a few times before . I can’t tell you why I keep returning to this venture when I’ve failed at it so many times. What I can tell you is why I always fail. Every time I begin a sparkly new project with fresh eyes and quickly whip together a lexer.