@@ -199,6 +199,35 @@ what makes that safe: the allocation is released exactly once, when its last map
   its own `cuMemCreate` reference. It is not called for buffers from `allocate()`, whose ranges
   free themselves. A subclass override of `deallocate()` therefore does not run for them.
 
+## Sharing across processes
+
+A `VirtualMemoryBuffer` is shared the way pool-backed buffers are, through
+`Buffer.ipc_descriptor` and `Buffer.from_ipc_descriptor`, when the resource's
+`handle_type` can travel between processes (`posix_fd` on Linux;
+`is_ipc_enabled` reports it). The exporter calls `cuMemExportToShareableHandle`
+once per mapping that covers the buffer's size, in address order, and the
+descriptor carries the handles with each allocation's size. Each file
+descriptor is owned by an `IPCAllocationHandle` and closed when the descriptor
+goes; `multiprocessing` duplicates it into the receiving process. The sizes
+travel because the OS handle does not expose them to the importer; a wrong size
+fails the importer's `cuMemMap`.
+
+The importer is a `VirtualMemoryResource` of the receiving process with the
+same `handle_type`. `import_mem_allocation_handle` calls
+`cuMemImportFromShareableHandle` and wraps the result in the same box and
+deleter as `create_mem_allocation_handle`: the driver gives an imported handle
+one reference and frees the memory when all references are released and no
+mapping remains, so `cuMemRelease` is the right teardown for both. The access
+descriptors stored in the box are the importer's, built from its options for
+its device; the exporter's access does not travel. The import then reserves
+`sum(sizes)` with the importer's alignment, maps each allocation in order, and
+builds a range and a `VirtualMemoryBuffer` exactly as `allocate()` does, so a
+grown buffer imports as one contiguous range with the same byte layout, and the
+imported buffer frees itself through the same deleters. A descriptor imported
+in the exporting process yields an alias of the exporter's memory at a new
+address. A `VirtualMemoryResource` pickles as (device, options), which is what
+lets a `Buffer` pickle as (resource, descriptor).
+
 ## Why `modify_allocation` returns a new buffer
 
 The input buffer stays open and aliases the result. The chunks the input already mapped are
 
@@ -262,6 +262,18 @@ MemAllocationHandle create_mem_allocation_handle(size_t size, const CUmemAllocat
 // Size of the allocation; the only size cuMemMap accepts for it.
 size_t mem_allocation_size(const MemAllocationHandle& h) noexcept;
 
+// Import a physical allocation that another process exported with
+// cuMemExportToShareableHandle. `os_handle` is the shareable handle in the
+// form cuMemImportFromShareableHandle expects for `handle_type` (a POSIX file
+// descriptor is its value cast to void*). `size` is the allocation's size,
+// which the OS handle does not expose to the importer; the caller takes it
+// from the exporter, and a wrong size fails the later cuMemMap. The result is
+// a MemAllocationHandle like one from create_mem_allocation_handle: the
+// access descriptors are applied to every mapping, and the last reference
+// calls cuMemRelease. Returns empty handle on error (caller must check).
+MemAllocationHandle import_mem_allocation_handle(void* os_handle, CUmemAllocationHandleType handle_type,
+                                                 size_t size, const CUmemAccessDesc* descs, size_t count);
+
 // Reserve an address range via cuMemAddressReserve. Pass alignment 0 for the
 // driver default. When the last reference is released, cuMemAddressFree is
 // called with the exact reserved pair. Returns empty handle on error.
 
@@ -135,6 +135,7 @@ namespace cuda_core::rt {
     X(cuMemMap, 10020)                           \
     X(cuMemUnmap, 10020)                         \
     X(cuMemSetAccess, 10020)                     \
+    X(cuMemImportFromShareableHandle, 10020)     \
     /* cuda-bindings requests 7000 (PTDS) or 2000 (legacy) */ \
     X(cuStreamSynchronize, 7000)                 \
     X(cuStreamIsCapturing, 10000)                \
 
@@ -52,6 +52,22 @@ const Box* box_of(const Handle& h) noexcept {
         reinterpret_cast<const char*>(h.get()) - offsetof(Box, resource));
 }
 
+// Wrap an allocation handle this process holds one reference to, whether
+// cuMemCreate or cuMemImportFromShareableHandle produced it. The last
+// reference releases it; the memory is freed once no mapping remains.
+MemAllocationHandle wrap_mem_allocation(CUmemGenericAllocationHandle handle, size_t size,
+                                        std::vector<CUmemAccessDesc>&& access) {
+    auto box = std::shared_ptr<const MemAllocationBox>(
+        new MemAllocationBox{{handle}, size, std::move(access)},
+        [](const MemAllocationBox* b) {
+            GILReleaseGuard gil;
+            pw_cuMemRelease(b->resource.raw);
+            delete b;
+        }
+    );
+    return MemAllocationHandle(box, &box->resource);
+}
+
 }  // namespace
 
 // ============================================================================
