numba-cuda 0.19.0__py3-none-any.whl → 0.20.0__py3-none-any.whl

numba_cuda/numba/cuda/cuda_paths.py

@@ -1,27 +1,34 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
 import sys
-import re
 import os
 from collections import namedtuple
 import platform
-import site
-from pathlib import Path
-from numba.core.config import IS_WIN32
-from numba.misc.findlib import find_lib
-from numba import config
-import ctypes
+import importlib.metadata
+from numba.cuda.core.config import IS_WIN32
+from numba.cuda.misc.findlib import find_lib
+from numba.cuda import config
 
 _env_path_tuple = namedtuple("_env_path_tuple", ["by", "info"])
 
 SEARCH_PRIORITY = [
     "Conda environment",
-    "Conda environment (NVIDIA package)",
     "NVIDIA NVCC Wheel",
     "CUDA_HOME",
     "System",
-    "Debian package",
 ]
 
 
+def _get_distribution(distribution_name):
+    """Get the distribution path using importlib.metadata, returning None if not found."""
+    try:
+        dist = importlib.metadata.distribution(distribution_name)
+        return dist
+    except importlib.metadata.PackageNotFoundError:
+        return None
+
+
 def _priority_index(label):
     if label in SEARCH_PRIORITY:
         return SEARCH_PRIORITY.index(label)
@@ -61,182 +68,183 @@ def _find_valid_path(options):
 def _get_libdevice_path_decision():
     options = _build_options(
         [
-            ("Conda environment", get_conda_ctk),
-            ("Conda environment (NVIDIA package)", get_nvidia_libdevice_ctk),
-            ("CUDA_HOME", lambda: get_cuda_home("nvvm", "libdevice")),
-            ("NVIDIA NVCC Wheel", get_libdevice_wheel),
-            ("System", lambda: get_system_ctk("nvvm", "libdevice")),
-            ("Debian package", get_debian_pkg_libdevice),
+            ("Conda environment", get_libdevice_conda_path),
+            ("NVIDIA NVCC Wheel", get_libdevice_wheel_path),
+            (
+                "CUDA_HOME",
+                lambda: get_cuda_home("nvvm", "libdevice", "libdevice.10.bc"),
+            ),
+            (
+                "System",
+                lambda: get_system_ctk("nvvm", "libdevice", "libdevice.10.bc"),
+            ),
         ]
     )
     return _find_first_valid_lazy(options)
 
 
-def _nvvm_lib_dir():
-    if IS_WIN32:
-        return "nvvm", "bin"
-    else:
-        return "nvvm", "lib64"
-
-
 def _get_nvvm_path_decision():
-    options = [
-        ("Conda environment", get_conda_ctk),
-        ("Conda environment (NVIDIA package)", get_nvidia_nvvm_ctk),
-        ("NVIDIA NVCC Wheel", _get_nvvm_wheel),
-        ("CUDA_HOME", lambda: get_cuda_home(*_nvvm_lib_dir())),
-        ("System", lambda: get_system_ctk(*_nvvm_lib_dir())),
-    ]
+    options = _build_options(
+        [
+            ("Conda environment", _get_nvvm_conda_path),
+            ("NVIDIA NVCC Wheel", _get_nvvm_wheel_path),
+            ("CUDA_HOME", _get_nvvm_cuda_home_path),
+            ("System", _get_nvvm_system_path),
+        ]
+    )
     return _find_first_valid_lazy(options)
 
 
-def _get_nvrtc_system_ctk():
-    sys_path = get_system_ctk("bin" if IS_WIN32 else "lib64")
-    candidates = find_lib("nvrtc", sys_path)
-    if candidates:
-        return max(candidates)
-
-
 def _get_nvrtc_path_decision():
     options = _build_options(
         [
-            ("CUDA_HOME", lambda: get_cuda_home(_cudalib_path())),
-            ("Conda environment", get_conda_ctk),
-            ("Conda environment (NVIDIA package)", get_nvidia_cudalib_ctk),
-            ("NVIDIA NVCC Wheel", _get_nvrtc_wheel),
-            ("System", _get_nvrtc_system_ctk),
+            ("Conda environment", get_conda_ctk_libdir),
+            ("NVIDIA NVCC Wheel", _get_nvrtc_wheel_libdir),
+            ("CUDA_HOME", get_cuda_home_libdir),
+            ("System", get_system_ctk_libdir),
         ]
     )
     return _find_first_valid_lazy(options)
 
 
