Windows arm64 not supported (yet)

[SideFx]

Compilation error on Windows arm64:
C:\Users\janbu\go\pkg\mod\github.com\go-webgpu\goffi@v0.4.2\internal\arch\arm64\implementation.go:16:16: cannot use &Implementation{} (value of type *Implementation) as arch.FunctionCaller value in argument to arch.Register: *Implementation does not implement arch.FunctionCaller (missing method Execute)

See issue at https://github.com/orgs/gogpu/discussions/156.

[kolkov]

Thanks for filing this, @SideFx! We're excited to see gogpu interest on Snapdragon X hardware — Windows ARM64 is definitely something we want to support.

Root cause

The ARM64 Execute method is in call_unix.go (build-tagged !windows), so on Windows ARM64 the Implementation struct doesn't satisfy the arch.FunctionCaller interface → compile error.

Windows ARM64 uses a different calling convention than Unix ARM64 (AAPCS64). We need a new call_windows_arm64.go + call_windows_arm64.s with Win ARM64 ABI specifics (different volatile/non-volatile register sets, structured exception handling, different stack parameter rules).

Plan

• Research Win ARM64 calling convention (ARM64EC vs native ARM64)
• Implement call_windows_arm64.go + assembly
• Add CI target for windows/arm64
• Test on real hardware

We'll handle the implementation — the main thing we'd need from you is testing on your device when we have a draft branch ready. Would you be up for that? Just building and running a test binary, nothing complex.

Stay tuned on this issue — we'll ping you when there's something to try.

[kolkov]

@SideFx We have a branch ready for testing: feature/windows-arm64

What changed

Windows ARM64 uses the same AAPCS64 calling convention as Linux/macOS ARM64. We extended the build tags of existing ARM64 files to include Windows — no new assembly, same proven code path. runtime.cgocall works on Windows without fakecgo (Go runtime explicitly exempts Windows).

How to test

Step 1: Build

git clone https://github.com/go-webgpu/goffi.git
cd goffi
git checkout feature/windows-arm64
go build ./...

If this succeeds — the compilation error from your original report is fixed.

Step 2: Run tests

go test -v ./ffi ./types

All tests should pass. The TestCallPrintf test calls printf from msvcrt.dll — this validates that FFI calls actually work on your hardware.

Step 3: Smoke test (optional but very helpful)

Create a file test_arm64.go:

package main

import (
	"fmt"
	"github.com/go-webgpu/goffi/ffi"
	"github.com/go-webgpu/goffi/types"
	"unsafe"
)

func main() {
	lib, err := ffi.LoadLibrary("kernel32.dll")
	if err != nil {
		panic(err)
	}
	defer ffi.FreeLibrary(lib)

	fn, err := ffi.GetSymbol(lib, "GetCurrentProcessId")
	if err != nil {
		panic(err)
	}

	cif, err := ffi.PrepareCallInterface(types.ABI_DEFAULT, nil, types.UInt32TypeDescriptor)
	if err != nil {
		panic(err)
	}

	var result uint32
	err = ffi.CallFunction(cif, fn, unsafe.Pointer(&result), nil)
	if err != nil {
		panic(err)
	}
	fmt.Printf("goffi on Windows ARM64: PID = %d\n", result)
	fmt.Println("Success!")
}

go run test_arm64.go

Expected output:

goffi on Windows ARM64: PID = <some number>
Success!

What we need from you

Please report:

1. Does go build ./... succeed? (fixes your original error)
2. Does go test -v ./ffi ./types pass?
3. Does the smoke test print the correct PID?
4. Your Go version (go version)

Thank you for volunteering to test — if this works, gogpu becomes the first Go GPU framework on Snapdragon X!

[SideFx]

This is ideed exciting news. I've managed to run the test which IMHO succeeded (pls see attached log). The smoke test returned the old error, I guess it did not fetch the new branch? I've included this, too.
Edit: Go version is 1.26.1 (from the MSYS2 clangarm64 repo)

goffi_smoke_test.zip
test_log.zip

[kolkov]

@SideFx This is great news -- all tests pass on Snapdragon X Elite! 🎉

The test log confirms real FFI calls work correctly on Windows ARM64:

• TestCallPrintf -- called printf from msvcrt.dll successfully
• TestWindowsStackArgumentsFileIO -- CreateFileA/WriteFile/ReadFile with 7+ args, data integrity verified
• TestWindowsStackArguments10Args -- CreateProcessA with 10 args, exit code 42 confirmed

About the smoke test

The smoke test used require github.com/go-webgpu/goffi v0.4.2 in go.mod -- that's the released version which doesn't have the fix yet. To test with the branch, you need a replace directive:

go mod edit -replace github.com/go-webgpu/goffi=../goffi

(assuming the cloned goffi repo is in ../goffi relative to your smoke test directory)

But honestly, the test suite already covers everything the smoke test would -- including actual kernel32.dll calls with multiple arguments. So this is confirmed working.

Next steps

We'll create a PR, merge to main, and tag a new release. Once released, gogpu will work on your Snapdragon X out of the box. Will update here when it's ready.

Thank you for testing -- gogpu is now the first Go GPU framework with Windows ARM64 support!