# Write SIMD code on Arm using Rust

## In this learning path

- [Introduction](https://learn.arm.com/learning-paths/cross-platform/simd-on-rust/)
- [Introduction to Rust](https://learn.arm.com/learning-paths/cross-platform/simd-on-rust/intro-to-rust/)
- [Arm SIMD on Rust](https://learn.arm.com/learning-paths/cross-platform/simd-on-rust/simd-on-rust-part1/)
- [Inlining Intrinsics](https://learn.arm.com/learning-paths/cross-platform/simd-on-rust/simd-on-rust-part2/)
- [Matrix transpose](https://learn.arm.com/learning-paths/cross-platform/simd-on-rust/simd-on-rust-part3/)
- [A more complicated example](https://learn.arm.com/learning-paths/cross-platform/simd-on-rust/simd-on-rust-part4/)
- [Conclusion](https://learn.arm.com/learning-paths/cross-platform/simd-on-rust/conclusion/)
- [Next Steps](https://learn.arm.com/learning-paths/cross-platform/simd-on-rust/_next-steps/)

## About this Learning Path

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

|  |  |
| --- | --- |
| Author: | Konstantinos Margaritis , VectorCamp<br>[GitHub](https://github.com/markos)<br>[LinkedIn](https://linkedin.com/in/konstantinosmargaritis)<br>[Twitter](https://twitter.com/@freevec1)<br>[vectorcamp.gr](https://vectorcamp.gr/) |
| 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) [Clang](https://learn.arm.com/tag/clang) [Rust](https://learn.arm.com/tag/rust) [Runbook](https://learn.arm.com/tag/runbook) |

### Who is this for?
This is an advanced topic for software developers who want to take advantage of SIMD code on Arm systems using Rust.

### What will you learn?
After completing this Learning Path, you'll be able to perform the following tasks:
- Write SIMD code with Rust using `std::arch` and Neon intrinsics on Arm
- Use portable SIMD abstractions with `std::simd` for cross-platform code
- Apply feature detection and target attributes for architecture-specific optimizations
- Compare C and Rust SIMD implementations and disassembly output

### Prerequisites
Before starting, you'll need the following prerequisites:
- An Arm-based computer with recent versions of a C compiler (Clang or GCC) and a Rust compiler installed.

### Summary
You’ll write SIMD code for Arm with Rust by translating familiar C examples into Rust. Starting with Arm Advanced SIMD (Neon) intrinsics in C, you’ll mirror them in Rust with `std::arch` and explore portable SIMD with `std::simd`. You’ll implement pairwise averaging, a dot-product sum of absolute differences, a 4x4 matrix transpose, and a DCT butterfly. Then, you’ll compare C and Rust output and disassembly.

### Frequently asked questions

**Which Rust SIMD API should I use when porting the C Neon intrinsics examples?**

Use `std::arch` for a one-to-one match with the C Neon intrinsics. Use `std::simd` when you prefer a portable abstraction.

**How do I know the pairwise average example produced the right result?**

The program averages corresponding elements from two arrays. Compare its output with the scalar calculation `(A[i] + B[i]) / 2` for each index.

<summary>What output should I expect from the dot product (`vdotq_u32`) example?</summary>
The example prints the input arrays and then reports one sum of absolute differences (SAD) value. Compare the arrays and SAD total with the expected calculation.

**What should I check if the Rust intrinsics code does not compile?**

Confirm that the imports and architecture-specific attributes match the example, and target an Arm platform that supports the intrinsics. Mismatched names or attributes can cause build errors.

**How do I compare the C and Rust implementations for the transpose or butterfly steps?**

Build and run both versions, then compare their printed outputs. Review the disassembly to see how each implementation maps to Arm Neon instructions.