Port x64 Windows projects to Windows on Snapdragon using agentic AI

WoS Porter in a nutshell

WoS Porter comprises AI-powered agents that automatically port open-source x64 Windows applications to native Snapdragon. We offer it as a GitHub Copilot VS Code extension, a Claude Code plugin, and an OpenAI Codex plugin so you can use it with whichever AI coding tool you already use. It automates code and build system migration, SSE/AVX-to-NEON conversion, MSVC builds, binary validation, testing, and NEON optimization.

Point WoS Porter at a GitHub repository URL or a local path to an x64 project. It will have following 8 steps as part of the tool:

1. Analyze the codebase : Analyze the repo for x64-specific code (SIMD intrinsics, inline assembly, architecture guards)
2. Preparation for build system : Port the build system by adding targets to CMake, MSBuild, Meson, Cargo, and 15+ other build systems
3. Porting of code : Port the source code, translating SSE/AVX intrinsics to NEON, adding preprocessor guards, and fixing calling conventions
4. Building the project: Build the project for Snapdragon using MSVC, iteratively fixing compilation errors
5. Validation for ARM64 Architecture : Validate every output binary with dumpbin to confirm Arm64 architecture
6. Test and benchmark results : Run tests on Snapdragon hardware (when available)
7. Optimization : Apply hand-written <arm_neon.h> NEON optimizations to hot kernels for maximum performance
8. Report generation : Generate an ARM64-PORT.md report and a series of clean commits on the arm64-port branch, ready to review and merge

Why WoS Porter?

Porting software involves far more than recompiling code. At a minimum, you’ll need to:

• translate x86 SIMD intrinsics
• update build systems
• resolve architecture-specific compilation issues
• debug Snapdragon-only runtime failures
• carefully optimize performance-critical code using NEON

Those tasks require significant expertise and, without automation and specialized tooling, can consume long stretches of engineering effort. As shown in the tables below, WoS Porter compresses weeks of senior engineering time into hours, with benchmark-validated results.

Level	Typical Libraries / Applications	Projected Effort Saved
Simple	zlib, Audacity, Crypto++, wuffs, CRC32C, SWIG	90-100%
Medium	NumPy, KiCad, Halide, gemmlowp, libgav1	60-70%
Complex	Skia, xsimd, IFCOpenShell	40-50%

Table 1: Porting effort reduction

 

Workload	Pre-Optimization	Post-Optimization	Improvement	Manual Effort (days)	AI-Assisted Effort (hours)
Crypto++ SM4	127 MiB/s	307 MiB/s	2.5×	6-8	4-6
CRC32C 4KB	4.45 GB/s	23.12 GB/s	5.20×	8-10	20-24
SQLite Workload	595.916 s	556.177 s	1.07×	10-12	10-14
OpenCV Rotate	0.578 ms	0.217 ms	2.67×	10-12	20-24
OpenCV Norm Mask	0.90 ms	0.32 ms	2.82×	10-12	20-24

Table 2: Manual vs. AI-assisted porting and optimization effort

Setting up WoS Porter

System requirements:

• Visual Studio 2022 with the MSVC v143 Arm64/Arm64EC build tools and Windows 11 SDK
  
  
• GitHub Copilot extension, Claude Code, or OpenAI Codex CLI — installed and authenticated
  
  
• VS Code 1.100+ (for Copilot or Claude Code or Codex VS Code extension) Claude Code CLI or Codex CLI
  
  
• git in PATH

We’ve posted a Get Started procedure to help you set up WoS Porter.

Once you’ve set up the agent, you can start using it to port and optimize applications and libraries. Have a look at the typical scenarios below for using WoS Porter.

Scenario 1: Use agentic AI to port an x64 Windows app or library to Windows on Snapdragon

Open your preferred AI coding tool and select the WoS Porter agent. For this scenario, you’ll pass the project URL or local path with WOS_SKIP_OPTIMIZE=1 to run only the porting, build, and test phases (skipping NEON optimization).

Note: To ensure full automation, enable command auto-approval before starting.

• GitHub Copilot (VS Code extension)

or

• Claude Code (plugin)

or

• Codex (plugin)

or

In this scenario, WoS Porter executes the following tasks/phases automatically:

1. Clones the repository.
2. Ports the build system and source code.
3. Builds for Snapdragon.
4. Validates every output binary with dumpbin.
5. Runs tests.
6. Generates ARM64-PORT.md with a series of clean commits on the arm64-port branch, ready to review and merge.
7. NEON optimization is skipped in this scenario. (See Scenario 2.)
8. If the agent stops midway, you can re-prompt it to continue the remaining phases.

Scenario 2: Use agentic AI to port and optimize x64 Windows app or library to Windows on Snapdragon

Open your preferred AI coding tool, select the WoS Porter agent, and pass the project URL or local path.

No flags are required. By default, the agent executes all 8 phases, including NEON optimization.

• GitHub Copilot

or

• Claude Code

or

• Codex CLI

or

In this scenario, WoS Porter runs the full 8-phase pipeline:

