How compilation works

Two compilers, not one

In the first lesson you saw the big picture: C# becomes IL, and IL becomes machine code. Let's look closer, because this explains a lot about how .NET behaves — why the first request to a web app is slower, why a .dll runs on any OS, and what "AOT" means.

 Program.cs ──Roslyn──▶ MyApp.dll ──JIT (at run time)──▶ machine code
                          IL + metadata                     x64 / ARM64

Step 1: Roslyn compiles C# to IL

Roslyn — the C# compiler — checks your code (types, syntax, nullability) and emits IL, Intermediate Language: instructions for an imaginary stack-based machine. For example:

int Add(int a, int b) => a + b;

compiles to IL like:

ldarg.0     // push argument a onto the stack
ldarg.1     // push argument b
add         // pop both, push a + b
ret         // return the top of the stack

IL is the same on every OS and CPU. That's how one .dll runs on Windows, Linux and macOS.

Step 2: the assembly

The output is an assembly — a .dll (or an .exe launcher plus .dll). It contains:

• IL code for every method,
• Metadata — a complete description of every type, method, property and field,
• A manifest — the assembly's name, version and the other assemblies it depends on.

Metadata is why you can reference a library without its source, why IntelliSense knows its methods, and why reflection works at run time:

Step 3: the JIT turns IL into machine code

When your program runs, the CLR loads the assembly. The first time a method is called, the JIT compiler translates its IL into native machine code for this CPU, caches it, and jumps to it. Later calls go straight to the cached machine code.

Tiered compilation

Compiling well takes time, so the JIT works in tiers:

1. Tier 0 — compile fast with few optimizations, so the app starts quickly.
2. Methods that run often (hot loops, busy endpoints) are recompiled at Tier 1 with full optimizations, using information gathered while running.

This is why .NET apps "warm up": they get faster after running for a little while.

Ahead-of-time (AOT) compilation

You can skip the JIT entirely with Native AOT:

dotnet publish -c Release -r linux-x64 -p:PublishAot=true

The output is a single native executable with no IL and no JIT.

AOT shines for command-line tools, serverless functions and small containers. For most web apps, the default JIT is the right choice.

Managed code

Because the CLR runs your code, it can do things for you that C or C++ programs must do themselves:

• Memory management — the garbage collector frees objects you no longer use (Track 5).
• Type safety — you can't treat a string as an int or read past the end of an array.
• Exceptions — errors are reported consistently with stack traces.

Code that runs under the CLR like this is called managed code.

Key takeaways

• Roslyn compiles C# into IL + metadata, stored in an assembly.
• The JIT compiles each method to machine code on first call; tiered compilation optimizes hot code later.
• Native AOT compiles everything ahead of time: fast startup, OS-specific output, fewer dynamic features.
• The CLR manages memory, type safety and exceptions — that's "managed code".