@@ -41,23 +41,15 @@ cuda_bindings_13/cuda/bindings/_internal/runtime_ptds.pyx
 cuda_bindings_13/cuda/bindings/utils/_get_handle.pyx
 
 # CUDA 12 bindings source generation
-cuda_bindings_12/cuda/bindings/_bindings/cyruntime.pxd
-cuda_bindings_12/cuda/bindings/_bindings/cyruntime.pyx
-cuda_bindings_12/cuda/bindings/_bindings/cyruntime_ptds.pxd
-cuda_bindings_12/cuda/bindings/_bindings/cyruntime_ptds.pyx
 cuda_bindings_12/cuda/bindings/_internal/cufile.pyx
 cuda_bindings_12/cuda/bindings/_internal/driver.pyx
 cuda_bindings_12/cuda/bindings/_internal/nvfatbin.pyx
 cuda_bindings_12/cuda/bindings/_internal/nvjitlink.pyx
 cuda_bindings_12/cuda/bindings/_internal/nvml.pyx
 cuda_bindings_12/cuda/bindings/_internal/nvrtc.pyx
 cuda_bindings_12/cuda/bindings/_internal/nvvm.pyx
-cuda_bindings_12/cuda/bindings/cyruntime.pxd
-cuda_bindings_12/cuda/bindings/cyruntime.pyx
-cuda_bindings_12/cuda/bindings/cyruntime_functions.pxi
-cuda_bindings_12/cuda/bindings/cyruntime_types.pxi
-cuda_bindings_12/cuda/bindings/runtime.pxd
-cuda_bindings_12/cuda/bindings/runtime.pyx
+cuda_bindings_12/cuda/bindings/_internal/runtime.pyx
+cuda_bindings_12/cuda/bindings/_internal/runtime_ptds.pyx
 
 # Version files from setuptools_scm
 _version.py
 
@@ -15,9 +15,9 @@ intentional API, layout, and build differences.
 - Handwritten utilities, build helpers, tests, and documentation can be edited
   directly. Inspect headers and provenance; a filename extension alone does
   not identify generated code.
-- Source builds parse CUDA headers and expand `.in` templates before Cython.
-  Regenerate these outputs from their templates and headers. Preserve the
-  CUDA 12 parser, legacy APIs, and namespace redirector.
+- Source builds do not parse CUDA headers or expand templates; all binding
+  sources, including `runtime`, are pre-generated. Preserve the CUDA 12
+  legacy APIs and namespace redirector.
 
 ## Build and test guidance
 
 
@@ -2,7 +2,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 # This module implements basic PEP 517 backend support to defer CUDA-dependent
-# logic (header parsing, code generation, cythonization) to build time. See:
+# logic (cythonization) to build time. See:
 # - https://peps.python.org/pep-0517/
 # - https://setuptools.pypa.io/en/latest/build_meta.html#dynamic-build-dependencies-and-other-build-meta-tweaks
 # - https://github.com/NVIDIA/cuda-python/issues/1635
@@ -203,209 +203,6 @@ def record_build_toolchain() -> None:
     record_build_key(_BUILD_TOOLCHAIN_STAMP, name)
 
 
