feat: add support for CTK 13 (#410)

* fix: make cuda 13 compile

* feat: add if_cuda_toolkit_version_ge

* fix: address split of culibos

* fix: address cccl subdirectory

* fix: update toolchain configuration for standalone nvvm repo

* fix: add npp uber target which depends on nppc, nppi and npps

* fix: depends on crt after 13

* fix: make cicc_label and libdevice_label optional

* fix: make version attr mandatory for nvcc

Since cuda 13, nvcc deliverable does not contain any header file that
have a version string hardcoded. `repository_ctx.execute` is not for our
case as the binary may not be compatible with the host.

* ci: add cuda 13 in build tests

* test: stop specifying components as it is optional

* fix: make cuda_toolkit_info cicc and libdevice optional for local ctk

* fix: also add CICC_PATH and NVVMIR_LIBRARY_DIR env for nvcc msvc toolchain configuration

* ci: add crt and nvvm starts with ctk 13

* style: format

* ci: disable clang test in ci for ctk 13 due to bug upstream

Author: cloudhan

.github/actions/set-build-env/action.yaml

@@ -68,7 +68,7 @@ runs:
       if: ${{ startsWith(inputs.os, 'windows') }}
       with:
         cuda: ${{ inputs.cuda-version }}
-        sub-packages: '["nvcc", "cudart"]'
+        sub-packages: ${{ (startsWith(inputs.cuda-version, '11') || startsWith(inputs.cuda-version, '12')) && '["nvcc", "cudart"]' || '["nvcc", "cudart", "crt", "nvvm"]' }}
         method: network
     - name: Show bin, include, lib64 (Windows)
       if: ${{ startsWith(inputs.os, 'windows') }}

.github/workflows/build-tests.yaml

@@ -17,6 +17,7 @@ jobs:
         cases:
           - { os: "ubuntu-22.04", cuda-version: "11.7.0", source: "nvidia" }
           - { os: "ubuntu-24.04", cuda-version: "12.6.3", source: "nvidia" }
+          - { os: "ubuntu-24.04", cuda-version: "13.0.2", source: "nvidia" }
           - {
               os: "ubuntu-22.04",
               cuda-version: "11.7.0",
@@ -31,13 +32,21 @@ jobs:
               toolchain: "llvm_host_device", # clang as cuda compiler driver
               toolchain-version: "19",
             }
+          # - {  # FIXME: enable once llvm 22 is released
+          #     os: "ubuntu-24.04",
+          #     cuda-version: "13.0.2",
+          #     source: "nvidia",
+          #     toolchain: "llvm_host_only", # clang as host compiler
+          #     toolchain-version: "21",
+          #   }
           - {
               os: "ubuntu-22.04",
               cuda-version: "11.5.1-1ubuntu1",
               source: "ubuntu",
             }
           - { os: "windows-2022", cuda-version: "11.5.2", source: "nvidia" }
           - { os: "windows-2025", cuda-version: "12.6.3", source: "nvidia" }
+          - { os: "windows-2025", cuda-version: "13.0.2", source: "nvidia" }
     steps:
       - uses: actions/checkout@v5
 

cuda/private/providers.bzl

@@ -107,6 +107,8 @@ CudaToolkitInfo = provider(
         "link_stub": "File to the link.stub file",
         "bin2c": "File to the bin2c executable",
         "fatbinary": "File to the fatbinary executable",
+        "cicc": "File to the cicc executable",
+        "libdevice": "File to the libdevice LLVM bitcode library (libdevice.10.bc)",
     },
 )
 

cuda/private/repositories.bzl

@@ -84,11 +84,26 @@ def _detect_local_cuda_toolkit(repository_ctx):
         link_stub_label = link_stub,
         bin2c_label = bin2c,
         fatbinary_label = fatbinary,
+        cicc_label = None,  # local CTK do not need this
+        libdevice_label = None,  # local CTK do not need this
     )
 
 def _detect_deliverable_cuda_toolkit(repository_ctx):
+    cuda_version_str = repository_ctx.attr.version
+    if cuda_version_str == None or cuda_version_str == "":
+        fail("attr version is required.")
+
+    nvcc_version_str = repository_ctx.attr.nvcc_version
+    if nvcc_version_str == None or nvcc_version_str == "":
+        nvcc_version_str = cuda_version_str
+
+    cuda_version_major, cuda_version_minor = cuda_version_str.split(".")[:2]
+    nvcc_version_major, nvcc_version_minor = nvcc_version_str.split(".")[:2]
+
     # NOTE: component nvcc contains some headers that will be used.
     required_components = ["cccl", "cudart", "nvcc"]
