rust-lang/miri

Miri is an interpreter for Rust MIR that detects undefined behavior in memory access, pointer provenance, and concurrency. It provides a comprehensive simulation environment with platform-specific shims for Unix, Windows, and Android, alongside support for native library FFI and architecture-specific intrinsics. The system includes a formal verification mode via GenMC for exhaustive concurrency testing, a standalone debugger named Priroda, and extensive benchmarking infrastructure to evaluate performance and correctness.

59 changes.

This period focused on expanding Miri's platform compatibility by implementing comprehensive shims for Windows, Linux, macOS, FreeBSD, and Android, alongside a major architectural refactor of the interpreter engine and cargo-miri tooling. Concurrently, the project significantly enhanced its undefined behavior detection capabilities by introducing the Tree Borrows aliasing model and adding extensive regression tests for concurrency, provenance, and system call interactions.

35 changes.

This period focused on maturing the Tree Borrows borrow checker through extensive testing, performance optimizations, and diagnostic improvements. It also significantly expanded platform support by adding shims for Solaris/Illumos and Linux-specific synchronization primitives, while enhancing intrinsic emulation and refining the internal testing and CI infrastructure.

38 changes.

This period focused on integrating the GenMC model checker for exhaustive concurrency verification and introducing the Priroda standalone debugger with CLI and DAP support. Significant work also included expanding intrinsic emulation for aarch64 and x86, implementing native library FFI tracing, and adding extensive test coverage for memory models and platform shims.

Miri now supports Android by introducing a dedicated shim layer that implements key POSIX functions including file operations (pread64, pwrite64, lseek64, ftruncate64), event handling (epoll\_create1, epoll\_ctl, epoll\_wait, eventfd), thread management (gettid, prctl), and dynamic syscall invocation. This enables accurate emulation of Android-specific system calls and library functions that were previously unsupported.

src/shims/unix/android · high confidence

Users can now interact with the Priroda interpreter via a command-line interface or the Debug Adapter Protocol (DAP). The CLI supports commands such as step, next, step-out, continue, setting breakpoints, and inspecting locals. The DAP frontend enables integration with external debuggers (e.g., VS Code) by exposing standard DAP requests like initialize, launch, setBreakpoints, threads, stackTrace, scopes, and variables, allowing for remote debugging sessions over stdin/stdout or TCP.

priroda/src/frontend · high confidence

Miri now supports running programs on FreeBSD by introducing a new shim layer in \src/shims/unix/freebsd\. This adds interceptors for key system calls including \pthread\_setname\_np\ and \pthread\_getname\_np\ for thread naming, \stat\, \lstat\, \fstat\, and \readdir\ for filesystem operations, and \cpuset\_getaffinity\ for CPU affinity. It also implements the \\_umtx\op\ syscall to support futex-based synchronization (WAIT/WAKE operations) and provides \\\error\ and \\\_xuname\ for error handling and system identification.

src/shims/unix/freebsd · high confidence

The genmc-sys crate now includes the build script and configuration files necessary to fetch, compile, and link the GenMC model checker. This change introduces a .clang-format file for C++ code consistency, a .gitignore to manage source downloads, and a build.rs script that clones the GenMC repository from GitHub, compiles it with CMake, and sets up the Rust-C++ bridge via cxx.rs.

genmc-sys · high confidence

Miri now supports running programs through the GenMC model checker to exhaustively verify concurrent behavior. This new mode intercepts atomic operations, thread creation/joining, and \std::sync::Mutex\ calls, mapping them to GenMC's execution model. Users can enable it via the \-Zmiri-genmc\ flag and configure options such as estimation mode (\-Zmiri-genmc-estimate\), execution graph printing, and log levels. The implementation enforces strict constraints: it requires 64-bit little-endian targets, disables borrow tracking and native libraries, and mandates data race detection. This provides a formal verification layer for concurrency bugs that standard Miri sampling might miss.

src/concurrency/genmc · high confidence

This change introduces the Linux-specific shim implementation layer, adding support for \mremap\ (with validation for page alignment and supported flags), 64-bit file operations (\open64\, \pread64\, \pwrite64\, \lseek64\, \ftruncate64\, \posix\_fallocate64\), \fallocate\/\fallocate64\, \readdir64\, \sync\_file\_range\, \statx\, epoll (\epoll\_create1\, \epoll\_ctl\, \epoll\_wait\), \eventfd\, and \pthread\_setname\_np\. These shims enable Miri to correctly emulate these Linux-specific system calls and library functions during interpretation.

