matrix.yaml

compile_time:
  pull_request:
    - id: public-headers-gcc13
      name: Public headers compile-time bench
      gpu: t4
      launch_args: "--cuda 13.4 --host gcc13"
      baseline_ref: origin/main
      preset: all-dev
      targets:
        - cub.headers.base
        - thrust.cpp.cuda.headers.base
        - libcudacxx.test.public_headers
      args: "-arch native"
      slices:
        - id: total-compilation
          title: TU total compilation
          filter: total-compilation
          timing: inclusive
          sort: total
          top: 15
          threshold: 3.0
        - id: file-processing
          title: Direct file processing
          filter: file-processing
          timing: exclusive
          sort: total
          top: 15
          threshold: 0.2
        - id: function-bodies
          title: Function-body parsing
          filter: scanning-function-body
          timing: inclusive
          sort: total
          top: 15
          threshold: 0.25
        - id: template-instantiation
          title: Template instantiation
          filter: template-instantiation
          timing: inclusive
          sort: total
          top: 15
          threshold: 0.2

# Compares the SASS of the benchmarks before and after the change in a PR, and tells the
# author to run the benchmarks when the generated code changed.
#
# We should almost always run these on latest CTK and compiler since that compiles the most
# amount of arches.
sass:
  pull_request:
    - id: cub-benchmarks
      project: cub
      ctk: '13.X'
      cxx: 'gcc13'
      preset: cub-benchmark
      archs: all-major-cccl
      target_filters: ["^cub\\.bench\\."]
    - id: thrust-benchmarks
      project: thrust
      ctk: '13.X'
      cxx: 'gcc13'
      preset: thrust-benchmark
      archs: all-major-cccl
      target_filters: ["^thrust\\.bench\\."]