@@ -68,15 +84,20 @@ MemAllocationHandle create_mem_allocation_handle(size_t size, const CUmemAllocat
     if (CUDA_SUCCESS != (err = DRIVER_CALL(cuMemCreate, &handle, size, &prop, 0))) {
         return {};
     }
-    auto box = std::shared_ptr<const MemAllocationBox>(
-        new MemAllocationBox{{handle}, size, std::move(access)},
-        [](const MemAllocationBox* b) {
-            GILReleaseGuard gil;
-            pw_cuMemRelease(b->resource.raw);
-            delete b;
-        }
-    );
-    return MemAllocationHandle(box, &box->resource);
+    return wrap_mem_allocation(handle, size, std::move(access));
+}
+
+MemAllocationHandle import_mem_allocation_handle(void* os_handle, CUmemAllocationHandleType handle_type,
+                                                 size_t size, const CUmemAccessDesc* descs, size_t count) {
+    // Copy the descriptors before the driver call so a failed copy leaves
+    // nothing to undo.
+    std::vector<CUmemAccessDesc> access(descs, descs + count);
+    GILReleaseGuard gil;
+    CUmemGenericAllocationHandle handle = 0;
+    if (CUDA_SUCCESS != (err = DRIVER_CALL(cuMemImportFromShareableHandle, &handle, os_handle, handle_type))) {
+        return {};
+    }
+    return wrap_mem_allocation(handle, size, std::move(access));
 }
 
 size_t mem_allocation_size(const MemAllocationHandle& h) noexcept {
 
@@ -2,10 +2,9 @@
 
 from typing import TypedDict
 
+from _typeshed import Incomplete
 from cuda.core._memory._copy_enums import CopyOptions
-from cuda.core._memory._device_memory_resource import DeviceMemoryResource
 from cuda.core._memory._ipc import IPCBufferDescriptor
-from cuda.core._memory._pinned_memory_resource import PinnedMemoryResource
 from cuda.core._stream import Stream
 from cuda.core._utils.pycompat import BufferProtocol
 from cuda.core.graph import GraphBuilder
@@ -82,13 +81,18 @@ class Buffer:
         :class:`Buffer` is closed or garbage collected.
         """
     @classmethod
-    def from_ipc_descriptor(cls, mr: DeviceMemoryResource | PinnedMemoryResource, ipc_descriptor: IPCBufferDescriptor, *, stream: Stream) -> Buffer:
+    def from_ipc_descriptor(cls, mr: Incomplete, ipc_descriptor: IPCBufferDescriptor, *, stream: Stream) -> Buffer:
         """Import a buffer that was exported from another process.
 
         Parameters
         ----------
-        mr : :obj:`~_memory.DeviceMemoryResource` | :obj:`~_memory.PinnedMemoryResource`
-            The IPC-enabled memory resource matching the exporting process.
+        mr : :obj:`~_memory.DeviceMemoryResource` | :obj:`~_memory.PinnedMemoryResource` | :obj:`~_memory.VirtualMemoryResource`
+            The IPC-enabled memory resource matching the exporting process. A
+            descriptor exported from a :class:`VirtualMemoryBuffer` is imported
+            with a :class:`VirtualMemoryResource` of this process whose
+            ``handle_type`` matches the exporter's; the import maps the shared
+            physical memory for that resource's device with that resource's
+            access options.
         ipc_descriptor : :obj:`~_memory.IPCBufferDescriptor`
             The descriptor exported from another process.
         stream : :obj:`~_stream.Stream`
 
@@ -388,15 +388,21 @@ cdef class Buffer:
 
     @classmethod
     def from_ipc_descriptor(
-        cls, mr: DeviceMemoryResource | PinnedMemoryResource, ipc_descriptor: IPCBufferDescriptor,
+        cls, mr: DeviceMemoryResource | PinnedMemoryResource | VirtualMemoryResource,
+        ipc_descriptor: IPCBufferDescriptor,
         *, stream: Stream
     ) -> Buffer:
         """Import a buffer that was exported from another process.
 
         Parameters
         ----------
-        mr : :obj:`~_memory.DeviceMemoryResource` | :obj:`~_memory.PinnedMemoryResource`
-            The IPC-enabled memory resource matching the exporting process.
+        mr : :obj:`~_memory.DeviceMemoryResource` | :obj:`~_memory.PinnedMemoryResource` | :obj:`~_memory.VirtualMemoryResource`
+            The IPC-enabled memory resource matching the exporting process. A
+            descriptor exported from a :class:`VirtualMemoryBuffer` is imported
+            with a :class:`VirtualMemoryResource` of this process whose
+            ``handle_type`` matches the exporter's; the import maps the shared
+            physical memory for that resource's device with that resource's
+            access options.
         ipc_descriptor : :obj:`~_memory.IPCBufferDescriptor`
             The descriptor exported from another process.
         stream : :obj:`~_stream.Stream`
 
@@ -53,10 +53,18 @@ cdef class IPCAllocationHandle:
     cpdef close(self)
 
 
+# Descriptor of a VirtualMemoryResource buffer: one exported handle per
+# physical allocation that backs the buffer, in address order.
+cdef class VirtualMemoryIPCBufferDescriptor(IPCBufferDescriptor):
+    cdef readonly int   _handle_type
+    cdef readonly tuple _chunk_sizes
+    cdef readonly tuple _handles
+
+
 # Buffer IPC Implementation
 # -------------------------
 cdef IPCBufferDescriptor Buffer_get_ipc_descriptor(Buffer)
-cdef Buffer Buffer_from_ipc_descriptor(cls, _MemPool, IPCBufferDescriptor, stream)
+cdef Buffer Buffer_from_ipc_descriptor(cls, object, IPCBufferDescriptor, stream)
 
 
 # _MemPool IPC Implementation
 
@@ -1,6 +1,7 @@
 # This file was generated by stubgen-pyx v0.2.22 from cuda_core/cuda/core/_memory/_ipc.pyx
 
 import uuid
+from typing import Any
 
 __all__ = []
 
@@ -39,7 +40,8 @@ class IPCBufferDescriptor:
     def size(self) -> int: ...
 
 class IPCAllocationHandle:
-    """Shareable handle to an IPC-enabled device memory pool."""
+    """Shareable OS handle to an IPC-enabled memory pool or to a physical allocation
+    of a :class:`VirtualMemoryResource` buffer."""
     def __init__(self, *arg, **kwargs) -> None: ...
     @classmethod
     def _init(cls, handle: int, uuid: uuid.UUID | None) -> IPCAllocationHandle: ...
@@ -54,5 +56,29 @@ class IPCAllocationHandle:
     @property
     def uuid(self) -> uuid.UUID: ...
 
+class VirtualMemoryIPCBufferDescriptor(IPCBufferDescriptor):
+    """Serializable object describing a :class:`VirtualMemoryBuffer` that can be shared between processes.
+
+    The descriptor holds one exported handle per physical allocation that
+    backs the buffer, in address order, with each allocation's size. With
+    POSIX file descriptors the handles are :class:`IPCAllocationHandle`
+    objects: the descriptor owns them and closes them when it is released, and
+    ``multiprocessing`` duplicates them into the receiving process. Plain
+    ``pickle`` cannot carry file descriptors.
+
+    Note
+    ----
+    The sizes are controlled by the exporting peer. Receivers must treat them
+    as untrusted and import only through :meth:`Buffer.from_ipc_descriptor`,
+    which fails instead of mapping a size the driver rejects.
+    """
+    _handle_type: int
+    _chunk_sizes: tuple[Any, ...]
+    _handles: tuple[Any, ...]
+
+    @staticmethod
+    def _from_exports(handle_type: int, chunk_sizes: tuple[int, ...], handles: tuple[Any, ...], size: int) -> VirtualMemoryIPCBufferDescriptor: ...
+    def __reduce__(self) -> tuple[object, ...]: ...
+
 def _reduce_allocation_handle(alloc_handle: IPCAllocationHandle) -> tuple[object, ...]: ...
 def _reconstruct_allocation_handle(cls: type, df: object, uuid: uuid.UUID | None) -> IPCAllocationHandle: ...
@@ -116,7 +116,8 @@ cdef inline int IPCAllocationHandle_check_open(IPCAllocationHandle self) except
 
 
 cdef class IPCAllocationHandle:
-    """Shareable handle to an IPC-enabled device memory pool."""
+    """Shareable OS handle to an IPC-enabled memory pool or to a physical allocation
+    of a :class:`VirtualMemoryResource` buffer."""
 
     def __init__(self, *arg, **kwargs) -> None:
         raise RuntimeError("IPCAllocationHandle objects cannot be instantiated directly. Please use MemoryResource APIs.")
@@ -169,12 +170,52 @@ def _reconstruct_allocation_handle(cls: type, df: object, uuid: uuid.UUID | None
 multiprocessing.reduction.register(IPCAllocationHandle, _reduce_allocation_handle)
 
 
+cdef class VirtualMemoryIPCBufferDescriptor(IPCBufferDescriptor):
+    """Serializable object describing a :class:`VirtualMemoryBuffer` that can be shared between processes.
+
+    The descriptor holds one exported handle per physical allocation that
+    backs the buffer, in address order, with each allocation's size. With
+    POSIX file descriptors the handles are :class:`IPCAllocationHandle`
+    objects: the descriptor owns them and closes them when it is released, and
+    ``multiprocessing`` duplicates them into the receiving process. Plain
+    ``pickle`` cannot carry file descriptors.
+
+    Note
+    ----
+    The sizes are controlled by the exporting peer. Receivers must treat them
+    as untrusted and import only through :meth:`Buffer.from_ipc_descriptor`,
+    which fails instead of mapping a size the driver rejects.
+    """
+
+    @staticmethod
+    def _from_exports(
+        handle_type: int, chunk_sizes: tuple[int, ...], handles: tuple, size: int
+    ) -> VirtualMemoryIPCBufferDescriptor:
+        cdef VirtualMemoryIPCBufferDescriptor self = VirtualMemoryIPCBufferDescriptor.__new__(
+            VirtualMemoryIPCBufferDescriptor)
+        self._payload = b""
+        self._size = size
+        self._handle_type = handle_type
+        self._chunk_sizes = tuple(chunk_sizes)
+        self._handles = tuple(handles)
+        return self
+
+    def __reduce__(self) -> tuple[object, ...]:
+        return VirtualMemoryIPCBufferDescriptor._from_exports, (
+            self._handle_type, self._chunk_sizes, self._handles, self._size)
+
+
 # Buffer IPC Implementation
 # -------------------------
 cdef IPCBufferDescriptor Buffer_get_ipc_descriptor(Buffer self):
     Buffer_check_open(self)
     if not self.memory_resource.is_ipc_enabled:
         raise RuntimeError("Memory resource is not IPC-enabled")
+    if not isinstance(self.memory_resource, _MemPool):
+        # VirtualMemoryBuffer overrides ipc_descriptor; a plain Buffer wrapped
+        # with Buffer.from_handle(mr=<VirtualMemoryResource>) lands here.
+        raise TypeError(
+            f"a Buffer that {type(self.memory_resource).__name__} did not allocate cannot be shared")
     cdef cydriver.CUmemPoolPtrExportData data
     with nogil:
         HANDLE_RETURN(
@@ -186,10 +227,24 @@ cdef IPCBufferDescriptor Buffer_get_ipc_descriptor(Buffer self):
     return IPCBufferDescriptor._init(data_b, self.size)
 
 cdef Buffer Buffer_from_ipc_descriptor(
-    cls, _MemPool mr, IPCBufferDescriptor ipc_descriptor, stream
+    cls, object mr, IPCBufferDescriptor ipc_descriptor, stream
 ):
     """Import a buffer that was exported from another process."""
-    MP_check_open(mr)
+    if isinstance(ipc_descriptor, VirtualMemoryIPCBufferDescriptor):
+        # Imported here rather than cimported: _virtual_memory_resource
+        # cimports this module.
+        from cuda.core._memory._virtual_memory_resource import VirtualMemoryResource
+        if not isinstance(mr, VirtualMemoryResource):
+            raise TypeError(
+                "this descriptor was exported from a VirtualMemoryResource buffer and must be "
+                f"imported with a VirtualMemoryResource, not {type(mr).__name__}")
+        return mr._import_ipc_buffer(ipc_descriptor, stream)
+    if not isinstance(mr, _MemPool):
+        raise TypeError(
+            "this descriptor was exported from a memory pool buffer and must be imported with a "
+            f"DeviceMemoryResource or PinnedMemoryResource, not {type(mr).__name__}")
+    cdef _MemPool pool = <_MemPool>mr
+    MP_check_open(pool)
     if not mr.is_ipc_enabled:
         raise RuntimeError("Memory resource is not IPC-enabled")
     cdef size_t payload_size = len(ipc_descriptor._payload)
@@ -201,7 +256,7 @@ cdef Buffer Buffer_from_ipc_descriptor(
         )
     cdef Stream s = Stream_accept(stream)
     cdef DevicePtrHandle h_ptr = deviceptr_import_ipc(
-        mr._h_pool,
+        pool._h_pool,
         ipc_descriptor.payload_ptr(),
         s._h_stream
     )
@@ -220,7 +275,7 @@ cdef Buffer Buffer_from_ipc_descriptor(
             f"IPC buffer descriptor size ({claimed_size}) exceeds "
             f"mapped allocation extent ({mapped_size} bytes)"
         )
-    return Buffer_from_deviceptr_handle(h_ptr, claimed_size, mr, ipc_descriptor)
+    return Buffer_from_deviceptr_handle(h_ptr, claimed_size, pool, ipc_descriptor)
 
 
 # _MemPool IPC Implementation