-def _get_nvvm_wheel():
-    platform_map = {
-        "linux": ("lib64", "libnvvm.so"),
-        "win32": ("bin", "nvvm64_40_0.dll"),
-    }
-
-    for plat, (dso_dir, dso_path) in platform_map.items():
-        if sys.platform.startswith(plat):
-            break
-    else:
-        raise NotImplementedError("Unsupported platform")
-
-    site_paths = [site.getusersitepackages()] + site.getsitepackages()
+def _get_nvvm_wheel_path():
+    dso_path = None
+    # CUDA 12
+    nvcc_distribution = _get_distribution("nvidia-cuda-nvcc-cu12")
+    if nvcc_distribution is not None:
+        site_packages_path = nvcc_distribution.locate_file("")
+        nvvm_lib_dir = os.path.join(
+            site_packages_path,
+            "nvidia",
+            "cuda_nvcc",
+            "nvvm",
+            "bin" if IS_WIN32 else "lib64",
+        )
+        dso_path = os.path.join(
+            nvvm_lib_dir, "nvvm64_40_0.dll" if IS_WIN32 else "libnvvm.so"
+        )
 
-    for sp in filter(None, site_paths):
-        nvvm_path = Path(sp, "nvidia", "cuda_nvcc", "nvvm", dso_dir, dso_path)
-        if nvvm_path.exists():
-            return str(nvvm_path.parent)
+    # CUDA 13
+    if dso_path is None:
+        nvcc_distribution = _get_distribution("nvidia-nvvm")
+        if (
+            nvcc_distribution is not None
+            and nvcc_distribution.version.startswith("13.")
+        ):
+            site_packages_path = nvcc_distribution.locate_file("")
+            nvvm_lib_dir = os.path.join(
+                site_packages_path,
+                "nvidia",
+                "cu13",
+                "bin" if IS_WIN32 else "lib",
+                "x86_64" if IS_WIN32 else "",
+            )
+            dso_path = os.path.join(
+                nvvm_lib_dir, "nvvm64_40_0.dll" if IS_WIN32 else "libnvvm.so.4"
+            )
 
+    if dso_path and os.path.isfile(dso_path):
+        return dso_path
     return None
 
 
