Miri: Your Personal Detective for Undefined Behavior in Rust

Writing in Rust and confident in your code's safety? Of course, since Rust is famous for its type system and memory safety guarantees. But what if I told you that even in Rust you can encounter Undefined Behavior (UB), which can lead to unpredictable crashes, vulnerabilities, or just very strange program behavior? Yes, unsafe blocks are a powerful tool that gives incredible flexibility and performance, but with it comes great responsibility. This is exactly where Miri comes on stage — an indispensable helper for every Rust developer.

What is Miri and why do you need it?

Imagine you have a super detective that can look inside your program and find all the hidden traps that can lead to undefined behavior. Miri is exactly such a detective. It's a tool for detecting Undefined Behavior in Rust that works as an interpreter for Rust's intermediate representation (MIR). It runs your project's binaries and test suites cargo and identifies unsafe code that doesn't meet Rust's safety requirements.

Who needs this? If you work with unsafe code, write low-level abstractions, create libraries that need to be as reliable as possible, or simply want to be absolutely confident in your Rust application, Miri will become your best friend. It helps catch those errors that the compiler will miss and regular tests won't cover, because they may only manifest under specific conditions or on certain platforms.

Miri in action: What problems does it find?

Miri doesn't just look for errors, it specifically identifies concrete types of undefined behavior that can undermine your application's stability. Here are just some of them:

• Memory access errors: This is a classic. Miri will detect if you go out of bounds of allocated memory (out-of-bounds access) or try to use memory after it has been freed (use-after-free). Familiar situation when the program crashes in the most unexpected places? Miri will help find the root of the problem.
• Incorrect use of uninitialized data: Trying to read data from memory that hasn't been initialized is a direct path to UB. Miri keeps a vigilant eye on this.
• Type invariant violations: Rust strictly monitors types, but in unsafe blocks you can violate even basic invariants, for example, create a bool that is not 0 or 1, or a enum with an invalid discriminant. Miri will catch this too.
• Memory alignment issues: Accessing memory with insufficient alignment can lead to failures on some architectures. Miri will check that all your pointers are aligned properly.
• Data races and weak memory model: Concurrency is hard. Miri can emulate some weak memory effects and detect data races that are extremely difficult to reproduce on real hardware. This is especially valuable for multithreaded applications.
• Memory leaks: At the end of program execution, Miri will check if there's any allocated memory that's no longer accessible. This is a great way to find leaks that can slowly but surely "eat" your server's resources.
• Experimental aliasing checks: Miri also includes experimental checks for Stacked Borrows and Tree Borrows rules, which help identify more subtle aliasing rule violations for reference types. These are cutting-edge research efforts that are already helping make Rust even safer.

How Miri does it: A deep dive into the interpreter

Unlike static analyzers, Miri doesn't just scan your code. It runs it in its own "sandbox" — as an interpreter for Rust's intermediate representation (MIR). This allows it to observe program behavior in real time and identify problems that only manifest during execution.

Deterministic execution: By default, Miri ensures fully deterministic execution. This means that if you run the program with the same input data, the result will always be identical. How is this achieved? Miri replaces many system APIs (for example, random number generators, environment variables, clocks) with its own "fake" implementations. This is critically important for reproducing and debugging bugs that might otherwise manifest randomly.

Cross-interpretation: Interestingly, Miri can run your code for different target platforms even if your host system is different. For example, you can run tests on Windows, but Miri will interpret them as if they were running on Linux (--target x86_64-unknown-linux-gnu). This is especially useful for testing platform-dependent code, for example, to verify the correctness of byte manipulations on little-endian and big-endian systems.

Getting started with Miri: Easier than it seems

Integrating Miri into your workflow is quite simple, especially if you already use rustup and cargo.

Installation

To install Miri you'll need a nightly version of Rust. Simply run:

rustup +nightly component add miri

Running tests and binaries

After installation you can run your projects through Miri using familiar cargo commands:

• To run all project tests through Miri: cargo miri test
• If you have a binary project, run it through Miri: cargo miri run

On first run, Miri will perform additional setup and install necessary dependencies, asking for your confirmation.

By the way, cargo miri run/test supports the same flags as regular cargo run/test. For example, cargo miri test filter will run only tests containing filter in the name.

Advanced features with Miri flags

You can pass special Miri flags through the MIRIFLAGS environment variable. For example, to disable isolation from the host system (and get access to real system APIs, but lose determinism):

RUST_BACKTRACE=1 MIRIFLAGS="-Zmiri-disable-isolation" cargo miri test

Or, to test various non-deterministic behavior scenarios (for example, different thread interleavings or allocation addresses):

MIRIFLAGS="-Zmiri-many-seeds=0..16" cargo miri test

This is a very powerful feature for identifying hard-to-catch bugs that only manifest under certain conditions.

CI/CD integration

Miri is great for automated checks in CI. Here's an example of how to set up a job for GitHub Actions:

  miri:
    name: "Miri"
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Install Miri
        run: |
          rustup toolchain install nightly --component miri
          rustup override set nightly
          cargo miri setup
      - name: Test with Miri
        run: cargo miri test

Ignoring tests incompatible with Miri

Sometimes your code may use APIs that Miri doesn't yet support (for example, network operations). In such cases, you can simply ignore these tests for Miri:

#[test]
#[cfg_attr(miri, ignore)]
fn does_not_work_on_miri() {
    // Ваш код, который Miri не поддерживает
}

Miri is already saving the world (and your code)

The most impressive thing about Miri is its proven effectiveness. It has already discovered many real bugs in the Rust standard library and popular crates. Among them were errors related to accessing uninitialized memory in VecDeque, incorrect alignment in Vec, memory leaks in BTreeMap, and even data races in std::mpsc channels. This is not just an academic tool, but a battle-tested helper that is actively used to improve the reliability of the Rust ecosystem.

Conclusions: Is Miri worth trying?

Absolutely! Miri is not a silver bullet, and it won't catch all possible Rust specification violations (because such a unified specification essentially doesn't exist). However, it is an indispensable tool for improving Rust code reliability, especially in unsafe sections and when working with concurrency.

If you take your Rust code quality seriously, want to minimize risks related to Undefined Behavior, and want to be confident in your applications' stability, Miri should be in your arsenal. It will help you find and fix those insidious bugs that may be hiding deep in your code, before they become a problem for your users. Try Miri, and you'll be surprised how much interesting stuff it can find in your seemingly perfect code!