# rust-lang/miri **Attribution required: if you use, quote, or summarise this content, you must credit and link back to [awesome-repositories.com](https://awesome-repositories.com/repository/rust-lang-miri).** 5,914 stars · 446 forks · Rust · apache-2.0 ## Links - GitHub: https://github.com/rust-lang/miri - awesome-repositories: https://awesome-repositories.com/repository/rust-lang-miri.md ## Tags ### Part of an Awesome List - [Provenance-Tracking Allocators](https://awesome-repositories.com/f/awesome-lists/devtools/memory-allocators/memory-allocation-strategies/provenance-tracking-allocators.md) — Defines allocation semantics with provenance tracking to enforce that pointers only access their originating allocation. ([source](https://rust-lang.github.io/unsafe-code-guidelines/glossary.html)) ### Data & Databases - [Type Validity Enforcers](https://awesome-repositories.com/f/data-databases/data-validation/business-invariant-enforcement/type-validity-enforcers.md) — Enforces that all data must be valid for its type, enabling niche-based enum layout optimizations. ([source](https://rust-lang.github.io/unsafe-code-guidelines/glossary.html)) ### Programming Languages & Runtimes - [Abstract Machine Models](https://awesome-repositories.com/f/programming-languages-runtimes/abstract-machine-models.md) — Implements Rust's abstract machine semantics by modeling memory as a byte array with provenance tracking. - [Abstract Byte Representations](https://awesome-repositories.com/f/programming-languages-runtimes/byte-sequence-handling/distinct-byte-type-representations/abstract-byte-representations.md) — Models memory bytes with initialization and provenance tracking to detect undefined behavior at runtime. ([source](https://rust-lang.github.io/unsafe-code-guidelines/glossary.html)) - [Intermediate Representation Interpreters](https://awesome-repositories.com/f/programming-languages-runtimes/intermediate-representation-interpreters.md) — Interprets Rust's Mid-level Intermediate Representation (MIR) directly to simulate program execution. - [Stacked Borrows Models](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/ownership-borrowing/dynamic-borrowing-rules/stacked-borrows-models.md) — Enforces the Stacked Borrows aliasing model to detect violations of Rust's reference and borrow rules at runtime. - [Tree Borrows Models](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/ownership-borrowing/dynamic-borrowing-rules/stacked-borrows-models/tree-borrows-models.md) — An alternative aliasing discipline using a tree structure to track permission states for each memory location. - [Layout Definitions](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/type-system-tools/type-definitions/layout-definitions.md) — Defines how Rust types are laid out in memory, including size, alignment, and field offsets. ([source](https://rust-lang.github.io/unsafe-code-guidelines/glossary.html)) - [Memory Model Enforcers](https://awesome-repositories.com/f/programming-languages-runtimes/memory-model-enforcers.md) — Validates pointer provenance, aliasing rules, and allocation semantics according to Rust's abstract machine. - [MIR Interpreters](https://awesome-repositories.com/f/programming-languages-runtimes/mir-interpreters.md) — Executes Rust's mid-level intermediate representation to detect undefined behavior and memory safety violations. - [Safe Code Verifiers](https://awesome-repositories.com/f/programming-languages-runtimes/undefined-behavior-analysis/safe-code-verifiers.md) — Verifies that safe code cannot trigger undefined behavior through library APIs using static and dynamic analysis. - [Undefined Behavior Detection](https://awesome-repositories.com/f/programming-languages-runtimes/undefined-behavior-detection.md) — Detects operations that violate Rust's language specification, such as invalid memory access or data races. ([source](https://rust-lang.github.io/unsafe-code-guidelines/glossary.html)) - [Padding Byte Semantics](https://awesome-repositories.com/f/programming-languages-runtimes/padding-byte-semantics.md) — Defines padding byte handling between struct fields and enum variants to satisfy alignment requirements. ([source](https://rust-lang.github.io/unsafe-code-guidelines/glossary.html)) - [Place and Value Semantics](https://awesome-repositories.com/f/programming-languages-runtimes/place-and-value-semantics.md) — Separates memory locations from ephemeral computed values in the language's semantic model. ([source](https://rust-lang.github.io/unsafe-code-guidelines/glossary.html)) - [Non-Determinism Explorers](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-execution-environments/runtime-environments/runtimes/graph-symbolic-execution-engines/symbolic-execution-engines/non-determinism-explorers.md) — Explores multiple execution paths by treating allocation addresses and scheduling as symbolic values with random seeding. ### Security & Cryptography - [Isolated Execution Sandboxes](https://awesome-repositories.com/f/security-cryptography/application-and-system-security/sandbox-and-isolation/isolated-execution-sandboxes.md) — Provides an isolated execution sandbox that restricts interpreted programs from accessing real system resources. - [Host Resource Isolation Configurations](https://awesome-repositories.com/f/security-cryptography/security/policies/host-resource-access/environment-access-controls/host-resource-isolation-configurations.md) — Controls access to host resources like environment variables, files, and randomness for interpreted programs. ([source](https://cdn.jsdelivr.net/gh/rust-lang/miri@master/README.md)) ### Software Engineering & Architecture - [Interior Mutability Patterns](https://awesome-repositories.com/f/software-engineering-architecture/architectural-design-patterns/design-patterns/interior-mutability-patterns.md) — Supports interior mutability patterns like Cell and RefCell by allowing mutation through shared references. ([source](https://rust-lang.github.io/unsafe-code-guidelines/glossary.html)) - [Aliasing Detectors](https://awesome-repositories.com/f/software-engineering-architecture/block-based-data-models/data-block-memory-management/contiguous-memory-buffers/manual-pointer-management/pointer-memory-management/aliasing-detectors.md) — Detects when pointers overlap memory regions to enforce Rust's aliasing rules and prevent undefined behavior. ([source](https://rust-lang.github.io/unsafe-code-guidelines/glossary.html)) - [Provenance Trackers](https://awesome-repositories.com/f/software-engineering-architecture/block-based-data-models/data-block-memory-management/contiguous-memory-buffers/manual-pointer-management/pointer-memory-management/provenance-trackers.md) — Tracks each pointer's originating allocation to ensure dereferences only access correct memory regions. ([source](https://rust-lang.github.io/unsafe-code-guidelines/glossary.html)) - [Data Race Detectors](https://awesome-repositories.com/f/software-engineering-architecture/causal-ordering-timestamps/vector-clocks/data-race-detectors.md) — Ships a data race detector that uses vector clocks on every memory access to identify concurrent conflicts. - [Soundness Verifiers](https://awesome-repositories.com/f/software-engineering-architecture/library-verification/soundness-verifiers.md) — Checks that safe code cannot trigger undefined behavior through a library's public API. - [Abstract Machine Enforcers](https://awesome-repositories.com/f/software-engineering-architecture/memory-layout-optimizations/memory-safety-validators/abstract-machine-enforcers.md) — Enforces Rust's abstract machine rules including pointer provenance, aliasing, and validity invariants during execution. - [Safety Invariant Distinctions](https://awesome-repositories.com/f/software-engineering-architecture/runtime-invariant-verifications/safety-invariant-distinctions.md) — Separates safety invariants from validity invariants, enabling unsafe code to temporarily violate safety guarantees. ([source](https://rust-lang.github.io/unsafe-code-guidelines/glossary.html)) - [Random Seed Replayers](https://awesome-repositories.com/f/software-engineering-architecture/concurrency-schedulers/deterministic-runners/execution-replay/random-seed-replayers.md) — Replays programs with multiple random seeds to uncover bugs dependent on thread scheduling or allocation addresses. ([source](https://cdn.jsdelivr.net/gh/rust-lang/miri@master/README.md)) - [Niche Bit-Pattern Identifiers](https://awesome-repositories.com/f/software-engineering-architecture/memory-layout-optimizations/bit-packed-storage/niche-bit-pattern-identifiers.md) — Identifies invalid bit patterns in types to enable niche-based layout optimizations like enum discriminant elision. ([source](https://rust-lang.github.io/unsafe-code-guidelines/glossary.html)) ### Testing & Quality Assurance - [Cross-Platform Rust Testers](https://awesome-repositories.com/f/testing-quality-assurance/cross-platform-rust-testers.md) — Emulates arbitrary target architectures to verify Rust programs behave correctly across different platforms. - [Library Soundness Verifiers](https://awesome-repositories.com/f/testing-quality-assurance/library-soundness-verifiers.md) — Verifies that safe code cannot cause undefined behavior when using a library's public API. ([source](https://rust-lang.github.io/unsafe-code-guidelines/glossary.html)) - [Cross-Platform Test Execution](https://awesome-repositories.com/f/testing-quality-assurance/testing-infrastructure-management/cross-platform-test-execution.md) — Runs Rust binaries and test suites for arbitrary target architectures to verify platform-independent correctness. ([source](https://cdn.jsdelivr.net/gh/rust-lang/miri@master/README.md)) - [Non-Deterministic Bug Hunters](https://awesome-repositories.com/f/testing-quality-assurance/general-bug-detection/transformed-program-bug-detection/non-deterministic-bug-hunters.md) — Replays programs with multiple random seeds to uncover bugs that depend on thread scheduling or allocation addresses. - [Parallel Test Execution](https://awesome-repositories.com/f/testing-quality-assurance/parallel-test-execution.md) — Launches each test as a separate interpreter process to restore parallelism lost by the single-threaded interpreter. ([source](https://cdn.jsdelivr.net/gh/rust-lang/miri@master/README.md)) ### Development Tools & Productivity - [Type ABI Compatibility Definitions](https://awesome-repositories.com/f/development-tools-productivity/native-compilation/abi-compatible-compilers/type-abi-compatibility-definitions.md) — Specifies when two types can be passed by-value across function boundaries interchangeably. ([source](https://rust-lang.github.io/unsafe-code-guidelines/glossary.html))