What are the ARM processor profiles A, R and M?

ARM defines three profiles. The A profile (Cortex-A) is for application processors that run rich operating systems like Linux and Android, with an MMU and virtual memory. The R profile (Cortex-R) is for real-time, deterministic, safety-critical systems such as storage controllers, modems and automotive, using an MPU and low interrupt latency. The M profile (Cortex-M) is for microcontrollers, optimised for low power, low cost and deterministic interrupt response, with the NVIC and the Thumb instruction set.

What is the difference between Cortex-A and Cortex-M?

Cortex-A processors are large, high-performance cores with a Memory Management Unit (MMU) that run full operating systems like Linux or Android - think phones and laptops. Cortex-M processors are small, cheap, ultra-low-power microcontroller cores without an MMU, designed for deterministic real-time control - think sensors, appliances and IoT devices. Cortex-A maximises performance; Cortex-M maximises efficiency and predictability.

What is ARM Neoverse?

Neoverse is ARM's line of cores designed for data centres, cloud servers and infrastructure. It builds on the A profile but is tuned for many-core throughput, large caches and high memory bandwidth, powering server chips like AWS Graviton and Ampere Altra.

How do you read an ARM Cortex core name?

The letter after Cortex- is the profile: A (Application), R (Real-time) or M (Microcontroller). The number is a model identifier, where higher generally means newer or more capable within that profile - for example Cortex-M0 is a tiny entry core while Cortex-M7 is a high-performance microcontroller, and Cortex-A78 is a high-end application core. The number is not a direct performance score across different profiles.

DAY 2 · FOUNDATIONS

ARM Processor Families — Cortex-A, Cortex-R & Cortex-M

By EcrioniX · Updated Jun 6, 2026

Yesterday we learned ARM is one architecture, licensed everywhere. But a server CPU and a sensor's microcontroller have very different needs. So ARM splits its cores into three profiles — and knowing them is the map for everything ahead.

1. One architecture, three jobs

ARM defines three profiles, each a letter in the famous Cortex brand. They share the same core RISC philosophy from Day 1, but are tuned for completely different goals:

Application

Runs rich OSes — Linux, Android, iOS. Has an MMU and virtual memory. High performance. Phones, tablets, laptops.

Real-time

Deterministic, low-latency, safety-critical. Uses an MPU. Guarantees timing. Storage, modems, automotive, industrial.

Microcontroller

Tiny, cheap, ultra-low-power. Fast interrupts via the NVIC. No MMU. Sensors, appliances, IoT, wearables.

💡 An analogy

Same engine maker, three vehicles. Cortex-A is a comfortable car that runs a full infotainment system (the OS). Cortex-R is an ambulance — it must arrive on time, every time (real-time guarantees). Cortex-M is an electric scooter — small, cheap, sips energy, does one job reliably.

2. Cortex-A — the Application profile

These are the big cores. The defining feature is a Memory Management Unit (MMU), which provides virtual memory — the thing a modern OS needs to give every process its own protected address space. That's why Cortex-A runs Linux, Android and the like.

Deep pipelines, out-of-order execution, large caches → high performance.
Runs full operating systems with memory protection between apps.
Examples: Cortex-A53, A78, X-series; Apple's custom cores are A-profile.

For servers, ARM extends this profile into the Neoverse line — many cores, huge bandwidth — powering chips like AWS Graviton.

3. Cortex-R — the Real-time profile

Some systems care less about raw speed and more about predictability: a hard-drive controller, a 5G modem, an engine controller, a brake system. They must respond within a guaranteed time, every single time — that's real-time, and missing a deadline can be catastrophic.

Uses an MPU (Memory Protection Unit) instead of an MMU — protection without the unpredictable latency of address translation.
Very low, deterministic interrupt latency; often tightly-coupled memories.
Built for functional safety (e.g. lockstep cores that run the same code twice to catch faults).

4. Cortex-M — the Microcontroller profile

This is where most people start learning ARM, and much of this course's hands-on examples will use it. Cortex-M is designed for microcontrollers: a whole computer (CPU + flash + RAM + peripherals) on one cheap, low-power chip.

No MMU — simple, deterministic, cheap. Real-time interrupt response via the NVIC (we cover it on Day 18).
Executes the Thumb / Thumb-2 instruction set for tiny code size (Day 16).
Sleeps in microamps → perfect for battery and always-on devices.
Range: Cortex-M0/M0+ (smallest), M3/M4 (M4 adds DSP), M7 (fast), M33 (adds TrustZone security).

5. Putting them side by side

Feature	Cortex-A	Cortex-R	Cortex-M
Goal	Max performance	Guaranteed timing	Low power & cost
Memory protection	MMU (virtual memory)	MPU	Optional MPU
Runs	Linux / Android	RTOS / bare-metal	RTOS / bare-metal
Typical use	Phone, laptop, server	Modem, storage, auto	Sensor, IoT, appliance
Interrupts	GIC	Low-latency	NVIC (very fast)

6. How to read a core name

Decode any ARM core at a glance:

Cortex‑M4 → the letter is the profile (M = Microcontroller); the number is the model within that profile (higher ≈ newer/more capable). So Cortex-M0 is a tiny entry core, Cortex-M7 a fast one, Cortex-A78 a high-end application core. The number doesn't compare across profiles — an M7 and an A78 aren't on the same scale.

✅ Why this matters for the rest of the course

Many architecture details depend on profile. The MMU (Day 21) is an A-profile thing; the NVIC (Day 18) is M-profile; banked modes differ between them. When we say "on Cortex-M…" you'll now know exactly what world we're in.

🎯 Day 2 takeaways

ARM has three profiles: A (Application), R (Real-time), M (Microcontroller).
Cortex-A = MMU + rich OS (phones, laptops, servers via Neoverse).
Cortex-R = deterministic, safety-critical real-time (MPU, low latency).
Cortex-M = tiny, low-power microcontrollers (NVIC, Thumb, no MMU).
Core name = profile letter + model number.

Quick check

Which profile would run Android — and why does it need an MMU?
Your design must guarantee it reacts to a sensor within 10 µs, every time. Which profile fits?
What does the "7" in Cortex-M7 tell you — and what does it not?

FAQ

What's the difference between Cortex-A and Cortex-M?

Cortex-A is a large, high-performance core with an MMU that runs full OSes (phones/laptops). Cortex-M is a tiny, ultra-low-power microcontroller core without an MMU for deterministic real-time control (sensors/IoT).

What is Neoverse?

ARM's server/data-centre line, built on the A profile but tuned for many-core throughput and bandwidth (e.g. AWS Graviton).

Which profile should I learn first?

Cortex-M — it's the simplest, cheapest to get hands-on with, and most of this course's examples use it.

← Back to the full course roadmap