Blog
November 20, 2026
MISRA C:2025 Addendum 6 and Rust: What It Means for Safety-Critical Code
Coding Best Practices,
Security & Compliance
MISRA C:2025 Addendum 6: “Applicability of MISRA C:2025 to the Rust Programming Language” was published in March 2025. It assesses which MISRA C:2025 guidelines are relevant to the Rust programming language and whether they apply to safe Rust or to the broader Rust language, including capabilities associated with unsafe Rust and FFI.
Of the 223 MISRA C guidelines assessed:
- 36% apply to both safe and unsafe Rust, wholly or in part.
- 22% apply only to unsafe Rust and FFI.
- 42% do not apply to Rust.
While the addendum is not a Rust coding standard, and it does not make a Rust project MISRA compliant, it does offer a useful starting point for understanding which established MISRA C guidelines may also be relevant to Rust. The challenge then becomes putting that mapping into practice:
Once you know which MISRA C guidelines are relevant to Rust, how do you check your code against them?
In this blog, we'll explore the difference between safe and unsafe Rust, why memory-safe code still needs a coding guideline, what Addendum 6 found, and how static analysis can help check Rust code against these guidelines.
“Working in Rust and C/C++? See how Perforce QAC and Klocwork analyze both languages in one workflow.”
Back to top
What is the Difference Between Safe Rust and Unsafe Rust?
Before understanding how MISRA guidelines apply to Rust code, let's clarify the types of code at play. Not all Rust code carries the same risk profile. Rust distinguishes between:
- Safe Rust: Rust code without
unsafeblocks or external (extern) interfaces. The compiler enforces Rust’s safety rules and developers cannot perform certain operations that could violate memory safety. - Unsafe Rust: Code marked
unsafemeans the developer rather than the compiler must uphold safety guarantees. These capabilities may be necessary for low-level hardware access, performance-critical operations, or interoperability with existing software. - Foreign Function Interface (FFI): The mechanism Rust uses to interact with code outside Rust, such as existing C/C++ software. Because Rust cannot enforce its safety guarantees over external code, FFI introduces additional considerations beyond those of code operating entirely within safe Rust.
Addendum 6 assesses applicability differently depending on whether a guideline relates to safe Rust or to capabilities available in the broader Rust language, including unsafe Rust and FFI.
Back to top
Why Does Rust Still Need Coding Guidelines?
Rust prevents many memory-safety defects, but memory safety does not eliminate every source of unpredictable software behavior. Rust still contains unspecified and implementation-defined aspects of the language that safety-critical teams need to understand and control.
Coding guidelines such as MISRA help identify and restrict these behaviors, particularly when software uses unsafe Rust or interfaces with C through FFI. Static analysis can then identify violations and provide evidence that the guidelines have been consistently applied throughout development.
Is There a MISRA Coding Standard for Rust?
Not currently. And without one, the question becomes “Which established MISRA guidelines can you apply to Rust?” That's where MISRA C:2025 Addendum 6 comes in.
Back to top
What Does MISRA C:2025 Addendum 6 Tell Us About Rust?
MISRA C:2025 Addendum 6 is an assessment of which MISRA C guidelines address issues that can also occur in the Rust language. However, it is not a Rust coding guide.
How Addendum 6 Assesses MISRA C Guidelines
For each MISRA C guideline, the addendum records whether the issue the guideline targets also exists in Rust, and whether the guideline is still relevant. Each of the 223 guidelines gets a Yes, No or Partial rating in two columns: one for Rust in general (including unsafe code and FFI) and one for safe Rust only. The combination sorts every guideline into one of three groups:
| Group | Guidelines | What it means |
| Don't apply to rust | 94 | The problem doesn't arise anywhere in a Rust project. |
| Apply to both safe and unsafe Rust | 79 | The problem exists in safe Rust, fully or in part, and therefore in unsafe Rust. |
| Apply to unsafe Rust and FFI only | 50 | The developer, not the compiler, must uphold safety. |
This breakdown shows where Rust's design already eliminates or constrains issues familiar to C developers, and where established MISRA concerns remain relevant.
Why Do Some MISRA C Guidelines Apply to Rust and Others Don’t?
It depends on where the issue can occur. If the C feature or problem doesn't exist in Rust, the guideline doesn't apply. If the problem is still present in safe Rust, the guideline applies throughout. If it arises only through unsafe code or FFI, the guideline still applies.
- Why 94 don't apply. Either the C feature doesn't exist in Rust (no C preprocessor, no null pointer constant) or Rust's rules remove the ambiguity (evaluation order is strict, and
matchexpressions must be complete). - Why 79 still apply in safe Rust. Some risks survive the compiler. Directive 5.1, for example, is only partly applicable because not all safe Rust types are race-free, and Directive 4.1 notes that run-time failures often appear as panics. Even where the compiler enforces a guideline, such as Rule 9.1, the addendum notes that unsafe code can bypass that enforcement.
- Why 50 apply only to unsafe Rust and FFI. Rule groups 21 and 22 account for 33 of the unsafe-only guidelines, because the addendum describes the related facilities as reachable only through unsafe
extern"C". The rest cover extern declarations (such as Rule 8.3, which requires an extern declaration to have a type compatible with the C declaration) and unsafe APIs (Rules 18.1, 18.2 and 18.4).
What Happened to MISRA C’s Mandatory guidelines in Addendum 6?
The addendum does not use MISRA's Mandatory category for Rust. Of the 22 guidelines that are Mandatory in MISRA C:2025, 16 are re-categorized as Required for Rust and the other 6 don't apply.
That leaves four categories for each remaining guideline:
- Required: the strictest category the addendum uses. Follow these guidelines or record a formal deviation.
- Advisory: follow where it's reasonably practical.
- Disapplied: no enforcement is expected.
- N/A: the problem doesn't exist in Rust.
It’s important to recognize that categories of some of the guidelines are changed between C and Rust. For example: Rules 11.4 and 11.5 go from Advisory to Required, and Rule 2.1 goes from Required to Advisory. Some are disapplied completely. So, don't assume a guideline keeps its C category. Check the adjusted one in the addendum.
Back to top
Why Are Safety-Critical Teams Adopting the Rust Coding Language?
Rust is increasingly attractive for embedded and safety-critical software because it provides the performance and hardware-level control needed for systems programming while protecting against many common memory-safety defects.
Additional incentive comes from international governments pointing critical infrastructure and other developers toward memory-safe languages for development.
Is There Any Requirement to Move to the Rust Language?
No, there is no mandated requirement, but several instances of international guidance strongly recommend memory-safe languages:
- 2022 – U.S. National Security Agency (NSA): In The Case for Memory Safe Roadmaps, the NSA recommended organizations consider memory-safe languages, including Rust, to help reduce software vulnerabilities caused by memory-management issues.
- 2024 – EU Cyber Resilience Act (CRA): The CRA established cybersecurity requirements for products with digital elements sold in the EU. Although it does not require Rust or memory-safe languages, it raises expectations for secure-by-design development and reducing exploitable vulnerabilities.
- 2026 – European Telecommunications Standards Institute (ETSI): ETSI published its draft TS 104 198 on memory-safety requirements. It provides a framework for assessing memory-safety approaches across programming languages, hardware, and software and explicitly recognizes Rust as one approach to achieving greater memory-safety assurance.
Back to top
Can You Apply the MISRA C Guidelines to Rust Yourself?
Not easily. The addendum was never meant to be used to check your source code against each guideline. Its purpose is to identify which MISRA C guidelines are applicable to Rust and under what circumstances.
Because the guidelines were written for C, applicable guidelines still need to be translated into checks for Rust, including those that apply to safe Rust, unsafe Rust, or FFI. The Rust compiler and Clippy help, but they do not provide complete coverage of the guidelines. One independent, exploratory mapping from the Rust community, based on Addendum 6, found 13 guidelines already covered by rustc or Clippy and roughly 50 that would require custom lints. It isn't official guidance, but it illustrates the gap between identifying applicable guidelines and enforcing them automatically.
How Static Analysis Can Help Check Rust Code Against the Guidelines
Static analysis helps bridge that gap by automatically checking source code against defined coding guidelines and identifying violations early in development. It provides developers with repeatable checks rather than relying solely on manual code review.
In safety-critical environments, static analysis can help:
- Check supported coding guidelines: Identify violations of supported guidelines directly in Rust source code.
- Find defects earlier: Detect quality, reliability, and security issues before the software runs.
- Support verification: Produce consistent, reviewable findings that show how coding guidelines were checked and violations addressed.
Back to top
How Perforce Static Analysis Helps Put Addendum 6 into Practice
Rather than interpreting and implementing the applicable guidelines yourself, use a static analysis tool with checks designed for Rust. Perforce includes Rust support for QAC and Klocwork following the MISRA C guidelines identified as applicable through Addendum 6. Of the two, QAC currently offers the strongest Rust support.
Use Perforce QAC to Check MISRA Guidelines in Rust
Perforce QAC offers significant Rust support for 82% of the statically checkable guidelines.