workflows:
  # If any jobs appear here, they will be executed instead of `pull_request' for PRs.
  # This is useful for limiting resource usage when a full matrix is not needed.
  # The branch protection checks will fail when using this override workflow.
  #
  # Example:
  # override:
  #   # Full project build: slow, expensive
  #   - { jobs: ['test'], project: 'thrust', std: 17, ctk: '12.X', cxx: ['gcc12', 'clang16'] }
  #
  #   # Build / run targeted tests: faster turnaround, less runner usage.
  #   # Use project 'target'.
  #   # args are passed to ci/util/build_and_test_targets.sh. See that script for available options.
  #   - { jobs: ['run_cpu'], project: 'target', ctk: ['12.X', '13.X'], cxx: ['gcc', 'clang', 'msvc'],
  #       args: '--preset cub-cpp20 --build-targets "cub.cpp20.test.iterator"' }
  #   - { jobs: ['run_gpu'], project: 'target', ctk: ['12.X', '13.X'], cxx: ['gcc', 'clang'], gpu: 'rtxa6000',
  #       args: '--preset cub-cpp20 --build-targets "cub.cpp20.test.iterator" --ctest-targets "cub.cpp20.test.iterator"' }
  #   - { jobs: ['run_cpu'], project: 'target', ctk: ['12.X', '13.X'], cxx: ['gcc', 'clang', 'msvc'],
  #       args: '--preset libcudacxx --lit-precompile-tests "cuda/utility/basic_any.pass.cpp"' }
  #   - { jobs: ['run_gpu'], project: 'target', ctk: ['12.X', '13.X'], cxx: ['gcc', 'clang'], gpu: 't4',
  #       args: '--preset libcudacxx --lit-tests "cuda/utility/basic_any.pass.cpp"' }
  #
  # IMPORTANT: Do NOT delete or remove the `override:` key below, even when it is empty.
  override:

  pull_request_fork:
    - {jobs: ['build'],                     project: ['libcudacxx', 'thrust', 'cudax'], std: 'max',  cxx: ['gcc', 'clang', 'msvc']}
    - {jobs: ['build_nolid', 'build_lid0'], project: 'cub',                             std: 'max',  cxx: ['gcc', 'clang', 'msvc']}
    - {jobs: ['test_headers'],              project: 'python', py_version: '3.14',      ctk: '13.X', cxx: ['gcc13', 'msvc2022']}

  pull_request:
    # Old CTK: Oldest/newest supported host compilers:
    - {jobs: ['build'],                     project: ['libcudacxx', 'thrust'], std: 'minmax', ctk: '12.0', cxx: ['gcc12', 'clang14',            'msvc2019', 'msvc14.39']}
    - {jobs: ['build'],                     project: ['libcudacxx', 'thrust'], std: 'minmax', ctk: '12.0', cxx: 'gcc7'}
    - {jobs: ['build'],                     project: ['libcudacxx', 'thrust'], std: 'minmax', ctk: '12.X', cxx: ['gcc7',  'gcc14',   'clang14', 'clang19', 'msvc2019', 'msvc2022' ]}
    - {jobs: ['build'],                     project: ['libcudacxx', 'thrust'], std: 'minmax', ctk: '13.0', cxx: ['gcc11', 'gcc15',   'clang15', 'clang20', 'msvc2019', 'msvc2022' ]}
    - {jobs: ['build_nolid', 'build_lid0'], project: 'cub',                   std: 'minmax', ctk: '12.0', cxx: ['gcc12', 'clang14',            'msvc2019', 'msvc14.39']}
    - {jobs: ['build_nolid'],               project: 'cub',                   std: 'minmax', ctk: '12.0', cxx: 'gcc7'}
    # CTK12.0/GCC7 CUB host-launch builds are memory-heavy with benchmarks enabled; keep this shard below
    # the 61 GiB linux-amd64-cpu16 runner limit.
    - {jobs: ['build_lid0'],                project: 'cub',                   std: 'minmax', ctk: '12.0', cxx: 'gcc7', environment: ['PARALLEL_LEVEL=8']}
    - {jobs: ['build_nolid', 'build_lid0'], project: 'cub',                   std: 'minmax', ctk: '12.X', cxx: ['gcc7',  'gcc14',   'clang14', 'clang19', 'msvc2019', 'msvc2022' ]}
    - {jobs: ['build_nolid', 'build_lid0'], project: 'cub',                   std: 'minmax', ctk: '13.0', cxx: ['gcc11', 'gcc15',   'clang15', 'clang20', 'msvc2019', 'msvc2022' ]}
    # Old CTK: cudax has a different support matrix:
    - {jobs: ['build'], project: 'cudax', ctk: '12.0', std: 'minmax', cxx: ['gcc9',  'gcc12', 'clang14',            'msvc14.39']}
    - {jobs: ['build'], project: 'cudax', ctk: '12.X', std: 'minmax', cxx: ['gcc9',  'gcc14', 'clang14', 'clang19', 'msvc2022']}
    - {jobs: ['build'], project: 'cudax', ctk: '13.0', std: 'minmax', cxx: ['gcc11', 'gcc15', 'clang15', 'clang20', 'msvc2022']}
    # Current CTK build-only:
    - {jobs: ['build'],                     project: ['libcudacxx', 'thrust'], std: 'minmax', cxx: ['gcc11', 'clang15', 'msvc2019'] } # Oldest
    - {jobs: ['build'],                     project: ['libcudacxx', 'thrust'], std: 'max',    cxx: ['gcc12', 'gcc13', 'gcc14', 'gcc15'] }
    - {jobs: ['build'],                     project: ['libcudacxx', 'thrust'], std: 'max',    cxx: ['clang16', 'clang17', 'clang18', 'clang19', 'clang20', 'clang21'] }
    - {jobs: ['build'],                     project: ['libcudacxx', 'thrust'], std: 'max',    cxx: ['msvc2022'] }
    - {jobs: ['build'],                     project: ['libcudacxx', 'thrust'], std: 'all',    cxx: ['gcc', 'clang', 'msvc']} # Latest
    - {jobs: ['build_nolid', 'build_lid0'], project: 'cub',                   std: 'minmax', cxx: ['gcc11', 'clang15', 'msvc2019'] } # Oldest
    - {jobs: ['build_nolid', 'build_lid0'], project: 'cub',                   std: 'max',    cxx: ['gcc12', 'gcc13', 'gcc14', 'gcc15'] }
    - {jobs: ['build_nolid', 'build_lid0'], project: 'cub',                   std: 'max',    cxx: ['clang16', 'clang17', 'clang18', 'clang19', 'clang20', 'clang21'] }
    - {jobs: ['build_nolid', 'build_lid0'], project: 'cub',                   std: 'max',    cxx: ['msvc2022'] }
    - {jobs: ['build_nolid', 'build_lid0'], project: 'cub',                   std: 'all',    cxx: ['gcc', 'clang', 'msvc']} # Latest
    # Current CTK build-only: cudax has a different support matrix:
    - {jobs: ['build'], project: 'cudax', std: 'minmax', cxx: ['gcc11', 'clang15', 'msvc2022']} # Oldest
    - {jobs: ['build'], project: 'cudax', std: 'max',    cxx: ['gcc12']}
    - {jobs: ['build'], project: 'cudax', std: 'max',    cxx: ['clang16', 'clang17', 'clang18', 'clang19', 'clang20', 'clang21']}
    - {jobs: ['build'], project: 'cudax', std: 'all',    cxx: ['gcc', 'clang', 'msvc']} # Newest
    # CTK '13.X' build with tile support: default projects
    - {jobs: ['build'],                     std: 'all', project: ['libcudacxx', 'thrust', cudax], ctk: '13.X', cxx: ['gcc', 'clang', 'msvc'], args: '-enable-tile'}
    - {jobs: ['build_nolid', 'build_lid0'], std: 17, project: 'cub',                    ctk: '13.X', cxx: ['gcc', 'clang', 'msvc'], args: '-enable-tile'}
    # Current CTK testing:
    - {jobs: ['test'], project: 'thrust',     std: 'max', cxx: ['gcc', 'clang', 'msvc'], gpu: 'rtx4090'}
    - {jobs: ['test'], project: ['libcudacxx', 'cudax'], std: 'max', cxx: ['gcc', 'clang', 'msvc'], gpu: 't4'}

    - {jobs: ['test_nolid', 'test_lid0'], project: 'cub', std: 'max', cxx: ['gcc', 'clang', 'msvc'], gpu: 'rtxa6000'}
    - {jobs: ['test_lid1',  'test_lid2'], project: 'cub', std: 'max', cxx: ['gcc'],                  gpu: 'rtxa6000'}
    # H100 coverage:
    - {jobs: ['test_nolid', 'test_lid0'], project: 'cub',                   std: 'max', gpu: 'h100' }
    - {jobs: ['test_gpu'],                project: 'thrust',                std: 'max', gpu: 'h100' }
    - {jobs: ['test'],                    project: ['libcudacxx', 'cudax'], std: 'max', gpu: 'h100' }
    # Multi-GPU coverage:
    - {jobs: ['test'], project: ['libcudacxx', 'cudax'], std: 'max', gpu: 'h100_2gpu', sm: 'gpu'}
    # RTX PRO 6000 coverage (limited due to small number of runners):
    - {jobs: ['test_lid0'], project: 'cub', std: 'max', cxx: 'gcc', gpu: 'rtxpro6000'}
    # Misc:
    - {jobs: ['build'],                     cpu: 'arm64', project: ['libcudacxx', 'thrust', 'cudax'], std: '20', cxx: 'gcc'}
    - {jobs: ['build'],                     cpu: 'arm64', project: ['libcudacxx', 'thrust', 'cudax'], std: 'max', cxx: 'clang'}
    - {jobs: ['build_nolid', 'build_lid0'], cpu: 'arm64', project: 'cub', std: '20', cxx: 'gcc'}
    - {jobs: ['build_nolid', 'build_lid0'], cpu: 'arm64', project: 'cub', std: 'max', cxx: 'clang'}
    - {jobs: ['test_gpu'], project: 'thrust', cmake_options: '-DTHRUST_DISPATCH_TYPE=Force32bit', gpu: 'rtx4090'}
    - {jobs: ['nvrtc'], project: 'libcudacxx', std: 'all', gpu: 't4', sm: 'gpu'}
    - {jobs: ['verify_codegen'], project: 'libcudacxx'}
    # libcu++ Codegen FileCheck: PRs use one GCC host compiler per CTK.
    # Suite-specific architectures are added separately.
    - {jobs: ['codegen_filecheck'], project: 'libcudacxx', std: 'max', ctk: '12.0', cxx: 'gcc12', codegen_target: ['atomics-ptx', 'atomics-sass'], sm: [75, 80, 90]}
    - {jobs: ['codegen_filecheck'], project: 'libcudacxx', std: 'max', ctk: '12.X', cxx: 'gcc14', codegen_target: ['atomics-ptx', 'atomics-sass', 'simd-ptx', 'simd-sass'], sm: [80, 90, 100, 120]}
    - {jobs: ['codegen_filecheck'], project: 'libcudacxx', std: 'max', ctk: '12.X', cxx: 'gcc14', codegen_target: ['atomics-ptx', 'atomics-sass'], sm: 75}
    - {jobs: ['codegen_filecheck'], project: 'libcudacxx', std: 'max', ctk: '12.X', cxx: 'gcc14', codegen_target: 'simd-sass', sm: [103, '120f']}
    - {jobs: ['codegen_filecheck'], project: 'libcudacxx', std: 'max', ctk: '13.0', cxx: 'gcc15', codegen_target: ['atomics-ptx', 'atomics-sass', 'simd-ptx', 'simd-sass'], sm: [80, 90, 100, 120]}
    - {jobs: ['codegen_filecheck'], project: 'libcudacxx', std: 'max', ctk: '13.0', cxx: 'gcc15', codegen_target: ['atomics-ptx', 'atomics-sass'], sm: 75}
    - {jobs: ['codegen_filecheck'], project: 'libcudacxx', std: 'max', ctk: '13.0', cxx: 'gcc15', codegen_target: 'simd-sass', sm: [103, '120f']}
    - {jobs: ['codegen_filecheck'], project: 'libcudacxx', std: 'max', cxx: 'gcc', codegen_target: ['atomics-ptx', 'atomics-sass', 'simd-ptx', 'simd-sass'], sm: [80, 90, 100, 120]}
    - {jobs: ['codegen_filecheck'], project: 'libcudacxx', std: 'max', cxx: 'gcc', codegen_target: ['atomics-ptx', 'atomics-sass'], sm: 75}
    - {jobs: ['codegen_filecheck'], project: 'libcudacxx', std: 'max', cxx: 'gcc', codegen_target: 'simd-sass', sm: [103, '120f']}
    # c.parallel -- pinned to gcc13 / msvc2022 to match python
    - {jobs: ['test'], project: 'cccl_c_parallel', ctk: '12.X', cxx: ['gcc13', 'msvc2022'], gpu: ['t4']}
    - {jobs: ['test'], project: 'cccl_c_parallel', ctk: '13.X', cxx: ['gcc13', 'msvc2022'], gpu: ['t4', 'l4', 'h100']}
    # RTX PRO 6000 coverage (limited due to small number of runners):
    - {jobs: ['test'], project: 'cccl_c_parallel', ctk: '13.X', cxx: ['gcc13'], gpu: ['rtxpro6000']}
    # c.parallel v2 (HostJIT-based)
    #
    # For now, this is a separate job run for CUDA13.
    # Eventually v2 will replace v1 as the default and run across the
    # entire matrix. Currently blocked on libnvfatbin availability for CUDA <12.4.
    - {jobs: ['test'], project: 'cccl_c_parallel_v2', ctk: '13.X', cxx: 'gcc13', gpu: 't4'}
    - {jobs: ['test'], project: 'cccl_c_parallel_v2', ctk: '13.X', cxx: 'msvc', gpu: 'l4'}
    # Python against c.parallel v2 (HostJIT-based). Single point of coverage
    # for the v2 Python path; the main `python` matrix continues to test
    # against v1 until v2 replaces it. The minimal row proves the minimal extras
    # (no JIT backend) work against a v2 wheel.
    - {jobs: ['test'], project: 'python_v2', ctk: '13.X', py_version: ['3.14', '3.14t'], gpu: 'l4', cxx: 'gcc13'}
    - {jobs: ['test_py_compute_minimal'], project: 'python_v2', ctk: '13.X', py_version: ['3.14', '3.14t'], gpu: 'l4', cxx: 'gcc13'}
    # Oldest-supported-12.x smoke coverage (see #10778); single py_version,
    # no minimal row, to keep the PR job count down. Nightly/weekly sweep the
    # full 12.0/12.X/13.0/13.X matrix instead.
    - {jobs: ['test'], project: 'python_v2', ctk: '12.0', py_version: '3.14', gpu: 'l4', cxx: 'gcc13'}
    # c.experimental.stf-- pinned to gcc13 to match python
    - {jobs: ['test'], project: 'cccl_c_stf', ctk: ['12.X', '13.X'], cxx: 'gcc13', gpu: 't4'}
    - {jobs: ['test'], project: 'cccl_c_stf', ctk: '13.X', cxx: 'gcc13', gpu: ['l4', 'h100']}
    # Python -- pinned to gcc13 / msvc2022 for consistency across CTK images
    - {jobs: ['test'], project: 'python', ctk: ['12.X',        '13.X'], py_version: ['3.10'], gpu: 'l4', cxx: ['gcc13', 'msvc2022']}
    - {jobs: ['test'], project: 'python', ctk: ['12.0', '12.X','13.0', '13.X'], py_version: ['3.14', '3.14t'], gpu: 'l4', cxx: ['gcc13', 'msvc2022']}
    - {jobs: ['test'], project: 'python', py_version: '3.14', gpu: 'h100', cxx: 'gcc13'}
    - {jobs: ['test'], project: 'python', ctk: '13.X', py_version: '3.14', gpu: ['t4', 'rtxa6000', 'rtxpro6000'], cxx: 'gcc13'}
    # Minimal arm64 coverage of cuda.compute
    - {jobs: ['test'], project: 'python', cpu: 'arm64', ctk: ['12.X', '13.X'], py_version: '3.14', gpu: 'l4', cxx: 'gcc13'}
    # cuda.stf._experimental -- pinned to gcc13, Linux only. The cuda_cccl and
    # cuda_stf wheels both come from the auto-derived combined producer
    # (build_py_stf_wheel), so no companion `test` lane is needed here.
    - {jobs: ['test_py_stf'], project: 'python', ctk: ['12.X', '13.X'], py_version: ['3.14'], gpu: 'l4', cxx: 'gcc13'}
    - {jobs: ['test_py_stf'], project: 'python', ctk: '13.X', py_version: '3.14', gpu: 'h100_2gpu', cxx: 'gcc13'}
    # Test minimal extra
    - {jobs: ['test_py_compute_minimal'], project: 'python', ctk: '13.X', py_version: ['3.14', '3.14t'], gpu: 'l4', cxx: 'gcc13'}
    - {jobs: ['test_py_compute_minimal'], project: 'python_tsan', ctk: '13.X', py_version: '3.14t', gpu: 'l4', cxx: 'gcc13'}
    # Deliberately unpinned: py_ctk_mode 'latest' skips the CTK pin so pip
    # resolves the latest minor -- catching breakage a plain `pip install
    # cuda-cccl[cu12]/[cu13]` would hit before the container CTK bumps.
    - {jobs: ['test'], project: 'python', ctk: ['12.X', '13.X'], py_version: '3.14', gpu: 'l4', cxx: ['gcc13', 'msvc2022'], py_ctk_mode: 'latest'}
    # sysctk: install the sysctk extras (system-provided CTK, no pip cuda-toolkit)
    # rather than cu*.
    # Test sysctk and minimal-sysctk extras
    - {jobs: ['test'], project: 'python', ctk: ['12.0', '12.X', '13.0', '13.X'], py_version: '3.14t', gpu: 'l4', cxx: ['gcc13', 'msvc2022'], py_ctk_mode: 'sysctk'}
    - {jobs: ['test_py_compute_minimal'], project: 'python', ctk: ['12.0', '12.X', '13.0', '13.X'], py_version: '3.14t', gpu: 'l4', cxx: ['gcc13', 'msvc2022'], py_ctk_mode: 'sysctk'}
    # cuda.cccl.headers: CPU-only (gpu:false), arch-insensitive
    - {jobs: ['test_headers'], project: 'python', ctk: ['12.X', '13.X'], py_version: '3.14', cxx: ['gcc13', 'msvc2022'], py_ctk_mode: ['pinned', 'latest', 'sysctk']}
    # cuda.coop: installed-wheel host contracts, GPU-free compilation, one
    # representative runtime lane, and Windows universal-wheel endpoints.
    - {jobs: ['test_py_coop_host'], project: 'cuda_coop_python', ctk: '13.X', py_version: ['3.10', '3.14'], cxx: 'gcc13'}
    - {jobs: ['test_py_coop_numba_mlir_compile'], project: 'cuda_coop_python', ctk: '13.X', py_version: '3.14', cxx: 'gcc13'}
    - {jobs: ['test_py_coop_numba_mlir_runtime'], project: 'cuda_coop_python', ctk: '13.X', py_version: '3.14', gpu: 'l4', cxx: 'gcc13'}
    - {jobs: ['build'], project: 'cuda_coop_python', ctk: '13.X', py_version: ['3.10', '3.14'], cxx: 'msvc2022'}
    # CCCL packaging:
    - {jobs: ['test'], project: 'packaging', ctk: '12.0', cxx: ['gcc10', 'clang14'], gpu: 't4', args: '-min-cmake'}
    - {jobs: ['test'], project: 'packaging', ctk: '12.X', cxx: ['gcc10', 'clang14'], gpu: 't4'}
    - {jobs: ['test'], project: 'packaging', ctk: '13.0', cxx: ['gcc15', 'clang20'], gpu: 't4', args: '-min-cmake'}
    - {jobs: ['test'], project: 'packaging', ctk: '13.X', cxx: ['gcc',   'clang'],   gpu: 't4'}
    - {jobs: ['install'], project: 'packaging'}
    # NVBench Helper testing:
    - {jobs: ['test'], project: 'nvbench_helper', ctk: ['12.0', '12.X'], cxx: ['gcc10', 'clang14'], gpu: 't4'}
    - {jobs: ['test'], project: 'nvbench_helper', ctk: '13.0', cxx: ['gcc15', 'clang20'], gpu: 't4'}
    - {jobs: ['test'], project: 'nvbench_helper', ctk: '13.X', cxx: ['gcc',   'clang'],   gpu: 't4'}
    # NVHPC build
    - {jobs: ['build'], cxx: 'nvhpc', ctk: 'nvhpc', std: 'max', project: ['libcudacxx', 'thrust', 'stdpar'], cpu: 'amd64'}
    - {jobs: ['build_nolid'], cxx: 'nvhpc', ctk: 'nvhpc', std: 'max', project: 'cub', cpu: 'amd64'}
    # clang-cuda
    - {jobs: ['build'],                     project: ['libcudacxx', 'thrust'], cudacxx: 'clang', ctk: 'clang-cuda', cxx: 'clang-cuda',  std: 'all', sm: '75;80;90;100;120'}
    - {jobs: ['build_nolid', 'build_lid0'], project: 'cub',                   cudacxx: 'clang', ctk: 'clang-cuda', cxx: 'clang-cuda',  std: 'all', sm: '75;80;90;100;120'}
    - {jobs: ['build'], project: 'libcudacxx', cudacxx: 'clang', ctk: 'clang-cuda', cxx: 'clang-cuda',  std: 23, sm: '75;80;90;100;120'}
    # libc++
    # - arm64 for now as it's closest to android.
    # - {jobs: ['build'], cpu: 'arm64', project: 'libcudacxx', std: 'all', cudacxx: 'clang', ctk: 'clang-cuda', cxx: 'clang-cuda', cmake_options: '-DCCCL_USE_LIBCXX=ON', sm: '75;80;90;100;120'}
    # clang-tidy
    #
    # The precise value of sm is not important, but it is required for cmake to identify
    # clang as a CUDA compiler (see
    # https://discourse.cmake.org/t/cmake-cuda-clang-fails/8657/5).
    #
    # Standard being exactly "min" is required. clang-tidy may emit additional diagnostics
    # for later C++ versions (for example, warning that you should use designated
    # initializers in C++20 or higher).
    - { jobs: ['build'], project: 'tidy', std: 'min', cxx: ['clang_preview-cuda'], cudacxx: ['clang'], ctk: 'clang_preview-cuda', sm: '75' }

  # Used when an upstream project changes to reduce time spent smoke testing dependencies.
  pull_request_lite:
    # libcudacxx - Specialized, testing default SM
    - {project: 'libcudacxx', jobs: ['test'],  std: 'max', cxx: ['gcc', 'msvc'], gpu: 't4', sm: 'gpu'}
    - {project: 'libcudacxx', jobs: ['build'], std: 'max', cxx: 'clang'}
    - {project: 'libcudacxx', jobs: ['build'], std: 'max', ctk: 'nvhpc', cxx: 'nvhpc'}
    - {project: 'libcudacxx', jobs: ['build'], std: 'max', cudacxx: 'clang', ctk: 'clang-cuda', cxx: 'clang-cuda', sm: '70;80;90;100;120'}
    - {project: 'libcudacxx', jobs: ['nvrtc'], std: 'max', gpu: 't4', sm: 'gpu'}
    - {project: 'libcudacxx', jobs: ['verify_codegen']}
    # CUB - Specialized, testing default SM
    - {project: 'cub', jobs: ['test_nolid', 'test_lid0'], std: 'max', cxx: ['gcc', 'msvc'], gpu: 'rtxa6000', sm: 'gpu'}
    - {project: 'cub', jobs: ['build_nolid', 'build_lid0'], std: 'max', cxx: 'clang'}
    - {project: 'cub', jobs: ['build_nolid', 'build_lid0'], std: 'max', ctk: 'nvhpc', cxx: 'nvhpc'}
    - {project: 'cub', jobs: ['build_nolid', 'build_lid0'], std: 'max', cudacxx: 'clang', ctk: 'clang-cuda', cxx: 'clang-cuda', sm: '75;80;90;100;120'}
    # Thrust - Keep number of sm small. Kernel coverage is in CUB. This just tests dispatch / glue in lite mode:
    - {project: 'thrust', jobs: ['test'], std: 'max', cxx: ['gcc', 'msvc'], gpu: 'rtx4090', sm: 'gpu'}
    - {project: 'thrust', jobs: ['build'], std: 'max', cxx: 'clang', sm: '75;120'}
    - {project: 'thrust', jobs: ['build'], std: 'max', ctk: 'nvhpc', cxx: 'nvhpc', sm: '75;120'}
    - {project: 'thrust', jobs: ['build'], std: 'max', cudacxx: 'clang', ctk: 'clang-cuda', cxx: 'clang-cuda', sm: '75;120'}
    # cudax
    - {project: 'cudax', jobs: ['test'], std: 'max', cxx: ['gcc', 'msvc'], gpu: 't4', sm: 'gpu'}
    - {project: 'cudax', jobs: ['build'], std: 'max', cxx: 'clang', sm: '75;120'}
    - {project: 'cudax', jobs: ['build'], std: 'max', ctk: 'nvhpc', cxx: 'nvhpc', sm: '75;120'}
    # CTK '13.X' build with tile support: default projects
    - {jobs: ['build'], project: ['libcudacxx', 'thrust', cudax], ctk: '13.X', std: 'all', cxx: ['gcc', 'clang', 'msvc'], args: '-enable-tile'}
    - {jobs: ['build'], project: 'cub',                           ctk: '13.X', std: 17,    cxx: ['gcc', 'clang', 'msvc'], args: '-enable-tile'}
    # stdpar
    - {project: 'stdpar', jobs: ['build'], std: 'max', ctk: 'nvhpc', cxx: 'nvhpc'}
    # Python + support
    - {project: 'cccl_c_parallel', jobs: ['test'], ctk: '13.X', cxx: ['gcc13', 'msvc2022'], gpu: 't4', sm: 'gpu'}
    - {project: 'cccl_c_parallel', jobs: ['test'], ctk: '13.X', cxx: 'gcc13', gpu: 'rtxpro6000', sm: 'gpu'}
    - {project: 'cccl_c_stf',      jobs: ['test'], ctk: '13.X', cxx: 'gcc13',               gpu: 't4', sm: 'gpu'}
    - {project: 'python', jobs: ['test'], ctk: '13.X', py_version: '3.14', gpu: 'l4', cxx: ['gcc13', 'msvc2022']}
    - {project: 'python', jobs: ['test_headers'], ctk: '13.X', py_version: '3.14', cxx: ['gcc13', 'msvc2022']}
    - {project: 'python', jobs: ['test_py_stf'], ctk: '13.X', py_version: '3.14', gpu: 'l4', cxx: 'gcc13'}
    # Test the installed `cuda-coop` wheel when its dependencies change.
    - {project: 'cuda_coop_python', jobs: ['test_py_coop_host'], ctk: '13.X', py_version: '3.14', cxx: 'gcc13'}
    - {project: 'cuda_coop_python', jobs: ['test_py_coop_numba_mlir_compile'], ctk: '13.X', py_version: '3.14', cxx: 'gcc13'}
    - {project: 'cuda_coop_python', jobs: ['test_py_coop_numba_mlir_runtime'], ctk: '13.X', py_version: '3.14', gpu: 'l4', cxx: 'gcc13'}
    # Packaging / install
    - {project: 'packaging', jobs: ['test'], ctk: '13.X', cxx: ['gcc', 'clang'], gpu: 't4', sm: 'gpu'}
    - {project: 'packaging', jobs: ['test'], args: '-min-cmake', gpu: 't4', sm: 'gpu'}
    - {project: 'packaging', jobs: ['install']}
    # NVBench Helper testing:
    - {project: 'nvbench_helper', jobs: ['test'], ctk: '13.X', cxx: ['gcc', 'clang'], gpu: 't4'}
    # c.parallel v2 (HostJIT-based).
    - {jobs: ['test'], project: 'cccl_c_parallel_v2', ctk: '13.X', cxx: 'gcc13', gpu: 't4'}
    - {jobs: ['test'], project: 'cccl_c_parallel_v2', ctk: '13.X', cxx: 'msvc', gpu: 'l4'}
    # Python against c.parallel v2 (HostJIT-based)
    - {jobs: ['test'], project: 'python_v2', ctk: '13.X', py_version: '3.14', gpu: 'l4', cxx: 'gcc13'}

  nightly:
    # CTK 12.0 full matrix build: default projects
    - {jobs: ['build'], std: 'all', ctk: '12.0', cxx: ['gcc7', 'gcc8', 'gcc9', 'gcc10', 'gcc11', 'gcc12']}
    - {jobs: ['build'], std: 'all', ctk: '12.0', cxx: ['clang14']}
    - {jobs: ['build'], std: 'all', ctk: '12.0', cxx: ['msvc2019', 'msvc14.39']}
    # CTK 12.X full matrix build: default projects
    - {jobs: ['build'], std: 'all', ctk: '12.X', cxx: ['gcc7', 'gcc8', 'gcc9', 'gcc10', 'gcc11', 'gcc12', 'gcc13', 'gcc14']}
    - {jobs: ['build'], std: 'all', ctk: '12.X', cxx: ['clang14', 'clang15', 'clang16', 'clang17', 'clang18', 'clang19']}
    - {jobs: ['build'], std: 'all', ctk: '12.X', cxx: ['msvc2019', 'msvc2022']}
    # CTK 13.0 full matrix build: default projects
    - {jobs: ['build'], std: 'all', ctk: '13.0', cxx: ['gcc11', 'gcc12', 'gcc13', 'gcc14', 'gcc15']}
    - {jobs: ['build'], std: 'all', ctk: '13.0', cxx: ['clang15', 'clang16', 'clang17', 'clang18', 'clang19', 'clang20']}
    - {jobs: ['build'], std: 'all', ctk: '13.0', cxx: ['msvc2019', 'msvc2022']}
    # CTK '13.X' full matrix build: default projects
    - {jobs: ['build'], std: 'all', ctk: '13.X', cxx: ['gcc11', 'gcc12', 'gcc13', 'gcc14', 'gcc15', 'gcc16']}
    - {jobs: ['build'], std: 'all', ctk: '13.X', cxx: ['clang15', 'clang16', 'clang17', 'clang18', 'clang19', 'clang20', 'clang21', 'clang22']}
    - {jobs: ['build'], std: 'all', ctk: '13.X', cxx: ['msvc2019', 'msvc2022', 'msvc2026']}
    # CTK '13.X' full matrix build with tile support: default projects
    - {jobs: ['build'], project: ['libcudacxx', 'thrust'], ctk: '13.X', std: 'all', cxx: ['gcc', 'clang', 'msvc'], args: '-enable-tile'}
    - {jobs: ['build'], project: 'cub',                    ctk: '13.X', std: 17,    cxx: ['gcc', 'clang', 'msvc'], args: '-enable-tile'}
    # CTK 12.0 full matrix build: cudax
    - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '12.0', cxx: ['gcc9', 'gcc10', 'gcc11', 'gcc12']}
    - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '12.0', cxx: ['clang14']}
    - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '12.0', cxx: ['msvc14.39']}
    # CTK 12.X full matrix build: cudax
    - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '12.X', cxx: ['gcc9', 'gcc10', 'gcc11', 'gcc12', 'gcc13', 'gcc14']}
    - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '12.X', cxx: ['clang14', 'clang15', 'clang16', 'clang17', 'clang18', 'clang19']}
    - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '12.X', cxx: ['msvc2022']}
    # CTK 13.0 full matrix build: cudax
    - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '13.0', cxx: ['gcc11', 'gcc12', 'gcc13', 'gcc14', 'gcc15']}
    - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '13.0', cxx: ['clang15', 'clang16', 'clang17', 'clang18', 'clang19', 'clang20']}
    - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '13.0', cxx: ['msvc2022']}
    # CTK '13.X' full matrix build: cudax
    - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '13.X', cxx: ['gcc11', 'gcc12', 'gcc13', 'gcc14', 'gcc15', 'gcc16']}
    - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '13.X', cxx: ['clang15', 'clang16', 'clang17', 'clang18', 'clang19', 'clang20', 'clang21', 'clang22']}
    - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '13.X', cxx: ['msvc2022', 'msvc2026']}
    # CTK '13.X' full matrix build with tile support: cudax
    - {jobs: ['build'], project: 'cudax', ctk: '13.X', std: 'all', cxx: ['gcc', 'clang', 'msvc'], args: '-enable-tile'}
    # CTK 12.X testing:
    - {jobs: ['test'], project: 'libcudacxx', ctk: '12.X', std: 'max', cxx: ['gcc14', 'clang19', 'msvc2022'], gpu: 't4'}
    - {jobs: ['test'], project: 'cub',        ctk: '12.X', std: 'max', cxx: ['gcc14', 'clang19', 'msvc2022'], gpu: 'rtxa6000'}
    - {jobs: ['test'], project: 'thrust',     ctk: '12.X', std: 'max', cxx: ['gcc14', 'clang19', 'msvc2022'], gpu: 'rtx4090'}
    - {jobs: ['test'], project: 'cudax',      ctk: '12.X', std: 'max', cxx: ['gcc14', 'clang19', 'msvc2022'], gpu: 'rtx2080'}
    - {jobs: ['test'], project: ['libcudacxx', 'cub', 'thrust', 'cudax'], ctk: '12.X', std: 'max', cxx: 'gcc14', gpu: 'h100' }
    # CTK '13.X' testing:
    - {jobs: ['test'], project: 'libcudacxx', ctk: '13.X', std: 'max', cxx: ['gcc', 'clang', 'msvc'], gpu: 'rtx2080'}
    - {jobs: ['test'], project: 'cub',        ctk: '13.X', std: 'max', cxx: ['gcc', 'clang', 'msvc'], gpu: 'rtxa6000'}
    - {jobs: ['test'], project: 'thrust',     ctk: '13.X', std: 'max', cxx: ['gcc', 'clang', 'msvc'], gpu: 'rtx4090'}
    - {jobs: ['test'], project: 'cudax',      ctk: '13.X', std: 'max', cxx: ['gcc', 'clang', 'msvc'], gpu: ['t4', 'rtx2080']}
    - {jobs: ['test'], project: ['libcudacxx', 'cub', 'thrust', 'cudax'], ctk: '13.X', std: 'max', gpu: 'h100' }
    # CTK '13.X' testing with tile support:
    - {jobs: ['test'], project: 'libcudacxx', ctk: '13.X', std: 20, cxx: ['gcc', 'clang', 'msvc'], gpu: 'rtxa6000', args: '-enable-tile'}
    - {jobs: ['test'], project: 'cub',        ctk: '13.X', std: 17, cxx: ['gcc', 'clang', 'msvc'], gpu: 'h100', args: '-enable-tile'}
    - {jobs: ['test'], project: 'thrust',     ctk: '13.X', std: 20, cxx: ['gcc', 'clang', 'msvc'], gpu: 'rtxpro6000', args: '-enable-tile'}
    - {jobs: ['test'], project: 'cudax',      ctk: '13.X', std: 20, cxx: ['gcc', 'clang', 'msvc'], gpu: 'l4', args: '-enable-tile'}
      # RTX PRO 6000 coverage (limited due to small number of runners):
    - {jobs: ['test_nolid', 'test_lid0'], project: 'cub', std: 'max', cxx: 'gcc', gpu: 'rtxpro6000'}
    # GB300 ARM64 coverage:
    - {jobs: ['test'],      cpu: 'arm64', project: 'libcudacxx', std: '20', cxx: 'gcc', gpu: 'gb300', sm: 'gpu', cmake_options: '-Dlibcudacxx_LIT_PARALLEL_LEVEL=1'}
    - {jobs: ['test_lid0'], cpu: 'arm64', project: 'cub',        std: '20', cxx: 'gcc', gpu: 'gb300', sm: 'gpu'}
    - {jobs: ['test'],      cpu: 'arm64', project: 'libcudacxx', std: 'max', cxx: 'clang', gpu: 'gb300', sm: 'gpu', cmake_options: '-Dlibcudacxx_LIT_PARALLEL_LEVEL=1'}
    - {jobs: ['test_lid0'], cpu: 'arm64', project: 'cub',        std: 'max', cxx: 'clang', gpu: 'gb300', sm: 'gpu'}
    # Misc:
    - {jobs: ['build'], cpu: 'arm64', project: ['libcudacxx', 'cub', 'thrust', 'cudax'], ctk: '12.X', std: 'all', cxx: ['gcc14', 'clang19']}
    - {jobs: ['build'], cpu: 'arm64', project: ['libcudacxx', 'cub', 'thrust', 'cudax'], ctk: '13.X', std: ['17', '20'], cxx: 'gcc'}
    - {jobs: ['build'], cpu: 'arm64', project: ['libcudacxx', 'cub', 'thrust', 'cudax'], ctk: '13.X', std: 'all', cxx: 'clang'}
    - {jobs: ['test_gpu'], project: 'thrust', cmake_options: '-DTHRUST_DISPATCH_TYPE=Force32bit', gpu: 'rtx4090'}
    - {jobs: ['test_gpu'], project: 'thrust', cmake_options: '-DTHRUST_DISPATCH_TYPE=Force64bit', gpu: 'rtx4090'}
    - {jobs: ['limited'], project: 'cub', std: 17, gpu: 'rtx2080'}
    # NVRTC tests don't currently support 12.0:
    - {jobs: ['nvrtc'],          project: 'libcudacxx', ctk: [        '12.X', '13.0', '13.X'], cxx: 'gcc12', std: 'all', gpu: 'rtx2080', sm: 'gpu'}
    - {jobs: ['nvrtc'], project: 'libcudacxx', std: 'all', gpu: 'rtx2080', sm: 'gpu'}
    - {jobs: ['verify_codegen'], project: 'libcudacxx'}
    # libcu++ Codegen FileCheck: nightly covers the GCC and Clang host compilers
    # supported by each CTK. Suite-specific architectures are added separately.
    - {jobs: ['codegen_filecheck'], project: 'libcudacxx', std: 'max', ctk: '12.0', cxx: ['gcc12', 'clang14'], codegen_target: ['atomics-ptx', 'atomics-sass'], sm: [75, 80, 90]}
    - {jobs: ['codegen_filecheck'], project: 'libcudacxx', std: 'max', ctk: '12.X', cxx: ['gcc14', 'clang19'], codegen_target: ['atomics-ptx', 'atomics-sass', 'simd-ptx', 'simd-sass'], sm: [80, 90, 100, 120]}
    - {jobs: ['codegen_filecheck'], project: 'libcudacxx', std: 'max', ctk: '12.X', cxx: ['gcc14', 'clang19'], codegen_target: ['atomics-ptx', 'atomics-sass'], sm: 75}
    - {jobs: ['codegen_filecheck'], project: 'libcudacxx', std: 'max', ctk: '12.X', cxx: ['gcc14', 'clang19'], codegen_target: 'simd-sass', sm: [103, '120f']}
    - {jobs: ['codegen_filecheck'], project: 'libcudacxx', std: 'max', ctk: '13.0', cxx: ['gcc15', 'clang20'], codegen_target: ['atomics-ptx', 'atomics-sass', 'simd-ptx', 'simd-sass'], sm: [80, 90, 100, 120]}
    - {jobs: ['codegen_filecheck'], project: 'libcudacxx', std: 'max', ctk: '13.0', cxx: ['gcc15', 'clang20'], codegen_target: ['atomics-ptx', 'atomics-sass'], sm: 75}
    - {jobs: ['codegen_filecheck'], project: 'libcudacxx', std: 'max', ctk: '13.0', cxx: ['gcc15', 'clang20'], codegen_target: 'simd-sass', sm: [103, '120f']}
    - {jobs: ['codegen_filecheck'], project: 'libcudacxx', std: 'max', cxx: ['gcc', 'clang'], codegen_target: ['atomics-ptx', 'atomics-sass', 'simd-ptx', 'simd-sass'], sm: [80, 90, 100, 120]}
    - {jobs: ['codegen_filecheck'], project: 'libcudacxx', std: 'max', cxx: ['gcc', 'clang'], codegen_target: ['atomics-ptx', 'atomics-sass'], sm: 75}
    - {jobs: ['codegen_filecheck'], project: 'libcudacxx', std: 'max', cxx: ['gcc', 'clang'], codegen_target: 'simd-sass', sm: [103, '120f']}
    # c.parallel -- pinned to gcc13 / msvc2022 to match python
    - {jobs: ['test'],  project: ['cccl_c_parallel'], ctk: '12.X', cxx: ['gcc13', 'msvc2022'], gpu: ['t4']}
    - {jobs: ['test'],  project: ['cccl_c_parallel'], ctk: '13.X', cxx: ['gcc13', 'msvc2022'], gpu: ['rtx2080', 'l4', 'h100']}
    - {jobs: ['test'], project: 'cccl_c_parallel_v2', ctk: '13.X', cxx: ['gcc13', 'msvc'], gpu: 'rtx2080'}
    # RTX PRO 6000 coverage (limited due to small number of runners):
    - {jobs: ['test'], project: 'cccl_c_parallel', ctk: '13.X', cxx: ['gcc13'], gpu: ['rtxpro6000']}
    # c.experimental.stf -- pinned to gcc13 to match python
    - {jobs: ['test'],  project: ['cccl_c_stf'], ctk: '12.X', cxx: 'gcc13', gpu: ['rtx2080']}
    - {jobs: ['test'],  project: ['cccl_c_stf'], ctk: '13.X', cxx: 'gcc13', gpu: ['t4', 'l4', 'h100']}
    # Python -- pinned to gcc13 / msvc2022 on Linux for consistency across CTK images
    - {jobs: ['test'], project: 'python', ctk: ['12.0', '12.X', '13.0', '13.X'], py_version: ['3.10', '3.11', '3.12', '3.13', '3.14', '3.14t'], gpu: 'l4', cxx: ['gcc13', 'msvc2022']}
    - {jobs: ['test'], project: 'python', ctk: ['12.X', '13.X'], py_version: '3.14', gpu: 'h100', cxx: 'gcc13'}
    - {jobs: ['test'], project: 'python', ctk: ['12.X', '13.X'], py_version: '3.14', gpu: ['t4', 'rtxa6000'], cxx: 'gcc13'}
    - {jobs: ['test'], project: 'python', ctk: '13.X', py_version: '3.14', gpu: 'rtxpro6000', cxx: 'gcc13'}
    # cuda.stf._experimental -- pinned to gcc13, Linux only
    - {jobs: ['test_py_stf'], project: 'python', ctk: ['12.X', '13.X'], py_version: ['3.10', '3.14'], gpu: 'l4', cxx: 'gcc13'}
    - {jobs: ['test_py_stf'], project: 'python', ctk: '13.X', py_version: '3.14', gpu: 'h100', cxx: 'gcc13'}
    # Python against c.parallel v2 (HostJIT-based): full 12.0/12.X/13.0/13.X
    # CTK sweep (see #10778), full and minimal extras. Single py_version here
    # -- Python-version breadth is weekly's job (py3.14t); CTK breadth is the
    # interesting axis for v2.
    - {jobs: ['test'], project: 'python_v2', ctk: ['12.0', '12.X', '13.0', '13.X'], py_version: '3.14', gpu: 'l4', cxx: 'gcc13'}
    - {jobs: ['test_py_compute_minimal'], project: 'python_v2', ctk: ['12.0', '12.X', '13.0', '13.X'], py_version: '3.14', gpu: 'l4', cxx: 'gcc13'}
    # Minimal extra, GIL and free-threaded -- wider than the pull_request rows so
    # regressions (e.g. from dependency bumps) surface between PRs. The
    # free-threaded lanes also run the free-threading stress suite and the
    # pytest-run-parallel sweep; the TSan lane runs them under ThreadSanitizer.
    - {jobs: ['test_py_compute_minimal'], project: 'python', ctk: ['12.0', '12.X', '13.0', '13.X'], py_version: ['3.14', '3.14t'], gpu: 'l4', cxx: ['gcc13', 'msvc2022']}
    - {jobs: ['test_py_compute_minimal'], project: 'python_tsan', ctk: '13.X', py_version: '3.14t', gpu: 'l4', cxx: 'gcc13'}
    # sysctk and minimal-sysctk extras
    - {jobs: ['test'], project: 'python', ctk: ['12.0', '12.X', '13.0', '13.X'], py_version: ['3.14', '3.14t'], gpu: 'l4', cxx: ['gcc13', 'msvc2022'], py_ctk_mode: 'sysctk'}
    - {jobs: ['test_py_compute_minimal'], project: 'python', ctk: ['12.0', '12.X', '13.0', '13.X'], py_version: '3.14t', gpu: 'l4', cxx: ['gcc13', 'msvc2022'], py_ctk_mode: 'sysctk'}
    # cuda.cccl.headers (CPU-only): all CTK x source x OS, py endpoints 3.10 + 3.14
    - {jobs: ['test_headers'], project: 'python', ctk: ['12.0', '12.X', '13.0', '13.X'], py_version: ['3.10', '3.14'], cxx: ['gcc13', 'msvc2022'], py_ctk_mode: ['pinned', 'latest', 'sysctk']}
    # cuda.coop: run the older supported CUDA major in `nightly`. The CUDA 13
    # compiler/runtime counterparts run in `pull_request`, while the pure wheel
    # is checked at both Python endpoints on Linux and Windows in both.
    - {jobs: ['test_py_coop_host'], project: 'cuda_coop_python', ctk: '13.X', py_version: ['3.10', '3.14'], cxx: 'gcc13'}
    - {jobs: ['test_py_coop_numba_mlir_compile'], project: 'cuda_coop_python', ctk: '12.X', py_version: '3.14', cxx: 'gcc13'}
    - {jobs: ['test_py_coop_numba_mlir_runtime'], project: 'cuda_coop_python', ctk: '12.X', py_version: '3.14', gpu: 'l4', cxx: 'gcc13'}
    - {jobs: ['build'], project: 'cuda_coop_python', ctk: '13.X', py_version: ['3.10', '3.14'], cxx: 'msvc2022'}
    # CCCL packaging:
    - {jobs: ['test'], project: 'packaging', ctk: '12.0', cxx: ['gcc10', 'clang14'], gpu: 't4', args: '-min-cmake'}
    - {jobs: ['test'], project: 'packaging', ctk: '12.X', cxx: ['gcc10', 'clang14'], gpu: 'rtx2080'}
    - {jobs: ['test'], project: 'packaging', ctk: '13.0', cxx: ['gcc15', 'clang20'], gpu: 't4', args: '-min-cmake'}
    - {jobs: ['test'], project: 'packaging', ctk: '13.X', cxx: ['gcc',   'clang'],   gpu: 'rtx2080'}
    - {jobs: ['install'], project: 'packaging'}
    # NVBench Helper testing:
    - {jobs: ['test'], project: 'nvbench_helper', ctk: '12.0', cxx: ['gcc10', 'clang14'], gpu: 'rtx2080'}
    - {jobs: ['test'], project: 'nvbench_helper', ctk: '12.X', cxx: ['gcc10', 'clang14'], gpu: 't4'}
    - {jobs: ['test'], project: 'nvbench_helper', ctk: '13.0', cxx: ['gcc15', 'clang20'], gpu: 'rtx2080'}
    - {jobs: ['test'], project: 'nvbench_helper', ctk: '13.X', cxx: ['gcc',   'clang'],   gpu: ['t4', 'rtx2080']}
    # NVHPC build
    - {jobs: ['build'], cxx: 'nvhpc-prev', ctk: 'nvhpc-prev', std: 'all', project: ['libcudacxx', 'cub', 'thrust', 'cudax', 'stdpar'], cpu: ['amd64', 'arm64']}
    - {jobs: ['build'], cxx: 'nvhpc',      ctk: 'nvhpc',      std: 'all', project: ['libcudacxx', 'cub', 'thrust', 'cudax', 'stdpar'], cpu: ['amd64', 'arm64']}
    # clang-cuda
    - {jobs: ['build'], cudacxx: 'clang', ctk: 'clang-cuda', cxx: 'clang-cuda', std: 'all', sm: '75;80;90;100;120'}
    - {jobs: ['build'], cudacxx: 'clang', ctk: 'clang_preview-cuda', cxx: 'clang_preview-cuda', std: 'all', sm: '75;80;90;100;120'}
    - {jobs: ['build'], project: 'libcudacxx', cudacxx: 'clang', ctk: 'clang-cuda', cxx: 'clang-cuda',  std: 23, sm: '75;80;90;100;120'}
    - {jobs: ['build'], project: 'libcudacxx', cudacxx: 'clang', ctk: 'clang_preview-cuda', cxx: 'clang_preview-cuda', std: 23, sm: '75;80;90;100;120'}
    # clang-tidy
    - { jobs: ['build'], project: 'tidy', std: 'min', cxx: ['clang_preview-cuda'], cudacxx: ['clang'], ctk: 'clang_preview-cuda', sm: '75' }
    # arch-specific and family-specific arch builds
    - {jobs: ['build'], project: ['libcudacxx', 'cub', 'thrust', 'cudax'], std: 'all', sm: '90a;100a;103a;110a;120a;121a'}
    - {jobs: ['build'], project: ['libcudacxx', 'cub', 'thrust', 'cudax'], std: 'all', sm: '100f;103f;110f;120f;121f'}

  weekly:
    # CTK 12.0 full matrix build: default projects
    - {jobs: ['build'], std: 'all', ctk: '12.0', cxx: ['gcc7', 'gcc8', 'gcc9', 'gcc10', 'gcc11', 'gcc12']}
    - {jobs: ['build'], std: 'all', ctk: '12.0', cxx: ['clang14']}
    - {jobs: ['build'], std: 'all', ctk: '12.0', cxx: ['msvc2019', 'msvc14.39']}
    # CTK 12.X full matrix build: default projects
    - {jobs: ['build'], std: 'all', ctk: '12.X', cxx: ['gcc7', 'gcc8', 'gcc9', 'gcc10', 'gcc11', 'gcc12', 'gcc13', 'gcc14']}
    - {jobs: ['build'], std: 'all', ctk: '12.X', cxx: ['clang14', 'clang15', 'clang16', 'clang17', 'clang18', 'clang19']}
    - {jobs: ['build'], std: 'all', ctk: '12.X', cxx: ['msvc2019', 'msvc2022']}
    # CTK 13.0 full matrix build: default projects
    - {jobs: ['build'], std: 'all', ctk: '13.0', cxx: ['gcc11', 'gcc12', 'gcc13', 'gcc14', 'gcc15']}
    - {jobs: ['build'], std: 'all', ctk: '13.0', cxx: ['clang15', 'clang16', 'clang17', 'clang18', 'clang19', 'clang20']}
    - {jobs: ['build'], std: 'all', ctk: '13.0', cxx: ['msvc2019', 'msvc2022']}
    # CTK '13.X' full matrix build: default projects
    - {jobs: ['build'], std: 'all', ctk: '13.X', cxx: ['gcc11', 'gcc12', 'gcc13', 'gcc14', 'gcc15', 'gcc16']}
    - {jobs: ['build'], std: 'all', ctk: '13.X', cxx: ['clang15', 'clang16', 'clang17', 'clang18', 'clang19', 'clang20', 'clang21', 'clang22']}
    - {jobs: ['build'], std: 'all', ctk: '13.X', cxx: ['msvc2019', 'msvc2022', 'msvc2026']}
    # CTK 12.0 full matrix build: cudax
    - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '12.0', cxx: ['gcc9', 'gcc10', 'gcc11', 'gcc12']}
    - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '12.0', cxx: ['clang14']}
    - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '12.0', cxx: ['msvc14.39']}
    # CTK 12.X full matrix build: cudax
    - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '12.X', cxx: ['gcc9', 'gcc10', 'gcc11', 'gcc12', 'gcc13', 'gcc14']}
    - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '12.X', cxx: ['clang14', 'clang15', 'clang16', 'clang17', 'clang18', 'clang19']}
    - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '12.X', cxx: ['msvc2022']}
    # CTK 13.0 full matrix build: cudax
    - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '13.0', cxx: ['gcc11', 'gcc12', 'gcc13', 'gcc14', 'gcc15']}
    - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '13.0', cxx: ['clang15', 'clang16', 'clang17', 'clang18', 'clang19', 'clang20']}
    - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '13.0', cxx: ['msvc2022']}
    # CTK '13.X' full matrix build: cudax
    - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '13.X', cxx: ['gcc11', 'gcc12', 'gcc13', 'gcc14', 'gcc15', 'gcc16']}
    - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '13.X', cxx: ['clang15', 'clang16', 'clang17', 'clang18', 'clang19', 'clang20', 'clang21', 'clang22']}
    - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '13.X', cxx: ['msvc2022', 'msvc2026']}
    # CTK 12.X testing:
    - {jobs: ['test'], project: 'libcudacxx', ctk: '12.X', std: 'minmax', cxx: ['gcc14', 'clang19', 'msvc2022'], gpu: 'rtx2080'}
    - {jobs: ['test'], project: 'cub',        ctk: '12.X', std: 'minmax', cxx: ['gcc14', 'clang19', 'msvc2022'], gpu: 'rtxa6000'}
    - {jobs: ['test'], project: 'thrust',     ctk: '12.X', std: 'minmax', cxx: ['gcc14', 'clang19', 'msvc2022'], gpu: 'rtx4090'}
    - {jobs: ['test'], project: 'cudax',      ctk: '12.X', std: 'minmax', cxx: ['gcc14', 'clang19', 'msvc2022'], gpu: 't4'}
    - {jobs: ['test'], project: ['libcudacxx', 'cub', 'thrust', 'cudax'], ctk: '12.X', std: 'minmax', cxx: 'gcc14', gpu: 'h100' }
    # CTK '13.X' testing:
    - {jobs: ['test'], project: 'libcudacxx', ctk: '13.X', std: 'minmax', cxx: ['gcc', 'clang', 'msvc'], gpu: 't4'}
    - {jobs: ['test'], project: 'cub',        ctk: '13.X', std: 'minmax', cxx: ['gcc', 'clang', 'msvc'], gpu: 'rtxa6000'}
    - {jobs: ['test'], project: 'thrust',     ctk: '13.X', std: 'minmax', cxx: ['gcc', 'clang', 'msvc'], gpu: 'rtx4090'}
    - {jobs: ['test'], project: 'cudax',      ctk: '13.X', std: 'minmax', cxx: ['gcc', 'clang', 'msvc'], gpu: 'rtx2080'}
    - {jobs: ['test'], project: ['libcudacxx', 'cub', 'thrust', 'cudax'], ctk: '13.X', std: 'minmax', gpu: 'h100' }
    # RTX PRO 6000 coverage (limited due to small number of runners):
    - {jobs: ['test'], project: ['cub', 'thrust'], std: 'max', cxx: 'gcc', gpu: 'rtxpro6000'}
    # Misc:
    - {jobs: ['build'], cpu: 'arm64', project: ['libcudacxx', 'cub', 'thrust', 'cudax'], ctk: '12.X', std: 'all', cxx: ['gcc14', 'clang19']}
    - {jobs: ['build'], cpu: 'arm64', project: ['libcudacxx', 'cub', 'thrust', 'cudax'], ctk: '13.X', std: ['17', '20'], cxx: 'gcc'}
    - {jobs: ['build'], cpu: 'arm64', project: ['libcudacxx', 'cub', 'thrust', 'cudax'], ctk: '13.X', std: 'all', cxx: 'clang'}
    - {jobs: ['test_gpu'], project: 'thrust', cmake_options: '-DTHRUST_DISPATCH_TYPE=Force32bit', gpu: 'rtx4090'}
    - {jobs: ['test_gpu'], project: 'thrust', cmake_options: '-DTHRUST_DISPATCH_TYPE=Force64bit', gpu: 'rtx4090'}
    - {jobs: ['limited'], project: 'cub', std: 17, gpu: 'rtx2080'}
    # sm: all-cccl:
    - {jobs: ['build'], project: ['thrust', 'libcudacxx', 'cudax'], std: 'max', sm: 'all-cccl' }
    - {jobs: ['build_nolid', 'build_lid0'], project: ['cub'], std: 'max', sm: 'all-cccl'}
    # NVRTC tests don't currently support 12.0:
    - {jobs: ['nvrtc'],          project: 'libcudacxx', ctk: [        '12.X', '13.0', '13.X'], cxx: 'gcc12', std: 'all', gpu: 'rtx2080', sm: 'gpu'}
    - {jobs: ['verify_codegen'], project: 'libcudacxx'}
    # libcu++ Codegen FileCheck: weekly covers the GCC and Clang host compilers
    # supported by each CTK. Suite-specific architectures are added separately.
    - {jobs: ['codegen_filecheck'], project: 'libcudacxx', std: 'max', ctk: '12.0', cxx: ['gcc12', 'clang14'], codegen_target: ['atomics-ptx', 'atomics-sass'], sm: [75, 80, 90]}
    - {jobs: ['codegen_filecheck'], project: 'libcudacxx', std: 'max', ctk: '12.X', cxx: ['gcc14', 'clang19'], codegen_target: ['atomics-ptx', 'atomics-sass', 'simd-ptx', 'simd-sass'], sm: [80, 90, 100, 120]}
    - {jobs: ['codegen_filecheck'], project: 'libcudacxx', std: 'max', ctk: '12.X', cxx: ['gcc14', 'clang19'], codegen_target: ['atomics-ptx', 'atomics-sass'], sm: 75}
    - {jobs: ['codegen_filecheck'], project: 'libcudacxx', std: 'max', ctk: '12.X', cxx: ['gcc14', 'clang19'], codegen_target: 'simd-sass', sm: [103, '120f']}
    - {jobs: ['codegen_filecheck'], project: 'libcudacxx', std: 'max', ctk: '13.0', cxx: ['gcc15', 'clang20'], codegen_target: ['atomics-ptx', 'atomics-sass', 'simd-ptx', 'simd-sass'], sm: [80, 90, 100, 120]}
    - {jobs: ['codegen_filecheck'], project: 'libcudacxx', std: 'max', ctk: '13.0', cxx: ['gcc15', 'clang20'], codegen_target: ['atomics-ptx', 'atomics-sass'], sm: 75}
    - {jobs: ['codegen_filecheck'], project: 'libcudacxx', std: 'max', ctk: '13.0', cxx: ['gcc15', 'clang20'], codegen_target: 'simd-sass', sm: [103, '120f']}
    - {jobs: ['codegen_filecheck'], project: 'libcudacxx', std: 'max', cxx: ['gcc', 'clang21'], codegen_target: ['atomics-ptx', 'atomics-sass', 'simd-ptx', 'simd-sass'], sm: [80, 90, 100, 120]}
    - {jobs: ['codegen_filecheck'], project: 'libcudacxx', std: 'max', cxx: ['gcc', 'clang21'], codegen_target: ['atomics-ptx', 'atomics-sass'], sm: 75}
    - {jobs: ['codegen_filecheck'], project: 'libcudacxx', std: 'max', cxx: ['gcc', 'clang21'], codegen_target: 'simd-sass', sm: [103, '120f']}
    # c.parallel -- pinned to gcc13 / msvc2022 to match python
    - {jobs: ['test'],  project: ['cccl_c_parallel'], ctk: '12.X', cxx: ['gcc13', 'msvc2022'], gpu: ['t4']}
    - {jobs: ['test'],  project: ['cccl_c_parallel'], ctk: '13.X', cxx: ['gcc13', 'msvc2022'], gpu: ['rtx2080', 'l4', 'h100']}
    # RTX PRO 6000 coverage (limited due to small number of runners):
    - {jobs: ['test'], project: 'cccl_c_parallel', ctk: '13.X', cxx: ['gcc13'], gpu: ['rtxpro6000']}
    # Python against c.parallel v2 (HostJIT-based): full 12.0/12.X/13.0/13.X
    # CTK sweep (see #10778), full and minimal extras. py3.14t here
    # complements nightly's py3.14, so both get swept weekly without
    # doubling either workflow's job count.
    - {jobs: ['test'], project: 'python_v2', ctk: ['12.0', '12.X', '13.0', '13.X'], py_version: '3.14t', gpu: 'l4', cxx: 'gcc13'}
    - {jobs: ['test_py_compute_minimal'], project: 'python_v2', ctk: ['12.0', '12.X', '13.0', '13.X'], py_version: '3.14t', gpu: 'l4', cxx: 'gcc13'}
    # c.experimental.stf -- pinned to gcc13 to match python
    - {jobs: ['test'],  project: ['cccl_c_stf'], ctk: '12.X', cxx: 'gcc13', gpu: ['rtx2080']}
    - {jobs: ['test'],  project: ['cccl_c_stf'], ctk: '13.X', cxx: 'gcc13', gpu: ['t4', 'l4', 'h100']}
    # Python -- pinned to gcc13 / msvc2022 for consistency across CTK images
    - {jobs: ['test'], project: 'python', ctk: ['12.0', '12.X', '13.0', '13.X'], py_version: ['3.10', '3.11', '3.12', '3.13', '3.14', '3.14t'], gpu: 'l4', cxx: ['gcc13', 'msvc2022']}
    - {jobs: ['test'], project: 'python', ctk: ['12.X', '13.X'], py_version: '3.14', gpu: 'h100', cxx: ['gcc13', 'msvc2022']}
    - {jobs: ['test'], project: 'python', ctk: ['12.0', '12.X', '13.0', '13.X'], py_version: ['3.10', '3.14'], gpu: 't4', cxx: 'gcc13'}
    - {jobs: ['test'], project: 'python', ctk: ['12.0', '12.X', '13.0', '13.X'], py_version: '3.14', gpu: 'rtxa6000', cxx: 'gcc13'}
    - {jobs: ['test'], project: 'python', ctk: '13.X', py_version: '3.14', gpu: 'rtxpro6000', cxx: 'gcc13'}
    # cuda.stf._experimental -- pinned to gcc13, Linux only
    - {jobs: ['test_py_stf'], project: 'python', ctk: ['12.X', '13.X'], py_version: ['3.10', '3.14'], gpu: 'l4', cxx: 'gcc13'}
    - {jobs: ['test_py_stf'], project: 'python', ctk: '13.X', py_version: '3.14', gpu: 'h100', cxx: 'gcc13'}
    - {jobs: ['test'], project: 'python', ctk: ['12.0', '12.X', '13.0', '13.X'], py_version: ['3.14', '3.14t'], gpu: 'l4', cxx: ['gcc13', 'msvc2022'], py_ctk_mode: 'sysctk'}
    - {jobs: ['test_py_compute_minimal'], project: 'python', ctk: ['12.0', '12.X', '13.0', '13.X'], py_version: '3.14t', gpu: 'l4', cxx: ['gcc13', 'msvc2022'], py_ctk_mode: 'sysctk'}
    # cuda.cccl.headers (CPU-only): all CTK x source x OS, py endpoints 3.10 + 3.14
    - {jobs: ['test_headers'], project: 'python', ctk: ['12.0', '12.X', '13.0', '13.X'], py_version: ['3.10', '3.14'], cxx: ['gcc13', 'msvc2022'], py_ctk_mode: ['pinned', 'latest', 'sysctk']}
    # CCCL packaging:
    - {jobs: ['test'], project: 'packaging', ctk: '12.0', cxx: ['gcc10', 'clang14'], gpu: 't4', args: '-min-cmake'}
    - {jobs: ['test'], project: 'packaging', ctk: '12.X', cxx: ['gcc10', 'clang14'], gpu: 'rtx2080'}
    - {jobs: ['test'], project: 'packaging', ctk: '13.0', cxx: ['gcc15', 'clang20'],   gpu: 't4', args: '-min-cmake'}
    - {jobs: ['test'], project: 'packaging', ctk: '13.X', cxx: ['gcc',   'clang'],   gpu: 'rtx2080'}
    - {jobs: ['install'], project: 'packaging'}
    # NVBench Helper:
    - {jobs: ['test'], project: 'nvbench_helper', ctk: '12.0', cxx: ['gcc10', 'clang14'], gpu: 'rtx2080'}
    - {jobs: ['test'], project: 'nvbench_helper', ctk: '12.X', cxx: ['gcc10', 'clang14'], gpu: 't4'}
    - {jobs: ['test'], project: 'nvbench_helper', ctk: '13.0', cxx: ['gcc15', 'clang20'], gpu: 'rtx2080'}
    - {jobs: ['test'], project: 'nvbench_helper', ctk: '13.X', cxx: ['gcc',   'clang'],   gpu: 't4'}
    # NVHPC build
    - {jobs: ['build'], cxx: 'nvhpc-prev', ctk: 'nvhpc-prev', std: 'all', project: ['libcudacxx', 'cub', 'thrust', 'cudax', 'stdpar'], cpu: ['amd64', 'arm64']}
    - {jobs: ['build'], cxx: 'nvhpc',      ctk: 'nvhpc',      std: 'all', project: ['libcudacxx', 'cub', 'thrust', 'cudax', 'stdpar'], cpu: ['amd64', 'arm64']}
    # clang-cuda
    - {jobs: ['build'], cudacxx: 'clang', ctk: 'clang-cuda', cxx: 'clang-cuda', std: 'all', sm: '75;80;90;100;120'}
    - {jobs: ['build'], cudacxx: 'clang', ctk: 'clang_preview-cuda', cxx: 'clang_preview-cuda', std: 'all', sm: '75;80;90;100;120'}
    - {jobs: ['build'], project: 'libcudacxx', cudacxx: 'clang', ctk: 'clang-cuda', cxx: 'clang-cuda',  std: 23, sm: '75;80;90;100;120'}
    - {jobs: ['build'], project: 'libcudacxx', cudacxx: 'clang', ctk: 'clang_preview-cuda', cxx: 'clang_preview-cuda', std: 23, sm: '75;80;90;100;120'}
    # compute-sanitizer
    - {jobs: ['compute_sanitizer'], project: 'cub', std: 'max', gpu: 'rtxa6000', sm: 'gpu', cmake_options: '-DCMAKE_CUDA_FLAGS=-lineinfo'}
    # clang-tidy
    - { jobs: ['build'], project: 'tidy', std: 'min', cxx: ['clang_preview-cuda'], cudacxx: ['clang'], ctk: 'clang_preview-cuda', sm: '75' }
    # arch-specific and family-specific arch builds
    - {jobs: ['build'], project: ['libcudacxx', 'cub', 'thrust', 'cudax'], std: 'all', sm: '90a;100a;103a;110a;120a;121a'}
    - {jobs: ['build'], project: ['libcudacxx', 'cub', 'thrust', 'cudax'], std: 'all', sm: '100f;103f;110f;120f;121f'}

  python-wheels:
    # NOTE: release-wheels.yml harvests every 'wheel-*' artifact of a run of
    # this workflow and publishes it to PyPI. cuda.stf._experimental jobs are
    # deliberately absent (like the TSan lanes below): the experimental
    # cuda-stf wheel must not be published, and the combined STF producer's
    # cuda_cccl wheel would collide with the release one in dist/. STF
    # coverage lives in the pull_request/nightly/weekly workflows. cuda.coop
    # is also absent until cuda-coop has a registered release target.
    - {jobs: ['test'], project: 'python', ctk: ['12.0', '12.X', '13.0', '13.X'], py_version: ['3.10', '3.11', '3.12', '3.13', '3.14', '3.14t'], gpu: 'l4', cxx: ['gcc13', 'msvc2022']}
    - {jobs: ['test'], project: 'python', ctk: ['12.X', '13.X'], py_version: '3.14', gpu: 'h100', cxx: ['gcc13', 'msvc2022']}
    - {jobs: ['test'], project: 'python', cpu: 'arm64', ctk: ['12.X', '13.X'], py_version: ['3.10', '3.11', '3.12', '3.13', '3.14', '3.14t'], gpu: 'l4', cxx: 'gcc13'}

  # This is just used to ensure that we generate devcontainers for all images we build.
  # These do not map to any actual jobs.
  devcontainers:
    - {jobs: ['dc'],     ctk: ['12.0', '12.X'                ], cxx: ['clang14']}
    - {jobs: ['dc'],     ctk: ['12.0', '12.X'                ], cxx: ['gcc7', 'gcc8', 'gcc9', 'gcc10']}
    - {jobs: ['dc'],     ctk: ['12.0', '12.X', '13.0', '13.X'], cxx: ['gcc11', 'gcc12']}
    - {jobs: ['dc'],     ctk: [        '12.X', '13.0', '13.X'], cxx: ['gcc13', 'gcc14']}
    - {jobs: ['dc'],     ctk: [                '13.0', '13.X'], cxx: ['gcc15']}
    - {jobs: ['dc'],     ctk: [        '12.X', '13.0', '13.X'], cxx: ['clang15', 'clang16', 'clang17', 'clang18', 'clang19']}
    - {jobs: ['dc'],     ctk: [                        '13.X'], cxx: ['gcc16', 'clang22']}
    - {jobs: ['dc_ext'], ctk: [        '12.X', '13.0', '13.X'], cxx: ['gcc14', 'clang20']}
    # Clang21+CTK12.9 is currently only used for cuda-clang testing. nvcc 12.9 doesn't support clang21.
    - {jobs: ['dc_ext'], ctk: [        '12.X',         '13.X'], cxx: ['clang21']}
    - {jobs: ['dc_ext'], ctk: [                        '13.X'], cxx: ['gcc15']}
    # Clang22+CTK12.9 is currently only used for clang-cuda testing. nvcc 12.9 doesn't support clang22.
    - {jobs: ['dc_ext'], ctk: [        '12.X'                ], cxx: ['clang_preview22']}
    # 12.0 python image, pinned at gcc13 for simplicity. CTK 12.0 doesn't really play nice with gcc13, but
    # that doesn't matter for running python tests.
    - {jobs: ['dc'], ctk: ['12.0'], cxx: 'gcc13'}
    # NVHPC
    - {jobs: ['dc'], cxx: 'nvhpc-prev', ctk: 'nvhpc-prev'}
    - {jobs: ['dc'], cxx: 'nvhpc',      ctk: 'nvhpc'}

  # Any generated jobs that match the entries in `exclude` will be removed from the final matrix for all workflows.
  exclude:
    # GPU runners are not available on Windows.
    - {jobs: ['test', 'test_gpu', 'test_nolid', 'test_lid0', 'test_lid1', 'test_lid2'], cxx: ['msvc2019', 'msvc14.39', 'msvc2022', 'msvc2026']}
    # cuda.stf._experimental is Linux-only.
    - {jobs: ['test_py_stf'], cxx: ['msvc2019', 'msvc14.39', 'msvc2022', 'msvc2026']}
    # cudax doesn't support C++17 on msvc:
    - {project: 'cudax', std: 17, cxx: ['msvc2019', 'msvc14.39', 'msvc2022', 'msvc2026']}


