@@ -87,6 +87,14 @@ except Exception as e:
     exit(1)
 "
 
+    # Require the CUDA backend and hardware instead of silently skipping these
+    # tests. Separate processes also exercise the output policy fixed at import.
+    for tensor_output in torch executorch; do
+        EXECUTORCH_PYBIND_TEST_REQUIRE_CUDA=1 \
+        EXECUTORCH_PYBINDINGS_TENSOR_OUTPUT="$tensor_output" \
+            python extension/pybindings/test/test_pybindings_cuda_dlpack.py -v
+    done
+
     echo "SUCCESS: ExecuTorch CUDA ${cuda_version} build and verification completed successfully"
 }
 
 
@@ -51,17 +51,16 @@ def test_cuda_builds_take_the_node_driver_on_an_unpinned_v3(self):
         for pin in ("test-infra-ref", "driver-version", "driver-download-url"):
             self.assertNotIn(pin, job["with"])
 
-    def test_cuda134_runtime_update_precedes_build_and_propagates_failure(self):
+    def test_cuda_runtime_update_precedes_build_and_propagates_failure(self):
         script = WORKFLOW["jobs"]["test-cuda-builds"]["with"]["script"]
         stubs = """
 conda() { printf 'CONDA %s\n' "$*"; return "$CONDA_STATUS"; }
-source() { printf 'BUILD %s\n' "$*"; }
+source() { printf 'BUILD %s\n' "$*"; printf 'LIBRARY PATH %s\n' "$LD_LIBRARY_PATH"; }
 """
         for version, conda_status in (
-            ("12.6", 0),
-            ("13.0", 0),
-            ("13.4", 0),
-            ("13.4", 1),
+            (version, status)
+            for version in ("12.6", "13.0", "13.4")
+            for status in (0, 1)
         ):
             with self.subTest(version=version, conda_status=conda_status):
                 result = subprocess.run(
@@ -70,19 +69,26 @@ def test_cuda134_runtime_update_precedes_build_and_propagates_failure(self):
                         "-c",
                         stubs + script.replace("${{ matrix.cuda-version }}", version),
                     ],
-                    env={**os.environ, "CONDA_STATUS": str(conda_status)},
+                    env={
+                        **os.environ,
+                        "CONDA_STATUS": str(conda_status),
+                        "LD_LIBRARY_PATH": "/cuda/lib64",
+                    },
                     capture_output=True,
                     text=True,
                 )
                 self.assertEqual(result.returncode, conda_status, result.stderr)
-                expected = []
-                if version == "13.4":
-                    expected.append(
-                        "CONDA install -y -n base -c conda-forge "
-                        "libstdcxx-ng=16.2.0 libgcc-ng=16.2.0"
-                    )
+                expected = [
+                    "CONDA install -y -n base -c conda-forge "
+                    "libstdcxx-ng=16.2.0 libgcc-ng=16.2.0"
+                ]
                 if conda_status == 0:
-                    expected.append(f"BUILD .ci/scripts/test-cuda-build.sh {version}")
+                    expected.extend(
+                        (
+                            f"BUILD .ci/scripts/test-cuda-build.sh {version}",
+                            "LIBRARY PATH /opt/conda/lib:/cuda/lib64",
+                        )
+                    )
                 self.assertEqual(result.stdout.splitlines(), expected)
 
     def test_cuda_probe_checks_the_result_and_torch_train(self):
 
@@ -10,11 +10,11 @@
 The Windows CUDA wheel ships the CUDA delegate for C++ applications only. A CUDA program
 cannot be lowered on Windows, since lowering compiles the model with a toolchain that only
 the Linux side has, so a Windows user exports on Linux (or WSL) and runs the program with
-this wheel. The Python extension therefore carries no CUDA dependency at all, and the
+this wheel. The Python extension uses the shipped CUDA helper for tensor interchange, and the
 checks here hold both halves of that:
 
   the CUDA DLLs ship, with import libraries a C++ consumer links
