How to Run Raspberry Pi Win 11 ARM64 on the Pi 5 (2026 Setup)

If you want to run a full desktop OS on a maker board, the Raspberry Pi Win 11 ARM64 route is the most capable option available in 2026. But let's get the reality check out of the way first: you cannot run standard x86 Windows 11 on a Pi, and running it off a microSD card will result in a miserable, pagefile-thrashing experience. To do this right, you need a Raspberry Pi 5 (8GB), an NVMe SSD, and the Windows on Raspberry (WoR) project's UEFI firmware to bridge the hardware gap.

This guide covers the exact hardware requirements, the NVMe flashing process, and how to write C# .NET 8 code to control the Pi 5's new RP1 GPIO southbridge under Windows 11.

Hardware Realities: Pi 4 vs Pi 5 for Windows 11

While early adopters forced Windows 11 onto the Pi 4, the Pi 5's architecture change—specifically the move from the BCM2711 to the BCM2712 CPU and the dedicated RP1 I/O controller—fundamentally changes how Windows interacts with the hardware. The RP1 chip handles all GPIO, USB, and Ethernet, meaning Windows must enumerate it over an internal PCIe link rather than reading memory-mapped registers directly.

Parts List & Hardware Pin Mapping

Before we flash the drive, gather these exact components. Prices reflect early 2026 market rates.

• Compute: Raspberry Pi 5 (8GB) Rev 1.0 ($80)
• Thermal: Official Pi 5 Active Cooler ($5) - Do not use passive heatsinks; the PMIC will throttle under Win 11 background tasks.
• Storage Interface: Official Raspberry Pi M.2 HAT+ or Pimoroni NVMe Base ($12-$15)
• Storage: 256GB M.2 2230/2242 NVMe SSD (e.g., WD SN740) ($25)
• Power: Official 27W USB-C PD Power Supply ($12)

Pin Mapping for .NET GPIO

When writing C# for Windows 11 on the Pi 5, the System.Device.Gpio library uses BCM numbering, not physical pin numbers. The RP1 chip maps these identically to the BCM2711 legacy numbers for compatibility.

Step-by-Step: Flashing Windows 11 ARM64 to NVMe

We use the Windows on Raspberry (WoR) project's configurator. This tool injects the necessary EDK2 UEFI firmware and ARM64 drivers into a Windows 11 IoT Enterprise or Pro ARM64 ISO.

1. Assemble the Hardware: Attach the Active Cooler, mount the NVMe SSD to the M.2 HAT+, and connect the HAT+ to the Pi 5's PCIe FPC connector. Boot into Raspberry Pi OS first to update the bootloader EEPROM and enable PCIe Gen 3.
2. Prepare the Host PC: Download the WoR Configurator on a Windows x86/x64 host. Download a Windows 11 ARM64 ISO (via UUP Dump or Microsoft Evaluation Center).
3. Configure WoR: Select your Pi 5 (8GB) model, point to the Win 11 ARM64 ISO, and select your USB-to-NVMe adapter (or remove the SSD and use an M.2 USB enclosure for flashing).
4. UEFI Settings (Critical): In the WoR advanced settings, ensure 'Expose GPIO via ACPI' is checked. Without this, the RP1 chip's GPIO pins will not be mapped to the Windows HAL, and your .NET code will fail.
5. Flash and Transfer: Let the tool flash the drive. Once complete, install the NVMe SSD back onto the Pi 5 M.2 HAT+ and power on.
6. First Boot: The Pi will boot into the WoR UEFI environment, then chainload the Windows bootloader. Initial setup takes about 15 minutes. Connect via Ethernet for driver fetching.

The Code: C# .NET 8 GPIO Control on Windows 11

This code targets the Raspberry Pi 5 (8GB) Rev 1.0 running Windows 11 ARM64. It uses the System.Device.Gpio NuGet package to blink an LED when a button is pressed.

using System;
using System.Device.Gpio;
using System.Threading;

namespace Pi5Win11Gpio
{
    class Program
    {
        // Target Board: Raspberry Pi 5 (8GB) Rev 1.0
        // Pin Definitions (BCM numbering mapped via RP1 ACPI)
        const int LedPin = 18;      // Physical Pin 12
        const int ButtonPin = 19;   // Physical Pin 35