#############################################################################################


# The version of the devcontainer images to use from https://hub.docker.com/r/rapidsai/devcontainers
devcontainer_version: '26.12'

# Devcontainer image configuration.
#
# devcontainer_image:
#   The image repo (registry/organization/name) used as the prefix for all
#   generated devcontainer image references. Override this to point at an
#   internal or alternative registry.
#   Default: 'rapidsai/devcontainers'
#
# devcontainer_image_includes_version:
#   When true, the devcontainer_version is prepended to the image tag
#   (e.g. 'rapidsai/devcontainers:26.10-cpp-gcc14-cuda12.9').
#   When false, the version is omitted
#   (e.g. 'rapidsai/devcontainers:cpp-gcc14-cuda12.9').
#   Default: true
devcontainer_image: 'rapidsai/devcontainers'
devcontainer_image_includes_version: true

# Runner label templates.
#
# These templates control how GitHub Actions runner labels are generated for
# CPU-only and GPU jobs. They support {placeholder} substitution.
#
# CPU template variables:
#   {os}   - 'linux' or 'windows'
#   {cpu}  - 'amd64' or 'arm64'
#
# GPU template variables (in addition to the CPU variables):
#   {gpu_id}      - The GPU identifier (the key in `gpus`, or `runner_id` if set)
#   {gpu_runner}  - The base runner name from the `gpus` map (e.g. 't4-latest')
#   {gpu_count}   - Number of GPUs on the runner (e.g. 1 or 2). Authoritative for
#                   the count suffix in the default template.
#   {gpu_name}    - The GPU display name (e.g. 'T4', 'H100 2-GPU')
#   {gpu_testing} - '-testing' if the GPU is in a testing pool, '' otherwise
#
# Default cpu: '{os}-{cpu}-cpu16'
# Default gpu: '{os}-{cpu}-gpu-{gpu_runner}-{gpu_count}{gpu_testing}'
runner_labels:
  cpu: '{os}-{cpu}-cpu16'
  gpu: '{os}-{cpu}-gpu-{gpu_runner}-{gpu_count}{gpu_testing}'