+    if int(cuda_version_major) >= 13:
+        required_components.extend(["crt", "nvvm"])
     for rc in required_components:
         if rc not in repository_ctx.attr.components_mapping:
             fail('component "{}" is required.'.format(rc))
@@ -102,16 +117,12 @@ def _detect_deliverable_cuda_toolkit(repository_ctx):
     bin2c = "{}//:nvcc/bin/bin2c{}".format(nvcc_repo, bin_ext)
     fatbinary = "{}//:nvcc/bin/fatbinary{}".format(nvcc_repo, bin_ext)
 
-    cuda_version_str = repository_ctx.attr.version
-    if cuda_version_str == None or cuda_version_str == "":
-        fail("attr version is required.")
-
-    nvcc_version_str = repository_ctx.attr.nvcc_version
-    if nvcc_version_str == None or nvcc_version_str == "":
-        nvcc_version_str = cuda_version_str
-
-    cuda_version_major, cuda_version_minor = cuda_version_str.split(".")[:2]
-    nvcc_version_major, nvcc_version_minor = nvcc_version_str.split(".")[:2]
+    cicc = None
+    libdevice = None
+    if int(cuda_version_major) >= 13:
+        nvvm_repo = repository_ctx.attr.components_mapping["nvvm"]
+        cicc = "{}//:nvvm/nvvm/bin/cicc{}".format(nvvm_repo, bin_ext)  # TODO: can we use @cuda//:cicc?
+        libdevice = "{}//:nvvm/nvvm/libdevice/libdevice.10.bc".format(nvvm_repo)  # TODO: can we use @cuda//:libdevice?
 
     return struct(
         path = None,  # scattered components
@@ -124,6 +135,8 @@ def _detect_deliverable_cuda_toolkit(repository_ctx):
         link_stub_label = link_stub,
         bin2c_label = bin2c,
         fatbinary_label = fatbinary,
+        cicc_label = cicc,
+        libdevice_label = libdevice,
     )
 
 def detect_cuda_toolkit(repository_ctx):
@@ -188,7 +201,7 @@ def config_cuda_toolkit_and_nvcc(repository_ctx, cuda):
         )
 
     # Generate @cuda//defs.bzl
-    template_helper.generate_defs_bzl(repository_ctx, is_local_ctk == True)
+    template_helper.generate_defs_bzl(repository_ctx, cuda.version_major, cuda.version_minor, is_local_ctk == True)
 
     # Generate @cuda//toolchain/BUILD
     template_helper.generate_toolchain_build(repository_ctx, cuda)
@@ -283,6 +296,44 @@ cuda_toolkit = repository_rule(
     # remotable = True,
 )
 
+def _patch_nvcc_profile_pre(repository_ctx, component_name):
+    """nvcc after 13 needs to adjust nvcc.profile to support distributed components"""
+
+    patch_nvcc_profile = False
+    rename_files = {}
+
+    if component_name != "nvcc":
+        return patch_nvcc_profile, rename_files
+    if getattr(repository_ctx.attr, "version") == None or repository_ctx.attr.version == "":
+        fail("attribute `version` must be filled for 'nvcc' component")
+
+    nvcc_major_version = int(repository_ctx.attr.version.split(".")[0])
+    if nvcc_major_version >= 13:
+        patch_nvcc_profile = True
+
+    if patch_nvcc_profile:
+        nvcc_profile = repository_ctx.attr.strip_prefix + "/bin/nvcc.profile"
+        rename_files[nvcc_profile] = nvcc_profile + ".renamed_by_rules_cuda"
+
+    return patch_nvcc_profile, rename_files
+
+def _patch_nvcc_profile_post(repository_ctx, patch_nvcc_profile):
+    if not patch_nvcc_profile:
+        return
+
+    nvcc_profile_content = repository_ctx.read("nvcc/bin/nvcc.profile.renamed_by_rules_cuda")
+    lines = nvcc_profile_content.split("\n")
+    for i, line in enumerate(lines):
+        key_to_replace = ["CICC_PATH", "NVVMIR_LIBRARY_DIR"]
+        for key in key_to_replace:
+            s = line.find(key)
+            if s == 0 or (s > 0 and line[s-1] != "(" and line[s-1] != "%"):  # ensure it is a env key assignment, not a reference
+                # we will then pass the env from outside to
+                new_line = key + " ?= " + key + "/in/nvcc.profile/replaced/by/rules_cuda/but/not/set/at/runtime"
+                lines[i] = new_line
+    nvcc_profile_content = "\n".join(lines)
+    repository_ctx.file("nvcc/bin/nvcc.profile", nvcc_profile_content)
+
 def _cuda_component_impl(repository_ctx):
     component_name = None
     if repository_ctx.attr.component_name:
@@ -300,14 +351,19 @@ def _cuda_component_impl(repository_ctx):
     if repository_ctx.attr.url and repository_ctx.attr.urls:
         fail("attributes `url` and `urls` cannot be used at the same time")
 
+    patch_nvcc_profile, rename_files = _patch_nvcc_profile_pre(repository_ctx, component_name)
+
     repository_ctx.download_and_extract(
         url = repository_ctx.attr.url or repository_ctx.attr.urls,
         output = component_name,
         integrity = repository_ctx.attr.integrity,
         sha256 = repository_ctx.attr.sha256,
         stripPrefix = repository_ctx.attr.strip_prefix,
+        rename_files = rename_files,
     )
 
+    _patch_nvcc_profile_post(repository_ctx, patch_nvcc_profile)
+
     template_helper.generate_build(
         repository_ctx,
         libpath = "lib",

cuda/private/rules/cuda_toolkit_info.bzl

@@ -12,6 +12,8 @@ def _impl(ctx):
         link_stub = ctx.file.link_stub,
         bin2c = ctx.file.bin2c,
         fatbinary = ctx.file.fatbinary,
+        cicc = ctx.file.cicc,
+        libdevice = ctx.file.libdevice,
     )
 
 cuda_toolkit_info = rule(
@@ -25,6 +27,8 @@ cuda_toolkit_info = rule(
         "link_stub": attr.label(allow_single_file = True, doc = "The link.stub text file."),
         "bin2c": attr.label(allow_single_file = True, doc = "The bin2c executable."),
         "fatbinary": attr.label(allow_single_file = True, doc = "The fatbinary executable."),
+        "cicc": attr.label(default = None, allow_single_file = True, doc = "The cicc executable."),
+        "libdevice": attr.label(default = None, allow_single_file = True, doc = "The libdevice LLVM bitcode library."),
     },
     provides = [CudaToolkitInfo],
 )

cuda/private/template_helper.bzl

@@ -127,9 +127,11 @@ def _generate_build(repository_ctx, libpath, components = None, is_cuda_repo = T
 
     _generate_build_impl(repository_ctx, libpath, components, is_cuda_repo, is_deliverable)
 
-def _generate_defs_bzl(repository_ctx, is_local_ctk):
+def _generate_defs_bzl(repository_ctx, version_major, version_minor, is_local_ctk):
     tpl_label = Label("//cuda/private:templates/defs.bzl.tpl")
     substitutions = {
+        "%{version_major}": str(version_major),
+        "%{version_minor}": str(version_minor),
         "%{is_local_ctk}": str(is_local_ctk),
     }
     repository_ctx.template("defs.bzl", tpl_label, substitutions = substitutions, executable = False)
@@ -185,7 +187,16 @@ def _generate_toolchain_build(repository_ctx, cuda):
         "//cuda/private:templates/BUILD.toolchain_" +
         ("nvcc" if _is_linux(repository_ctx) else "nvcc_msvc"),
     )
+    compiler_files = ["@cuda//:compiler_deps"]
+    if int(cuda.version_major) >= 13:
+        if cuda.cicc_label != None:
+            compiler_files.append(cuda.cicc_label)
+        if cuda.libdevice_label != None:
+            compiler_files.append(cuda.libdevice_label)
+    compiler_files_line = "compiler_files = " + repr(compiler_files) + ","
+
     substitutions = {
+        "# %{compiler_files_line}": compiler_files_line,
         "%{cuda_path}": _to_forward_slash(cuda.path) if cuda.path else "cuda-not-found",
         "%{cuda_version}": "{}.{}".format(cuda.version_major, cuda.version_minor),
         "%{nvcc_version_major}": str(cuda.nvcc_version_major),
@@ -196,6 +207,11 @@ def _generate_toolchain_build(repository_ctx, cuda):
         "%{bin2c_label}": cuda.bin2c_label,
         "%{fatbinary_label}": cuda.fatbinary_label,
     }
+    if cuda.cicc_label:
+        substitutions["# %{cicc_line}"] = "cicc = " + repr(cuda.cicc_label)
+    if cuda.libdevice_label:
+        substitutions["# %{libdevice_line}"] = "libdevice = " + repr(cuda.libdevice_label)
+
     env_tmp = repository_ctx.os.environ.get("TMP", repository_ctx.os.environ.get("TEMP", None))
     if env_tmp != None:
         substitutions["%{env_tmp}"] = _to_forward_slash(env_tmp)
@@ -256,6 +272,10 @@ def _generate_toolchain_clang_build(repository_ctx, cuda, clang_path_or_label):
         "%{bin2c_label}": cuda.bin2c_label,
         "%{fatbinary_label}": cuda.fatbinary_label,
     }
