Architecture and Hardware

ARM Cortex-M vs Cortex-A vs Cortex-R: Which Core Does What?

How Arm's Cortex-M, Cortex-A and Cortex-R profiles differ in memory management, real-time behavior and software, with example chips and advice on choosing.

On this page
  1. The short answer
  2. What the three profiles are for
  3. Cortex-M: the microcontroller profile
  4. Cortex-A: the application profile
  5. Cortex-R: the real-time profile
  6. Side-by-side comparison
  7. MMU vs MPU: the difference that matters most
  8. Chips that mix profiles
  9. Where the lines blur
  10. How to choose
  11. Summary

The short answer

Arm splits its Cortex processor cores into three profiles, each designed for a different kind of job:

  • Cortex-A (Application): high-performance cores with a memory management unit (MMU) that run full operating systems such as Linux and Android. Found in smartphones, single-board computers like the Raspberry Pi, and many embedded Linux devices.
  • Cortex-R (Real-time): cores built for fast, predictable response and high reliability. Found in automotive controllers, storage controllers and other safety- or timing-critical systems.
  • Cortex-M (Microcontroller): small, low-power, low-cost cores designed for microcontrollers. Found in STM32, nRF52, RP2040 and countless other chips, typically running bare-metal code or a small RTOS.

A useful rule of thumb: if it runs Linux, it’s almost certainly Cortex-A. If it’s a microcontroller you flash with firmware, it’s very likely Cortex-M. Cortex-R sits in between and is mostly found in specialised industrial and automotive parts.

What the three profiles are for

The letters in A, R and M aren’t just branding. Each profile is defined by a different version of the Arm architecture, with its own instruction set features, memory model and exception handling:

Profile Architecture versions Design priority
Cortex-A Armv7-A, Armv8-A, Armv9-A Throughput, rich OS support
Cortex-R Armv7-R, Armv8-R Deterministic timing, reliability
Cortex-M Armv6-M, Armv7-M, Armv8-M Low power, low cost, simple programming

All three are Arm cores, but code compiled for one profile won’t generally run unmodified on another. They differ in how they boot, how interrupts work and how memory is protected, so the startup code, drivers and operating system are different too.

Cortex-M: the microcontroller profile

Cortex-M is what most people mean when they talk about “an ARM microcontroller.” Silicon vendors license the core and build a chip around it with flash, SRAM and peripherals on the same die.

Key traits

  • Thumb instruction set only. Cortex-M cores run the compact Thumb/Thumb-2 instruction set, which keeps code size small. They can’t run the classic 32-bit Arm instruction set or 64-bit code.
  • Built-in interrupt controller (NVIC). The Nested Vectored Interrupt Controller is part of the core, so interrupt handling works the same way across vendors. Interrupt entry saves registers in hardware, which means interrupt handlers can be ordinary C functions.
  • Low, predictable interrupt latency. Response times are measured in a small number of clock cycles, which suits real-time control.
  • MPU, not MMU. Many Cortex-M cores offer an optional memory protection unit that can stop a task from writing where it shouldn’t. There’s no MMU, so there’s no virtual memory and standard Linux can’t run.
  • Code runs from on-chip flash. Programs usually execute directly from internal flash; see our guide to microcontroller memory types for how flash and SRAM are used.
  • Simple software stack. Typically bare metal (a main loop plus interrupts) or an RTOS such as FreeRTOS or Zephyr.

The Cortex-M family at a glance

  • Cortex-M0 / M0+ (Armv6-M): the smallest and lowest-power cores, used in cheap and battery-powered parts. The Raspberry Pi RP2040 uses two Cortex-M0+ cores.
  • Cortex-M3 (Armv7-M): the classic mid-range core with a fuller Thumb-2 instruction set.
  • Cortex-M4 (Armv7-M): adds DSP instructions and an optional single-precision floating-point unit, popular for motor control, audio and sensor fusion.
  • Cortex-M7 (Armv7-M): the high-performance end of Armv7-M, with caches, tightly coupled memory and an optional double-precision FPU.
  • Cortex-M23 / M33 and later (Armv8-M): add optional TrustZone security, which splits the chip into secure and non-secure worlds. The M33 is common in newer parts, including the RP2350.
  • Cortex-M55 / M85 (Armv8.1-M): add the Helium vector extension, aimed at signal processing and machine learning on microcontrollers.

Cortex-A: the application profile

Cortex-A cores are designed to run general-purpose operating systems and large applications. Chips built around them are usually called application processors or SoCs (systems on chip) rather than microcontrollers.

Key traits

  • Memory management unit (MMU). The MMU provides virtual memory and process isolation, which Linux, Android and other full operating systems need.
  • High clock speeds and caches. Cortex-A cores typically run at hundreds of MHz to several GHz, with multi-level caches and, in many designs, multiple cores.
  • External memory. Most Cortex-A systems use external DRAM and boot from an SD card, eMMC or other storage, unlike a microcontroller that runs straight from internal flash.
  • 64-bit support. Armv8-A and later cores can run 64-bit (AArch64) code. Older Armv7-A cores are 32-bit.
  • SIMD and multimedia. NEON (Advanced SIMD) instructions speed up media, graphics and signal processing work.
  • Less predictable timing. Caches, virtual memory and a general-purpose OS make worst-case response times harder to guarantee than on a Cortex-M or Cortex-R.

Where you’ll meet Cortex-A

  • Single-board computers: the Raspberry Pi 4 uses Cortex-A72 cores, and the Raspberry Pi 5 uses Cortex-A76 cores.
  • Smartphones and tablets, often with a mix of large and small Cortex-A cores (Arm’s big.LITTLE approach) to balance speed and battery life.
  • Embedded Linux products: routers, industrial HMIs, smart displays, cameras and gateways.