# Compiler versions used for the cuda99.X internal builds:
cuda99_gcc_version: 15
cuda99_clang_version: 21

# All supported C++ standards:
all_stds: [17, 20, 23]

# Aliases:
# - 12.X: Newest CTK 12.X version.
# - 13.X: Newest CTK 13.X version.
# - nvhpc: CTK shipped in newest NVHPC
# - nvhpc-prev: CTK shipped in previous NVHPC
# - pybuild: Selects image to use for python wheel builds' outer docker instance
ctk_versions:
  '12.0': { stds: [17, 20] }
  '12.9': { stds: [17, 20], alias: ['12.X', 'pybuild', 'clang-cuda', 'clang_preview-cuda'] }
  '13.0': { stds: [17, 20] }
  '13.2': { stds: [17, 20], alias: ['nvhpc-prev']}
  '13.3': { stds: [17, 20, 23], alias: ['nvhpc']}
  '13.4': { stds: [17, 20, 23], alias: ['13.X'] }

device_compilers:
  nvcc: # Version / stds are taken from CTK
    name: 'nvcc'
    exe: 'nvcc'
  clang: # Requires cxx=clang. Version / stds are taken from cxx compiler.
    name: "ClangCUDA"
    exe: 'clang++'

host_compilers:
  gcc:
    name: 'GCC'
    container_tag: 'gcc'
    exe: 'g++'
    versions:
      7:  { stds: [17,   ] }
      8:  { stds: [17,   ] }
      9:  { stds: [17,   ] }
      10: { stds: [17, 20] }
      11: { stds: [17, 20] }
      12: { stds: [17, 20] }
      13: { stds: [17, 20] }
      14: { stds: [17, 20, 23] }
      15: { stds: [17, 20, 23] }
      16: { stds: [17, 20, 23] }
  clang:
    name: 'Clang'
    container_tag: 'llvm'
    exe: 'clang++'
    versions:
      14: { stds: [17, 20] }
      15: { stds: [17, 20] }
      16: { stds: [17, 20] }
      17: { stds: [17, 20] }
      18: { stds: [17, 20, 23] }
      19: { stds: [17, 20, 23] }
      20: { stds: [17, 20, 23] }
      21: { stds: [17, 20, 23], alias: 'cuda' }
      22: { stds: [17, 20, 23] }
  clang_preview:
    name: 'Clang'
    container_tag: 'llvm'
    exe: 'clang++'
    versions:
      22: { stds: [17, 20, 23], alias: 'cuda' }
  msvc:
    name: 'MSVC'
    container_tag: 'cl'
    exe: cl
    versions:
      '14.29': { stds: [17,   ], alias: '2019' }
      '14.39': { stds: [17, 20] } # CTK 12.0 doesn't recognize >14.39 as MSVC 2022.
      '14.44': { stds: [17, 20], alias: '2022' }
      '14.50': { stds: [17, 20], alias: '2026' }

  nvhpc:
    name: 'NVHPC'
    container_tag: 'nvhpc'
    exe: nvc++
    versions:
      # !! Update the ctk_versions 'nvhpc*' aliases when updating NVHPC versions:
      # nvc++ is not supported by nvcc in c++23 mode (as of CTK 13.4)
      26.5: { stds: [17, 20], alias: 'prev' }
      26.9: { stds: [17, 20] }

