What Is Code Generation?

Translation, not transformation.

Think about translating a book from English to Spanish. You don't change the story. You don't rearrange the chapters. You express the same ideas in a different language, following that language's grammar and conventions.

Code generation is exactly this. The AST is your outline -- the structure of the program, fully understood. The code generator walks that outline node by node and writes the equivalent C code. Same program, different language.

By the time we reach code generation, the hard work is done. The lexer found the tokens. The parser built the tree. The checker (when it exists) verified types. Now we just need to express the same program in C, and let a C compiler handle the rest.

Why C and not something else.

Monk compiles to C, not LLVM IR, not assembly, not bytecode. This is a deliberate choice with real trade-offs.

A simple program, two languages.

Here's a Monk program:

let greeting = "hello world"
show(greeting)

And here's the C code the generator produces:

#include "runtime.h"

int main(int argc, char *argv[]) {
    monk_init(argc, argv);

    #line 1 "hello.monk"
    MonkValue greeting = monk_string("hello world");
    #line 2 "hello.monk"
    monk_show(greeting);

    monk_free(greeting);
    return 0;
}

Every line of Monk maps to one or more lines of C. The structure is preserved. The meaning is preserved. The only new things are C-specific bookkeeping: including the runtime header, initializing the runtime, freeing memory at the end, and #line directives for source mapping.

The anatomy of a generated C file.

Every generated C file follows the same structure, regardless of how complex the Monk program is:

#include "runtime.h"

// 1. Hoisted functions (from Monk function expressions)
static MonkValue _fn_add(MonkValue a, MonkValue b) {
    // function body
}

// 2. Main function (everything else)
int main(int argc, char *argv[]) {
    monk_init(argc, argv);

    // Program body: declarations, expressions, control flow
    MonkValue x = monk_int(42);
    MonkValue result = _fn_add(x, monk_int(8));
    monk_show(result);

    // Cleanup
    monk_free(x);
    monk_free(result);
    return 0;
}

Why everything goes through the runtime.

You might wonder: if x is an integer, why not just emit int x = 42; in C? Why wrap everything in MonkValue?

Because Monk values aren't raw C types. A MonkValue is a tagged union -- it knows its own type at runtime. When you write x + y in Monk, the runtime checks that both values are numbers before adding them. If one is a string, it produces a proper error instead of silently corrupting memory.

This is why x + y becomes monk_add(x, y), not x + y in the generated C. Every operation goes through a runtime function that enforces type safety and proper value semantics. The C code is the vehicle, but the runtime is the engine.

Key takeaways