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:
- Do you need Linux, a full networking stack, a desktop-style GUI, or lots of RAM? Choose a Cortex-A based board or SoC.
- Do you need low power, instant start-up, precise timing, or low cost? Choose a Cortex-M microcontroller.
- 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.
- 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.