# Jobs support the following properties:
#
# - name: The human-readable name of the job. Default is the capitalized job key.
# - needs:
#   - A list of jobs that must be completed before this job can run. Default is an empty list.
#   - These jobs are automatically added if needed:
#     - Eg. "jobs: ['test']" in the workflow def will also create the required 'build' jobs.
# - gpu: Whether the job requires a GPU runner. Default is false.
# - ext: Devcontainer extensions [cuda, tidy]. Defaults to the project's ext; [] disables extensions.
# - invoke:
#   - Map the job type to the script invocation spec:
#     - prefix: The script invocation prefix. Default is the job name.
#     - args: Additional arguments to pass to the script. Default is no args.
#   - The script is invoked either:
#     linux:   `ci/windows/<spec[prefix]>_<project>.ps1 <spec[args]>`
#     windows: `ci/<spec[prefix]>_<project>.sh <spec[args]>`
# - force_producer_ctk:
#   - If set, force the auto-generated producers for this job to use a specific CTK version.
#   - By default, the autogenerated job's CTK version is determined by the consumer's `ctk` tag.
#   - This is useful for testing the cross-testing major version compat.
#   - E.g. "force_producer_ctk: '12.0'" on a test step will force the generated build step to use CTK 12.0.

jobs:
  # General:
  build:        { gpu: false }
  test:         { gpu: true, needs: 'build' }
  install:      { gpu: false }

  test_nobuild: { gpu: true, name: 'Test', invoke: { prefix: 'test' } }

  compute_sanitizer: { gpu: true, name: 'ComputeSanitizer', needs: 'build', invoke: { prefix: 'test', args: '-compute-sanitizer' } }

  # libcudacxx:
  nvrtc: { gpu: true, name: 'NVRTC' }
  verify_codegen: { gpu: false, name: 'VerifyCodegen' }
  codegen_filecheck: { gpu: false, name: 'libcu++ Codegen FileCheck' }

  # CUB:
  build_nolid: { name: 'BuildNoLaunch',     gpu: false, invoke: { prefix: 'build', args: '-no-lid'} }
  build_lid0:  { name: 'BuildHostLaunch',   gpu: false, invoke: { prefix: 'build', args: '-lid0'} }
  build_lid1:  { name: 'BuildDeviceLaunch', gpu: false, invoke: { prefix: 'build', args: '-lid1'} }
  build_lid2:  { name: 'BuildGraphCapture', gpu: false, invoke: { prefix: 'build', args: '-lid2'} }
  # NoLid -> The string `lid_X` doesn't appear in the test name. Mostly warp/block tests, old device tests, and examples.
  test_nolid: { name: 'TestNoLaunch',      gpu: true, needs: 'build_nolid', invoke: { prefix: 'test', args: '-no-lid --test-par 8'} }
  # CUB uses `lid` to indicate launch strategies: whether CUB algorithms are:
  # - launched from the host (lid0):
  test_lid0:  { name: 'HostLaunch',   gpu: true, needs: 'build_lid0', invoke: { prefix: 'test', args: '-lid0 --test-par 8'} }
  # - launched from the device (lid1):
  test_lid1:  { name: 'DeviceLaunch', gpu: true, needs: 'build_lid1', invoke: { prefix: 'test', args: '-lid1 --test-par 8'} }
  # - captured in a CUDA graph for deferred launch (lid2):
  test_lid2:  { name: 'GraphCapture', gpu: true, needs: 'build_lid2', invoke: { prefix: 'test', args: '-lid2 --test-par 8'} }
  # Limited build reduces the number of runtime test cases, available device memory, etc, and may be used
  # to reduce test runtime in limited environments.
  limited:    { name: "SmallGMem",   gpu: true, needs: 'build', invoke: { prefix: 'test', args: '-limited'} }
  # Compute sanitizer jobs:
  compute_mem_nolid:  { name: 'CSMem-TestGPU',       gpu: true, needs: 'build_nolid', invoke: { prefix: 'test', args: '-compute-sanitizer-memcheck  -no-lid'} }
  compute_mem_lid0:   { name: 'CSMem-HostLaunch',    gpu: true, needs: 'build_lid0',  invoke: { prefix: 'test', args: '-compute-sanitizer-memcheck  -lid0'} }
  compute_race_nolid: { name: 'CSRace-TestGPU',      gpu: true, needs: 'build_nolid', invoke: { prefix: 'test', args: '-compute-sanitizer-racecheck -no-lid'} }
  compute_race_lid0:  { name: 'CSRace-HostLaunch',   gpu: true, needs: 'build_lid0',  invoke: { prefix: 'test', args: '-compute-sanitizer-racecheck -lid0'} }
  compute_init_nolid: { name: 'CSInit-TestGPU',      gpu: true, needs: 'build_nolid', invoke: { prefix: 'test', args: '-compute-sanitizer-initcheck -no-lid'} }
  compute_init_lid0:  { name: 'CSInit-HostLaunch',   gpu: true, needs: 'build_lid0',  invoke: { prefix: 'test', args: '-compute-sanitizer-initcheck -lid0'} }
  compute_sync_nolid: { name: 'CSSync-TestGPU',      gpu: true, needs: 'build_nolid', invoke: { prefix: 'test', args: '-compute-sanitizer-synccheck -no-lid'} }
  compute_sync_lid0:  { name: 'CSSync-HostLaunch',   gpu: true, needs: 'build_lid0',  invoke: { prefix: 'test', args: '-compute-sanitizer-synccheck -lid0'} }

  # Thrust:
  test_cpu: { name: 'TestCPU', gpu: false, needs: 'build', invoke: { prefix: 'test', args: '-cpu-only'} }
  test_gpu: { name: 'TestGPU', gpu: true,  needs: 'build', invoke: { prefix: 'test', args: '-gpu-only'} }

  # Python:
  build_py_wheel:   { name: "Build cuda.cccl",             gpu: false, invoke: { prefix: 'build_cuda_cccl'} }
  build_py_stf_wheel: { name: "Build cuda.stf",            gpu: false, invoke: { prefix: 'build_cuda_stf_combined'} }
  test_headers:     { name: "Test cuda.cccl.headers",      gpu: false, needs: 'build_py_wheel', force_producer_ctk: "pybuild", invoke: { prefix: 'test_cuda_cccl_headers'} }
  test_py_par:      { name: "Test cuda.compute",     gpu: true,  needs: 'build_py_wheel', force_producer_ctk: "pybuild", invoke: { prefix: 'test_cuda_compute'} }
  test_py_compute_minimal: { name: "Test cuda.compute minimal", gpu: true, needs: 'build_py_wheel', force_producer_ctk: "pybuild", invoke: { prefix: 'test_cuda_compute_minimal'} }
  test_py_examples: { name: "Test cuda.cccl.examples",     gpu: true,  needs: 'build_py_wheel', force_producer_ctk: "pybuild", invoke: { prefix: 'test_cuda_cccl_examples'} }
  test_py_stf:      { name: "Test cuda.stf._experimental", gpu: true,  needs: 'build_py_stf_wheel', force_producer_ctk: "pybuild", invoke: { prefix: 'test_cuda_stf'} }
  test_py_coop_host: { name: "Test cuda.coop (host)", gpu: false, needs: 'build', force_producer_ctk: "pybuild", invoke: { prefix: 'test', args: '-stage contracts'} }
  test_py_coop_numba_mlir_compile: { name: "Compile cuda.coop Numba-CUDA-MLIR (GPU hidden)", gpu: false, needs: 'build', force_producer_ctk: "pybuild", invoke: { prefix: 'test', args: '-stage numba-mlir-compile'} }
  test_py_coop_numba_mlir_runtime: { name: "Test cuda.coop Numba-CUDA-MLIR (L4)", gpu: true, needs: 'build', force_producer_ctk: "pybuild", invoke: { prefix: 'test', args: '-stage numba-mlir-runtime'} }

  # Run jobs for 'target' project (ci/util/build_and_test_targets.sh):
  run_cpu: { gpu: false }
  run_gpu: { gpu: true  }

  # Only used for generating devcontainers. No scripts actually exist for these:
  dc:     { gpu: false }
  dc_ext: { gpu: false, ext: [cuda] }