-  the Python extension depends on no CUDA DLL, so importing the package needs no CUDA
+  the Python extension needs no CUDA runtime DLL, so importing the package needs no CUDA
   the delegate registers in a C++ application linking executorch::backend_cuda
   the device code covers the GPUs the row claims
   a program exported on Linux for a Windows target runs through the C++ SDK and matches eager
@@ -209,30 +209,28 @@ def test_cuda_libraries_are_shipped() -> None:
     print(f"✓ the CUDA DLLs and their import libraries ship ({len(expected)} files)")
 
 
-def test_python_extension_carries_no_cuda() -> None:
-    """The Python extension must depend on no CUDA DLL.
-
-    CUDA programs are lowered on Linux, so the Windows extension has nothing to do with the
-    delegate, and depending on it would make importing the package fail on a machine
-    without the CUDA runtime.
-    """
+def test_python_extension_requires_no_cuda_runtime() -> None:
+    """The bindings and their shipped helper must import without a CUDA toolkit."""
     import test_shared_libraries
 
     package = _package_dir()
     extensions = sorted((package / "extension" / "pybindings").glob("_C.*.pyd"))
     assert len(extensions) == 1, f"expected one _C extension, found {extensions}"
-    dependents = {
-        name.lower() for name in test_shared_libraries._pe_dependents(extensions[0])
-    }
-    cuda = sorted(
-        name
-        for name in dependents
-        if "cuda" in name or name.startswith(("cudart", "cublas", "nvrtc"))
-    )
-    assert not cuda, (
-        f"{extensions[0].name} depends on {cuda}, so the Python side of the Windows wheel "
-        "carries CUDA it cannot use and fails to import without the CUDA runtime"
-    )
+    helper = package / "lib" / "executorch_extension_cuda.dll"
+    for library in (extensions[0], helper):
+        dependents = {
+            name.lower() for name in test_shared_libraries._pe_dependents(library)
+        }
+        cuda = sorted(
+            name
+            for name in dependents
+            if ("cuda" in name or name.startswith(("cudart", "cublas", "nvrtc")))
+            and name != helper.name.lower()
+        )
+        assert not cuda, (
+            f"{library.name} imports {cuda}, so importing the bindings would "
+            "require CUDA libraries outside the wheel"
+        )
     from executorch.extension.pybindings.portable_lib import (
         _get_registered_backend_names,
     )
@@ -243,7 +241,7 @@ def test_python_extension_carries_no_cuda() -> None:
         "Windows wheel does not ship it for"
     )
     print(
-        f"✓ {extensions[0].name} depends on no CUDA DLL and registers no CUDA backend"
+        f"✓ {extensions[0].name} requires no CUDA runtime DLL and registers no CUDA backend"
     )
 
 
@@ -628,7 +626,7 @@ def export(destination: str) -> None:
         test_clean_install.run_tests(Path(work_dir))
 
     test_cuda_libraries_are_shipped()
-    test_python_extension_carries_no_cuda()
+    test_python_extension_requires_no_cuda_runtime()
     test_cuda_runtime_is_linked_statically()
     test_device_code_covers_the_row()
     with tempfile.TemporaryDirectory() as work_dir:
 
@@ -120,6 +120,7 @@ jobs:
       contains(needs.changed-files.outputs.changed-files, 'backends/cuda') ||
       contains(needs.changed-files.outputs.changed-files, 'backends/aoti') ||
         contains(needs.changed-files.outputs.changed-files, 'extension/cuda') ||
+      contains(needs.changed-files.outputs.changed-files, 'extension/pybindings') ||
       contains(needs.changed-files.outputs.changed-files, '.github/workflows/cuda.yml') ||
       contains(needs.changed-files.outputs.changed-files, '.ci/scripts/test-cuda-build.sh') ||
       contains(needs.changed-files.outputs.changed-files, '.ci/scripts/export_model_artifact.sh') ||
@@ -145,10 +146,10 @@ jobs:
       script: |
         set -eux
 
