# Migrating x86_64 workloads to aarch64

## In this learning path

- [Introduction](https://learn.arm.com/learning-paths/embedded-and-microcontrollers/migration/)
- [Porting methodology](https://learn.arm.com/learning-paths/embedded-and-microcontrollers/migration/2_porting_methodology/)
- [Porting analysis](https://learn.arm.com/learning-paths/embedded-and-microcontrollers/migration/3_porting_analysis/)
- [Development environment](https://learn.arm.com/learning-paths/embedded-and-microcontrollers/migration/4_development_environment/)
- [Application porting](https://learn.arm.com/learning-paths/embedded-and-microcontrollers/migration/5_application_porting/)
- [Run and evaluate](https://learn.arm.com/learning-paths/embedded-and-microcontrollers/migration/6_run_evaluate/)
- [Evaluating performance on Arm hardware (Optional)](https://learn.arm.com/learning-paths/embedded-and-microcontrollers/migration/7_alternative/)
- [Next Steps](https://learn.arm.com/learning-paths/embedded-and-microcontrollers/migration/_next-steps/)

## About this Learning Path

|  |  |
| --- | --- |
| Skill level: | Advanced |
| Reading time: | 30 min |
| Last updated: | 13 Aug 2026 |

|  |  |
| --- | --- |
| Author: | Kasper Mecklenburg , Arm |
| Arm IP: | [Cortex-A](https://support.arm.com/?tab=compute-ip&Product%20Type=Application%20Processors) [Neoverse](https://support.arm.com/?tab=compute-ip&Product%20Type=Infrastructure%20Processors) |
| Tags: | [Performance and Architecture](https://learn.arm.com/tag/performance-and-architecture) [Linux](https://learn.arm.com/tag/linux) [GCC](https://learn.arm.com/tag/gcc) [Arm Compiler for Linux](https://learn.arm.com/tag/arm-compiler-for-linux) [Docker](https://learn.arm.com/tag/docker) [Neon](https://learn.arm.com/tag/neon) |

### Who is this for?

This is an advanced topic for embedded software developers looking at migrating Linux workloads to aarch64.

### What will you learn?

After completing this Learning Path, you'll be able to perform the following tasks:

- Understand software migration methodology
- Use different Arm compilers and libraries
- Port applications containing compiler intrinsics

### Prerequisites

Before starting, you'll need the following prerequisites:

- Introductory understanding of software containers
- Knowledge about building workflows
- Access to an aarch64 or x86_64 machine running Linux

### Summary

You’ll migrate an `x86_64` Linux Sobel-filter application to `aarch64` through a structured porting workflow. First, you’ll create an `aarch64` GCC container, adjust source and build options, replace `x86_64` intrinsics with SIMD Everywhere (SIMDe), and compile with CMake. Then, you’ll run each implementation, compare execution times and images, and validate through emulation or remote Arm hardware.

### Frequently asked questions

<summary>Which development environment should I use to build for `aarch64` on my `x86_64` host?</summary>
Use an `aarch64` GCC development container on your `x86_64` machine. Aim to match the original GCC version when possible, and run the build steps inside that container.

**Where do I get the example application, and from which directory do I build?**

Clone the [GitHub repository](https://github.com/m3y54m/sobel-simd-opencv.git) and change into that directory. Follow the provided CMake commands to configure `src` into a build directory and then build from there.

**How should I port the x86_64 SIMD intrinsics in the project?**

Use SIMDe to replace the AVX intrinsics so the code compiles for `aarch64`. Make source and build option changes iteratively until the project compiles in the `aarch64` container.

**What result should I expect after I run the application?**

The program prints execution times in microseconds for the non-SIMD, SIMD, and OpenCV implementations. It also opens four windows showing the original image and outputs from each implementation.

**Do I need physical Arm hardware to follow this Learning Path?**

No. You can run and validate the port using emulation or remote hardware. Physical Arm hardware isn’t required.