Check Rust in One Analysis Workflow
With the applicable checks built into the analysis workflow, teams can analyze Rust code consistently, review violations, and document how findings are resolved or justified.
The result is a practical way to act on Addendum 6 without recreating its applicability mapping yourself. This does not make a Rust project MISRA compliant. Rather, teams can describe their analysis as informed by MISRA C:2025 Addendum 6 and document which applicable guidelines were checked.
Analyze Your Rust Code
Try Perforce Static Analysis on your own codebase and see how its automated analysis complements rustc, Clippy without manual code review.
Back to top
Frequently Asked Questions Around Rust Code and MISRA Compliance
What is MISRA C:2025 Addendum 6?
It is an assessment, published by MISRA in March 2025, of whether each MISRA C:2025 guideline applies to Rust. It is not a Rust coding standard.
Is there a MISRA coding standard for Rust?
Not yet. As of October 2026, MISRA has not published a dedicated set of Rust coding guidelines. The MISRA C:2025 Addendum 6 is described as the basis for future work with the Rust community.
Does Rust make MISRA unnecessary?
No. The addendum’s Foreword cautions that switching languages does not solve every problem. 79 guidelines still apply in safe Rust, fully or in part.
Does Addendum 6 make a Rust project MISRA compliant?
No. It assesses the language, not any particular source code, so it cannot make a project compliant. Describe your practices as “informed by Addendum 6,” not MISRA compliant.
Is unsafe Rust covered by the MISRA C guidelines?
Yes. The addendum's "Rust in general" column includes unsafe code and FFI, while its safe Rust column excludes them. Where rustc enforces a guideline, unsafe code can bypass that enforcement.
How can static analysis help with Rust and C code?
Static analysis reads source code and flags defects and rule violations before the program runs, giving human reviewers a consistent first pass. In a mixed C and Rust project, a tool that analyzes both languages in one workflow keeps findings at the boundary together. Perforce added Rust support to QAC and Klocwork in its 2026.1 release.
*Note: MISRA and MISRA C are registered trademarks of The MISRA Consortium Limited. Rust is a registered trademark of the Rust Foundation.