src/shims/unix/linux · high confidence

This change introduces a new shim implementation for Solaris and Illumos targets (collectively referred to as Solarish). It adds support for key POSIX APIs including file system operations (stat, lstat), networking (socket, bind, connect, getaddrinfo, getsockopt, socketpair), threading (pthread\_setname\_np, pthread\_getname\_np), and system utilities (epoll, eventfd, stack\_getbounds, pset\_info). This enables Miri to interpret and run code targeting these operating systems.

src/shims/unix/solarish · high confidence

A new benchmark named big-allocs has been added to the bench-cargo-miri suite to serve as a regression test for Miri issue \#3637. This benchmark creates large uninit allocations (512 MB vectors) in a loop to verify that allocation strategies remain efficient and do not suffer from performance degradation due to unnecessary cloning or address space exhaustion.

bench-cargo-miri/big-allocs · high confidence

Miri now supports a broader range of macOS-specific system calls and synchronization primitives. This includes shims for \os\_unfair\_lock\ and macOS futex functions (\os\_sync\_wait\_on\_address\, \os\_sync\_wake\_by\_address\_any\, \os\_sync\_wake\_by\_address\_all\), which handle thread synchronization and waiting on memory addresses. File system operations such as \stat\, \lstat\, \fstat\, \opendir\, \readdir\, and \realpath\ are now intercepted and emulated. Additionally, system information and environment access via \\_NSGetExecutablePath\, \\_NSGetArgc\, \\_NSGetArgv\, \\_NSGetEnviron\, and time-related functions like \mach\_absolute\_time\ and \mach\_timebase\_info\ are supported, allowing macOS applications to run more accurately in the interpreter.

src/shims/unix/macos · high confidence

Added a new tracing subsystem for native-lib FFI calls, introducing a supervisor/child process model that uses IPC channels and ptrace to monitor memory accesses during FFI execution. The implementation includes child process management (child.rs), parent supervisor logic (parent.rs), IPC message definitions (messages.rs), and platform-specific stubs (stub.rs) for unsupported targets, enabling detailed memory event tracking for FFI interactions.

_src/shims/native\lib/trace · high confidence

Miri now supports generating Chrome trace files (viewable in Perfetto) when built with the new "tracing" feature and the MIRI\_TRACING environment variable is set. This change introduces a custom tracing layer that writes performance data to a JSON file, including frame spans on separate trace lines and accurate timing measurements. The feature is gated behind a build-time flag to avoid dependency conflicts with rustc's internal tracing libraries.

src/bin/log · high confidence

Miri now supports several Linux-specific system calls and synchronization primitives. The new \src/shims/unix/linux\_like\ module implements \epoll\_create1\ and \epoll\_ctl\ for managing file descriptor readiness events, \eventfd\ for inter-thread signaling, and the \futex\ syscall for low-level synchronization. Additionally, \prctl\ is supported for setting and getting thread names. These additions allow Miri to correctly interpret and execute programs that rely on these core Linux concurrency and I/O mechanisms.

_src/shims/unix/linux\like · high confidence

New benchmark programs have been added to the bench-cargo-miri suite: an MSE (Mean Squared Error) benchmark in bench-cargo-miri/mse that computes error metrics on static audio sample data, and a Serde benchmark in bench-cargo-miri/serde1 that measures JSON deserialization performance on a large embedded buffer.

bench-cargo-miri/mse · high confidence

A new benchmark program has been added to the bench-cargo-miri suite to exercise backtrace processing logic in Miri. The program, located at bench-cargo-miri/backtraces/src/main.rs, extracts frame information from the backtrace crate and formats it into a string, allowing for performance testing of backtrace resolution and symbol handling without emitting output to stdout/stderr.

bench-cargo-miri/backtraces · high confidence

A new benchmark entry (serde2) was added to the bench-cargo-miri suite that exercises serde's JSON deserialization under concurrent load. The benchmark spawns a second thread to deserialize the same large JSON payload simultaneously with the main thread, allowing measurement of performance and safety in a multi-threaded context.

