MISRA C defines a subset of C with mandatory, required, and advisory rules to avoid unsafe constructs.

It focuses on eliminating undefined, unspecified, and implementation-defined behaviors.

Widely adopted in aerospace, automotive, and defense systems for safety certification.

Supports static analysis and code review compliance processes.

Facilitates maintainable and portable code across compilers and platforms.

Restrictions on dynamic memory allocation

Prohibition of dangerous constructs (goto, setjmp, recursion in certain contexts)

Type safety and strict conversions

Structured control flow and function usage guidelines

Portability and predictability enforcement across compilers

Mandatory Rules - must be strictly enforced

Required Rules - should be enforced unless justified deviation exists

Advisory Rules - guidance for best practices

Undefined Behavior - code constructs that are unpredictable across compilers

Deviation - formal documentation when a rule is intentionally not followed

Source code files (.c/.h) conforming to MISRA C

Configuration files for compliance checker

Documentation for deviations and exceptions

Build scripts ensuring rule compliance before compilation

Test suites for functional and safety verification

Write C code following MISRA subset rules

Run static analysis to detect rule violations

Document justified deviations if any

Iterate and correct violations before integration

Review and verify compliance during code reviews

Beginner: simple embedded C modules with basic rule compliance

Intermediate: multi-module avionics subsystems with full compliance checks

Advanced: integrating MISRA compliance in complex RTOS or safety-critical systems

Expert: full DO-178C software lifecycle including verification and deviation management

Certifier: auditing software projects for MISRA C adherence and safety compliance

MISRA C vs Standard C: safer, restricted subset

MISRA C vs CERT C: avionics vs general embedded safety

MISRA C vs DO-178C guidelines: MISRA is code-level, DO-178C is lifecycle-level

MISRA C vs Coding without guidelines: predictable, verifiable, and certifiable

MISRA C vs AUTOSAR C: automotive vs avionics standards

1998 - MISRA C first edition for automotive

2004 - MISRA C:2004 introduced updates for embedded systems

2012 - MISRA C:2012 consolidated and enhanced rules

2016 - MISRA C:2012 Amendment 1, updated for wider safety-critical use

2020 - MISRA C:2020 revised for modern C and embedded applications

2023 - Latest updates focus on avionics-specific guidance and tool support

Undefined Behavior - operations with unpredictable outcome

Deviation - formally documented exception to a rule

Rule Classification - mandatory, required, advisory

Static Analysis - automated code inspection for compliance

Embedded System - dedicated hardware with software for a specific function

Ensure C compiler and development environment are available

Integrate MISRA compliance checker or static analysis tool

Configure project with MISRA rulesets (mandatory, required, advisory)

Define code review procedures aligned with MISRA

Set up automated reporting for compliance tracking

Install C compiler for target hardware

Install MISRA static analysis tools

Configure project ruleset and reporting options

Integrate compliance checks into build pipeline

Train development team on MISRA rules and practices

Static analysis tool configurations

Project-specific MISRA ruleset files

Deviation justification documentation

Build scripts integrating compliance checks

Documentation for certification authorities

lint - analyze code for MISRA rule violations

build - compile with MISRA-compliant options

report - generate compliance report

check - verify deviation documentation

test - run unit and integration tests on embedded targets

Rules apply globally to safety-critical C code

Documentation and standards available in multiple languages

Compiler-independent rules ensure portability

Applicable across avionics, automotive, and industrial embedded systems

Universal coding practices for safety-critical software

Accessible to trained embedded C developers

Documentation and tools widely available

Works across various compiler toolchains

Supported by industry certification authorities

Community support through MISRA and safety-critical forums

N/A - textual embedded C code

Comments and documentation critical for readability

Structured indentation and naming conventions

Tool-generated reports provide visual feedback

Coding standards maintained for human review

Global variables restricted and controlled

Static memory allocation for predictable behavior

Module-level encapsulation for internal states

Function parameters strictly typed and validated

State transitions verified with testing

Static arrays and fixed-size buffers

Avoid dynamic memory allocation at runtime

Explicit type casting to prevent undefined behavior

Document all external inputs and outputs

Log violations and deviations for review

Guidelines operate at code and project level

Rules cover expressions, control flow, functions, types, and macros

Compliance is verified through static analysis, code review, and testing

Supports hierarchical projects with module-level rule enforcement

Optional deviations formally documented for justified exceptions

Code is compiled for target embedded hardware

Static analysis checks rule compliance before integration

Runtime behavior is predictable and well-defined

Violations are documented and justified

Integration with RTOS or bare-metal environments

Module-based software structure

Layered abstraction for hardware access

Strict interface definitions between modules

Use of static data structures over dynamic allocations

Formal testing and verification at each layer

Flight control software

Avionics sensor and actuator modules

Navigation and guidance systems

Safety-critical communication protocols

Redundant embedded control systems

Avoid undefined and unspecified behaviors

Restrict unsafe constructs and dynamic memory

Enforce type safety and explicit conversions

Enable static analysis and verifiable code

Maintain portability, readability, and maintainability

Use modular code for complex avionics subsystems

Apply rules consistently across all modules

Automate static analysis in CI/CD pipelines

Document deviations centrally for team-wide tracking

Optimize code without violating MISRA rules

Update legacy C code to comply with MISRA rules

Document and justify deviations for existing unsafe constructs

Refactor dynamic memory and pointer usage

Integrate static analysis tools in development workflow

Test thoroughly to ensure functional equivalence and compliance

Rule compliance may limit some optimization techniques

Static analysis overhead is minimal but must be integrated into build

