Fix Windows GPU build: use Ninja generator + MSVC env setup

Root cause: pyproject-pypi.toml.j2 hardcoded '-G Visual Studio 17 2022' for
ALL Windows builds. scikit-build-core passed this directly to CMake, overriding
the CMAKE_GENERATOR env var. The Visual Studio generator uses MSBuild which
spawns nvcc in subprocesses where pixi's conda-modified PATH lacks cl.exe.

Fix:
1. Split cmake_windows_args() into cpu (Visual Studio) and gpu (Ninja) macros
2. Add setup_msvc_env.py helper that runs vcvarsall.bat inside the pixi env,
   capturing MSVC environment (PATH, INCLUDE, LIB) for the build subprocess
3. Pass CMAKE_CUDA_HOST_COMPILER via cmake.define to tell nvcc where cl.exe is
4. Find cl.exe path in CI workflow using vswhere.exe before the build step

Author: jeongseok-meta

.github/workflows/publish_to_pypi.yml

@@ -283,7 +283,42 @@ jobs:
 
       # Note: No separate CUDA toolkit install needed for Windows.
       # conda-forge's cuda-toolkit (via pixi) provides nvcc and CUDA headers/libs.
-      # We use Ninja generator to avoid MSBuild CUDA .targets PATH issues.
+      # We use Ninja generator (set in pyproject-pypi.toml.j2) to avoid MSBuild CUDA
+      # .targets PATH issues. CMAKE_CUDA_HOST_COMPILER points nvcc to cl.exe directly.
+
+      - name: Find MSVC cl.exe path (Windows GPU)
+        if: steps.should_run.outputs.run == 'true' && runner.os == 'Windows'
+        id: msvc
+        shell: bash
+        run: |
+          # Find vswhere.exe (installed by default on GitHub-hosted Windows runners)
+          VSWHERE="/c/Program Files (x86)/Microsoft Visual Studio/Installer/vswhere.exe"
+          if [ ! -f "$VSWHERE" ]; then
+            echo "::error::vswhere.exe not found"
+            exit 1
+          fi
+
+          # Get the Visual Studio installation path
+          VS_PATH=$("$VSWHERE" -latest -property installationPath)
+          echo "Visual Studio path: $VS_PATH"
+
+          # Find cl.exe for the host architecture (x64)
+          CL_PATH=$(find "$VS_PATH/VC/Tools/MSVC" -name "cl.exe" -path "*/Hostx64/x64/*" | head -1)
+          if [ -z "$CL_PATH" ]; then
+            echo "::error::cl.exe not found in Visual Studio installation"
+            exit 1
+          fi
+          echo "cl.exe found: $CL_PATH"
+
+          # Convert to Windows path format for CMake
+          CL_PATH_WIN=$(cygpath -w "$CL_PATH")
+          echo "cl.exe (Windows path): $CL_PATH_WIN"
+          echo "cl_path=$CL_PATH_WIN" >> $GITHUB_OUTPUT
+
+          # Also export the directory containing cl.exe for PATH
+          CL_DIR=$(dirname "$CL_PATH")
+          CL_DIR_WIN=$(cygpath -w "$CL_DIR")
+          echo "cl_dir=$CL_DIR_WIN" >> $GITHUB_OUTPUT
 
       - name: Set up pixi
         if: steps.should_run.outputs.run == 'true'
@@ -344,7 +379,7 @@ jobs:
           CMAKE_C_COMPILER_LAUNCHER: sccache
           CMAKE_CXX_COMPILER_LAUNCHER: sccache
           SCCACHE_GHA_ENABLED: "true"
-          CMAKE_GENERATOR: Ninja
+          CMAKE_CUDA_HOST_COMPILER: ${{ steps.msvc.outputs.cl_path }}
         run: pixi run -e ${{ matrix.pixi-environment }} wheel_build
 
       - name: Repair GPU wheel (Linux)

pixi.toml

@@ -589,11 +589,13 @@ pytorch-gpu = ">=2.8.0,<3"
 
 [feature.gpu-wheel-build-win.target.win-64.tasks]
 # Windows GPU wheel build using pip wheel + delvewheel