+    if cuda.cicc_label:
+        substitutions["# %{cicc_line}"] = "cicc = " + repr(cuda.cicc_label)
+    if cuda.libdevice_label:
+        substitutions["# %{libdevice_line}"] = "libdevice = " + repr(cuda.libdevice_label)
 
     if clang_label_for_subst:
         substitutions.pop("%{clang_path}")

cuda/private/templates/BUILD.cccl

@@ -1,36 +1,57 @@
 cc_library(
     name = "libcudacxx",
     hdrs = glob(
-        [
-            "%{component_name}/include/cuda/**",
-            "%{component_name}/include/nv/**",
-        ],
+        if_cuda_toolkit_version_ge(
+            (13, 0),
+            [
+                "%{component_name}/include/cccl/cuda/**",
+                "%{component_name}/include/cccl/nv/**",
+            ],
+            [
+                "%{component_name}/include/cuda/**",
+                "%{component_name}/include/nv/**",
+            ],
+        ),
         allow_empty = True,
     ),
-    includes = [
-        "%{component_name}/include",
-    ],
+    includes = if_cuda_toolkit_version_ge(
+        (13, 0),
+        ["%{component_name}/include/cccl"],
+        ["%{component_name}/include"],
+    ),
 )
 
 cc_library(
     name = "cub",
     hdrs = glob(
-        ["%{component_name}/include/cub/**"],
+        if_cuda_toolkit_version_ge(
+            (13, 0),
+            ["%{component_name}/include/cccl/cub/**"],
+            ["%{component_name}/include/cub/**"],
+        ),
         allow_empty = True,
     ),
-    includes = [
-        "%{component_name}/include",
-    ],
+    includes = if_cuda_toolkit_version_ge(
+        (13, 0),
+        ["%{component_name}/include/cccl"],
+        ["%{component_name}/include"],
+    ),
 )
 
 cc_library(
     name = "thrust",
     hdrs = glob(
-        ["%{component_name}/include/thrust/**"],
+        if_cuda_toolkit_version_ge(
+            (13, 0),
+            ["%{component_name}/include/cccl/thrust/**"],
+            ["%{component_name}/include/thrust/**"],
+        ),
         allow_empty = True,
     ),
-    includes = [
-        "%{component_name}/include",
-    ],
+    includes = if_cuda_toolkit_version_ge(
+        (13, 0),
+        ["%{component_name}/include/cccl"],
+        ["%{component_name}/include"],
+    ),
     deps = [":cub"],
 )

cuda/private/templates/BUILD.crt

@@ -0,0 +1,10 @@
+cc_library(
+    name = "crt",
+    hdrs = glob(
+        ["%{component_name}/include/crt/**"],
+        allow_empty = True,
+    ),
+    includes = [
+        "%{component_name}/include",
+    ],
+)

cuda/private/templates/BUILD.cuda_shared

@@ -1,5 +1,5 @@
 load("@bazel_skylib//rules:common_settings.bzl", "bool_setting")  # @unused
-load("@cuda//:defs.bzl", "additional_header_deps", "if_local_cuda_toolkit")  # @unused
+load("@cuda//:defs.bzl", "additional_header_deps", "if_cuda_toolkit_version_ge", "if_local_cuda_toolkit")  # @unused
 load("@rules_cuda//cuda:defs.bzl", "cc_import_versioned_sos", "if_linux", "if_windows")  # @unused
 
 package(

cuda/private/templates/BUILD.cudart

@@ -9,10 +9,20 @@ cc_library(
     target_compatible_with = ["@platforms//os:linux"],
 )
 
-cc_library(
-    name = "culibos_a",
-    srcs = ["%{component_name}/%{libpath}/libculibos.a"],
-    target_compatible_with = ["@platforms//os:linux"],
+# NOTE: for cuda toolkit older than 13.0, culibos_a is defined here, BUILD.culibos otherwise.
+[
+    cc_library(
+        name = "culibos_a",
+        srcs = ["%{component_name}/%{libpath}/libculibos.a"],
+        target_compatible_with = ["@platforms//os:linux"],
+    )
+    for name in if_cuda_toolkit_version_ge((13,0), [], ["culibos"])
+]
+
+conditional_culibos_a = if_cuda_toolkit_version_ge(
+  (13,0),
+  if_local_cuda_toolkit([":culibos_a"], ["@cuda//:culibos_a"]),
+  [":culibos_a"],
 )
 
 cc_import(
@@ -43,9 +53,8 @@ cc_library(
     ] + if_linux([
         # devrt is required for jit linking when rdc is enabled
         ":cudadevrt_a",
-        ":culibos_a",
         ":cudart_so",
-    ]) + if_windows([
+    ] + conditional_culibos_a) + if_windows([
         # devrt is required for jit linking when rdc is enabled
         ":cudadevrt_lib",
         ":cudart_lib",