The Rust compiler, rustc, is the tool that transforms your human-readable Rust code into machine-executable instructions. Think of it as a sophisticated translator. It doesn't just swap words; it understands the deep structure and rules of your program to ensure it's correct and efficient.

This translation process isn't a single magical step. Instead, your code embarks on a journey through several stages of refinement. At each stage, the compiler represents your program in a different way, progressively lowering the level of abstraction from high-level Rust concepts down to something a machine can execute.

The journey begins with the raw text in your .rs files. The first task for rustc is to make sense of this sequence of characters. This phase is called parsing. The compiler reads your code and builds an Abstract Syntax Tree (AST). An AST is a tree-like data structure that represents the grammatical structure of your code, ignoring things like whitespace and comments.

But the AST is still very close to the syntax you wrote. To make analysis easier, rustc converts the AST into a High-level Intermediate Representation (HIR). The HIR is a more simplified and explicit representation of your Rust code. It performs "desugaring," which means it expands syntactic sugar into its more fundamental components. For example, a for loop is translated into a combination of loop, match, and break.

This conversion makes the compiler's job simpler. By working with a more consistent and explicit structure, rustc can perform crucial checks, like type checking, more reliably. The HIR is the first point where the compiler really starts to analyze the meaning of your code, not just its syntax.

After the high-level analysis is complete, rustc lowers the HIR into a Mid-level Intermediate Representation (MIR). This is arguably the most important stage in the Rust compiler. MIR is designed to be very simple and explicit, making it the perfect foundation for Rust's most critical analyses.

What does "simple and explicit" mean? In MIR, all control flow is represented as a graph. Your code is broken down into a series of basic blocks—straight-line sequences of instructions without any jumps. Jumps only happen at the end of a block, directing the flow to another block. This structure is called a Control Flow Graph (CFG).

Beyond borrow checking, MIR is also used for a range of optimizations and other static analyses, like identifying unreachable code. Because its structure is so simple, writing complex and powerful analyses is much more manageable than it would be on the HIR.

Once rustc has fully analyzed and optimized the MIR, it's time to generate machine code. Rust doesn't do this final step itself. Instead, it delegates the task to a well-established compiler backend called LLVM.

To do this, rustc translates the MIR into LLVM's own format, known as LLVM Intermediate Representation (LLVM IR). LLVM is a massive project that knows how to perform sophisticated, low-level optimizations and generate highly efficient machine code for a vast array of different processor architectures (x86, ARM, etc.).

By leveraging LLVM, the Rust team can focus on what makes Rust unique—its high-level features, safety guarantees, and robust type system. They don't have to reinvent the wheel for machine code generation. This separation of concerns is a key part of rustc's design. The journey from your source code to an executable file is a pipeline of transformations, each with a specific purpose, culminating in a handoff to a specialized tool for the final step.