Introduction
Windows on Arm64 is becoming a practical option for developers who want better battery life, quieter devices, and efficient performance on modern Windows hardware. For many existing .NET applications, moving to an Arm64-based Windows machine does not mean rewriting the application from scratch.
The .NET runtime supports Arm64, and most applications built with modern .NET versions can run on Windows Arm64 with little or no source-code change. The real work is usually around application dependencies, native libraries, build configuration, installers, and third-party components.
This article explains how to migrate an existing .NET application to Windows Arm64, what to check before moving, and how to spot problems before they reach production.
What Does Windows Arm64 Mean for a .NET Application?
Arm64 is a 64-bit CPU architecture used by processors from vendors such as Qualcomm and Microsoft.
Traditional Windows desktop and server applications have commonly targeted x64 processors. Windows on Arm64 uses a different instruction set, so applications containing architecture-specific native code can require additional work.
For a .NET application, there are two important cases:
The application is mostly managed .NET code.
The application depends on native binaries or architecture-specific libraries.
The first case is usually straightforward because modern .NET provides Arm64 support.
For example, an application containing normal C# code such as this does not need to be rewritten simply because it is running on Arm64:
using System;
class Program
{
static void Main()
{
Console.WriteLine("Application is running on Windows Arm64.");
}
}The C# source code itself is not tied to x64.
The challenge starts when the application depends on components that were compiled specifically for x64.
Check the .NET Version Before Migration
Start by identifying the .NET version used by the application.
Modern .NET releases provide support for Windows Arm64, but older applications may require an upgrade before they can be properly deployed as Arm64 applications.
Check the installed SDKs and runtimes:
dotnet --infoYou can also inspect the project file:
<TargetFramework>net8.0</TargetFramework>or:
<TargetFramework>net10.0</TargetFramework>The exact migration path depends on whether the application uses modern .NET, .NET Framework, or another older runtime.
For applications still running on .NET Framework, the situation is different. You should not assume that changing the CPU architecture alone will make the application a native Arm64 application.
Check Whether the Application Is Architecture-Dependent
Before changing the deployment architecture, inspect the project for architecture-specific code.
Look for code that explicitly assumes x64 or uses platform-specific APIs.
For example:
if (Environment.Is64BitProcess)
{
Console.WriteLine("64-bit process");
}Being a 64-bit process does not automatically mean x64. Arm64 is also a 64-bit architecture.
A better approach is to inspect the actual process architecture:
Console.WriteLine($"Process architecture: {System.Runtime.InteropServices.RuntimeInformation.ProcessArchitecture}");This can return values such as:
X64
Arm64You can also inspect the operating system architecture:
Console.WriteLine(
System.Runtime.InteropServices.RuntimeInformation.OSArchitecture);This is useful when troubleshooting applications that behave differently on different machines.
Review Native Dependencies
Native dependencies are one of the most common migration problems.
A managed NuGet package can often run on Arm64 without changes, but a package that contains native binaries may require an Arm64-compatible version.
Common examples include:
Native database drivers
Image-processing libraries
Hardware SDKs
Encryption libraries
Video and audio codecs
C/C++ DLLs
Browser engines
Native machine-learning libraries
Suppose an application loads a native DLL:
[DllImport("MyNativeLibrary.dll")]
private static extern int ProcessData();The C# code may compile successfully, but the application can fail at runtime if MyNativeLibrary.dll does not contain an Arm64-compatible binary.
A typical error may look like:
BadImageFormatExceptionor:
Unable to load DLL 'MyNativeLibrary.dll'This is why dependency checking should happen before the migration.
Check NuGet Packages
Review the application's NuGet dependencies.
You can list project dependencies with:
dotnet list packageFor each package, determine whether it is:
Fully managed
Platform-specific
Using native runtime assets
Dependent on another native component
Pay particular attention to packages containing runtime-specific folders such as:
runtimes/win-x64/
runtimes/win-arm64/If a package provides only x64 native binaries, the application may not work correctly when published for Arm64.
A package with explicit Arm64 assets is a much safer choice.
Understand Runtime Identifiers
.NET uses Runtime Identifiers, or RIDs, to describe operating-system and architecture combinations.
For Windows Arm64, the relevant RID is:
win-arm64You can use it when publishing the application:
dotnet publish -c Release -r win-arm64 --self-contained trueThis tells .NET to publish the application for Windows Arm64.
For comparison, an x64 build would use:
dotnet publish -c Release -r win-x64 --self-contained trueThe important point is that the target architecture is determined during publishing rather than by changing the C# source code.
Framework-Dependent vs Self-Contained Deployment
You should decide whether the Arm64 application will be framework-dependent or self-contained.
A framework-dependent deployment relies on the appropriate .NET runtime being installed on the target machine.
A self-contained deployment includes the required .NET runtime with the application.
For example:
dotnet publish -c Release -r win-arm64 --self-contained trueThis can simplify deployment because the target machine does not need a separately installed compatible .NET runtime.
However, self-contained deployments are larger and require you to manage runtime updates as part of the application deployment process.
Join the conversation! Your thoughts help the community grow.