You ran the rustup installer on your Snapdragon laptop and got a toolchain error, or cargo build dies complaining about a missing linker, or everything “installs” but produces binaries that crash on launch. Rust is supposed to be the systems language that just works — on ARM Windows it needs a little more setup than the installer admits.

Rust’s ARM64 Windows support is stable and real: the aarch64-pc-windows-msvc target compiles natively. The friction comes from three places: rustup’s installer defaulting to the x86_64 toolchain on some setups, the Visual Studio linker requirement (Rust on Windows needs MSVC’s linker, and you need the ARM64-capable Build Tools), and PATH issues where the wrong toolchain shadows the right one. It is the same ARM64-first discipline as the rest of the dev stack — Go on ARM Windows has nearly identical installer traps, and Copilot Pages issues show how even non-dev features stumble on the same architecture confusion. The same confusion shows up outside dev tools — Live Captions delay problems and Paint background removal failures both trace to wrong-build installs.

This guide gives you six fixes in order: install rustup correctly for ARM64, set the default toolchain, install the MSVC linker properly, fix PATH and toolchain shadowing, handle crate/native dependency issues, and repair a broken rustup installation. Commands run in PowerShell unless noted.

Why this happens

  • x86_64 toolchain installed by default: Some rustup installer flows detect “Windows” and install the x86_64-pc-windows-msvc toolchain. It works under emulation but builds emulated binaries and confuses linker setup.
  • Missing Visual Studio Build Tools: Rust on Windows links with Microsoft’s linker (link.exe). Without the Build Tools — or with only x64 components — every build fails at the link stage.
  • Wrong-architecture Build Tools: The Build Tools installer can pull x64-only MSVC components. The ARM64 linker pieces must be selected for native ARM64 Rust builds.
  • PATH not updated or stale: rustup adds %USERPROFILE%\.cargo\bin to PATH. If the terminal was open during install, or another toolchain shadows it, cargo resolves wrong or not at all.
  • Crates with x86-only build scripts: Some crates shell out to x64 tools or bundle x64 binaries in their build scripts, failing on ARM64 hosts even though the Rust code itself is portable.
  • Multiple toolchains shadowing each other: rustup toolchains plus standalone Rust installs (from winget, scoop, or MSYS2) create several cargo/rustc binaries; the wrong one wins silently.
  • Corrupted rustup state: Interrupted installs leave .rustup and .cargo directories half-written, producing toolchain errors that survive reinstall attempts.

How to fix it

Work through these in order — diagnose first, then act.

Fix 1: Install rustup and select the ARM64 toolchain

Get the foundation right: rustup itself plus the native ARM64 toolchain as the default.

  1. Download rustup-init.exe from the official Rust website (rust-lang.org) — the standard installer works on ARM64 Windows.
  2. Run it and choose the default installation, then open a new PowerShell window so PATH picks up %USERPROFILE%\.cargo\bin.
  3. Run rustup toolchain install stable-aarch64-pc-windows-msvc to add the native ARM64 toolchain explicitly.
  4. Set it as default: rustup default stable-aarch64-pc-windows-msvc.
  5. Verify with rustup show — the Default host should read aarch64-pc-windows-msvc and rustc -vV should report host aarch64-pc-windows-msvc.

Fix 2: Install the Visual Studio Build Tools with ARM64 support

No linker, no binaries. Install Microsoft’s build tools with the components Rust actually needs.

  1. Download the Visual Studio Build Tools installer from Microsoft’s Visual Studio downloads page.
  2. In the installer, select the Desktop development with C++ workload.
  3. In the individual components list, make sure the MSVC ARM64 build tools are included (the x64 tools alone will not link ARM64 targets).
  4. Complete the installation and restart your terminal — the linker needs fresh environment variables.
  5. Test with a trivial project: cargo new linktest, cd linktest, cargo build — a successful link proves the toolchain is complete.

Fix 3: Fix PATH and remove toolchain shadowing