        static void Main(string[] args)
        {
            Console.WriteLine("Initializing GPIO on Windows 11 ARM64...");
            
            // Initialize the GPIO Controller
            // On Pi 5 Win 11, this relies on the UEFI ACPI tables mapping the RP1 chip
            GpioController controller = null;
            
            try
            {
                controller = new GpioController(PinNumberingScheme.Logical);
                
                controller.OpenPin(LedPin, PinMode.Output);
                controller.OpenPin(ButtonPin, PinMode.InputPullUp);
                
                Console.WriteLine("Pins opened. Press the button to toggle the LED. Ctrl+C to exit.");
                
                bool ledState = false;
                
                while (true)
                {
                    // Read button (Active Low due to PullUp)
                    if (controller.Read(ButtonPin) == PinValue.Low)
                    {
                        ledState = !ledState;
                        controller.Write(LedPin, ledState ? PinValue.High : PinValue.Low);
                        Console.WriteLine($"Button pressed. LED state: {ledState}");
                        
                        // Software debounce delay
                        Thread.Sleep(250); 
                    }
                    Thread.Sleep(20);
                }
            }
            catch (PlatformNotSupportedException pex)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine($"FATAL: {pex.Message}");
                Console.WriteLine("Fix: Ensure WoR UEFI firmware is exposing RP1 GPIO via ACPI.");
                Console.ResetColor();
            }
            catch (IOException ioex)
            {
                Console.ForegroundColor = ConsoleColor.Yellow;
                Console.WriteLine($"IO Error: {ioex.Message}");
                Console.WriteLine("Fix: Pin is likely reserved by another driver (e.g., SPI/I2C overlay).");
                Console.ResetColor();
            }
            finally
            {
                if (controller != null)
                {
                    if (controller.IsPinOpen(LedPin)) controller.ClosePin(LedPin);
                    if (controller.IsPinOpen(ButtonPin)) controller.ClosePin(ButtonPin);
                    controller.Dispose();
                }
            }
        }
    }
}

Debugging: 'No GPIO controller is available' and Boot Failures

Running hardware-level code on a desktop OS layered over a maker board introduces unique failure modes. If your code crashes immediately, you will likely see this exact error string:

System.PlatformNotSupportedException: No GPIO controller is available on this device.

Ranked Causes and Fixes

1. Missing RP1 ACPI Mapping (Most Likely): The Pi 5's GPIO is handled by the RP1 chip. If you used an older WoR configurator version or unchecked the ACPI GPIO injection, Windows sees the CPU but not the I/O controller. Fix: Re-flash the NVMe drive using WoR PE v2.3.0 or newer, ensuring the RP1 PCIe endpoint is enumerated.
2. Driver Collision: Windows Update may have silently installed a generic BCM2712 driver that conflicts with the WoR custom HAL. Fix: Open Device Manager, find 'System Devices', and roll back the 'BCM2712 RP1 GPIO Controller' driver.
3. Architecture Mismatch: You compiled your .NET app for win-x64 and are running it under Windows 11's x86 emulation layer. The emulation layer cannot pass hardware interrupts to the GPIO controller. Fix: Recompile strictly for win-arm64.

The First Three Things to Check When It Fails

Extending and Simplifying the Build

How to Simplify

If your goal is purely to read sensors and toggle relays, do not use Windows 11. The overhead of the Windows HAL, Defender background scans, and the RP1 PCIe latency makes real-time bit-banging impossible. Simplify the build by flashing Raspberry Pi OS (Bookworm) and using Python with the gpiozero library. You will drop your boot time to 8 seconds and your GPIO latency to under 2 µs.

How to Extend

If you need Windows 11 for its edge AI capabilities (e.g., running ONNX Runtime or Windows ML models) but still need hardware control, extend the build by adding a USB-to-UART bridge (like an FT232RL) or an MCP2221A I2C/USB bridge. By offloading the sensor reading to a dedicated microcontroller (like an Arduino Nano) and passing the data to the Pi 5 via a virtual COM port, you bypass the Windows GPIO latency entirely while keeping the heavy compute on the Windows ARM64 desktop.