refactor: make this a pure CUDA example

Remove the CPU fallback so the package is a pure CUDA example: building now
hard-requires the CUDA Toolkit (CMake declares CUDA as a required language).

- add/subtract are both CUDA kernels; cuda_available() queries the device
- drop src/add_cpu.cpp, the WITH_CUDA flag, and the conditional CMake path
- skip the GPU tests when no device is present
- remove the non-CUDA CI/config (conda, Android/iOS/Pyodide cross-compile)
- fold CUDA wheel building into wheels.yml; pip.yml is a build-and-import check
- link the CUDA runtime statically so wheels don't depend on libcudart

Assisted-by: ClaudeCode:claude-opus-4.8

Author: henryiii

.github/workflows/cibw-cc.yaml

@@ -8,25 +8,31 @@ on:
       - master
 
 jobs:
-  build:
-    name: Build with Pip
-    runs-on: ${{ matrix.platform }}
+  # Build the CUDA extension inside the manylinux images that ship the CUDA
+  # Toolkit (see https://github.com/pypa/cibuildwheel/pull/2896). GitHub's
+  # runners have no GPU, so this compiles the kernels and imports the module;
+  # the GPU tests are skipped (`cuda_available()` is False).
+  cuda:
+    name: Build with CUDA (${{ matrix.arch }})
+    runs-on: ${{ matrix.runner }}
+    container: quay.io/manylinux_cuda/manylinux_2_28_${{ matrix.arch }}_cuda13_1:latest
     strategy:
       fail-fast: false
       matrix:
-        platform: [windows-latest, macos-latest, ubuntu-latest]
-        python-version: ["3.9", "3.14", "pypy-3.10"]
+        include:
+          - arch: x86_64
+            runner: ubuntu-24.04
+          - arch: aarch64
+            runner: ubuntu-24.04-arm
 
     steps:
     - uses: actions/checkout@v6
 
-    - uses: actions/setup-python@v6
-      with:
-        python-version: ${{ matrix.python-version }}
-        allow-prereleases: true
-
     - name: Build and install
-      run: pip install --verbose . --group test
+      run: |
+        /opt/python/cp312-cp312/bin/python -m venv /tmp/venv
+        /tmp/venv/bin/pip install --upgrade pip
+        /tmp/venv/bin/pip install --verbose . --group test
 
     - name: Test
-      run: pytest
+      run: /tmp/venv/bin/pytest

.github/workflows/cibw-cuda.yaml

@@ -23,8 +23,6 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v6
-      with:
-        submodules: true
 
     - name: Build SDist
       run: pipx run build --sdist
@@ -39,29 +37,42 @@ jobs:
 
 
   build_wheels:
-    name: Wheels on ${{ matrix.os }}
-    runs-on: ${{ matrix.os }}
+    name: Wheels on ${{ matrix.arch }}
+    runs-on: ${{ matrix.runner }}
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-latest, macos-15-intel, macos-latest, windows-latest, ubuntu-24.04-arm, windows-11-arm]
+        include:
+          - arch: x86_64
+            runner: ubuntu-24.04
+          - arch: aarch64
+            runner: ubuntu-24.04-arm
+
+    # The CUDA Toolkit ships inside these custom manylinux images, so nvcc is
+    # available during the build (see https://github.com/pypa/cibuildwheel/pull/2896).
+    # Bump the CUDA version here; to publish wheels for several CUDA versions you
+    # would also need distinct local version labels (e.g. 0.0.1+cu131).
+    env:
+      CUDA_VERSION: "13_1"
+      MANYLINUX_BASE: manylinux_2_28
 
     steps:
     - uses: actions/checkout@v6
-      with:
-        submodules: true
-
-    - uses: astral-sh/setup-uv@v8.0.0
 
     - uses: pypa/cibuildwheel@v3.4