Predictable memory and control flow improve runtime performance

Avoid undefined behavior for consistent execution on target hardware

Optimization flags in compiler should respect MISRA guidelines

Safe coding reduces vulnerabilities in avionics systems

Avoid unsafe functions (strcpy, sprintf) in favor of bounded alternatives

Formal verification of deviations ensures no hidden risk

Follow defensive coding practices

Monitor third-party libraries for MISRA compliance

Track compliance reports for all modules

Monitor deviation justifications

Integrate with build and CI pipelines

Review runtime logs for adherence to safe behavior

Audit code for certification readiness

Strict adherence to MISRA rules

Comprehensive commenting and documentation

Consistent naming and formatting

Modular and reusable code structures

Regular code reviews and static analysis

Avoid using pointer arithmetic that can cause undefined behavior

Replace dynamic memory allocation with static buffers

Eliminate unstructured control flow (goto statements)

Use explicit type casting rules to avoid implicit conversions

Document all rule deviations and rationale for certification audits

Static analyzer flags violations; review warnings and errors

Check for implicit conversions causing runtime issues

Validate memory usage and pointer operations

Verify module interface consistency

Document deviations and update compliance reports

Run static analysis against all code modules

Validate deviations are justified and documented

Check compliance reports before build promotion

Unit test functional correctness for safety-critical modules

Integrate regression tests to maintain ongoing compliance

Compile compliant C code for embedded avionics targets

Deploy with automated compliance report for certification

Use in RTOS-based avionics systems

Distribute code modules internally with verified MISRA adherence

Include compliance documentation in safety case

Static analyzers (LDRA, PC-lint, QA-C, Polyspace)

C compilers for target avionics hardware

Code review and version control systems

Documentation tools for compliance reporting

Unit testing frameworks for embedded C

Integration with CI/CD pipelines for automated compliance checks

Linking with RTOS and hardware abstraction layers

Integration with DO-178C verification tools

Static analysis integrated into IDEs (Eclipse, Visual Studio, IAR)

External test data and simulation tools

Integrate static analysis early in development

Document deviations and justifications promptly

Modularize code to simplify compliance checking

Use compliant coding templates for new modules

Regularly review and update team practices with MISRA updates

Understanding and enforcing complex rules

Managing justified deviations

Integrating static analysis in build pipelines

Balancing performance with rule compliance

Keeping up with evolving MISRA C updates

Learn ISO C standard thoroughly

Study MISRA C rules (mandatory, required, advisory)

Practice writing small compliant modules

Use static analysis tools to enforce compliance

Integrate MISRA practices into real embedded projects

Week 1: C syntax, types, and undefined behaviors

Week 2: MISRA mandatory rules and static analysis

Week 3: Required rules and deviation documentation

Week 4: Integrate compliance into RTOS modules

Week 5: Full avionics software workflow with testing and reporting

What is MISRA C and why is it important in avionics?

Explain the difference between mandatory, required, and advisory rules

How do you document and justify a rule deviation?

How does MISRA C improve code safety and reliability?

Which static analysis tools are commonly used for MISRA C compliance?

Mandatory - must follow

Required - should follow, justify deviations

Advisory - recommended practices

Avoid undefined/implementation-defined behavior

Static analysis + code review ensures compliance

MISRA C:2023 Guidelines Explained

Embedded C Coding Guidelines for Safety-Critical Systems

Certified Software for Avionics with MISRA C

Static Analysis for Safety-Critical Embedded Software

Best Practices in Avionics Software Development

Getting started with MISRA C for embedded systems

Static analysis tools for MISRA compliance

Documenting deviations and exceptions

Integrating MISRA C into avionics software workflow

Advanced techniques for safety-critical C programming

https://www.misra.org.uk

MISRA C:2023 Guidelines for the C Programming Language

MISRA Compliance and Certification Guidelines

MISRA official website and forums

Embedded C safety-critical communities

Tool vendor forums (LDRA, Polyspace, PC-lint)

LinkedIn groups for avionics software engineers

DO-178C compliance discussion groups

MISRA official website and publications

Aerospace software engineering forums

Embedded systems safety groups

Tool vendor support communities (LDRA, Polyspace, PC-lint)

DO-178C and avionics certification discussion groups

Consulting for MISRA-compliant avionics development

Safety-critical software engineering services

Training and workshops on MISRA C

Embedded software certification support

Tool integration and automation services

Enhanced avionics-specific MISRA rules

Better integration with automated certification tools

Expanded guidance for modern C features (C11/C17)

Tool-supported verification and deviation management

Integration with AI-assisted code analysis for safety-critical systems

Non-safety-critical or rapid-prototyping C projects

High-level application code not targeting embedded systems

Projects without formal verification or certification requirements

When coding flexibility outweighs strict safety constraints

For scripting or desktop applications with minimal risk

MISRA C Avionics provides a strict, safety-oriented subset of C for embedded avionics software.

It improves code reliability, maintainability, and safety for certification.

Compliance is verified through static analysis, testing, and documentation.

Widely adopted in aerospace and safety-critical industries.

Critical for high-integrity software development and safety certification.

Is MISRA C mandatory? -> Mandatory only if adopted by the project or regulatory body.

Does MISRA C replace DO-178C? -> No, it complements code-level compliance in safety-critical systems.

Can MISRA C be applied outside avionics? -> Yes, in any safety-critical embedded system.

Are all C constructs forbidden? -> Only unsafe or undefined behaviors; safe constructs are allowed.

Do I need tools to comply? -> Strongly recommended to use static analysis tools.