Free & Open Source

Learn to Build a Programming Language

Ever wondered how Python, JavaScript, or Rust actually work? In this course, you'll learn by building Nova from scratch. No PhD required. Just curiosity.

7
Lessons
Free
Forever
Open
Source
Basic programming knowledge
No compiler experience needed
No CS degree required

Why Build a Programming Language?

Understanding compilers makes you a 10x better developer. You'll see code differently forever.

The Old Way

  • Code crashes at runtime with cryptic errors
  • Security vulnerabilities everywhere
  • AI generates buggy, untested code
  • Debugging feels like guessing
  • Languages designed 30+ years ago

The Nova Way

  • Errors caught at compile time
  • Code proves itself correct
  • AI generates verified, safe code
  • Debugging with mathematical precision
  • Designed for the AI age

Your Learning Journey

1

Understand

Learn why we need new languages

2

Tokenize

Break code into tokens

3

Parse

Build syntax trees

4

Type Check

Catch errors early

5

Verify

Prove code correct

6

Generate

Emit WebAssembly

The Curriculum

Start from zero, end up understanding how every programming language works.

Lesson 1

Why Nova? The Problem with Old Languages

Understand why we're building a new language and what's wrong with the current ones. Runtime errors, security holes, and why AI needs better languages.

15 min read Beginner
Lesson 2

What Is a Compiler?

The 10,000-foot view. What happens when you run your code? From source text to machine execution, demystified.

20 min read Beginner
Lesson 3

Lexers & Tokens: Breaking Code Apart

Your first real compiler code! Learn how lexers turn source text into tokens. We'll build one from scratch.

30 min read Intermediate
Lesson 4

Parsers & AST: Understanding Structure

Tokens become trees. Learn how parsers understand grammar and build Abstract Syntax Trees.

35 min read Intermediate
Lesson 5

Type Systems: Catching Errors Early

Why types matter. How type checkers work. Bidirectional type inference explained simply.

30 min read Intermediate
Lesson 6

Verification: Code That Proves Itself

Nova's secret weapon. Refinement types and SMT solvers. How code can mathematically prove its own correctness.

25 min read Advanced
Lesson 7

Code Generation: Emitting WebAssembly

The final step. Turn your AST into actual runnable code. Target WebAssembly for universal execution.

35 min read Advanced
Roadmap

Nova Development Roadmap

See what's built, what's in progress, and where Nova is headed. From foundation to production-ready verification.

5 min read All Levels

Ready to Start?

Join hundreds of developers learning how programming languages really work.

Start Lesson 1 View on GitHub
PG

Pranjal Gupta

AI Engineer & Language Designer

I build AI systems that actually work in production. Nova is my exploration of what programming languages should look like in the age of AI — where code proves itself correct and AI can generate verified, safe software. Currently building enterprise AI at BSKiller.