I have been fortunate enough to have had early access to a device running Windows 10 on ARM for the purpose of exploring the developer experience. In case you have heard of Windows 10 on ARM, it is a build of Windows 10 Desktop that runs on the ARM64 processor. This enables Windows 10s and Pro to run on a new family of devices that have all-day battery life and can be Always Connected via mobile data networks. A great feature of Windows 10 on ARM is the fact that it can run Store Apps and existing x86 win32 applications unmodified via emulation. This means your existing productivity apps (such as Office Apps, notepad++, etc.) will run well – you could even run Visual Studio 2017, although I wouldn’t expect great performance there.

Disclaimer: The device I have is pre-production so I cannot talk about device build quality or overall performance.

You can learn more about Windows 10 on ARM and the Always Connected PC via the video from Build 2017 below – after the video I will walk through the steps I took to be able to remote debug an x86 UWP on the Windows 10 on ARM device.

Remote Debugging

The great thing about remote debugging a Windows 10 on ARM device is that it is exactly the same as remote debugging any other Windows 10 device.

Upgrade to Windows 10 Pro

My Windows 10 for ARM device came with Windows 10 S installed – given the price point, it makes sense that the device would be targeting Students and the like. However, if we want to use it as part of the development cycle, the device needs to be upgraded to Windows 10 Pro. Microsoft has documented the upgrade process here. As an MVP with a Visual Studio Subscription, I have product keys so I could update simply enough.

Enable Developer Mode

Once you are running Windows 10 Pro, it’s time to enable developer mode.

Note: Ensure you are connected to the internet for this process so that the dev packages are downloaded and installed.

Open Settings, search for Developer and choose “Use developer features”:


By default, the system may be set to “Microsoft Store Apps” or “Sideload apps” – change this to developer mode. You will see a dialog displayed to confirm the setting:


Hit “Yes” and you should see a message “Searching for Developer Mode Package”, followed by “Installing Developer Mode Package”. This may take a few minutes.

Once completed, you should see a message that states “Developer Mode package installed. Remote tooling for desktop is now enabled.”

Important: Ensure you switch “Device discovery” on – this will allow the developer machine to be able to “see” the device on the network and remote deploy/debug.

Remote Debugging a UWP App

In order to remote debug a UWP app, you need to ensure that both the Windows 10 on ARM device and the developer PC are on the same network subnet. As the Windows 10 on ARM device is probably connected to WiFi, you will likely need to WiFi connect your developer PC too.

In the following steps I will walk through the creation of blank UWP app and the steps to remote debug it – note that this is the same process for remote debugging on an x86/x64 Windows Desktop as well.

  1. On the developer machine, Open Visual Studio
  2. Choose “Create New Project”, “Visual C#”, “Windows Universal” and then select the “Blank App” template. I named the app “RemoteTest”.
  3. When the target/minimum platform dialog appears, chose “Windows 10 Fall Creators Update (10.0; Build 16299)” as the target Version, and “Windows 10 November Update (10.0; Build 10586)” as the Minimum version.
  4. Once the solution has been created and loaded, ensure the build platform is x86 or ARM (at the time of writing only x86 is working reliably for me but ARM should work fine – x64 is not supported) and you need to change the execution target to “Remote Machine”:
    1. clip_image002
  5. The “Remote Connections” dialog will be displayed. You may also see a firewall prompt the first time you display this dialog – “Allow Access”:
    1. clip_image002[11]
  6. If the network is setup correctly, Visual Studio will then automatically detect your remote systems (if not, check that “Device discovery” is enabled in the ""Developers features” settings on the remote machine). In the image below, the Windows 10 on ARM device is auto detected:
    1. clip_image002[5]
  7. Select the desired remote:
    1. clip_image002[7]
  8. Once Visual Studio has updated the configuration of the project, you can run with debugging by hitting F5 or by selecting “Remote Machine":
    1. clip_image002[9]
  9. This should launch a build – you can watch the build progress in the output window. You will see the following tasks:
    1. The build task start and complete
    2. The deploy task start (note: that you may see a firewall prompt on the remote machine during this process –”Allow Access”).
      1. clip_image001
    3. The first time you deploy may take a few minutes to complete. Also, Visual Studio may display a message informing you that remote operations are taking longer than expected – be patient. The Deploy task has the following stages:
      1. Updating the layout
      2. Copying files
      3. Checking whether frameworks are installed (any missing frameworks on the remote machine will be installed as necessary)
      4. Registering the application to run from layout
      5. Deployment complete
    4. The app should then launch on the remote machine.
  10. At this point you can set breakpoints and debug as you would expect.

I hope this post shows that there is no arcane magic needed to develop and test UWP applications on Windows 10 for ARM. You can also see that x86 applications run perfectly well.


Comments are closed