-# -----------------------------------------------------------------------
-# Header parsing helpers (called only from _build_cuda_bindings)
-
-_REQUIRED_HEADERS = {
-    "runtime": [
-        "driver_types.h",
-        "vector_types.h",
-        "cuda_runtime.h",
-        "surface_types.h",
-        "texture_types.h",
-        "library_types.h",
-        "cuda_runtime_api.h",
-        "device_types.h",
-        "driver_functions.h",
-        "cuda_profiler_api.h",
-    ],
-    # nvrtc: headers no longer parsed at build time (pre-generated by cybind).
-    # During compilation, Cython will reference C headers that are not
-    # explicitly parsed above. These are the known dependencies:
-    #
-    # - crt/host_defines.h
-    # - builtin_types.h
-    # - cuda_device_runtime_api.h
-}
-
-
-class _Struct:
-    def __init__(self, name, members):
-        self._name = name
-        self._member_names = []
-        self._member_types = []
-        self._member_declarators = []
-        for var_name, var_type, _ in members:
-            base_type = var_type[0]
-            base_type = base_type.removeprefix("struct ")
-            base_type = base_type.removeprefix("union ")
-
-            self._member_names += [var_name]
-            self._member_types += [base_type]
-            self._member_declarators += [tuple(var_type[1:])]
-
-    def member_type(self, member_name):
-        try:
-            return self._member_types[self._member_names.index(member_name)]
-        except ValueError:
-            return None
-
-    def member_array_length(self, member_name):
-        try:
-            declarators = self._member_declarators[self._member_names.index(member_name)]
-        except ValueError:
-            return None
-
-        for declarator in declarators:
-            if isinstance(declarator, list) and len(declarator) == 1:
-                return declarator[0]
-        return None
-
-    def discoverMembers(self, memberDict, prefix, seen=None):
-        if seen is None:
-            seen = set()
-        elif self._name in seen:
-            return []
-
-        discovered = []
-        next_seen = set(seen)
-        next_seen.add(self._name)
-
-        for memberName, memberType in zip(self._member_names, self._member_types):
-            if memberName:
-                discovered.append(".".join([prefix, memberName]))
-
-            t = memberType.replace("const ", "").replace("volatile ", "").strip().rstrip(" *")
-            if t in memberDict and t != self._name:
-                discovered += memberDict[t].discoverMembers(
-                    memberDict, discovered[-1] if memberName else prefix, next_seen
-                )
-
-        return discovered
-
-    def __repr__(self):
-        return f"{self._name}: {self._member_names} with types {self._member_types}"
-
-
-def _fetch_header_paths(required_headers, include_path_list):
-    header_dict = {}
-    missing_headers = []
-    for library, header_list in required_headers.items():
-        header_paths = []
-        for header in header_list:
-            path_candidate = [os.path.join(path, header) for path in include_path_list]
-            for path in path_candidate:
-                if os.path.exists(path):
-                    header_paths += [path]
-                    break
-            else:
-                missing_headers += [header]
-
-        header_dict[library] = header_paths
-
-    if missing_headers:
-        error_message = "Couldn't find required headers: "
-        error_message += ", ".join(missing_headers)
-        cuda_paths = _get_cuda_paths()
-        raise RuntimeError(f'{error_message}\nIs CUDA_HOME setup correctly? (CUDA_HOME="{cuda_paths}")')
-
-    return header_dict
-
-
-def _parse_headers(header_dict, include_path_list, parser_caching):
-    from pyclibrary import CParser
-
-    found_types = []
-    found_functions = []
-    found_values = []
-    found_struct = []
-    struct_list = {}
-
-    replace = {
-        " __device_builtin__ ": " ",
-        "CUDARTAPI ": " ",
-        "typedef __device_builtin__ enum cudaError cudaError_t;": "typedef cudaError cudaError_t;",
-        "typedef __device_builtin__ enum cudaOutputMode cudaOutputMode_t;": "typedef cudaOutputMode cudaOutputMode_t;",
-        "typedef enum cudaError cudaError_t;": "typedef cudaError cudaError_t;",
-        "typedef enum cudaOutputMode cudaOutputMode_t;": "typedef cudaOutputMode cudaOutputMode_t;",
-        "typedef enum cudaDataType_t cudaDataType_t;": "",
-        "typedef enum libraryPropertyType_t libraryPropertyType_t;": "",
-        "  enum ": "   ",
-        ", enum ": ", ",
-        "\\(enum ": "(",
-        # Since we only support 64 bit architectures, we can inline the sizeof(T*) to 8 and then compute the
-        # result in Python. The arithmetic expression is preserved to help with clarity and understanding
-        r"char reserved\[52 - sizeof\(CUcheckpointGpuPair \*\)\];": rf"char reserved[{52 - 8}];",
-        r"char reserved\[64 - sizeof\(CUcheckpointGpuPair \*\) - sizeof\(unsigned int\)\];": (
-            rf"char reserved[{64 - 8 - 4}];"
-        ),
-    }
-
-    print(f'Parsing headers in "{include_path_list}" (Caching = {parser_caching})', flush=True)
-    for library, header_paths in header_dict.items():
-        print(f"Parsing {library} headers", flush=True)
-        parser = CParser(
-            header_paths, cache="./cache_{}".format(library.split(".")[0]) if parser_caching else None, replace=replace
-        )
-
-        if library == "driver":
-            CUDA_VERSION = parser.defs["macros"].get("CUDA_VERSION", "Unknown")
-            print(f"Found CUDA_VERSION: {CUDA_VERSION}", flush=True)
-
-        found_types += {*parser.defs["types"]}
-        found_types += {*parser.defs["structs"]}
-        found_types += {*parser.defs["unions"]}
-        found_types += {*parser.defs["enums"]}
-        found_functions += {*parser.defs["functions"]}
-        found_values += {*parser.defs["values"]}
-
-        for key, value in parser.defs["structs"].items():
-            struct_list[key] = _Struct(key, value["members"])
-        for key, value in parser.defs["unions"].items():
-            struct_list[key] = _Struct(key, value["members"])
-
-        for key, value in struct_list.items():
-            if key.startswith("anon_union") or key.startswith("anon_struct"):
-                continue
-
-            found_struct += [key]
-            discovered = value.discoverMembers(struct_list, key)
-            if discovered:
-                found_struct += discovered
-
-    # TODO(#1312): make this work properly
-    found_types.append("CUstreamAtomicReductionDataType_enum")
-
-    return found_types, found_functions, found_values, found_struct, struct_list
-
-
-# -----------------------------------------------------------------------
-# Code generation helpers
-
-
-def _fetch_input_files(path):
-    return [os.path.join(path, f) for f in os.listdir(path) if f.endswith(".in")]
-
-
-def _generate_output(infile, template_vars):
-    from Cython import Tempita
-
-    assert infile.endswith(".in")
-    outfile = infile[:-3]
-
-    with open(infile, encoding="utf-8") as f:
-        pxdcontent = Tempita.Template(f.read()).substitute(template_vars)
-
-    if os.path.exists(outfile):
-        with open(outfile, encoding="utf-8") as f:
-            if f.read() == pxdcontent:
-                print(f"Skipping {infile} (No change)", flush=True)
-                return
-    with open(outfile, "w", encoding="utf-8") as f:
-        print(f"Generating {infile}", flush=True)
-        f.write(pxdcontent)
-
-
 # -----------------------------------------------------------------------
 # Extension preparation helpers
 
