@@ -121,31 +121,6 @@ def _determine_cuda_major_version() -> str:
     )
 
 
-@functools.cache
-def _cuda_core_has_localized_location() -> bool:
-    """Whether CUmemLocation exposes the ``localized`` union arm (CUDA 13.4+).
-
-    CUDA 13.4 adds ``CUmemLocation.localized`` and
-    ``CU_MEM_LOCATION_TYPE_DEVICE_LOCALITY_DOMAIN``. This flag is independent of
-    ``CUDA_CORE_BUILD_MAJOR`` so 13.3 and 13.4 can share a major version while
-    still compiling different ``to_cumemlocation`` signatures.
-    """
-    override = os.environ.get("CUDA_CORE_HAS_LOCALIZED_LOCATION")
-    if override is not None:
-        return bool(int(override))
-    cuda_path = _get_cuda_path()
-    cuda_h = os.path.join(cuda_path, "include", "cuda.h")
-    try:
-        with open(cuda_h, encoding="utf-8") as f:
-            for line in f:
-                m = re.match(r"^#\s*define\s+CUDA_VERSION\s+(\d+)\s*$", line)
-                if m:
-                    return int(m.group(1)) >= 13040
-    except OSError:
-        pass
-    return False
-
-
 # used later by setup()
 _extensions = None
 