bench-cargo-miri/serde2 · high confidence

A new benchmark has been added to the range-iteration suite that iterates over a range of 50,000 items. This workload is designed to generate significant activity for the AllocId component of the garbage collector, allowing for performance measurement of memory allocation and collection during range iteration.

bench-cargo-miri/range-iteration · high confidence

A new benchmark case named \zip-equal\ has been added to the \bench-cargo-miri\ suite. This benchmark implements a pathological pattern where adjacent identical items in a \RangeMap\ are not merged because \RangeMap::iter\_mut\ is not called on overlapping ranges. This specific scenario is designed to increase the cost of the Tree Borrows garbage collection procedure, addressing the issue described in rust-lang/miri\#2863.

bench-cargo-miri/zip-equal · high confidence

Miri now supports interpreting Windows-specific system calls, enabling the emulation of Windows applications on non-Windows hosts. This change introduces shims for core environment functions (GetEnvironmentVariableW, SetEnvironmentVariableW, GetCurrentDirectoryW), file system operations (CreateFileW, DeleteFileW, MoveFileExW), and thread management (CreateThread, WaitForSingleObject). It also implements synchronization primitives using futexes (mutexes, condition variables, SRWLocks) and one-time initialization (InitOnce), along with a structured Handle representation to manage pseudo-handles and file descriptors consistently.

src/shims/windows · high confidence

This change establishes the foundational structure for the Miri project, introducing essential configuration files for code formatting (rustfmt.toml, clippy.toml), editor consistency (.editorconfig), and repository attributes (.gitattributes). It adds the MIT and Apache-2.0 license files, a .gitignore for build artifacts and IDE directories, and a triagebot configuration to automate issue labeling and review workflows. Development ergonomics are improved with a new \./miri\ wrapper script (and Windows equivalent \miri.bat\) to simplify building and running the tool, alongside a \.gitpod.yml\ for cloud-based development environments. The commit also includes initial documentation in CONTRIBUTING.md and README.md, and sets the required Rust nightly version in rust-version.

(repo-wide) · high confidence

Added a new C++ layer (\MiriInterface.hpp\, \Exploration.cpp\, \Setup.cpp\) that bridges Miri and the GenMC model checker. This interface allows Miri to intercept and handle atomic and non-atomic memory accesses, thread creation/joining, mutex locking, and memory allocation, translating these operations into GenMC events for verification. It supports both standard verification and estimation modes, configures the RC11/SC memory models, and exposes scheduling and execution graph printing options to users.

genmc-sys/cpp · high confidence

The new \genmc-sys/src/lib.rs\ file establishes the Rust bindings for the GenMC model checker, introducing types such as \GenmcHandlerResult\, \CasOutcome\, \MutexLockOutcome\, and \RmwOutcome\ to handle atomic operations, memory allocation, and synchronization. This change adds the foundational API for running Miri with GenMC, including support for atomic load/store, compare-exchange, read-modify-write, mutex interception, and thread scheduling, while also renaming internal fields like \extra\ to \provenance\ to better reflect memory semantics.

genmc-sys/src · high confidence

This change introduces the Priroda debugger as a new standalone CLI crate. It provides a debugger frontend that can operate in two modes: a default command-line interface (CLI) and a Debug Adapter Protocol (DAP) server mode, selectable via the \--dap\ and \--port\ flags. The core debugger logic, including source-level stepping, breakpoint management, and variable inspection, is implemented in \debugger.rs\, while \main.rs\ handles argument parsing and initializes the Miri interpreter session.

priroda/src · high confidence

Added a dedicated \IsolatedAlloc\ allocator for interpreter memory in native-lib mode, which uses \mmap\ to store allocations on dedicated pages separate from Miri's own memory. This is exposed via the new \MiriAllocBytes\ type and \MiriAllocParams\ enum, allowing the system to distinguish between global and isolated allocation backends while maintaining compatibility through a stub implementation when the native-lib feature is disabled.

src/alloc · high confidence

The concurrency engine has been significantly restructured to improve data race detection accuracy and add support for the GenMC model checker. A new Blocking I/O manager has been introduced to handle non-blocking host I/O events using \mio\, allowing Miri to properly simulate asynchronous operations. The data race detector has been updated to better model the C++20 memory model, specifically regarding release sequences and sequential consistency fences, and now distinguishes between retags and real memory accesses. Additionally, a new GenMC mode has been implemented, enabling Miri to explore different concurrent executions by taking over scheduling and atomic operation semantics, with support for atomic fences, read-modify-write operations, and \assume\ statements.

src/concurrency · high confidence

The \src/bin/miri.rs\ file has been introduced to serve as the main entry point for the Miri interpreter. This change establishes the core driver logic, including the initialization of logging, the setup of a custom codegen backend that delegates to the dummy backend while respecting target features, and the registration of extra symbols. It introduces support for running multiple test seeds in parallel via a new \ManySeedsConfig\ structure and integrates with GenMC mode for non-deterministic concurrency testing. The binary now enforces that it only runs on executable crates, emits warnings for unsupported optimization levels, and handles entry point detection and configuration passing to the underlying evaluation engine.

src/bin · high confidence

A new \src/data\_structures\ module has been introduced, consolidating three specialized data structures: \DedupRangeMap\ for mapping integer indices to data via coalescible ranges, \MonoHashMap\ for thread-safe, shared-reference hash maps tailored for memory evaluation, and \RangeObjectMap\ for managing discrete, non-splittable allocation ranges. These components provide the foundational storage primitives for the evaluator's memory management system.

_src/data\structures · high confidence

The \miri-script\ tool has been rewritten in Rust, replacing the previous implementation. This introduces a new CLI structure with explicit commands for installing, building, checking, running, testing, documenting, formatting, and benchmarking Miri, as well as managing the Rust toolchain and squashing commits. Configuration is now centralized in \miri.toml\ (with fallback to legacy \.auto-\*\ files) to control toolchain settings and automatic actions like formatting and clippy. New capabilities include generating code coverage reports via \./miri test --coverage\, running benchmarks with baseline comparisons, and running tests natively on the host with \./miri run --native\.

miri-script · high confidence

Users can now invoke functions from external native shared libraries (e.g., .so files) directly from Miri-interpreted code. This new capability, implemented in \src/shims/native\_lib\, allows passing arguments and receiving return values for supported types (including structs, enums, and floats) via FFI. It also includes optional tracing of memory accesses during these native calls, enabling detection of out-of-bounds or invalid memory operations performed by the native code.

_src/shims/native\lib · high confidence

Miri now emulates intrinsics for several x86 instruction set extensions, including AES-NI (encryption/decryption rounds, key generation), AVX and AVX2 (float min/max, rounding, gather/scatter, shuffles), AVX-512 (ternary logic, permutations, packing), BMI1/BMI2 (bit extraction/deposit), and GFNI (Galois field multiplication). This allows Miri to correctly interpret and execute code using these SIMD and cryptographic instructions during simulation.

src/intrinsics/x86 · high confidence

A change to existing behaviour in src — 1825 commits (136 fixs), 12 files.

src · medium confidence · unverified

A new benchmark program has been added to the bench-cargo-miri suite that exercises the unicode-xid library. To prevent the benchmark from taking excessive time (previously up to 20 seconds), the implementation now processes only the first 1,500 valid Unicode characters instead of iterating through the entire valid range.

bench-cargo-miri/unicode · high confidence

The cargo-miri build process now uses the rustc\_tools\_util crate to gather version information, replacing the previous method. This change ensures that the build system only rebuilds when necessary and provides a more standardized way to include version details in the binary.

cargo-miri · high confidence

The borrow tracking subsystem has been significantly expanded to support the new Tree Borrows model alongside the existing Stacked Borrows implementation. This change introduces a modular architecture with dedicated modules for each strategy, allowing users to select their preferred aliasing model. Key additions include a unified \BorTag\ system for pointer provenance, support for tracking specific pointer IDs for diagnostics, and the implementation of a Provenance Garbage Collector to manage tag lifecycle. The diff also reveals internal refactoring such as the removal of the \Call ID\ concept, the adoption of Rust's \tracing\ crate for logging, and stricter handling of protected tags to prevent incorrect garbage collection, ensuring more accurate detection of undefined behavior related to pointer aliasing and memory access.

_src/borrow\tracker · high confidence