@@ -459,9 +256,8 @@ def _prep_extensions(sources, libraries, include_dirs, library_dirs, extra_compi
 def _build_cuda_bindings(debug=False):
     """Build all cuda-bindings extensions.
 
-    All CUDA-dependent logic (header parsing, code generation, cythonization)
-    is deferred to this function so that metadata queries do not require a
-    CUDA toolkit installation.
+    All CUDA-dependent logic (cythonization) is deferred to this function so
+    that metadata queries do not require a CUDA toolkit installation.
     """
     import Cython
     from Cython.Build import cythonize
@@ -485,7 +281,6 @@ def _build_cuda_bindings(debug=False):
     else:
         nthreads = int(os.environ.get("CUDA_PYTHON_PARALLEL_LEVEL", "0") or "0")
 
-    parser_caching = bool(os.environ.get("CUDA_PYTHON_PARSER_CACHING", False))
     compile_for_coverage = bool(int(os.environ.get("CUDA_PYTHON_COVERAGE", "0")))
 
     toolchain, _cc, _cxx, extra_compile_args, extra_link_args = _resolve_toolchain(
@@ -496,51 +291,8 @@ def _build_cuda_bindings(debug=False):
     if debug and sys.platform != "win32":
         extra_cythonize_kwargs["gdb_debug"] = True
 
-    # Parse CUDA headers
-    include_path_list = [os.path.join(path, "include") for path in cuda_paths]
-    header_dict = _fetch_header_paths(_REQUIRED_HEADERS, include_path_list)
-    found_types, found_functions, found_values, found_struct, struct_list = _parse_headers(
-        header_dict, include_path_list, parser_caching
-    )
-    struct_field_types = {}
-    struct_field_array_lengths = {}
-    for struct_name, struct in struct_list.items():
-        for member_name in struct._member_names:
-            key = f"{struct_name}.{member_name}"
-            struct_field_types[key] = struct.member_type(member_name)
-            struct_field_array_lengths[key] = struct.member_array_length(member_name)
-
-    # Generate code from .in templates
-    path_list = [
-        os.path.join("cuda"),
-        os.path.join("cuda", "bindings"),
-        os.path.join("cuda", "bindings", "_bindings"),
-        os.path.join("cuda", "bindings", "_internal"),
-        os.path.join("cuda", "bindings", "_lib"),
-        os.path.join("cuda", "bindings", "utils"),
-    ]
-    input_files = []
-    for path in path_list:
-        input_files += _fetch_input_files(path)
-
-    import platform
-
-    template_vars = {
-        "found_types": found_types,
-        "found_functions": found_functions,
-        "found_values": found_values,
-        "found_struct": found_struct,
-        "struct_list": struct_list,
-        "struct_field_types": struct_field_types,
-        "struct_field_array_lengths": struct_field_array_lengths,
-        "os": os,
-        "sys": sys,
-        "platform": platform,
-    }
-    for file in input_files:
-        _generate_output(file, template_vars)
-
     # Prepare compile/link arguments
+    include_path_list = [os.path.join(path, "include") for path in cuda_paths]
     include_dirs = [
         os.path.dirname(sysconfig.get_path("include")),
     ] + include_path_list
@@ -560,14 +312,19 @@ def _cleanup_dst_files():
 
     # Build extension list
     extensions = []
-    static_runtime_libraries = ["cudart_static", "rt"] if sys.platform == "linux" else ["cudart_static"]
     cuda_bindings_files = glob.glob("cuda/bindings/*.pyx")
     if sys.platform == "win32":
         cuda_bindings_files = [f for f in cuda_bindings_files if "cufile" not in f]
+
+    def get_static_libraries(f):
+        if os.path.basename(f) in ("runtime.pyx", "runtime_ptds.pyx"):
+            if sys.platform == "linux":
+                return ["cudart_static", "rt"]
+            else:
+                return ["cudart_static"]
+        return None
+
     sources_list = [
-        # private
-        (["cuda/bindings/_bindings/cyruntime.pyx"], static_runtime_libraries),
-        (["cuda/bindings/_bindings/cyruntime_ptds.pyx"], static_runtime_libraries),
         # utils
         (["cuda/bindings/utils/*.pyx"], None),
         # public
@@ -576,7 +333,7 @@ def _cleanup_dst_files():
         (["cuda/*.pyx"], None),
         # internal files used by generated bindings
         (["cuda/bindings/_internal/utils.pyx"], None),
-        *(([f], None) for f in dst_files if f.endswith(".pyx")),
+        *(([f], get_static_libraries(f)) for f in dst_files if f.endswith(".pyx")),
     ]
 
     for sources, libraries in sources_list: