# [Migrating x86_64 workloads to aarch64](https://learn.arm.com/learning-paths/embedded-and-microcontrollers/migration/)

## 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?

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

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

### Prerequisites

Before starting, you will need the following:

- 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

#### Which development environment should I use to build for `aarch64` on my `x86_64` host?
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.