This change refactors the Unix shim layer to support a broader range of operating systems (including NetBSD, FreeBSD, Solaris, and Android) and introduces extensive new functionality. Key additions include shims for the \poll\ system call, file locking (\flock\), and environment variable management (\getenv\, \setenv\, \unsetenv\). The file descriptor handling has been restructured with a new \UnixFileDescription\ trait and improved socket support (including \socket\, \bind\, \listen\, \accept\, \connect\, \send\, \recv\, and \shutdown\). The diff also includes significant internal refactoring of the interpreter's file description and synchronization primitives to improve correctness and maintainability across different Unix-like platforms.

src/shims/unix · high confidence

This release introduces a comprehensive architectural overhaul of the Miri interpreter's internal shims and core engine. The changes include a complete reorganization of the shim module structure, splitting platform-specific code into dedicated submodules (e.g., \shims::unix\, \shims::windows\, \shims::fs\). Key behavioral updates involve the introduction of a new \EnvVars\ abstraction for environment variable handling, a refactored file description system (\FileDescriptionRef\) with improved reference counting and ID tracking, and the addition of support for global constructors via \GlobalCtorState\. The interpreter engine itself has been updated with a new \InterpCx\ type, refined error handling via a dedicated \IoError\ enum, and improved support for weak symbols and extern statics. These changes lay the groundwork for better platform support, including enhanced Windows and macOS compatibility, and improved concurrency primitives.

src/shims · high confidence

Miri's intrinsic emulation engine has been significantly expanded to support previously unimplemented operations, improving the accuracy of its simulation for real-world code. This update adds support for AArch64 NEON intrinsics (including vector table lookups, pairwise additions, and saturating multiply-high), LoongArch CRC32 instructions, and various SIMD floating-point operations (square root, sine, cosine, exponential, and logarithmic functions). Additionally, it introduces emulation for fast-path floating-point operations (fadd\_fast, fmul\_fast, etc.) with controlled non-determinism to simulate precision loss, and exposes algebraic floating-point intrinsics for more precise modeling of compiler optimizations.

src/intrinsics · high confidence

The CI system now includes a new \build-all-targets.sh\ script that automatically scrapes Rust's platform support documentation to identify Tier 2 targets (with and without host tools) and verifies that their sysroots build successfully, reporting failures in a dedicated directory. The main \ci.sh\ script has been restructured to support a wider variety of host architectures (including 32-bit x86, ARM, and AArch64) and runs a more comprehensive test suite across these hosts, including many-seeds concurrency tests, optimization checks, and benchmarks. A new \scrape-targets.py\ utility parses the Rust platform support HTML to dynamically determine which targets require sysroot verification.

ci · high confidence

The logic for managing memory allocation addresses has been extracted from the main allocator into a new \src/alloc\_addresses\ module, introducing an \AddressGenerator\ struct for generating unique addresses and a \ReusePool\ for handling address reuse. This change introduces configurable address reuse rates (\address\_reuse\_rate\ and \address\_reuse\_cross\_thread\_rate\) and enforces that reused addresses match the original allocation's size and alignment to better simulate real-world memory behavior and trigger potential bugs like ABA issues. The refactoring also supports GenMC mode by allowing address generation to be delegated to the GenMC context when active, and ensures that reusing an address from a different thread establishes a happens-before link in the data race model.

_src/alloc\addresses · high confidence

The Stacked Borrows implementation has been reorganized into a new \src/borrow\_tracker/stacked\_borrows\ directory, splitting the code into \mod.rs\ (core permission and retagging logic), \item.rs\ (packed borrow stack items), \stack.rs\ (stack management and caching), and \diagnostics.rs\ (error reporting and history tracking). This change refactors how Miri tracks and reports borrow violations, improving the structure of the diagnostic output for users encountering undefined behavior related to pointer aliasing.

_src/borrow\_tracker/stacked\borrows · high confidence

The Tree Borrows borrow tracker now includes a dedicated diagnostics module that records detailed access history (including explicit accesses, reborrow events, and deallocations) to generate precise error messages for aliasing violations. Additionally, a new tree visitor implementation enables piecewise bottom-up traversal of the borrow tree, and an optimization based on Strongest Idempotent Foreign Access (SIFA) allows the tracker to skip redundant subtree traversals during foreign accesses, improving performance.