Cortex-R: the real-time profile

Cortex-R is the least familiar of the three to hobbyists, because it rarely appears on maker boards. It’s aimed at systems that need more performance than a typical microcontroller but must still respond to events within strict, predictable time limits.

Key traits

  • Deterministic, fast interrupt handling. Designed so worst-case response times can be bounded.
  • Tightly coupled memory (TCM). Fast memory close to the core gives predictable access times without relying on caches.
  • Reliability features. Depending on the core and chip, these can include error-correcting code (ECC) on memories and dual-core lockstep, where two cores run the same code and a mismatch is flagged as a fault.
  • MPU-based protection. Most Cortex-R cores use an MPU rather than an MMU. The 64-bit Cortex-R82 is an exception: it adds an optional MMU, so it can run Linux alongside real-time code.
  • RTOS software. Typically a real-time operating system, often one certified for functional safety work.

Where Cortex-R is used

  • Automotive controllers such as braking, steering and powertrain systems
  • Storage controllers in hard drives and SSDs
  • Cellular modems and baseband processors
  • Industrial safety controllers
  • Real-time co-processors inside larger SoCs; for example, some AMD (formerly Xilinx) Zynq UltraScale+ MPSoCs pair Cortex-A53 application cores with Cortex-R5F real-time cores

TI’s Hercules safety microcontrollers are one family where Cortex-R cores appear in a chip that is otherwise programmed much like a microcontroller.

Side-by-side comparison

Cortex-M Cortex-R Cortex-A
Main goal Low power, low cost Predictable timing, reliability Performance, rich OS
Memory protection Optional MPU MPU (optional MMU on R82) MMU
Typical OS Bare metal, FreeRTOS, Zephyr Safety-certified RTOS Linux, Android
Typical memory On-chip flash and SRAM TCM plus on-chip or external memory External DRAM, caches
Instruction set Thumb/Thumb-2 only Arm and Thumb (AArch64 on R82) Arm, Thumb, AArch64 (v8-A+)
Interrupt latency Very low, predictable Low, predictable Higher, less predictable
Typical clock Tens to hundreds of MHz Hundreds of MHz to over 1 GHz Hundreds of MHz to several GHz
Example uses Sensors, wearables, motor control, IoT nodes Brakes, SSD controllers, modems Phones, Raspberry Pi, embedded Linux

Clock figures are rough ranges; the real numbers depend on the specific chip.

MMU vs MPU: the difference that matters most

If you remember one technical difference, make it this one.

  • An MMU translates virtual addresses into physical ones. Every process gets its own address space, memory can be paged and swapped, and one program can’t corrupt another. Standard Linux depends on this.
  • An MPU only checks permissions on fixed regions of physical memory: “this task can read this range, can’t write that range, can’t execute from here.” There’s no address translation.

That’s why you can’t install standard Linux on an STM32 or an RP2040, no matter how fast the clock. There are niche ways to run Linux-like systems without an MMU, but for practical purposes Linux means Cortex-A.

Chips that mix profiles

Many modern SoCs combine profiles on one die, letting each core do what it’s good at:

  • STM32MP1: Cortex-A7 cores running Linux, plus a Cortex-M4 for real-time tasks.
  • NXP i.MX 8M family: Cortex-A53 application cores plus a Cortex-M core for low-latency control.
  • Zynq UltraScale+ MPSoC: Cortex-A53 cores, Cortex-R5F cores and FPGA fabric on one chip.

A common pattern is to let Linux on the Cortex-A handle networking, the user interface and storage, while the Cortex-M or Cortex-R handles motors, sensors and anything with a hard timing deadline. The cores exchange messages through shared memory and a mailbox peripheral. This split is a recurring theme in embedded system architecture.

Where the lines blur

The profiles overlap at the edges:

  • Fast Cortex-M “crossover” parts. Chips such as NXP’s i.MX RT series run a Cortex-M7 at several hundred MHz or more, with performance that overlaps older application processors, while still being programmed like a microcontroller.
  • Cortex-R with an MMU. The Cortex-R82 can run a rich OS, narrowing the gap with Cortex-A.
  • Cortex-A without Linux. A Cortex-A core can run bare-metal code or an RTOS. It’s less common, but it’s done when raw processing power is needed without OS overhead.

So treat the profiles as design targets rather than strict boundaries.

How to choose

For most projects, the decision comes down to a few questions:

  1. Do you need Linux, a full networking stack, a desktop-style GUI, or lots of RAM? Choose a Cortex-A based board or SoC.
  2. Do you need low power, instant start-up, precise timing, or low cost? Choose a Cortex-M microcontroller.
  3. Are you building a safety-critical or high-reliability controller that also needs significant processing power? A Cortex-R based part may fit, though many such designs also use high-end Cortex-M chips with safety features.
  4. Do you need both a rich OS and hard real-time control? Consider a mixed-profile SoC, or pair a Linux board with a separate microcontroller.

For learning embedded programming, a Cortex-M board is usually the best starting point because the tools are inexpensive and you work much closer to the hardware. Our guide to choosing embedded development boards covers specific options.

Summary

  • Cortex-M is the microcontroller profile: small, efficient, MPU-based, bare metal or RTOS.
  • Cortex-A is the application profile: fast, MMU-based, built to run Linux and Android.
  • Cortex-R is the real-time profile: predictable and reliable, used mostly in automotive, storage and safety-critical systems.
  • The MMU is the key reason only Cortex-A (and the Cortex-R82) can run standard Linux.
  • Many real products combine profiles, with each core handling the work it suits best.

The complete guide to architecture and hardware

Embedded System Architecture: Hardware and Software Components
Read the guide

Keep exploring

Guides from other topics

All topics →