feat(windows): Add Windows ARM64 support (#26215)

2026-02-02 15:08:46 +00:00 · 2026-01-22 04:22:45 -08:00
parent 1da41b7f91
commit 2a9980076d
33 changed files with 564 additions and 121 deletions
--- a/.buildkite/ci.mjs
+++ b/.buildkite/ci.mjs
@@ -114,6 +114,8 @@ const buildPlatforms = [
  { os: "linux", arch: "x64", abi: "musl", baseline: true, distro: "alpine", release: "3.22" },
  { os: "windows", arch: "x64", release: "2019" },
  { os: "windows", arch: "x64", baseline: true, release: "2019" },
+  // TODO: Enable when Windows ARM64 CI runners are ready
+  // { os: "windows", arch: "aarch64", release: "2019" },
 ];

 /**
@@ -136,6 +138,8 @@ const testPlatforms = [
  { os: "linux", arch: "x64", abi: "musl", baseline: true, distro: "alpine", release: "3.22", tier: "latest" },
  { os: "windows", arch: "x64", release: "2019", tier: "oldest" },
  { os: "windows", arch: "x64", release: "2019", baseline: true, tier: "oldest" },
+  // TODO: Enable when Windows ARM64 CI runners are ready
+  // { os: "windows", arch: "aarch64", release: "2019", tier: "oldest" },
 ];

 /**
--- a/.buildkite/scripts/sign-windows.ps1
+++ b/.buildkite/scripts/sign-windows.ps1
@@ -36,10 +36,14 @@ function Log-Debug {
    }
 }

+# Detect system architecture
+$script:IsARM64 = [System.Runtime.InteropServices.RuntimeInformation]::OSArchitecture -eq [System.Runtime.InteropServices.Architecture]::Arm64
+$script:VsArch = if ($script:IsARM64) { "arm64" } else { "amd64" }
+
 # Load Visual Studio environment if not already loaded
 function Ensure-VSEnvironment {
    if ($null -eq $env:VSINSTALLDIR) {
-        Log-Info "Loading Visual Studio environment..."
+        Log-Info "Loading Visual Studio environment for $script:VsArch..."

        $vswhere = "C:\Program Files (x86)\Microsoft Visual Studio\Installer\vswhere.exe"
        if (!(Test-Path $vswhere)) {
@@ -58,7 +62,7 @@ function Ensure-VSEnvironment {
        Push-Location $vsDir
        try {
            $vsShell = Join-Path -Path $vsDir -ChildPath "Common7\Tools\Launch-VsDevShell.ps1"
-            . $vsShell -Arch amd64 -HostArch amd64
+            . $vsShell -Arch $script:VsArch -HostArch $script:VsArch
        } finally {
            Pop-Location
        }
@@ -67,7 +71,7 @@ function Ensure-VSEnvironment {
    }

    if ($env:VSCMD_ARG_TGT_ARCH -eq "x86") {
-        throw "Visual Studio environment is targeting 32 bit, but only 64 bit is supported."
+        throw "Visual Studio environment is targeting 32 bit x86, but only 64-bit architectures (x64/arm64) are supported."
    }
 }

@@ -186,8 +190,10 @@ function Install-KeyLocker {
    }
    
    # Download MSI installer
-    $msiUrl = "https://bun-ci-assets.bun.sh/Keylockertools-windows-x64.msi"
-    $msiPath = Join-Path $env:TEMP "Keylockertools-windows-x64.msi"
+    # Note: KeyLocker tools currently only available for x64, but works on ARM64 via emulation
+    $msiArch = "x64"
+    $msiUrl = "https://bun-ci-assets.bun.sh/Keylockertools-windows-${msiArch}.msi"
+    $msiPath = Join-Path $env:TEMP "Keylockertools-windows-${msiArch}.msi"
    
    Log-Info "Downloading MSI from: $msiUrl"
    Log-Info "Downloading to: $msiPath"
--- a/.buildkite/scripts/upload-release.sh
+++ b/.buildkite/scripts/upload-release.sh
@@ -219,6 +219,9 @@ function create_release() {
    bun-windows-x64-profile.zip
    bun-windows-x64-baseline.zip
    bun-windows-x64-baseline-profile.zip
+    # TODO: Enable when Windows ARM64 CI runners are ready
+    # bun-windows-aarch64.zip
+    # bun-windows-aarch64-profile.zip
  )

  function upload_artifact() {
--- a/build.zig
+++ b/build.zig
@@ -34,6 +34,7 @@ const BunBuildOptions = struct {
    enable_asan: bool,
    enable_fuzzilli: bool,
    enable_valgrind: bool,
+    enable_tinycc: bool,
    use_mimalloc: bool,
    tracy_callstack_depth: u16,
    reported_nodejs_version: Version,
@@ -84,6 +85,7 @@ const BunBuildOptions = struct {
        opts.addOption(bool, "enable_asan", this.enable_asan);
        opts.addOption(bool, "enable_fuzzilli", this.enable_fuzzilli);
        opts.addOption(bool, "enable_valgrind", this.enable_valgrind);
+        opts.addOption(bool, "enable_tinycc", this.enable_tinycc);
        opts.addOption(bool, "use_mimalloc", this.use_mimalloc);
        opts.addOption([]const u8, "reported_nodejs_version", b.fmt("{f}", .{this.reported_nodejs_version}));
        opts.addOption(bool, "zig_self_hosted_backend", this.no_llvm);
@@ -259,6 +261,7 @@ pub fn build(b: *Build) !void {
        .enable_asan = b.option(bool, "enable_asan", "Enable asan") orelse false,
        .enable_fuzzilli = b.option(bool, "enable_fuzzilli", "Enable fuzzilli instrumentation") orelse false,
        .enable_valgrind = b.option(bool, "enable_valgrind", "Enable valgrind") orelse false,
+        .enable_tinycc = b.option(bool, "enable_tinycc", "Enable TinyCC for FFI JIT compilation") orelse true,
        .use_mimalloc = b.option(bool, "use_mimalloc", "Use mimalloc as default allocator") orelse false,
        .llvm_codegen_threads = b.option(u32, "llvm_codegen_threads", "Number of threads to use for LLVM codegen") orelse 1,
    };
@@ -342,6 +345,7 @@ pub fn build(b: *Build) !void {
        const step = b.step("check-debug", "Check for semantic analysis errors on some platforms");
        addMultiCheck(b, step, build_options, &.{
            .{ .os = .windows, .arch = .x86_64 },
+            .{ .os = .windows, .arch = .aarch64 },
            .{ .os = .mac, .arch = .aarch64 },
            .{ .os = .linux, .arch = .x86_64 },
        }, &.{.Debug});
@@ -352,6 +356,7 @@ pub fn build(b: *Build) !void {
        const step = b.step("check-all", "Check for semantic analysis errors on all supported platforms");
        addMultiCheck(b, step, build_options, &.{
            .{ .os = .windows, .arch = .x86_64 },
+            .{ .os = .windows, .arch = .aarch64 },
            .{ .os = .mac, .arch = .x86_64 },
            .{ .os = .mac, .arch = .aarch64 },
            .{ .os = .linux, .arch = .x86_64 },
@@ -366,6 +371,7 @@ pub fn build(b: *Build) !void {
        const step = b.step("check-all-debug", "Check for semantic analysis errors on all supported platforms in debug mode");
        addMultiCheck(b, step, build_options, &.{
            .{ .os = .windows, .arch = .x86_64 },
+            .{ .os = .windows, .arch = .aarch64 },
            .{ .os = .mac, .arch = .x86_64 },
            .{ .os = .mac, .arch = .aarch64 },
            .{ .os = .linux, .arch = .x86_64 },
@@ -380,12 +386,14 @@ pub fn build(b: *Build) !void {
        const step = b.step("check-windows", "Check for semantic analysis errors on Windows");
        addMultiCheck(b, step, build_options, &.{
            .{ .os = .windows, .arch = .x86_64 },
+            .{ .os = .windows, .arch = .aarch64 },
        }, &.{ .Debug, .ReleaseFast });
    }
    {
        const step = b.step("check-windows-debug", "Check for semantic analysis errors on Windows");
        addMultiCheck(b, step, build_options, &.{
            .{ .os = .windows, .arch = .x86_64 },
+            .{ .os = .windows, .arch = .aarch64 },
        }, &.{.Debug});
    }
    {
@@ -422,6 +430,7 @@ pub fn build(b: *Build) !void {
        const step = b.step("translate-c", "Copy generated translated-c-headers.zig to zig-out");
        for ([_]TargetDescription{
            .{ .os = .windows, .arch = .x86_64 },
+            .{ .os = .windows, .arch = .aarch64 },
            .{ .os = .mac, .arch = .x86_64 },
            .{ .os = .mac, .arch = .aarch64 },
            .{ .os = .linux, .arch = .x86_64 },
@@ -493,6 +502,7 @@ fn addMultiCheck(
                .no_llvm = root_build_options.no_llvm,
                .enable_asan = root_build_options.enable_asan,
                .enable_valgrind = root_build_options.enable_valgrind,
+                .enable_tinycc = root_build_options.enable_tinycc,
                .enable_fuzzilli = root_build_options.enable_fuzzilli,
                .use_mimalloc = root_build_options.use_mimalloc,
                .override_no_export_cpp_apis = root_build_options.override_no_export_cpp_apis,
--- a/cmake/CompilerFlags.cmake
+++ b/cmake/CompilerFlags.cmake
@@ -21,6 +21,10 @@ endforeach()
 if(CMAKE_SYSTEM_PROCESSOR MATCHES "arm|ARM|arm64|ARM64|aarch64|AARCH64")
  if(APPLE)
    register_compiler_flags(-mcpu=apple-m1)
+  elseif(WIN32)
+    # Windows ARM64: use /clang: prefix for clang-cl, skip for MSVC cl.exe subprojects
+    # These flags are only understood by clang-cl, not MSVC cl.exe
+    register_compiler_flags(/clang:-march=armv8-a+crc /clang:-mtune=ampere1)
  else()
    register_compiler_flags(-march=armv8-a+crc -mtune=ampere1)
  endif()
@@ -242,10 +246,17 @@ if(UNIX)
  )
 endif()

-register_compiler_flags(
-  DESCRIPTION "Set C/C++ error limit"
-  -ferror-limit=${ERROR_LIMIT}
-)
+if(WIN32)
+  register_compiler_flags(
+    DESCRIPTION "Set C/C++ error limit"
+    /clang:-ferror-limit=${ERROR_LIMIT}
+  )
+else()
+  register_compiler_flags(
+    DESCRIPTION "Set C/C++ error limit"
+    -ferror-limit=${ERROR_LIMIT}
+  )
+endif()

 # --- LTO ---
 if(ENABLE_LTO)
--- a/cmake/Globals.cmake
+++ b/cmake/Globals.cmake
@@ -106,9 +106,9 @@ else()
 endif()

 if(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "arm64|ARM64|aarch64|AARCH64")
-  set(HOST_OS "aarch64")
+  set(HOST_ARCH "aarch64")
 elseif(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "x86_64|X86_64|x64|X64|amd64|AMD64")
-  set(HOST_OS "x64")
+  set(HOST_ARCH "x64")
 else()
  unsupported(CMAKE_HOST_SYSTEM_PROCESSOR)
 endif()
@@ -433,6 +433,33 @@ function(register_command)
    list(APPEND CMD_EFFECTIVE_DEPENDS ${CMD_EXECUTABLE})
  endif()

+  # SKIP_CODEGEN: Skip commands that use BUN_EXECUTABLE if all outputs exist
+  # This is used for Windows ARM64 builds where x64 bun crashes under emulation
+  if(SKIP_CODEGEN AND CMD_EXECUTABLE STREQUAL "${BUN_EXECUTABLE}")
+    set(ALL_OUTPUTS_EXIST TRUE)
+    foreach(output ${CMD_OUTPUTS})
+      if(NOT EXISTS ${output})
+        set(ALL_OUTPUTS_EXIST FALSE)
+        break()
+      endif()
+    endforeach()
+    if(ALL_OUTPUTS_EXIST AND CMD_OUTPUTS)
+      message(STATUS "SKIP_CODEGEN: Skipping ${CMD_TARGET} (outputs exist)")
+      if(CMD_TARGET)
+        add_custom_target(${CMD_TARGET})
+      endif()
+      return()
+    elseif(NOT CMD_OUTPUTS)
+      message(STATUS "SKIP_CODEGEN: Skipping ${CMD_TARGET} (no outputs)")
+      if(CMD_TARGET)
+        add_custom_target(${CMD_TARGET})
+      endif()
+      return()
+    else()
+      message(FATAL_ERROR "SKIP_CODEGEN: Cannot skip ${CMD_TARGET} - missing outputs. Run codegen on x64 first.")
+    endif()
+  endif()
+
  foreach(target ${CMD_TARGETS})
    if(target MATCHES "/|\\\\")
      message(FATAL_ERROR "register_command: TARGETS contains \"${target}\", if it's a path add it to SOURCES instead")
@@ -650,6 +677,7 @@ function(register_bun_install)
      ${NPM_CWD}
    COMMAND
      ${BUN_EXECUTABLE}
+        ${BUN_FLAGS}
        install
        --frozen-lockfile
    SOURCES
@@ -757,7 +785,7 @@ function(register_cmake_command)
  set(MAKE_EFFECTIVE_ARGS -B${MAKE_BUILD_PATH} ${CMAKE_ARGS})

  set(setFlags GENERATOR BUILD_TYPE)
-  set(appendFlags C_FLAGS CXX_FLAGS LINKER_FLAGS)
+  set(appendFlags C_FLAGS CXX_FLAGS LINKER_FLAGS STATIC_LINKER_FLAGS EXE_LINKER_FLAGS SHARED_LINKER_FLAGS MODULE_LINKER_FLAGS)
  set(specialFlags POSITION_INDEPENDENT_CODE)
  set(flags ${setFlags} ${appendFlags} ${specialFlags})

@@ -803,6 +831,14 @@ function(register_cmake_command)
    list(APPEND MAKE_EFFECTIVE_ARGS "-DCMAKE_${flag}=${MAKE_${flag}}")
  endforeach()

+  # Workaround for CMake 4.1.0 bug: Force correct machine type for Windows ARM64
+  # Use toolchain file and set CMP0197 policy to prevent duplicate /machine: flags
+  if(WIN32 AND CMAKE_SYSTEM_PROCESSOR MATCHES "ARM64|aarch64|AARCH64")
+    list(APPEND MAKE_EFFECTIVE_ARGS "-DCMAKE_TOOLCHAIN_FILE=${CWD}/cmake/toolchains/windows-aarch64.cmake")
+    list(APPEND MAKE_EFFECTIVE_ARGS "-DCMAKE_POLICY_DEFAULT_CMP0197=NEW")
+    list(APPEND MAKE_EFFECTIVE_ARGS "-DCMAKE_PROJECT_INCLUDE=${CWD}/cmake/arm64-static-lib-fix.cmake")
+  endif()
+
  if(DEFINED FRESH)
    list(APPEND MAKE_EFFECTIVE_ARGS --fresh)
  endif()
--- a/cmake/Options.cmake
+++ b/cmake/Options.cmake
@@ -4,6 +4,7 @@ endif()

 optionx(BUN_LINK_ONLY BOOL "If only the linking step should be built" DEFAULT OFF)
 optionx(BUN_CPP_ONLY BOOL "If only the C++ part of Bun should be built" DEFAULT OFF)
+optionx(SKIP_CODEGEN BOOL "Skip JavaScript codegen (for Windows ARM64 debug)" DEFAULT OFF)

 optionx(BUILDKITE BOOL "If Buildkite is enabled" DEFAULT OFF)
 optionx(GITHUB_ACTIONS BOOL "If GitHub Actions is enabled" DEFAULT OFF)
@@ -49,7 +50,7 @@ else()
  message(FATAL_ERROR "Unsupported operating system: ${CMAKE_SYSTEM_NAME}")
 endif()

-if(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64|arm64|arm")
+if(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64|arm64|ARM64")
  setx(ARCH "aarch64")
 elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "amd64|x86_64|x64|AMD64")
  setx(ARCH "x64")
@@ -57,6 +58,18 @@ else()
  message(FATAL_ERROR "Unsupported architecture: ${CMAKE_SYSTEM_PROCESSOR}")
 endif()

+# CMake 4.0+ policy CMP0197 controls how MSVC machine type flags are handled
+# Setting to NEW prevents duplicate /machine: flags being added to linker commands
+if(WIN32 AND ARCH STREQUAL "aarch64")
+  set(CMAKE_POLICY_DEFAULT_CMP0197 NEW)
+  set(CMAKE_MSVC_CMP0197 NEW)
+  # Set linker flags for exe/shared linking
+  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /machine:ARM64")
+  set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /machine:ARM64")
+  set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} /machine:ARM64")
+  set(CMAKE_STATIC_LINKER_FLAGS "${CMAKE_STATIC_LINKER_FLAGS} /machine:ARM64")
+endif()
+
 # Windows Code Signing Option
 if(WIN32)
  optionx(ENABLE_WINDOWS_CODESIGNING BOOL "Enable Windows code signing with DigiCert KeyLocker" DEFAULT OFF)
@@ -199,6 +212,16 @@ optionx(USE_WEBKIT_ICU BOOL "Use the ICU libraries from WebKit" DEFAULT ${DEFAUL

 optionx(ERROR_LIMIT STRING "Maximum number of errors to show when compiling C++ code" DEFAULT "100")

+# TinyCC is used for FFI JIT compilation
+# Disable on Windows ARM64 where it's not yet supported
+if(WIN32 AND ARCH STREQUAL "aarch64")
+  set(DEFAULT_ENABLE_TINYCC OFF)
+else()
+  set(DEFAULT_ENABLE_TINYCC ON)
+endif()
+
+optionx(ENABLE_TINYCC BOOL "Enable TinyCC for FFI JIT compilation" DEFAULT ${DEFAULT_ENABLE_TINYCC})
+
 # This is not an `option` because setting this variable to OFF is experimental
 # and unsupported. This replaces the `use_mimalloc` variable previously in
 # bun.zig, and enables C++ code to also be aware of the option.
--- a/cmake/arm64-static-lib-fix.cmake
+++ b/cmake/arm64-static-lib-fix.cmake
@@ -0,0 +1,8 @@
+# This file is included after project() via CMAKE_PROJECT_INCLUDE
+# It fixes the static library creation command to use ARM64 machine type
+
+if(WIN32 AND CMAKE_SYSTEM_PROCESSOR STREQUAL \"aarch64\")
+  # Override the static library creation commands to avoid spurious /machine:x64 flags
+  set(CMAKE_C_CREATE_STATIC_LIBRARY \"<CMAKE_AR> /nologo /machine:ARM64 /out:<TARGET> <OBJECTS>\" CACHE STRING \"\" FORCE)
+  set(CMAKE_CXX_CREATE_STATIC_LIBRARY \"<CMAKE_AR> /nologo /machine:ARM64 /out:<TARGET> <OBJECTS>\" CACHE STRING \"\" FORCE)
+endif()
--- a/cmake/scripts/DownloadZig.cmake
+++ b/cmake/scripts/DownloadZig.cmake
@@ -21,7 +21,12 @@ if(NOT DEFINED CMAKE_HOST_SYSTEM_PROCESSOR)
 endif()

 if(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "arm64|ARM64|aarch64|AARCH64")
-  set(ZIG_ARCH "aarch64")
+  # Windows ARM64 can run x86_64 via emulation, and no native ARM64 Zig build exists yet
+  if(CMAKE_HOST_WIN32)
+    set(ZIG_ARCH "x86_64")
+  else()
+    set(ZIG_ARCH "aarch64")
+  endif()
 elseif(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "amd64|AMD64|x86_64|X86_64|x64|X64")
  set(ZIG_ARCH "x86_64")
 else()
--- a/cmake/scripts/llvm-lib-arm64.bat
+++ b/cmake/scripts/llvm-lib-arm64.bat
@@ -0,0 +1,34 @@
+@echo off
+setlocal enabledelayedexpansion
+
+REM Wrapper for llvm-lib that strips conflicting /machine:x64 flag for ARM64 builds
+REM This is a workaround for CMake 4.1.0 bug
+
+REM Find llvm-lib.exe - check LLVM_LIB env var, then PATH, then known locations
+if defined LLVM_LIB (
+    set "LLVM_LIB_EXE=!LLVM_LIB!"
+) else (
+    where llvm-lib.exe >nul 2>&1
+    if !ERRORLEVEL! equ 0 (
+        for /f "delims=" %%i in ('where llvm-lib.exe') do set "LLVM_LIB_EXE=%%i"
+    ) else if exist "C:\Program Files\LLVM\bin\llvm-lib.exe" (
+        set "LLVM_LIB_EXE=C:\Program Files\LLVM\bin\llvm-lib.exe"
+    ) else (
+        echo Error: Cannot find llvm-lib.exe. Set LLVM_LIB environment variable or add LLVM to PATH.
+        exit /b 1
+    )
+)
+
+set "ARGS="
+
+for %%a in (%*) do (
+    set "ARG=%%a"
+    if /i "!ARG!"=="/machine:x64" (
+        REM Skip this argument
+    ) else (
+        set "ARGS=!ARGS! %%a"
+    )
+)
+
+"!LLVM_LIB_EXE!" %ARGS%
+exit /b %ERRORLEVEL%
--- a/cmake/scripts/llvm-lib-arm64.ps1
+++ b/cmake/scripts/llvm-lib-arm64.ps1
@@ -0,0 +1,18 @@
+# Wrapper for llvm-lib that strips conflicting /machine:x64 flag for ARM64 builds
+# This is a workaround for CMake 4.1.0 bug where both /machine:ARM64 and /machine:x64 are added
+
+# Find llvm-lib.exe - check LLVM_LIB env var, then PATH, then known locations
+if ($env:LLVM_LIB) {
+    $llvmLib = $env:LLVM_LIB
+} elseif (Get-Command llvm-lib.exe -ErrorAction SilentlyContinue) {
+    $llvmLib = (Get-Command llvm-lib.exe).Source
+} elseif (Test-Path "C:\Program Files\LLVM\bin\llvm-lib.exe") {
+    $llvmLib = "C:\Program Files\LLVM\bin\llvm-lib.exe"
+} else {
+    Write-Error "Cannot find llvm-lib.exe. Set LLVM_LIB environment variable or add LLVM to PATH."
+    exit 1
+}
+
+$filteredArgs = $args | Where-Object { $_ -ne "/machine:x64" }
+& $llvmLib @filteredArgs
+exit $LASTEXITCODE
--- a/cmake/scripts/llvm-lib-wrapper.bat
+++ b/cmake/scripts/llvm-lib-wrapper.bat
@@ -0,0 +1,34 @@
+@echo off
+setlocal enabledelayedexpansion
+
+REM Wrapper for llvm-lib that strips conflicting /machine:x64 flag for ARM64 builds
+REM This is a workaround for CMake 4.1.0 bug
+
+REM Find llvm-lib.exe - check LLVM_LIB env var, then PATH, then known locations
+if defined LLVM_LIB (
+    set "LLVM_LIB_EXE=!LLVM_LIB!"
+) else (
+    where llvm-lib.exe >nul 2>&1
+    if !ERRORLEVEL! equ 0 (
+        for /f "delims=" %%i in ('where llvm-lib.exe') do set "LLVM_LIB_EXE=%%i"
+    ) else if exist "C:\Program Files\LLVM\bin\llvm-lib.exe" (
+        set "LLVM_LIB_EXE=C:\Program Files\LLVM\bin\llvm-lib.exe"
+    ) else (
+        echo Error: Cannot find llvm-lib.exe. Set LLVM_LIB environment variable or add LLVM to PATH.
+        exit /b 1
+    )
+)
+
+set NEWARGS=
+
+for %%a in (%*) do (
+    set "ARG=%%a"
+    if /i "!ARG!"=="/machine:x64" (
+        REM Skip /machine:x64 argument
+    ) else (
+        set "NEWARGS=!NEWARGS! %%a"
+    )
+)
+
+"!LLVM_LIB_EXE!" %NEWARGS%
+exit /b %ERRORLEVEL%
--- a/cmake/targets/BuildBun.cmake
+++ b/cmake/targets/BuildBun.cmake
@@ -57,13 +57,17 @@ set(BUN_DEPENDENCIES
  LolHtml
  Lshpack
  Mimalloc
-  TinyCC
  Zlib
  LibArchive # must be loaded after zlib
  HdrHistogram # must be loaded after zlib
  Zstd
 )

+# TinyCC is optional - disabled on Windows ARM64 where it's not supported
+if(ENABLE_TINYCC)
+  list(APPEND BUN_DEPENDENCIES TinyCC)
+endif()
+
 include(CloneZstd)

 # --- Codegen ---
@@ -185,7 +189,7 @@ register_command(
  CWD
    ${BUN_NODE_FALLBACKS_SOURCE}
  COMMAND
-    ${BUN_EXECUTABLE} run build-fallbacks
+    ${BUN_EXECUTABLE} ${BUN_FLAGS} run build-fallbacks
      ${BUN_NODE_FALLBACKS_OUTPUT}
      ${BUN_NODE_FALLBACKS_SOURCES}
  SOURCES
@@ -206,7 +210,7 @@ register_command(
  CWD
    ${BUN_NODE_FALLBACKS_SOURCE}
  COMMAND
-    ${BUN_EXECUTABLE} build
+    ${BUN_EXECUTABLE} ${BUN_FLAGS} build
      ${BUN_NODE_FALLBACKS_SOURCE}/node_modules/react-refresh/cjs/react-refresh-runtime.development.js
      --outfile=${BUN_REACT_REFRESH_OUTPUT}
      --target=browser
@@ -243,6 +247,7 @@ register_command(
    "Generating ErrorCode.{zig,h}"
  COMMAND
    ${BUN_EXECUTABLE}
+      ${BUN_FLAGS}
      run
      ${BUN_ERROR_CODE_SCRIPT}
      ${CODEGEN_PATH}
@@ -278,6 +283,7 @@ register_command(
    "Generating ZigGeneratedClasses.{zig,cpp,h}"
  COMMAND
    ${BUN_EXECUTABLE}
+      ${BUN_FLAGS}
      run
      ${BUN_ZIG_GENERATED_CLASSES_SCRIPT}
      ${BUN_ZIG_GENERATED_CLASSES_SOURCES}
@@ -328,6 +334,7 @@ register_command(
    "Generating C++ --> Zig bindings"
  COMMAND
    ${BUN_EXECUTABLE}
+      ${BUN_FLAGS}
      ${CWD}/src/codegen/cppbind.ts
      ${CWD}/src
      ${CODEGEN_PATH}
@@ -345,6 +352,7 @@ register_command(
    "Generating CI info"
  COMMAND
    ${BUN_EXECUTABLE}
+      ${BUN_FLAGS}
      ${CWD}/src/codegen/ci_info.ts
      ${CODEGEN_PATH}/ci_info.zig
  SOURCES
@@ -353,24 +361,35 @@ register_command(
    ${BUN_CI_INFO_OUTPUTS}
 )

-register_command(
-  TARGET
-    bun-js-modules
-  COMMENT
-    "Generating JavaScript modules"
-  COMMAND
-    ${BUN_EXECUTABLE}
-      run
+if(SKIP_CODEGEN)
+  # Skip JavaScript codegen - useful for Windows ARM64 debug builds where bun crashes
+  message(STATUS "SKIP_CODEGEN is ON - skipping bun-js-modules codegen")
+  foreach(output ${BUN_JAVASCRIPT_OUTPUTS})
+    if(NOT EXISTS ${output})
+      message(FATAL_ERROR "SKIP_CODEGEN is ON but ${output} does not exist. Run codegen manually first.")
+    endif()
+  endforeach()
+else()
+  register_command(
+    TARGET
+      bun-js-modules
+    COMMENT
+      "Generating JavaScript modules"
+    COMMAND
+      ${BUN_EXECUTABLE}
+        ${BUN_FLAGS}
+        run
+        ${BUN_JAVASCRIPT_CODEGEN_SCRIPT}
+          --debug=${DEBUG}
+          ${BUILD_PATH}
+    SOURCES
+      ${BUN_JAVASCRIPT_SOURCES}
+      ${BUN_JAVASCRIPT_CODEGEN_SOURCES}
      ${BUN_JAVASCRIPT_CODEGEN_SCRIPT}
-        --debug=${DEBUG}
-        ${BUILD_PATH}
-  SOURCES
-    ${BUN_JAVASCRIPT_SOURCES}
-    ${BUN_JAVASCRIPT_CODEGEN_SOURCES}
-    ${BUN_JAVASCRIPT_CODEGEN_SCRIPT}
-  OUTPUTS
-    ${BUN_JAVASCRIPT_OUTPUTS}
-)
+    OUTPUTS
+      ${BUN_JAVASCRIPT_OUTPUTS}
+  )
+endif()

 set(BUN_BAKE_RUNTIME_CODEGEN_SCRIPT ${CWD}/src/codegen/bake-codegen.ts)

@@ -392,6 +411,7 @@ register_command(
    "Bundling Bake Runtime"
  COMMAND
    ${BUN_EXECUTABLE}
+      ${BUN_FLAGS}
      run
      ${BUN_BAKE_RUNTIME_CODEGEN_SCRIPT}
        --debug=${DEBUG}
@@ -415,7 +435,7 @@ string(REPLACE ";" "," BUN_BINDGENV2_SOURCES_COMMA_SEPARATED
  "${BUN_BINDGENV2_SOURCES}")

 execute_process(
-  COMMAND ${BUN_EXECUTABLE} run ${BUN_BINDGENV2_SCRIPT}
+  COMMAND ${BUN_EXECUTABLE} ${BUN_FLAGS} run ${BUN_BINDGENV2_SCRIPT}
    --command=list-outputs
    --sources=${BUN_BINDGENV2_SOURCES_COMMA_SEPARATED}
    --codegen-path=${CODEGEN_PATH}
@@ -438,7 +458,7 @@ register_command(
  COMMENT
    "Generating bindings (v2)"
  COMMAND
-    ${BUN_EXECUTABLE} run ${BUN_BINDGENV2_SCRIPT}
+    ${BUN_EXECUTABLE} ${BUN_FLAGS} run ${BUN_BINDGENV2_SCRIPT}
      --command=generate
      --codegen-path=${CODEGEN_PATH}
      --sources=${BUN_BINDGENV2_SOURCES_COMMA_SEPARATED}
@@ -469,6 +489,7 @@ register_command(
    "Processing \".bind.ts\" files"
  COMMAND
    ${BUN_EXECUTABLE}
+      ${BUN_FLAGS}
      run
      ${BUN_BINDGEN_SCRIPT}
        --debug=${DEBUG}
@@ -501,6 +522,7 @@ register_command(
    "Generating JSSink.{cpp,h}"
  COMMAND
    ${BUN_EXECUTABLE}
+      ${BUN_FLAGS}
      run
      ${BUN_JS_SINK_SCRIPT}
      ${CODEGEN_PATH}
@@ -573,6 +595,7 @@ foreach(i RANGE 0 ${BUN_OBJECT_LUT_SOURCES_MAX_INDEX})
      ${BUN_OBJECT_LUT_SOURCE}
    COMMAND
      ${BUN_EXECUTABLE}
+        ${BUN_FLAGS}
        run
        ${BUN_OBJECT_LUT_SCRIPT}
        ${BUN_OBJECT_LUT_SOURCE}
@@ -656,6 +679,10 @@ endif()
 if(CMAKE_SYSTEM_PROCESSOR MATCHES "arm|ARM|arm64|ARM64|aarch64|AARCH64")
  if(APPLE)
    set(ZIG_CPU "apple_m1")
+  elseif(WIN32)
+    # Windows ARM64: use a specific CPU with NEON support
+    # Zig running under x64 emulation would detect wrong CPU with "native"
+    set(ZIG_CPU "cortex_a76")
  else()
    set(ZIG_CPU "native")
  endif()
@@ -694,6 +721,7 @@ register_command(
      -Denable_asan=$<IF:$<BOOL:${ENABLE_ZIG_ASAN}>,true,false>
      -Denable_fuzzilli=$<IF:$<BOOL:${ENABLE_FUZZILLI}>,true,false>
      -Denable_valgrind=$<IF:$<BOOL:${ENABLE_VALGRIND}>,true,false>
+      -Denable_tinycc=$<IF:$<BOOL:${ENABLE_TINYCC}>,true,false>
      -Duse_mimalloc=$<IF:$<BOOL:${USE_MIMALLOC_AS_DEFAULT_ALLOCATOR}>,true,false>
      -Dllvm_codegen_threads=${LLVM_ZIG_CODEGEN_THREADS}
      -Dversion=${VERSION}
@@ -1211,7 +1239,7 @@ if(BUN_LINK_ONLY)
        WEBKIT_DOWNLOAD_URL=${WEBKIT_DOWNLOAD_URL}
        WEBKIT_VERSION=${WEBKIT_VERSION}
        ZIG_COMMIT=${ZIG_COMMIT}
-        ${BUN_EXECUTABLE} ${CWD}/scripts/create-link-metadata.mjs ${BUILD_PATH} ${bun}
+        ${BUN_EXECUTABLE} ${BUN_FLAGS} ${CWD}/scripts/create-link-metadata.mjs ${BUILD_PATH} ${bun}
    SOURCES
      ${BUN_ZIG_OUTPUT}
      ${BUN_CPP_OUTPUT}
--- a/cmake/targets/BuildHighway.cmake
+++ b/cmake/targets/BuildHighway.cmake
@@ -20,6 +20,15 @@ set(HIGHWAY_CMAKE_ARGS
  -DHWY_ENABLE_INSTALL=OFF
 )

+# On Windows ARM64 with clang-cl, the __ARM_NEON macro isn't defined by default
+# but NEON intrinsics are supported. Define it so Highway can detect NEON support.
+if(WIN32 AND CMAKE_SYSTEM_PROCESSOR MATCHES "ARM64|aarch64|AARCH64")
+  list(APPEND HIGHWAY_CMAKE_ARGS
+    -DCMAKE_C_FLAGS=-D__ARM_NEON=1
+    -DCMAKE_CXX_FLAGS=-D__ARM_NEON=1
+  )
+endif()
+
 register_cmake_command(
  TARGET
    highway
--- a/cmake/targets/BuildLolHtml.cmake
+++ b/cmake/targets/BuildLolHtml.cmake
@@ -33,6 +33,37 @@ if (NOT WIN32)
  set(RUSTFLAGS "-Cpanic=abort-Cdebuginfo=0-Cforce-unwind-tables=no-Copt-level=s")
 endif()

+# On Windows, ensure MSVC link.exe is used instead of Git's link.exe
+set(LOLHTML_ENV
+  CARGO_TERM_COLOR=always
+  CARGO_TERM_VERBOSE=true
+  CARGO_TERM_DIAGNOSTIC=true
+  CARGO_ENCODED_RUSTFLAGS=${RUSTFLAGS}
+  CARGO_HOME=${CARGO_HOME}
+  RUSTUP_HOME=${RUSTUP_HOME}
+)
+
+if(WIN32)
+  # On Windows, tell Rust to use MSVC link.exe directly via the target-specific linker env var.
+  # This avoids Git's /usr/bin/link being found first in PATH.
+  # Find the MSVC link.exe from Visual Studio installation
+  file(GLOB MSVC_VERSIONS "C:/Program Files/Microsoft Visual Studio/2022/*/VC/Tools/MSVC/*")
+  if(MSVC_VERSIONS)
+    list(GET MSVC_VERSIONS -1 MSVC_LATEST)  # Get the latest version
+    if(CMAKE_SYSTEM_PROCESSOR MATCHES "ARM64|aarch64")
+      set(MSVC_LINK_PATH "${MSVC_LATEST}/bin/HostARM64/arm64/link.exe")
+      set(CARGO_LINKER_VAR "CARGO_TARGET_AARCH64_PC_WINDOWS_MSVC_LINKER")
+    else()
+      set(MSVC_LINK_PATH "${MSVC_LATEST}/bin/Hostx64/x64/link.exe")
+      set(CARGO_LINKER_VAR "CARGO_TARGET_X86_64_PC_WINDOWS_MSVC_LINKER")
+    endif()
+    if(EXISTS "${MSVC_LINK_PATH}")
+      list(APPEND LOLHTML_ENV "${CARGO_LINKER_VAR}=${MSVC_LINK_PATH}")
+      message(STATUS "lolhtml: Using MSVC link.exe: ${MSVC_LINK_PATH}")
+    endif()
+  endif()
+endif()
+
 register_command(
  TARGET
    lolhtml
@@ -45,12 +76,7 @@ register_command(
  ARTIFACTS
    ${LOLHTML_LIBRARY}
  ENVIRONMENT
-    CARGO_TERM_COLOR=always
-    CARGO_TERM_VERBOSE=true
-    CARGO_TERM_DIAGNOSTIC=true
-    CARGO_ENCODED_RUSTFLAGS=${RUSTFLAGS}
-    CARGO_HOME=${CARGO_HOME}
-    RUSTUP_HOME=${RUSTUP_HOME}
+    ${LOLHTML_ENV}
 )

 target_link_libraries(${bun} PRIVATE ${LOLHTML_LIBRARY})
--- a/cmake/toolchains/windows-aarch64.cmake
+++ b/cmake/toolchains/windows-aarch64.cmake
@@ -0,0 +1,20 @@
+set(CMAKE_SYSTEM_NAME Windows)
+set(CMAKE_SYSTEM_PROCESSOR aarch64)
+
+set(CMAKE_C_COMPILER_WORKS ON)
+set(CMAKE_CXX_COMPILER_WORKS ON)
+
+# Force ARM64 architecture ID - this is what CMake uses to determine /machine: flag
+set(MSVC_C_ARCHITECTURE_ID ARM64 CACHE INTERNAL "")
+set(MSVC_CXX_ARCHITECTURE_ID ARM64 CACHE INTERNAL "")
+
+# CMake 4.0+ policy CMP0197 controls how MSVC machine type flags are handled
+set(CMAKE_POLICY_DEFAULT_CMP0197 NEW CACHE INTERNAL "")
+
+# Clear any inherited static linker flags that might have wrong machine types
+set(CMAKE_STATIC_LINKER_FLAGS "" CACHE STRING "" FORCE)
+
+# Use wrapper script for llvm-lib that strips /machine:x64 flags
+# This works around CMake 4.1.0 bug where both ARM64 and x64 machine flags are added
+get_filename_component(_TOOLCHAIN_DIR "${CMAKE_CURRENT_LIST_DIR}" DIRECTORY)
+set(CMAKE_AR "${_TOOLCHAIN_DIR}/scripts/llvm-lib-wrapper.bat" CACHE FILEPATH "" FORCE)
--- a/cmake/tools/SetupBuildkite.cmake
+++ b/cmake/tools/SetupBuildkite.cmake
@@ -48,8 +48,16 @@ if(NOT BUILDKITE_BUILD_STATUS EQUAL 0)
 endif()

 file(READ ${BUILDKITE_BUILD_PATH}/build.json BUILDKITE_BUILD)
-# Escape backslashes so CMake doesn't interpret JSON escape sequences (e.g., \n in commit messages)
-string(REPLACE "\\" "\\\\" BUILDKITE_BUILD "${BUILDKITE_BUILD}")
+# CMake's string(JSON ...) interprets escape sequences like \n, \r, \t.
+# We need to escape these specific sequences while preserving valid JSON escapes like \" and \\.
+# Strategy: Use a unique placeholder to protect \\ sequences, escape \n/\r/\t, then restore \\.
+# This prevents \\n (literal backslash + n) from being corrupted to \\\n.
+set(BKSLASH_PLACEHOLDER "___BKSLASH_PLACEHOLDER_7f3a9b2c___")
+string(REPLACE "\\\\" "${BKSLASH_PLACEHOLDER}" BUILDKITE_BUILD "${BUILDKITE_BUILD}")
+string(REPLACE "\\n" "\\\\n" BUILDKITE_BUILD "${BUILDKITE_BUILD}")
+string(REPLACE "\\r" "\\\\r" BUILDKITE_BUILD "${BUILDKITE_BUILD}")
+string(REPLACE "\\t" "\\\\t" BUILDKITE_BUILD "${BUILDKITE_BUILD}")
+string(REPLACE "${BKSLASH_PLACEHOLDER}" "\\\\" BUILDKITE_BUILD "${BUILDKITE_BUILD}")

 string(JSON BUILDKITE_BUILD_UUID GET ${BUILDKITE_BUILD} id)
 string(JSON BUILDKITE_JOBS GET ${BUILDKITE_BUILD} jobs)
--- a/cmake/tools/SetupBun.cmake
+++ b/cmake/tools/SetupBun.cmake
@@ -17,6 +17,14 @@ if (NOT CI)
  set(BUN_EXECUTABLE ${BUN_EXECUTABLE} CACHE FILEPATH "Bun executable" FORCE)
 endif()

+# On Windows ARM64, we need to add --smol flag to avoid crashes when running
+# x64 bun under WoW64 emulation
+if(WIN32 AND ARCH STREQUAL "aarch64")
+  set(BUN_FLAGS "--smol" CACHE STRING "Extra flags for bun executable")
+else()
+  set(BUN_FLAGS "" CACHE STRING "Extra flags for bun executable")
+endif()
+
 # If this is not set, some advanced features are not checked.
 # https://github.com/oven-sh/bun/blob/cd7f6a1589db7f1e39dc4e3f4a17234afbe7826c/src/bun.js/javascript.zig#L1069-L1072
 setenv(BUN_GARBAGE_COLLECTOR_LEVEL 1)
--- a/cmake/tools/SetupLLVM.cmake
+++ b/cmake/tools/SetupLLVM.cmake
@@ -12,7 +12,13 @@ if(NOT ENABLE_LLVM)
  return()
 endif()

-set(DEFAULT_LLVM_VERSION "19.1.7")
+# LLVM 21 is required for Windows ARM64 (first version with ARM64 Windows builds)
+# Other platforms use LLVM 19.1.7
+if(WIN32 AND CMAKE_SYSTEM_PROCESSOR MATCHES "ARM64|aarch64|AARCH64")
+  set(DEFAULT_LLVM_VERSION "21.1.8")
+else()
+  set(DEFAULT_LLVM_VERSION "19.1.7")
+endif()

 optionx(LLVM_VERSION STRING "The version of LLVM to use" DEFAULT ${DEFAULT_LLVM_VERSION})

--- a/cmake/tools/SetupWebKit.cmake
+++ b/cmake/tools/SetupWebKit.cmake
@@ -5,7 +5,11 @@ if(NOT WEBKIT_VERSION)
  set(WEBKIT_VERSION 87c6cde57dd1d2a82bbc9caf500f70f8a7c1f249)
 endif()

+# Use preview build URL for Windows ARM64 until the fix is merged to main
+set(WEBKIT_PREVIEW_PR 140)
+
 string(SUBSTRING ${WEBKIT_VERSION} 0 16 WEBKIT_VERSION_PREFIX)
+string(SUBSTRING ${WEBKIT_VERSION} 0 8 WEBKIT_VERSION_SHORT)

 if(WEBKIT_LOCAL)
  set(DEFAULT_WEBKIT_PATH ${VENDOR_PATH}/WebKit/WebKitBuild/${CMAKE_BUILD_TYPE})
@@ -36,6 +40,22 @@ if(WEBKIT_LOCAL)
      ${WEBKIT_PATH}/JavaScriptCore/PrivateHeaders/JavaScriptCore
      ${WEBKIT_PATH}/JavaScriptCore/DerivedSources/inspector
    )
+
+    # On Windows, add ICU include path from vcpkg
+    if(WIN32)
+      # Auto-detect vcpkg triplet
+      set(VCPKG_ARM64_PATH ${VENDOR_PATH}/WebKit/vcpkg_installed/arm64-windows-static)
+      set(VCPKG_X64_PATH ${VENDOR_PATH}/WebKit/vcpkg_installed/x64-windows-static)
+      if(EXISTS ${VCPKG_ARM64_PATH})
+        set(VCPKG_ICU_PATH ${VCPKG_ARM64_PATH})
+      else()
+        set(VCPKG_ICU_PATH ${VCPKG_X64_PATH})
+      endif()
+      if(EXISTS ${VCPKG_ICU_PATH}/include)
+        include_directories(${VCPKG_ICU_PATH}/include)
+        message(STATUS "Using ICU from vcpkg: ${VCPKG_ICU_PATH}/include")
+      endif()
+    endif()
  endif()

  # After this point, only prebuilt WebKit is supported
@@ -52,7 +72,7 @@ else()
  message(FATAL_ERROR "Unsupported operating system: ${CMAKE_SYSTEM_NAME}")
 endif()

-if(CMAKE_SYSTEM_PROCESSOR MATCHES "arm64|aarch64")
+if(CMAKE_SYSTEM_PROCESSOR MATCHES "arm64|ARM64|aarch64|AARCH64")
  set(WEBKIT_ARCH "arm64")
 elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "amd64|x86_64|x64|AMD64")
  set(WEBKIT_ARCH "amd64")
--- a/cmake/tools/SetupZig.cmake
+++ b/cmake/tools/SetupZig.cmake
@@ -1,4 +1,4 @@
-if(CMAKE_SYSTEM_PROCESSOR MATCHES "arm64|aarch64")
+if(CMAKE_SYSTEM_PROCESSOR MATCHES "arm64|ARM64|aarch64|AARCH64")
  set(DEFAULT_ZIG_ARCH "aarch64")
 elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "amd64|x86_64|x64|AMD64")
  set(DEFAULT_ZIG_ARCH "x86_64")
--- a/docs/project/building-windows.mdx
+++ b/docs/project/building-windows.mdx
@@ -35,7 +35,7 @@ winget install "Visual Studio Community 2022" --override "--add Microsoft.Visual

 After Visual Studio, you need the following:

- LLVM 19.1.7
+- LLVM (19.1.7 for x64, 21.1.8 for ARM64)
 - Go
 - Rust
 - NASM
@@ -47,25 +47,35 @@ After Visual Studio, you need the following:

 [Scoop](https://scoop.sh) can be used to install these remaining tools easily.

-```ps1 Scoop
+```ps1 Scoop (x64)
 irm https://get.scoop.sh | iex
 scoop install nodejs-lts go rust nasm ruby perl ccache
 # scoop seems to be buggy if you install llvm and the rest at the same time
 scoop install llvm@19.1.7
 ```

+For Windows ARM64, download LLVM 21.1.8 directly from GitHub releases (first version with ARM64 Windows builds):
+
+```ps1 ARM64
+# Download and install LLVM for ARM64
+Invoke-WebRequest -Uri "https://github.com/llvm/llvm-project/releases/download/llvmorg-21.1.8/LLVM-21.1.8-woa64.exe" -OutFile "$env:TEMP\LLVM-21.1.8-woa64.exe"
+Start-Process -FilePath "$env:TEMP\LLVM-21.1.8-woa64.exe" -ArgumentList "/S" -Wait
+```
+
 <Note>
  Please do not use WinGet/other package manager for these, as you will likely install Strawberry Perl instead of a more
  minimal installation of Perl. Strawberry Perl includes many other utilities that get installed into `$Env:PATH` that
  will conflict with MSVC and break the build.
 </Note>

-If you intend on building WebKit locally (optional), you should install these packages:
+If you intend on building WebKit locally (optional, x64 only), you should install these packages:

 ```ps1 Scoop
 scoop install make cygwin python
 ```

+<Note>Cygwin is not required for ARM64 builds as WebKit is provided as a pre-built binary.</Note>
+
 From here on out, it is **expected you use a PowerShell Terminal with `.\scripts\vs-shell.ps1` sourced**. This script is available in the Bun repository and can be loaded by executing it:

 ```ps1
--- a/scripts/build-jsc.ts
+++ b/scripts/build-jsc.ts
@@ -23,7 +23,10 @@ const OS_NAME = platform().toLowerCase();
 const ARCH_NAME_RAW = arch();
 const IS_MAC = OS_NAME === "darwin";
 const IS_LINUX = OS_NAME === "linux";
-const IS_ARM64 = ARCH_NAME_RAW === "arm64" || ARCH_NAME_RAW === "aarch64";
+const IS_WINDOWS = OS_NAME === "win32";
+// On Windows, use PROCESSOR_ARCHITECTURE env var to get native arch (Bun may run under x64 emulation)
+const NATIVE_ARCH = IS_WINDOWS ? (process.env.PROCESSOR_ARCHITECTURE || ARCH_NAME_RAW).toUpperCase() : ARCH_NAME_RAW;
+const IS_ARM64 = NATIVE_ARCH === "ARM64" || NATIVE_ARCH === "AARCH64" || ARCH_NAME_RAW === "arm64";

 // Paths
 const ROOT_DIR = resolve(import.meta.dir, "..");
@@ -33,22 +36,54 @@ const WEBKIT_RELEASE_DIR = join(WEBKIT_BUILD_DIR, "Release");
 const WEBKIT_DEBUG_DIR = join(WEBKIT_BUILD_DIR, "Debug");
 const WEBKIT_RELEASE_DIR_LTO = join(WEBKIT_BUILD_DIR, "ReleaseLTO");

+// Windows ICU paths - use vcpkg static build
+// Auto-detect triplet: prefer arm64 if it exists, otherwise x64
+const VCPKG_ARM64_PATH = join(WEBKIT_DIR, "vcpkg_installed", "arm64-windows-static");
+const VCPKG_X64_PATH = join(WEBKIT_DIR, "vcpkg_installed", "x64-windows-static");
+const VCPKG_ROOT = existsSync(VCPKG_ARM64_PATH) ? VCPKG_ARM64_PATH : VCPKG_X64_PATH;
+const ICU_INCLUDE_DIR = join(VCPKG_ROOT, "include");
+
+// Get ICU library paths based on build config (debug uses 'd' suffix libraries)
+function getICULibraryPaths(config: BuildConfig) {
+  const isDebug = config === "debug";
+  // vcpkg static ICU libraries: release in lib/, debug in debug/lib/ with 'd' suffix
+  const libDir = isDebug ? join(VCPKG_ROOT, "debug", "lib") : join(VCPKG_ROOT, "lib");
+  const suffix = isDebug ? "d" : "";
+  return {
+    ICU_LIBRARY: libDir,
+    ICU_DATA_LIBRARY: join(libDir, `sicudt${suffix}.lib`),
+    ICU_I18N_LIBRARY: join(libDir, `sicuin${suffix}.lib`),
+    ICU_UC_LIBRARY: join(libDir, `sicuuc${suffix}.lib`),
+  };
+}
+
 // Homebrew prefix detection
 const HOMEBREW_PREFIX = IS_ARM64 ? "/opt/homebrew/" : "/usr/local/";

 // Compiler detection
 function findExecutable(names: string[]): string | null {
  for (const name of names) {
-    const result = spawnSync("which", [name], { encoding: "utf8" });
-    if (result.status === 0) {
-      return result.stdout.trim();
-    }
+    const path = Bun.which(name);
+    if (path) return path;
  }
  return null;
 }

-const CC = findExecutable(["clang-19", "clang"]) || "clang";
-const CXX = findExecutable(["clang++-19", "clang++"]) || "clang++";
+// Detect ccache
+const CCACHE = findExecutable(["ccache"]);
+const HAS_CCACHE = CCACHE !== null;
+
+// Configure compilers with ccache if available
+// On Windows, use clang-cl for MSVC compatibility
+const CC_BASE = IS_WINDOWS
+  ? findExecutable(["clang-cl.exe", "clang-cl"]) || "clang-cl"
+  : findExecutable(["clang-19", "clang"]) || "clang";
+const CXX_BASE = IS_WINDOWS
+  ? findExecutable(["clang-cl.exe", "clang-cl"]) || "clang-cl"
+  : findExecutable(["clang++-19", "clang++"]) || "clang++";
+
+const CC = HAS_CCACHE ? CCACHE : CC_BASE;
+const CXX = HAS_CCACHE ? CCACHE : CXX_BASE;

 // Build directory based on config
 const getBuildDir = (config: BuildConfig) => {
@@ -63,7 +98,7 @@ const getBuildDir = (config: BuildConfig) => {
 };

 // Common CMake flags
-const getCommonFlags = () => {
+const getCommonFlags = (config: BuildConfig) => {
  const flags = [
    "-DPORT=JSCOnly",
    "-DENABLE_STATIC_JSC=ON",
@@ -74,10 +109,20 @@ const getCommonFlags = () => {
    "-DENABLE_FTL_JIT=ON",
    "-G",
    "Ninja",
-    `-DCMAKE_C_COMPILER=${CC}`,
-    `-DCMAKE_CXX_COMPILER=${CXX}`,
  ];

+  // Configure compiler with ccache if available
+  if (HAS_CCACHE) {
+    flags.push(
+      `-DCMAKE_C_COMPILER_LAUNCHER=${CCACHE}`,
+      `-DCMAKE_CXX_COMPILER_LAUNCHER=${CCACHE}`,
+      `-DCMAKE_C_COMPILER=${CC_BASE}`,
+      `-DCMAKE_CXX_COMPILER=${CXX_BASE}`,
+    );
+  } else {
+    flags.push(`-DCMAKE_C_COMPILER=${CC}`, `-DCMAKE_CXX_COMPILER=${CXX}`);
+  }
+
  if (IS_MAC) {
    flags.push(
      "-DENABLE_SINGLE_THREADED_VM_ENTRY_SCOPE=ON",
@@ -91,6 +136,27 @@ const getCommonFlags = () => {
      "-DUSE_VISIBILITY_ATTRIBUTE=1",
      "-DENABLE_REMOTE_INSPECTOR=ON",
    );
+  } else if (IS_WINDOWS) {
+    // Find lld-link for Windows builds
+    const lldLink = findExecutable(["lld-link.exe", "lld-link"]) || "lld-link";
+    // Get ICU library paths for this build config (debug uses 'd' suffix libraries)
+    const icuPaths = getICULibraryPaths(config);
+
+    flags.push(
+      "-DENABLE_REMOTE_INSPECTOR=ON",
+      "-DUSE_VISIBILITY_ATTRIBUTE=1",
+      "-DUSE_SYSTEM_MALLOC=ON",
+      `-DCMAKE_LINKER=${lldLink}`,
+      `-DICU_ROOT=${VCPKG_ROOT}`,
+      `-DICU_LIBRARY=${icuPaths.ICU_LIBRARY}`,
+      `-DICU_INCLUDE_DIR=${ICU_INCLUDE_DIR}`,
+      // Explicitly set ICU library paths to use vcpkg static libs (debug has 'd' suffix)
+      `-DICU_DATA_LIBRARY_RELEASE=${icuPaths.ICU_DATA_LIBRARY}`,
+      `-DICU_I18N_LIBRARY_RELEASE=${icuPaths.ICU_I18N_LIBRARY}`,
+      `-DICU_UC_LIBRARY_RELEASE=${icuPaths.ICU_UC_LIBRARY}`,
+      "-DCMAKE_C_FLAGS=/DU_STATIC_IMPLEMENTATION",
+      "-DCMAKE_CXX_FLAGS=/DU_STATIC_IMPLEMENTATION /clang:-fno-c++-static-destructors",
+    );
  }

  return flags;
@@ -98,7 +164,7 @@ const getCommonFlags = () => {

 // Build-specific CMake flags
 const getBuildFlags = (config: BuildConfig) => {
-  const flags = [...getCommonFlags()];
+  const flags = [...getCommonFlags(config)];

  switch (config) {
    case "debug":
@@ -110,20 +176,37 @@ const getBuildFlags = (config: BuildConfig) => {
        "-DUSE_VISIBILITY_ATTRIBUTE=1",
      );

-      if (IS_MAC) {
-        // Enable address sanitizer by default on Mac debug builds
+      if (IS_MAC || IS_LINUX) {
+        // Enable address sanitizer by default on Mac/Linux debug builds
        flags.push("-DENABLE_SANITIZERS=address");
        // To disable asan, comment the line above and uncomment:
        // flags.push("-DENABLE_MALLOC_HEAP_BREAKDOWN=ON");
      }
+
+      if (IS_WINDOWS) {
+        flags.push("-DCMAKE_MSVC_RUNTIME_LIBRARY=MultiThreadedDebug");
+      }
      break;

    case "lto":
-      flags.push("-DCMAKE_BUILD_TYPE=Release", "-DCMAKE_C_FLAGS=-flto=full", "-DCMAKE_CXX_FLAGS=-flto=full");
+      flags.push("-DCMAKE_BUILD_TYPE=Release");
+      if (IS_WINDOWS) {
+        // On Windows, append LTO flags to existing Windows-specific flags
+        flags.push(
+          "-DCMAKE_C_FLAGS=/DU_STATIC_IMPLEMENTATION -flto=full",
+          "-DCMAKE_CXX_FLAGS=/DU_STATIC_IMPLEMENTATION /clang:-fno-c++-static-destructors -flto=full",
+          "-DCMAKE_MSVC_RUNTIME_LIBRARY=MultiThreaded",
+        );
+      } else {
+        flags.push("-DCMAKE_C_FLAGS=-flto=full", "-DCMAKE_CXX_FLAGS=-flto=full");
+      }
      break;

    default: // release
      flags.push("-DCMAKE_BUILD_TYPE=RelWithDebInfo");
+      if (IS_WINDOWS) {
+        flags.push("-DCMAKE_MSVC_RUNTIME_LIBRARY=MultiThreaded");
+      }
      break;
  }

@@ -134,17 +217,6 @@ const getBuildFlags = (config: BuildConfig) => {
 const getBuildEnv = () => {
  const env = { ...process.env };

-  const cflags = ["-ffat-lto-objects"];
-  const cxxflags = ["-ffat-lto-objects"];
-
-  if (IS_LINUX && buildConfig !== "lto") {
-    cflags.push("-Wl,--whole-archive");
-    cxxflags.push("-Wl,--whole-archive", "-DUSE_BUN_JSC_ADDITIONS=ON", "-DUSE_BUN_EVENT_LOOP=ON");
-  }
-
-  env.CFLAGS = (env.CFLAGS || "") + " " + cflags.join(" ");
-  env.CXXFLAGS = (env.CXXFLAGS || "") + " " + cxxflags.join(" ");
-
  if (IS_MAC) {
    env.ICU_INCLUDE_DIRS = `${HOMEBREW_PREFIX}opt/icu4c/include`;
  }
@@ -179,6 +251,9 @@ function buildJSC() {

  console.log(`Building JSC with configuration: ${buildConfig}`);
  console.log(`Build directory: ${buildDir}`);
+  if (HAS_CCACHE) {
+    console.log(`Using ccache for faster builds: ${CCACHE}`);
+  }

  // Create build directories
  if (!existsSync(buildDir)) {
--- a/scripts/build.mjs
+++ b/scripts/build.mjs
@@ -14,6 +14,15 @@ import {
  startGroup,
 } from "./utils.mjs";

+// Detect Windows ARM64 - bun may run under x64 emulation (WoW64), so check multiple indicators
+const isWindowsARM64 =
+  isWindows &&
+  (process.env.PROCESSOR_ARCHITECTURE === "ARM64" ||
+    process.env.VSCMD_ARG_HOST_ARCH === "arm64" ||
+    process.env.MSYSTEM_CARCH === "aarch64" ||
+    (process.env.PROCESSOR_IDENTIFIER || "").includes("ARMv8") ||
+    process.arch === "arm64");
+
 if (globalThis.Bun) {
  await import("./glob-sources.mjs");
 }
@@ -83,6 +92,23 @@ async function build(args) {
    generateOptions["--toolchain"] = toolchainPath;
  }

+  // Windows ARM64: automatically set required options
+  if (isWindowsARM64) {
+    // Use clang-cl instead of MSVC cl.exe for proper ARM64 flag support
+    if (!generateOptions["-DCMAKE_C_COMPILER"]) {
+      generateOptions["-DCMAKE_C_COMPILER"] = "clang-cl";
+    }
+    if (!generateOptions["-DCMAKE_CXX_COMPILER"]) {
+      generateOptions["-DCMAKE_CXX_COMPILER"] = "clang-cl";
+    }
+    // Skip codegen by default since x64 bun crashes under WoW64 emulation
+    // Can be overridden with -DSKIP_CODEGEN=OFF once ARM64 bun is available
+    if (!generateOptions["-DSKIP_CODEGEN"]) {
+      generateOptions["-DSKIP_CODEGEN"] = "ON";
+    }
+    console.log("Windows ARM64 detected: using clang-cl and SKIP_CODEGEN=ON");
+  }
+
  const generateArgs = Object.entries(generateOptions).flatMap(([flag, value]) =>
    flag.startsWith("-D") ? [`${flag}=${value}`] : [flag, value],
  );
--- a/scripts/vs-shell.ps1
+++ b/scripts/vs-shell.ps1
@@ -3,6 +3,10 @@

 $ErrorActionPreference = "Stop"

+# Detect system architecture
+$script:IsARM64 = [System.Runtime.InteropServices.RuntimeInformation]::OSArchitecture -eq [System.Runtime.InteropServices.Architecture]::Arm64
+$script:VsArch = if ($script:IsARM64) { "arm64" } else { "amd64" }
+
 if($env:VSINSTALLDIR -eq $null) {
  Write-Host "Loading Visual Studio environment, this may take a second..."

@@ -23,14 +27,14 @@ if($env:VSINSTALLDIR -eq $null) {
  Push-Location $vsDir
  try {
    $vsShell = (Join-Path -Path $vsDir -ChildPath "Common7\Tools\Launch-VsDevShell.ps1")
-    . $vsShell -Arch amd64 -HostArch amd64
+    . $vsShell -Arch $script:VsArch -HostArch $script:VsArch
  } finally {
    Pop-Location
  }
 }

 if($env:VSCMD_ARG_TGT_ARCH -eq "x86") {
-  throw "Visual Studio environment is targeting 32 bit, but only 64 bit is supported."
+  throw "Visual Studio environment is targeting 32 bit x86, but only 64-bit architectures (x64/arm64) are supported."
 }

 if ($args.Count -gt 0) {
--- a/src/bun.js/api/ffi.zig
+++ b/src/bun.js/api/ffi.zig
@@ -606,6 +606,9 @@ pub const FFI = struct {
    };

    pub fn Bun__FFI__cc(globalThis: *jsc.JSGlobalObject, callframe: *jsc.CallFrame) bun.JSError!jsc.JSValue {
+        if (comptime !Environment.enable_tinycc) {
+            return globalThis.throw("bun:ffi cc() is not available in this build (TinyCC is disabled)", .{});
+        }
        const arguments = callframe.arguments_old(1).slice();
        if (arguments.len == 0 or !arguments[0].isObject()) {
            return globalThis.throwInvalidArguments("Expected object", .{});
@@ -834,6 +837,9 @@ pub const FFI = struct {
    }

    pub fn callback(globalThis: *JSGlobalObject, interface: jsc.JSValue, js_callback: jsc.JSValue) bun.JSError!JSValue {
+        if (comptime !Environment.enable_tinycc) {
+            return globalThis.throw("bun:ffi callback() is not available in this build (TinyCC is disabled)", .{});
+        }
        jsc.markBinding(@src());
        if (!interface.isObject()) {
            return globalThis.toInvalidArguments("Expected object", .{});
@@ -1003,6 +1009,10 @@ pub const FFI = struct {
    }

    pub fn open(global: *JSGlobalObject, name_str: ZigString, object_value: jsc.JSValue) jsc.JSValue {
+        if (comptime !Environment.enable_tinycc) {
+            global.throw("bun:ffi dlopen() is not available in this build (TinyCC is disabled)", .{}) catch {};
+            return .zero;
+        }
        jsc.markBinding(@src());
        const vm = VirtualMachine.get();
        var name_slice = name_str.toSlice(bun.default_allocator);
@@ -1169,6 +1179,10 @@ pub const FFI = struct {
    }

    pub fn linkSymbols(global: *JSGlobalObject, object_value: jsc.JSValue) jsc.JSValue {
+        if (comptime !Environment.enable_tinycc) {
+            global.throw("bun:ffi linkSymbols() is not available in this build (TinyCC is disabled)", .{}) catch {};
+            return .zero;
+        }
        jsc.markBinding(@src());
        const allocator = VirtualMachine.get().allocator;

@@ -2417,8 +2431,13 @@ fn makeNapiEnvIfNeeded(functions: []const FFI.Function, globalThis: *JSGlobalObj

 const string = []const u8;

+const TCC = if (Environment.enable_tinycc) @import("../../deps/tcc.zig") else struct {
+    pub const State = struct {
+        pub fn deinit(_: *State) void {}
+    };
+};
+
 const Fs = @import("../../fs.zig");
-const TCC = @import("../../deps/tcc.zig");
 const napi = @import("../../napi/napi.zig");
 const options = @import("../../options.zig");
 const std = @import("std");
--- a/src/bun.js/bindings/ZigGlobalObject.cpp
+++ b/src/bun.js/bindings/ZigGlobalObject.cpp
@@ -286,20 +286,18 @@ extern "C" void JSCInitialize(const char* envp[], size_t envc, void (*onCrash)(c
        }
 #endif

-        JSC::initialize();
-        {
-
-            JSC::Options::AllowUnfinalizedAccessScope scope;
-
+        // Use JSC::initialize with a callback to set Options during initialization.
+        // The callback runs BEFORE IPInt::initialize() so we can configure WASM options early.
+        JSC::initialize([&] {
+            JSC::Options::useWasm() = true;
+            JSC::Options::useJIT() = true;
+            JSC::Options::useBBQJIT() = true;
            JSC::Options::useConcurrentJIT() = true;
            // JSC::Options::useSigillCrashAnalyzer() = true;
-            JSC::Options::useWasm() = true;
            JSC::Options::useSourceProviderCache() = true;
            // JSC::Options::useUnlinkedCodeBlockJettisoning() = false;
            JSC::Options::exposeInternalModuleLoader() = true;
            JSC::Options::useSharedArrayBuffer() = true;
-            JSC::Options::useJIT() = true;
-            JSC::Options::useBBQJIT() = true;
            JSC::Options::useJITCage() = false;
            JSC::Options::useShadowRealm() = true;
            JSC::Options::useV8DateParser() = true;
@@ -331,7 +329,7 @@ extern "C" void JSCInitialize(const char* envp[], size_t envc, void (*onCrash)(c
                }
            }
            JSC::Options::assertOptionsAreCoherent();
-        }
+        }); // end JSC::initialize lambda
    }); // end std::call_once lambda

    // NOLINTEND
--- a/src/bun.js/bindings/highway_strings.cpp
+++ b/src/bun.js/bindings/highway_strings.cpp
@@ -657,15 +657,15 @@ HWY_EXPORT(IndexOfNewlineOrNonASCIIOrHashOrAtImpl);
 HWY_EXPORT(IndexOfSpaceOrNewlineOrNonASCIIImpl);
 HWY_EXPORT(MemMemImpl);
 HWY_EXPORT(ScanCharFrequencyImpl);
-} // namespace bun
-
 // Define the C-callable wrappers that use HWY_DYNAMIC_DISPATCH.
-// These need to be defined *after* the HWY_EXPORT block.
+// These need to be defined *after* the HWY_EXPORT block and INSIDE namespace bun
+// so that HWY_DYNAMIC_DISPATCH(FuncImpl) correctly resolves to bun::N_*::FuncImpl.
+// The extern "C" only affects linkage (for C callers), not namespace resolution.
 extern "C" {

 void* highway_memmem(const uint8_t* haystack, size_t haystack_len, const uint8_t* needle, size_t needle_len)
 {
-    return HWY_DYNAMIC_DISPATCH(bun::MemMemImpl)(haystack, haystack_len, needle, needle_len);
+    return HWY_DYNAMIC_DISPATCH(MemMemImpl)(haystack, haystack_len, needle, needle_len);
 }

 static void highway_copy_u16_to_u8_impl(
@@ -673,7 +673,7 @@ static void highway_copy_u16_to_u8_impl(
    size_t count,
    uint8_t* output)
 {
-    return HWY_DYNAMIC_DISPATCH(bun::CopyU16ToU8Impl)(input, count, output);
+    return HWY_DYNAMIC_DISPATCH(CopyU16ToU8Impl)(input, count, output);
 }

 void highway_copy_u16_to_u8(
@@ -707,53 +707,53 @@ void highway_copy_u16_to_u8(
 }
 size_t highway_index_of_any_char(const uint8_t* HWY_RESTRICT text, size_t text_len, const uint8_t* HWY_RESTRICT chars, size_t chars_len)
 {
-    return HWY_DYNAMIC_DISPATCH(bun::IndexOfAnyCharImpl)(text, text_len, chars, chars_len);
+    return HWY_DYNAMIC_DISPATCH(IndexOfAnyCharImpl)(text, text_len, chars, chars_len);
 }

 void highway_char_frequency(const uint8_t* HWY_RESTRICT text, size_t text_len,
    int32_t* freqs, int32_t delta)
 {
-    HWY_DYNAMIC_DISPATCH(bun::ScanCharFrequencyImpl)(text, text_len, freqs, delta);
+    HWY_DYNAMIC_DISPATCH(ScanCharFrequencyImpl)(text, text_len, freqs, delta);
 }

 size_t highway_index_of_char(const uint8_t* HWY_RESTRICT haystack, size_t haystack_len,
    uint8_t needle)
 {
-    return HWY_DYNAMIC_DISPATCH(bun::IndexOfCharImpl)(haystack, haystack_len, needle);
+    return HWY_DYNAMIC_DISPATCH(IndexOfCharImpl)(haystack, haystack_len, needle);
 }

 size_t highway_index_of_interesting_character_in_string_literal(const uint8_t* HWY_RESTRICT text, size_t text_len, uint8_t quote)
 {
-    return HWY_DYNAMIC_DISPATCH(bun::IndexOfInterestingCharacterInStringLiteralImpl)(text, text_len, quote);
+    return HWY_DYNAMIC_DISPATCH(IndexOfInterestingCharacterInStringLiteralImpl)(text, text_len, quote);
 }

 size_t highway_index_of_newline_or_non_ascii(const uint8_t* HWY_RESTRICT haystack, size_t haystack_len)
 {
-    return HWY_DYNAMIC_DISPATCH(bun::IndexOfNewlineOrNonASCIIImpl)(haystack, haystack_len);
+    return HWY_DYNAMIC_DISPATCH(IndexOfNewlineOrNonASCIIImpl)(haystack, haystack_len);
 }

 size_t highway_index_of_newline_or_non_ascii_or_hash_or_at(const uint8_t* HWY_RESTRICT haystack, size_t haystack_len)
 {
-    return HWY_DYNAMIC_DISPATCH(bun::IndexOfNewlineOrNonASCIIOrHashOrAtImpl)(haystack, haystack_len);
+    return HWY_DYNAMIC_DISPATCH(IndexOfNewlineOrNonASCIIOrHashOrAtImpl)(haystack, haystack_len);
 }

 bool highway_contains_newline_or_non_ascii_or_quote(const uint8_t* HWY_RESTRICT text, size_t text_len)
 {
-    return HWY_DYNAMIC_DISPATCH(bun::ContainsNewlineOrNonASCIIOrQuoteImpl)(text, text_len);
+    return HWY_DYNAMIC_DISPATCH(ContainsNewlineOrNonASCIIOrQuoteImpl)(text, text_len);
 }

 size_t highway_index_of_needs_escape_for_javascript_string(const uint8_t* HWY_RESTRICT text, size_t text_len, uint8_t quote_char)
 {
    if (quote_char == '`') {
-        return HWY_DYNAMIC_DISPATCH(bun::IndexOfNeedsEscapeForJavaScriptStringImplBacktick)(text, text_len, quote_char);
+        return HWY_DYNAMIC_DISPATCH(IndexOfNeedsEscapeForJavaScriptStringImplBacktick)(text, text_len, quote_char);
    } else {
-        return HWY_DYNAMIC_DISPATCH(bun::IndexOfNeedsEscapeForJavaScriptStringImplQuote)(text, text_len, quote_char);
+        return HWY_DYNAMIC_DISPATCH(IndexOfNeedsEscapeForJavaScriptStringImplQuote)(text, text_len, quote_char);
    }
 }

 size_t highway_index_of_space_or_newline_or_non_ascii(const uint8_t* HWY_RESTRICT text, size_t text_len)
 {
-    return HWY_DYNAMIC_DISPATCH(bun::IndexOfSpaceOrNewlineOrNonASCIIImpl)(text, text_len);
+    return HWY_DYNAMIC_DISPATCH(IndexOfSpaceOrNewlineOrNonASCIIImpl)(text, text_len);
 }

 void highway_fill_with_skip_mask(
@@ -764,11 +764,13 @@ void highway_fill_with_skip_mask(
    size_t length, // Length of input/output
    bool skip_mask) // Whether to skip masking
 {
-    HWY_DYNAMIC_DISPATCH(bun::FillWithSkipMaskImpl)(mask, mask_len, output, input, length, skip_mask);
+    HWY_DYNAMIC_DISPATCH(FillWithSkipMaskImpl)(mask, mask_len, output, input, length, skip_mask);
 }

 } // extern "C"

+} // namespace bun
+
 #if OS(DARWIN)
 // On macOS, override the libc memmem with our implementation
 // This uses inline assembly to ensure the symbol is exported with the correct name
--- a/src/compile_target.zig
+++ b/src/compile_target.zig
@@ -294,7 +294,7 @@ pub fn downloadToPath(this: *const CompileTarget, env: *bun.DotEnv.Loader, alloc

 pub fn isSupported(this: *const CompileTarget) bool {
    return switch (this.os) {
-        .windows => this.arch == .x64,
+        .windows => this.arch == .x64 or this.arch == .arm64,

        .mac => true,
        .linux => true,
--- a/src/crash_handler.zig
+++ b/src/crash_handler.zig
@@ -1103,6 +1103,7 @@ const Platform = enum(u8) {

    windows_x86_64 = 'w',
    windows_x86_64_baseline = 'e',
+    windows_aarch64 = 'W',

    const current = @field(Platform, @tagName(bun.Environment.os) ++
        "_" ++ @tagName(builtin.target.cpu.arch) ++
--- a/src/env.zig
+++ b/src/env.zig
@@ -52,6 +52,7 @@ pub const base_path = build_options.base_path;
 pub const enable_logs = build_options.enable_logs;
 pub const enable_asan = build_options.enable_asan;
 pub const enable_fuzzilli = build_options.enable_fuzzilli;
+pub const enable_tinycc = build_options.enable_tinycc;
 pub const codegen_path = build_options.codegen_path;
 pub const codegen_embed = build_options.codegen_embed;

--- a/src/windows-app-info.rc
+++ b/src/windows-app-info.rc
@@ -24,7 +24,7 @@ BEGIN
            VALUE "InternalName", "bun\0"
            VALUE "OriginalFilename", "bun.exe\0"
            VALUE "ProductName", "Bun\0"
-            VALUE "ProductVersion", "@Bun_VERSION_WITH_TAG@\0",
+            VALUE "ProductVersion", "@Bun_VERSION_WITH_TAG@\0"
            VALUE "CompanyName", "Oven\0"
            VALUE "LegalCopyright", "https://bun.com/docs/project/licensing\0"
        END
--- a/test/bundler/bun-build-compile.test.ts
+++ b/test/bundler/bun-build-compile.test.ts
@@ -48,16 +48,6 @@ describe("Bun.build compile", () => {
        },
      }),
    ).toThrowErrorMatchingInlineSnapshot(`"Unknown compile target: bun-invalid-platform"`);
-
-    expect(() =>
-      Bun.build({
-        entrypoints: [join(dir, "index.js")],
-        compile: {
-          target: "bun-windows-arm64",
-          outfile: join(dir, "invalid-app"),
-        },
-      }),
-    ).toThrowErrorMatchingInlineSnapshot(`"Unsupported compile target: bun-windows-arm64"`);
  });
  test("compile with relative outfile paths", async () => {
    using dir = tempDir("build-compile-relative-paths", {