_src/borrow\_tracker/tree\borrows · high confidence

The cargo-miri tool has been restructured from a single monolithic file into a modular codebase (arg.rs, main.rs, phases.rs, setup.rs, util.rs) that explicitly separates the build process into distinct phases: setup, cargo dispatch, rustc compilation, rustdoc handling, and binary execution. This refactoring introduces a new 'clean' subcommand to remove the Miri cache and target directory, improves error reporting for common misconfigurations (such as missing RUSTC or running inside bootstrap), and refines environment variable handling to only preserve those actually set by cargo, reducing noise and potential security issues. The change also updates the sysroot build to use rustc-build-sysroot instead of xargo and ensures doctests are properly supported through dedicated rustdoc phases.

cargo-miri/src · high confidence

Add Miri tests for two-phase borrows and aliasing models; Add extensive Miri regression and feature tests; Add no-std smoke test for cargo-miri; Add regression test for issue \#1567; Add subcrate test to verify workspace CWD and dev-dependencies; Add test harness for cargo-miri integration; Added C test library for Miri FFI validation; Added DAP attach and unknown-command test fixtures; Added GenMC data-race regression tests for atomic pointers and weak orderings; Added GenMC failure tests for loom smoke and litmus cases; Added GenMC failure tests for weak memory models and resource exhaustion; Added GenMC litmus test suite for atomic memory models; Added GenMC tests for mutex and exit behavior; Added GenMC verification tests for atomic operations and concurrent data structures; Added GenMC verification tests for atomic pointer safety; Added GenMC verification tests for standard library concurrency primitives; Added GenMC verification tests for std::sync::Mutex and spinloop bounding; Added Miri concurrency tests for mutex deadlock and read-only atomic access; Added Miri regression tests for async shared mutability and various UB scenarios; Added Miri test for file isolation errors; Added Miri tests for Tree Borrows aliasing and deallocation rules; Added Miri tests for allocation error handling and invalid deallocation; Added Miri tests for function pointer ABI mismatches and invalid calls; Added Miri tests for libc filesystem and I/O operations; Added Miri tests for match and closure capture UB; Added Miri tests for native library FFI interactions; Added Miri tests for panic and unwind edge cases; Added Miri tests for tail-call safety checks; Added Miri tests for thread-local storage behavior and Windows FLS support; Added Miri tests for uninitialized padding bytes; Added Priroda CLI integration tests; Added Tree Borrows implicit-writes failure tests; Added Tree Borrows tests for protected Reserved tags; Added backtrace capture tests; Added benchmark for slice-chunked Tree Borrows performance; Added benchmark for slice-get-unchecked hang scenario; Added concurrency regression and regression tests; Added concurrency tests for platform-specific synchronization primitives; Added concurrency tests for pthread and macOS lock primitives; Added data race detection tests for Miri; Added fail-shim tests for constructor UB, ABI mismatches, and variadic signatures; Added integration tests for Tokio runtime support; Added panic handling tests for Miri; Added pass tests for aarch64 AES, CRC32, NEON, and SHA256 intrinsics; Added proc-macro test crate to verify Miri configuration isolation; Added regression and dependency tests for Miri; Added regression test for cross-crate async closure handling; Added regression tests for Miri and compiler issues; Added regression tests for thread-local and reentrant lock issues; Added stacked-borrows tests for coroutines, stack printing, and edge cases; Added string-replace benchmark to evaluate subtree skipping effectiveness; Added test crate for exported symbols and static constructors; Added test for DuplicateHandle on pseudo handles; Added test for local crate detection; Added test for panic handling in exported symbols with good unwind; Added test for thread-local static deallocation; Added test for weak memory uninitialized access; Added test infrastructure for native libraries and kernel targets; Added tests for FreeBSD cpuset affinity, cross-platform thread ID retrieval, and Windows file system shims; Added tests for LoongArch CRC intrinsics; Added tests for environment variable shims; Added tests for extern static validation and error reporting; Added tests for function call ABI compatibility and edge cases; Added tests for invalid backtrace shim flags and declarations; Added tests for native library FFI error handling; Added tests for native-lib tracing edge cases; Added tests for panic handling and Miri validation; Added tests for wildcard provenance in Tree Borrows; Added tests for wildcard provenance support in tree borrows; Added x86 intrinsic tests for SHA, ADX, AES, AVX, AVX2, AVX-512, BMI, GFNI, PCLMULQDQ, and SSE; Exhaustive testing for Tree Borrows permission logic; Expanded Miri test coverage for intrinsic Undefined Behavior; Expanded Miri validity checks for references, boxes, and function pointers; Expanded UI test coverage for Priroda debugger commands and DAP protocol; Expanded libc test coverage for epoll, eventfd, and file operations; Expanded libc validation tests for Miri; Expanded shim test coverage for filesystem, networking, and system APIs; Expanded test coverage for SIMD, integer, and miscellaneous intrinsics; Expanded test coverage for cargo-miri execution scenarios; Expanded weak memory emulation tests for consistency and C++20 semantics; Initial test suite for cargo-miri integration; Miri Tree Borrows: expanded test coverage for implicit writes, interior mutability, and concurrency; Miri adds comprehensive tests for unaligned pointer detection; Miri adds tests for function call argument aliasing and ABI checks; Miri: Added provenance fail tests for pointer validity and strict provenance; Miri: Added tests for dangling pointer detection; New test utility modules for Miri integration testing; Regression test for \#\[no\_mangle\] on use items and structs; Removed obsolete test file; Stacked Borrows tests updated for new pointer and retag rules.