@@ -245,10 +220,7 @@ def get_sources(mod_name):
     )
 
     nthreads = int(os.environ.get("CUDA_PYTHON_PARALLEL_LEVEL", os.cpu_count() // 2))
-    compile_time_env = {
-        "CUDA_CORE_BUILD_MAJOR": int(_determine_cuda_major_version()),
-        "CUDA_CORE_HAS_LOCALIZED_LOCATION": int(_cuda_core_has_localized_location()),
-    }
+    compile_time_env = {"CUDA_CORE_BUILD_MAJOR": int(_determine_cuda_major_version())}
     compiler_directives = {"embedsignature": True, "warn.deprecated.IF": False, "freethreading_compatible": True}
     _CythonOptions.warning_errors = True
     if COMPILE_FOR_COVERAGE:
 
@@ -5,7 +5,7 @@
 from __future__ import annotations
 
 from cuda.bindings cimport cydriver
-from cuda.core._memory._location cimport to_cumemlocation
+from cuda.core._memory._location cimport cumemlocation_from_type
 from cuda.core._memory._memory_pool cimport (
     _MemPool, MP_init_create_pool, MP_raise_release_threshold,
 )
@@ -322,7 +322,8 @@ cpdef str DMR_mempool_get_access(DeviceMemoryResource dmr, int device_id):
 
     cdef int dev_id = Device(device_id).device_id
     cdef cydriver.CUmemAccess_flags flags
-    cdef cydriver.CUmemLocation location = to_cumemlocation("device", dev_id)
+    cdef cydriver.CUmemLocation location = cumemlocation_from_type(
+        cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_DEVICE, dev_id)
 
     with nogil:
         HANDLE_RETURN(cydriver.cuMemPoolGetAccess(&flags, as_cu(dmr._h_pool), &location))
 
@@ -2,69 +2,64 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-# Conversion from the internal ``_LocSpec`` record produced by
-# ``_managed_location._coerce_location`` to the driver's ``CUmemLocation``.
+# Conversion helpers for the driver's ``CUmemLocation`` struct.
 #
 # Header-only so both the managed-memory ops and the batched copy path can
 # cimport it without either module depending on the other. ``CUmemLocation``
 # is only populated on a CUDA 13 build; the CUDA 12 stub exists so callers
 # compiled there still resolve the symbol.
 #
-# Construction uses field assignment rather than Cython struct literals so
-# the same source compiles against both the CUDA 13.3 two-member declaration
-# and the CUDA 13.4 declaration that adds the ``localized`` union arm.
-# ``CUDA_CORE_HAS_LOCALIZED_LOCATION`` selects a helper signature with an
-# optional ``localized`` argument (13.4+) or without it (13.3). Passing
-# ``localized=...`` is therefore a Cython compile-time error on 13.3.
+# Both helpers use field assignment rather than Cython struct literals
+# (``CUmemLocation(type=..., id=...)``) so this source keeps compiling if a
+# future generated ``cydriver.pxd`` adds a sibling member to the struct's
+# anonymous union (e.g. CUDA 13.4's ``localized`` arm): Cython's struct-literal
+# coercion warns "Not all members given for struct" whenever a call site does
+# not name every declared member, and cuda_core promotes that warning to a
+# build error.
 
 from cuda.bindings cimport cydriver
 
 
 IF CUDA_CORE_BUILD_MAJOR >= 13:
-    cdef inline void _fill_id_location(
-        cydriver.CUmemLocation* cu_loc, str kind, int loc_id
-    ) except *:
+    cdef inline cydriver.CUmemLocation cumemlocation_from_type(
+        cydriver.CUmemLocationType loc_type, int loc_id
+    ):
+        """Build a ``CUmemLocation`` from an already-known ``CUmemLocationType``.
+
+        For call sites that already carry a ``CUmemLocationType`` value
+        (e.g. from a pool-configuration parameter), rather than the
+        ``kind`` string used by :func:`to_cumemlocation`.
+        """
+        cdef cydriver.CUmemLocation cu_loc
+        cu_loc.type = loc_type
+        cu_loc.id = loc_id
+        return cu_loc
+
+    cdef inline cydriver.CUmemLocation to_cumemlocation(str kind, int loc_id):
         if kind == "device":
-            cu_loc.type = cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_DEVICE
-            cu_loc.id = loc_id
+            return cumemlocation_from_type(
+                cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_DEVICE, loc_id)
         elif kind == "host":
-            cu_loc.type = cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_HOST
-            cu_loc.id = 0
+            return cumemlocation_from_type(
+                cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_HOST, 0)
         elif kind == "host_numa":
-            cu_loc.type = cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_HOST_NUMA
-            cu_loc.id = loc_id
+            return cumemlocation_from_type(
+                cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_HOST_NUMA, loc_id)
         elif kind == "host_numa_current":
-            cu_loc.type = cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_HOST_NUMA_CURRENT
-            cu_loc.id = 0
+            return cumemlocation_from_type(
+                cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_HOST_NUMA_CURRENT, 0)
         else:
             raise ValueError(f"unknown location kind: {kind!r}")
-
-    IF CUDA_CORE_HAS_LOCALIZED_LOCATION:
-        cdef inline cydriver.CUmemLocation to_cumemlocation(
-            str kind, int loc_id=0, tuple localized=None
-        ):
-            cdef cydriver.CUmemLocation cu_loc
-            if kind == "device_locality_domain":
-                if localized is None:
-                    raise ValueError(
-                        "kind='device_locality_domain' requires "
-                        "localized=(device_id, locality_domain_id)"
-                    )
-                cu_loc.type = (
-                    cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_DEVICE_LOCALITY_DOMAIN
-                )
-                cu_loc.localized.deviceId = localized[0]
-                cu_loc.localized.localityDomainId = localized[1]
-                return cu_loc
-            _fill_id_location(&cu_loc, kind, loc_id)
-            return cu_loc
-    ELSE:
-        cdef inline cydriver.CUmemLocation to_cumemlocation(str kind, int loc_id=0):
-            cdef cydriver.CUmemLocation cu_loc
-            _fill_id_location(&cu_loc, kind, loc_id)
-            return cu_loc
 ELSE:
-    cdef inline cydriver.CUmemLocation to_cumemlocation(str kind, int loc_id=0):
+    cdef inline cydriver.CUmemLocation cumemlocation_from_type(
+        cydriver.CUmemLocationType loc_type, int loc_id
+    ):
+        cdef cydriver.CUmemLocation cu_loc
+        cu_loc.type = loc_type
+        cu_loc.id = loc_id
+        return cu_loc
+
+    cdef inline cydriver.CUmemLocation to_cumemlocation(str kind, int loc_id):
         raise NotImplementedError(
             "CUmemLocation requires cuda.core built against CUDA 13 headers"
         )
@@ -13,8 +13,10 @@ IF CUDA_CORE_BUILD_MAJOR >= 13:
 from cuda.bindings cimport cydriver
 from cuda.core._memory._buffer cimport Buffer, Buffer_coerce_batch
 
-# to_cumemlocation is referenced only from CUDA 13 branches. cython-lint does
-# not evaluate compile-time IF blocks, so it needs a pragma to be seen as used.
+# to_cumemlocation / cumemlocation_from_type are referenced only from CUDA 13
+# branches. cython-lint does not evaluate compile-time IF blocks, so they
+# need a pragma to be seen as used.
+from cuda.core._memory._location cimport cumemlocation_from_type  # no-cython-lint
 from cuda.core._memory._location cimport to_cumemlocation  # no-cython-lint
 from cuda.core._resource_handles cimport as_cu
 from cuda.core._stream cimport Stream, Stream_accept
@@ -193,7 +195,8 @@ cdef void _do_single_advise(Buffer buf, object advice_value, object loc, bint al
             # Driver ignores location for read_mostly / unset_preferred_location
             # advice values but still validates the CUmemLocation; pass a
             # host placeholder.
-            cu_loc = to_cumemlocation("host", 0)
+            cu_loc = cumemlocation_from_type(
+                cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_HOST, 0)
         else:
             cu_loc = to_cumemlocation(loc.kind, loc.id)
         with nogil:
 
@@ -12,6 +12,9 @@ from libc.string cimport memset
 from cuda.bindings cimport cydriver
 from cuda.core._memory._buffer cimport Buffer, Buffer_from_deviceptr_handle, MemoryResource
 from cuda.core._memory cimport _ipc
+# cumemlocation_from_type is referenced only from CUDA 13 branches. cython-lint
+# does not evaluate compile-time IF blocks, so it needs a pragma to be seen as used.
+from cuda.core._memory._location cimport cumemlocation_from_type  # no-cython-lint
 from cuda.core._stream cimport Stream_accept, Stream
 from cuda.core._resource_handles cimport (
     MemoryPoolHandle,
@@ -279,8 +282,7 @@ cdef int MP_init_current_pool(
     """
     IF CUDA_CORE_BUILD_MAJOR >= 13:
         cdef cydriver.CUmemoryPool pool
-        cdef cydriver.CUmemLocation loc = cydriver.CUmemLocation(
-            type=loc_type, id=loc_id)
+        cdef cydriver.CUmemLocation loc = cumemlocation_from_type(loc_type, loc_id)
         with nogil:
             HANDLE_RETURN(cydriver.cuMemGetMemPool(&pool, &loc, alloc_type))
         self._h_pool = create_mempool_handle_ref(pool)
 
@@ -10,7 +10,7 @@ from typing import TYPE_CHECKING, Any
 
 from cuda.bindings cimport cydriver
 from cuda.core._memory._device_memory_resource cimport DeviceMemoryResource
-from cuda.core._memory._location cimport to_cumemlocation
+from cuda.core._memory._location cimport cumemlocation_from_type
 from cuda.core._resource_handles cimport as_cu
 from cuda.core._utils.cuda_utils cimport HANDLE_RETURN
 from cpython.mem cimport PyMem_Malloc, PyMem_Free
@@ -114,7 +114,8 @@ cdef inline tuple _query_peer_access_ids(DeviceMemoryResource mr):
 cdef inline bint _peer_access_includes(DeviceMemoryResource mr, int dev_id):
     """Return True if peer access from ``dev_id`` is currently granted."""
     cdef cydriver.CUmemAccess_flags flags
-    cdef cydriver.CUmemLocation location = to_cumemlocation("device", dev_id)
+    cdef cydriver.CUmemLocation location = cumemlocation_from_type(
+        cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_DEVICE, dev_id)
     with nogil:
         HANDLE_RETURN(cydriver.cuMemPoolGetAccess(&flags, as_cu(mr._h_pool), &location))
     return flags == cydriver.CUmemAccess_flags.CU_MEM_ACCESS_FLAGS_PROT_READWRITE
 
@@ -21,7 +21,7 @@ from cuda.core._event cimport Event
 from cuda.core._kernel_arg_handler cimport ParamHolder
 from cuda.core._launch_config cimport LaunchConfig
 from cuda.core._memory._buffer cimport Buffer
-from cuda.core._memory._location cimport to_cumemlocation
+from cuda.core._memory._location cimport cumemlocation_from_type
 from cuda.core._module cimport Kernel
 from cuda.core.graph._graph_definition cimport GraphCondition, GraphDefinition
 from cuda.core.graph._subclasses cimport (
@@ -836,7 +836,8 @@ cdef inline AllocNode GN_alloc(GraphNode self, size_t size, object device,
             peer_id = getattr(peer_dev, 'device_id', peer_dev)
             peer_ids.append(peer_id)
             access_descs.push_back(cydriver.CUmemAccessDesc_st(
-                to_cumemlocation("device", peer_id),
+                cumemlocation_from_type(
+                    cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_DEVICE, peer_id),
                 cydriver.CUmemAccess_flags.CU_MEM_ACCESS_FLAGS_PROT_READWRITE,
             ))
 
 
@@ -100,7 +100,6 @@ def _check_version_detection(
 
         build_hooks._get_cuda_path.cache_clear()
         build_hooks._determine_cuda_major_version.cache_clear()
-        build_hooks._cuda_core_has_localized_location.cache_clear()
         get_cuda_path_or_home.cache_clear()
 
         mock_env = {
@@ -126,7 +125,6 @@ def test_env_var_override(self, version):
         """CUDA_CORE_BUILD_MAJOR env var override works with various versions."""
         build_hooks._get_cuda_path.cache_clear()
         build_hooks._determine_cuda_major_version.cache_clear()
-        build_hooks._cuda_core_has_localized_location.cache_clear()
         get_cuda_path_or_home.cache_clear()
         with mock.patch.dict(os.environ, {"CUDA_CORE_BUILD_MAJOR": version}, clear=False):
             result = build_hooks._determine_cuda_major_version()
@@ -161,61 +159,9 @@ def test_missing_cuda_path_raises_error(self):
         """RuntimeError is raised when CUDA_PATH/CUDA_HOME not set and no env var override."""
         build_hooks._get_cuda_path.cache_clear()
         build_hooks._determine_cuda_major_version.cache_clear()
-        build_hooks._cuda_core_has_localized_location.cache_clear()
         get_cuda_path_or_home.cache_clear()
         with (
             mock.patch.dict(os.environ, {}, clear=True),
             pytest.raises(RuntimeError, match="CUDA_PATH or CUDA_HOME"),
         ):
             build_hooks._determine_cuda_major_version()
-
-
-def _check_localized_location_detection(cuda_version, expected, *, env_override=None):
-    """Test localized-arm detection with a mock cuda.h."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        include_dir = Path(tmpdir) / "include"
-        include_dir.mkdir()
-        (include_dir / "cuda.h").write_text(f"#define CUDA_VERSION {cuda_version}\n")
-
-        build_hooks._get_cuda_path.cache_clear()
-        build_hooks._cuda_core_has_localized_location.cache_clear()
-        get_cuda_path_or_home.cache_clear()
-
-        mock_env = {"CUDA_PATH": tmpdir}
-        if env_override is not None:
-            mock_env["CUDA_CORE_HAS_LOCALIZED_LOCATION"] = env_override
-
-        with mock.patch.dict(os.environ, mock_env, clear=True):
-            assert build_hooks._cuda_core_has_localized_location() is expected
-
-
-class TestHasLocalizedLocation:
-    """Tests for _cuda_core_has_localized_location()."""
-
-    @pytest.mark.agent_authored(model="grok-4.6")
-    @pytest.mark.parametrize(
-        ("cuda_version", "expected"),
-        [
-            (12080, False),
-            (13000, False),
-            (13030, False),
-            (13040, True),
-            (14000, True),
-        ],
-        ids=["12.8", "13.0", "13.3", "13.4", "14.0"],
-    )
-    def test_cuda_headers_parsing(self, cuda_version, expected):
-        """CUDA_VERSION 13040+ enables the localized CUmemLocation arm."""
-        _check_localized_location_detection(cuda_version, expected)
-
-    @pytest.mark.agent_authored(model="grok-4.6")
-    @pytest.mark.parametrize(
-        ("override", "expected"),
-        [
-            ("0", False),
-            ("1", True),
-        ],
-    )
-    def test_env_var_override(self, override, expected):
-        """CUDA_CORE_HAS_LOCALIZED_LOCATION overrides the header-derived value."""
-        _check_localized_location_detection(13030, expected, env_override=override)