-        if [ "${{ matrix.cuda-version }}" = "13.4" ]; then
-          # The image's older Conda runtime aborts during CUDA thread-local cleanup.
-          conda install -y -n base -c conda-forge 'libstdcxx-ng=16.2.0' 'libgcc-ng=16.2.0'
-        fi
+        # AOTI model libraries need a newer C++ runtime than the 12.6 image's
+        # system library; the 13.4 image also needs the thread-local cleanup fix.
+        conda install -y -n base -c conda-forge 'libstdcxx-ng=16.2.0' 'libgcc-ng=16.2.0'
+        export LD_LIBRARY_PATH="/opt/conda/lib${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
         source .ci/scripts/test-cuda-build.sh "${{ matrix.cuda-version }}"
 
   # This job will fail if any of the CUDA versions fail
@@ -164,6 +165,7 @@ jobs:
         contains(needs.changed-files.outputs.changed-files, 'backends/cuda') ||
         contains(needs.changed-files.outputs.changed-files, 'backends/aoti') ||
         contains(needs.changed-files.outputs.changed-files, 'extension/cuda') ||
+        contains(needs.changed-files.outputs.changed-files, 'extension/pybindings') ||
         contains(needs.changed-files.outputs.changed-files, '.github/workflows/cuda.yml') ||
         contains(needs.changed-files.outputs.changed-files, '.ci/scripts/test-cuda-build.sh') ||
         contains(needs.changed-files.outputs.changed-files, '.ci/scripts/export_model_artifact.sh') ||
 
@@ -176,6 +176,17 @@ jobs:
         python -m examples.portable.scripts.export \
           --model_name=add \
           --output_dir=cmake-out-no-aten
+        python - <<'PY'
+        from pathlib import Path
+
+        from executorch.extension.pybindings.test.make_test import (
+            create_program,
+            ModuleAddBFloat16,
+        )
+
+        program, _ = create_program(ModuleAddBFloat16())
+        Path("cmake-out-no-aten/add_bfloat16.pte").write_bytes(bytes(program.buffer))
+        PY
         EXECUTORCH_PYBIND_TEST_PTE=cmake-out-no-aten/add.pte \
           PYTHONPATH=cmake-out-no-aten:.. \
           python extension/pybindings/test/test_pybindings_no_aten.py \
@@ -187,11 +198,13 @@ jobs:
             PybindingsNoAtenTest.test_executorch_output_is_sticky_after_torch_import
         python -m pip uninstall -y torch torchvision torchaudio
         EXECUTORCH_PYBIND_TEST_PTE=cmake-out-no-aten/add.pte \
+          EXECUTORCH_PYBIND_TEST_BFLOAT16_PTE=cmake-out-no-aten/add_bfloat16.pte \
           PYTHONPATH=cmake-out-no-aten:.. \
           python extension/pybindings/test/test_pybindings_no_aten.py \
             PybindingsNoAtenTest.test_output_policy_without_torch
         EXECUTORCH_PYBINDINGS_TENSOR_OUTPUT=executorch \
           EXECUTORCH_PYBIND_TEST_PTE=cmake-out-no-aten/add.pte \
+          EXECUTORCH_PYBIND_TEST_BFLOAT16_PTE=cmake-out-no-aten/add_bfloat16.pte \
           PYTHONPATH=cmake-out-no-aten:.. \
           python extension/pybindings/test/test_pybindings_no_aten.py
         if ldd cmake-out-no-aten/_C*.so | grep -Eiq 'torch|aten|c10'; then
 
@@ -1457,6 +1457,10 @@ if(EXECUTORCH_BUILD_PYBIND)
     target_compile_options(portable_lib PRIVATE -fvisibility-inlines-hidden)
   endif()
   target_link_libraries(portable_lib PRIVATE ${_dep_libs})
+  if(TARGET extension_cuda)
+    target_link_libraries(portable_lib PRIVATE extension_cuda)
+    target_compile_definitions(portable_lib PRIVATE EXECUTORCH_PYBINDINGS_CUDA)
+  endif()
   executorch_target_link_shared_runtime(portable_lib)
   # These libraries register their operators or their backend from a static
   # initializer, so nothing here references a symbol from them and some linkers
 
@@ -16,6 +16,11 @@ fbcode_target(_kind = runtime.export_file,
     visibility = ["//executorch/extension/pybindings/..."],
 )
 
