# [Migrate x86-64 SIMD to Arm64](https://learn.arm.com/learning-paths/cross-platform/vectorization-comparison/)

## In this learning path

- [Introduction](https://learn.arm.com/learning-paths/cross-platform/vectorization-comparison/)
- [Migrate SIMD code to the Arm architecture](https://learn.arm.com/learning-paths/cross-platform/vectorization-comparison/1-vectorization/)
- [Explore vector extension code examples](https://learn.arm.com/learning-paths/cross-platform/vectorization-comparison/2-code-examples/)
- [Next Steps](https://learn.arm.com/learning-paths/cross-platform/vectorization-comparison/_next-steps/)

## About this Learning Path

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

| Author:            | Jason Andrews, Arm  |
|--------------------|---------------------|
| Arm IP:            | [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), [Clang](https://learn.arm.com/tag/clang) |

### Who is this for?
This is an advanced topic for developers migrating vectorized (SIMD) code from x86-64 to Arm64.

### What will you learn?
Upon completion of this Learning Path, you will be able to:
- Identify how Arm vector extensions including Neon, Scalable Vector Extension (SVE), and Scalable Matrix Extension (SME) map to vector extensions from other architectures
- Plan a migration strategy using autovectorization, intrinsics, or library substitution

### Prerequisites
Before starting, you will need the following:
- Familiarity with vector extensions, SIMD programming, and compiler intrinsics
- Access to Linux systems with Neon and SVE support

### Summary
You’ll migrate vectorized code from x86-64 (SSE and AVX) to Arm by mapping features to Neon, SVE, and SME. You’ll compare autovectorization, intrinsics, and library substitution. Then, you’ll build a SAXPY kernel in plain C and with vector extensions on Arm and x86. You’ll compare each result with a scalar reference and use vector width and throughput to choose an approach for your codebase.

### Frequently asked questions
<details>
<summary>Which migration approach should I pick: autovectorization, intrinsics, or a library?</summary>
First check whether a tuned library provides the routine you need. If it does, prefer the library. Otherwise, try autovectorization first and use intrinsics when you need tighter control.
</details>

<details>
<summary>What result should I expect when I run the SAXPY variants?</summary>
Build and run the plain C and vectorized versions, then compare them across instruction sets. Their outputs match the scalar reference, and the measurements show how vector width affects throughput. Use those observations to inform your migration plan.
</details>

<details>
<summary>What should I do if my Arm hardware doesn't support SVE or SME?</summary>
Run the plain C and Neon versions supported by your hardware. SVE and SME sections need compatible systems, but the conceptual mapping still informs portability decisions.
</details>

<details>
<summary>Where do I find how SSE and AVX map to Neon, SVE, and SME?</summary>
The first section maps x86 SIMD extensions to Arm vector extensions. It highlights scalable vector length and matrix operations to guide code adaptation.
</details>

<details>
<summary>Can I use GCC or Clang to build the examples?</summary>
Yes. You can use either GCC or Clang to build the examples.
</details>