-def get_nvrtc_dso_path():
-    site_paths = [site.getusersitepackages()] + site.getsitepackages()
-
-    for sp in site_paths:
-        lib_dir = os.path.join(
-            sp,
+def _get_nvrtc_wheel_libdir():
+    dso_path = None
+    # CUDA 12
+    nvrtc_distribution = _get_distribution("nvidia-cuda-nvrtc-cu12")
+    if nvrtc_distribution is not None:
+        site_packages_path = nvrtc_distribution.locate_file("")
+        nvrtc_lib_dir = os.path.join(
+            site_packages_path,
             "nvidia",
             "cuda_nvrtc",
-            ("bin" if IS_WIN32 else "lib") if sp else None,
+            "bin" if IS_WIN32 else "lib",
+        )
+        dso_path = os.path.join(
+            nvrtc_lib_dir, "nvrtc64_120_0.dll" if IS_WIN32 else "libnvrtc.so.12"
         )
-        if lib_dir and os.path.exists(lib_dir):
-            chosen_path = None
-
-            # Check for each version of the NVRTC DLL, preferring the most
-            # recent.
-            versions = (
-                "120" if IS_WIN32 else "12",
-                "130" if IS_WIN32 else "13",
-            )
-
-            for version in versions:
-                dso_path = os.path.join(
-                    lib_dir,
-                    f"nvrtc64_{version}_0.dll"
-                    if IS_WIN32
-                    else f"libnvrtc.so.{version}",
-                )
 
-                if os.path.exists(dso_path) and os.path.isfile(dso_path):
-                    chosen_path = dso_path
+    # CUDA 13
+    if dso_path is None:
+        nvrtc_distribution = _get_distribution("nvidia-cuda-nvrtc")
+        if (
+            nvrtc_distribution is not None
+            and nvrtc_distribution.version.startswith("13.")
+        ):
+            site_packages_path = nvrtc_distribution.locate_file("")
+            nvrtc_lib_dir = os.path.join(
+                site_packages_path,
+                "nvidia",
+                "cu13",
+                "bin" if IS_WIN32 else "lib",
+                "x86_64" if IS_WIN32 else "",
+            )
+            dso_path = os.path.join(
+                nvrtc_lib_dir,
+                "nvrtc64_130_0.dll" if IS_WIN32 else "libnvrtc.so.13",
+            )
 
-            return chosen_path
+    if dso_path and os.path.isfile(dso_path):
+        return os.path.dirname(dso_path)
+    return None
 
 
-def _get_nvrtc_wheel():
-    dso_path = get_nvrtc_dso_path()
-    if dso_path:
-        try:
-            result = ctypes.CDLL(dso_path, mode=ctypes.RTLD_GLOBAL)
-        except OSError:
-            pass
-        else:
-            if IS_WIN32:
-                import win32api
-
-                # This absolute path will
-                # always be correct regardless of the package source
-                nvrtc_path = win32api.GetModuleFileNameW(result._handle)
-                dso_dir = os.path.dirname(nvrtc_path)
-                builtins_path = os.path.join(
-                    dso_dir,
-                    [
-                        f
-                        for f in os.listdir(dso_dir)
-                        if re.match("^nvrtc-builtins.*.dll$", f)
-                    ][0],
-                )
-                if not os.path.exists(builtins_path):
-                    raise RuntimeError(
-                        f'Path does not exist: "{builtins_path}"'
-                    )
-        return Path(dso_path)
-
-
-def _get_libdevice_paths():
-    by, libdir = _get_libdevice_path_decision()
-    if not libdir:
+def _get_libdevice_path():
+    by, out = _get_libdevice_path_decision()
+    if not out:
         return _env_path_tuple(by, None)
-    out = os.path.join(libdir, "libdevice.10.bc")
     return _env_path_tuple(by, out)
 
 
-def _cudalib_path():
+def _cuda_static_libdir():
     if IS_WIN32:
-        return "bin"
+        return ("lib", "x64")
     else:
-        return "lib64"
+        return ("lib64",)
 
 
-def _cuda_home_static_cudalib_path():
-    if IS_WIN32:
-        return ("lib", "x64")
+def _get_cudalib_wheel_libdir():
+    """Get the cudalib path from the cudart wheel."""
+    cuda_module_lib_dir = None
+    cuda_runtime_distribution = _get_distribution("nvidia-cuda-runtime-cu12")
+    if cuda_runtime_distribution is not None:
+        site_packages_path = cuda_runtime_distribution.locate_file("")
+        cuda_module_lib_dir = os.path.join(
+            site_packages_path,
+            "nvidia",
+            "cuda_runtime",
+            "bin" if IS_WIN32 else "lib",
+        )
     else:
-        return ("lib64",)
+        cuda_runtime_distribution = _get_distribution("nvidia-cuda-runtime")
+        if (
+            cuda_runtime_distribution is not None
+            and cuda_runtime_distribution.version.startswith("13.")
+        ):
+            site_packages_path = cuda_runtime_distribution.locate_file("")
+            cuda_module_lib_dir = os.path.join(
+                site_packages_path,
+                "nvidia",
+                "cu13",
+                "bin" if IS_WIN32 else "lib",
+                "x86_64" if IS_WIN32 else "",
+            )
 
+    if cuda_module_lib_dir is None:
+        return None
 
-def _get_cudalib_wheel():
-    """Get the cudalib path from the NVCC wheel."""
-    site_paths = [site.getusersitepackages()] + site.getsitepackages()
-    libdir = "bin" if IS_WIN32 else "lib"
-    for sp in filter(None, site_paths):
-        cudalib_path = Path(sp, "nvidia", "cuda_runtime", libdir)
-        if cudalib_path.exists():
-            return str(cudalib_path)
+    if cuda_module_lib_dir and os.path.isdir(cuda_module_lib_dir):
+        return cuda_module_lib_dir
     return None
 
 
 def _get_cudalib_dir_path_decision():
     options = _build_options(
         [
-            ("Conda environment", get_conda_ctk),
-            ("Conda environment (NVIDIA package)", get_nvidia_cudalib_ctk),
-            ("NVIDIA NVCC Wheel", _get_cudalib_wheel),
-            ("CUDA_HOME", lambda: get_cuda_home(_cudalib_path())),
-            ("System", lambda: get_system_ctk(_cudalib_path())),
+            ("Conda environment", get_conda_ctk_libdir),
+            ("NVIDIA NVCC Wheel", _get_cudalib_wheel_libdir),
+            ("CUDA_HOME", get_cuda_home_libdir),
+            ("System", get_system_ctk_libdir),
         ]
     )
     return _find_first_valid_lazy(options)
@@ -245,16 +253,13 @@ def _get_cudalib_dir_path_decision():
 def _get_static_cudalib_dir_path_decision():
     options = _build_options(
         [
-            ("Conda environment", get_conda_ctk),
-            (
-                "Conda environment (NVIDIA package)",
-                get_nvidia_static_cudalib_ctk,
-            ),
+            ("Conda environment", get_conda_ctk_libdir),
+            ("NVIDIA NVCC Wheel", get_wheel_static_libdir),
             (
                 "CUDA_HOME",
-                lambda: get_cuda_home(*_cuda_home_static_cudalib_path()),
+                lambda: get_cuda_home(*_cuda_static_libdir()),
             ),
-            ("System", lambda: get_system_ctk(_cudalib_path())),
+            ("System", lambda: get_system_ctk(*_cuda_static_libdir())),
         ]
     )
     return _find_first_valid_lazy(options)
@@ -279,74 +284,196 @@ def get_system_ctk(*subdirs):
         result = os.path.join("/usr/local/cuda", *subdirs)
         if os.path.exists(result):
             return result
+        return None
+    return None
+
+
+def get_system_ctk_libdir():
+    """Return path to directory containing the shared libraries of cudatoolkit."""
+    system_ctk_dir = get_system_ctk()
+    if system_ctk_dir is None:
+        return None
+    libdir = os.path.join(
+        system_ctk_dir,
+        "Library" if IS_WIN32 else "lib64",
+        "bin" if IS_WIN32 else "",
+    )
+    # Windows CUDA 13 system CTK uses "bin\x64" directory
+    if IS_WIN32 and os.path.isdir(os.path.join(libdir, "x64")):
+        libdir = os.path.join(libdir, "x64")
+
+    if libdir and os.path.isdir(libdir):
+        return os.path.normpath(libdir)
+    return None
+
+
+def get_system_ctk_include():
+    system_ctk_dir = get_system_ctk()
+    if system_ctk_dir is None:
+        return None
+    include_dir = os.path.join(system_ctk_dir, "include")
+
+    if include_dir and os.path.isdir(include_dir):
+        if os.path.isfile(
+            os.path.join(include_dir, "cuda_device_runtime_api.h")
+        ):
+            return include_dir
+    return None
 
 
-def get_conda_ctk():
+def _get_nvvm_system_path():
+    nvvm_lib_dir = get_system_ctk("nvvm")
+    if nvvm_lib_dir is None:
+        return None
+    nvvm_lib_dir = os.path.join(nvvm_lib_dir, "bin" if IS_WIN32 else "lib64")
+    if IS_WIN32 and os.path.isdir(os.path.join(nvvm_lib_dir, "x64")):
+        nvvm_lib_dir = os.path.join(nvvm_lib_dir, "x64")
+
+    nvvm_path = os.path.join(
+        nvvm_lib_dir, "nvvm64_40_0.dll" if IS_WIN32 else "libnvvm.so.4"
+    )
+    # if os.path.isfile(nvvm_path):
+    #     return nvvm_path
+    return nvvm_path
+
+
+def get_conda_ctk_libdir():
     """Return path to directory containing the shared libraries of cudatoolkit."""
-    is_conda_env = os.path.exists(os.path.join(sys.prefix, "conda-meta"))
+    is_conda_env = os.path.isdir(os.path.join(sys.prefix, "conda-meta"))
     if not is_conda_env:
-        return
-    # Assume the existence of NVVM to imply cudatoolkit installed
-    paths = find_lib("nvvm")
+        return None
+    libdir = os.path.join(
+        sys.prefix,
+        "Library" if IS_WIN32 else "lib",
+        "bin" if IS_WIN32 else "",
+    )
+    # Windows CUDA 13.0.0 uses "bin\x64" directory but 13.0.1+ just uses "bin" directory
+    if IS_WIN32 and os.path.isdir(os.path.join(libdir, "x64")):
+        libdir = os.path.join(libdir, "x64")
+    # Assume the existence of nvrtc to imply needed CTK libraries are installed
+    paths = find_lib("nvrtc", libdir)
     if not paths:
-        return
+        return None
     # Use the directory name of the max path
     return os.path.dirname(max(paths))
 
 
-def get_nvidia_nvvm_ctk():
-    """Return path to directory containing the NVVM shared library."""
-    is_conda_env = os.path.exists(os.path.join(sys.prefix, "conda-meta"))
+def get_libdevice_conda_path():
+    """Return path to directory containing the libdevice bitcode library."""
+    is_conda_env = os.path.isdir(os.path.join(sys.prefix, "conda-meta"))
     if not is_conda_env:
-        return
+        return None
 
-    # Assume the existence of NVVM in the conda env implies that a CUDA toolkit
-    # conda package is installed.
-    if IS_WIN32:
-        # The path used on Windows
-        libdir = os.path.join(sys.prefix, "Library", "nvvm", _cudalib_path())
-    else:
-        # The path used on Linux is different to that on Windows
-        libdir = os.path.join(sys.prefix, "nvvm", _cudalib_path())
+    # Linux: nvvm/libdevice/libdevice.10.bc
+    # Windows: Library/nvvm/libdevice/libdevice.10.bc
+    libdevice_path = os.path.join(
+        sys.prefix,
+        "Library" if IS_WIN32 else "",
+        "nvvm",
+        "libdevice",
+        "libdevice.10.bc",
+    )
+    if os.path.isfile(libdevice_path):
+        return libdevice_path
+    return None
 
-    if not os.path.exists(libdir) or not os.path.isdir(libdir):
-        # If the path doesn't exist, we didn't find the NVIDIA conda package
-        return
 
-    paths = find_lib("nvvm", libdir=libdir)
-    if not paths:
-        return
-    # Use the directory name of the max path
-    return os.path.dirname(max(paths))
+def _get_nvvm_conda_path():
+    """Return path to directory containing the nvvm library."""
+    is_conda_env = os.path.isdir(os.path.join(sys.prefix, "conda-meta"))
+    if not is_conda_env:
+        return None
+    nvvm_dir = os.path.join(
+        sys.prefix,
+        "Library" if IS_WIN32 else "",
+        "nvvm",
+        "bin" if IS_WIN32 else "lib64",
+    )
+    # Windows CUDA 13.0.0 puts in "bin\x64" directory but 13.0.1+ just uses "bin" directory
+    if IS_WIN32 and os.path.isdir(os.path.join(nvvm_dir, "x64")):
+        nvvm_dir = os.path.join(nvvm_dir, "x64")
 
+    nvvm_path = os.path.join(
+        nvvm_dir, "nvvm64_40_0.dll" if IS_WIN32 else "libnvvm.so.4"
+    )
+    if os.path.isfile(nvvm_path):
+        return nvvm_path
+    return None
 
-def get_nvidia_libdevice_ctk():
-    """Return path to directory containing the libdevice library."""
-    nvvm_ctk = get_nvidia_nvvm_ctk()
-    if not nvvm_ctk:
-        return
-    nvvm_dir = os.path.dirname(nvvm_ctk)
-    return os.path.join(nvvm_dir, "libdevice")
 
+def get_wheel_static_libdir():
+    cuda_module_static_lib_dir = None
+    # CUDA 12
+    cuda_runtime_distribution = _get_distribution("nvidia-cuda-runtime-cu12")
+    if cuda_runtime_distribution is not None:
+        site_packages_path = cuda_runtime_distribution.locate_file("")
+        cuda_module_static_lib_dir = os.path.join(
+            site_packages_path,
+            "nvidia",
+            "cuda_runtime",
+            "lib",
+            "x64" if IS_WIN32 else "",
+        )
+    else:
+        cuda_runtime_distribution = _get_distribution("nvidia-cuda-runtime")
+        if (
+            cuda_runtime_distribution is not None
+            and cuda_runtime_distribution.version.startswith("13.")
+        ):
+            site_packages_path = cuda_runtime_distribution.locate_file("")
+            cuda_module_static_lib_dir = os.path.join(
+                site_packages_path,
+                "nvidia",
+                "cu13",
+                "lib",
+                "x64" if IS_WIN32 else "",
+            )
 
-def get_nvidia_cudalib_ctk():
-    """Return path to directory containing the shared libraries of cudatoolkit."""
-    nvvm_ctk = get_nvidia_nvvm_ctk()
-    if not nvvm_ctk:
-        return
-    env_dir = os.path.dirname(os.path.dirname(nvvm_ctk))
-    subdir = "bin" if IS_WIN32 else "lib"
-    return os.path.join(env_dir, subdir)
+    if cuda_module_static_lib_dir is None:
+        return None
 
+    cudadevrt_path = os.path.join(
+        cuda_module_static_lib_dir,
+        "cudadevrt.lib" if IS_WIN32 else "libcudadevrt.a",
+    )
 
-def get_nvidia_static_cudalib_ctk():
-    """Return path to directory containing the static libraries of cudatoolkit."""
-    nvvm_ctk = get_nvidia_nvvm_ctk()
-    if not nvvm_ctk:
-        return
+    if cudadevrt_path and os.path.isfile(cudadevrt_path):
+        return os.path.dirname(cudadevrt_path)
+    return None
 
-    env_dir = os.path.dirname(os.path.dirname(nvvm_ctk))
-    return os.path.join(env_dir, "lib")
+
+def get_wheel_include():
+    cuda_module_include_dir = None
+    # CUDA 12
+    cuda_runtime_distribution = _get_distribution("nvidia-cuda-runtime-cu12")
+    if cuda_runtime_distribution is not None:
+        site_packages_path = cuda_runtime_distribution.locate_file("")
+        cuda_module_include_dir = os.path.join(
+            site_packages_path,
+            "nvidia",
+            "cuda_runtime",
+            "include",
+        )
+    else:
+        cuda_runtime_distribution = _get_distribution("nvidia-cuda-runtime")
+        if (
+            cuda_runtime_distribution is not None
+            and cuda_runtime_distribution.version.startswith("13.")
+        ):
+            site_packages_path = cuda_runtime_distribution.locate_file("")
+            cuda_module_include_dir = os.path.join(
+                site_packages_path,
+                "nvidia",
+                "cu13",
+                "include",
+            )
+
+    if cuda_module_include_dir and os.path.isdir(cuda_module_include_dir):
+        if os.path.isfile(
+            os.path.join(cuda_module_include_dir, "cuda_device_runtime_api.h")
+        ):
+            return cuda_module_include_dir
+    return None
 
 
 def get_cuda_home(*subdirs):
@@ -360,39 +487,74 @@ def get_cuda_home(*subdirs):
         cuda_home = os.environ.get("CUDA_PATH")
     if cuda_home is not None:
         return os.path.join(cuda_home, *subdirs)
+    return None
 
 
-def _get_nvvm_path():
-    by, path = _get_nvvm_path_decision()
+def get_cuda_home_libdir():
+    """Return path to directory containing the shared libraries of cudatoolkit."""
+    cuda_home_dir = get_cuda_home()
+    if cuda_home_dir is None:
+        return None
+    libdir = os.path.join(
+        cuda_home_dir,
+        "Library" if IS_WIN32 else "lib64",
+        "bin" if IS_WIN32 else "",
+    )
+    # Windows CUDA 13 system CTK uses "bin\x64" directory while conda just uses "bin" directory
+    if IS_WIN32 and os.path.isdir(os.path.join(libdir, "x64")):
+        libdir = os.path.join(libdir, "x64")
+    return os.path.normpath(libdir)
 
-    if by == "NVIDIA NVCC Wheel":
-        platform_map = {
-            "linux": "libnvvm.so",
-            "win32": "nvvm64_40_0.dll",
-        }
 
-        for plat, dso_name in platform_map.items():
-            if sys.platform.startswith(plat):
-                break
+def get_cuda_home_include():
+    cuda_home_dir = get_cuda_home()
+    if cuda_home_dir is None:
+        return None
+    include_dir = cuda_home_dir
+    # For Windows, CTK puts it in $CTK/include but conda puts it in $CTK/Library/include
+    if IS_WIN32:
+        if os.path.isdir(os.path.join(include_dir, "Library")):
+            include_dir = os.path.join(include_dir, "Library", "include")
         else:
-            raise NotImplementedError("Unsupported platform")
-
-        path = os.path.join(path, dso_name)
+            include_dir = os.path.join(include_dir, "include")
     else:
-        candidates = find_lib("nvvm", path)
-        path = max(candidates) if candidates else None
-    return _env_path_tuple(by, path)
+        include_dir = os.path.join(include_dir, "include")
+
+    if include_dir and os.path.isdir(include_dir):
+        if os.path.isfile(
+            os.path.join(include_dir, "cuda_device_runtime_api.h")
+        ):
+            return include_dir
+    return None
+
+
+def _get_nvvm_cuda_home_path():
+    nvvm_lib_dir = get_cuda_home("nvvm")
+    if nvvm_lib_dir is None:
+        return
+    nvvm_lib_dir = os.path.join(nvvm_lib_dir, "bin" if IS_WIN32 else "lib64")
+    if IS_WIN32 and os.path.isdir(os.path.join(nvvm_lib_dir, "x64")):
+        nvvm_lib_dir = os.path.join(nvvm_lib_dir, "x64")
+
+    nvvm_path = os.path.join(
+        nvvm_lib_dir, "nvvm64_40_0.dll" if IS_WIN32 else "libnvvm.so.4"
+    )
+    # if os.path.isfile(nvvm_path):
+    #     return nvvm_path
+    return nvvm_path
+
+
+def _get_nvvm_path():
+    by, out = _get_nvvm_path_decision()
+    if not out:
+        return _env_path_tuple(by, None)
+    return _env_path_tuple(by, out)
 
 
 def _get_nvrtc_path():
     by, path = _get_nvrtc_path_decision()
-    if by == "NVIDIA NVCC Wheel":
-        path = str(path)
-    elif by == "System":
-        return _env_path_tuple(by, path)
-    else:
-        candidates = find_lib("nvrtc", path)
-        path = max(candidates) if candidates else None
+    candidates = find_lib("nvrtc", libdir=path)
+    path = max(candidates) if candidates else None
     return _env_path_tuple(by, path)
 
 
@@ -402,8 +564,11 @@ def get_cuda_paths():
 
     The returned dictionary will have the following keys and infos:
     - "nvvm": file_path
-    - "libdevice": List[Tuple[arch, file_path]]
+    - "nvrtc": file_path
+    - "libdevice": file_path
     - "cudalib_dir": directory_path
+    - "static_cudalib_dir": directory_path
+    - "include_dir": directory_path
 
     Note: The result of the function is cached.
     """
@@ -415,7 +580,7 @@ def get_cuda_paths():
         d = {
             "nvvm": _get_nvvm_path(),
             "nvrtc": _get_nvrtc_path(),
-            "libdevice": _get_libdevice_paths(),
+            "libdevice": _get_libdevice_path(),
             "cudalib_dir": _get_cudalib_dir(),
             "static_cudalib_dir": _get_static_cudalib_dir(),
             "include_dir": _get_include_dir(),
@@ -425,25 +590,41 @@ def get_cuda_paths():
         return d
 
 
-def get_debian_pkg_libdevice():
-    """
-    Return the Debian NVIDIA Maintainers-packaged libdevice location, if it
-    exists.
-    """
-    pkg_libdevice_location = "/usr/lib/nvidia-cuda-toolkit/libdevice"
-    if not os.path.exists(pkg_libdevice_location):
-        return None
-    return pkg_libdevice_location
-
+def get_libdevice_wheel_path():
+    libdevice_path = None
+    # CUDA 12
+    nvvm_distribution = _get_distribution("nvidia-cuda-nvcc-cu12")
+    if nvvm_distribution is not None:
+        site_packages_path = nvvm_distribution.locate_file("")
+        libdevice_path = os.path.join(
+            site_packages_path,
+            "nvidia",
+            "cuda_nvcc",
+            "nvvm",
+            "libdevice",
+            "libdevice.10.bc",
+        )
 
-def get_libdevice_wheel():
-    nvvm_path = _get_nvvm_wheel()
-    if nvvm_path is None:
-        return None
-    nvvm_path = Path(nvvm_path)
-    libdevice_path = nvvm_path.parent / "libdevice"
+    # CUDA 13
+    if libdevice_path is None:
+        nvvm_distribution = _get_distribution("nvidia-nvvm")
+        if (
+            nvvm_distribution is not None
+            and nvvm_distribution.version.startswith("13.")
+        ):
+            site_packages_path = nvvm_distribution.locate_file("")
+            libdevice_path = os.path.join(
+                site_packages_path,
+                "nvidia",
+                "cu13",
+                "nvvm",
+                "libdevice",
+                "libdevice.10.bc",
+            )
 
-    return str(libdevice_path)
+    if libdevice_path and os.path.isfile(libdevice_path):
+        return libdevice_path
+    return None
 
 
 def get_current_cuda_target_name():
@@ -475,11 +656,11 @@ def get_conda_include_dir():
     Return the include directory in the current conda environment, if one
     is active and it exists.
     """
-    is_conda_env = os.path.exists(os.path.join(sys.prefix, "conda-meta"))
+    is_conda_env = os.path.isdir(os.path.join(sys.prefix, "conda-meta"))
     if not is_conda_env:
         return
 
-    if platform.system() == "Windows":
+    if IS_WIN32:
         include_dir = os.path.join(sys.prefix, "Library", "include")
     elif target_name := get_current_cuda_target_name():
         include_dir = os.path.join(
@@ -490,23 +671,21 @@ def get_conda_include_dir():
         # though usually it shouldn't.
         include_dir = os.path.join(sys.prefix, "include")
 
-    if (
-        os.path.exists(include_dir)
-        and os.path.isdir(include_dir)
-        and os.path.exists(
-            os.path.join(include_dir, "cuda_device_runtime_api.h")
-        )
+    if os.path.isdir(include_dir) and os.path.isfile(
+        os.path.join(include_dir, "cuda_device_runtime_api.h")
     ):
         return include_dir
-    return
+    return None
 
 
 def _get_include_dir():
     """Find the root include directory."""
     options = [
         ("Conda environment (NVIDIA package)", get_conda_include_dir()),
+        ("NVIDIA NVCC Wheel", get_wheel_include()),
+        ("CUDA_HOME", get_cuda_home_include()),
+        ("System", get_system_ctk_include()),
         ("CUDA_INCLUDE_PATH Config Entry", config.CUDA_INCLUDE_PATH),
-        # TODO: add others
     ]
     by, include_dir = _find_valid_path(options)
     return _env_path_tuple(by, include_dir)