What it is

RTIC is the Real-Time Interrupt-driven Concurrency framework for ARM Cortex-M microcontrollers. It lives in the Rust embedded ecosystem, with topics that include bare-metal, no-std, concurrency, and scheduling. The README describes it as a hardware accelerated Rust RTOS and a concurrency framework for building real-time systems. All Cortex-M devices are fully supported, and most RISC-V devices are supported.

It solves the problem of organizing concurrent embedded software around tasks, interrupts, timers, and shared memory. Instead of leaving developers to coordinate event handlers and data access by hand, RTIC provides event triggered or spawned tasks, message passing, a timer queue, priority based critical sections, and compile time deadlock free execution. It targets systems where scheduling overhead, memory use, and data race freedom are important.

Key capabilities

• Tasks are the unit of concurrency and can be event triggered by asynchronous stimuli or spawned by the application on demand.
• Messages can be passed to software tasks at spawn time.
• A timer queue lets tasks be delayed or scheduled to continue at a future time, which supports periodic tasks.
• Task prioritization enables preemptive multitasking.
• Fine-grained priority based critical sections support efficient and data race free memory sharing.
• Deadlock free execution is guaranteed at compile time, which the README says is stronger than the standard Mutex abstraction.
• The scheduler has minimal software footprint because hardware does bulk scheduling; tasks share a single call stack and need no hard dependency on a dynamic allocator.

Who uses it and how

• Developers building bare-metal Rust applications for Cortex-M microcontrollers can use RTIC as the concurrency framework and scheduler.
• Application authors use event triggered tasks for asynchronous stimuli and spawned tasks for requests raised by the program.
• Real-time control work can use the timer queue for delayed work and periodic tasks.
• Community members use examples repo, Matrix room, meeting notes, and RFC repo for examples, discussion, and major changes.
• Contributors run local tests with QEMU and ESP32 QEMU through cargo xtask ci, cargo xtask fmt, and cargo xtask clippy.

Getting started

The README points to the rtic crate on crates.io, the user documentation at rtic.rs, and the API reference at rtic.rs/stable/api. Local test workflows use QEMU, optional ESP32 QEMU, and cargo xtask commands such as ci, fmt, and clippy.

When to use it — and when not to

Use RTIC for bare-metal Rust real-time systems on Cortex-M and supported RISC-V targets, especially when interrupt-driven tasks, timer scheduling, and low scheduling overhead are central. Do not use it when the target lacks RTIC backend support, and do not expect a hosted deployment path from the provided facts. The main weakness is partial RISC-V support, because the README says most RISC-V devices are supported and directs readers to the book for backend particularities and limitations.

$ cargo xtask ci

$ cargo xtask fmt

$ cargo xtask clippy