# [Explore Arm Memory Tagging Extension with an example C program](https://learn.arm.com/learning-paths/mobile-graphics-and-gaming/mte/)

## In this learning path

- [Introduction](https://learn.arm.com/learning-paths/mobile-graphics-and-gaming/mte/)
- [Create and compile an example C application to explore Arm MTE](https://learn.arm.com/learning-paths/mobile-graphics-and-gaming/mte/mte/)
- [Run the example application to explore Arm MTE](https://learn.arm.com/learning-paths/mobile-graphics-and-gaming/mte/run-mte-example/)
- [Next Steps](https://learn.arm.com/learning-paths/mobile-graphics-and-gaming/mte/_next-steps/)

## About this Learning Path

| Skill level:    | Introductory       |
|------------------|-------------------|
| Reading time:    | 20 min            |
| Last updated:    | 19 Aug 2026       |

| Author:          | Jason Andrews, Arm [GitHub](https://github.com/jasonrandrews) [LinkedIn](https://linkedin.com/in/jason-andrews-7b05a8) |
|------------------|-------------------|
| Arm IP:          | [Cortex-A](https://support.arm.com/?tab=compute-ip&Product%20Type=Application%20Processors) |
| Tags:            | [Performance and Architecture](/tag/performance-and-architecture), [Linux](/tag/linux), [QEMU](/tag/qemu) |

### Who is this for?

This is an introductory topic for developers who want to gain experience with the Arm Memory Tagging Extension (MTE).

### What will you learn?

Upon completion of this Learning Path, you will be able to:

- Build an MTE-enabled C program on AArch64 Linux
- Run the program to observe MTE detecting an invalid memory access
- Use QEMU to run the example when MTE hardware is unavailable

### Prerequisites

Before starting, you will need the following:

- An AArch64 Linux development machine. You can also use a cloud instance. For more information, see the list of [Arm cloud service providers](/learning-paths/servers-and-cloud-computing/csp/).

### Summary

You’ll explore Arm MTE on an `aarch64` Linux system. First, you’ll build and run a small C program that triggers buffer-overflow and use-after-free errors, then observe the resulting faults or diagnostics. You’ll use a recent Arm system or supported Arm-based cloud instance to relate MTE behavior to invalid memory accesses.

### Frequently asked questions

<details>
<summary>How do I know if my system can demonstrate MTE?</summary>
MTE is implemented in Armv8.5-A and Armv9-A processors. Verify that you’re using an AArch64 Linux system with hardware that supports MTE. Otherwise, the example might not show tagging-related behavior.
</details>

<details>
<summary>What result should I expect when running the example program?</summary>
Expect behavior that illustrates MTE catching memory safety issues, such as a fault or diagnostic triggered by an invalid access. The outcome should align with the bug the program intentionally exercises.
</details>

<details>
<summary>Can I run the example without MTE hardware?</summary>
Yes. Install `qemu-user` and run the example with `qemu-aarch64 ./mte-example`. This lets you exercise MTE behavior when the processor doesn’t implement MTE.
</details>

<details>
<summary>What should I check if the program runs without showing any MTE effects?</summary>
Confirm you’re on AArch64 Linux and that the processor implements MTE (Armv8.5-A or Armv9-A). If the processor lacks MTE support, install `qemu-user` and run `qemu-aarch64 ./mte-example` to exercise the MTE behavior through emulation.
</details>

<details>
<summary>What invalid memory access does the example demonstrate?</summary>
The example writes beyond a 16-byte allocation granule at offset `0x10`. MTE detects the tag mismatch and should generate an exception.
</details>