NVIDIA
diff --git a/‎cuda_pathfinder/cuda/pathfinder/_dynamic_libs/canary_probe_subprocess.py‎
Lines changed: 30 additions & 0 deletions b/‎cuda_pathfinder/cuda/pathfinder/_dynamic_libs/canary_probe_subprocess.py‎
Lines changed: 30 additions & 0 deletions
diff --git a/‎cuda_pathfinder/cuda/pathfinder/_dynamic_libs/find_nvidia_dynamic_lib.py‎
Lines changed: 69 additions & 1 deletion b/‎cuda_pathfinder/cuda/pathfinder/_dynamic_libs/find_nvidia_dynamic_lib.py‎
Lines changed: 69 additions & 1 deletion
diff --git a/‎cuda_pathfinder/cuda/pathfinder/_dynamic_libs/load_nvidia_dynamic_lib.py‎
Lines changed: 94 additions & 4 deletions b/‎cuda_pathfinder/cuda/pathfinder/_dynamic_libs/load_nvidia_dynamic_lib.py‎
Lines changed: 94 additions & 4 deletions
diff --git a/‎cuda_pathfinder/cuda/pathfinder/_dynamic_libs/supported_nvidia_libs.py‎
Lines changed: 7 additions & 0 deletions b/‎cuda_pathfinder/cuda/pathfinder/_dynamic_libs/supported_nvidia_libs.py‎
Lines changed: 7 additions & 0 deletions
diff --git a/‎…thfinder/tests/spawned_process_runner.py‎ ‎…hfinder/_utils/spawned_process_runner.py‎cuda_pathfinder/tests/spawned_process_runner.py renamed to cuda_pathfinder/cuda/pathfinder/_utils/spawned_process_runner.py
Lines changed: 9 additions & 3 deletions b/‎…thfinder/tests/spawned_process_runner.py‎ ‎…hfinder/_utils/spawned_process_runner.py‎cuda_pathfinder/tests/spawned_process_runner.py renamed to cuda_pathfinder/cuda/pathfinder/_utils/spawned_process_runner.py
Lines changed: 9 additions & 3 deletions
@@ -0,0 +1,30 @@
+#!/usr/bin/env python
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+import json
+
+from cuda.pathfinder._dynamic_libs.load_dl_common import DynamicLibNotFoundError, LoadedDL
+from cuda.pathfinder._utils.platform_aware import IS_WINDOWS
+
+if IS_WINDOWS:
+    from cuda.pathfinder._dynamic_libs.load_dl_windows import load_with_system_search
+else:
+    from cuda.pathfinder._dynamic_libs.load_dl_linux import load_with_system_search
+
+
+def _probe_canary_abs_path(libname: str) -> str | None:
+    try:
+        loaded: LoadedDL | None = load_with_system_search(libname)
+    except DynamicLibNotFoundError:
+        return None
+    if loaded is None:
+        return None
+    abs_path = loaded.abs_path
+    if not isinstance(abs_path, str):
+        return None
+    return abs_path
+
+
+def probe_canary_abs_path_and_print_json(libname: str) -> None:
+    print(json.dumps(_probe_canary_abs_path(libname)))  # noqa: T201
@@ -101,7 +101,7 @@ def _find_lib_dir_using_anchor_point(libname: str, anchor_point: str, linux_lib_
     for rel_path in rel_paths:
         for dirname in sorted(glob.glob(os.path.join(anchor_point, rel_path))):
             if os.path.isdir(dirname):
-                return dirname
+                return os.path.normpath(dirname)
 
     return None
 
@@ -152,6 +152,64 @@ def _find_dll_using_lib_dir(
     return None
 
 
+def _derive_ctk_root_linux(resolved_lib_path: str) -> str | None:
+    """Derive the CTK installation root from a resolved library path on Linux.
+
+    Standard system CTK layout: ``$CTK_ROOT/lib64/libfoo.so.XX``
+    (some installs use ``lib`` instead of ``lib64``).
+    Also handles target-specific layouts:
+    ``$CTK_ROOT/targets/<triple>/lib64/libfoo.so.XX`` (or ``lib``).
+
+    Returns None if the path doesn't match a recognized layout.
+    """
+    lib_dir = os.path.dirname(resolved_lib_path)
+    basename = os.path.basename(lib_dir)
+    if basename in ("lib64", "lib"):
+        parent = os.path.dirname(lib_dir)
+        grandparent = os.path.dirname(parent)
+        if os.path.basename(grandparent) == "targets":
+            # This corresponds to /.../targets/<triple>/lib{,64}
+            return os.path.dirname(grandparent)
+        return parent
+    return None
+
+
+def _derive_ctk_root_windows(resolved_lib_path: str) -> str | None:
+    """Derive the CTK installation root from a resolved library path on Windows.
+
+    Handles two CTK layouts:
+    - CTK 13: ``$CTK_ROOT/bin/x64/foo.dll``
+    - CTK 12: ``$CTK_ROOT/bin/foo.dll``
+
+    Returns None if the path doesn't match a recognized layout.
+
+    Uses ``ntpath`` explicitly so the function is testable on any platform.
+    """
+    import ntpath
+
+    lib_dir = ntpath.dirname(resolved_lib_path)
+    basename = ntpath.basename(lib_dir).lower()
+    if basename == "x64":
+        parent = ntpath.dirname(lib_dir)
+        if ntpath.basename(parent).lower() == "bin":
+            return ntpath.dirname(parent)
+    elif basename == "bin":
+        return ntpath.dirname(lib_dir)
+    return None
+
+
+def derive_ctk_root(resolved_lib_path: str) -> str | None:
+    """Derive the CTK installation root from a resolved library path.
+
+    Given the absolute path of a loaded CTK shared library, walk up the
+    directory tree to find the CTK root.  Returns None if the path doesn't
+    match any recognized CTK directory layout.
+    """
+    if IS_WINDOWS:
+        return _derive_ctk_root_windows(resolved_lib_path)
+    return _derive_ctk_root_linux(resolved_lib_path)
+
+
 class _FindNvidiaDynamicLib:
     def __init__(self, libname: str):
         self.libname = libname
@@ -185,6 +243,16 @@ def try_with_conda_prefix(self) -> str | None:
     def try_with_cuda_home(self) -> str | None:
         return self._find_using_lib_dir(_find_lib_dir_using_cuda_home(self.libname))
 
+    def try_via_ctk_root(self, ctk_root: str) -> str | None:
+        """Find the library under a derived CTK root directory.
+
+        Uses :func:`_find_lib_dir_using_anchor_point` which already knows
+        about non-standard sub-paths (e.g. ``nvvm/lib64`` for nvvm).
+        """
+        return self._find_using_lib_dir(
+            _find_lib_dir_using_anchor_point(self.libname, anchor_point=ctk_root, linux_lib_dir="lib64")
+        )
+
     def _find_using_lib_dir(self, lib_dir: str | None) -> str | None:
         if lib_dir is None:
             return None
 
@@ -2,16 +2,24 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import functools
+import json
 import struct
 import sys
 
-from cuda.pathfinder._dynamic_libs.find_nvidia_dynamic_lib import _FindNvidiaDynamicLib
+from cuda.pathfinder._dynamic_libs.canary_probe_subprocess import probe_canary_abs_path_and_print_json
+from cuda.pathfinder._dynamic_libs.find_nvidia_dynamic_lib import (
+    _FindNvidiaDynamicLib,
+    derive_ctk_root,
+)
 from cuda.pathfinder._dynamic_libs.load_dl_common import DynamicLibNotFoundError, LoadedDL, load_dependencies
 from cuda.pathfinder._dynamic_libs.supported_nvidia_libs import (
+    _CTK_ROOT_CANARY_ANCHOR_LIBNAMES,
+    _CTK_ROOT_CANARY_DISCOVERABLE_LIBNAMES,
     SUPPORTED_LINUX_SONAMES,
     SUPPORTED_WINDOWS_DLLS,
 )
 from cuda.pathfinder._utils.platform_aware import IS_WINDOWS
+from cuda.pathfinder._utils.spawned_process_runner import run_in_spawned_child_process
 
 if IS_WINDOWS:
     from cuda.pathfinder._dynamic_libs.load_dl_windows import (
@@ -60,6 +68,67 @@ def _load_driver_lib_no_cache(libname: str) -> LoadedDL:
     )
 
 
+@functools.cache
+def _resolve_system_loaded_abs_path_in_subprocess(libname: str) -> str | None:
+    """Resolve a library's system-search absolute path in a child process.
+
+    This runs in a spawned (not forked) child process. Spawning is important
+    because it starts from a fresh interpreter state, so the child does not
+    inherit already-loaded CUDA dynamic libraries from the parent process
+    (especially the well-known canary probe library).
+
+    That keeps any side-effects of loading the canary library scoped to the
+    child process instead of polluting the current process, and ensures the
+    canary probe is an independent system-search attempt.
+    """
+    result = run_in_spawned_child_process(
+        probe_canary_abs_path_and_print_json,
+        args=(libname,),
+        timeout=10.0,
+        rethrow=True,
+    )
+
+    # Read the final non-empty stdout line in case earlier lines are emitted.
+    lines = [line for line in result.stdout.splitlines() if line.strip()]
+    if not lines:
+        raise RuntimeError(f"Canary probe child process produced no stdout payload for {libname!r}")
+    try:
+        payload = json.loads(lines[-1])
+    except json.JSONDecodeError:
+        raise RuntimeError(
+            f"Canary probe child process emitted invalid JSON payload for {libname!r}: {lines[-1]!r}"
+        ) from None
+    if isinstance(payload, str):
+        return payload
+    if payload is None:
+        return None
+    raise RuntimeError(f"Canary probe child process emitted unexpected payload for {libname!r}: {payload!r}")
+
+
+def _try_ctk_root_canary(finder: _FindNvidiaDynamicLib) -> str | None:
+    """Derive the CTK root from a system-installed canary lib.
+
+    For discoverable libs (currently nvvm) whose shared object doesn't reside
+    on the standard linker path, we locate a well-known CTK lib that IS on
+    the linker path via system search, derive the CTK installation root from
+    its resolved path, and then look for the target lib relative to that root.
+
+    The canary load is performed in a subprocess to avoid introducing loader
+    state into the current process.
+    """
+    for canary_libname in _CTK_ROOT_CANARY_ANCHOR_LIBNAMES:
+        canary_abs_path = _resolve_system_loaded_abs_path_in_subprocess(canary_libname)
+        if canary_abs_path is None:
+            continue
+        ctk_root = derive_ctk_root(canary_abs_path)
+        if ctk_root is None:
+            continue
+        abs_path: str | None = finder.try_via_ctk_root(ctk_root)
+        if abs_path is not None:
+            return abs_path
+    return None
+
+
 def _load_lib_no_cache(libname: str) -> LoadedDL:
     if libname in _DRIVER_ONLY_LIBNAMES:
         return _load_driver_lib_no_cache(libname)
@@ -90,11 +159,24 @@ def _load_lib_no_cache(libname: str) -> LoadedDL:
         loaded = load_with_system_search(libname)
         if loaded is not None:
             return loaded
+
         abs_path = finder.try_with_cuda_home()
-        if abs_path is None:
-            finder.raise_not_found_error()
-        else:
+        if abs_path is not None:
             found_via = "CUDA_HOME"
+        else:
+            if libname not in _CTK_ROOT_CANARY_DISCOVERABLE_LIBNAMES:
+                finder.raise_not_found_error()
+
+            # Canary probe (discoverable libs only): if the direct system
+            # search and CUDA_HOME both failed (e.g. nvvm isn't on the linker
+            # path and CUDA_HOME is unset), try to discover the CTK root by
+            # loading a well-known CTK lib in a subprocess, then look for the
+            # target lib relative to that root.
+            abs_path = _try_ctk_root_canary(finder)
+            if abs_path is not None:
+                found_via = "system-ctk-root"
+            else:
+                finder.raise_not_found_error()
 
     return load_with_abs_path(libname, abs_path, found_via)
 
@@ -164,6 +246,14 @@ def load_nvidia_dynamic_lib(libname: str) -> LoadedDL:
 
            - If set, use ``CUDA_HOME`` or ``CUDA_PATH`` (in that order).
 
+        5. **CTK root canary probe (discoverable libs only)**
+
+           - For selected libraries whose shared object doesn't reside on the
+             standard linker path (currently ``nvvm``),
+             attempt to discover the CTK installation root by system-loading a
+             well-known CTK library (``cudart``) in a subprocess, then derive
+             the root from its resolved absolute path.
+
     **Driver libraries** (``"cuda"``, ``"nvml"``):
 
         These are part of the NVIDIA display driver (not the CUDA Toolkit) and
 
@@ -358,6 +358,13 @@
 
 LIBNAMES_REQUIRING_RTLD_DEEPBIND = ("cufftMp",)
 
+# CTK root canary probe config:
+# - anchor libs: expected on the standard system loader path and used to derive
+#   CTK root in an isolated child process.
+# - discoverable libs: libs that are allowed to use the CTK-root canary fallback.
+_CTK_ROOT_CANARY_ANCHOR_LIBNAMES = ("cudart",)
+_CTK_ROOT_CANARY_DISCOVERABLE_LIBNAMES = ("nvvm",)
+
 # Based on output of toolshed/make_site_packages_libdirs_linux.py
 SITE_PACKAGES_LIBDIRS_LINUX_CTK = {
     "cublas": ("nvidia/cu13/lib", "nvidia/cublas/lib"),
 
@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
 import multiprocessing
@@ -24,13 +24,19 @@ class CompletedProcess:
 
 
 class ChildProcessWrapper:
-    def __init__(self, result_queue, target, args, kwargs):
+    def __init__(
+        self,
+        result_queue: Any,
+        target: Callable[..., None],
+        args: Sequence[Any] | None,
+        kwargs: dict[str, Any] | None,
+    ) -> None:
         self.target = target
         self.args = () if args is None else args
         self.kwargs = {} if kwargs is None else kwargs
         self.result_queue = result_queue
 
-    def __call__(self):
+    def __call__(self) -> None:
         # Capture stdout/stderr
         old_stdout = sys.stdout
         old_stderr = sys.stderr