The Miri project, along with its tooling (cargo-miri, miri-script, priroda, genmc-sys), has been updated to the Rust 2024 edition. This change is accompanied by a broad update of dependencies across the workspace, including major bumps to cargo\_metadata (0.23), directories (6), and libc (0.2.189), as well as the addition of new benchmark crates for backtraces, big allocations, and serialization performance.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 67 → 66 (-1.4)
• Rubric changed (rubric-2026.09.9 → rubric-2026.09.18) — scores are not directly comparable.

• Code Health 76 → 76 (+0.3)
• Architecture 100 → 99 (-0.7)
• Maturity 60 → 59 (-0.2)
• Readiness 64 → 59 (-5.4)
• Security 74 → 81 (+6.5)
• Event Sourcing 100 → 100 (+0.0)

• Documentation: no installation or build instructions (README.md)
• Duplicated block (10 lines × 2) (src/shims/unix/foreign_items.rs)
• Duplicated block (14 lines × 2) (src/shims/unix/foreign_items.rs)
• Duplicated block (18–24 lines × 2) (src/shims/unix/freebsd/foreign_items.rs)
• Duplicated block (6 lines × 8) (src/intrinsics/aarch64.rs)
• Duplicated block (7 lines × 2) (src/shims/unix/thread.rs)
• Duplicated block (7 lines × 7) (src/intrinsics/x86/avx.rs)
• Duplicated block (9 lines × 2) (src/shims/unix/tcp_socket.rs)
• Duplicated block (9–10 lines × 2) (src/shims/unix/tcp_socket.rs)
• FixmeComment (src/shims/unix/fs.rs)
• FixmeComment (src/shims/unix/tcp_socket.rs)
• Hotspot: miri-script/src/commands.rs (miri-script/src/commands.rs)
• Hotspot: src/bin/miri.rs (src/bin/miri.rs)
• Hotspot: src/borrow_tracker/stacked_borrows/mod.rs (src/borrow_tracker/stacked_borrows/mod.rs)
• Hotspot: src/borrow_tracker/tree_borrows/mod.rs (src/borrow_tracker/tree_borrows/mod.rs)
• Hotspot: src/concurrency/data_race.rs (src/concurrency/data_race.rs)
• Hotspot: src/math.rs (src/math.rs)
• Hotspot: src/shims/math.rs (src/shims/math.rs)
• Hotspot: src/shims/native_lib/mod.rs (src/shims/native_lib/mod.rs)
• Members sharing a duplicated core (15 members, 50+ identical tokens) (src/intrinsics/aarch64.rs)
• …and 6 more