When cargo is not found or resolves to a stale copy, clean up the binary resolution.

  1. In a fresh PowerShell, run Get-Command cargo | Select-Object Source to see which cargo binary resolves.
  2. It should point to %USERPROFILE%\.cargo\bin\cargo.exe. If it points elsewhere (scoop shims, MSYS2, an old standalone install), remove or deprioritize that entry.
  3. Check Environment Variables > User Path and confirm %USERPROFILE%\.cargo\bin is present; add it manually if the installer missed it.
  4. Uninstall standalone Rust copies from winget/scoop if you use rustup — one toolchain manager avoids all shadowing.
  5. Open a new terminal and confirm cargo --version and rustc --version report the stable ARM64 toolchain.

Fix 4: Handle crates with native or x86-only build scripts

cargo build fails inside a dependency’s build script — the crate assumes an x64 world.

  1. Read the failing build script’s output for hardcoded paths like Program Files (x86), x64 tool names, or downloaded x86 binaries.
  2. Check the crate’s repository for ARM64/Windows-AArch64 support issues or newer versions that fixed it.
  3. For C dependencies, prefer crates that vendor their C code and build it with the cc crate — those compile natively for ARM64 automatically.
  4. If a crate downloads prebuilt x64 binaries, look for a feature flag or environment variable to build from source instead.
  5. As a last resort, pin the crate to a version before the x64-only change while you file or track the upstream ARM64 issue.

Fix 5: Set the target explicitly per project

For projects that must build for a specific architecture, stop relying on the default toolchain and declare the target.

  1. In your project, create or edit .cargo/config.toml and set build.target = "aarch64-pc-windows-msvc" for native ARM64 builds.
  2. For x64 output from your ARM laptop, first run rustup target add x86_64-pc-windows-msvc, then build with cargo build --target x86_64-pc-windows-msvc.
  3. Confirm the output binary’s architecture with dumpbin /headers target\...\yourapp.exe | findstr machine from a VS Developer Prompt — look for ARM64.
  4. Keep per-project targets in version control so teammates on x64 machines get the right behavior too.
  5. For release builds, use cargo build --release --target aarch64-pc-windows-msvc to get optimized native binaries.

Fix 6: Repair a corrupted rustup installation

When toolchain errors persist through correct installs, the rustup state directories themselves are damaged.

  1. Back up anything custom in %USERPROFILE%\.cargo (your config.toml, installed binaries you added).
  2. Uninstall rustup via Settings > Apps, then delete %USERPROFILE%\.cargo and %USERPROFILE%\.rustup if they remain.
  3. Remove .cargo\bin from your user PATH, then restart the laptop.
  4. Reinstall rustup from the official installer and immediately set the ARM64 toolchain as default (Fix 1, steps 3-5).
  5. Reinstall the Build Tools components from Fix 2 if the linker still fails — a fresh rustup sometimes needs the environment re-registered.

Closing

Rust on Snapdragon laptops is a solid native experience once the toolchain triple is right: rustup, the aarch64-pc-windows-msvc toolchain as default, and ARM64 MSVC build tools for the linker. Verify with rustup show and a hello-world build whenever something smells off — most “broken Rust” reports are really “wrong toolchain” reports. The honest limitation is the crate ecosystem: a minority of crates still assume x64 in their build scripts, and those need upstream fixes or workarounds. For the underlying build tools, Microsoft’s Windows support hub links to the current Visual Studio Build Tools downloads.

Frequently asked questions

Does Rust support Windows on ARM natively?
Yes — Rust ships a stable aarch64-pc-windows-msvc toolchain that compiles and runs natively on Snapdragon laptops. Install it through rustup by selecting the aarch64-pc-windows-msvc target; the default x86_64 toolchain will install but produce emulated binaries.
Why does rustup fail with a linker error on my ARM laptop?
Rust needs Microsoft’s C++ linker, which comes with the Visual Studio Build Tools. The error usually means the Build Tools are missing or the wrong-architecture (x64-only) tools were installed — install the Build Tools with the ARM64 components.
cargo build works but the binary will not run. Why?
You likely built for the wrong target — an x86_64-pc-windows-msvc binary runs under emulation and may fail if its dependencies are missing. Run rustup show to confirm the active toolchain is aarch64-pc-windows-msvc.
Can I cross-compile from ARM Windows to x64?
Yes — add the x86_64-pc-windows-msvc target with rustup target add and build with cargo build –target. Cross-compiling the other direction works too, though native ARM64 builds are what you want on these laptops.