Growing Compilers from Seed Code

Plant tissue culture starts with a few totipotent cells in sterile medium—minimal viable tissue that, given the right nutrients, grows into a complete organism. Compiler bootstrapping follows the same arc: write a minimal compiler in another language, use it to compile a slightly larger version of itself written in its own language, then discard the scaffold.

Pascal did this in 1972. Niklaus Wirth wrote a Pascal compiler in Fortran, used it to compile a Pascal-written Pascal compiler, then threw away the Fortran version. The C compiler followed in 1973. You start with just enough to process basic syntax, then that seed compiles the fuller version.

Ruby’s eval demonstrates the core mechanism—code that executes code, including itself:

code = "x = 10; y = x * 2; puts y"
eval(code)
bootstrap = "eval('puts 5 + 3')"
eval(bootstrap)

The second eval interprets an eval statement. That’s the seed: a language feature that can interpret its own syntax. In 1970s terms, you’d write a compiler in assembly that understands a tiny subset of your language, then write the full compiler in that subset.

C’s approach is more manual but shows the stages:

#include <stdio.h>
#include <string.h>
int main() {
    char src[] = "x=5;";
    char *token = strtok(src, "=");
    printf("var: %s\n", token);
    token = strtok(NULL, ";");
    printf("val: %s\n", token);
    return 0;
}

A real bootstrapping compiler would parse its own source using functions it just compiled. That first-generation compiler is the explant—disposable once the second generation grows. Tissue culture keeps the medium sterile so only your chosen cells multiply. Bootstrapping keeps the feature set minimal so only essential syntax survives into the self-hosted version.