Python Win Arm64 Gha Wheel Builder

GitHub Actions Windows ARM64 wheel builder

You are a CI/CD specialist. Your task is to add a native Windows ARM64 wheel build to this repository's GitHub Actions build/release workflow using the windows-11-arm runner image.

Context

Many Python package repositories use GitHub Actions workflows to produce platform wheels for PyPI. Common targets include Linux x86_64/aarch64, macOS (universal2 or separate x86_64/arm64), and Windows AMD64 — but Windows ARM64 is often missing.

GitHub now provides a native windows-11-arm runner that can build ARM64 Windows wheels without cross-compilation.

Pre-flight Checks

Before modifying the workflow, verify the following:

cibuildwheel version (if applicable)

If the workflow uses cibuildwheel, native win_arm64 support requires cibuildwheel ≥ 2.11.2. If the workflow pins an older version (e.g. in requirements-dev.txt or the action's version input), update it to a compatible release before proceeding.

Python version support

Not all Python versions have Windows ARM64 wheels available. Check the documentation for the specific build tool used (e.g. cibuildwheel, maturin, raw pip) to determine the minimum supported Python version for win_arm64. When constructing the ARM64 matrix entries, omit Python versions that are not supported — attempting to build unsupported versions will fail. Prefer updating targeted strategy.exclude entries or conditional matrix rules rather than broad changes that alter the supported AMD64 set. Do not assume the same Python version range used for Windows AMD64 is valid for ARM64.

Instructions

1. Locate the build workflow

Find the GitHub Actions workflow file that builds wheels (commonly .github/workflows/build.yml or similar). Look for jobs that invoke cibuildwheel or otherwise produce .whl artifacts.

Some repositories wrap the real build logic in a reusable workflow (workflow_call) or a composite action under .github/actions/. Trace through those indirections and update the actual source of the wheel-building logic, not just the thin wrapper workflow.

If the repository already contains a Windows ARM64 entry or job, do not add a duplicate. Instead, normalize or fix the existing configuration so it uses the correct runner and architecture-specific settings.

2. Add a Windows ARM64 entry to the build matrix

If the workflow uses separate jobs per platform rather than a strategy matrix, create a Windows ARM64 sibling job by copying the existing Windows AMD64 job and changing only the platform-specific fields.

In the strategy matrix of the wheel-building job, add a new entry for Windows ARM64. Follow the naming conventions already used in the matrix (e.g., if existing entries use identifiers like win_amd64, manylinux_x86_64, etc., choose a consistent name such as win_arm64).

If the workflow already uses strategy.exclude or similar conditional logic, update those rules so unsupported Windows ARM64 and Python combinations are excluded explicitly without affecting the existing supported platforms.

CIBW_BUILD filter: If the workflow sets CIBW_BUILD to an explicit allow-list of wheel tags (e.g. cp39-win_amd64 cp310-win_amd64 ...), the ARM64 entries must be added to that list as well (e.g. cp39-win_arm64 cp310-win_arm64 ...). Without this, cibuildwheel will silently skip the ARM64 wheels even when running on the correct runner. Use a matrix variable or conditional expression to set the appropriate value per platform so existing AMD64 entries are unaffected.

3. Map the new entry to the windows-11-arm runner

Ensure the new matrix entry resolves to the windows-11-arm runner. Follow the same pattern the workflow already uses to map matrix entries to runner labels (e.g., via include blocks, conditional expressions, or direct os values in the matrix).

Reuse the existing matrix variable: If the runner image passed to runs-on for the Windows AMD64/x64 build is supplied through a matrix variable (e.g., runs-on: ${{ matrix.os }} or runs-on: ${{ matrix.runner }}), set the ARM64 entry's image through that same matrix variable (e.g., add a matrix entry with os: windows-11-arm). Do not introduce a complicated conditional expression in runs-on to select the ARM64 image when the existing matrix variable can carry windows-11-arm directly.

windows-latest disambiguation: If the existing Windows AMD64 job uses windows-latest as its runner label, do not use a variant of windows-latest for the ARM64 entry. Always set the ARM64 runner explicitly to windows-11-arm so the correct native hardware is selected.

4. Set up MSVC for ARM64 when the workflow already configures MSVC for x64

If the workflow uses ilammy/msvc-dev-cmd (or a similar action) to set up MSVC for x64 Windows wheel builds, add an equivalent MSVC setup step for ARM64 on the windows-11-arm runner. The new step should use the arm64 architecture and be conditioned so it only runs on the ARM64 runner.

Also guard the existing x64 MSVC setup steps so they only run on the original Windows job/entry and not on windows-11-arm. Prefer conditions based on the matrix or job metadata (such as platform ID, architecture, or target) rather than broad checks like runner.os == 'Windows' or hardcoded runner-label checks. This ensures each entry only configures the MSVC toolchain it actually needs.

Direct Visual Studio script invocations: Some workflows invoke Visual Studio developer environment scripts directly instead of using a GitHub Action (e.g. call "C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\Common7\Tools\VsDevCmd.bat" or vcvarsall.bat). The windows-11-arm runner ships with Visual Studio 2022, and VS2019 may not be installed or may lack ARM64 toolchain support. When creating the ARM64 job or matrix entry, check for hardcoded paths to VS2019 scripts and update them to their VS2022 equivalents:

• C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\... → C:\Program Files\Microsoft Visual Studio\2022\Enterprise\...

• Change the -arch= argument to arm64 (e.g. -arch=amd64 → -arch=arm64).

Note that VS2022 installs under Program Files (not Program Files (x86)). If the existing x64 job and the ARM64 job are separate, only change the path in the ARM64 job — leave the existing x64 job's VS2019 reference untouched. If they share steps via a matrix, use a matrix variable or conditional expression to select the correct Visual Studio path and architecture per entry.

5. Pass arm64 to actions/setup-python when an architecture is specified

If the workflow's actions/setup-python step includes an architecture option (e.g., architecture: x64), ensure the ARM64 matrix entry passes arm64 as the architecture value. Use a matrix variable or conditional expression so existing entries are unaffected.

If the setup-python step does not specify an architecture option at all, do not add one.

setup-python version support: If the existing Windows AMD64 job uses the setup-python action, it only supports Python versions 3.11 or greater for Windows ARM64.

6. Use the correct Rust/cargo/maturin target for ARM64

When the workflow builds a Rust component (via maturin, setuptools-rust, raw cargo, or by adding a Rust target with rustup), ensure the ARM64 entry uses the target aarch64-pc-windows-msvc. This is the correct Rust target triple for native Windows ARM64 builds.

Always use the full aarch64-pc-windows-msvc triple for Rust targets — never arm64 or the shortened form aarch64. arm64 is a valid value in other ARM64 contexts (e.g. the actions/setup-python architecture input, MSVC arch, or CIBW_ARCHS), but it should not be used as a Rust target. Use aarch64-pc-windows-msvc in every Rust target position.

• Whenever a Rust target is specified — including rustup target add (e.g. rustup target add aarch64-pc-windows-msvc) — use aarch64-pc-windows-msvc for the ARM64 entry. If setuptools-rust (or another tool that invokes cargo indirectly) is used, the target is typically installed this way in a setup step or CIBW_BEFORE_ALL; make sure the ARM64 target is added there.

• In maturin-action, set the target input to aarch64-pc-windows-msvc. Use that same target when running the build through an action such as PyO3/maturin-action (set its target input to aarch64-pc-windows-msvc).

• For raw cargo build or cargo test invocations, pass --target aarch64-pc-windows-msvc.

7. Test commands — match existing x64 Windows behaviour

Do not add ARM64-specific test commands or overrides (such as CIBW_TEST_COMMAND_WINDOWS) unless the workflow already defines Windows-specific test configuration for the x64 build. The ARM64 build should receive the same test treatment as the existing Windows AMD64 build.

If the existing workflow uses a generic CIBW_TEST_COMMAND (even one that invokes bash) and does not add a Windows-specific variant for x64, do not add one for ARM64 either. Keep the two Windows targets symmetrical.

8. Configure cibuildwheel for the ARM64 architecture (if using cibuildwheel)

Check whether cibuildwheel needs an explicit CIBW_ARCHS_WINDOWS override. When building natively on a windows-11-arm runner, cibuildwheel's default auto-detection will already target ARM64. Only add CIBW_ARCHS_WINDOWS if the workflow already sets it or if the default behaviour needs to be overridden (e.g., if both AMD64 and ARM64 share a runner and the architecture must be disambiguated via a matrix conditional).

If an override is necessary, use a conditional expression tied to the matrix entry so existing AMD64 builds are unaffected. Place it alongside any existing CIBW_ARCHS_LINUX or CIBW_ARCHS_MACOS variables. If no override is needed, do not add one.

9. Review CIBW_BEFORE_BUILD and CIBW_BEFORE_ALL scripts (if using cibuildwheel)

If the workflow defines CIBW_BEFORE_BUILD or CIBW_BEFORE_ALL commands that install native dependencies (e.g. via choco install, vcpkg install, or similar package managers), verify that the packages and their versions are available for ARM64. Update these scripts as needed — for example, specifying an ARM64 package variant or a different install command — conditioned on the ARM64 matrix entry so existing builds are unaffected.

10. Install PyTorch dependencies from the PyTorch download index on ARM64

If the build or test steps install a PyTorch dependency (e.g. torch, torchvision, torchaudio) via pip, note that — as of May 2026 — PyTorch wheels are not published on PyPI for Windows ARM64 (win_arm64). A plain pip install torch on the windows-11-arm runner will therefore fail or pull an incompatible wheel.

For the ARM64 entry, install the PyTorch dependency from the PyTorch download index instead of PyPI by adding an index URL:

• https://download.pytorch.org/whl — for the default (e.g. CUDA-tagged) wheels.

• https://download.pytorch.org/whl/cpu — for the CPU-only build variant.

Pass it to pip via --index-url (or --extra-index-url), for example pip install torch --index-url https://download.pytorch.org/whl/cpu. Use a matrix variable or conditional expression so the index URL is only applied to the ARM64 entry and existing x64/Linux/macOS installs (which can resolve PyTorch from PyPI) are unaffected.

11. Set compiler environment variables for ARM64 when the workflow builds LLVM

If the workflow manually builds LLVM or a project that depends on LLVM (e.g. via CMake), ensure the ARM64 job sets the appropriate compiler environment variables to use the LLVM-based toolchain for native Windows ARM64 builds.

• Set CC=clang-cl and CXX=clang-cl environment variables (or the CMake equivalents -DCMAKE_C_COMPILER=clang-cl -DCMAKE_CXX_COMPILER=clang-cl).

• If a Fortran compiler is needed, set FC=flang (or the CMake equivalent -DCMAKE_Fortran_COMPILER=flang).

• Use a matrix variable or conditional expression so existing x64 Windows, Linux, or macOS entries that may use a different compiler (e.g. gfortran) are unaffected.

12. Verify artifact upload names are unique

If artifacts are uploaded with names derived from the matrix (e.g., wheels-${{ matrix.platform_id }}-${{ matrix.python }}), ensure the new win_arm64 entry produces a distinct artifact name. Most matrix-based naming schemes will handle this automatically.

13. Add Windows ARM64 test runs when x64 Windows tests already exist

Search all workflow files under .github/workflows/ for jobs that run tests on Windows x64 (e.g., windows-latest, windows-2022, windows-2019, or any runner with an x64 architecture). These test jobs may live in the same workflow file as the wheel build or in a separate workflow file (e.g., ci.yml, tests.yml, test.yml).

If Windows x64 test jobs exist, either in the same workflow file or a different one, mirror the existing Windows x64 test configuration — same steps, same dependencies, same test commands — changing only the runner and architecture-specific settings and only skipping steps and tests if they are incompatible with Windows ARM64.

When adding the ARM64 test entry:

• Use windows-11-arm as the runner.

• If actions/setup-python specifies architecture: x64, add a matrix variable or conditional so the ARM64 entry passes architecture: arm64. If no architecture is specified, do not add one.

• Only include Python versions that are supported on Windows ARM64 (3.11+ for actions/setup-python). If the x64 matrix tests older Python versions, exclude them from the ARM64 entries using strategy.exclude, matrix conditionals, or by constructing a narrower version list for ARM64.

• If the test job uses MSVC setup (e.g., ilammy/msvc-dev-cmd), apply the same ARM64 MSVC guidance from step 4.

• If the test job installs native dependencies (e.g., via choco, vcpkg), verify ARM64 availability as described in step 9.

• Ensure any artifact download or upload names remain unique.

If no Windows x64 test jobs exist in any workflow file, skip this step.

14. Leave unrelated jobs unchanged

Do not modify source-distribution builds, pure-Python wheel builds, or publish jobs unless they are directly affected by the new platform entry.

15. Validate

• Confirm the workflow YAML is valid (e.g., run actionlint).

• If repository access permits, verify that the new ARM64 matrix/job entry is wired correctly using the repo's normal CI validation flow or a test build. If triggering CI is not possible in the current environment, still ensure the configuration is internally consistent and ready to run.

Acceptance Criteria

• The wheel-building matrix or job set includes a Windows ARM64 entry that runs on windows-11-arm.

• The repository's wheel-building path (cibuildwheel, maturin, or equivalent) is configured to produce ARM64 wheels on that runner.

• All existing platform builds (Linux, macOS, Windows AMD64) remain intact; no previously supported artifacts regress, and ARM64 artifacts are added for all supported combinations.

• Artifact names remain unique across all matrix combinations.

• The workflow YAML is syntactically valid.

• No unsupported Python version ARM64 wheel builds are attempted.

• If any workflow file contains Windows x64 test jobs, a corresponding Windows ARM64 test job or matrix entry has been added using windows-11-arm, with unsupported Python versions excluded.

• Only if the workflow already contains logic that derives or modifies the job name based on the architecture, the job name logic is extended so the Windows ARM64 entry produces a distinct, architecture-specific name (e.g. one that identifies it as arm64/win_arm64). If the workflow has no architecture-dependent job naming logic, the job name is left unchanged.

• Re-running the agent does not duplicate an existing Windows ARM64 entry or job.