+      env:
+        CIBW_MANYLINUX_X86_64_IMAGE: >-
+          quay.io/manylinux_cuda/${{ env.MANYLINUX_BASE }}_x86_64_cuda${{ env.CUDA_VERSION }}:latest
+        CIBW_MANYLINUX_AARCH64_IMAGE: >-
+          quay.io/manylinux_cuda/${{ env.MANYLINUX_BASE }}_aarch64_cuda${{ env.CUDA_VERSION }}:latest
 
     - name: Verify clean directory
       run: git diff --exit-code
       shell: bash
 
     - uses: actions/upload-artifact@v7
       with:
-        name: cibw-wheels-${{ matrix.os }}
+        name: cibw-wheels-${{ matrix.arch }}
         path: wheelhouse/*.whl
 
 

.github/workflows/conda.yml

@@ -22,6 +22,7 @@ parts/
 sdist/
 var/
 wheels/
+wheelhouse/
 share/python-wheels/
 *.egg-info/
 .installed.cfg

.github/workflows/pip.yml

@@ -26,7 +26,6 @@ repos:
   - id: check-merge-conflict
   - id: check-symlinks
   - id: check-yaml
-    exclude: ^conda\.recipe/meta\.yaml$
   - id: debug-statements
   - id: end-of-file-fixer
   - id: mixed-line-ending

.github/workflows/wheels.yml

@@ -3,46 +3,30 @@
 cmake_minimum_required(VERSION 3.18...4.0)
 
 # Scikit-build-core sets these values for you, or you can just hard-code the
-# name and version.
+# name and version. CUDA is a required language: configuration fails without a
+# CUDA compiler (nvcc).
 project(
   ${SKBUILD_PROJECT_NAME}
   VERSION ${SKBUILD_PROJECT_VERSION}
-  LANGUAGES CXX)
+  LANGUAGES CXX CUDA)
 
 # Find pybind11 and Python
 find_package(pybind11 CONFIG REQUIRED)
 
-# Enable CUDA if a compiler (nvcc) is available. This lets the example build
-# everywhere: with the CUDA Toolkit it compiles the real kernel, and without it
-# it falls back to a CPU implementation.
-include(CheckLanguage)
-check_language(CUDA)
-if(CMAKE_CUDA_COMPILER)
-  enable_language(CUDA)
-  message(STATUS "CUDA found: building the GPU implementation")
-  set(ADD_SOURCE src/add.cu)
-else()
-  message(STATUS "CUDA not found: building the CPU fallback")
-  set(ADD_SOURCE src/add_cpu.cpp)
-endif()
-
 # Add a library using FindPython's tooling (pybind11 also provides a helper like
-# this)
-python_add_library(_core MODULE src/main.cpp ${ADD_SOURCE} WITH_SOABI)
+# this), combining the pybind11 bindings with the CUDA kernels.
+python_add_library(_core MODULE src/main.cpp src/add.cu WITH_SOABI)
 target_link_libraries(_core PRIVATE pybind11::headers)
 
 # This is passing in the version as a define just as an example
 target_compile_definitions(_core PRIVATE VERSION_INFO=${PROJECT_VERSION})
 
-if(CMAKE_CUDA_COMPILER)
-  # Build for all major architectures so the wheel is portable, and link the
-  # CUDA runtime statically so the wheel does not depend on libcudart.
-  if(NOT DEFINED CMAKE_CUDA_ARCHITECTURES)
-    set_property(TARGET _core PROPERTY CUDA_ARCHITECTURES all-major)
-  endif()
-  set_property(TARGET _core PROPERTY CUDA_RUNTIME_LIBRARY Static)
-  target_compile_definitions(_core PRIVATE WITH_CUDA)
+# Build for all major architectures so the wheel is portable, and link the CUDA
+# runtime statically so the wheel does not depend on libcudart.
+if(NOT DEFINED CMAKE_CUDA_ARCHITECTURES)
+  set_property(TARGET _core PROPERTY CUDA_ARCHITECTURES all-major)
 endif()
+set_property(TARGET _core PROPERTY CUDA_RUNTIME_LIBRARY Static)
 
 # The install directory is the output (wheel) directory
 install(TARGETS _core DESTINATION cuda_example)