codegen_targets:
  atomics-ptx: { name: 'Atomics PTX', cmake_target: 'libcudacxx.test.atomics.ptx' }
  atomics-sass: { name: 'Atomics SASS', cmake_target: 'libcudacxx.test.atomics.sass' }
  simd-ptx: { name: 'SIMD PTX', cmake_target: 'libcudacxx.test.simd.ptx' }
  simd-sass: { name: 'SIMD SASS', cmake_target: 'libcudacxx.test.simd.sass' }

# Projects have the following properties:
#
# Keys are project subdirectories names. These will also be used in script names.
#
# - stds: A list of C++ standards to test. Required.
# - name: The human-readable name of the project. Default is the project key.
# - job_map: Map general jobs to arrays of project-specific jobs.
#            Useful for things like splitting cpu/gpu testing for a project.
#            E.g. "job_map: { test: ['test_cpu', 'test_gpu'] }" replaces
#            the "test" job with distinct "test_cpu" and "test_gpu" jobs.
projects:
  packaging:
    name: 'CCCL Packaging'
    stds: [17, 20, 23]
    job_map:
      build: []
      test: ['test_nobuild']
  libcudacxx:
    name: 'libcu++'
    stds: [17, 20, 23]
  cub:
    name: 'CUB'
    stds: [17, 20, 23]
    job_map:
      build: ['build_nolid', 'build_lid0', 'build_lid1', 'build_lid2']
      test:  ['test_nolid',  'test_lid0',  'test_lid1',  'test_lid2']
      compute_sanitizer:
        - compute_mem_nolid
        - compute_mem_lid0
        - compute_race_nolid
        - compute_race_lid0
        - compute_init_nolid
        - compute_init_lid0
        - compute_sync_nolid
        - compute_sync_lid0
  thrust:
    name: 'Thrust'
    stds: [17, 20, 23]
    job_map: { test: ['test_cpu', 'test_gpu'] }
  cudax:
    stds: [17, 20, 23]
  stdpar:
    name: 'NVHPC stdpar'
    stds: [17, 20, 23]
  python:
    name: "Python"
    job_map:
      build: ['build_py_wheel']
      test:  ['test_py_par', 'test_py_examples']
  python_v2:
    name: "Python (cuda.compute on v2/HostJIT)"
    # Only cuda.compute differs between v1 and v2; cuda.cccl.headers does not
    # need separate coverage. Run the examples because they exercise
    # cuda.compute against the v2 backend.
    job_map:
      build: ['build_py_wheel']
      test:  ['test_py_par', 'test_py_examples']
  python_tsan:
    name: "Python (cuda.compute free-threaded ThreadSanitizer)"
    # Runs per-PR (and nightly). The producer build_py_wheel runs
    # build_cuda_cccl_python_tsan.sh (c.parallel v1 host code built with
    # -fsanitize=thread); test_py_compute_minimal runs
    # test_cuda_compute_minimal_python_tsan.sh (the FT stress + sweep under the
    # TSan runtime). Deliberately absent from the `python-wheels` publish
    # workflow, so these instrumented wheels never reach PyPI.
    job_map:
      build: ['build_py_wheel']
      test:  ['test_py_compute_minimal']
  cuda_coop_python:
    name: "Python (cuda.coop)"
  cccl_c_parallel:
    name: 'CCCL C Parallel'
    stds: [20]
  cccl_c_parallel_v2:
    name: 'CCCL C Parallel v2 (HostJIT)'
    stds: [20]
    # test_cccl_c_parallel_v2.sh builds inline (no separate build script),
    # so suppress the default test→build dependency. test_nobuild invokes
    # test_<project>.sh directly without a producer build job.
    job_map:
      build: []
      test: ['test_nobuild']
  cccl_c_stf:
    name: 'CCCL C CUDASTF'
    stds: [20]
  nvbench_helper:
    name: 'NVBench Helper'
    stds: [17] # Only builds on oldest arch for max compat.
    job_map:
      build: []
      test: ['test_nobuild']

  # Run specific build_and_test_targets.sh invocations across the CI matrix.
  # Use the override workflow and supply arguments via the `args` tag.
  # Example:
  #   override:
  #     - { jobs: ['run'], project: 'target', ctk: ['12.X', '13.X'], cxx: 'gcc', gpu: 't4',
  #         args: '--preset cub-cpp20 --build-targets "cub.cpp20.test.iterator" --ctest-targets "cub.cpp20.test.iterator"' }
  target:
    name: 'Target'
    stds: [17, 20, 23]
  bisect:
    name: 'Bisect'
    stds: [17, 20, 23]
  tidy:
    name: 'clang-tidy'
    stds: [17]
    ext: [tidy]

