Making a Language on Thunderseethe's Devlog

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

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.

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.

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.

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.

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.