• Documentation: no contributor guidance (README.md)
• Duplicated block (10 lines × 2) (src/shims/unix/tcp_socket.rs)
• Duplicated block (11 lines × 2) (src/shims/cpu_affinity.rs)
• Duplicated block (19 lines × 2) (src/shims/unix/tcp_socket.rs)
• Duplicated block (25 lines × 2) (src/intrinsics/x86/mod.rs)
• Duplicated block (5 lines × 2) (src/shims/unix/thread.rs)
• Duplicated block (6 lines × 2) (src/shims/unix/foreign_items.rs)
• Duplicated block (6 lines × 9) (src/intrinsics/aarch64.rs)
• Duplicated block (7 lines × 2) (src/shims/cpu_affinity.rs)
• Duplicated block (7 lines × 8) (src/intrinsics/x86/avx.rs)
• Duplicated block (9 lines × 2) (src/shims/unix/thread.rs)
• FixmeComment (src/shims/unix/fs.rs)
• FixmeComment (src/shims/unix/fs.rs)
• FixmeComment (src/shims/unix/tcp_socket.rs)
• FixmeComment (src/shims/unix/tcp_socket.rs)
• FixmeComment (src/shims/unix/tcp_socket.rs)
• FixmeComment (src/shims/unix/tcp_socket.rs)
• FixmeComment (tests/pass-dep/shims/windows-fs.rs)
• FixmeComment (tests/pass/shims/available-parallelism-miri-num-cpus.rs)
• Hotspot: src/shims/windows/fs.rs (src/shims/windows/fs.rs)
• …and 21 more

• 286 commits — 257 feature/other, 29 fixes

• (repo) — 225 commits
• src/shims — 14 commits
• (root) — 11 commits
• tests/pass-dep — 7 commits
• tests/fail — 4 commits
• tests/pass — 4 commits
• cargo-miri/src — 3 commits
• src/bin — 3 commits
• miri-script/src — 2 commits
• src/diagnostics.rs — 2 commits
• tests/panic — 2 commits
• etc/rust_analyzer_helix.toml — 1 commit
• etc/rust_analyzer_vscode.json — 1 commit
• etc/rust_analyzer_zed.json — 1 commit
• src/borrow_tracker — 1 commit
• src/intrinsics — 1 commit
• src/lib.rs — 1 commit
• src/machine.rs — 1 commit
• test-cargo-miri/src — 1 commit
• tests/fail-dep — 1 commit

• fix: Adjust bug!/span_bug! emission
• fix: Auto merge of #162573 - erickt:fix-fuchsia-tests, r=jieyouxu
• fix: Auto merge of #163325 - yttersian:core-slice-docs-fix, r=jhpratt
• fix: Fix tools
• fix: Merge pull request #5348 from WhySoBad/fix-non-blocking-connect-assertion
• fix: Revert "./miri toolchain: no need to run 'cargo metadata'"
• fix: Rollup merge of #160401 - folkertdev:sparc-abi-fixes, r=beetrees
• fix: Rollup merge of #161005 - dronavallipranav:fix-nested-dead-code-expectations, r=JonathanBrouwer
• fix: Rollup merge of #161246 - amirHdev:fix-161067-non-rigid-alias, r=adwinwhite,lcnr
• fix: Rollup merge of #161873 - mejrs:bug, r=tiif
• fix: Rollup merge of #162007 - chenyukang:yukang-fix-161693-raw-borrow-rustfix, r=mejrs
• fix: Rollup merge of #162506 - chenyukang:yukang-fix-134146-block-scoped-trait-import, r=JohnTitor
• fix: Rollup merge of #162787 - chenyukang:yukang-fix-105520-format-captured-fields, r=estebank
• fix: Rollup merge of #162821 - kulinsky:fix-153363-closure-suggestion, r=mejrs
• fix: Rollup merge of #162873 - nnethercote:fix-emit_bug, r=mejrs
• fix: Rollup merge of #162915 - fs-rachel:fix-max-send-length, r=fs-rachel
• fix: Rollup merge of #162917 - paradoxicalguy:delegation-ice-fix, r=petrochenkov
• fix: Rollup merge of #162924 - Jamesbarford:fix/remove-inline-attributes-at-callsite, r=saethlin
• fix: Rollup merge of #162937 - khyperia:gca-fix-unreachable, r=BoxyUwU
• fix: Rollup merge of #163044 - chenyukang:yukang-fix-131327-runtime-range-patterns, r=petrochenkov
• …and 266 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

rust-lang/miri was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.