+fbcode_target(_kind = runtime.export_file,
+    name = "pybindings_cuda.h",
+    visibility = ["//executorch/extension/pybindings/..."],
+)
+
 fbcode_target(_kind = runtime.export_file,
     name = "pybindings_dlpack.h",
     visibility = ["//executorch/extension/pybindings/..."],
 
@@ -13,24 +13,32 @@ pip install . --no-build-isolation
 Portable bindings do not link against ATen or PyTorch. CPU inputs may be NumPy
 arrays or other dense objects implementing Python's buffer protocol. CPU and
 CUDA `torch.Tensor` inputs are inspected through their public Python attributes
-instead of being cast to `at::Tensor`; CUDA pointers retain their device index.
+instead of being cast to `at::Tensor`. DLPack producers, including CuPy, can
+provide CPU or CUDA allocations directly; their device indices are preserved.
+Tensor protocols can be mixed within the same call.
 
-Portable Torch inputs must have dense strides compatible with the exported
-method input's dimension order. This includes channels last and channels last
-3D layouts when the model was exported with those layouts. Strides on singleton
-dimensions are normalized to the exported layout without copying tensor data.
+Tensor inputs must have dense storage laid out for the exported method's
+dimension order. Stride compatibility checks are deferred; the bindings interpret
+Torch and DLPack tensor storage using the exported layout without copying data.
+CUDA inputs require a method
+exported with CUDA inputs and `MemoryPlanningPass(alloc_graph_input=False)` so
+execution can share the caller's device allocation.
 
 When PyTorch is available, importing `portable_lib` imports it and portable
-bindings create output tensors through its public Python API. When it cannot be
-imported, the default output type is `ExecuTorchResult`. The extension itself does not link against ATen or PyTorch.
-CUDA outputs use a private DLPack capsule consumed by `torch.from_dlpack`, and
-`clone_outputs=True` copies them through Torch on their original CUDA device.
-The `executorch` output mode supports CPU buffers; CUDA outputs require the
-default Torch output mode.
+bindings return `torch.Tensor` outputs. When it cannot be imported, the default
+output type is `ExecuTorchResult`. Output conversion uses Python APIs and
+DLPack; the extension does not link against PyTorch.
+`clone_outputs=True` returns independent storage on the output's original
+device. With `clone_outputs=False`, results share runtime or input storage and
+later execution may overwrite that storage.
+
+Calls on a shared method or module are serialized. A sequence of separate
+`set_inputs`, `execute`, and `get_outputs` calls requires caller synchronization
+when each thread needs its own inputs and outputs.
 
 To select `ExecuTorchResult` outputs even when PyTorch is installed, set the
-environment variable before importing the bindings. The setting is fixed when the extension loads, so importing PyTorch
-later does not change the output type.
+environment variable before importing the bindings. The setting is fixed when
+the extension loads, so importing PyTorch later does not change the output type.
 
 ```python
 import os
@@ -39,15 +47,48 @@ os.environ["EXECUTORCH_PYBINDINGS_TENSOR_OUTPUT"] = "executorch"
 from executorch.extension.pybindings import portable_lib
 ```
 
-`ExecuTorchResult` exposes shape, strides, dtype, and the Python buffer protocol
-so NumPy can read it without another copy. Explicitly setting the environment
-variable to `torch` requires PyTorch to import successfully. ATen-mode bindings continue to return native PyTorch tensors directly.
+`ExecuTorchResult` preserves shape, strides, dtype, and device. CPU results expose
+the Python buffer protocol so NumPy can read them without another copy. Without
+the environment setting, the bindings fall back to `ExecuTorchResult` if
+PyTorch cannot be imported. Explicitly selecting `torch` requires it to import
+successfully. ATen-mode bindings continue to return native PyTorch tensors
+directly.
 
 ```python
 output = module.forward([numpy_input])[0]
 result = np.asarray(output)
 ```
 
+CPU and CUDA results implement `__dlpack__` and `__dlpack_device__`. CUDA results
+remain on CUDA and can be passed to another DLPack consumer or back into
+ExecuTorch without moving the data to the CPU.
+
+CUDA DLPack inputs and `ExecuTorchResult` outputs require CUDA-enabled bindings.
+Torch CUDA inputs and outputs synchronize through Python Torch, including in
+CPU builds of the bindings. The Python CUDA execution boundary waits for device
+work because the device allocator does not expose readiness events.
+Execution is synchronous at this boundary, including producer and consumer
+stream readiness. The synchronization has no C++ ATen dependency.
+
+For bfloat16 inputs, raw byte buffers use the shape declared by the exported
+method. Bfloat16 results expose flat bytes through the buffer protocol because
+NumPy and PEP 3118 do not define that numeric dtype. DLPack consumers receive the
+original bfloat16 dtype and tensor shape.
+
+```python
+import cupy as cp
+
+cuda_input = cp.ones((1, 3, 224, 224), dtype=cp.float32)
+output = cuda_module.forward([cuda_input], clone_outputs=False)[0]
+cuda_output = cp.from_dlpack(output)
+```
+
+The CUDA build workflow runs `test_pybindings_cuda_dlpack.py` in both output
+modes on a GPU. It checks device allocations, DLPack stream ordering, channels
+last views, cloning, and borrowed output lifetimes using a CUDA delegate.
+Set `EXECUTORCH_PYBIND_TEST_REQUIRE_CUDA=1` when running this test to treat missing
+GPU hardware or a missing CUDA backend as a failure.
+
 # Link Backends
 
 Not all backends are built into the pip wheel by default. You can link these missing/experimental backends by turning on the corresponding cmake flag. For example, to include the Vulkan backend:
@@ -68,9 +109,8 @@ CMAKE_ARGS="-DEXECUTORCH_BUILD_VULKAN=ON" ./install_executorch.sh
 ## Classes
 ### ExecuTorchModule
 - `plan_execute()`: Plan and execute.
-- `run_method()`: Run a method with either PyTorch tensors or objects that
-  implement Python's buffer protocol, such as NumPy arrays. A call must use a
-  single tensor protocol; PyTorch tensors and buffers cannot be mixed.
+- `run_method()`: Run a method with PyTorch tensors, Python buffer objects such
+  as NumPy arrays, or DLPack producers, including mixed tensor protocols.
 - `forward()`: Forward. A single buffer may be passed directly; multiple
   inputs are passed as a flat sequence.
 - `has_etdump()`: Check if etdump is available.
@@ -80,6 +120,4 @@ CMAKE_ARGS="-DEXECUTORCH_BUILD_VULKAN=ON" ./install_executorch.sh
 This class is currently empty and serves as a placeholder for future methods and attributes.
 - `verify_result_with_bundled_expected_output(method_name: str, testset_idx: int, rtol: float = 1e-5, atol: float = 1e-8)`: Verify result with bundled expected output.
 ## Note
-Calls on a shared method or module are serialized. A sequence of separate
-`set_inputs`, `execute`, and `get_outputs` calls requires caller synchronization
-when each thread needs its own inputs and outputs.
+Runtime logs are forwarded to Python stderr.
Original file line number	Diff line number	Diff line change
`@@ -87,6 +87,14 @@ except Exception as e:`
`87`	`87`	`exit(1)`
`88`	`88`	`"`
`89`	`89`
	`90`	`+ # Require the CUDA backend and hardware instead of silently skipping these`
	`91`	`+ # tests. Separate processes also exercise the output policy fixed at import.`
	`92`	`+ for tensor_output in torch executorch; do`
	`93`	`+ EXECUTORCH_PYBIND_TEST_REQUIRE_CUDA=1 \`
	`94`	`+ EXECUTORCH_PYBINDINGS_TENSOR_OUTPUT="$tensor_output" \`
	`95`	`+ python extension/pybindings/test/test_pybindings_cuda_dlpack.py -v`
	`96`	`+ done`
	`97`	`+`
`90`	`98`	`echo "SUCCESS: ExecuTorch CUDA ${cuda_version} build and verification completed successfully"`
`91`	`99`	`}`
`92`	`100`