Phase	Purpose	Key Activities
1. Setup	Prepare repository for enablement	Clone repository, create arm64-port branch, detect coding style and commit conventions
2. Analyze	Assess readiness	Scan SIMD/assembly usage, audit dependencies, review CI/build configuration
3. Port	Enable support in source code	Convert platform-specific code, update build configurations, make required code changes
4. Dependencies	Resolve build requirements	Identify and configure project dependencies and toolchain requirements
5. Build	Achieve successful compilation	Build the project, fix compilation/linker errors, validate binaries
6. Test	Verify functionality	Run test suites, debug failures, execute performance benchmarks
7. Optimize	Improve performance	Replace bottlenecks with NEON optimizations, analyze coverage and performance gaps
8. Report	Deliver final results	Generate ARM64-PORT report, document build steps, benchmark results, and clean commits

If the agent stops midway, you can re-prompt it to continue the remaining phases.

The optimization in Phase 7 uses a coverage-driven approach. The optimizer:

• Reads benchmark results from Phase 6
• Identifies hot kernels with benchmark coverage
• Applies hand-written <arm_neon.h> intrinsics only to those functions

Each NEON implementation is benchmark-gated; that is, it is kept only if Arm64 performance improves. The implementation is discarded if no improvement is observed.

Functions already performing well are left unchanged. If the token budget is exhausted, the optimizer writes optimizer-deferred.json. The optimizer can be resumed for up to three additional invocations, for a total of four.

 

Consideration	Details
Deep assembly not in scope	Phase 7 optimization targets C/C++ intrinsic level only; hand-written .asm or compiler-backend tuning is out of scope.
Snapdragon host required for Phase 6	Benchmarks must run natively on Snapdragon; cross-compiled builds cannot produce the baseline Phase 7 gates against.

 

Table 3: Considerations, scenario 2

The table below summarizes the increase in performance and the reduction in effort.

Workload	Performance before optimization	Performance after optimization	Performance improvement	Effort, manual (days)	Effort, AI-assisted (hours)
Crypto++SM4	127 MiB/s	307 MiB/s	2.5x	6-8	4-6
CRC32C 4KB	4.45 GB/s	23.12 GB/s	5.20x	8-10	20-24
SQLite full workload	595.916 s	556.177 s	1.07​x	10-12	10-14
OpenCV rotate	0.578 ms	0.217 ms	2.67x	10-12	20-24
OpenCV norm_mask	0.90 ms	0.32 ms	2.82x	10-12	20-24

Table 4: Before and after WoS Porter

Scenario 3: Use agentic AI to port, optimize, and compare application performance against x64 on Windows on Snapdragon

This scenario uses the differential optimization path. WoS Porter performs the following:

1. Aligns x64 and Arm64 benchmark results.
2. Finds functions where native Snapdragon is at least 15% slower.
3. Applies hand-written <arm_neon.h> intrinsics to those functions.
4. Skips functions already at parity.

Note: If an x64 benchmark result is already present in x64_benchmark/, then start with Step 2.

Step 1 - Capture the x64 baseline from an x64 machine.

This clones the project, builds it for x64, runs benchmarks, and stores results under x64_benchmark/.

• GitHub Copilot

• Claude Code

• Codex CLI

Step 2 - Port and optimize using x64 baseline on Windows on Snapdragon.

• GitHub Copilot

• Claude Code

• Codex CLI

or

Considerations	Details
x64 baseline required	WOS_X64_BENCH must point to a valid x64 benchmark results file.
Snapdragon host required	Benchmarking must be executed on native Snapdragon hardware.
Gap threshold	Only functions that are ≥ 1.15× slower than x64 are targeted for optimization.
No shims	Uses only hand-written <arm_neon.h> intrinsics; no shim layers are introduced.
Budget limit	Up to three additional resume cycles may be required to complete the optimization process, for a total of four.

Table 5: Considerations, scenario 3

Benchmark	x64	Arm64 (Pre-Optimization)	Arm64 (Post-Optimization)	Improvement Arm64	Status
SM4	300 MiB/s	127 MiB/s	307 MiB/s	2.5×	Improved
CRC32C (4 KB)	22 GB/s	4.45 GB/s	23.12 GB/s	5.20×	Improved

Table 6: Sample final report, scenario 3

Note: Dependency readiness on Windows on Snapdragon is a hidden challenge, and MediaPipe is a good example of why porting to Snapdragon is often a dependency challenge rather than an application challenge.

While enabling MediaPipe on Windows on Snapdragon, we encountered multiple issues within dependencies such as TensorFlow Lite and Halide.  Those issues included build failures, toolchain incompatibilities, and missing support for Snapdragon. In several cases, resolving dependency and build-system issues required more effort than the specific code changes for Snapdragon themselves.

The main lesson is simple: Plan to port the dependency graph, not just the application. For complex projects, dependency readiness is often the critical path to successful enablement.

Next steps

We continue working with Microsoft to make it easy to develop, test and run your apps on Windows on Snapdragon. We’re keeping Windows on Snapdragon in sync with Microsoft’s initiative, with results like these:

• 2000 native apps
• Top 200+ Steam titles
• 10,000+ printers and peripherals
• 1200+ models running on Qualcomm Hexagon neural processing unit (NPU)
• 220+ enterprise IT applications

Have a look at WoS Porter in our GitHub repo. Gauge the fit with your plans for Windows on Snapdragon, then install it and try it on apps and libraries you want to port to Snapdragon.

If you have questions or want help, contact us at Qualcomm Developers on Discord.