What Is a Compiler?

The 10,000-foot view of how source code becomes something a computer can run.

The Simple Answer

A compiler is a program that translates code from one language to another.

That's it. Really.

When you write print("Hello") in Python, your computer doesn't understand that. It only understands machine code — ones and zeros. Something has to translate your human-readable code into machine-readable instructions.

The Compilation Pipeline

Every compiler follows roughly the same pipeline. The source code flows through a series of transformations, each one bringing it closer to machine code.

Let's walk through each stage with a simple example. Say you write this Nova code:

fn add(a: Int, b: Int) -> Int {
    a + b
}

add(3, 5)

// Your code becomes a stream of tokens:
[FN] [IDENT:"add"] [LPAREN] [IDENT:"a"] [COLON] [IDENT:"Int"]
[COMMA] [IDENT:"b"] [COLON] [IDENT:"Int"] [RPAREN] [ARROW]
[IDENT:"Int"] [LBRACE] [IDENT:"a"] [PLUS] [IDENT:"b"] [RBRACE]
[IDENT:"add"] [LPAREN] [NUMBER:3] [COMMA] [NUMBER:5] [RPAREN]

// Your code becomes a tree:
Program
├── FunctionDef
│   ├── name: "add"
│   ├── params: [(a, Int), (b, Int)]
│   ├── return_type: Int
│   └── body: BinaryExpr
│       ├── op: Add
│       ├── left: Var("a")
│       └── right: Var("b")
└── FunctionCall
    ├── name: "add"
    └── args: [Literal(3), Literal(5)]

// Type checking passes:
✓ add: (Int, Int) -> Int
✓ a: Int, b: Int
✓ a + b: Int (Int + Int = Int)
✓ add(3, 5): Int (call matches signature)

// WebAssembly output:
(func $add (param $a i32) (param $b i32) (result i32)
    local.get $a
    local.get $b
    i32.add)

// Calling add(3, 5):
i32.const 3
i32.const 5
call $add

Compiler vs. Interpreter

You might wonder: "What about Python? It doesn't compile to machine code."

Good catch! There are actually two approaches:

• Compilers (Rust, C, Go, Nova) translate your entire program to machine code before running it. Compilation happens once, then you run the fast machine code many times.
• Interpreters (Python, JavaScript, Ruby) read and execute your code line by line, while running. No separate compilation step.

Why This Matters for Nova

Nova adds extra stages to the pipeline that most languages skip:

That Verifier stage is what makes Nova special. It uses an SMT solver (a kind of mathematical proof engine) to verify that your code satisfies its contracts.

If you write:

fn divide(a: Int, b: Int) -> Int
where
    requires b != 0
{
    a / b
}

Nova's verifier will prove that every call to divide has a non-zero second argument. Not by testing — by mathematical proof.

The Foundation: 5 Components

Every compiler needs at least these 5 fundamental components:

1. Span — Where in the source code? (line, column, file)
2. Token — What did we see? (keyword, number, identifier)
3. Source — What is the source code? (file contents)
4. Error — What went wrong? (diagnostics, messages)
5. Lexer — How do we tokenize? (the first transformer)

Every production compiler (Rust, Go, Swift, TypeScript) has exactly these 5 components. We'll build each one in the coming lessons.

What's Next?

Now you understand the big picture. In the next lesson, we'll zoom into the first stage: Lexers and Tokens. You'll see actual Rust code that tokenizes source text, and understand how the lexer identifies keywords, numbers, and symbols.