-# Uses CUDA from conda-forge for GPU support
+# Uses Ninja generator with CUDA from conda-forge
+# setup_msvc_env.py injects MSVC environment (cl.exe, INCLUDE, LIB) into the pixi env
+# so that nvcc can find cl.exe for host compilation
 wheel_build = { cmd = """
     python scripts/generate_pyproject.py && \
     python -c "import os, shutil; os.makedirs('.tmp', exist_ok=True); shutil.copy('pyproject.toml', '.tmp/pyproject-backup.toml'); shutil.copy('pyproject-pypi-gpu.toml', 'pyproject.toml')" && \
-    pip wheel . --no-deps --no-build-isolation --wheel-dir=dist && \
+    python scripts/setup_msvc_env.py pip wheel . --no-deps --no-build-isolation --wheel-dir=dist && \
     python -c "import shutil; shutil.move('.tmp/pyproject-backup.toml', 'pyproject.toml')"
 """, env = { MOMENTUM_ENABLE_CUDA = "ON", TORCH_CUDA_ARCH_LIST = "5.0;6.0;6.1;7.0;7.5;8.0;8.6;8.9;9.0+PTX" }, description = "Build GPU wheel for Windows (uses pip wheel + delvewheel + CUDA from conda-forge)" }
 

pyproject-pypi.toml.j2

@@ -33,8 +33,8 @@
     "-DMOMENTUM_USE_SYSTEM_PYBIND11=ON",
 {%- endmacro %}
 