# name -> Display name for generated job labels.
# runner -> GPU/driver/count segment of the GHA runner label.
# testing -> Runner with GPU is in a nv-gh-runners testing pool.
# gpu_count -> Number of GPUs on the runner. Used by runner label templates and
#              the job-execution actions to decide whether to pass --gpus all.
# runner_id -> Override the GPU identifier used in runner label templates.
#              Defaults to the GPU key. Useful when the key includes a suffix
#              (e.g. 'h100_2gpu') but the runner label should use the base name
#              (e.g. 'h100').
gpus:
  t4:         { name: 'T4',          sm: 75,  runner: 't4-latest',         gpu_count: 1 } # 16 GB,  10 runners
  rtx2080:    { name: 'RTX2080',     sm: 75,  runner: 'rtx2080-latest',    gpu_count: 1 } #  8 GB,  12 runners
  rtxa6000:   { name: 'RTXA6000',    sm: 86,  runner: 'rtxa6000-latest',   gpu_count: 1 } # 48 GB,  12 runners
  l4:         { name: 'L4',          sm: 89,  runner: 'l4-latest',         gpu_count: 1 } # 24 GB,  48 runners
  rtx4090:    { name: 'RTX4090',     sm: 89,  runner: 'rtx4090-latest',    gpu_count: 1 } # 24 GB,  10 runners
  h100:       { name: 'H100',        sm: 90,  runner: 'h100-latest',       gpu_count: 1 } # 80 GB,  16 runners
  h100_2gpu:  { name: 'H100 2-GPU',  sm: 90,  runner: 'h100-latest',       gpu_count: 2, runner_id: 'h100' } # 2 x 80 GB
  gb300:      { name: 'GB300',       sm: 103, runner: 'gb300-latest',      gpu_count: 1 }
  # Very small number of runners on loan from cuda-python while we wait for our order to arrive.
  # Limit jobs on these:
  rtxpro6000: { name: 'RTXPRO6000',  sm: 120, runner: 'rtxpro6000-latest', gpu_count: 1 }