-{#- Windows-specific args (maintains original order with -G after SHARED_LIBS) -#}
-{%- macro cmake_windows_args() %}
+{#- Windows CPU-specific args (Visual Studio generator for CPU builds) -#}
+{%- macro cmake_windows_cpu_args() %}
     "-DBUILD_SHARED_LIBS=OFF",
     "-G Visual Studio 17 2022",
     "-DMOMENTUM_BUILD_PYMOMENTUM=ON",
@@ -44,9 +44,23 @@
     "-DMOMENTUM_ENABLE_SIMD=OFF",
     "-DMOMENTUM_USE_SYSTEM_RERUN_CPP_SDK=ON",
     "-DMOMENTUM_USE_SYSTEM_PYBIND11=ON",
-{% if variant == "cpu" %}
     "-DCMAKE_CXX_SCAN_FOR_MODULES=OFF",
-{% endif %}
+{%- endmacro %}
+
+{#- Windows GPU-specific args (Ninja generator to avoid MSBuild/CUDA PATH issues) -#}
+{#- Using Ninja avoids the Visual Studio CUDA .targets integration which spawns -#}
+{#- nvcc in subprocesses where pixi's conda-modified PATH lacks cl.exe. -#}
+{#- CMAKE_CUDA_HOST_COMPILER must be set to the full cl.exe path via env var. -#}
+{%- macro cmake_windows_gpu_args() %}
+    "-DBUILD_SHARED_LIBS=OFF",
+    "-G Ninja",
+    "-DMOMENTUM_BUILD_PYMOMENTUM=ON",
+    "-DMOMENTUM_BUILD_EXAMPLES=OFF",
+    "-DMOMENTUM_BUILD_TESTING=OFF",
+    "-DMOMENTUM_BUILD_RENDERER=OFF",
+    "-DMOMENTUM_ENABLE_SIMD=OFF",
+    "-DMOMENTUM_USE_SYSTEM_RERUN_CPP_SDK=ON",
+    "-DMOMENTUM_USE_SYSTEM_PYBIND11=ON",
 {%- endmacro %}
 
 {#- Common cibuildwheel before-all script for Linux (CPU builds) -#}
@@ -136,6 +150,7 @@ classifiers = [
     "License :: OSI Approved :: MIT License",
 {% if variant == "gpu" %}
     "Operating System :: POSIX :: Linux",
+    "Operating System :: Microsoft :: Windows",
 {% else %}
     "Operating System :: POSIX :: Linux",
     "Operating System :: MacOS",
@@ -226,12 +241,24 @@ cmake.args = [
 cmake.define.CMAKE_PREFIX_PATH = {env = "CMAKE_PREFIX_PATH"}
 {% endif %}
 
+{% if variant == "cpu" %}
 [[tool.scikit-build.overrides]]
 if.platform-system = "^win32"
 cmake.args = [
-{{ cmake_windows_args() }}
+{{ cmake_windows_cpu_args() }}
 ]
 cmake.define.CMAKE_PREFIX_PATH = {env = "CMAKE_PREFIX_PATH"}
+{% endif %}
+
+{% if variant == "gpu" %}
+[[tool.scikit-build.overrides]]
+if.platform-system = "^win32"
+cmake.args = [
+{{ cmake_windows_gpu_args() }}
+]
+cmake.define.CMAKE_PREFIX_PATH = {env = "CMAKE_PREFIX_PATH"}
+cmake.define.CMAKE_CUDA_HOST_COMPILER = {env = "CMAKE_CUDA_HOST_COMPILER", default = "cl.exe"}
+{% endif %}
 
 [tool.setuptools_scm]
 # Automatically determine version from git tags

scripts/setup_msvc_env.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""Set up MSVC environment variables for Ninja + CUDA builds on Windows.
+
+When using the Ninja CMake generator with CUDA on Windows inside a pixi/conda
+environment, the PATH may not include MSVC tools (cl.exe, link.exe, etc.).
+This script finds vcvarsall.bat, runs it, captures the environment changes,
+and applies them to the current process before executing the given command.
+
+Usage:
+    python scripts/setup_msvc_env.py <command> [args...]
+
+Example:
+    python scripts/setup_msvc_env.py pip wheel . --no-deps --wheel-dir=dist
+"""
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+
+def find_vcvarsall() -> Path:
+    """Find vcvarsall.bat using vswhere.exe."""
+    vswhere = Path(
+        r"C:\Program Files (x86)\Microsoft Visual Studio\Installer\vswhere.exe"
+    )
+    if not vswhere.exists():
+        raise FileNotFoundError(f"vswhere.exe not found at {vswhere}")
+
+    result = subprocess.run(
+        [str(vswhere), "-latest", "-property", "installationPath"],
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+    vs_path = Path(result.stdout.strip())
+    vcvarsall = vs_path / "VC" / "Auxiliary" / "Build" / "vcvarsall.bat"
+    if not vcvarsall.exists():
+        raise FileNotFoundError(f"vcvarsall.bat not found at {vcvarsall}")
+    return vcvarsall
+
+
+def get_msvc_env(vcvarsall: Path, arch: str = "amd64") -> dict:
+    """Run vcvarsall.bat and capture the resulting environment variables."""
+    # Run vcvarsall.bat and print the environment
+    cmd = f'"{vcvarsall}" {arch} && set'
+    result = subprocess.run(cmd, shell=True, capture_output=True, text=True, check=True)
+
+    env = {}
+    for line in result.stdout.splitlines():
+        if "=" in line:
+            key, _, value = line.partition("=")
+            env[key] = value
+    return env
+
+
+def main():
+    if len(sys.argv) < 2:
+        print(f"Usage: {sys.argv[0]} <command> [args...]", file=sys.stderr)
+        sys.exit(1)
+
+    if sys.platform != "win32":
+        # On non-Windows, just exec the command directly
+        os.execvp(sys.argv[1], sys.argv[1:])
+
+    print("=== Setting up MSVC environment for Ninja + CUDA build ===")
+
+    # Find vcvarsall.bat
+    vcvarsall = find_vcvarsall()
+    print(f"Found vcvarsall.bat: {vcvarsall}")
+
+    # Get MSVC environment
+    msvc_env = get_msvc_env(vcvarsall)
+
+    # Merge MSVC environment into current environment
+    # Key variables to merge: PATH, INCLUDE, LIB, LIBPATH, etc.
+    merge_vars = [
+        "PATH",
+        "INCLUDE",
+        "LIB",
+        "LIBPATH",
+        "WindowsSdkDir",
+        "WindowsSdkVersion",
+        "VCToolsInstallDir",
+        "VCToolsVersion",
+        "VSCMD_ARG_TGT_ARCH",
+    ]
+
+    for var in merge_vars:
+        if var in msvc_env:
+            if var == "PATH":
+                # Prepend MSVC paths to existing PATH (preserve conda paths too)
+                current_path = os.environ.get("PATH", "")
+                msvc_path = msvc_env["PATH"]
+                # Extract paths from MSVC env that aren't already in current PATH
+                current_paths = set(current_path.lower().split(os.pathsep))
+                new_paths = [
+                    p
+                    for p in msvc_path.split(os.pathsep)
+                    if p.lower() not in current_paths
+                ]
+                if new_paths:
+                    os.environ["PATH"] = (
+                        os.pathsep.join(new_paths) + os.pathsep + current_path
+                    )
+                    print(f"Added {len(new_paths)} MSVC paths to PATH")
+            else:
+                os.environ[var] = msvc_env[var]
+                print(f"Set {var}")
+
+    # Verify cl.exe is accessible
+    try:
+        result = subprocess.run(
+            ["where", "cl.exe"], capture_output=True, text=True, check=True
+        )
+        print(f"cl.exe found: {result.stdout.strip().splitlines()[0]}")
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        print("WARNING: cl.exe not found on PATH after MSVC setup", file=sys.stderr)
+
+    print("=== MSVC environment ready ===")
+    print(f"Executing: {' '.join(sys.argv[1:])}")
+
+    # Execute the requested command
+    result = subprocess.run(sys.argv[1:])
+    sys.exit(result.returncode)
+
+
+if __name__ == "__main__":
+    main()