# Tags are used to define a `matrix job` in the workflow section.
#
# Tags have the following options:
#  - required: Whether the tag is required. Default is false.
#  - default: The default value for the tag. Default is null.
tags:
   # An array of jobs (e.g. 'build', 'test', 'nvrtc', 'infra', 'verify_codegen', 'codegen_filecheck', ...)
   # See the `jobs` map.
  jobs: { required: true }
  # FileCheck codegen suite selected by a codegen_filecheck job.
  codegen_target: { required: false }
  # CUDA ToolKit version
  # See the `ctks` map.
  ctk: { default: '13.X' }
  # CPU architecture
  cpu: { default: 'amd64' }
  # GPU model
  gpu: { default: 't4' }
  # Host compiler {name, version, exe}
  # See the `host_compilers` map.
  cxx: { default: 'gcc' }
  # Device compiler.
  # See the `device_compilers` map.
  cudacxx: { default: 'nvcc' }
  # Project name (e.g. libcudacxx, cub, thrust, cccl)
  # See the `projects` map.
  project: { default: ['libcudacxx', 'cub', 'thrust'] }
  # Python version for Python builds/tests
  py_version: { required: false }
  # Python CTK-source mode for test lanes (Python-only):
  #   'pinned' (default) -- pin cuda-toolkit to the container CTK minor
  #   'latest'           -- unpinned; pip resolves the newest minor
  #   'sysctk'           -- use the system toolkit; install the sysctk extras
  # If set, passed to the script with `-ctk-mode <mode>`. Exploded if an array,
  # e.g. `['pinned','sysctk']`.
  py_ctk_mode: { required: false }
  # C++ standard
  # If set to 'all', all stds supported by the ctk/compilers/project are used.
  # If set to 'min', 'max', or 'minmax', the minimum, maximum, or both stds are used.
  # If set, will be passed to script with `-std <std>`.
  std: { required: false }
  # GPU architecture
  # - If set, passed to script with `-arch <sm>`.
  # - Format is the same as `CMAKE_CUDA_ARCHITECTURES`:
  #   - PTX only: 70-virtual
  #   - SASS only: 70-real
  #   - Both: 70
  # - Can pass multiple architectures via "60;70-real;80-virtual"
  # - Defaults to use the settings in the CMakePresets.json file.
  # - Will be exploded if an array, e.g. `sm: ['60;70;80;90', '90a']` creates two jobs.
  # - Set to 'gpu' to only target the GPU in the `gpu` tag.
  sm: { required: false }
  # Additional CMake options to pass to the build.
  # If set, passed to script with `-cmake_options "<cmake_options>"`.
  cmake_options: { required: false }
  # Environment variables to add
  environment: { required: false, default: [] }
  # Additional arguments appended to the generated command.
  # Typically used with the `target` project to forward options to
  # ci/util/build_and_test_targets.sh, but works with all CI jobs.
  args: { required: false, default: "" }