diff --git a/cudax/include/cuda/experimental/__container/uninitialized_async_buffer.cuh b/cudax/include/cuda/experimental/__container/uninitialized_async_buffer.cuh
index 731ed555bb3..77616627b42 100644
--- a/cudax/include/cuda/experimental/__container/uninitialized_async_buffer.cuh
+++ b/cudax/include/cuda/experimental/__container/uninitialized_async_buffer.cuh
@@ -22,7 +22,6 @@
 #endif // no system header
 
 #include <cuda/__memory_resource/properties.h>
-#include <cuda/__memory_resource/resource_ref.h>
 #include <cuda/std/__memory/align.h>
 #include <cuda/std/__new/launder.h>
 #include <cuda/std/__type_traits/type_set.h>
@@ -287,7 +286,7 @@ public:
   _CCCL_HIDE_FROM_ABI uninitialized_async_buffer __replace_allocation(const size_t __count)
   {
     // Create a new buffer with a reference to the stored memory resource and swap allocation information
-    uninitialized_async_buffer __ret{_CUDA_VMR::async_resource_ref<_Properties...>{__mr_}, __stream_, __count};
+    uninitialized_async_buffer __ret{mr::async_resource_ref<_Properties...>{__mr_}, __stream_, __count};
     _CUDA_VSTD::swap(__count_, __ret.__count_);
     _CUDA_VSTD::swap(__buf_, __ret.__buf_);
     return __ret;
diff --git a/cudax/include/cuda/experimental/__container/uninitialized_buffer.cuh b/cudax/include/cuda/experimental/__container/uninitialized_buffer.cuh
index 1f661c0c7d5..451dddfa89c 100644
--- a/cudax/include/cuda/experimental/__container/uninitialized_buffer.cuh
+++ b/cudax/include/cuda/experimental/__container/uninitialized_buffer.cuh
@@ -22,7 +22,6 @@
 #endif // no system header
 
 #include <cuda/__memory_resource/properties.h>
-#include <cuda/__memory_resource/resource_ref.h>
 #include <cuda/std/__memory/align.h>
 #include <cuda/std/__new/launder.h>
 #include <cuda/std/__type_traits/type_set.h>
@@ -252,7 +251,7 @@ public:
   _CCCL_HIDE_FROM_ABI uninitialized_buffer __replace_allocation(const size_t __count)
   {
     // Create a new buffer with a reference to the stored memory resource and swap allocation information
-    uninitialized_buffer __ret{_CUDA_VMR::resource_ref<_Properties...>{__mr_}, __count};
+    uninitialized_buffer __ret{mr::resource_ref<_Properties...>{__mr_}, __count};
     _CUDA_VSTD::swap(__count_, __ret.__count_);
     _CUDA_VSTD::swap(__buf_, __ret.__buf_);
     return __ret;
diff --git a/cudax/include/cuda/experimental/__detail/config.cuh b/cudax/include/cuda/experimental/__detail/config.cuh
index 3b9e147306b..7437abfccb8 100644
--- a/cudax/include/cuda/experimental/__detail/config.cuh
+++ b/cudax/include/cuda/experimental/__detail/config.cuh
@@ -61,6 +61,7 @@
 
 namespace cuda::experimental
 {
+namespace __cudax = ::cuda::experimental; // NOLINT: misc-unused-alias-decls
 }
 
 #endif // __CUDAX__DETAIL_CONFIG_CUH
diff --git a/cudax/include/cuda/experimental/__detail/utility.cuh b/cudax/include/cuda/experimental/__detail/utility.cuh
index 1263ea880fd..6345c6fbb67 100644
--- a/cudax/include/cuda/experimental/__detail/utility.cuh
+++ b/cudax/include/cuda/experimental/__detail/utility.cuh
@@ -11,7 +11,7 @@
 #ifndef __CUDAX_DETAIL_UTILITY_H
 #define __CUDAX_DETAIL_UTILITY_H
 
-#include <cuda/__cccl_config>
+#include <cuda/std/detail/__config>
 
 #if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
 #  pragma GCC system_header
@@ -21,6 +21,8 @@
 #  pragma system_header
 #endif // no system header
 
+#include <cuda/std/__utility/declval.h>
+
 namespace cuda::experimental
 {
 namespace detail
@@ -30,8 +32,8 @@ struct [[maybe_unused]] __ignore
 {
   __ignore() = default;
 
-  template <typename _Arg>
-  _CCCL_HOST_DEVICE constexpr __ignore(_Arg&&) noexcept
+  template <typename... _Args>
+  _CCCL_HOST_DEVICE constexpr __ignore(_Args&&...) noexcept
   {}
 };
 
@@ -42,8 +44,24 @@ struct __immovable
   __immovable(__immovable&&)            = delete;
   __immovable& operator=(__immovable&&) = delete;
 };
+
+template <class... _Types>
+struct _LIBCUDACXX_DECLSPEC_EMPTY_BASES __inherit : _Types...
+{};
+
+template <class _Type, template <class...> class _Template>
+inline constexpr bool __is_specialization_of = false;
+
+template <template <class...> class _Template, class... _Args>
+inline constexpr bool __is_specialization_of<_Template<_Args...>, _Template> = true;
+
 } // namespace detail
 
+template <class _Tp>
+using __identity_t _CCCL_NODEBUG_ALIAS = _Tp;
+
+using _CUDA_VSTD::declval;
+
 struct uninit_t
 {
   explicit uninit_t() = default;
diff --git a/cudax/include/cuda/experimental/__memory_resource/any_resource.cuh b/cudax/include/cuda/experimental/__memory_resource/any_resource.cuh
index c3d6fce7a08..f2cc2462e34 100644
--- a/cudax/include/cuda/experimental/__memory_resource/any_resource.cuh
+++ b/cudax/include/cuda/experimental/__memory_resource/any_resource.cuh
@@ -41,241 +41,712 @@
 #include <cuda/__memory_resource/resource.h>
 #include <cuda/__memory_resource/resource_ref.h>
 #include <cuda/std/__concepts/concept_macros.h>
-#include <cuda/std/__new_>
-#include <cuda/std/__type_traits/is_constructible.h>
-#include <cuda/std/__type_traits/is_nothrow_constructible.h>
-#include <cuda/std/__type_traits/is_same.h>
-#include <cuda/std/__type_traits/remove_cvref.h>
-#include <cuda/std/__type_traits/type_set.h>
-#include <cuda/std/__utility/exchange.h>
 #include <cuda/std/__utility/forward.h>
-#include <cuda/std/__utility/in_place.h>
+#include <cuda/std/optional>
 
-namespace cuda::experimental
-{
-template <class _Ty, class _Uy = _CUDA_VSTD::remove_cvref_t<_Ty>>
-_CCCL_INLINE_VAR constexpr bool __is_basic_any_resource = false;
+#include <cuda/experimental/__utility/basic_any.cuh>
 
-//! @rst
-//! .. _cudax-memory-resource-basic-any-resource:
-//!
-//! Base class for a type erased owning wrapper around a memory resource
-//! ---------------------------------------------------------------------
-//!
-//! ``basic_any_resource`` abstracts the differences between a resource and an async resource away, allowing efficient
-//! interoperability between the two.
-//!
-//! @endrst
-template <_CUDA_VMR::_AllocType _Alloc_type, class... _Properties>
-class basic_any_resource
-    : public _CUDA_VMR::_Resource_base<_Alloc_type, _CUDA_VMR::_WrapperType::_Owning>
-    , private _CUDA_VMR::_Filtered_vtable<_Properties...>
-{
-private:
-  static_assert(_CUDA_VMR::__contains_execution_space_property<_Properties...>,
-                "The properties of cuda::experimental::basic_any_resource must contain at least one execution "
-                "space property!");
-
-  template <_CUDA_VMR::_AllocType, class...>
-  friend class basic_any_resource;
-
-  template <class...>
-  friend struct _CUDA_VMR::_Resource_vtable;
-
-  using __vtable = _CUDA_VMR::_Filtered_vtable<_Properties...>;
+_CCCL_PUSH_MACROS
+#undef interface
 
-  //! @brief Validates that a set of \c _OtherProperties... is a superset of \c _Properties... .
-  template <class... _OtherProperties>
-  static constexpr bool __properties_match =
-    _CUDA_VSTD::__type_set_contains_v<_CUDA_VSTD::__make_type_set<_OtherProperties...>, _Properties...>;
+namespace cuda::experimental
+{
+#ifndef _CCCL_DOXYGEN_INVOKED // Do not document this
 
-  //! @brief Validates that a passed in \c _Resource satisfies the \c resource or \c async_resource concept respectively
-  //! as well as all properties in \c _Properties... .
-  template <class _Resource>
-  static constexpr bool __valid_resource =
-    _Alloc_type == _CUDA_VMR::_AllocType::_Async
-      ? _CUDA_VMR::async_resource_with<_Resource, _Properties...>
-      : _CUDA_VMR::resource_with<_Resource, _Properties...>;
+template <class _Property>
+using __property_result_t _CCCL_NODEBUG_ALIAS = _CUDA_VSTD::__type_call1< //
+  _CUDA_VSTD::conditional_t<cuda::property_with_value<_Property>,
+                            _CUDA_VSTD::__type_quote1<__property_value_t>,
+                            _CUDA_VSTD::__type_always<void>>,
+  _Property>;
 
-public:
-  //! @brief Constructs a \c basic_any_resource from a type that satisfies the \c resource or \c async_resource
-  //! concept as well as all properties.
-  //! @param __res The resource to be wrapped within the \c basic_any_resource.
-  _CCCL_TEMPLATE(class _Resource, class __resource_t = _CUDA_VSTD::remove_cvref_t<_Resource>)
-  _CCCL_REQUIRES((!__is_basic_any_resource<_Resource>) _CCCL_AND __valid_resource<__resource_t>)
-  basic_any_resource(_Resource&& __res) noexcept
-      : _CUDA_VMR::_Resource_base<_Alloc_type, _CUDA_VMR::_WrapperType::_Owning>(
-          nullptr, &_CUDA_VMR::__alloc_vtable<_Alloc_type, _CUDA_VMR::_WrapperType::_Owning, __resource_t>)
-      , __vtable(__vtable::template _Create<__resource_t>())
+template <class _Property>
+struct __with_property
+{
+  template <class _Ty>
+  _CUDAX_PUBLIC_API static auto __get_property(const _Ty& __obj) //
+    -> __property_result_t<_Property>
   {
-    if constexpr (_CUDA_VMR::_IsSmall<__resource_t>())
+    if constexpr (!_CUDA_VSTD::is_same_v<__property_result_t<_Property>, void>)
     {
-      ::new (static_cast<void*>(this->__object.__buf_)) __resource_t(_CUDA_VSTD::forward<_Resource>(__res));
+      return get_property(__obj, _Property());
     }
     else
     {
-      this->__object.__ptr_ = new __resource_t(_CUDA_VSTD::forward<_Resource>(__res));
+      return void();
     }
   }
 
-  //! @brief Constructs a \c basic_any_resource wrapping an object of type \c _Resource that
-  //! is constructed from \c __args... . \c _Resource must satisfy the  \c resource or \c async_resource
-  //! concept, and it must provide all properties in \c _Properties... .
-  //! @param __args The arguments used to construct the instance of \c _Resource to be wrapped within the
-  //! \c basic_any_resource.
-  _CCCL_TEMPLATE(class _Resource, class... _Args)
-  _CCCL_REQUIRES(_CCCL_TRAIT(_CUDA_VSTD::is_constructible, _Resource, _Args...) _CCCL_AND __valid_resource<_Resource>)
-  basic_any_resource(_CUDA_VSTD::in_place_type_t<_Resource>, _Args&&... __args) noexcept
-      : _CUDA_VMR::_Resource_base<_Alloc_type, _CUDA_VMR::_WrapperType::_Owning>(
-          nullptr, &_CUDA_VMR::__alloc_vtable<_Alloc_type, _CUDA_VMR::_WrapperType::_Owning, _Resource>)
-      , __vtable(__vtable::template _Create<_Resource>())
+  template <class...>
+  struct __iproperty : interface<__iproperty>
   {
-    if constexpr (_CUDA_VMR::_IsSmall<_Resource>())
+    _CUDAX_HOST_API friend auto
+    get_property([[maybe_unused]] const __iproperty& __obj, _Property) -> __property_result_t<_Property>
     {
-      ::new (static_cast<void*>(this->__object.__buf_)) _Resource(_CUDA_VSTD::forward<_Args>(__args)...);
+      if constexpr (!_CUDA_VSTD::is_same_v<__property_result_t<_Property>, void>)
+      {
+        return __cudax::virtcall<&__get_property<__iproperty>>(&__obj);
+      }
+      else
+      {
+        return void();
+      }
     }
-    else
-    {
-      this->__object.__ptr_ = new _Resource(_CUDA_VSTD::forward<_Args>(__args)...);
-    }
-  }
 
-  //! @brief Conversion from a \c basic_any_resource with the same set of properties but in a different order.
-  //! This constructor also handles conversion from \c any_async_resource to \c any_resource
-  //! @param __other The other \c basic_any_resource.
-  _CCCL_TEMPLATE(_CUDA_VMR::_AllocType _OtherAllocType, class... _OtherProperties)
-  _CCCL_REQUIRES(
-    (_CUDA_VSTD::_IsNotSame<basic_any_resource, basic_any_resource<_OtherAllocType, _OtherProperties...>>::value)
-      _CCCL_AND(_OtherAllocType == _Alloc_type || _OtherAllocType == _CUDA_VMR::_AllocType::_Async)
-        _CCCL_AND __properties_match<_OtherProperties...>)
-  basic_any_resource(basic_any_resource<_OtherAllocType, _OtherProperties...> __other) noexcept
-      : _CUDA_VMR::_Resource_base<_Alloc_type, _CUDA_VMR::_WrapperType::_Owning>(
-          nullptr, _CUDA_VSTD::exchange(__other.__static_vtable, nullptr))
-      , __vtable(__other)
-  {
-    _CCCL_ASSERT(this->__static_vtable != nullptr, "copying from a moved-from object");
-    this->__static_vtable->__move_fn(&this->__object, &__other.__object);
-  }
+    template <class _Ty>
+    using overrides _CCCL_NODEBUG_ALIAS = overrides_for<_Ty, _CUDAX_FNPTR_CONSTANT_WAR(&__get_property<_Ty>)>;
+  };
+};
+
+template <class _Property>
+using __iproperty = typename __with_property<_Property>::template __iproperty<>;
+
+template <class... _Properties>
+using __iproperty_set = iset<__iproperty<_Properties>...>;
+
+// Wrap the calls of the allocate_async and deallocate_async member functions
+// because of NVBUG#4967486
+template <class _Resource>
+_CUDAX_PUBLIC_API void* __allocate_async(_Resource& mr, size_t __bytes, size_t __alignment, ::cuda::stream_ref __stream)
+{
+  return mr.allocate_async(__bytes, __alignment, __stream);
+}
 
-  //! @brief Move-constructs a \c basic_any_resource from another one, taking ownership of the stored resource.
-  //! @param __other The other \c basic_any_resource.
-  basic_any_resource(basic_any_resource&& __other) noexcept
-      : _CUDA_VMR::_Resource_base<_Alloc_type, _CUDA_VMR::_WrapperType::_Owning>(
-          nullptr, _CUDA_VSTD::exchange(__other.__static_vtable, nullptr))
-      , __vtable(__other)
+template <class _Resource>
+_CUDAX_PUBLIC_API void
+__deallocate_async(_Resource& mr, void* __pv, size_t __bytes, size_t __alignment, ::cuda::stream_ref __stream)
+{
+  mr.deallocate_async(__pv, __bytes, __alignment, __stream);
+}
+
+template <class...>
+struct __ibasic_resource : interface<__ibasic_resource>
+{
+  _CUDAX_PUBLIC_API void* allocate(size_t __bytes, size_t __alignment = alignof(_CUDA_VSTD::max_align_t))
   {
-    _CCCL_ASSERT(this->__static_vtable != nullptr, "copying from a moved-from object");
-    this->__static_vtable->__move_fn(&this->__object, &__other.__object);
+    return __cudax::virtcall<&__ibasic_resource::allocate>(this, __bytes, __alignment);
   }
 
-  //! @brief Move-assigns another \c basic_any_resource, taking ownership of the stored resource.
-  //! @param __other The other \c basic_any_resource.
-  basic_any_resource& operator=(basic_any_resource&& __other) noexcept
+  _CUDAX_PUBLIC_API void deallocate(void* __pv, size_t __bytes, size_t __alignment = alignof(_CUDA_VSTD::max_align_t))
   {
-    if (this->__static_vtable != nullptr)
-    {
-      this->__static_vtable->__destroy_fn(&this->__object);
-      this->__static_vtable = nullptr;
-    }
+    return __cudax::virtcall<&__ibasic_resource::deallocate>(this, __pv, __bytes, __alignment);
+  }
 
-    if (__other.__static_vtable != nullptr)
-    {
-      this->__static_vtable = _CUDA_VSTD::exchange(__other.__static_vtable, nullptr);
-      this->__static_vtable->__move_fn(&this->__object, &__other.__object);
-    }
+  template <class _Ty>
+  using overrides _CCCL_NODEBUG_ALIAS =
+    overrides_for<_Ty, _CUDAX_FNPTR_CONSTANT_WAR(&_Ty::allocate), _CUDAX_FNPTR_CONSTANT_WAR(&_Ty::deallocate)>;
+};
 
-    return *this;
+template <class...>
+struct __ibasic_async_resource : interface<__ibasic_async_resource>
+{
+  _CUDAX_PUBLIC_API void* allocate_async(size_t __bytes, size_t __alignment, ::cuda::stream_ref __stream)
+  {
+    return __cudax::virtcall<&__allocate_async<__ibasic_async_resource>>(this, __bytes, __alignment, __stream);
   }
 
-  //! @brief Copy-constructs a \c basic_any_resource from another one.
-  //! @param __other The other \c basic_any_resource.
-  basic_any_resource(const basic_any_resource& __other)
-      : _CUDA_VMR::_Resource_base<_Alloc_type, _CUDA_VMR::_WrapperType::_Owning>(nullptr, __other.__static_vtable)
-      , __vtable(__other)
+  _CUDAX_PUBLIC_API void* allocate_async(size_t __bytes, ::cuda::stream_ref __stream)
   {
-    _CCCL_ASSERT(this->__static_vtable != nullptr, "copying from a moved-from object");
-    this->__static_vtable->__copy_fn(&this->__object, &__other.__object);
+    return __cudax::virtcall<&__allocate_async<__ibasic_async_resource>>(
+      this, __bytes, alignof(_CUDA_VSTD::max_align_t), __stream);
   }
 
-  //! @brief Copy-assigns another \c basic_any_resource.
-  //! @param __other The other \c basic_any_resource.
-  basic_any_resource& operator=(const basic_any_resource& __other)
+  _CUDAX_PUBLIC_API void deallocate_async(void* __pv, size_t __bytes, size_t __alignment, ::cuda::stream_ref __stream)
   {
-    return this == &__other ? *this : operator=(basic_any_resource(__other));
+    return __cudax::virtcall<&__deallocate_async<__ibasic_async_resource>>(this, __pv, __bytes, __alignment, __stream);
   }
 
-  //! @brief Destroys the stored resource
-  ~basic_any_resource() noexcept
+  _CUDAX_PUBLIC_API void deallocate_async(void* __pv, size_t __bytes, ::cuda::stream_ref __stream)
   {
-    if (this->__static_vtable != nullptr)
-    {
-      this->__static_vtable->__destroy_fn(&this->__object);
-    }
+    return __cudax::virtcall<&__deallocate_async<__ibasic_async_resource>>(
+      this, __pv, __bytes, alignof(_CUDA_VSTD::max_align_t), __stream);
   }
 
-  //! @brief Converts a \c basic_any_resource to a \c resource_ref with a potential subset of properties.
-  //! @return The \c resource_ref to this resource.
-  _CCCL_TEMPLATE(_CUDA_VMR::_AllocType _OtherAllocType, class... _OtherProperties)
-  _CCCL_REQUIRES((_OtherAllocType == _CUDA_VMR::_AllocType::_Default || _OtherAllocType == _Alloc_type) _CCCL_AND(
-    _CUDA_VSTD::__type_set_contains_v<_CUDA_VSTD::__make_type_set<_Properties...>, _OtherProperties...>))
-  operator _CUDA_VMR::basic_resource_ref<_OtherAllocType, _OtherProperties...>() noexcept
+  template <class _Ty>
+  using overrides _CCCL_NODEBUG_ALIAS =
+    overrides_for<_Ty,
+                  _CUDAX_FNPTR_CONSTANT_WAR(&__allocate_async<_Ty>),
+                  _CUDAX_FNPTR_CONSTANT_WAR(&__deallocate_async<_Ty>)>;
+};
+
+// This is the pseudo-virtual override for getting an old-style vtable pointer
+// from a new-style basic_any resource type. It is used below by
+// __iresource_ref_conversions.
+template <class _Resource>
+_CUDAX_PUBLIC_API const _CUDA_VMR::_Alloc_vtable* __get_resource_vptr(_Resource&) noexcept
+{
+  if constexpr (_CUDA_VMR::async_resource<_Resource>)
   {
-    return _CUDA_VMR::_Resource_ref_helper::_Construct<_Alloc_type, _OtherProperties...>(
-      this->_Get_object(), this->__static_vtable, static_cast<const __vtable&>(*this));
+    return &_CUDA_VMR::__alloc_vtable<_CUDA_VMR::_AllocType::_Async, _CUDA_VMR::_WrapperType::_Reference, _Resource>;
   }
-
-  //! @brief Swaps a \c basic_any_resource with another one.
-  //! @param __other The other \c basic_any_resource.
-  void swap(basic_any_resource& __other) noexcept
+  else if constexpr (_CUDA_VMR::resource<_Resource>)
   {
-    auto __tmp = _CUDA_VSTD::move(__other);
-    __other    = _CUDA_VSTD::move(*this);
-    *this      = _CUDA_VSTD::move(__tmp);
+    return &_CUDA_VMR::__alloc_vtable<_CUDA_VMR::_AllocType::_Default, _CUDA_VMR::_WrapperType::_Reference, _Resource>;
   }
-
-  //! @brief Equality comparison between two \c basic_any_resource
-  //! @param __rhs The other \c basic_any_resource
-  //! @return Checks whether both resources have the same equality function stored in their vtable and if so returns
-  //! the result of that equality comparison. Otherwise returns false.
-  _CCCL_TEMPLATE(class... _OtherProperties)
-  _CCCL_REQUIRES((sizeof...(_Properties) == sizeof...(_OtherProperties))
-                   _CCCL_AND __properties_match<_OtherProperties...>)
-  _CCCL_NODISCARD bool operator==(const basic_any_resource<_Alloc_type, _OtherProperties...>& __rhs) const
+  else
   {
-    return (this->__static_vtable->__equal_fn == __rhs.__static_vtable->__equal_fn)
-        && this->__static_vtable->__equal_fn(this->_Get_object(), __rhs._Get_object());
+    // This branch is taken when called from the thunk of an unspecialized
+    // interface; e.g., `icat<>` rather than `icat<ialley_cat<>>`. The thunks of
+    // unspecialized interfaces are never called, they just need to exist. The
+    // function pointer will be used as a key to look up the proper override.
+    _CCCL_UNREACHABLE();
   }
+}
+
+_CCCL_DIAG_PUSH
+_CCCL_DIAG_SUPPRESS_GCC("-Wunused-but-set-parameter")
+
+// Given a list of properties and a basic_any vptr, build a _Resource_vtable
+// for the properties as cuda::mr::basic_resource_ref expects.
+template <class _VPtr, class... _Properties>
+_CUDAX_HOST_API auto __make_resource_vtable(_VPtr __vptr, _CUDA_VMR::_Resource_vtable<_Properties...>*) noexcept
+  -> _CUDA_VMR::_Resource_vtable<_Properties...>
+{
+  return {__vptr->__query_interface(__iproperty<_Properties>())->__fn_...};
+}
+
+_CCCL_DIAG_POP
 
-  //! @brief Inequality comparison between two \c basic_any_resource
-  //! @param __rhs The other \c basic_any_resource
-  //! @return Checks whether both resources have the same equality function stored in their vtable and if so returns
-  //! the inverse result of that equality comparison. Otherwise returns true.
-  _CCCL_TEMPLATE(class... _OtherProperties)
-  _CCCL_REQUIRES((sizeof...(_Properties) == sizeof...(_OtherProperties))
-                   _CCCL_AND __properties_match<_OtherProperties...>)
-  _CCCL_NODISCARD bool operator!=(const basic_any_resource<_Alloc_type, _OtherProperties...>& __rhs) const
+// This interface provides the any_[async_]resource types with a conversion
+// to the old cuda::mr::basic_resource_ref types.
+template <class... _Super>
+struct _LIBCUDACXX_DECLSPEC_EMPTY_BASES __iresource_ref_conversions
+    : interface<__iresource_ref_conversions>
+    , _CUDA_VMR::_Resource_ref_base
+{
+  using __basic_any_type =
+    _CUDA_VSTD::decay_t<decltype(__cudax::basic_any_from(declval<__iresource_ref_conversions&>()))>;
+
+  template <class _Property>
+  using __iprop = __rebind_interface<__iproperty<_Property>, _Super...>;
+
+  template <_CUDA_VMR::_AllocType _Alloc_type>
+  using __iresource = __rebind_interface<
+    _CUDA_VSTD::
+      conditional_t<_Alloc_type == _CUDA_VMR::_AllocType::_Default, __ibasic_resource<>, __ibasic_async_resource<>>,
+    _Super...>;
+
+  _CCCL_TEMPLATE(_CUDA_VMR::_AllocType _Alloc_type, class... _Properties)
+  _CCCL_REQUIRES(_CUDA_VSTD::derived_from<__basic_any_type, __iresource<_Alloc_type>>
+                 && (_CUDA_VSTD::derived_from<__basic_any_type, __iprop<_Properties>> && ...))
+  operator _CUDA_VMR::basic_resource_ref<_Alloc_type, _Properties...>()
   {
-    return !(*this == __rhs);
+    auto& __self = __cudax::basic_any_from(*this);
+    auto* __vptr = __cudax::virtcall<&__get_resource_vptr<__iresource_ref_conversions>>(this);
+    auto* __vtag = static_cast<_CUDA_VMR::_Filtered_vtable<_Properties...>*>(nullptr);
+    auto __props = __cudax::__make_resource_vtable(__basic_any_access::__get_vptr(__self), __vtag);
+
+    return _CUDA_VMR::_Resource_ref_helper::_Construct<_Alloc_type, _Properties...>(
+      __basic_any_access::__get_optr(__self),
+      static_cast<const _CUDA_VMR::_Vtable_store<_Alloc_type>*>(__vptr),
+      __props);
   }
 
-  //! @brief Forwards the stateless properties
-  _CCCL_TEMPLATE(class _Property)
-  _CCCL_REQUIRES((!property_with_value<_Property>) _CCCL_AND(_CUDA_VSTD::__is_included_in_v<_Property, _Properties...>))
-  friend void get_property(const basic_any_resource&, _Property) noexcept {}
+  template <class _Resource>
+  using overrides = overrides_for<_Resource, _CUDAX_FNPTR_CONSTANT_WAR(&__get_resource_vptr<_Resource>)>;
+};
+
+template <class... _Properties>
+using __iresource _CCCL_NODEBUG_ALIAS =
+  iset<__ibasic_resource<>,
+       __iproperty_set<_Properties...>,
+       __iresource_ref_conversions<>,
+       icopyable<>,
+       iequality_comparable<>>;
+
+template <class... _Properties>
+using __iasync_resource _CCCL_NODEBUG_ALIAS = iset<__iresource<_Properties...>, __ibasic_async_resource<>>;
+
+template <class _Property>
+using __try_property_result_t =
+  _CUDA_VSTD::conditional_t<!_CUDA_VSTD::is_same_v<__property_result_t<_Property>, void>, //
+                            _CUDA_VSTD::optional<__property_result_t<_Property>>, //
+                            bool>;
 
-  //! @brief Forwards the stateful properties
-  _CCCL_TEMPLATE(class _Property)
-  _CCCL_REQUIRES(property_with_value<_Property> _CCCL_AND(_CUDA_VSTD::__is_included_in_v<_Property, _Properties...>))
-  _CCCL_NODISCARD_FRIEND __property_value_t<_Property> get_property(const basic_any_resource& __res, _Property) noexcept
+template <class _Derived>
+struct __with_try_get_property
+{
+  template <class _Property>
+  _CUDAX_HOST_API _CCCL_NODISCARD_FRIEND auto
+  try_get_property(const _Derived& __self, _Property) noexcept -> __try_property_result_t<_Property>
   {
-    _CUDA_VMR::_Property_vtable<_Property> const& __prop = __res;
-    return __prop.__property_fn(__res._Get_object());
+    auto __prop = __cudax::dynamic_any_cast<const __iproperty<_Property>*>(&__self);
+    if constexpr (_CUDA_VSTD::is_same_v<__property_result_t<_Property>, void>)
+    {
+      return __prop != nullptr;
+    }
+    else if (__prop)
+    {
+      return get_property(*__prop, _Property{});
+    }
+    else
+    {
+      return _CUDA_VSTD::nullopt;
+    }
   }
 };
 
-//! @brief Checks whether a passed in type is a specialization of basic_any_resource
-template <class _Ty, _CUDA_VMR::_AllocType _Alloc_type, class... _Properties>
-_CCCL_INLINE_VAR constexpr bool __is_basic_any_resource<_Ty, basic_any_resource<_Alloc_type, _Properties...>> = true;
+// `any_resource` wraps any given resource that satisfies the required
+// properties. It owns the contained resource, taking care of construction /
+// destruction. This makes it especially suited for use in e.g. container types
+// that need to ensure that the lifetime of the container exceeds the lifetime
+// of the memory resource used to allocate the storage
+template <class... _Properties>
+struct _LIBCUDACXX_DECLSPEC_EMPTY_BASES any_resource
+    : basic_any<__iresource<_Properties...>>
+    , __with_try_get_property<any_resource<_Properties...>>
+{
+  using any_resource::basic_any::basic_any;
+
+private:
+  static_assert(_CUDA_VMR::__contains_execution_space_property<_Properties...>,
+                "The properties of cuda::experimental::any_resource must contain at least one execution space "
+                "property!");
+  using any_resource::basic_any::interface;
+};
+
+// ``any_async_resource`` wraps any given async_resource that satisfies the
+// required properties. It owns the contained resource, taking care of
+// construction / destruction. This makes it especially suited for use in e.g.
+// container types that need to ensure that the lifetime of the container
+// exceeds the lifetime of the memory resource used to allocate the storage
+template <class... _Properties>
+struct _LIBCUDACXX_DECLSPEC_EMPTY_BASES any_async_resource
+    : basic_any<__iasync_resource<_Properties...>>
+    , __with_try_get_property<any_async_resource<_Properties...>>
+{
+  using any_async_resource::basic_any::basic_any;
+
+private:
+  static_assert(_CUDA_VMR::__contains_execution_space_property<_Properties...>,
+                "The properties of cuda::experimental::any_async_resource must contain at least one execution space "
+                "property!");
+  using any_async_resource::basic_any::interface;
+};
+
+//! @brief Type erased wrapper around a `resource` that satisfies \tparam _Properties
+//! @tparam _Properties The properties that any resource wrapped within the `resource_ref` needs to satisfy
+template <class... _Properties>
+struct _LIBCUDACXX_DECLSPEC_EMPTY_BASES resource_ref
+    : basic_any<__iresource<_Properties...>&>
+    , __with_try_get_property<resource_ref<_Properties...>>
+{
+  using resource_ref::basic_any::basic_any;
+
+private:
+  static_assert(_CUDA_VMR::__contains_execution_space_property<_Properties...>,
+                "The properties of cuda::experimental::resource_ref must contain at least one execution space "
+                "property!");
+  using resource_ref::basic_any::interface;
+};
+
+//! @brief Type erased wrapper around a `async_resource` that satisfies \tparam _Properties
+//! @tparam _Properties The properties that any async resource wrapped within the `async_resource_ref` needs to satisfy
+template <class... _Properties>
+struct _LIBCUDACXX_DECLSPEC_EMPTY_BASES async_resource_ref
+    : basic_any<__iasync_resource<_Properties...>&>
+    , __with_try_get_property<async_resource_ref<_Properties...>>
+{
+  using async_resource_ref::basic_any::basic_any;
+
+private:
+  static_assert(_CUDA_VMR::__contains_execution_space_property<_Properties...>,
+                "The properties of cuda::experimental::async_resource_ref must contain at least one execution space "
+                "property!");
+  using async_resource_ref::basic_any::interface;
+};
+
+#else // ^^^ !_CCCL_DOXYGEN_INVOKED ^^^ / vvv _CCCL_DOXYGEN_INVOKED vvv
+
+enum class _ResourceKind
+{
+  _Synchronous,
+  _Asynchronous
+};
+
+//! @rst
+//! Type erased wrapper around a `resource` or an `async_resource`
+//! --------------------------------------------------------------
+//!
+//! ``basic_any_resource`` wraps any given :ref:`resource
+//! <libcudacxx-extended-api-memory-resources-resource>` that satisfies the
+//! required properties. It owns the contained resource, taking care of
+//! construction / destruction. This makes it especially suited for use in e.g.
+//! container types that need to ensure that the lifetime of the container
+//! exceeds the lifetime of the memory resource used to allocate the storage
+//!
+//! ``basic_any_resource`` models the ``cuda::std::regular`` concept.
+//! @endrst
+//!
+//! @tparam _Kind Either `_ResourceKind::_Synchronous` for `any_resource`, or
+//! `_ResourceKind::_Asynchronous` for `any_async_resource`.
+//! @tparam _Properties A pack of property types that a memory resource must
+//! provide in order to be storable in instances of this `basic_any_resource`
+//! type.
+//!
+//! @sa any_resource
+//! @sa any_async_resource
+//! @sa resource_ref
+//! @sa async_resource_ref
+template <_ResourceKind _Kind, class... _Properties>
+class basic_any_resource
+{
+public:
+  //! @brief Constructs a \c basic_any_resource with no value
+  //! @post `has_value()` is `false`
+  basic_any_resource() noexcept;
+
+  //! @brief Move constructs a \c basic_any_resource
+  //! @post `has_value()` is `true` if `__other` had a value prior to the move,
+  //! and `false` otherwise. `__other.has_value()` is `false`.
+  basic_any_resource(basic_any_resource&& __other) noexcept;
+
+  //! @brief Copy constructs a \c basic_any_resource
+  //! @post `has_value()` is the same as `__other.has_value()`.
+  basic_any_resource(const basic_any_resource& __other);
+
+  //! @brief Constructs a \c basic_any_resource from a type that satisfies the
+  //! \c resource concept.
+  //! and that supports all of the specified properties.
+  //! @param __res The resource to be wrapped by the \c basic_any_resource.
+  //! @pre \c _Resource is not a specialization of \c basic_any_resource or
+  //! \c basic_resource_ref, or a type derived from such.
+  //! @pre `resource_with<_Resource, _Properties...>` is `true`.
+  //! @pre If \c _Kind is \c _ResourceKind::_Asynchronous,
+  //! `async_resource_with<_Resource, _Properties...>` is `true`.
+  //! @post `has_value()` is `true`
+  template <class _Resource>
+  basic_any_resource(_Resource __res);
+
+  //! @brief Conversion from a type-erased resource with a superset of the
+  //! required properties.
+  //! @param __res The object to copy from.
+  //! @pre \c _OtherKind is equal to either \c _Kind or
+  //! \c _ResourceKind::_Asynchronous.
+  //! @pre The set `_OtherProperties...` is a superset of `_Properties...`.
+  //! @post `has_value()` is equal to `__res.has_value()`
+  template <_ResourceKind _OtherKind, class... _OtherProperties>
+  basic_any_resource(basic_any_resource<_OtherKind, _OtherProperties...> __res);
+
+  //! @brief Deep copy from a type-erased resource reference with a superset
+  //! of the required properties.
+  //!
+  //! The object to which \c __res refers is copied into `*this`.
+  //! @param __res The reference to copy from.
+  //! @pre \c _OtherKind is equal to either \c _Kind or
+  //! \c _ResourceKind::_Asynchronous.
+  //! @pre The set `_OtherProperties...` is a superset of `_Properties...`.
+  template <_ResourceKind _OtherKind, class... _OtherProperties>
+  basic_any_resource(basic_resource_ref<_OtherKind, _OtherProperties...> __res);
+
+  //! @brief Move assigns a \c basic_any_resource
+  //! @post `has_value()` is `true` if `__other` had a value prior to the move,
+  //! and `false` otherwise.
+  //! @post `__other.has_value()` is `false`.
+  basic_any_resource& operator=(basic_any_resource&& __other) noexcept;
+
+  //! @brief Copy assigns a \c basic_any_resource
+  //! @post `has_value()` is the same as `__other.has_value()`.
+  basic_any_resource& operator=(const basic_any_resource& __other);
+
+  //! @brief Assigns from a type that satisfies the \c resource concept and that
+  //! supports all of the specified properties.
+  //! @param __res The resource to be wrapped within the \c basic_any_resource
+  //! @pre \c _Resource is not a specialization of \c basic_any_resource or
+  //! \c basic_resource_ref, or a type derived from such.
+  //! @pre `resource_with<_Resource, _Properties...>` is `true`.
+  //! @pre If \c _Kind is \c _ResourceKind::_Asynchronous,
+  //! `async_resource_with<_Resource, _Properties...>` is `true`.
+  //! @post `has_value()` is `true`
+  template <class _Resource>
+  basic_any_resource& operator=(_Resource __res);
+
+  //! @brief Assignment from a type-erased resource with a superset of the
+  //! required properties.
+  //! @param __res The object to copy from.
+  //! @pre \c _OtherKind is equal to either \c _Kind or
+  //! \c _ResourceKind::_Asynchronous.
+  //! @pre The set `_OtherProperties...` is a superset of `_Properties...`.
+  //! @post `has_value()` is equal to `__res.has_value()`.
+  template <_ResourceKind _OtherKind, class... _OtherProperties>
+  basic_any_resource& operator=(basic_any_resource<_OtherKind, _OtherProperties...> __res);
+
+  //! @brief Deep copy from a type-erased resource reference with a superset of
+  //! the required properties.
+  //! @param __res The type-erased resource reference to copy from.
+  //! @pre \c _OtherKind is equal to either \c _Kind or
+  //! \c _ResourceKind::_Asynchronous.
+  //! @pre The set `_OtherProperties...` is a superset of `_Properties...`.
+  //! @post `has_value()` is `true`.
+  template <_ResourceKind _OtherKind, class... _OtherProperties>
+  basic_any_resource& operator=(basic_resource_ref<_OtherKind, _OtherProperties...> __res);
+
+  //! @brief Equality comparison between two type-erased memory resource
+  //! @param __rhs The type-erased resource to compare with `*this`.
+  //! @pre \c _OtherKind is equal to either \c _Kind or
+  //! \c _ResourceKind::_Asynchronous.
+  //! @pre The set `_Properties...` is equal to the set `_OtherProperties...`.
+  //! @return `true` if both resources hold objects of the same type and those
+  //! objects compare equal, and `false` otherwise.
+  template <_ResourceKind _OtherKind, class... _OtherProperties>
+  [[nodiscard]] bool operator==(const basic_any_resource<_OtherKind, _OtherProperties...>& __rhs) const;
+
+  //! @brief Equality comparison between `*this` and a type-erased resource
+  //! reference.
+  //! @param __rhs The type-erased resource reference to compare with `*this`.
+  //! @pre \c _OtherKind is equal to either \c _Kind or
+  //! \c _ResourceKind::_Asynchronous.
+  //! @pre The set `_Properties...` is equal to the set `_OtherProperties...`.
+  //! @return `true` if \c __rhs refers to an object of the same type as that
+  //! wrapped by `*this` and those objects compare equal; `false` otherwise.
+  template <_ResourceKind _OtherKind, class... _OtherProperties>
+  [[nodiscard]] bool operator==(const basic_resource_ref<_OtherKind, _OtherProperties...>& __rhs) const;
+
+  //! @brief Calls `allocate` on the wrapped object with the specified
+  //! arguments.
+  //! @pre `has_value()` is `true`.
+  //! @return `obj.allocate(__size, __align)`, where `obj` is the wrapped
+  //! object.
+  [[nodiscard]] void* allocate(size_t __size, size_t __align = alignof(cuda::std::max_align_t));
+
+  //! @brief Calls `deallocate` on the wrapped object with the specified
+  //! arguments.
+  //! @pre `has_value()` is `true`.
+  //! @pre `__pv` must be a pointer that was previously returned by a call to \c
+  //! allocate on the object wrapped by `*this`.
+  //! @return `obj.deallocate(__pv, __size, __align)`, where `obj` is the
+  //! wrapped object.
+  void deallocate(void* __pv, size_t __size, size_t __align = alignof(cuda::std::max_align_t));
+
+  //! @brief Calls `allocate_async` on the wrapped object with the specified
+  //! arguments.
+  //! @pre `_Kind` is `_ResourceKind::_Asynchronous`.
+  //! @pre `has_value()` is `true`.
+  //! @return `obj.allocate_async(__size, __align, __stream)`, where `obj` is
+  //! the wrapped object.
+  //! @warning The returned pointer is not valid until `__stream` has been
+  //! synchronized.
+  [[nodiscard]] void* allocate_async(size_t __size, size_t __align, cuda::stream_ref __stream);
+
+  //! @brief Equivalent to `allocate_async(__size,
+  //! alignof(_CUDA_VSTD::max_align_t), __stream)`.
+  [[nodiscard]] void* allocate_async(size_t __size, cuda::stream_ref __stream);
+
+  //! @brief Calls `deallocate_async` on the wrapped object with the specified
+  //! arguments.
+  //! @pre `_Kind` is `_ResourceKind::_Asynchronous`.
+  //! @pre `has_value()` is `true`.
+  //! @pre `__pv` must be a pointer that was previously returned by a call to
+  //! \c allocate_async on the object wrapped by `*this`.
+  //! @return `obj.deallocate_async(__pv, __size, __align, __stream)`, where
+  //! `obj` is the wrapped object.
+  void deallocate_async(void* __pv, size_t __size, size_t __align, cuda::stream_ref __stream);
+
+  //! @brief Equivalent to `deallocate_async(__pv, __size,
+  //! alignof(_CUDA_VSTD::max_align_t), __stream)`.
+  void deallocate_async(void* __pv, size_t __size, cuda::stream_ref __stream);
+
+  //! @brief Checks if `*this` holds a value.
+  //! @return `true` if `*this` holds a value; `false` otherwise.
+  [[nodiscard]] bool has_value() const noexcept;
+
+  //! @brief Resets `*this` to the empty state.
+  //! @post `has_value() == false`
+  void reset() noexcept;
+
+  //! @return A reference to the \c type_info object for the wrapped
+  //! resource, or `typeid(void)` if `has_value()` is `false`.
+  [[nodiscard]] const cuda::std::type_info& type() const noexcept;
+
+  //! @brief Forwards a property query to the type-erased object.
+  //! @param __res The \c basic_any_resource object
+  //! @param __prop The property to query
+  //! @pre The type \c _Property is one of the types in the pack
+  //! `_Properties...`.
+  //! @return The result of calling `get_property(__obj, __prop)`, where `__obj`
+  //! is the type-erased object stored in `__res`.
+  template <class _Property>
+  friend decltype(auto) get_property(const basic_any_resource& __res, _Property __prop) noexcept;
+
+  //! @brief Attempts to forward a property query to the type-erased object and
+  //! returns a _`boolean-testable`_ object that contains the result, if any.
+  //!
+  //! @tparam _Property
+  //! @param __res The \c basic_any_resource object
+  //! @param __prop The property to query
+  //! @pre `has_value()` is `true`.
+  //! @return
+  //! Let:
+  //!   - \c obj be the wrapped object.
+  //!   - \c ValueType be the associated value type of \c __prop.
+  //!   - \c ReturnType be \c bool if \c ValueType is \c void. Otherwise,
+  //!     \c ReturnType is \c cuda::std::optional<ValueType>.
+  //!   - \c _OtherProperties be the pack of type parameters of the
+  //!     \c basic_any_resource object that first type-erased \c obj. [_Note:_
+  //!     `_OtherProperties` is different than `_Properties` when \c *this is
+  //!     the result of an interface-narrowing conversion. -- end note]
+  //!   .
+  //! `try_get_property(__res, __prop)` has type \c ReturnType. If \c _Property
+  //! is not in the pack \c _OtherProperties, returns `ReturnType()`.
+  //! Otherwise:
+  //!   - Returns \c true if \c ValueType is \c void.
+  //!   - Returns `ReturnType(get_property(obj, __prop))` otherwise.
+  template <class _Property>
+  friend _SEE_BELOW_ try_get_property(const basic_any_resource& __res, _Property __prop) noexcept;
+};
+
+//! @brief Type erased wrapper around a reference to an object that satisfies
+//! the \c resource concept and that provides the requested \c _Properties.
+//! @tparam _Properties The properties that any resource wrapped within the
+//! `basic_resource_ref` needs to provide.
+//!
+//! ``basic_resource_ref`` models the ``cuda::std::copable`` and
+//! ``cuda::std::equality_comparable`` concepts.
+template <_ResourceKind _Kind, class... _Properties>
+class basic_resource_ref
+{
+public:
+  //! @brief Copy constructs a \c basic_resource_ref
+  //! @post `*this` and `__other` both refer to the same resource object.
+  basic_resource_ref(const basic_resource_ref& __other);
+
+  //! @brief Constructs a \c basic_resource_ref from a reference to a type that
+  //! satisfies the \c resource concept and that supports all of the specified
+  //! properties.
+  //! @param __res The resource reference to be wrapped.
+  //! @pre `resource_with<_Resource, _Properties...>` is `true`.
+  //! @pre If \c _Kind is \c _ResourceKind::_Asynchronous,
+  //! `async_resource_with<_Resource, _Properties...>` is `true`.
+  //! @pre If \c __res refers to a specialization of \c basic_any_resource or
+  //! a type derived from such, `__res.has_value()` is `true`.
+  template <class _Resource>
+  basic_resource_ref(_Resource& __res);
+
+  //! @brief Conversion from type-erased resource reference with a superset
+  //! of the required properties.
+  //! @param __res The other type-erased resource reference to copy from.
+  //! @pre \c _OtherKind is equal to either \c _Kind or
+  //! \c _ResourceKind::_Asynchronous.
+  //! @pre The set `_OtherProperties...` is a superset of `_Properties...`.
+  //! @post `*this` and `__res` both refer to the same resource object.
+  template <_ResourceKind _OtherKind, class... _OtherProperties>
+  basic_resource_ref(basic_resource_ref<_OtherKind, _OtherProperties...> __res);
+
+  //! @brief Rebinds `*this` to refer to the object to which `__other` refers.
+  //! @post `*this` and `__other` both refer to the same resource object.
+  basic_resource_ref& operator=(const basic_resource_ref& __other);
+
+  //! @brief Rebinds the wrapped reference to an object whose type satisfies the
+  //! \c resource concept and that supports all of the specified properties.
+  //! @param __res The reference to the resource to be wrapped by the \c
+  //! basic_resource_ref.
+  //! @pre `resource_with<_Resource, _Properties...>` is `true`.
+  //! @pre If \c _Kind is \c _ResourceKind::_Asynchronous,
+  //! `async_resource_with<_Resource, _Properties...>` is `true`.
+  //! @pre If \c __res refers to a specialization of \c basic_any_resource or a
+  //! type derived from such, `__res.has_value()` is `true`.
+  template <class _Resource>
+  basic_resource_ref& operator=(_Resource& __res);
+
+  //! @brief Rebinds `*this` to refer to the object to which `__other` refers.
+  //! @param __res The other type-erased resource reference to copy from.
+  //! @pre \c _OtherKind is equal to either \c _Kind or
+  //! \c _ResourceKind::_Asynchronous.
+  //! @pre The set `_OtherProperties...` is a superset of `_Properties...`.
+  //! @post `*this` and `__res` both refer to the same resource object.
+  template <_ResourceKind _OtherKind, class... _OtherProperties>
+  basic_resource_ref& operator=(basic_resource_ref<_OtherKind, _OtherProperties...> __res);
+
+  //! @brief Equality comparison between two type-erased resource references.
+  //! @param __rhs The other type-erased resource reference.
+  //! @pre \c _OtherKind is equal to either \c _Kind or
+  //! \c _ResourceKind::_Asynchronous.
+  //! @pre The set `_Properties...` is equal to the set `_OtherProperties...`.
+  //! @return `true` if both resources refer to objects of the same type and
+  //! those objects compare equal. Otherwise, returns `false`.
+  template <_ResourceKind _OtherKind, class... _OtherProperties>
+  [[nodiscard]] bool operator==(const basic_resource_ref<_OtherKind, _OtherProperties...>& __rhs) const;
+
+  //! @brief Calls `allocate` on the wrapped reference with the specified
+  //! arguments.
+  //! @return `obj.allocate(__size, __align)`, where `obj` is the wrapped
+  //! reference.
+  [[nodiscard]] void* allocate(size_t __size, size_t __align = alignof(cuda::std::max_align_t));
+
+  //! @brief Calls `deallocate` on the wrapped reference with the specified
+  //! arguments.
+  //! @pre `__pv` must be a pointer that was previously returned by a call to
+  //! \c allocate on the object referenced by `*this`.
+  //! @return `obj.deallocate(__pv, __size, __align)`, where `obj` is the
+  //! wrapped reference.
+  void deallocate(void* __pv, size_t __size, size_t __align = alignof(cuda::std::max_align_t));
+
+  //! @brief Calls `allocate_async` on the wrapped reference with the specified
+  //! arguments.
+  //! @pre `_Kind` is `_ResourceKind::_Asynchronous`.
+  //! @return `obj.allocate_async(__size, __align, __stream)`, where `obj` is
+  //! the wrapped reference.
+  //! @warning The returned pointer is not valid until `__stream` has been
+  //! synchronized.
+  [[nodiscard]] void* allocate_async(size_t __size, size_t __align, cuda::stream_ref __stream);
+
+  //! @brief Equivalent to `allocate_async(__size,
+  //! alignof(_CUDA_VSTD::max_align_t), __stream)`.
+  [[nodiscard]] void* allocate_async(size_t __size, cuda::stream_ref __stream);
+
+  //! @brief Calls `deallocate_async` on the wrapped reference with the specified
+  //! arguments.
+  //! @pre `_Kind` is `_ResourceKind::_Asynchronous`.
+  //! @pre `__pv` must be a pointer that was previously returned by a call to \c
+  //! allocate_async on the object referenced by `*this`.
+  //! @return `obj.deallocate_async(__pv, __size, __align, __stream)`, where
+  //! `obj` is the wrapped reference.
+  void deallocate_async(void* __pv, size_t __size, size_t __align, cuda::stream_ref __stream);
+
+  //! @brief Equivalent to `deallocate_async(__pv, __size,
+  //! alignof(_CUDA_VSTD::max_align_t), __stream)`.
+  void deallocate_async(void* __pv, size_t __size, cuda::stream_ref __stream);
+
+  //! @return A reference to the \c type_info object for the type of the object
+  //! to which `*this` refers.
+  [[nodiscard]] const cuda::std::type_info& type() const noexcept;
+
+  //! @brief Forwards a property query to the type-erased reference.
+  //! @tparam _Property
+  //! @param __res The \c basic_resource_ref object
+  //! @param __prop The property to query
+  //! @pre \c _Property is a type in `_Properties...`.
+  //! @return The result of calling `get_property(__obj, __prop)`, where `__obj`
+  //! is the type-erased reference stored in `__res`.
+  template <class _Property>
+  friend decltype(auto) get_property(const basic_resource_ref& __res, _Property __prop) noexcept;
+
+  //! @brief Attempts to forward a property query to the type-erased object and
+  //! returns a _`boolean-testable`_ object that contains the result, if any.
+  //!
+  //! @tparam _Property
+  //! @param __res The \c any_resource object
+  //! @param __prop The property to query
+  //! @pre `has_value()` is `true`.
+  //! @return
+  //! Let:
+  //!   - \c obj be the wrapped reference.
+  //!   - \c ValueType be the associated value type of \c __prop.
+  //!   - \c ReturnType be \c bool if \c ValueType is \c void. Otherwise,
+  //!     \c ReturnType is \c cuda::std::optional<ValueType>.
+  //!   - \c _OtherProperties be the pack of type parameters of the wrapper type
+  //!     that first type-erased \c obj. [_Note:_ `_OtherProperties` is
+  //!     different than `_Properties` when \c *this is the result of an
+  //!     interface-narrowing conversion. -- end note]
+  //!   .
+  //! `try_get_property(__res, __prop)` has type \c ReturnType. If \c _Property
+  //! is not in the pack \c _OtherProperties, returns `ReturnType()`.
+  //! Otherwise:
+  //!   - Returns \c true if \c ValueType is \c void.
+  //!   - Returns `ReturnType(get_property(obj, __prop))` otherwise.
+  template <class _Property>
+  friend _SEE_BELOW_ try_get_property(const basic_resource_ref& __res, _Property __prop) noexcept;
+};
 
 //! @rst
 //! .. _cudax-memory-resource-any-resource:
@@ -283,29 +754,53 @@ _CCCL_INLINE_VAR constexpr bool __is_basic_any_resource<_Ty, basic_any_resource<
 //! Type erased wrapper around a `resource`
 //! ----------------------------------------
 //!
-//! ``any_resource`` wraps any given :ref:`resource <libcudacxx-extended-api-memory-resources-resource>` that
-//! satisfies the required properties. It owns the contained resource, taking care of construction / destruction.
-//! This makes it especially suited for use in e.g. container types that need to ensure that the lifetime of the
-//! container exceeds the lifetime of the memory resource used to allocate the storage
+//! ``any_resource`` wraps any given :ref:`resource
+//! <libcudacxx-extended-api-memory-resources-resource>` that satisfies the
+//! required properties. It owns the contained resource, taking care of
+//! construction / destruction. This makes it especially suited for use in e.g.
+//! container types that need to ensure that the lifetime of the container
+//! exceeds the lifetime of the memory resource used to allocate the storage
+//!
+//! ``any_resource`` models the ``cuda::std::regular`` concept.
 //!
 //! @endrst
 template <class... _Properties>
-using any_resource = basic_any_resource<_CUDA_VMR::_AllocType::_Default, _Properties...>;
+using any_resource = basic_any_resource<_ResourceKind::_Synchronous, _Properties...>;
 
 //! @rst
 //! .. _cudax-memory-resource-any-async-resource:
 //!
 //! Type erased wrapper around an `async_resource`
-//! -----------------------------------------------
+//! ----------------------------------------------
+//!
+//! ``any_async_resource`` wraps any given :ref:`async_resource
+//! <libcudacxx-extended-api-memory-resources-resource>` that satisfies the
+//! required properties. It owns the contained resource, taking care of
+//! construction / destruction. This makes it especially suited for use in e.g.
+//! container types that need to ensure that the lifetime of the container
+//! exceeds the lifetime of the memory resource used to allocate the storage
 //!
-//! ``any_async_resource`` wraps any given :ref:`async resource <libcudacxx-extended-api-memory-resources-resource>`
-//! that satisfies the required properties. It owns the contained resource, taking care of construction / destruction.
-//! This makes it especially suited for use in e.g. container types that need to ensure that the lifetime of the
-//! container exceeds the lifetime of the memory resource used to allocate the storage
+//! ``any_async_resource`` models the ``cuda::std::regular`` concept.
 //!
 //! @endrst
 template <class... _Properties>
-using any_async_resource = basic_any_resource<_CUDA_VMR::_AllocType::_Async, _Properties...>;
+using any_async_resource = basic_any_resource<_ResourceKind::_Asynchronous, _Properties...>;
+
+//! @brief Type erased wrapper around a `resource` that satisfies \c
+//! _Properties.
+//! @tparam _Properties The properties that any resource wrapped within the
+//! `resource_ref` needs to satisfy
+template <class... _Properties>
+using resource_ref = basic_resource_ref<_ResourceKind::_Synchronous, _Properties...>;
+
+//! @brief Type erased wrapper around a `async_resource` that satisfies \c
+//! _Properties
+//! @tparam _Properties The properties that any async resource wrapped within
+//! the `async_resource_ref` needs to satisfy
+template <class... _Properties>
+using async_resource_ref = basic_resource_ref<_ResourceKind::_Asynchronous, _Properties...>;
+
+#endif // _CCCL_DOXYGEN_INVOKED
 
 //! @rst
 //! .. _cudax-memory-resource-make-any-resource:
@@ -313,11 +808,14 @@ using any_async_resource = basic_any_resource<_CUDA_VMR::_AllocType::_Async, _Pr
 //! Factory function for `any_resource` objects
 //! -------------------------------------------
 //!
-//! ``make_any_resource`` constructs an :ref:`any_resource <cudax-memory-resource-any-resource>` object that wraps a
-//! newly constructed instance of the given resource type. The resource type must satisfy the ``cuda::mr::resource``
-//! concept and provide all of the properties specified in the template parameter pack.
+//! ``make_any_resource`` constructs an :ref:`any_resource
+//! <cudax-memory-resource-any-resource>` object that wraps a newly constructed
+//! instance of the given resource type. The resource type must satisfy the
+//! ``cuda::mr::resource`` concept and provide all of the properties specified
+//! in the template parameter pack.
 //!
-//! @param __args The arguments used to construct the instance of the resource type.
+//! @param __args The arguments used to construct the instance of the resource
+//! type.
 //!
 //! @endrst
 template <class _Resource, class... _Properties, class... _Args>
@@ -325,7 +823,7 @@ auto make_any_resource(_Args&&... __args) -> any_resource<_Properties...>
 {
   static_assert(_CUDA_VMR::resource<_Resource>, "_Resource does not satisfy the cuda::mr::resource concept");
   static_assert(_CUDA_VMR::resource_with<_Resource, _Properties...>,
-                "Resource does not satisfy the required properties");
+                "The provided _Resource type does not support the requested properties");
   return any_resource<_Properties...>{_CUDA_VSTD::in_place_type<_Resource>, _CUDA_VSTD::forward<_Args>(__args)...};
 }
 
@@ -335,11 +833,14 @@ auto make_any_resource(_Args&&... __args) -> any_resource<_Properties...>
 //! Factory function for `any_async_resource` objects
 //! -------------------------------------------------
 //!
-//! ``make_any_async_resource`` constructs an :ref:`any_async_resource <cudax-memory-resource-any-async-resource>`
-//! object that wraps a newly constructed instance of the given resource type. The resource type must satisfy the
-//! ``cuda::mr::async_resource`` concept and provide all of the properties specified in the template parameter pack.
+//! ``make_any_async_resource`` constructs an :ref:`any_async_resource
+//! <cudax-memory-resource-any-async-resource>` object that wraps a newly
+//! constructed instance of the given resource type. The resource type must
+//! satisfy the ``cuda::mr::async_resource`` concept and provide all of the
+//! properties specified in the template parameter pack.
 //!
-//! @param __args The arguments used to construct the instance of the resource type.
+//! @param __args The arguments used to construct the instance of the resource
+//! type.
 //!
 //! @endrst
 template <class _Resource, class... _Properties, class... _Args>
@@ -348,10 +849,12 @@ auto make_any_async_resource(_Args&&... __args) -> any_async_resource<_Propertie
   static_assert(_CUDA_VMR::async_resource<_Resource>,
                 "_Resource does not satisfy the cuda::mr::async_resource concept");
   static_assert(_CUDA_VMR::async_resource_with<_Resource, _Properties...>,
-                "Resource does not satisfy the required properties");
+                "The provided _Resource type does not support the requested properties");
   return any_async_resource<_Properties...>{_CUDA_VSTD::in_place_type<_Resource>, _CUDA_VSTD::forward<_Args>(__args)...};
 }
 
 } // namespace cuda::experimental
 
-#endif //_CUDAX__MEMORY_RESOURCE_ANY_RESOURCE_H
+_CCCL_POP_MACROS
+
+#endif // _CUDAX__MEMORY_RESOURCE_ANY_RESOURCE_H
diff --git a/cudax/include/cuda/experimental/__memory_resource/device_memory_pool.cuh b/cudax/include/cuda/experimental/__memory_resource/device_memory_pool.cuh
index f3ffcfeea24..5a01c329106 100644
--- a/cudax/include/cuda/experimental/__memory_resource/device_memory_pool.cuh
+++ b/cudax/include/cuda/experimental/__memory_resource/device_memory_pool.cuh
@@ -31,12 +31,12 @@
 
 #  include <cuda/__memory_resource/get_property.h>
 #  include <cuda/__memory_resource/properties.h>
-#  include <cuda/__memory_resource/resource_ref.h>
 #  include <cuda/std/__cuda/api_wrapper.h>
 #  include <cuda/std/__new_>
 #  include <cuda/std/span>
 #  include <cuda/stream_ref>
 
+#  include <cuda/experimental/__memory_resource/any_resource.cuh>
 #  include <cuda/experimental/__stream/stream.cuh>
 
 #  if _CCCL_STD_VER >= 2014
diff --git a/cudax/include/cuda/experimental/__memory_resource/device_memory_resource.cuh b/cudax/include/cuda/experimental/__memory_resource/device_memory_resource.cuh
index c0aedab7fa9..67abd02839e 100644
--- a/cudax/include/cuda/experimental/__memory_resource/device_memory_resource.cuh
+++ b/cudax/include/cuda/experimental/__memory_resource/device_memory_resource.cuh
@@ -39,6 +39,7 @@
 #  include <cuda/stream_ref>
 
 #  include <cuda/experimental/__device/device_ref.cuh>
+#  include <cuda/experimental/__memory_resource/any_resource.cuh>
 #  include <cuda/experimental/__memory_resource/device_memory_pool.cuh>
 #  include <cuda/experimental/__memory_resource/properties.cuh>
 #  include <cuda/experimental/__stream/stream.cuh>
diff --git a/cudax/include/cuda/experimental/__utility/basic_any.cuh b/cudax/include/cuda/experimental/__utility/basic_any.cuh
new file mode 100644
index 00000000000..ab4e4919eba
--- /dev/null
+++ b/cudax/include/cuda/experimental/__utility/basic_any.cuh
@@ -0,0 +1,508 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of CUDA Experimental in CUDA C++ Core Libraries,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef __CUDAX_DETAIL_BASIC_ANY_H
+#define __CUDAX_DETAIL_BASIC_ANY_H
+
+#include <cuda/__cccl_config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+//! @file basic_any.hpp
+//!
+//! @brief This file provides the implementation of the `basic_any` class
+//! template.
+//!
+//! The `basic_any` class template generates a type-erasing wrapper for types
+//! described by a user-provided _interface_. An interface is a class template
+//! that has member and/or friend functions that dispatch to the appropriate
+//! pseudo-virtual functions, and a nested `overrides` type alias that maps the
+//! members of a given type to the pseudo-virtuals. Objects that implement the
+//! interface will be stored in-situ in the `basic_any` object if possible;
+//! otherwise, they will be stored on the heap.
+//!
+//! A simple interface looks like this (where `cudax` is an alias for
+//! `cuda::experimental`):
+//!
+//! @code
+//! template <class...>
+//! struct icat : cudax::interface<icat>
+//! {
+//!   void meow() const
+//!   {
+//!     // dispatch to the icat::meow override:
+//!     cudax::virtcall<&icat::meow>(this);
+//!   }
+//!
+//!   template <class Cat>
+//!   using overrides = cudax::overrides_for<Cat, &Cat::meow>;
+//! };
+//!
+//! // `any_cat` is a type-erasing wrapper that can store any object whose type
+//! // satisfies the `icat` interface.
+//! using any_cat = cudax::basic_any<icat<>>;
+//! @endcode
+//!
+//! The `any_cat` type can now be used to store any object that implements the
+//! `icat` interface. For example:
+//!
+//! @code
+//! struct siamese
+//! {
+//!   void meow() const
+//!   {
+//!     std::cout << "meow" << std::endl;
+//!   }
+//! };
+//!
+//! any_cat cat = siamese{};
+//! cat.meow(); // prints "meow"
+//! @endcode
+//!
+//!
+//! ## The `basic_any` type
+//!
+//! For an interface `I`, the `basic_any<I>` has the following member functions
+//! in addition to those provided by `I`:
+//!
+//! @code
+//! void swap(basic_any<I>& other) noexcept;
+//!
+//! template <class T, class... Args>
+//! T& emplace(Args&&... args);
+//!
+//! template <class T, class U, class... Args>
+//! T& emplace(std::initializer_list<U> il, Args&&... args);
+//!
+//! bool has_value() const noexcept;
+//!
+//! void reset() noexcept;
+//!
+//! const std::type_info& type() const noexcept;
+//!
+//! const std::type_info& interface() const noexcept;
+//!
+//! bool __in_situ() const noexcept;
+//! @endcode
+//!
+//! These members behave as they do for `std::any`. The `interface()` member
+//! function returns the `std::type_info` object for the _dynamic_ interface of
+//! the stored object, which could be different from `I` if the `basic_any`
+//! object was constructed from a `basic_any<J>`, where `J` extends `I` (see
+//! the next section).
+//!
+//! ## Interface Extension
+//!
+//! An interface can extend other interfaces. We can make `any_cat` copyable by
+//! extending the `cudax::icopyable` interface:
+//!
+//! @code
+//! template <class...>
+//! struct icat
+//!   : cudax::interface<icat, cudax::extends<cudax::icopyable<>>>
+//! {
+//!   ... as before ...
+//! @endcode
+//!
+//! The `cudax::extends` template is variadic to allow extending multiple
+//! interfaces. Interface extension works like virtual inheritance in C++; the
+//! same interface can be inherited multiple times, either directly or
+//! indirectly, without creating any ambiguity.
+//!
+//! Conversion from a "derived" `basic_any` (e.g., `any_cat`) to a "base"
+//! `basic_any` (e.g., `basic_any<icopyable<>>`) is supported.
+//!
+//! ## Pointers and References
+//!
+//! The `basic_any` class template can hold pointers and references to objects
+//! that implement the interface. For example:
+//!
+//! @code
+//! // `any_cat_ptr` is a type-erasing wrapper that can store a pointer to any
+//! // (non-const) object whose type implements the `icat` interface.
+//! using any_cat_ptr = cudax::basic_any<icat<>*>; // note the pointer type!
+//!
+//! // store a pointer to a siamese cat in a basic_any object
+//! siamese fluffy;
+//! any_cat_ptr pcat1 = &fluffy;
+//! pcat1->meow(); // prints "meow"
+//!
+//! // a basic_any pointer can also point to a type-erased object:
+//! any_cat cat2 = fluffy;
+//! any_cat_ptr pcat2 = &cat2;
+//! pcat2->meow(); // prints "meow"
+//! @endcode
+//!
+//! If the base interface (in this case, `icat<>`) extends `icopyable<>` or
+//! `imovable<>`, then you can copy or move out of a dereferenced basic_any
+//! pointer. For example:
+//!
+//! @code
+//! any_cat_ptr pcat = &fluffy;
+//! any_cat copycat = *pcat;            // copy from fluffy
+//! any_cat movecat = std::move(*pcat); // move from fluffy
+//! @endcode
+//!
+//! Type-erased references are supported as well. For example:
+//!
+//! @code
+//! // `any_cat_ref` is a type-erasing wrapper that can store a (non-owning)
+//! // reference to any (non-const) object whose type implements the `icat`
+//! // interface.
+//! using any_cat_ref = cudax::basic_any<icat<>&>; // note the reference type!
+//!
+//! // store a non-const reference to a siamese cat in a basic_any object:
+//! siamese fluffy;
+//! any_cat_ref rcat1 = fluffy;
+//! rcat1.meow(); // prints "meow"
+//! @endcode
+//!
+//! All the conversion sequences that are valid for pointers and references are
+//! also valid for basic_any pointers and references. For example, a
+//! `basic_any<I*>` can be implicitly converted to a `basic_any<I const*>`, and
+//! a `basic_any<IDerived&>` is implicitly convertible to a
+//! `basic_any<IBase&>`.
+//!
+//! @warning **You cannot use `std::move` to move a value out of a basic_any
+//! reference.** Although `any_cat value = std::move(rcat1);` will compile and
+//! looks perfectly reasonable, it will not actually move the value out of
+//! `rcat1`. Instead, it will copy the value. `std::move(rcat1)` is an rvalue
+//! reference of type `any_cat_ref`, which continues to behave like an lvalue.
+//! For this reason, basic_any references all have a `move` member function that
+//! can be used to move the value out of the reference: `any_cat value =
+//! rcat1.move();`.
+//!
+//! ## In-Situ Storage
+//!
+//! Small objects with non-throwing move constructors can be stored in-situ in
+//! the `basic_any` object. The size of the in-situ buffer is determined by the
+//! interface's `::size` member, which defaults to `3 * sizeof(void*)` and
+//! cannot be smaller than `sizeof(void*)`. The alignment of the in-situ buffer
+//! is determined by the interface's `::align` member, which defaults to
+//! `alignof(std::max_align_t)` and cannot be smaller than `alignof(void*)`.
+//!
+//! For convenience, the `cudax::interface` template lets you specify the size
+//! and alignment of the in-situ buffer directly:
+//!
+//! @code
+//! template <class...>
+//! struct icat
+//!   : cudax::interface<icat,
+//!                      cudax::extends<cudax::icopyable<>>,
+//!                      2 * sizeof(void*),  // in-situ buffer size
+//!                      alignof(void*)>     // in-situ buffer alignment
+//! {
+//!   ... as before ...
+//! @endcode
+//!
+//! An object of type `T` will be stored in-situ in a `basic_any<I>` object if
+//! the following conditions are met:
+//!
+//! - `I::size >= sizeof(T)`, and
+//! - `I::align % alignof(T) == 0`, and
+//! - `std::is_nothrow_move_constructible_v<T> == true`
+//!
+//! If any of these conditions are not met, the object will be stored on the
+//! heap. When such a `basic_any` object is copied, a new `T` object will be
+//! dynamically allocated and initialized with the old object. In other words,
+//! `basic_any` objects have value semantics regardless of how the wrapped
+//! object is stored. All `basic_any` objects are nothrow move constructible.
+//!
+//! `basic_any` pointer and reference types (`basic_any<I*>` and
+//! `basic_any<I&>`) ignore the interface's `::size` and `::align` members.
+//! Rather than an internal buffer, they store the pointer or reference
+//! directly.
+//!
+//! ## Explicit Casting
+//!
+//! TODO
+//!
+//! ## Defining An Interface
+//!
+//! An interface must be a variadic class template that inherits from the
+//! `cudax::interface` template as described above. The members of the interface
+//! stub functions, aka thunks, that both define the interface and dispatch to
+//! the type-erased pseudo-virtual overrides. You use the `cudax::virtcall`
+//! function to dispatch to the pseudo-virtuals, using the member pointer of the
+//! thunk as a key for dispatching to the correct function.
+//!
+//! The following example shows how to define an interface that will give us the
+//! behavior of `std::function`. The interface itself needs to be parameterized
+//! by the function signature, which involves some contortions:
+//!
+//! @code
+//! // We use an outer template to bind the function signature to the interface.
+//! template <class Signature>
+//! struct _with_signature;
+//!
+//! template <class Ret, class... Args>
+//! struct _with_signature<Ret(Args...)>
+//! {
+//!   // The actual interface is a variadic class template that inherits from
+//!   // `cudax::interface` and contains the thunks.
+//!   template <class...>
+//!   struct _ifuntion
+//!     : cudax::interface<_ifunction, cudax::extends<cudax::icopyable<>>>
+//!   {
+//!     Ret operator()(Args... args) const
+//!     {
+//!       return cudax::virtcall<&_ifunction::operator()>(this, std::forward<Args>(args)...);
+//!     }
+//!
+//!     template <class F>
+//!     using overrides = cudax::overrides_for<F, static_cast<Ret (F::*)(Args...)
+//!     const>(&F::operator())>;
+//!   };
+//! };
+//!
+//! template <class Signature>
+//! using ifunction = _with_signature<Signature>::template _ifunction<>;
+//!
+//! template <class Signature>
+//! using any_function = cudax::basic_any<ifunction<Signature>>;
+//! @endcode
+//!
+//! With the `any_function` template defined above, we can now store any callable
+//! object that has the same signature as the `Signature` template parameter.
+//!
+//! @code
+//! any_function<int(int, int)> fn = std::plus<int>{};
+//! assert(fn(1, 2) == 3);
+//! @endcode
+//!
+//! Within a thunk of an interface `I<>`, the `this` pointer has type
+//! `I<J>*`, where `J` is the interface used to parameterize the `basic_any`
+//! object. For example, imagine an interface `ialley_cat` that extends `icat`.
+//! `basic_any<ialley_cat<>>` inherits publicly from `icat<ialley_cat<>>`, which
+//! will be the type of the `this` pointer in the `icat<...>::meow()` thunk.
+//!
+//! Sometimes it is necessary to access the full `basic_any` object from within
+//! the thunk. You can do this by passing the `this` pointer to the
+//! `cudax::basic_any_from` function, which will return a pointer to the full
+//! `basic_any` object; a `basic_any<ialley_cat<>>*` in this case.
+//!
+//! ## Using Free Functions As Overrides
+//!
+//! So far, we have only seen how to bind member functions to an interface. But
+//! what if we want to bind a free function? The `cudax::overrides_for` template can
+//! bind free functions to an interface as well. Here is an example that uses a
+//! free function, `_equal_to<T>`, to define the `iequality_comparable`
+//! interface:
+//!
+//! @code
+//! template <class T>
+//! auto _equal_to(T const& lhs, std::type_info const& rhs_type, void const* rhs)
+//!   -> decltype(lhs == lhs) // SFINAE out if `lhs == lhs` is ill-formed
+//! {
+//!   return (rhs_type == typeid(T)) ? (lhs == *static_cast<T const*>(rhs)) : false;
+//! }
+//!
+//! template <class...>
+//! struct iequality_comparable : cudax::interface<iequality_comparable>
+//! {
+//!   friend bool operator==(iequality_comparable const& lhs, iequality_comparable const& rhs)
+//!   {
+//!     // downcast the `rhs` object to the correct specialization of `basic_any`:
+//!     auto const& rhs_any  = cudax::basic_any_from(rhs);
+//!     // get the object pointer from the `rhs` object:
+//!     void const* rhs_optr = cudax::any_cast<void const>(&rhs_any);
+//!     // dispatch to the `_equal_to` override:
+//!     return cudax::virtcall<&_equal_to<iequality_comparable>>(this, rhs_any.type(), rhs_optr);
+//!   }
+//!
+//!   friend bool operator!=(iequality_comparable const& lhs, iequality_comparable const& rhs)
+//!   {
+//!     return !(lhs == rhs);
+//!   }
+//!
+//!   template <class T>
+//!   using overrides = cudax::overrides_for<T, &_equal_to<T>>;
+//! };
+//! @endcode
+//!
+//! ## Implementation Details
+//!
+//! For an interface `I<>`, let `IBases<>...` be the (flattened, uniqued) list
+//! of interfaces that `I<>` extends, either directly or indirectly.
+//! `basic_any<I<>>` inherits publicly from `I<I<>>` and `IBases<I<>>...`.
+//! Therefore, the members of `basic_any<I<>>` are the thunks of `I<>`
+//! and all the interfaces that `I<>` extends.
+//!
+//! The `basic_any<I<>>` type looks roughly like this:
+//!
+//! @code
+//! template <template <class...> class I>
+//! struct _CCCL_TYPE_VISIBILITY_DEFAULT basic_any<I<>> : I<I<>>, IBases<I<>>...
+//! {
+//!   // constructors, destructor, assignment operators, etc.
+//!
+//! private:
+//!   // a tagged pointer to the object's vtable
+//!   __tagged_ptr<__vtable<I<>> const*> __vptr_;
+//!
+//!   // the object's buffer
+//!   alignas(I<>::align) std::byte __buffer_[I<>::size];
+//! };
+//! @endcode
+//!
+//! The `__tagged_ptr` type wraps a pointer that uses the lowest order bit to
+//! indicate whether the buffer stores the object in-situ, or if it stores a
+//! pointer to the object on the heap.
+//!
+//! The type `__vtable<I<>>` is a struct that aggregates the vtables of `I<>`
+//! and all the interfaces that `I<>` extends. It also aggregates an "RTTI"
+//! struct that contains metadata about the object and the vtable.
+//! `__vtable<I<>>` is an alias for a type that looks like this:
+//!
+//! @code
+//! template <class I, class... {base-interfaces-of-I}>
+//! struct __vtable_tuple
+//!   : __rtti_ex
+//!   , __vtable_for<I>
+//!   , __vtable_for<{base-interfaces-of-I}>...
+//! {
+//!    //... constexpr constructors ...
+//!
+//!    template <class Interface>
+//!    __vtable_for<Interface> const* __query_interface(Interface) const noexcept;
+//! };
+//! @endcode
+//!
+//! The `__rtti_ex` struct contains a map from interface typeid's to the pointer
+//! to the vtable for that interface. This map is used for `dynamic_cast`-like
+//! functionality. `__rtti_ex` is derived from a `__rtti` class that has
+//! metadata about the type-erased object like its typeid, size, and alignment.
+//!
+//! `__vtable_for<I<>>` names a struct that contains function pointers --
+//! "overrides" -- for the pseudo-virtual functions of `I<>`. It is actually an
+//! alias for a nested struct of the `cudax::overrides_for` template. The actual vtable
+//! struct looks like this:
+//!
+//! @code
+//! template <class InterfaceOrObject, auto... Mbrs>
+//! struct overrides_for
+//! {
+//!   // InterfaceOrObject is either the type of the unspecialized interface or
+//!   // the type of an object that implements the interface and that is being
+//!   // type-erased.
+//!   struct __vtable
+//!     : __rtti_base         // described below
+//!     , __virtual_fn<Mbrs>... // the pseudo-virtual overrides
+//!   {
+//!     // Within the __vtable struct, InterfaceOrObject is the type of the
+//!     // unspecialized interface.
+//!
+//!     // ... constexpr constructors ...
+//!
+//!     template <class Interface>
+//!     __vtable_for<Interface> const* __query_interface(Interface) const noexcept;
+//!
+//!     // Pointers to the vtables of I's bases:
+//!     using I = InterfaceOrObject;
+//!     __rtti_base const* __vptr_map[{count-of-I's-bases}];
+//!   };
+//! };
+//! @endcode
+//!
+//! Here is the one trick that makes the whole of `basic_any` work:
+//! `__vtable_for<I<>>` is an alias for `I<>::overrides<I<>>::__vtable`. For the
+//! `icat` interface defined above, the `icat<>::overrides` alias looks like this:
+//!
+//! @code
+//! template <class T>
+//! using overrides = cudax::overrides_for<T, &T::meow>;
+//! @endcode
+//!
+//! So `__vtable_for<icat<>>` is an alias for `cudax::overrides_for<icat<>,
+//! &icat<>::meow>::__vtable`. `icat<>::meow` is the thunk in the `icat<>`
+//! interface.
+//!
+//! We can now describe how pseudo-virtual dispatch works. Given an object `cat`
+//! of type `basic_any<ialley_cat<>>` that we defined above, a call of
+//! `cat.meow()` does the following:
+//!
+//! - Within the `meow` thunk, `this` has type `icat<ialley_cat<>>*`.
+//!   The thunk calls `cudax::virtcall<&icat::meow>(this)`.
+//!
+//! - `&icat::meow` is a pointer to the `icat<ialley_cat<>>::meow` thunk. The
+//!   `virtcall` infers from the `this` argument that the unspecialized
+//!   interface is `icat<>`. `virtcall` maps the `&icat<ialley_cat<>>::meow`
+//!   member pointer to the `&icat<>::meow` member pointer by building a map
+//!   from `icat<ialley_cat<>>::overrides<icat<ialley_cat<>>` to
+//!   `icat<>::overrides<icat<>>`.
+//!
+//! - Having established that the override for `icat<>::meow` is the one that
+//!   should be called, `virtcall` calls
+//!   `basic_any_from({the-this-ptr-from-above})` to obtain a pointer to the
+//!   full `basic_any<ialley_cat<>>` object. From there, it pulls out the vtable
+//!   pointer (which has type `__vtable<ialley_cat<>> const*`) and casts it to
+//!   `__vtable_for<icat<>> const*`. (As described above,
+//!   `__vtable<ialley_cat<>>` inherits from `__vtable_for<icat<>>`.) From
+//!   there, it further casts the pointer to `__virtual_fn<&icat<>::meow>
+//!   const*`, which contains the override for the `&icat<>::meow`
+//!   pseudo-virtual.
+//!
+//! The `__virtual_fn` template wraps a function pointer that dispatches to the
+//! correct member of the type-erased object. It is parameterized by the member
+//! pointer of the thunk. `__virtual_fn<&icat<>::meow>` is handled by a
+//! partial specialization that looks like this:
+//!
+//! @code
+//! template <auto Mbr, class = decltype(Mbr)>
+//! struct __virtual_fn;
+//!
+//! template <auto Mbr, class R, class C, class... Args>
+//! struct __virtual_fn<Mbr, R (C::*)(Args...)>
+//! {
+//!   using __function_t = R(*)(void*, Args...);
+//!   __function_t __fn_;
+//! };
+//! @endcode
+//!
+//! When a `basic_any<icat<>>` object is constructed from an object `fluffy` of
+//! type `siamese`, a global constexpr object of type `__vtable<icat<>>` is
+//! instantiated and initialized with `__tag<siamese>{}` (where `__tag` is an
+//! empty struct). That will cause the base sub-object `__vtable_for<icat<>>` --
+//! aka, `icat<>::overrides<icat<>>::__vtable`, aka `cudax::overrides_for<icat<>,
+//! &icat<>::meow>::__vtable` -- to be initialized with an object of type
+//! `icat<>::overrides<siamese>`, aka `cudax::overrides_for<siamese, &siamese::meow>`.
+//! And that causes `__virtual_fn<&icat<>::meow>` to be initialized with a
+//! pointer to a function that casts its `void*` argument to `siamese*` and
+//! dispatches to its `meow` member function. So that's how the vtable gets
+//! populated with the correct function pointers. In the `basic_any`
+//! constructor, a pointer to that vtable is saved in its `__vptr_` member.
+
+// IWYU pragma: begin_exports
+#include <cuda/experimental/__utility/basic_any/any_cast.cuh>
+#include <cuda/experimental/__utility/basic_any/basic_any_from.cuh>
+#include <cuda/experimental/__utility/basic_any/basic_any_ptr.cuh>
+#include <cuda/experimental/__utility/basic_any/basic_any_ref.cuh>
+#include <cuda/experimental/__utility/basic_any/basic_any_value.cuh>
+#include <cuda/experimental/__utility/basic_any/conversions.cuh>
+#include <cuda/experimental/__utility/basic_any/dynamic_any_cast.cuh>
+#include <cuda/experimental/__utility/basic_any/interfaces.cuh>
+#include <cuda/experimental/__utility/basic_any/iset.cuh>
+#include <cuda/experimental/__utility/basic_any/overrides.cuh>
+#include <cuda/experimental/__utility/basic_any/rtti.cuh>
+#include <cuda/experimental/__utility/basic_any/semiregular.cuh>
+#include <cuda/experimental/__utility/basic_any/storage.cuh>
+#include <cuda/experimental/__utility/basic_any/tagged_ptr.cuh>
+#include <cuda/experimental/__utility/basic_any/virtcall.cuh>
+#include <cuda/experimental/__utility/basic_any/virtual_functions.cuh>
+#include <cuda/experimental/__utility/basic_any/virtual_tables.cuh>
+// IWYU pragma: end_exports
+
+#endif // __CUDAX_DETAIL_BASIC_ANY_H
diff --git a/cudax/include/cuda/experimental/__utility/basic_any/access.cuh b/cudax/include/cuda/experimental/__utility/basic_any/access.cuh
new file mode 100644
index 00000000000..f0d7ee072b5
--- /dev/null
+++ b/cudax/include/cuda/experimental/__utility/basic_any/access.cuh
@@ -0,0 +1,90 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of CUDA Experimental in CUDA C++ Core Libraries,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef __CUDAX_DETAIL_BASIC_ANY_ACCESS_H
+#define __CUDAX_DETAIL_BASIC_ANY_ACCESS_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__concepts/concept_macros.h>
+#include <cuda/std/__type_traits/remove_const.h>
+#include <cuda/std/__type_traits/remove_cvref.h>
+
+#include <cuda/experimental/__detail/utility.cuh>
+#include <cuda/experimental/__utility/basic_any/basic_any_fwd.cuh>
+#include <cuda/experimental/__utility/basic_any/conversions.cuh>
+#include <cuda/experimental/__utility/basic_any/interfaces.cuh>
+
+_CCCL_PUSH_MACROS
+#undef interface
+
+namespace cuda::experimental
+{
+//!
+//! basic_any_access
+//!
+struct __basic_any_access
+{
+  template <class _Interface>
+  _CUDAX_TRIVIAL_HOST_API static auto __make() noexcept -> basic_any<_Interface>
+  {
+    return basic_any<_Interface>{};
+  }
+
+  _CCCL_TEMPLATE(class _SrcCvAny, class _DstInterface)
+  _CCCL_REQUIRES(__any_castable_to<_SrcCvAny, basic_any<_DstInterface>>)
+  _CUDAX_TRIVIAL_HOST_API static auto __cast_to(_SrcCvAny&& __from, basic_any<_DstInterface>& __to) noexcept(
+    noexcept(__to.__convert_from(static_cast<_SrcCvAny&&>(__from)))) -> void
+  {
+    static_assert(detail::__is_specialization_of<_CUDA_VSTD::remove_cvref_t<_SrcCvAny>, basic_any>);
+    __to.__convert_from(static_cast<_SrcCvAny&&>(__from));
+  }
+
+  _CCCL_TEMPLATE(class _SrcCvAny, class _DstInterface)
+  _CCCL_REQUIRES(__any_castable_to<_SrcCvAny*, basic_any<_DstInterface>>)
+  _CUDAX_TRIVIAL_HOST_API static auto
+  __cast_to(_SrcCvAny* __from, basic_any<_DstInterface>& __to) noexcept(noexcept(__to.__convert_from(__from))) -> void
+  {
+    static_assert(detail::__is_specialization_of<_CUDA_VSTD::remove_const_t<_SrcCvAny>, basic_any>);
+    __to.__convert_from(__from);
+  }
+
+  template <class _Interface>
+  _CUDAX_TRIVIAL_HOST_API static auto __get_vptr(basic_any<_Interface> const& __self) noexcept -> __vptr_for<_Interface>
+  {
+    return __self.__get_vptr();
+  }
+
+  template <class _Interface>
+  _CUDAX_TRIVIAL_HOST_API static auto __get_optr(basic_any<_Interface>& __self) noexcept -> void*
+  {
+    return __self.__get_optr();
+  }
+
+  template <class _Interface>
+  _CUDAX_TRIVIAL_HOST_API static auto __get_optr(basic_any<_Interface> const& __self) noexcept -> void const*
+  {
+    return __self.__get_optr();
+  }
+};
+
+} // namespace cuda::experimental
+
+_CCCL_POP_MACROS
+
+#endif // __CUDAX_DETAIL_BASIC_ANY_ACCESS_H
diff --git a/cudax/include/cuda/experimental/__utility/basic_any/any_cast.cuh b/cudax/include/cuda/experimental/__utility/basic_any/any_cast.cuh
new file mode 100644
index 00000000000..1acbcb33382
--- /dev/null
+++ b/cudax/include/cuda/experimental/__utility/basic_any/any_cast.cuh
@@ -0,0 +1,85 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of CUDA Experimental in CUDA C++ Core Libraries,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef __CUDAX_DETAIL_BASIC_ANY_ANY_CAST_H
+#define __CUDAX_DETAIL_BASIC_ANY_ANY_CAST_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__concepts/concept_macros.h>
+#include <cuda/std/__type_traits/is_const.h>
+#include <cuda/std/__type_traits/is_void.h>
+#include <cuda/std/__utility/move.h>
+#include <cuda/std/__utility/typeid.h>
+
+#include <cuda/experimental/__utility/basic_any/access.cuh>
+#include <cuda/experimental/__utility/basic_any/basic_any_fwd.cuh>
+#include <cuda/experimental/__utility/basic_any/interfaces.cuh>
+
+_CCCL_PUSH_MACROS
+#undef interface
+
+namespace cuda::experimental
+{
+//!
+//! __valid_any_cast
+//!
+template <class _Interface, class _Tp>
+inline constexpr bool __valid_any_cast = true;
+
+template <class _Interface, class _Tp>
+inline constexpr bool __valid_any_cast<_Interface*, _Tp> = false;
+
+template <class _Interface, class _Tp>
+inline constexpr bool __valid_any_cast<_Interface*, _Tp*> =
+  !_CUDA_VSTD::is_const_v<_Interface> || _CUDA_VSTD::is_const_v<_Tp>;
+
+//!
+//! any_cast
+//!
+_CCCL_TEMPLATE(class _Tp, class _Interface)
+_CCCL_REQUIRES(__satisfies<_Tp, _Interface> || _CUDA_VSTD::is_void_v<_Tp>)
+_CCCL_NODISCARD _CUDAX_HOST_API auto any_cast(basic_any<_Interface>* __self) noexcept -> _Tp*
+{
+  static_assert(__valid_any_cast<_Interface, _Tp>);
+  if (__self && (_CUDA_VSTD::is_void_v<_Tp> || __self->type() == _CCCL_TYPEID(_Tp)))
+  {
+    return static_cast<_Tp*>(__basic_any_access::__get_optr(*__self));
+  }
+  return nullptr;
+}
+
+_CCCL_TEMPLATE(class _Tp, class _Interface)
+_CCCL_REQUIRES(__satisfies<_Tp, _Interface> || _CUDA_VSTD::is_void_v<_Tp>)
+_CCCL_NODISCARD _CUDAX_HOST_API auto any_cast(basic_any<_Interface> const* __self) noexcept -> _Tp const*
+{
+  static_assert(__valid_any_cast<_Interface, _Tp>);
+  if (__self && (_CUDA_VSTD::is_void_v<_Tp> || __self->type() == _CCCL_TYPEID(_Tp)))
+  {
+    return static_cast<_Tp const*>(__basic_any_access::__get_optr(*__self));
+  }
+  return nullptr;
+}
+
+// TODO: implement the same overloads as for std::any_cast
+
+} // namespace cuda::experimental
+
+_CCCL_POP_MACROS
+
+#endif // __CUDAX_DETAIL_BASIC_ANY_ANY_CAST_H
diff --git a/cudax/include/cuda/experimental/__utility/basic_any/basic_any_base.cuh b/cudax/include/cuda/experimental/__utility/basic_any/basic_any_base.cuh
new file mode 100644
index 00000000000..daf8a01f260
--- /dev/null
+++ b/cudax/include/cuda/experimental/__utility/basic_any/basic_any_base.cuh
@@ -0,0 +1,138 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of CUDA Experimental in CUDA C++ Core Libraries,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef __CUDAX_DETAIL_BASIC_ANY_BASIC_ANY_BASE_H
+#define __CUDAX_DETAIL_BASIC_ANY_BASIC_ANY_BASE_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__concepts/concept_macros.h>
+#include <cuda/std/cstddef> // for byte
+
+#include <cuda/experimental/__utility/basic_any/basic_any_fwd.cuh>
+#include <cuda/experimental/__utility/basic_any/interfaces.cuh>
+#include <cuda/experimental/__utility/basic_any/storage.cuh>
+#include <cuda/experimental/__utility/basic_any/tagged_ptr.cuh>
+
+_CCCL_PUSH_MACROS
+#undef interface
+
+namespace cuda::experimental
+{
+template <class _Interface>
+_CUDAX_HOST_API auto __is_basic_any_test(basic_any<_Interface>&&) -> basic_any<_Interface>&&;
+template <class _Interface>
+_CUDAX_HOST_API auto __is_basic_any_test(basic_any<_Interface>&) -> basic_any<_Interface>&;
+template <class _Interface>
+_CUDAX_HOST_API auto __is_basic_any_test(basic_any<_Interface> const&) -> basic_any<_Interface> const&;
+
+// clang-format off
+template <class _Tp>
+_CCCL_CONCEPT __is_basic_any =
+  _CCCL_REQUIRES_EXPR((_Tp), _Tp& __value)
+  (
+    __is_basic_any_test(__value)
+  );
+// clang-format on
+
+#if !defined(_CCCL_NO_CONCEPTS)
+template <class _Interface, int = 0>
+struct __basic_any_base : __interface_of<_Interface>
+{
+private:
+  template <class, class>
+  friend struct basic_any;
+  friend struct __basic_any_access;
+
+  static constexpr size_t __size_  = __buffer_size(_Interface::size);
+  static constexpr size_t __align_ = __buffer_align(_Interface::align);
+
+  __tagged_ptr<__vptr_for<_Interface>> __vptr_{};
+  alignas(__align_) _CUDA_VSTD_NOVERSION::byte __buffer_[__size_];
+};
+#else // ^^^ !_CCCL_NO_CONCEPTS ^^^ / vvv _CCCL_NO_CONCEPTS vvv
+// Without concepts, we need a base class to correctly implement movability
+// and copyability.
+template <class _Interface, int = extension_of<_Interface, imovable<>> + extension_of<_Interface, icopyable<>>>
+struct __basic_any_base;
+
+template <class _Interface>
+struct __basic_any_base<_Interface, 2> : __interface_of<_Interface> // copyable interfaces
+{
+  __basic_any_base() = default;
+
+  _CUDAX_HOST_API __basic_any_base(__basic_any_base&& __other) noexcept
+  {
+    static_cast<basic_any<_Interface>*>(this)->__convert_from(static_cast<basic_any<_Interface>&&>(__other));
+  }
+
+  _CUDAX_HOST_API __basic_any_base(__basic_any_base const& __other)
+  {
+    static_cast<basic_any<_Interface>*>(this)->__convert_from(static_cast<basic_any<_Interface> const&>(__other));
+  }
+
+  _CUDAX_HOST_API auto operator=(__basic_any_base&& __other) noexcept -> __basic_any_base&
+  {
+    static_cast<basic_any<_Interface>*>(this)->__assign_from(static_cast<basic_any<_Interface>&&>(__other));
+    return *this;
+  }
+
+  _CUDAX_HOST_API auto operator=(__basic_any_base const& __other) -> __basic_any_base&
+  {
+    static_cast<basic_any<_Interface>*>(this)->__assign_from(static_cast<basic_any<_Interface> const&>(__other));
+    return *this;
+  }
+
+private:
+  template <class, class>
+  friend struct basic_any;
+  friend struct __basic_any_access;
+
+  static constexpr size_t __size_  = __buffer_size(_Interface::size);
+  static constexpr size_t __align_ = __buffer_align(_Interface::align);
+
+  __tagged_ptr<__vptr_for<_Interface>> __vptr_{};
+  alignas(__align_) _CUDA_VSTD_NOVERSION::byte __buffer_[__size_];
+};
+
+template <class _Interface>
+struct __basic_any_base<_Interface, 1> : __basic_any_base<_Interface, 2> // move-only interfaces
+{
+  __basic_any_base()                                               = default;
+  __basic_any_base(__basic_any_base&&) noexcept                    = default;
+  __basic_any_base(__basic_any_base const&)                        = delete;
+  auto operator=(__basic_any_base&&) noexcept -> __basic_any_base& = default;
+  auto operator=(__basic_any_base const&) -> __basic_any_base&     = delete;
+};
+
+template <class _Interface>
+struct __basic_any_base<_Interface, 0> : __basic_any_base<_Interface, 2> // immovable interfaces
+{
+  __basic_any_base()                                               = default;
+  __basic_any_base(__basic_any_base&&) noexcept                    = delete;
+  __basic_any_base(__basic_any_base const&)                        = delete;
+  auto operator=(__basic_any_base&&) noexcept -> __basic_any_base& = delete;
+  auto operator=(__basic_any_base const&) -> __basic_any_base&     = delete;
+};
+#endif // ^^^ _CCCL_NO_CONCEPTS ^^^
+
+} // namespace cuda::experimental
+
+_CCCL_POP_MACROS
+
+#endif // __CUDAX_DETAIL_BASIC_ANY_BASIC_ANY_BASE_H
diff --git a/cudax/include/cuda/experimental/__utility/basic_any/basic_any_from.cuh b/cudax/include/cuda/experimental/__utility/basic_any/basic_any_from.cuh
new file mode 100644
index 00000000000..9413a153bde
--- /dev/null
+++ b/cudax/include/cuda/experimental/__utility/basic_any/basic_any_from.cuh
@@ -0,0 +1,89 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of CUDA Experimental in CUDA C++ Core Libraries,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef __CUDAX_DETAIL_BASIC_ANY_BASIC_ANY_FROM_H
+#define __CUDAX_DETAIL_BASIC_ANY_BASIC_ANY_FROM_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/experimental/__utility/basic_any/basic_any_fwd.cuh>
+
+_CCCL_PUSH_MACROS
+#undef interface
+
+namespace cuda::experimental
+{
+//!
+//! `basic_any_from`
+//!
+//! @brief This function is for use in the thunks in an interface to get
+//! a pointer or a reference to the full `basic_any` object.
+//!
+template <template <class...> class _Interface, class _Super>
+_CCCL_NODISCARD _CUDAX_TRIVIAL_HOST_API auto basic_any_from(_Interface<_Super>&& __self) noexcept -> basic_any<_Super>&&
+{
+  return static_cast<basic_any<_Super>&&>(__self);
+}
+
+template <template <class...> class _Interface, class _Super>
+_CCCL_NODISCARD _CUDAX_TRIVIAL_HOST_API auto basic_any_from(_Interface<_Super>& __self) noexcept -> basic_any<_Super>&
+{
+  return static_cast<basic_any<_Super>&>(__self);
+}
+
+template <template <class...> class _Interface, class _Super>
+_CCCL_NODISCARD _CUDAX_TRIVIAL_HOST_API auto
+basic_any_from(_Interface<_Super> const& __self) noexcept -> basic_any<_Super> const&
+{
+  return static_cast<basic_any<_Super> const&>(__self);
+}
+
+template <template <class...> class _Interface>
+_CCCL_NODISCARD _CUDAX_HOST_API auto basic_any_from(_Interface<> const&) noexcept -> basic_any<_Interface<>> const&
+{
+  // This overload is selected when called from the thunk of an unspecialized
+  // interface; e.g., `icat<>` rather than `icat<ialley_cat<>>`. The thunks of
+  // unspecialized interfaces are never called, they just need to exist.
+  _CCCL_UNREACHABLE();
+}
+
+template <template <class...> class _Interface, class _Super>
+_CCCL_NODISCARD _CUDAX_TRIVIAL_HOST_API auto basic_any_from(_Interface<_Super>* __self) noexcept -> basic_any<_Super>*
+{
+  return static_cast<basic_any<_Super>*>(__self);
+}
+
+template <template <class...> class _Interface, class _Super>
+_CCCL_NODISCARD _CUDAX_TRIVIAL_HOST_API auto
+basic_any_from(_Interface<_Super> const* __self) noexcept -> basic_any<_Super> const*
+{
+  return static_cast<basic_any<_Super> const*>(__self);
+}
+
+template <template <class...> class _Interface>
+_CCCL_NODISCARD _CUDAX_HOST_API auto basic_any_from(_Interface<> const*) noexcept -> basic_any<_Interface<>> const*
+{
+  // See comment above about the use of `basic_any_from` in the thunks of
+  // unspecialized interfaces.
+  _CCCL_UNREACHABLE();
+}
+} // namespace cuda::experimental
+
+_CCCL_POP_MACROS
+
+#endif // __CUDAX_DETAIL_BASIC_ANY_BASIC_ANY_FROM_H
diff --git a/cudax/include/cuda/experimental/__utility/basic_any/basic_any_fwd.cuh b/cudax/include/cuda/experimental/__utility/basic_any/basic_any_fwd.cuh
new file mode 100644
index 00000000000..54f870349e0
--- /dev/null
+++ b/cudax/include/cuda/experimental/__utility/basic_any/basic_any_fwd.cuh
@@ -0,0 +1,137 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of CUDA Experimental in CUDA C++ Core Libraries,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef __CUDAX_DETAIL_BASIC_ANY_FWD_H
+#define __CUDAX_DETAIL_BASIC_ANY_FWD_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/type_list.h>
+#include <cuda/std/cstddef> // for max_align_t
+#include <cuda/std/cstdint> // for uint8_t
+
+#include <cuda/experimental/__detail/config.cuh> // IWYU pragma: keep export
+#include <cuda/experimental/__detail/utility.cuh> // IWYU pragma: keep export
+
+// Some functions defined here have their addresses appear in public types
+// (e.g., in `cudax::overrides_for` specializations). If the function is declared
+// `__attribute__((visibility("hidden")))`, and if the address appears, say, in
+// the type of a member of a class that is declared
+// `__attribute__((visibility("default")))`, GCC complains bitterly. So we
+// avoid declaring those functions `hidden`. Instead of the typical `_CUDAX_HOST_API`
+// macro, we use `_CUDAX_PUBLIC_API` for those functions.
+#define _CUDAX_PUBLIC_API _CCCL_HOST
+
+_CCCL_PUSH_MACROS
+#undef interface
+
+namespace cuda::experimental
+{
+struct __primary;
+struct __secondary;
+
+template <class _Interface>
+struct __ireference;
+
+template <class _Interface, class _Select = __primary>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT basic_any;
+
+template <class _Interface, class _Select>
+struct _LIBCUDACXX_DECLSPEC_EMPTY_BASES basic_any<__ireference<_Interface>, _Select>;
+
+template <class _Interface>
+struct basic_any<_Interface*>;
+
+template <class _Interface>
+struct basic_any<_Interface&>;
+
+template <class _InterfaceOrModel, auto... _VirtualFnsOrOverrides>
+struct overrides_for;
+
+template <class _Interface, auto... _Mbrs>
+struct _LIBCUDACXX_DECLSPEC_EMPTY_BASES __basic_vtable;
+
+struct __rtti_base;
+
+struct __rtti;
+
+template <size_t NbrBases>
+struct __rtti_ex;
+
+template <class...>
+struct extends;
+
+template <template <class...> class, class = extends<>, size_t = 0, size_t = 0>
+struct interface;
+
+template <class _Interface, class... _Super>
+using __rebind_interface _CCCL_NODEBUG_ALIAS = typename _Interface::template __rebind<_Super...>;
+
+struct iunknown;
+
+template <class...>
+struct __iset;
+
+template <class...>
+struct __iset_vptr;
+
+template <class...>
+struct imovable;
+
+template <class...>
+struct icopyable;
+
+template <class...>
+struct iequality_comparable;
+
+template <class... _Tp>
+using __tag _CCCL_NODEBUG_ALIAS = _CUDA_VSTD::__type_list_ptr<_Tp...>;
+
+template <auto...>
+struct __ctag_;
+
+template <auto... _Is>
+using __ctag _CCCL_NODEBUG_ALIAS = __ctag_<_Is...>*;
+
+constexpr size_t __word                 = sizeof(void*);
+constexpr size_t __default_buffer_size  = 3 * __word;
+constexpr size_t __default_buffer_align = alignof(_CUDA_VSTD::max_align_t);
+
+using __make_type_list _CCCL_NODEBUG_ALIAS = _CUDA_VSTD::__type_quote<_CUDA_VSTD::__type_list>;
+
+_CCCL_NORETURN _CUDAX_HOST_API void __throw_bad_any_cast();
+
+enum class __vtable_kind : uint8_t
+{
+  __normal,
+  __rtti,
+};
+
+inline constexpr uint8_t __basic_any_version = 0;
+
+template <class _Interface>
+extern _Interface __remove_ireference_v; // specialized in interfaces.cuh
+
+template <class _Interface>
+using __remove_ireference_t _CCCL_NODEBUG_ALIAS = decltype(__remove_ireference_v<_Interface>);
+
+} // namespace cuda::experimental
+
+_CCCL_POP_MACROS
+
+#endif // __CUDAX_DETAIL_BASIC_ANY_FWD_H
diff --git a/cudax/include/cuda/experimental/__utility/basic_any/basic_any_ptr.cuh b/cudax/include/cuda/experimental/__utility/basic_any/basic_any_ptr.cuh
new file mode 100644
index 00000000000..bbc399a9d8d
--- /dev/null
+++ b/cudax/include/cuda/experimental/__utility/basic_any/basic_any_ptr.cuh
@@ -0,0 +1,307 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of CUDA Experimental in CUDA C++ Core Libraries,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef __CUDAX_DETAIL_BASIC_ANY_BASIC_ANY_PTR_H
+#define __CUDAX_DETAIL_BASIC_ANY_BASIC_ANY_PTR_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__concepts/concept_macros.h>
+#include <cuda/std/__concepts/derived_from.h>
+#include <cuda/std/__concepts/same_as.h>
+#include <cuda/std/__type_traits/is_const.h>
+#include <cuda/std/__type_traits/maybe_const.h>
+#include <cuda/std/__type_traits/remove_const.h>
+#include <cuda/std/__type_traits/remove_pointer.h>
+#include <cuda/std/__utility/typeid.h>
+
+#include <cuda/experimental/__utility/basic_any/basic_any_base.cuh>
+#include <cuda/experimental/__utility/basic_any/basic_any_from.cuh>
+#include <cuda/experimental/__utility/basic_any/basic_any_fwd.cuh>
+#include <cuda/experimental/__utility/basic_any/basic_any_ref.cuh>
+#include <cuda/experimental/__utility/basic_any/conversions.cuh>
+#include <cuda/experimental/__utility/basic_any/interfaces.cuh>
+#include <cuda/experimental/__utility/basic_any/rtti.cuh>
+#include <cuda/experimental/__utility/basic_any/virtual_tables.cuh>
+
+_CCCL_PUSH_MACROS
+#undef interface
+
+namespace cuda::experimental
+{
+//!
+//! basic_any<_Interface*>
+//!
+template <class _Interface>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT basic_any<_Interface*>
+{
+  using interface_type                 = _CUDA_VSTD::remove_const_t<_Interface>;
+  static constexpr bool __is_const_ptr = _CUDA_VSTD::is_const_v<_Interface>;
+
+  //!
+  //! Constructors
+  //!
+  basic_any() = default;
+
+  _CUDAX_TRIVIAL_HOST_API basic_any(_CUDA_VSTD::nullptr_t) {}
+
+  _CCCL_TEMPLATE(class _Tp, class _Up = _CUDA_VSTD::remove_const_t<_Tp>)
+  _CCCL_REQUIRES((!__is_basic_any<_Tp>) _CCCL_AND __satisfies<_Up, interface_type> _CCCL_AND(
+    __is_const_ptr || !_CUDA_VSTD::is_const_v<_Tp>))
+  _CUDAX_HOST_API basic_any(_Tp* __obj) noexcept
+  {
+    operator=(__obj);
+  }
+
+  _CUDAX_HOST_API basic_any(basic_any const& __other) noexcept
+  {
+    __convert_from(__other);
+  }
+
+  _CCCL_TEMPLATE(class _OtherInterface)
+  _CCCL_REQUIRES((!_CUDA_VSTD::same_as<_OtherInterface, _Interface>)
+                   _CCCL_AND __any_convertible_to<basic_any<_OtherInterface*>, basic_any<_Interface*>>)
+  _CUDAX_HOST_API basic_any(basic_any<_OtherInterface*> const& __other) noexcept
+  {
+    __convert_from(__other);
+  }
+
+  _CCCL_TEMPLATE(class _OtherInterface)
+  _CCCL_REQUIRES(__any_convertible_to<basic_any<_OtherInterface>&, basic_any<_Interface&>>)
+  _CUDAX_HOST_API basic_any(basic_any<_OtherInterface>* __other) noexcept
+  {
+    __convert_from(__other);
+  }
+
+  _CCCL_TEMPLATE(class _OtherInterface)
+  _CCCL_REQUIRES(__any_convertible_to<basic_any<_OtherInterface> const&, basic_any<_Interface&>>)
+  _CUDAX_HOST_API basic_any(basic_any<_OtherInterface> const* __other) noexcept
+  {
+    __convert_from(__other);
+  }
+
+  _CCCL_TEMPLATE(template <class...> class _OtherInterface, class _Super)
+  _CCCL_REQUIRES(__is_interface<_OtherInterface<_Super>> _CCCL_AND
+                   _CUDA_VSTD::derived_from<basic_any<_Super>, _OtherInterface<_Super>> _CCCL_AND
+                     _CUDA_VSTD::same_as<__normalized_interface_of<basic_any<_Super>*>, _Interface*>)
+  _CUDAX_HOST_API explicit basic_any(_OtherInterface<_Super>* __self) noexcept
+  {
+    __convert_from(basic_any_from(__self));
+  }
+
+  _CCCL_TEMPLATE(template <class...> class _OtherInterface, class _Super)
+  _CCCL_REQUIRES(__is_interface<_OtherInterface<_Super>> _CCCL_AND
+                   _CUDA_VSTD::derived_from<basic_any<_Super>, _OtherInterface<_Super>> _CCCL_AND
+                     _CUDA_VSTD::same_as<__normalized_interface_of<basic_any<_Super> const*>, _Interface*>)
+  _CUDAX_HOST_API explicit basic_any(_OtherInterface<_Super> const* __self) noexcept
+  {
+    __convert_from(basic_any_from(__self));
+  }
+
+  //!
+  //! Assignment operators
+  //!
+  _CUDAX_HOST_API auto operator=(_CUDA_VSTD::nullptr_t) noexcept -> basic_any&
+  {
+    reset();
+    return *this;
+  }
+
+  _CCCL_TEMPLATE(class _Tp, class _Up = _CUDA_VSTD::remove_const_t<_Tp>)
+  _CCCL_REQUIRES((!__is_basic_any<_Tp>) _CCCL_AND //
+                   __satisfies<_Up, interface_type> _CCCL_AND //
+                 (__is_const_ptr || !_CUDA_VSTD::is_const_v<_Tp>))
+  _CUDAX_HOST_API auto operator=(_Tp* __obj) noexcept -> basic_any&
+  {
+    __vptr_for<interface_type> __vptr = &__vtable_for_v<interface_type, _Up>;
+    __ref_.__set_ref(__obj ? __vptr : nullptr, __obj);
+    return *this;
+  }
+
+  _CUDAX_HOST_API auto operator=(basic_any const& __other) noexcept -> basic_any&
+  {
+    __convert_from(__other);
+    return *this;
+  }
+
+  _CCCL_TEMPLATE(class _OtherInterface)
+  _CCCL_REQUIRES((!_CUDA_VSTD::same_as<_OtherInterface, _Interface>)
+                   _CCCL_AND __any_convertible_to<basic_any<_OtherInterface*>, basic_any<_Interface*>>)
+  _CUDAX_HOST_API auto operator=(basic_any<_OtherInterface*> const& __other) noexcept -> basic_any&
+  {
+    __convert_from(__other);
+    return *this;
+  }
+
+  _CCCL_TEMPLATE(class _OtherInterface)
+  _CCCL_REQUIRES(__any_convertible_to<basic_any<_OtherInterface>&, basic_any<_Interface&>>)
+  _CUDAX_HOST_API auto operator=(basic_any<_OtherInterface>* __other) noexcept -> basic_any&
+  {
+    __convert_from(__other);
+    return *this;
+  }
+
+  _CCCL_TEMPLATE(class _OtherInterface)
+  _CCCL_REQUIRES(__any_convertible_to<basic_any<_OtherInterface> const&, basic_any<_Interface&>>)
+  _CUDAX_HOST_API auto operator=(basic_any<_OtherInterface> const* __other) noexcept -> basic_any&
+  {
+    __convert_from(__other);
+    return *this;
+  }
+
+  //!
+  //! emplace
+  //!
+  _CCCL_TEMPLATE(class _Tp, class _Up = _CUDA_VSTD::remove_pointer_t<_Tp>, class _Vp = _CUDA_VSTD::remove_const_t<_Up>)
+  _CCCL_REQUIRES(__satisfies<_Vp, _Interface> _CCCL_AND(__is_const_ptr || !_CUDA_VSTD::is_const_v<_Up>))
+  _CUDAX_HOST_API auto
+  emplace(_CUDA_VSTD::type_identity_t<_Up>* __obj) noexcept -> _CUDA_VSTD::__maybe_const<__is_const_ptr, _Vp>*&
+  {
+    __vptr_for<interface_type> __vptr = &__vtable_for_v<interface_type, _Vp>;
+    __ref_.__set_ref(__obj ? __vptr : nullptr, __obj);
+    return *static_cast<_CUDA_VSTD::__maybe_const<__is_const_ptr, _Vp>**>(static_cast<void*>(&__ref_.__optr_));
+  }
+
+#if defined(__cpp_three_way_comparison)
+  _CCCL_NODISCARD _CUDAX_HOST_API auto operator==(basic_any const& __other) const noexcept -> bool
+  {
+    using __void_ptr_t _CCCL_NODEBUG_ALIAS = _CUDA_VSTD::__maybe_const<__is_const_ptr, void>* const*;
+    return *static_cast<__void_ptr_t>(__get_optr()) == *static_cast<__void_ptr_t>(__other.__get_optr());
+  }
+#else // ^^^ __cpp_three_way_comparison ^^^ / vvv !__cpp_three_way_comparison vvv
+  _CCCL_NODISCARD_FRIEND _CUDAX_HOST_API auto operator==(basic_any const& __lhs, basic_any const& __rhs) noexcept -> bool
+  {
+    using __void_ptr_t _CCCL_NODEBUG_ALIAS = _CUDA_VSTD::__maybe_const<__is_const_ptr, void>* const*;
+    return *static_cast<__void_ptr_t>(__lhs.__get_optr()) == *static_cast<__void_ptr_t>(__rhs.__get_optr());
+  }
+
+  _CCCL_NODISCARD_FRIEND _CUDAX_TRIVIAL_HOST_API auto
+  operator!=(basic_any const& __lhs, basic_any const& __rhs) noexcept -> bool
+  {
+    return !(__lhs == __rhs);
+  }
+#endif // !__cpp_three_way_comparison
+
+  using __any_ref_t _CCCL_NODEBUG_ALIAS =
+    _CUDA_VSTD::__maybe_const<__is_const_ptr, basic_any<__ireference<_Interface>>>;
+
+  _CCCL_NODISCARD _CUDAX_TRIVIAL_HOST_API auto operator->() const noexcept -> __any_ref_t*
+  {
+    return &__ref_;
+  }
+
+  _CCCL_NODISCARD _CUDAX_TRIVIAL_HOST_API auto operator*() const noexcept -> __any_ref_t&
+  {
+    return __ref_;
+  }
+
+  _CCCL_NODISCARD _CUDAX_HOST_API auto type() const noexcept -> _CUDA_VSTD::__type_info_ref
+  {
+    return __ref_.__vptr_ != nullptr
+           ? (__is_const_ptr ? *__get_rtti()->__object_info_->__const_pointer_typeid_
+                             : *__get_rtti()->__object_info_->__pointer_typeid_)
+           : _CCCL_TYPEID(void);
+  }
+
+  _CCCL_NODISCARD _CUDAX_HOST_API auto interface() const noexcept -> _CUDA_VSTD::__type_info_ref
+  {
+    return __ref_.__vptr_ != nullptr ? *__get_rtti()->__interface_typeid_ : _CCCL_TYPEID(interface_type);
+  }
+
+  _CCCL_NODISCARD _CUDAX_HOST_API auto has_value() const noexcept -> bool
+  {
+    return __ref_.__vptr_ != nullptr;
+  }
+
+  _CUDAX_HOST_API void reset() noexcept
+  {
+    __vptr_for<interface_type> __vptr = nullptr;
+    __ref_.__set_ref(__vptr, nullptr);
+  }
+
+  _CCCL_NODISCARD _CUDAX_HOST_API explicit operator bool() const noexcept
+  {
+    return __ref_.__vptr_ != nullptr;
+  }
+
+#if !defined(_CCCL_DOXYGEN_INVOKED) // Do not document
+  _CCCL_NODISCARD _CUDAX_TRIVIAL_HOST_API static constexpr auto __in_situ() noexcept -> bool
+  {
+    return true;
+  }
+#endif // _CCCL_DOXYGEN_INVOKED
+
+private:
+  template <class, class>
+  friend struct basic_any;
+  friend struct __basic_any_access;
+
+  template <class _SrcCvAny>
+  _CUDAX_HOST_API void __convert_from(_SrcCvAny* __other) noexcept
+  {
+    __other ? __ref_.__set_ref(__other->__get_vptr(), __other->__get_optr()) : reset();
+  }
+
+  template <class _OtherInterface>
+  _CUDAX_HOST_API void __convert_from(basic_any<_OtherInterface*> const& __other) noexcept
+  {
+    using __other_interface_t _CCCL_NODEBUG_ALIAS = _CUDA_VSTD::remove_const_t<_OtherInterface>;
+    auto __to_vptr = __try_vptr_cast<__other_interface_t, interface_type>(__other.__get_vptr());
+    auto __to_optr = __to_vptr ? *__other.__get_optr() : nullptr;
+    __ref_.__set_ref(__to_vptr, __to_optr);
+  }
+
+  _CCCL_NODISCARD _CUDAX_HOST_API auto __get_optr() noexcept -> _CUDA_VSTD::__maybe_const<__is_const_ptr, void>**
+  {
+    return &__ref_.__optr_;
+  }
+
+  _CCCL_NODISCARD _CUDAX_HOST_API auto
+  __get_optr() const noexcept -> _CUDA_VSTD::__maybe_const<__is_const_ptr, void>* const*
+  {
+    return &__ref_.__optr_;
+  }
+
+  _CCCL_NODISCARD _CUDAX_HOST_API auto __get_vptr() const noexcept -> __vptr_for<interface_type>
+  {
+    return __ref_.__vptr_;
+  }
+
+  _CCCL_NODISCARD _CUDAX_HOST_API auto __get_rtti() const noexcept -> __rtti const*
+  {
+    return __ref_.__vptr_ ? __ref_.__vptr_->__query_interface(iunknown()) : nullptr;
+  }
+
+  mutable basic_any<__ireference<_Interface>> __ref_;
+};
+
+_CCCL_TEMPLATE(template <class...> class _Interface, class _Super)
+_CCCL_REQUIRES(__is_interface<_Interface<_Super>>)
+_CUDAX_PUBLIC_API basic_any(_Interface<_Super>*) //
+  -> basic_any<__normalized_interface_of<basic_any<_Super>*>>;
+
+_CCCL_TEMPLATE(template <class...> class _Interface, class _Super)
+_CCCL_REQUIRES(__is_interface<_Interface<_Super>>)
+_CUDAX_PUBLIC_API basic_any(_Interface<_Super> const*) //
+  -> basic_any<__normalized_interface_of<basic_any<_Super> const*>>;
+
+} // namespace cuda::experimental
+
+_CCCL_POP_MACROS
+
+#endif // __CUDAX_DETAIL_BASIC_ANY_BASIC_ANY_PTR_H
diff --git a/cudax/include/cuda/experimental/__utility/basic_any/basic_any_ref.cuh b/cudax/include/cuda/experimental/__utility/basic_any/basic_any_ref.cuh
new file mode 100644
index 00000000000..974d0df2194
--- /dev/null
+++ b/cudax/include/cuda/experimental/__utility/basic_any/basic_any_ref.cuh
@@ -0,0 +1,357 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of CUDA Experimental in CUDA C++ Core Libraries,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef __CUDAX_DETAIL_BASIC_ANY_BASIC_ANY_REF_H
+#define __CUDAX_DETAIL_BASIC_ANY_BASIC_ANY_REF_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__concepts/concept_macros.h>
+#include <cuda/std/__type_traits/is_const.h>
+#include <cuda/std/__type_traits/maybe_const.h>
+#include <cuda/std/__type_traits/remove_const.h>
+#include <cuda/std/__type_traits/remove_reference.h>
+#include <cuda/std/__utility/typeid.h>
+
+#include <cuda/experimental/__utility/basic_any/basic_any_base.cuh>
+#include <cuda/experimental/__utility/basic_any/basic_any_fwd.cuh>
+#include <cuda/experimental/__utility/basic_any/conversions.cuh>
+#include <cuda/experimental/__utility/basic_any/interfaces.cuh>
+#include <cuda/experimental/__utility/basic_any/iset.cuh>
+#include <cuda/experimental/__utility/basic_any/rtti.cuh>
+
+_CCCL_PUSH_MACROS
+#undef interface
+
+namespace cuda::experimental
+{
+//!
+//! \c __ireference<_Interface>
+//!
+//! For an interface `I`, `__ireference<I>` represents a reference to an object
+//! that satisfies the given interface. When you dereference a `basic_any<I*>`,
+//! you get a `basic_any<__ireference<I>>`. Also, `basic_any<I&>` is implemented
+//! in terms of `basic_any<__ireference<I>>`.
+//!
+//! Note: a `basic_any<__ireference<_Interface>> &&` is an rvalue reference,
+//! whereas a `basic_any<_Interface &> &&` is an lvalue reference.
+template <class _Interface>
+struct __ireference : _Interface
+{
+  static_assert(_CUDA_VSTD::is_class_v<_Interface>, "expected a class type");
+  static constexpr size_t __size_      = sizeof(void*);
+  static constexpr size_t __align_     = alignof(void*);
+  static constexpr bool __is_const_ref = _CUDA_VSTD::is_const_v<_Interface>;
+
+  using interface _CCCL_NODEBUG_ALIAS = _CUDA_VSTD::remove_const_t<_Interface>;
+};
+
+#if defined(_CCCL_NO_CONCEPTS)
+//!
+//! A base class for basic_any<__ireference<_Interface>> that provides a
+//! conversion to basic_any<__ireference<_Interface const>>. Only used
+//! when concepts are not available.
+//!
+template <class _Interface>
+struct __basic_any_reference_conversion_base
+{
+  _CCCL_NODISCARD _CUDAX_HOST_API operator basic_any<__ireference<_Interface const>>() const noexcept
+  {
+    return basic_any<__ireference<_Interface const>>(static_cast<basic_any<__ireference<_Interface>> const&>(*this));
+  }
+};
+
+template <class _Interface>
+struct __basic_any_reference_conversion_base<_Interface const>
+{};
+#endif // _CCCL_NO_CONCEPTS
+
+_CCCL_DIAG_PUSH
+// "operator basic_any<...> will not be called for implicit or explicit conversions"
+_CCCL_DIAG_SUPPRESS_NVHPC(conversion_function_not_usable)
+// "operator basic_any<...> will not be called for implicit or explicit conversions"
+_CCCL_NV_DIAG_SUPPRESS(554)
+
+//!
+//! \c basic_any<__ireference<_Interface>>
+//!
+//! A `basic_any<__ireference<_Interface>>` is a reference to an object that
+//! satisfies the given interface. It is used as the result of dereferencing
+//! a `basic_any<_Interface*>` and as the implementation of
+//! `basic_any<_Interface&>`.
+//!
+//! `basic_any<__ireference<_Interface>>` is neither copyable nor movable. It is
+//! not an end-user type.
+template <class _Interface, class Select>
+struct _LIBCUDACXX_DECLSPEC_EMPTY_BASES basic_any<__ireference<_Interface>, Select>
+    : __interface_of<__ireference<_Interface>>
+#if defined(_CCCL_NO_CONCEPTS)
+    , __basic_any_reference_conversion_base<_Interface>
+#endif // _CCCL_NO_CONCEPTS
+{
+  static_assert(_CUDA_VSTD::is_class_v<_Interface>, "expecting a class type");
+  using interface_type                 = _CUDA_VSTD::remove_const_t<_Interface>;
+  static constexpr bool __is_const_ref = _CUDA_VSTD::is_const_v<_Interface>;
+
+  basic_any(basic_any&&)      = delete;
+  basic_any(basic_any const&) = delete;
+
+  auto operator=(basic_any&&) -> basic_any&      = delete;
+  auto operator=(basic_any const&) -> basic_any& = delete;
+
+#if !defined(_CCCL_NO_CONCEPTS)
+  //! \brief A non-const basic_any reference can be implicitly converted to a
+  //! const basic_any reference.
+  _CCCL_NODISCARD _CUDAX_HOST_API operator basic_any<__ireference<_Interface const>>() const noexcept
+    requires(!__is_const_ref)
+  {
+    return basic_any<__ireference<_Interface const>>(*this);
+  }
+#endif // !_CCCL_NO_CONCEPTS
+
+  //! \brief Returns a const reference to the type_info for the decayed type
+  //! of the type-erased object.
+  _CCCL_NODISCARD _CUDAX_HOST_API auto type() const noexcept -> _CUDA_VSTD::__type_info_ref
+  {
+    return *__get_rtti()->__object_info_->__object_typeid_;
+  }
+
+  //! \brief Returns a const reference to the type_info for the decayed type
+  //! of the type-erased object.
+  _CCCL_NODISCARD _CUDAX_HOST_API auto interface() const noexcept -> _CUDA_VSTD::__type_info_ref
+  {
+    return *__get_rtti()->__interface_typeid_;
+  }
+
+  //! \brief Returns a reference to a type_info object representing the type of
+  //! the dynamic interface.
+  //!
+  //! The dynamic interface is the interface that was used to construct the
+  //! object, which may be different from the current object's interface if
+  //! there was a conversion.
+  _CCCL_NODISCARD _CUDAX_TRIVIAL_HOST_API static constexpr auto has_value() noexcept -> bool
+  {
+    return true;
+  }
+
+#if !defined(_CCCL_DOXYGEN_INVOKED) // Do not document
+  _CCCL_NODISCARD _CUDAX_TRIVIAL_HOST_API static constexpr auto __in_situ() noexcept -> bool
+  {
+    return true;
+  }
+#endif // _CCCL_DOXYGEN_INVOKED
+
+private:
+  template <class, class>
+  friend struct basic_any;
+  friend struct __basic_any_access;
+
+  basic_any() = default;
+
+  //! \brief Constructs a \c basic_any<__ireference<_Interface>> from an lvalue
+  //! reference to a \c basic_any<_Interface>.
+  _CUDAX_HOST_API explicit basic_any(
+    _CUDA_VSTD::__maybe_const<__is_const_ref, basic_any<interface_type>>& __other) noexcept
+  {
+    this->__set_ref(__other.__get_vptr(), __other.__get_optr());
+  }
+
+  //! \brief Constructs a \c basic_any<__ireference<_Interface>> from a
+  //! vtable pointer and an object pointer.
+  _CUDAX_HOST_API basic_any(__vptr_for<interface_type> __vptr,
+                            _CUDA_VSTD::__maybe_const<__is_const_ref, void>* __optr) noexcept
+      : __vptr_(__vptr)
+      , __optr_(__optr)
+  {}
+
+  //! \brief No-op.
+  _CUDAX_TRIVIAL_HOST_API void reset() noexcept {}
+
+  //! \brief No-op.
+  _CUDAX_TRIVIAL_HOST_API void __release() noexcept {}
+
+  //! \brief Rebinds the reference with a vtable pointer and object pointer.
+  _CUDAX_HOST_API void __set_ref(__vptr_for<interface_type> __vptr,
+                                 _CUDA_VSTD::__maybe_const<__is_const_ref, void>* __obj) noexcept
+  {
+    __vptr_ = __vptr;
+    __optr_ = __vptr_ ? __obj : nullptr;
+  }
+
+  //! \brief Rebinds the reference with a vtable pointer for a different
+  //! interface and object pointer. The vtable pointer is cast to the correct
+  //! type. If the cast fails, the reference is set to null.
+  template <class _VTable>
+  _CUDAX_HOST_API void __set_ref(_VTable const* __other, _CUDA_VSTD::__maybe_const<__is_const_ref, void>* __obj) noexcept
+  {
+    using _OtherInterface = typename _VTable::interface;
+    __vptr_               = __try_vptr_cast<_OtherInterface, interface_type>(__other);
+    __optr_               = __vptr_ ? __obj : nullptr;
+  }
+
+  //! \brief Rebinds the reference with a pointer to an iset vtable, which
+  //! is cast to a pointer to the vtable for `_Interface`. If \c _Interface
+  //! is a specialization `__iset<Is...>`, the cast succeeds if the
+  //! \c Is... is a subset of `Interfaces...`. Otherwise, the cast succeeds
+  //! if the \c _Interface is a base of one of `Interfaces...`.
+  template <class... _Interfaces>
+  _CUDAX_HOST_API void
+  __set_ref(__iset_vptr<_Interfaces...> __other, _CUDA_VSTD::__maybe_const<__is_const_ref, void>* __obj) noexcept
+  {
+    using _OtherInterface = __iset<_Interfaces...>;
+    __vptr_               = __try_vptr_cast<_OtherInterface, interface_type>(__other);
+    __optr_               = __vptr_ ? __obj : nullptr;
+  }
+
+  template <class _SrcCvAny>
+  _CUDAX_HOST_API void __convert_from(_SrcCvAny&& __from)
+  {
+    using __src_interface_t _CCCL_NODEBUG_ALIAS = typename _CUDA_VSTD::remove_reference_t<_SrcCvAny>::interface_type;
+    if (!__from.has_value())
+    {
+      __throw_bad_any_cast();
+    }
+    auto __to_vptr = __vptr_cast<__src_interface_t, interface_type>(__from.__get_vptr());
+    __set_ref(__to_vptr, __from.__get_optr());
+  }
+
+  _CUDAX_TRIVIAL_HOST_API auto __get_optr() const noexcept -> _CUDA_VSTD::__maybe_const<__is_const_ref, void>*
+  {
+    return __optr_;
+  }
+
+  _CUDAX_TRIVIAL_HOST_API auto __get_vptr() const noexcept -> __vptr_for<interface_type>
+  {
+    return __vptr_;
+  }
+
+  _CUDAX_TRIVIAL_HOST_API auto __get_rtti() const noexcept -> __rtti const*
+  {
+    return __vptr_->__query_interface(iunknown());
+  }
+
+  __vptr_for<interface_type> __vptr_{};
+  _CUDA_VSTD::__maybe_const<__is_const_ref, void>* __optr_{};
+};
+
+_CCCL_NV_DIAG_DEFAULT(554)
+_CCCL_DIAG_POP
+
+//!
+//! basic_any<_Interface&>
+//!
+template <class _Interface>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT basic_any<_Interface&> : basic_any<__ireference<_Interface>, __secondary>
+{
+  static_assert(_CUDA_VSTD::is_class_v<_Interface>, "expecting a class type");
+  using typename basic_any<__ireference<_Interface>, __secondary>::interface_type;
+  using basic_any<__ireference<_Interface>, __secondary>::__is_const_ref;
+
+  _CUDAX_HOST_API basic_any(basic_any const& __other) noexcept
+      : basic_any<__ireference<_Interface>, __secondary>()
+  {
+    this->__set_ref(__other.__get_vptr(), __other.__get_optr());
+  }
+
+  _CCCL_TEMPLATE(class _Tp, class _Up = _CUDA_VSTD::remove_const_t<_Tp>)
+  _CCCL_REQUIRES((!__is_basic_any<_Tp>) _CCCL_AND __satisfies<_Up, interface_type> _CCCL_AND(
+    __is_const_ref || !_CUDA_VSTD::is_const_v<_Tp>))
+  _CUDAX_HOST_API basic_any(_Tp& __obj) noexcept
+      : basic_any<__ireference<_Interface>, __secondary>()
+  {
+    __vptr_for<interface_type> const __vptr = &__vtable_for_v<interface_type, _Up>;
+    this->__set_ref(__vptr, &__obj);
+  }
+
+#if defined(_CCCL_CUDA_COMPILER_NVCC) && !defined(_CCCL_NO_CONCEPTS)
+// For some reason, the constructor overloads below give nvcc fits when
+// constrained with c++20 requires clauses. So we fall back to good ol'
+// enable_if.
+#  define _CUDAX_TEMPLATE(...) template <__VA_ARGS__,
+#  define _CUDAX_REQUIRES(...) _CUDA_VSTD::enable_if_t<__VA_ARGS__, int> = 0 >
+#  define _CUDAX_AND           , int > = 0, _CUDA_VSTD::enable_if_t <
+#else // ^^^ NVCC && concepts ^^^ / vvv !NVCC || !concepts vvv
+#  define _CUDAX_TEMPLATE _CCCL_TEMPLATE
+#  define _CUDAX_REQUIRES _CCCL_REQUIRES
+#  define _CUDAX_AND      _CCCL_AND
+#endif // !NVCC || !concepts
+
+  _CUDAX_TEMPLATE(class _Tp)
+  _CUDAX_REQUIRES((!__is_basic_any<_Tp>) )
+  basic_any(_Tp const&&) = delete;
+
+  _CUDAX_TEMPLATE(class _SrcInterface)
+  _CUDAX_REQUIRES((!_CUDA_VSTD::same_as<_SrcInterface, _Interface&>) _CUDAX_AND //
+                  (!__is_value_v<_SrcInterface>) _CUDAX_AND //
+                    __any_convertible_to<basic_any<_SrcInterface>, basic_any>)
+  _CUDAX_HOST_API basic_any(basic_any<_SrcInterface>&& __src) noexcept
+      : basic_any<__ireference<_Interface>, __secondary>()
+  {
+    this->__set_ref(__src.__get_vptr(), __src.__get_optr());
+  }
+
+  _CUDAX_TEMPLATE(class _SrcInterface)
+  _CUDAX_REQUIRES((!_CUDA_VSTD::same_as<_SrcInterface, _Interface&>) _CUDAX_AND //
+                    __any_convertible_to<basic_any<_SrcInterface>&, basic_any>)
+  _CUDAX_HOST_API basic_any(basic_any<_SrcInterface>& __src) noexcept
+      : basic_any<__ireference<_Interface>, __secondary>()
+  {
+    this->__set_ref(__src.__get_vptr(), __src.__get_optr());
+  }
+
+  _CUDAX_TEMPLATE(class _SrcInterface)
+  _CUDAX_REQUIRES((!_CUDA_VSTD::same_as<_SrcInterface, _Interface&>) _CUDAX_AND //
+                    __any_convertible_to<basic_any<_SrcInterface> const&, basic_any>)
+  _CUDAX_HOST_API basic_any(basic_any<_SrcInterface> const& __src) noexcept
+      : basic_any<__ireference<_Interface>, __secondary>()
+  {
+    this->__set_ref(__src.__get_vptr(), __src.__get_optr());
+  }
+
+  // A temporary value cannot bind to a basic_any reference.
+  // TODO: find another way to support APIs that take by reference and want
+  // implicit conversion from prvalues.
+  _CUDAX_TEMPLATE(class _SrcInterface)
+  _CUDAX_REQUIRES(__is_value_v<_SrcInterface>) //
+  basic_any(basic_any<_SrcInterface> const&&) = delete;
+
+#undef _CUDAX_AND
+#undef _CUDAX_REQUIRES
+#undef _CUDAX_TEMPLATE
+
+  auto operator=(basic_any&&) -> basic_any&      = delete;
+  auto operator=(basic_any const&) -> basic_any& = delete;
+
+  _CUDAX_TRIVIAL_HOST_API auto move() & noexcept -> basic_any<__ireference<_Interface>>&&
+  {
+    return _CUDA_VSTD::move(*this);
+  }
+
+private:
+  template <class, class>
+  friend struct basic_any;
+  friend struct __basic_any_access;
+
+  basic_any() = default;
+};
+
+} // namespace cuda::experimental
+
+_CCCL_POP_MACROS
+
+#endif // __CUDAX_DETAIL_BASIC_ANY_BASIC_ANY_REF_H
diff --git a/cudax/include/cuda/experimental/__utility/basic_any/basic_any_value.cuh b/cudax/include/cuda/experimental/__utility/basic_any/basic_any_value.cuh
new file mode 100644
index 00000000000..1a18b65c778
--- /dev/null
+++ b/cudax/include/cuda/experimental/__utility/basic_any/basic_any_value.cuh
@@ -0,0 +1,491 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of CUDA Experimental in CUDA C++ Core Libraries,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef __CUDAX_DETAIL_BASIC_ANY_BASIC_ANY_VALUE_H
+#define __CUDAX_DETAIL_BASIC_ANY_BASIC_ANY_VALUE_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__concepts/concept_macros.h>
+#include <cuda/std/__concepts/same_as.h>
+#include <cuda/std/__new/launder.h>
+#include <cuda/std/__type_traits/is_class.h>
+#include <cuda/std/__type_traits/is_nothrow_constructible.h>
+#include <cuda/std/__type_traits/is_same.h>
+#include <cuda/std/__utility/in_place.h>
+#include <cuda/std/__utility/move.h>
+#include <cuda/std/__utility/swap.h>
+#include <cuda/std/initializer_list>
+
+#include <cuda/experimental/__utility/basic_any/basic_any_base.cuh>
+#include <cuda/experimental/__utility/basic_any/basic_any_fwd.cuh>
+#include <cuda/experimental/__utility/basic_any/basic_any_ref.cuh>
+#include <cuda/experimental/__utility/basic_any/conversions.cuh>
+#include <cuda/experimental/__utility/basic_any/interfaces.cuh>
+#include <cuda/experimental/__utility/basic_any/rtti.cuh>
+#include <cuda/experimental/__utility/basic_any/semiregular.cuh>
+#include <cuda/experimental/__utility/basic_any/storage.cuh>
+#include <cuda/experimental/__utility/basic_any/virtual_tables.cuh>
+
+_CCCL_PUSH_MACROS
+#undef interface
+
+namespace cuda::experimental
+{
+// constructible_from using list initialization syntax.
+// clang-format off
+template <class _Tp, class... _Args>
+_CCCL_CONCEPT __list_initializable_from =
+  _CCCL_REQUIRES_EXPR((_Tp, variadic _Args), _Args&&... __args)
+  (
+    _Tp{static_cast<_Args&&>(__args)...}
+  );
+// clang-format on
+
+//!
+//! basic_any
+//!
+template <class _Interface, class>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT basic_any : __basic_any_base<_Interface>
+{
+private:
+  static_assert(_CUDA_VSTD::is_class_v<_Interface>,
+                "basic_any requires an interface type, or a pointer or reference to an interface "
+                "type.");
+  static_assert(!_CUDA_VSTD::is_const_v<_Interface>, "basic_any does not support const-qualified interfaces.");
+
+  using __basic_any_base<_Interface>::__size_;
+  using __basic_any_base<_Interface>::__align_;
+  using __basic_any_base<_Interface>::__vptr_;
+  using __basic_any_base<_Interface>::__buffer_;
+
+public:
+  using interface_type = _Interface;
+
+  //! \brief Constructs an empty `basic_any` object.
+  //! \post `has_value() == false`
+  basic_any() = default;
+
+  //! \brief Constructs a `basic_any` object that contains a copy of `__value`.
+  //! \pre `__value` must be move constructible. `_Tp` must satisfy the
+  //! requirements of `_Interface`.
+  //! \post `has_value() == true`
+  _CCCL_TEMPLATE(class _Tp)
+  _CCCL_REQUIRES((!__is_basic_any<_Tp>) _CCCL_AND __satisfies<_Tp, _Interface>)
+  _CUDAX_HOST_API basic_any(_Tp __value) noexcept(__is_small<_Tp>(__size_, __align_))
+  {
+    __emplace<_Tp>(_CUDA_VSTD::move(__value));
+  }
+
+  //! \brief Constructs a `basic_any` object that contains a new object of type
+  //! `_Tp` constructed as `_Tp{__args...}`.
+  //! \pre `_Tp` must satisfy the requirements of `_Interface`.
+  //! \post `has_value() == true`
+  _CCCL_TEMPLATE(class _Tp, class _Up = _CUDA_VSTD::decay_t<_Tp>, class... _Args)
+  _CCCL_REQUIRES(__list_initializable_from<_Up, _Args...> _CCCL_AND __satisfies<_Tp, _Interface>)
+  _CUDAX_HOST_API explicit basic_any(_CUDA_VSTD::in_place_type_t<_Tp>, _Args&&... __args) noexcept(
+    __is_small<_Up>(__size_, __align_) && _CUDA_VSTD::is_nothrow_constructible_v<_Up, _Args...>)
+  {
+    __emplace<_Up>(static_cast<_Args&&>(__args)...);
+  }
+
+  //! \brief Constructs a `basic_any` object that contains a new object of type
+  //! `_Tp` constructed as `_Tp{__il, __args...}`.
+  //! \pre `_Tp` must satisfy the requirements of `_Interface`.
+  //! \post `has_value() == true`
+  _CCCL_TEMPLATE(class _Tp, class _Up, class _Vp = _CUDA_VSTD::decay_t<_Tp>, class... _Args)
+  _CCCL_REQUIRES(
+    __list_initializable_from<_Vp, _CUDA_VSTD::initializer_list<_Up>&, _Args...> _CCCL_AND __satisfies<_Tp, _Interface>)
+  _CUDAX_HOST_API explicit basic_any(
+    _CUDA_VSTD::in_place_type_t<_Tp>,
+    _CUDA_VSTD::initializer_list<_Up> __il,
+    _Args&&... __args) noexcept(__is_small<_Vp>(__size_, __align_)
+                                && _CUDA_VSTD::
+                                  is_nothrow_constructible_v<_Vp, _CUDA_VSTD::initializer_list<_Up>&, _Args...>)
+  {
+    __emplace<_Vp>(__il, static_cast<_Args&&>(__args)...);
+  }
+
+#if !defined(_CCCL_NO_CONCEPTS) || defined(_CCCL_DOXYGEN_INVOKED)
+  //! \brief Move constructs a `basic_any` object.
+  //! \pre `_Interface` must extend `imovable<>`.
+  //! \post `__other.has_value() == false` and `has_value()` is `true` if and
+  //! only if `__other.has_value()` was `true`.
+  _CUDAX_HOST_API basic_any(basic_any&& __other) noexcept
+    requires(extension_of<_Interface, imovable<>>)
+  {
+    __convert_from(_CUDA_VSTD::move(__other));
+  }
+
+  //! \brief Copy constructs a `basic_any` object.
+  //! \pre `_Interface` must extend `icopyable<>`.
+  //! \post `has_value() == __other.has_value()`. If `_Interface` extends
+  //! `iequality_comparable<>`, then `*this == __other` is `true`.
+  _CUDAX_HOST_API basic_any(basic_any const& __other)
+    requires(extension_of<_Interface, icopyable<>>)
+  {
+    __convert_from(__other);
+  }
+#else // ^^^ !_CCCL_NO_CONCEPTS ^^^ / vvv _CCCL_NO_CONCEPTS vvv
+  // Without real concepts, we use base classes to implement movability and
+  // copyability. All we need here is to accept the default implementations.
+  basic_any(basic_any&& __other)      = default;
+  basic_any(basic_any const& __other) = default;
+#endif // _CCCL_NO_CONCEPTS
+
+  //! \brief Converting constructor that move constructs from a compatible
+  //! `basic_any` object.
+  //! \pre Let `I` be the decayed type of `_OtherInterface`. `I` must extend
+  //! `_Interface`. If `_OtherInterface` is a reference type, then `I` must
+  //! extend `icopyable<>`. Otherwise, `I` must extend `imovable<>`.
+  //! \post `__other.has_value() == false` and `has_value()` is `true` if and
+  //! only if `__other.has_value()` was `true`.
+  _CCCL_TEMPLATE(class _OtherInterface)
+  _CCCL_REQUIRES((!_CUDA_VSTD::same_as<_OtherInterface, _Interface>)
+                   _CCCL_AND __any_convertible_to<basic_any<_OtherInterface>, basic_any>)
+  _CUDAX_HOST_API basic_any(basic_any<_OtherInterface>&& __other)
+  {
+    __convert_from(_CUDA_VSTD::move(__other));
+  }
+
+  //! \brief Converting constructor that copy constructs from a compatible
+  //! `basic_any` object.
+  //! \pre The decayed type of `_OtherInterface` must extend `_Interface` and
+  //! `icopyable<>`.
+  //! \post `has_value() == __other.has_value()`.
+  _CCCL_TEMPLATE(class _OtherInterface)
+  _CCCL_REQUIRES((!_CUDA_VSTD::same_as<_OtherInterface, _Interface>)
+                   _CCCL_AND __any_convertible_to<basic_any<_OtherInterface> const&, basic_any>)
+  _CUDAX_HOST_API basic_any(basic_any<_OtherInterface> const& __other)
+  {
+    __convert_from(__other);
+  }
+
+  //! \brief Destroys the contained value, if any.
+  _CUDAX_HOST_API ~basic_any()
+  {
+    reset();
+  }
+
+#if !defined(_CCCL_NO_CONCEPTS) || defined(_CCCL_DOXYGEN_INVOKED)
+  //! \brief Move assigns a `basic_any` object.
+  //! \pre `_Interface` must extend `imovable<>`.
+  //! \post `__other.has_value() == false` and `has_value()` is `true` if and
+  //! only if `__other.has_value()` was `true`.
+  _CUDAX_HOST_API basic_any& operator=(basic_any&& __other) noexcept
+    requires(extension_of<_Interface, imovable<>>)
+  {
+    return __assign_from(_CUDA_VSTD::move(__other));
+  }
+
+  //! \brief Copy assigns a `basic_any` object.
+  //! \pre `_Interface` must extend `icopyable<>`.
+  //! \post `has_value() == __other.has_value()`. If `_Interface` extends
+  //! `iequality_comparable<>`, then `*this == __other` is `true`.
+  _CUDAX_HOST_API basic_any& operator=(basic_any const& __other)
+    requires(extension_of<_Interface, icopyable<>>)
+  {
+    return __assign_from(__other);
+  }
+#else // ^^^ !_CCCL_NO_CONCEPTS ^^^ / vvv _CCCL_NO_CONCEPTS vvv
+  // Without real concepts, we use base classes to implement movability and
+  // copyability. All we need here is to accept the default implementations.
+  auto operator=(basic_any&& __other) -> basic_any&      = default;
+  auto operator=(basic_any const& __other) -> basic_any& = default;
+#endif // _CCCL_NO_CONCEPTS
+
+  //! \brief Converting move assignment operator from a compatible `basic_any`
+  //! object.
+  //!
+  //! Equivalent to:
+  //!
+  //! @code{.cpp}
+  //! basic_any(cuda::std::move(__other)).swap(*this);
+  //! return *this;
+  //! @endcode
+  _CCCL_TEMPLATE(class _OtherInterface)
+  _CCCL_REQUIRES((!_CUDA_VSTD::same_as<_OtherInterface, _Interface>)
+                   _CCCL_AND __any_convertible_to<basic_any<_OtherInterface>, basic_any>)
+  _CUDAX_HOST_API auto operator=(basic_any<_OtherInterface>&& __other) -> basic_any&
+  {
+    return __assign_from(_CUDA_VSTD::move(__other));
+  }
+
+  //! \brief Converting copy assignment operator from a compatible `basic_any`
+  //! object.
+  //!
+  //! Equivalent to:
+  //!
+  //! @code{.cpp}
+  //! basic_any(__other).swap(*this);
+  //! return *this;
+  //! @endcode
+  _CCCL_TEMPLATE(class _OtherInterface)
+  _CCCL_REQUIRES((!_CUDA_VSTD::same_as<_OtherInterface, _Interface>)
+                   _CCCL_AND __any_convertible_to<basic_any<_OtherInterface> const&, basic_any>)
+  _CUDAX_HOST_API auto operator=(basic_any<_OtherInterface> const& __other) -> basic_any&
+  {
+    return __assign_from(__other);
+  }
+
+  //! \brief Implicitly convert to a `basic_any` non-const reference type:
+  _CCCL_NODISCARD _CUDAX_HOST_API operator basic_any<__ireference<_Interface>>() & noexcept
+  {
+    return basic_any<__ireference<_Interface>>(*this);
+  }
+
+  //! \brief Implicitly convert to a `basic_any` const reference type:
+  _CCCL_NODISCARD _CUDAX_HOST_API operator basic_any<__ireference<_Interface const>>() const& noexcept
+  {
+    return basic_any<__ireference<_Interface const>>(*this);
+  }
+
+  //! \brief Exchanges the values of two `basic_any` objects.
+  _CUDAX_HOST_API void swap(basic_any& __other) noexcept
+  {
+    //! if both objects refer to heap-allocated object, we can just
+    //! swap the pointers. otherwise, do it the slow(er) way.
+    if (!__in_situ() && !__other.__in_situ())
+    {
+      _CUDA_VSTD::swap(__vptr_, __other.__vptr_);
+      __swap_ptr_ptr(__buffer_, __other.__buffer_);
+    }
+
+    basic_any __tmp;
+    __tmp.__convert_from(_CUDA_VSTD::move(*this));
+    (*this).__convert_from(_CUDA_VSTD::move(__other));
+    __other.__convert_from(_CUDA_VSTD::move(__tmp));
+  }
+
+  //! \brief Exchanges the values of two `basic_any` objects.
+  friend _CUDAX_TRIVIAL_HOST_API void swap(basic_any& __lhs, basic_any& __rhs) noexcept
+  {
+    __lhs.swap(__rhs);
+  }
+
+  //! \brief Emplaces a new object of type `_Tp` constructed as
+  //! `_Tp{__args...}`.
+  //! \pre `_Tp` must satisfy the requirements of `_Interface`.
+  //! \post `has_value() == true`
+  _CCCL_TEMPLATE(class _Tp, class _Up = _CUDA_VSTD::decay_t<_Tp>, class... _Args)
+  _CCCL_REQUIRES(__list_initializable_from<_Up, _Args...>)
+  _CUDAX_HOST_API auto emplace(_Args&&... __args) noexcept(
+    __is_small<_Up>(__size_, __align_) && _CUDA_VSTD::is_nothrow_constructible_v<_Up, _Args...>) -> _Up&
+  {
+    reset();
+    return __emplace<_Up>(static_cast<_Args&&>(__args)...);
+  }
+
+  //! \brief Emplaces a new object of type `_Tp` constructed as
+  //! `_Tp{__il, __args...}`.
+  //! \pre `_Tp` must satisfy the requirements of `_Interface`.
+  //! \post `has_value() == true`
+  _CCCL_TEMPLATE(class _Tp, class _Up, class _Vp = _CUDA_VSTD::decay_t<_Tp>, class... _Args)
+  _CCCL_REQUIRES(__list_initializable_from<_Vp, _CUDA_VSTD::initializer_list<_Up>&, _Args...>)
+  _CUDAX_HOST_API auto emplace(_CUDA_VSTD::initializer_list<_Up> __il, _Args&&... __args) noexcept(
+    __is_small<_Vp>(__size_, __align_)
+    && _CUDA_VSTD::is_nothrow_constructible_v<_Vp, _CUDA_VSTD::initializer_list<_Up>&, _Args...>) -> _Vp&
+  {
+    reset();
+    return __emplace<_Vp>(__il, static_cast<_Args&&>(__args)...);
+  }
+
+  //! \brief Tests whether the `basic_any` object contains a value.
+  _CCCL_NODISCARD _CUDAX_HOST_API auto has_value() const noexcept -> bool
+  {
+    return __get_vptr() != nullptr;
+  }
+
+  //! \brief Resets the `basic_any` object to an empty state.
+  //! \post `has_value() == false`
+  _CUDAX_HOST_API void reset() noexcept
+  {
+    if (auto __vptr = __get_vptr())
+    {
+      _CCCL_ASSERT(__vptr->__query_interface(iunknown())->__cookie_ == 0xDEADBEEF,
+                   "query_interface returned a bad pointer to the iunknown vtable");
+      __vptr->__query_interface(iunknown())->__dtor_(__buffer_, __in_situ());
+      __release();
+    }
+  }
+
+  //! \brief Returns a reference to a type_info object representing the type of
+  //! the contained object.
+  _CCCL_NODISCARD _CUDAX_HOST_API auto type() const noexcept -> _CUDA_VSTD::__type_info_ref
+  {
+    if (auto __vptr = __get_vptr())
+    {
+      _CCCL_ASSERT(__vptr->__query_interface(iunknown())->__cookie_ == 0xDEADBEEF,
+                   "query_interface returned a bad pointer to the iunknown vtable");
+      return *__vptr->__query_interface(iunknown())->__object_info_->__object_typeid_;
+    }
+    return _CCCL_TYPEID(void);
+  }
+
+  //! \brief Returns a reference to a type_info object representing the type of
+  //! the dynamic interface.
+  //!
+  //! The dynamic interface is the interface that was used to construct the
+  //! object, which may be different from the current object's interface if
+  //! there was a conversion.
+  _CCCL_NODISCARD _CUDAX_HOST_API auto interface() const noexcept -> _CUDA_VSTD::__type_info_ref
+  {
+    if (auto __vptr = __get_vptr())
+    {
+      _CCCL_ASSERT(__vptr->__query_interface(iunknown())->__cookie_ == 0xDEADBEEF,
+                   "query_interface returned a bad pointer to the iunknown vtable");
+      return *__vptr->__query_interface(iunknown())->__interface_typeid_;
+    }
+    return _CCCL_TYPEID(_Interface);
+  }
+
+#if !defined(_CCCL_DOXYGEN_INVOKED) // Do not document
+  _CCCL_NODISCARD _CUDAX_HOST_API auto __in_situ() const noexcept -> bool
+  {
+    return __vptr_.__flag();
+  }
+#endif // _CCCL_DOXYGEN_INVOKED
+
+private:
+  template <class, class>
+  friend struct basic_any;
+  friend struct __basic_any_access;
+  template <class, int>
+  friend struct __basic_any_base;
+
+  _CUDAX_HOST_API void __release()
+  {
+    __vptr_for<_Interface> __vptr = nullptr;
+    __vptr_.__set(__vptr, false);
+  }
+
+  template <class _Tp, class... _Args>
+  _CUDAX_HOST_API auto __emplace(_Args&&... __args) noexcept(
+    __is_small<_Tp>(__size_, __align_) && _CUDA_VSTD::is_nothrow_constructible_v<_Tp, _Args...>) -> _Tp&
+  {
+    if constexpr (__is_small<_Tp>(__size_, __align_))
+    {
+      ::new (__buffer_) _Tp{static_cast<_Args&&>(__args)...};
+    }
+    else
+    {
+      ::new (__buffer_) __identity_t<_Tp*>{new _Tp{static_cast<_Args&&>(__args)...}};
+    }
+
+    __vptr_for<_Interface> __vptr = &__vtable_for_v<_Interface, _Tp>;
+    __vptr_.__set(__vptr, __is_small<_Tp>(__size_, __align_));
+    return *_CUDA_VSTD::launder(static_cast<_Tp*>(__get_optr()));
+  }
+
+  // this overload handles moving from basic_any<_SrcInterface> and
+  // basic_any<__ireference<_SrcInterface>> (but not
+  // basic_any<__ireference<_SrcInterface const>>).
+  _CCCL_TEMPLATE(class _SrcInterface)
+  _CCCL_REQUIRES(__any_castable_to<basic_any<_SrcInterface>, basic_any>)
+  _CUDAX_HOST_API void
+  __convert_from(basic_any<_SrcInterface>&& __from) noexcept(_CUDA_VSTD::is_same_v<_SrcInterface, _Interface>)
+  {
+    _CCCL_ASSERT(!has_value(), "forgot to clear the destination object first");
+    using __src_interface_t _CCCL_NODEBUG_ALIAS = __remove_ireference_t<_SrcInterface>;
+    // if the source is an lvalue reference, we need to copy from it.
+    if constexpr (__is_lvalue_reference_v<_SrcInterface>)
+    {
+      __convert_from(__from); // will copy from the source
+    }
+    else if (auto __to_vptr = __vptr_cast<__src_interface_t, _Interface>(__from.__get_vptr()))
+    {
+      if (!__from.__in_situ())
+      {
+        ::new (__buffer_) __identity_t<void*>(__from.__get_optr());
+        __vptr_.__set(__to_vptr, false);
+        __from.__release();
+      }
+      else if constexpr (_CUDA_VSTD::is_same_v<_SrcInterface, _Interface>)
+      {
+        __from.__move_to(__buffer_);
+        __vptr_.__set(__from.__get_vptr(), true);
+        __from.reset();
+      }
+      else
+      {
+        bool const __small = __from.__move_to(__buffer_, __size_, __align_);
+        __vptr_.__set(__to_vptr, __small);
+        __from.reset();
+      }
+    }
+  }
+
+  // this overload handles copying from basic_any<_Interface>,
+  // basic_any<__ireference<_Interface>>, and basic_any<_Interface&>.
+  _CCCL_TEMPLATE(class _SrcInterface)
+  _CCCL_REQUIRES(__any_castable_to<basic_any<_SrcInterface> const&, basic_any>)
+  _CUDAX_HOST_API void __convert_from(basic_any<_SrcInterface> const& __from)
+  {
+    _CCCL_ASSERT(!has_value(), "forgot to clear the destination object first");
+    using __src_interface_t _CCCL_NODEBUG_ALIAS = __remove_ireference_t<_CUDA_VSTD::remove_reference_t<_SrcInterface>>;
+    if (auto __to_vptr = __vptr_cast<__src_interface_t, _Interface>(__from.__get_vptr()))
+    {
+      bool const __small = __from.__copy_to(__buffer_, __size_, __align_);
+      __vptr_.__set(__to_vptr, __small);
+    }
+  }
+
+  // Assignment from a compatible basic_any object handled here:
+  _CCCL_TEMPLATE(class _SrcCvAny)
+  _CCCL_REQUIRES(__any_castable_to<_SrcCvAny, basic_any>)
+  _CUDAX_HOST_API auto __assign_from(_SrcCvAny&& __src) -> basic_any&
+  {
+    if (!__ptr_eq(this, &__src))
+    {
+      reset();
+      __convert_from(static_cast<_SrcCvAny&&>(__src));
+    }
+    return *this;
+  }
+
+  _CCCL_NODISCARD _CUDAX_HOST_API auto __get_vptr() const noexcept -> __vptr_for<_Interface>
+  {
+    return __vptr_.__get();
+  }
+
+  _CCCL_NODISCARD _CUDAX_HOST_API auto __get_optr() noexcept -> void*
+  {
+    void* __pv = __buffer_;
+    return __in_situ() ? __pv : *static_cast<void**>(__pv);
+  }
+
+  _CCCL_DIAG_PUSH
+  _CCCL_DIAG_SUPPRESS_MSVC(4702) // warning C4702: unreachable code (srsly where, msvc?)
+  _CCCL_NODISCARD _CUDAX_HOST_API auto __get_optr() const noexcept -> void const*
+  {
+    void const* __pv = __buffer_;
+    return __in_situ() ? __pv : *static_cast<void const* const*>(__pv);
+  }
+  _CCCL_DIAG_POP
+
+  _CCCL_NODISCARD _CUDAX_HOST_API auto __get_rtti() const noexcept -> __rtti const*
+  {
+    return __get_vptr()->__query_interface(iunknown());
+  }
+};
+
+} // namespace cuda::experimental
+
+_CCCL_POP_MACROS
+
+#endif // __CUDAX_DETAIL_BASIC_ANY_BASIC_ANY_VALUE_H
diff --git a/cudax/include/cuda/experimental/__utility/basic_any/conversions.cuh b/cudax/include/cuda/experimental/__utility/basic_any/conversions.cuh
new file mode 100644
index 00000000000..3cd76bc9af3
--- /dev/null
+++ b/cudax/include/cuda/experimental/__utility/basic_any/conversions.cuh
@@ -0,0 +1,149 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of CUDA Experimental in CUDA C++ Core Libraries,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef __CUDAX_DETAIL_BASIC_ANY_CONVERSIONS_H
+#define __CUDAX_DETAIL_BASIC_ANY_CONVERSIONS_H
+
+#include <cuda/std/detail/__config>
+
+#include "cuda/std/__cccl/attributes.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/conditional.h>
+#include <cuda/std/__type_traits/is_convertible.h>
+#include <cuda/std/__type_traits/remove_reference.h>
+
+#include <cuda/experimental/__utility/basic_any/basic_any_fwd.cuh>
+#include <cuda/experimental/__utility/basic_any/interfaces.cuh>
+
+_CCCL_PUSH_MACROS
+#undef interface
+
+namespace cuda::experimental
+{
+//!
+//! conversions
+//!
+//! Can one basic_any type convert to another? Implicitly? Explicitly?
+//! Statically? Dynamically? We answer these questions by mapping two
+//! cvref qualified basic_any types to archetype types, and then using
+//! the built-in language rules to determine if the conversion is valid.
+//!
+struct __immovable_archetype
+{
+  __immovable_archetype()                        = default;
+  __immovable_archetype(__immovable_archetype&&) = delete;
+
+  template <class _Value>
+  _CUDAX_HOST_API __immovable_archetype(_Value) noexcept;
+  template <class _Value>
+  _CUDAX_HOST_API __immovable_archetype(_Value*) = delete;
+};
+
+struct __movable_archetype : __immovable_archetype
+{
+  __movable_archetype() = default;
+  _CUDAX_HOST_API __movable_archetype(__movable_archetype&&) noexcept;
+};
+
+struct __copyable_archetype : __movable_archetype
+{
+  __copyable_archetype() = default;
+  _CUDAX_HOST_API __copyable_archetype(__copyable_archetype const&);
+};
+
+template <class _Interface>
+using _archetype_base = _CUDA_VSTD::conditional_t<
+  extension_of<_Interface, icopyable<>>,
+  __copyable_archetype,
+  _CUDA_VSTD::conditional_t<extension_of<_Interface, imovable<>>, __movable_archetype, __immovable_archetype>>;
+
+template <class _Interface>
+_CUDAX_HOST_API auto __interface_from(basic_any<_Interface>&&) -> _Interface;
+template <class _Interface>
+_CUDAX_HOST_API auto __interface_from(basic_any<__ireference<_Interface>>&&) -> _Interface;
+template <class _Interface>
+_CUDAX_HOST_API auto __interface_from(basic_any<_Interface>&) -> _Interface&;
+template <class _Interface>
+_CUDAX_HOST_API auto __interface_from(basic_any<_Interface> const&) -> _Interface const&;
+template <class _Interface>
+_CUDAX_HOST_API auto __interface_from(basic_any<_Interface>*) -> _Interface*;
+template <class _Interface>
+_CUDAX_HOST_API auto __interface_from(basic_any<_Interface> const*) -> _Interface const*;
+template <class _Interface>
+_CUDAX_HOST_API auto __interface_from(basic_any<__ireference<_Interface>>*) -> _Interface*;
+template <class _Interface>
+_CUDAX_HOST_API auto __interface_from(basic_any<__ireference<_Interface>> const*) -> _Interface*;
+
+template <class _Interface>
+_CUDAX_HOST_API auto __as_archetype(_Interface&&) -> _archetype_base<_Interface>;
+template <class _Interface>
+_CUDAX_HOST_API auto __as_archetype(_Interface&) -> _archetype_base<_Interface>&;
+template <class _Interface>
+_CUDAX_HOST_API auto __as_archetype(_Interface const&) -> _archetype_base<_Interface> const&;
+template <class _Interface>
+_CUDAX_HOST_API auto __as_archetype(_Interface*) -> _archetype_base<_Interface>*;
+template <class _Interface>
+_CUDAX_HOST_API auto __as_archetype(_Interface const*) -> _archetype_base<_Interface> const*;
+template <class _Interface>
+_CUDAX_HOST_API auto __as_archetype(__ireference<_Interface>) -> _archetype_base<_Interface>&;
+template <class _Interface>
+_CUDAX_HOST_API auto __as_archetype(__ireference<_Interface const>) -> _archetype_base<_Interface> const&;
+
+template <class _Interface>
+_CUDAX_HOST_API auto __as_immovable(_Interface&&) -> __immovable_archetype;
+template <class _Interface>
+_CUDAX_HOST_API auto __as_immovable(_Interface&) -> __immovable_archetype&;
+template <class _Interface>
+_CUDAX_HOST_API auto __as_immovable(_Interface const&) -> __immovable_archetype const&;
+template <class _Interface>
+_CUDAX_HOST_API auto __as_immovable(_Interface*) -> __immovable_archetype*;
+template <class _Interface>
+_CUDAX_HOST_API auto __as_immovable(_Interface const*) -> __immovable_archetype const*;
+
+template <class CvAny>
+using __normalized_interface_of _CCCL_NODEBUG_ALIAS = decltype(__cudax::__interface_from(declval<CvAny>()));
+
+template <class CvAny>
+using __src_archetype_of _CCCL_NODEBUG_ALIAS =
+  decltype(__cudax::__as_archetype(__cudax::__interface_from(declval<CvAny>())));
+
+template <class CvAny>
+using __dst_archetype_of _CCCL_NODEBUG_ALIAS =
+  decltype(__cudax::__as_immovable(__cudax::__as_archetype(__cudax::__interface_from(declval<CvAny>()))));
+
+// If the archetypes are implicitly convertible, then it is possible to
+// dynamically cast from the source to the destination. The cast may fail,
+// but at least it is possible.
+template <class _SrcCvAny, class _DstCvAny>
+_CCCL_CONCEPT __any_castable_to =
+  _CUDA_VSTD::is_convertible_v<__src_archetype_of<_SrcCvAny>, __dst_archetype_of<_DstCvAny>>;
+
+// If the archetypes are implicitly convertible **and** the source interface
+// is an extension of the destination one, then it is possible to implicitly
+// convert from the source to the destination.
+template <class _SrcCvAny, class _DstCvAny>
+_CCCL_CONCEPT __any_convertible_to =
+  __any_castable_to<_SrcCvAny, _DstCvAny> && //
+  extension_of<typename _CUDA_VSTD::remove_reference_t<_SrcCvAny>::interface_type,
+               typename _CUDA_VSTD::remove_reference_t<_DstCvAny>::interface_type>;
+
+} // namespace cuda::experimental
+
+_CCCL_POP_MACROS
+
+#endif // __CUDAX_DETAIL_BASIC_ANY_CONVERSIONS_H
diff --git a/cudax/include/cuda/experimental/__utility/basic_any/dynamic_any_cast.cuh b/cudax/include/cuda/experimental/__utility/basic_any/dynamic_any_cast.cuh
new file mode 100644
index 00000000000..5ac40d3aaa4
--- /dev/null
+++ b/cudax/include/cuda/experimental/__utility/basic_any/dynamic_any_cast.cuh
@@ -0,0 +1,113 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of CUDA Experimental in CUDA C++ Core Libraries,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef __CUDAX_DETAIL_BASIC_ANY_DYNAMIC_ANY_CAST_H
+#define __CUDAX_DETAIL_BASIC_ANY_DYNAMIC_ANY_CAST_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__concepts/concept_macros.h>
+#include <cuda/std/__utility/move.h>
+
+#include <cuda/experimental/__utility/basic_any/access.cuh>
+#include <cuda/experimental/__utility/basic_any/basic_any_fwd.cuh>
+#include <cuda/experimental/__utility/basic_any/conversions.cuh>
+
+_CCCL_PUSH_MACROS
+#undef interface
+
+namespace cuda::experimental
+{
+//!
+//! __dynamic_any_cast_fn
+//!
+template <class _DstInterface>
+struct __dynamic_any_cast_fn
+{
+  //! @throws bad_any_cast when \c __src cannot be dynamically cast to a
+  //! \c basic_any<_DstInterface>.
+  _CCCL_TEMPLATE(class _SrcInterface)
+  _CCCL_REQUIRES(__any_castable_to<basic_any<_SrcInterface>, basic_any<_DstInterface>>)
+  _CCCL_NODISCARD _CUDAX_HOST_API auto operator()(basic_any<_SrcInterface>&& __src) const -> basic_any<_DstInterface>
+  {
+    auto __dst = __basic_any_access::__make<_DstInterface>();
+    __basic_any_access::__cast_to(_CUDA_VSTD::move(__src), __dst);
+    return __dst;
+  }
+
+  //! @throws bad_any_cast when \c __src cannot be dynamically cast to a
+  //! \c basic_any<_DstInterface>.
+  _CCCL_TEMPLATE(class _SrcInterface)
+  _CCCL_REQUIRES(__any_castable_to<basic_any<_SrcInterface>&, basic_any<_DstInterface>>)
+  _CCCL_NODISCARD _CUDAX_HOST_API auto operator()(basic_any<_SrcInterface>& __src) const -> basic_any<_DstInterface>
+  {
+    auto __dst = __basic_any_access::__make<_DstInterface>();
+    __basic_any_access::__cast_to(__src, __dst);
+    return __dst;
+  }
+
+  //! @throws bad_any_cast when \c __src cannot be dynamically cast to a
+  //! \c basic_any<_DstInterface>.
+  _CCCL_TEMPLATE(class _SrcInterface)
+  _CCCL_REQUIRES(__any_castable_to<basic_any<_SrcInterface> const&, basic_any<_DstInterface>>)
+  _CCCL_NODISCARD _CUDAX_HOST_API auto
+  operator()(basic_any<_SrcInterface> const& __src) const -> basic_any<_DstInterface>
+  {
+    auto __dst = __basic_any_access::__make<_DstInterface>();
+    __basic_any_access::__cast_to(__src, __dst);
+    return __dst;
+  }
+
+  //! @returns \c nullptr when \c __src cannot be dynamically cast to a
+  //! \c basic_any<_DstInterface>.
+  _CCCL_TEMPLATE(class _SrcInterface)
+  _CCCL_REQUIRES(__any_castable_to<basic_any<_SrcInterface>*, basic_any<_DstInterface>>)
+  _CCCL_NODISCARD _CUDAX_HOST_API auto operator()(basic_any<_SrcInterface>* __src) const -> basic_any<_DstInterface>
+  {
+    auto __dst = __basic_any_access::__make<_DstInterface>();
+    __basic_any_access::__cast_to(__src, __dst);
+    return __dst;
+  }
+
+  //! @returns \c nullptr when \c __src cannot be dynamically cast to a
+  //! \c basic_any<_DstInterface>.
+  _CCCL_TEMPLATE(class _SrcInterface)
+  _CCCL_REQUIRES(__any_castable_to<basic_any<_SrcInterface> const*, basic_any<_DstInterface>>)
+  _CCCL_NODISCARD _CUDAX_HOST_API auto
+  operator()(basic_any<_SrcInterface> const* __src) const -> basic_any<_DstInterface>
+  {
+    auto __dst = __basic_any_access::__make<_DstInterface>();
+    __basic_any_access::__cast_to(__src, __dst);
+    return __dst;
+  }
+};
+
+//!
+//! dynamic_any_cast
+//!
+//! @throws bad_any_cast when \c from cannot be dynamically cast to a
+//! \c basic_any<_DstInterface>
+//!
+template <class _DstInterface>
+inline constexpr __dynamic_any_cast_fn<_DstInterface> dynamic_any_cast{};
+
+} // namespace cuda::experimental
+
+_CCCL_POP_MACROS
+
+#endif // __CUDAX_DETAIL_BASIC_ANY_DYNAMIC_ANY_CAST_H
diff --git a/cudax/include/cuda/experimental/__utility/basic_any/interfaces.cuh b/cudax/include/cuda/experimental/__utility/basic_any/interfaces.cuh
new file mode 100644
index 00000000000..2c7ad6f7f08
--- /dev/null
+++ b/cudax/include/cuda/experimental/__utility/basic_any/interfaces.cuh
@@ -0,0 +1,362 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of CUDA Experimental in CUDA C++ Core Libraries,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef __CUDAX_DETAIL_BASIC_ANY_INTERFACES_H
+#define __CUDAX_DETAIL_BASIC_ANY_INTERFACES_H
+
+#include <cuda/std/detail/__config>
+
+#include "cuda/std/__cccl/attributes.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__algorithm/find.h>
+#include <cuda/std/__algorithm/max.h>
+#include <cuda/std/__concepts/concept_macros.h>
+#include <cuda/std/__type_traits/is_callable.h>
+#include <cuda/std/__type_traits/is_class.h>
+#include <cuda/std/__type_traits/is_const.h>
+#include <cuda/std/__type_traits/remove_const.h>
+#include <cuda/std/__type_traits/type_set.h>
+
+#include <cuda/experimental/__utility/basic_any/basic_any_fwd.cuh>
+#include <cuda/experimental/__utility/basic_any/overrides.cuh>
+
+_CCCL_PUSH_MACROS
+#undef interface
+
+namespace cuda::experimental
+{
+//!
+//! Interface type traits
+//!
+// The primary __remove_ireference_v template is defined in basic_any_fwd.cuh.
+template <class _Interface>
+extern _Interface __remove_ireference_v<_Interface const>;
+
+template <class _Interface>
+extern _Interface __remove_ireference_v<__ireference<_Interface>>;
+
+template <class _Interface>
+extern _Interface __remove_ireference_v<__ireference<_Interface const>>;
+
+template <class _Interface>
+inline constexpr bool __is_value_v = _CUDA_VSTD::is_class_v<_Interface>;
+
+template <class _Interface>
+inline constexpr bool __is_value_v<__ireference<_Interface>> = false;
+
+template <class _Interface>
+inline constexpr bool __is_lvalue_reference_v = false;
+
+template <class _Interface>
+inline constexpr bool __is_lvalue_reference_v<__ireference<_Interface const>> = true;
+
+template <class _Interface>
+inline constexpr bool __is_lvalue_reference_v<_Interface&> = true;
+
+//!
+//! __bases_of: get the list of base interface for an interface, including itself
+//!             and iunknown.
+//!
+template <class _Interface, class _Fn>
+using __bases_of _CCCL_NODEBUG_ALIAS = //
+  _CUDA_VSTD::__type_call< //
+    _CUDA_VSTD::__type_concat< //
+      _CUDA_VSTD::__type_list<iunknown, _CUDA_VSTD::remove_const_t<_Interface>>,
+      typename _Interface::template __ibases<__make_type_list>>,
+    _Fn>;
+
+//!
+//! interface subsumption
+//!
+template <class _Interface1, class _Interface2>
+inline constexpr bool __subsumes = false;
+
+template <class _Interface>
+inline constexpr bool __subsumes<_Interface, _Interface> = true;
+
+template <class... _Set>
+inline constexpr bool __subsumes<__iset<_Set...>, __iset<_Set...>> = true;
+
+template <class... _Subset, class... _Superset>
+inline constexpr bool __subsumes<__iset<_Subset...>, __iset<_Superset...>> =
+  _CUDA_VSTD::__type_set_contains_v<_CUDA_VSTD::__make_type_set<_Superset...>, _Subset...>;
+
+//!
+//! extension_of: Checks if one interface is an extension of another.
+//!
+//! An interface \c A is considered an extension of another \c B if \c B
+//! can be found by recursively searching the base interfaces of \c A.
+//! `iset<As...>` is an extension of `iset<Bs...>` if `Bs...` is a subset
+//! of `As...`.
+//!
+//! \note An interface is considered an extension of itself.
+//!
+template <class _Base>
+struct __has_base_fn
+{
+  template <class... _Interfaces>
+  using __call _CCCL_NODEBUG_ALIAS = _CUDA_VSTD::bool_constant<_CUDA_VSTD::__is_included_in_v<_Base, _Interfaces...>>;
+};
+
+template <class... _Bases>
+struct __has_base_fn<__iset<_Bases...>>
+{
+  using __bases_set _CCCL_NODEBUG_ALIAS = __iset<_Bases...>;
+
+  template <class... _Interfaces>
+  using __call _CCCL_NODEBUG_ALIAS = _CUDA_VSTD::bool_constant<(__subsumes<__bases_set, _Interfaces> || ...)>;
+};
+
+template <class _Derived, class _Base, class = void>
+inline constexpr bool __extension_of = false;
+
+template <class _Derived, class _Base>
+inline constexpr bool
+  __extension_of<_Derived,
+                 _Base,
+                 _CUDA_VSTD::enable_if_t<_CUDA_VSTD::is_class_v<_Derived> && _CUDA_VSTD::is_class_v<_Base>>> =
+    __bases_of<_Derived, __has_base_fn<_CUDA_VSTD::remove_const_t<_Base>>>::value;
+
+template <class _Derived, class _Base>
+_CCCL_CONCEPT extension_of = __extension_of<_Derived, _Base>;
+
+//!
+//! interface
+//!
+template <template <class...> class _Interface, class... _Bases, size_t Size, size_t Align>
+struct interface<_Interface, extends<_Bases...>, Size, Align>
+{
+  static constexpr size_t size  = (_CUDA_VSTD::max)({Size, _Bases::size...});
+  static constexpr size_t align = (_CUDA_VSTD::max)({Align, _Bases::align...});
+
+  template <class... _Super>
+  using __rebind _CCCL_NODEBUG_ALIAS = _Interface<_Super...>;
+
+  template <class _Fn>
+  using __ibases _CCCL_NODEBUG_ALIAS =
+    _CUDA_VSTD::__type_call<_CUDA_VSTD::__type_concat<__bases_of<_Bases, __make_type_list>...>, _Fn>;
+
+  template <class _Tp>
+  using overrides _CCCL_NODEBUG_ALIAS = overrides_for<_Tp>;
+};
+
+//!
+//! __is_interface
+//!
+template <template <class...> class _Interface, class _Extends, size_t _Size, size_t _Align>
+_CUDAX_HOST_API auto __is_interface_test(interface<_Interface, _Extends, _Size, _Align> const&) -> void;
+
+// clang-format off
+template <class _Tp>
+_CCCL_CONCEPT __is_interface =
+  _CCCL_REQUIRES_EXPR((_Tp), _Tp& __value)
+  (
+    __is_interface_test(__value)
+  );
+// clang-format on
+
+//!
+//! __unique_interfaces
+//!
+//! Given an interface, return a list that contains the interface and all its
+//! bases, but with duplicates removed.
+//!
+template <class _Interface, class _Fn = __make_type_list>
+using __unique_interfaces _CCCL_NODEBUG_ALIAS =
+  _CUDA_VSTD::__type_apply<_Fn, __bases_of<_Interface, _CUDA_VSTD::__type_quote<_CUDA_VSTD::__make_type_set>>>;
+
+//!
+//! __index_of_base: find the index of an interface in a list of unique interfaces
+//!
+_CCCL_NODISCARD _CUDAX_HOST_API constexpr auto __find_index(_CUDA_VSTD::initializer_list<bool> __il) -> size_t
+{
+  auto __it = _CUDA_VSTD::find(__il.begin(), __il.end(), true);
+  return static_cast<size_t>(__it - __il.begin());
+}
+
+template <class _Interface>
+struct __find_index_of_base
+{
+  template <class... _Interfaces>
+  static constexpr size_t __index = __find_index({__subsumes<_Interface, _Interfaces>...});
+
+  template <class... _Interfaces>
+  using __call _CCCL_NODEBUG_ALIAS = _CUDA_VSTD::integral_constant<size_t, __index<_Interfaces...>>;
+};
+
+template <class _Interface, class _Super>
+using __index_of_base _CCCL_NODEBUG_ALIAS =
+  _CUDA_VSTD::__type_apply<__find_index_of_base<_Interface>, __unique_interfaces<_Super>>;
+
+template <class...>
+struct __iempty : interface<__iempty>
+{};
+
+#if _CCCL_COMPILER(NVHPC)
+
+template <class _Interface>
+struct __vptr_for_impl
+{
+  using type = typename _Interface::template overrides<__remove_ireference_t<_Interface>>::__vptr_t;
+};
+
+template <class _Interface>
+using __vptr_for _CCCL_NODEBUG_ALIAS = typename __vptr_for_impl<_Interface>::type;
+
+#else // ^^^ _CCCL_COMPILER(NVHPC) ^^^ / vvv !_CCCL_COMPILER(NVHPC) vvv
+
+template <class _Interface>
+using __vptr_for _CCCL_NODEBUG_ALIAS = typename __overrides_for<_Interface>::__vptr_t;
+
+#endif // !_CCCL_COMPILER(NVHPC)
+
+//!
+//! interface satisfaction
+//!
+template <class _Tp>
+struct __satisfaction_fn
+{
+  template <class _Interface>
+  using __does_not_satisfy _CCCL_NODEBUG_ALIAS =
+    _CUDA_VSTD::_Not<_CUDA_VSTD::_IsValidExpansion<__overrides_for, _Interface, _Tp>>;
+
+  // Try to find an unsatisfied interface. If we find one, we return it (it's at
+  // the front of the list returned from __type_find_if). If we don't find one
+  // (that is, if the returned list is empty), we return __iempty<>.
+  template <class... _Interfaces>
+  using __call _CCCL_NODEBUG_ALIAS = _CUDA_VSTD::__type_front< // take the front of the list
+    _CUDA_VSTD::__type_push_back< // add __iempty<> to the end of the list
+      _CUDA_VSTD::__type_find_if< // find the first unsatisfied interface if any, returns a list
+        _CUDA_VSTD::__type_list<_Interfaces...>,
+        _CUDA_VSTD::__type_quote1<__does_not_satisfy>>,
+      __iempty<>>>;
+};
+
+template <class _Interface, class _Tp, class = void>
+struct __unsatisfied_interface
+{};
+
+template <class _Interface, class _Tp>
+struct __unsatisfied_interface<_Interface, _Tp, _CUDA_VSTD::enable_if_t<_CUDA_VSTD::is_class_v<_Interface>>>
+{
+  using type _CCCL_NODEBUG_ALIAS = __unique_interfaces<_Interface, __satisfaction_fn<_Tp>>;
+};
+
+template <class _Interface, class _Tp>
+struct __unsatisfied_interface<_Interface*, _Tp*> : __unsatisfied_interface<_Interface, _Tp>
+{};
+
+template <class _Interface, class _Tp>
+struct __unsatisfied_interface<_Interface const*, _Tp const*> : __unsatisfied_interface<_Interface, _Tp>
+{};
+
+template <class _Interface, class _Tp>
+struct __unsatisfied_interface<_Interface&, _Tp> : __unsatisfied_interface<_Interface, _Tp>
+{};
+
+template <class _Tp, class _Interface>
+_CCCL_CONCEPT __has_overrides = _CUDA_VSTD::_IsValidExpansion<__overrides_for, _Interface, _Tp>::value;
+
+//! The \c __satisfies concept checks if a type \c _Tp satisfies an interface
+//! \c _Interface. It does this by trying to instantiate
+//! `__overrides_for<_X, _Tp>` for all \c _X, where \c _X is \c _Interface or
+//! one of its bases. If any of the \c __overrides_for instantiations are ill-
+//! formed, then \c _Tp does not satisfy \c _Interface.
+//!
+//! \c __satisfies is implemented by searching through the list of interfaces for
+//! one that \c _Tp does not satisfy. If such an interface is found, the concept
+//! check fails in such a way as to hopefully tell the user which interface is
+//! not satisfied and why.
+template <class _Tp,
+          class _Interface,
+          class UnsatisfiedInterface = _CUDA_VSTD::__type<__unsatisfied_interface<_Interface, _Tp>>>
+_CCCL_CONCEPT __satisfies = __has_overrides<_Tp, UnsatisfiedInterface>;
+
+//!
+//! __interface_of
+//!
+template <class _Super>
+struct __make_interface_fn
+{
+  static_assert(_CUDA_VSTD::is_class_v<_Super>, "expected a class type");
+  template <class... _Interfaces>
+  using __call _CCCL_NODEBUG_ALIAS = detail::__inherit<__rebind_interface<_Interfaces, _Super>...>;
+};
+
+// Given an interface `_I<>`, let `_Bs<>...` be the list of types consisting
+// of all of `_I<>`'s unique bases. Then `__interface_of<_I<>>` is the
+// type `__inherit<_I<_I<>>, _Bs<_I<>>...>`. That is, it transforms the
+// unspecialized interfaces into ones specialized for `_I<>` and then
+// makes a type that inherits publicly from all of them.
+template <class _Interface>
+using __interface_of _CCCL_NODEBUG_ALIAS = __unique_interfaces<_Interface, __make_interface_fn<_Interface>>;
+
+//!
+//! interface_cast
+//!
+//! given a `basic_any<X<>>` object `o`, `interface_cast<Y>(o)` return a
+//! reference to the (empty) sub-object of type `Y<X<>>`, from which
+//! `basic_any<X<>>` inherits, where `Y<>` is an interface that `X<>` extends.
+//!
+template <class _Interface>
+struct __interface_cast_fn;
+
+template <template <class...> class _Interface>
+struct __interface_cast_fn<_Interface<>>
+{
+  template <class _Super>
+  _CCCL_NODISCARD _CUDAX_TRIVIAL_HOST_API auto
+  operator()(_Interface<_Super>&& __self) const noexcept -> _Interface<_Super>&&
+  {
+    return _CUDA_VSTD::move(__self);
+  }
+
+  template <class _Super>
+  _CCCL_NODISCARD _CUDAX_TRIVIAL_HOST_API auto
+  operator()(_Interface<_Super>& __self) const noexcept -> _Interface<_Super>&
+  {
+    return __self;
+  }
+
+  template <class _Super>
+  _CCCL_NODISCARD _CUDAX_TRIVIAL_HOST_API auto
+  operator()(_Interface<_Super> const& __self) noexcept -> _Interface<_Super> const&
+  {
+    return __self;
+  }
+};
+
+_CCCL_TEMPLATE(template <class...> class _Interface, class Object)
+_CCCL_REQUIRES(
+  __is_interface<_Interface<>> _CCCL_AND _CUDA_VSTD::__is_callable_v<__interface_cast_fn<_Interface<>>, Object>)
+_CCCL_NODISCARD _CUDAX_TRIVIAL_HOST_API auto __interface_cast(Object&& __obj) noexcept -> decltype(auto)
+{
+  return __interface_cast_fn<_Interface<>>{}(_CUDA_VSTD::forward<Object>(__obj));
+}
+
+_CCCL_TEMPLATE(class _Interface, class Object)
+_CCCL_REQUIRES(__is_interface<_Interface> _CCCL_AND _CUDA_VSTD::__is_callable_v<__interface_cast_fn<_Interface>, Object>)
+_CCCL_NODISCARD _CUDAX_TRIVIAL_HOST_API auto __interface_cast(Object&& __obj) noexcept -> decltype(auto)
+{
+  return __interface_cast_fn<_Interface>{}(_CUDA_VSTD::forward<Object>(__obj));
+}
+} // namespace cuda::experimental
+
+_CCCL_POP_MACROS
+
+#endif // __CUDAX_DETAIL_BASIC_ANY_INTERFACES_H
diff --git a/cudax/include/cuda/experimental/__utility/basic_any/iset.cuh b/cudax/include/cuda/experimental/__utility/basic_any/iset.cuh
new file mode 100644
index 00000000000..551f94f724c
--- /dev/null
+++ b/cudax/include/cuda/experimental/__utility/basic_any/iset.cuh
@@ -0,0 +1,145 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of CUDA Experimental in CUDA C++ Core Libraries,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef __CUDAX_DETAIL_BASIC_ANY_ISET_H
+#define __CUDAX_DETAIL_BASIC_ANY_ISET_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/type_list.h>
+#include <cuda/std/__type_traits/type_set.h>
+
+#include <cuda/experimental/__utility/basic_any/basic_any_fwd.cuh>
+#include <cuda/experimental/__utility/basic_any/rtti.cuh>
+#include <cuda/experimental/__utility/basic_any/tagged_ptr.cuh>
+#include <cuda/experimental/__utility/basic_any/virtual_tables.cuh>
+
+_CCCL_PUSH_MACROS
+#undef interface
+
+namespace cuda::experimental
+{
+//!
+//! __iset
+//!
+template <class... _Interfaces>
+struct __iset_
+{
+  template <class...>
+  struct __interface_ : interface<__interface_, extends<_Interfaces...>>
+  {};
+};
+
+template <class... _Interfaces>
+struct __iset : __iset_<_Interfaces...>::template __interface_<>
+{};
+
+// flatten any nested sets
+template <class _Interface>
+using __iset_flatten _CCCL_NODEBUG_ALIAS = _CUDA_VSTD::__as_type_list<
+  _CUDA_VSTD::
+    conditional_t<detail::__is_specialization_of<_Interface, __iset>, _Interface, _CUDA_VSTD::__type_list<_Interface>>>;
+
+// flatten all sets into one, remove duplicates, and sort the elements.
+// TODO: sort!
+// template <class... _Interfaces>
+// using iset _CCCL_NODEBUG_ALIAS = _CUDA_VSTD::__type_call<
+//   _CUDA_VSTD::__type_unique<_CUDA_VSTD::__type_sort<_CUDA_VSTD::__type_concat<__iset_flatten<_Interfaces>...>>>,
+//   _CUDA_VSTD::__type_quote<__iset>>;
+template <class... _Interfaces>
+using iset =
+  _CUDA_VSTD::__type_call<_CUDA_VSTD::__type_unique<_CUDA_VSTD::__type_concat<__iset_flatten<_Interfaces>...>>,
+                          _CUDA_VSTD::__type_quote<__iset>>;
+
+//!
+//! Virtual table pointers
+//!
+
+template <class... _Interfaces>
+struct __iset_vptr : __base_vptr
+{
+  using __iset_vtable _CCCL_NODEBUG_ALIAS = __vtable_for<__iset<_Interfaces...>>;
+
+  __iset_vptr() = default;
+
+  _CUDAX_HOST_API constexpr __iset_vptr(__iset_vtable const* __vptr) noexcept
+      : __base_vptr(__vptr)
+  {}
+
+  _CUDAX_HOST_API constexpr __iset_vptr(__base_vptr __vptr) noexcept
+      : __base_vptr(__vptr)
+  {}
+
+  // Permit narrowing conversions from a super-set __vptr. Warning: we can't
+  // simply constrain this because then the ctor from __base_vptr would be
+  // selected instead, giving the wrong result.
+  template <class... _Others>
+  _CUDAX_HOST_API __iset_vptr(__iset_vptr<_Others...> __vptr) noexcept
+      : __base_vptr(__vptr->__query_interface(iunknown()))
+  {
+    static_assert(_CUDA_VSTD::__type_set_contains_v<_CUDA_VSTD::__make_type_set<_Others...>, _Interfaces...>, "");
+    _CCCL_ASSERT(__vptr_->__kind_ == __vtable_kind::__rtti && __vptr_->__cookie_ == 0xDEADBEEF,
+                 "query_interface returned a bad pointer to the iunknown vtable");
+  }
+
+  _CCCL_NODISCARD _CUDAX_TRIVIAL_HOST_API constexpr auto operator->() const noexcept -> __iset_vptr const*
+  {
+    return this;
+  }
+
+  template <class _Interface>
+  _CCCL_NODISCARD _CUDAX_TRIVIAL_HOST_API constexpr auto
+  __query_interface(_Interface) const noexcept -> __vptr_for<_Interface>
+  {
+    if (__vptr_->__kind_ == __vtable_kind::__normal)
+    {
+      return static_cast<__iset_vtable const*>(__vptr_)->__query_interface(_Interface{});
+    }
+    else
+    {
+      return static_cast<__rtti const*>(__vptr_)->__query_interface(_Interface{});
+    }
+  }
+};
+
+template <class... _Interfaces>
+struct __tagged_ptr<__iset_vptr<_Interfaces...>>
+{
+  _CUDAX_TRIVIAL_HOST_API auto __set(__iset_vptr<_Interfaces...> __vptr, bool __flag) noexcept -> void
+  {
+    __ptr_ = reinterpret_cast<uintptr_t>(__vptr.__vptr_) | uintptr_t(__flag);
+  }
+
+  _CCCL_NODISCARD _CUDAX_TRIVIAL_HOST_API auto __get() const noexcept -> __iset_vptr<_Interfaces...>
+  {
+    return __iset_vptr<_Interfaces...>{reinterpret_cast<__rtti_base const*>(__ptr_ & ~uintptr_t(1))};
+  }
+
+  _CCCL_NODISCARD _CUDAX_TRIVIAL_HOST_API auto __flag() const noexcept -> bool
+  {
+    return static_cast<bool>(__ptr_ & uintptr_t(1));
+  }
+
+  uintptr_t __ptr_ = 0;
+};
+
+} // namespace cuda::experimental
+
+_CCCL_POP_MACROS
+
+#endif // __CUDAX_DETAIL_BASIC_ANY_ISET_H
diff --git a/cudax/include/cuda/experimental/__utility/basic_any/overrides.cuh b/cudax/include/cuda/experimental/__utility/basic_any/overrides.cuh
new file mode 100644
index 00000000000..ae4cfeb9271
--- /dev/null
+++ b/cudax/include/cuda/experimental/__utility/basic_any/overrides.cuh
@@ -0,0 +1,65 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of CUDA Experimental in CUDA C++ Core Libraries,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef __CUDAX_DETAIL_BASIC_ANY_OVERRIDES_H
+#define __CUDAX_DETAIL_BASIC_ANY_OVERRIDES_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/is_const.h>
+
+#include <cuda/experimental/__utility/basic_any/basic_any_fwd.cuh>
+
+_CCCL_PUSH_MACROS
+#undef interface
+
+namespace cuda::experimental
+{
+template <class _Interface, class _Tp = __remove_ireference_t<_Interface>>
+using __overrides_for _CCCL_NODEBUG_ALIAS = typename _Interface::template overrides<_Tp>;
+
+//!
+//! overrides_for
+//!
+template <class _InterfaceOrModel, auto... _VirtualFnsOrOverrides>
+struct overrides_for
+{
+  static_assert(!_CUDA_VSTD::is_const_v<_InterfaceOrModel>, "expected a class type");
+  using __vtable _CCCL_NODEBUG_ALIAS = __basic_vtable<_InterfaceOrModel, _VirtualFnsOrOverrides...>;
+  using __vptr_t _CCCL_NODEBUG_ALIAS = __vtable const*;
+};
+
+template <class... _Interfaces>
+struct overrides_for<__iset<_Interfaces...>>
+{
+  using __vtable _CCCL_NODEBUG_ALIAS = __basic_vtable<__iset<_Interfaces...>>;
+  using __vptr_t _CCCL_NODEBUG_ALIAS = __iset_vptr<_Interfaces...>;
+};
+
+template <>
+struct overrides_for<iunknown>
+{
+  using __vtable _CCCL_NODEBUG_ALIAS = detail::__ignore; // no vtable, rtti is added explicitly in __vtable_tuple
+  using __vptr_t _CCCL_NODEBUG_ALIAS = __rtti const*;
+};
+
+} // namespace cuda::experimental
+
+_CCCL_POP_MACROS
+
+#endif // __CUDAX_DETAIL_BASIC_ANY_OVERRIDES_H
diff --git a/cudax/include/cuda/experimental/__utility/basic_any/rtti.cuh b/cudax/include/cuda/experimental/__utility/basic_any/rtti.cuh
new file mode 100644
index 00000000000..69a798f28c7
--- /dev/null
+++ b/cudax/include/cuda/experimental/__utility/basic_any/rtti.cuh
@@ -0,0 +1,251 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of CUDA Experimental in CUDA C++ Core Libraries,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef __CUDAX_DETAIL_BASIC_ANY_RTTI_H
+#define __CUDAX_DETAIL_BASIC_ANY_RTTI_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__exception/terminate.h>
+#include <cuda/std/__utility/typeid.h>
+
+#include <cuda/experimental/__utility/basic_any/basic_any_fwd.cuh>
+#include <cuda/experimental/__utility/basic_any/interfaces.cuh>
+#include <cuda/experimental/__utility/basic_any/virtual_ptrs.cuh>
+
+#include <typeinfo> // IWYU pragma: keep (for std::bad_cast)
+
+#include <nv/target>
+
+_CCCL_PUSH_MACROS
+#undef interface
+
+namespace cuda::experimental
+{
+//!
+//! __iunknown: Logically, the root of all interfaces.
+//!
+struct iunknown : interface<_CUDA_VSTD::__type_always<iunknown>::__call>
+{};
+
+//!
+//! bad_any_cast
+//!
+struct bad_any_cast : ::std::bad_cast
+{
+  bad_any_cast() noexcept                                       = default;
+  bad_any_cast(bad_any_cast const&) noexcept                    = default;
+  ~bad_any_cast() noexcept override                             = default;
+  auto operator=(bad_any_cast const&) noexcept -> bad_any_cast& = default;
+
+  auto what() const noexcept -> char const* override
+  {
+    return "cannot cast value to target type";
+  }
+};
+
+_CCCL_NORETURN _CUDAX_HOST_API inline void __throw_bad_any_cast()
+{
+#ifndef _CCCL_NO_EXCEPTIONS
+  NV_IF_ELSE_TARGET(NV_IS_HOST, (throw bad_any_cast();), (_CUDA_VSTD_NOVERSION::terminate();))
+#else // ^^^ !_CCCL_NO_EXCEPTIONS ^^^ / vvv _CCCL_NO_EXCEPTIONS vvv
+  _CUDA_VSTD_NOVERSION::terminate();
+#endif // _CCCL_NO_EXCEPTIONS
+}
+
+struct __rtti_base : detail::__immovable
+{
+  _CUDAX_HOST_API constexpr __rtti_base(
+    __vtable_kind __kind, uint16_t __nbr_interfaces, _CUDA_VSTD::__type_info_ref __self) noexcept
+      : __kind_(__kind)
+      , __nbr_interfaces_(__nbr_interfaces)
+      , __typeid_(&__self)
+  {}
+
+  uint8_t __version_                    = __basic_any_version;
+  __vtable_kind __kind_                 = __vtable_kind::__normal;
+  uint16_t __nbr_interfaces_            = 0;
+  uint32_t const __cookie_              = 0xDEADBEEF;
+  _CUDA_VSTD::__type_info_ptr __typeid_ = nullptr;
+};
+
+static_assert(sizeof(__rtti_base) == sizeof(uint64_t) + sizeof(void*));
+
+// Used to map an interface typeid to a pointer to the vtable for that interface.
+struct __base_info
+{
+  _CUDA_VSTD::__type_info_ptr __typeid_;
+  __base_vptr __vptr_;
+};
+
+inline constexpr size_t __half_size_t_bits = sizeof(size_t) * CHAR_BIT / 2;
+
+// The metadata for the type-erased object. All vtables have an rtti sub-object,
+// which contains a sub-object of this type.
+struct __object_metadata
+{
+  size_t __size_ : __half_size_t_bits;
+  size_t __align_ : __half_size_t_bits;
+  _CUDA_VSTD::__type_info_ptr __object_typeid_;
+  _CUDA_VSTD::__type_info_ptr __pointer_typeid_;
+  _CUDA_VSTD::__type_info_ptr __const_pointer_typeid_;
+};
+
+template <class _Tp>
+inline constexpr __object_metadata __object_metadata_v = {
+  sizeof(_Tp), alignof(_Tp), &_CCCL_TYPEID(_Tp), &_CCCL_TYPEID(_Tp*), &_CCCL_TYPEID(_Tp const*)};
+
+template <class _Tp>
+_CUDAX_HOST_API void __dtor_fn(void* __pv, bool __small) noexcept
+{
+  __small ? static_cast<_Tp*>(__pv)->~_Tp() //
+          : delete *static_cast<_Tp**>(__pv);
+}
+
+// All vtables have an rtti sub-object. This object has several responsibilities:
+// * It contains the destructor for the type-erased object.
+// * It contains the metadata for the type-erased object.
+// * It contains a map from the base interfaces typeids to their vtables for use
+//   in dynamic_cast-like functionality.
+struct __rtti : __rtti_base
+{
+  template <class _Tp, class _Super, class... _Interfaces>
+  _CUDAX_TRIVIAL_HOST_API constexpr __rtti(
+    __tag<_Tp, _Super>, __tag<_Interfaces...>, __base_info const* __base_vptr_map) noexcept
+      : __rtti_base{__vtable_kind::__rtti, sizeof...(_Interfaces), _CCCL_TYPEID(__rtti)}
+      , __dtor_(&__dtor_fn<_Tp>)
+      , __object_info_(&__object_metadata_v<_Tp>)
+      , __interface_typeid_{&_CCCL_TYPEID(_Super)}
+      , __base_vptr_map_{__base_vptr_map}
+  {}
+
+  template <class... _Interfaces>
+  _CCCL_NODISCARD _CUDAX_HOST_API auto
+  __query_interface(__iset<_Interfaces...>) const noexcept -> __vptr_for<__iset<_Interfaces...>>
+  {
+    // TODO: find a way to check at runtime that the requested __iset is a subset
+    // of the interfaces in the vtable.
+    return static_cast<__vptr_for<__iset<_Interfaces...>>>(this);
+  }
+
+  // Sequentially search the base_vptr_map for the requested interface by
+  // comparing typeids. If the requested interface is found, return a pointer to
+  // its vtable; otherwise, return nullptr.
+  template <class _Interface>
+  _CCCL_NODISCARD _CUDAX_HOST_API auto __query_interface(_Interface) const noexcept -> __vptr_for<_Interface>
+  {
+    // On sane implementations, comparing type_info objects first compares their
+    // addresses and, if that fails, it does a string comparison. What we want is
+    // to check _all_ the addresses first, and only if they all fail, resort to
+    // string comparisons. So do two passes over the __base_vptr_map.
+    constexpr _CUDA_VSTD::__type_info_ref __id = _CCCL_TYPEID(_Interface);
+
+    for (size_t __i = 0; __i < __nbr_interfaces_; ++__i)
+    {
+      if (&__id == __base_vptr_map_[__i].__typeid_)
+      {
+        return static_cast<__vptr_for<_Interface>>(__base_vptr_map_[__i].__vptr_);
+      }
+    }
+
+    for (size_t __i = 0; __i < __nbr_interfaces_; ++__i)
+    {
+      if (__id == *__base_vptr_map_[__i].__typeid_)
+      {
+        return static_cast<__vptr_for<_Interface>>(__base_vptr_map_[__i].__vptr_);
+      }
+    }
+
+    return nullptr;
+  }
+
+  void (*__dtor_)(void*, bool) noexcept;
+  __object_metadata const* __object_info_;
+  _CUDA_VSTD::__type_info_ptr __interface_typeid_ = nullptr;
+  __base_info const* __base_vptr_map_;
+};
+
+template <size_t _NbrInterfaces>
+struct __rtti_ex : __rtti
+{
+  template <class _Tp, class _Super, class... _Interfaces, class _VPtr>
+  _CUDAX_HOST_API constexpr __rtti_ex(__tag<_Tp, _Super> __type, __tag<_Interfaces...> __ibases, _VPtr __self) noexcept
+      : __rtti{__type, __ibases, __base_vptr_array}
+      , __base_vptr_array{{&_CCCL_TYPEID(_Interfaces), static_cast<__vptr_for<_Interfaces>>(__self)}...}
+  {}
+
+  __base_info __base_vptr_array[_NbrInterfaces];
+};
+
+//!
+//! __try_vptr_cast
+//!
+//! This function ignores const qualification on the source and destination
+//! interfaces.
+//!
+template <class _SrcInterface, class _DstInterface>
+_CCCL_NODISCARD _CUDAX_HOST_API auto
+__try_vptr_cast(__vptr_for<_SrcInterface> __src_vptr) noexcept -> __vptr_for<_DstInterface>
+{
+  static_assert(_CUDA_VSTD::is_class_v<_SrcInterface> && _CUDA_VSTD::is_class_v<_DstInterface>, "expected class types");
+  if (__src_vptr == nullptr)
+  {
+    return nullptr;
+  }
+  else if constexpr (_CUDA_VSTD::is_same_v<_SrcInterface const, _DstInterface const>)
+  {
+    return __src_vptr;
+  }
+  else if constexpr (extension_of<_SrcInterface, _DstInterface>)
+  {
+    //! Fast up-casts:
+    return __src_vptr->__query_interface(_DstInterface());
+  }
+  else
+  {
+    //! Slow down-casts and cross-casts:
+    __rtti const* rtti = __src_vptr->__query_interface(iunknown());
+    return rtti->__query_interface(_DstInterface());
+  }
+}
+
+template <class _SrcInterface, class _DstInterface>
+_CCCL_NODISCARD _CUDAX_HOST_API auto __vptr_cast(__vptr_for<_SrcInterface> __src_vptr) //
+  noexcept(_CUDA_VSTD::is_same_v<_SrcInterface, _DstInterface>) //
+  -> __vptr_for<_DstInterface>
+{
+  if constexpr (_CUDA_VSTD::is_same_v<_SrcInterface, _DstInterface>)
+  {
+    return __src_vptr;
+  }
+  else
+  {
+    auto __dst_vptr = __try_vptr_cast<_SrcInterface, _DstInterface>(__src_vptr);
+    if (!__dst_vptr && __src_vptr)
+    {
+      __throw_bad_any_cast();
+    }
+    return __dst_vptr;
+  }
+}
+
+} // namespace cuda::experimental
+
+_CCCL_POP_MACROS
+
+#endif // __CUDAX_DETAIL_BASIC_ANY_RTTI_H
diff --git a/cudax/include/cuda/experimental/__utility/basic_any/semiregular.cuh b/cudax/include/cuda/experimental/__utility/basic_any/semiregular.cuh
new file mode 100644
index 00000000000..c4757b2248d
--- /dev/null
+++ b/cudax/include/cuda/experimental/__utility/basic_any/semiregular.cuh
@@ -0,0 +1,265 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of CUDA Experimental in CUDA C++ Core Libraries,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef __CUDAX_DETAIL_BASIC_ANY_SEMIREGULAR_H
+#define __CUDAX_DETAIL_BASIC_ANY_SEMIREGULAR_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__concepts/concept_macros.h>
+#include <cuda/std/__concepts/copyable.h>
+#include <cuda/std/__concepts/equality_comparable.h>
+#include <cuda/std/__concepts/movable.h>
+#include <cuda/std/__type_traits/copy_cvref.h>
+#include <cuda/std/__type_traits/decay.h>
+#include <cuda/std/__type_traits/is_same.h>
+#include <cuda/std/__type_traits/type_identity.h>
+#include <cuda/std/__utility/typeid.h>
+
+#include <cuda/experimental/__utility/basic_any/access.cuh>
+#include <cuda/experimental/__utility/basic_any/basic_any_from.cuh>
+#include <cuda/experimental/__utility/basic_any/basic_any_fwd.cuh>
+#include <cuda/experimental/__utility/basic_any/interfaces.cuh>
+#include <cuda/experimental/__utility/basic_any/storage.cuh>
+#include <cuda/experimental/__utility/basic_any/virtcall.cuh>
+
+_CCCL_PUSH_MACROS
+#undef interface
+
+#if defined(_CCCL_CUDA_COMPILER_NVCC) || defined(_CCCL_CUDA_COMPILER_NVHPC)
+// WAR for NVBUG #4924416
+#  define _CUDAX_FNPTR_CONSTANT_WAR(...) ::cuda::experimental::__constant_war(__VA_ARGS__)
+namespace cuda::experimental
+{
+template <class _Tp>
+_CCCL_NODISCARD _CUDAX_HOST_API constexpr _Tp __constant_war(_Tp __val) noexcept
+{
+  return __val;
+}
+} // namespace cuda::experimental
+#else // ^^^ defined(_CCCL_CUDA_COMPILER_NVCC) || defined(_CCCL_CUDA_COMPILER_NVHPC) ^^^ /
+      // vvv !defined(_CCCL_CUDA_COMPILER_NVCC) && !defined(_CCCL_CUDA_COMPILER_NVHPC) vvv
+#  define _CUDAX_FNPTR_CONSTANT_WAR(...) __VA_ARGS__
+#endif // !defined(_CCCL_CUDA_COMPILER_NVCC) && !defined(_CCCL_CUDA_COMPILER_NVHPC)
+
+namespace cuda::experimental
+{
+//!
+//! semi-regular overrides
+//!
+
+_CCCL_TEMPLATE(class _Tp)
+_CCCL_REQUIRES(_CUDA_VSTD::movable<_Tp>)
+_CUDAX_PUBLIC_API auto __move_fn(_Tp& __src, void* __dst) noexcept -> void
+{
+  ::new (__dst) _Tp(static_cast<_Tp&&>(__src));
+}
+
+_CCCL_TEMPLATE(class _Tp)
+_CCCL_REQUIRES(_CUDA_VSTD::movable<_Tp>)
+_CCCL_NODISCARD _CUDAX_PUBLIC_API auto __try_move_fn(_Tp& __src, void* __dst, size_t __size, size_t __align) -> bool
+{
+  if (__is_small<_Tp>(__size, __align))
+  {
+    ::new (__dst) _Tp(static_cast<_Tp&&>(__src));
+    return true;
+  }
+  else
+  {
+    ::new (__dst) __identity_t<_Tp*>(new _Tp(static_cast<_Tp&&>(__src)));
+    return false;
+  }
+}
+
+_CCCL_TEMPLATE(class _Tp)
+_CCCL_REQUIRES(_CUDA_VSTD::copyable<_Tp>)
+_CCCL_NODISCARD _CUDAX_PUBLIC_API auto __copy_fn(_Tp const& __src, void* __dst, size_t __size, size_t __align) -> bool
+{
+  if (__is_small<_Tp>(__size, __align))
+  {
+    ::new (__dst) _Tp(__src);
+    return true;
+  }
+  else
+  {
+    ::new (__dst) __identity_t<_Tp*>(new _Tp(__src));
+    return false;
+  }
+}
+
+_CCCL_TEMPLATE(class _Tp)
+_CCCL_REQUIRES(_CUDA_VSTD::equality_comparable<_Tp>)
+_CCCL_NODISCARD _CUDAX_PUBLIC_API auto
+__equal_fn(_Tp const& __self, _CUDA_VSTD::__type_info_ref __type, void const* __other) -> bool
+{
+  if (_CCCL_TYPEID(_Tp) == __type)
+  {
+    return __self == *static_cast<_Tp const*>(__other);
+  }
+  return false;
+}
+
+_CCCL_TEMPLATE(class _From, class _To)
+_CCCL_REQUIRES(_CUDA_VSTD::convertible_to<_From, _To>)
+_CCCL_NODISCARD _CUDAX_PUBLIC_API _To __conversion_fn(_CUDA_VSTD::type_identity_t<_From> __self)
+{
+  return static_cast<_To>(static_cast<_From&&>(__self));
+}
+
+//!
+//! semi-regular interfaces
+//!
+template <class...>
+struct imovable : interface<imovable>
+{
+  _CCCL_TEMPLATE(class _Tp)
+  _CCCL_REQUIRES(_CUDA_VSTD::movable<_Tp>)
+  using overrides _CCCL_NODEBUG_ALIAS =
+    overrides_for<_Tp, _CUDAX_FNPTR_CONSTANT_WAR(&__try_move_fn<_Tp>), _CUDAX_FNPTR_CONSTANT_WAR(&__move_fn<_Tp>)>;
+
+  _CUDAX_HOST_API auto __move_to(void* __pv) noexcept -> void
+  {
+    return __cudax::virtcall<&__move_fn<imovable>>(this, __pv);
+  }
+
+  _CCCL_NODISCARD _CUDAX_HOST_API auto __move_to(void* __pv, size_t __size, size_t __align) -> bool
+  {
+    return __cudax::virtcall<&__try_move_fn<imovable>>(this, __pv, __size, __align);
+  }
+};
+
+template <class...>
+struct icopyable : interface<icopyable, extends<imovable<>>>
+{
+  _CCCL_TEMPLATE(class _Tp)
+  _CCCL_REQUIRES(_CUDA_VSTD::copyable<_Tp>)
+  using overrides _CCCL_NODEBUG_ALIAS = overrides_for<_Tp, _CUDAX_FNPTR_CONSTANT_WAR(&__copy_fn<_Tp>)>;
+
+  _CCCL_NODISCARD _CUDAX_HOST_API auto __copy_to(void* __pv, size_t __size, size_t __align) const -> bool
+  {
+    return virtcall<&__copy_fn<icopyable>>(this, __pv, __size, __align);
+  }
+};
+
+template <class...>
+struct iequality_comparable : interface<iequality_comparable>
+{
+  _CCCL_TEMPLATE(class _Tp)
+  _CCCL_REQUIRES(_CUDA_VSTD::equality_comparable<_Tp>)
+  using overrides _CCCL_NODEBUG_ALIAS = overrides_for<_Tp, _CUDAX_FNPTR_CONSTANT_WAR(&__equal_fn<_Tp>)>;
+
+#if defined(__cpp_three_way_comparison)
+  _CCCL_NODISCARD _CUDAX_HOST_API auto operator==(iequality_comparable const& __other) const -> bool
+  {
+    auto const& __other = __cudax::basic_any_from(__other);
+    void const* __obj   = __basic_any_access::__get_optr(__other);
+    return __cudax::virtcall<&__equal_fn<iequality_comparable>>(this, __other.type(), __obj);
+  }
+#else // ^^^ __cpp_three_way_comparison ^^^ / vvv !__cpp_three_way_comparison vvv
+  _CCCL_NODISCARD_FRIEND _CUDAX_HOST_API auto
+  operator==(iequality_comparable const& __left, iequality_comparable const& __right) -> bool
+  {
+    auto const& __rhs = __cudax::basic_any_from(__right);
+    void const* __obj = __basic_any_access::__get_optr(__rhs);
+    return __cudax::virtcall<&__equal_fn<iequality_comparable>>(&__left, __rhs.type(), __obj);
+  }
+
+  _CCCL_NODISCARD_FRIEND _CUDAX_TRIVIAL_HOST_API auto
+  operator!=(iequality_comparable const& __left, iequality_comparable const& __right) -> bool
+  {
+    return !(__left == __right);
+  }
+#endif // !__cpp_three_way_comparison
+};
+
+struct self; // a nice placeholder type
+
+template <class _CvSelf, class _To>
+struct __iconvertible_to
+{
+  static_assert(_CUDA_VSTD::is_same_v<_CUDA_VSTD::decay_t<_CvSelf>, self>,
+                "The first template parameter to iconvertible_to must be the placeholder type "
+                "cuda::experimental::self, possibly with cv- and/or ref-qualifiers");
+};
+
+template <class _To>
+struct __iconvertible_to<self&&, _To>
+{
+  template <class>
+  struct __always_false : _CUDA_VSTD::false_type
+  {};
+
+  static_assert(__always_false<_To>::value, "rvalue-qualified conversion operations are not yet supported");
+};
+
+template <class _To>
+struct __iconvertible_to<self, _To>
+{
+  template <class...>
+  struct __interface_ : interface<__interface_>
+  {
+    _CCCL_NODISCARD _CUDAX_HOST_API operator _To()
+    {
+      return __cudax::virtcall<__conversion_fn<__interface_, _To>>(this);
+    }
+
+    template <class _From>
+    using overrides = overrides_for<_From, _CUDAX_FNPTR_CONSTANT_WAR(&__conversion_fn<_From, _To>)>;
+  };
+};
+
+template <class _To>
+struct __iconvertible_to<self&, _To>
+{
+  template <class...>
+  struct __interface_ : interface<__interface_>
+  {
+    _CCCL_NODISCARD _CUDAX_HOST_API operator _To() &
+    {
+      return __cudax::virtcall<&__conversion_fn<__interface_&, _To>>(this);
+    }
+
+    template <class _From>
+    using overrides = overrides_for<_From, _CUDAX_FNPTR_CONSTANT_WAR(&__conversion_fn<_From&, _To>)>;
+  };
+};
+
+template <class _To>
+struct __iconvertible_to<self const&, _To>
+{
+  template <class...>
+  struct __interface_ : interface<__interface_>
+  {
+    _CCCL_NODISCARD _CUDAX_HOST_API operator _To() const&
+    {
+      return __cudax::virtcall<&__conversion_fn<__interface_ const&, _To>>(this);
+    }
+
+    template <class _From>
+    using overrides = overrides_for<_From, _CUDAX_FNPTR_CONSTANT_WAR(&__conversion_fn<_From const&, _To>)>;
+  };
+};
+
+template <class _From, class _To>
+using iconvertible_to _CCCL_NODEBUG_ALIAS = typename __iconvertible_to<_From, _To>::template __interface_<>;
+
+} // namespace cuda::experimental
+
+_CCCL_POP_MACROS
+
+#endif // __CUDAX_DETAIL_BASIC_ANY_SEMIREGULAR_H
diff --git a/cudax/include/cuda/experimental/__utility/basic_any/storage.cuh b/cudax/include/cuda/experimental/__utility/basic_any/storage.cuh
new file mode 100644
index 00000000000..c7849f24a98
--- /dev/null
+++ b/cudax/include/cuda/experimental/__utility/basic_any/storage.cuh
@@ -0,0 +1,74 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of CUDA Experimental in CUDA C++ Core Libraries,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef __CUDAX_DETAIL_BASIC_ANY_STORAGE_H
+#define __CUDAX_DETAIL_BASIC_ANY_STORAGE_H
+
+#include <cuda/__cccl_config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__algorithm/max.h>
+#include <cuda/std/__type_traits/is_nothrow_move_constructible.h>
+#include <cuda/std/__utility/swap.h>
+
+#include <cuda/experimental/__utility/basic_any/basic_any_fwd.cuh>
+
+_CCCL_PUSH_MACROS
+#undef interface
+
+namespace cuda::experimental
+{
+_CCCL_NODISCARD _CUDAX_HOST_API inline constexpr auto __buffer_size(size_t __size) -> size_t
+{
+  //! round up to the nearest multiple of `__word`, which is the size of a
+  //! void*.
+  return ((__size ? (_CUDA_VSTD::max)(__size, sizeof(void*)) : __default_buffer_size) + __word - 1) / __word * __word;
+}
+
+_CCCL_NODISCARD _CUDAX_HOST_API inline constexpr auto __buffer_align(size_t __align) -> size_t
+{
+  //! need to be able to store a void* in the buffer.
+  return __align ? (_CUDA_VSTD::max)(__align, alignof(void*)) : __default_buffer_align;
+}
+
+template <class _Tp>
+_CCCL_NODISCARD _CUDAX_HOST_API inline constexpr auto __is_small(size_t __size, size_t __align) noexcept -> bool
+{
+  return (sizeof(_Tp) <= __size) && (__align % alignof(_Tp) == 0) && _CUDA_VSTD::is_nothrow_move_constructible_v<_Tp>;
+}
+
+_CUDAX_HOST_API inline void __swap_ptr_ptr(void* __lhs, void* __rhs) noexcept
+{
+  _CUDA_VSTD::swap(*static_cast<void**>(__lhs), *static_cast<void**>(__rhs));
+}
+
+template <class _Tp, class _Up, class _Vp = decltype(true ? __identity_t<_Tp*>() : __identity_t<_Up*>())>
+_CCCL_NODISCARD _CUDAX_TRIVIAL_HOST_API auto __ptr_eq(_Tp* __lhs, _Up* __rhs) noexcept -> bool
+{
+  return static_cast<_Vp>(__lhs) == static_cast<_Vp>(__rhs);
+}
+
+_CCCL_NODISCARD _CUDAX_TRIVIAL_HOST_API constexpr auto __ptr_eq(detail::__ignore, detail::__ignore) noexcept -> bool
+{
+  return false;
+}
+
+} // namespace cuda::experimental
+
+_CCCL_POP_MACROS
+
+#endif // __CUDAX_DETAIL_BASIC_ANY_STORAGE_H
diff --git a/cudax/include/cuda/experimental/__utility/basic_any/tagged_ptr.cuh b/cudax/include/cuda/experimental/__utility/basic_any/tagged_ptr.cuh
new file mode 100644
index 00000000000..0e803f35bde
--- /dev/null
+++ b/cudax/include/cuda/experimental/__utility/basic_any/tagged_ptr.cuh
@@ -0,0 +1,59 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of CUDA Experimental in CUDA C++ Core Libraries,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef __CUDAX_DETAIL_BASIC_ANY_TAGGED_PTR_H
+#define __CUDAX_DETAIL_BASIC_ANY_TAGGED_PTR_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/experimental/__utility/basic_any/basic_any_fwd.cuh>
+
+_CCCL_PUSH_MACROS
+#undef interface
+
+namespace cuda::experimental
+{
+template <class _Ptr>
+struct __tagged_ptr;
+
+template <class _Tp>
+struct __tagged_ptr<_Tp*>
+{
+  _CUDAX_HOST_API void __set(_Tp* __pv, bool __flag) noexcept
+  {
+    __ptr_ = reinterpret_cast<uintptr_t>(__pv) | uintptr_t(__flag);
+  }
+
+  _CCCL_NODISCARD _CUDAX_HOST_API auto __get() const noexcept -> _Tp*
+  {
+    return reinterpret_cast<_Tp*>(__ptr_ & ~uintptr_t(1));
+  }
+
+  _CCCL_NODISCARD _CUDAX_HOST_API auto __flag() const noexcept -> bool
+  {
+    return static_cast<bool>(__ptr_ & uintptr_t(1));
+  }
+
+  uintptr_t __ptr_ = 0;
+};
+
+} // namespace cuda::experimental
+
+_CCCL_POP_MACROS
+
+#endif // __CUDAX_DETAIL_BASIC_ANY_TAGGED_PTR_H
diff --git a/cudax/include/cuda/experimental/__utility/basic_any/virtcall.cuh b/cudax/include/cuda/experimental/__utility/basic_any/virtcall.cuh
new file mode 100644
index 00000000000..b2da96600e1
--- /dev/null
+++ b/cudax/include/cuda/experimental/__utility/basic_any/virtcall.cuh
@@ -0,0 +1,158 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of CUDA Experimental in CUDA C++ Core Libraries,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef __CUDAX_DETAIL_BASIC_ANY_VIRTCALL_H
+#define __CUDAX_DETAIL_BASIC_ANY_VIRTCALL_H
+
+#include <cuda/std/detail/__config>
+
+#include "cuda/std/__cccl/unreachable.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__concepts/concept_macros.h>
+
+#include <cuda/experimental/__utility/basic_any/access.cuh>
+#include <cuda/experimental/__utility/basic_any/basic_any_from.cuh>
+#include <cuda/experimental/__utility/basic_any/basic_any_fwd.cuh>
+#include <cuda/experimental/__utility/basic_any/interfaces.cuh>
+#include <cuda/experimental/__utility/basic_any/virtual_functions.cuh>
+
+_CCCL_PUSH_MACROS
+#undef interface
+
+namespace cuda::experimental
+{
+//!
+//! __virtuals_map
+//!
+
+//! The virtuals map is an extra convenience for interface authors. To make a
+//! virtual function call, the user must provide the member function pointer
+//! corresponding to the virtual, as in:
+//!
+//! @code
+//! template <class...>
+//! struct ifoo {
+//!   void meow(auto... __args) {
+//!     // dispatch to the &ifoo<>::meow virtual function
+//!     // NB: the `<>` after `ifoo` is significant!
+//!     virtcall<&ifoo<>::meow>(this, __args...);
+//!     //            ^^
+//!   }
+//!  ...
+//! };
+//! @endcode
+//!
+//! When taking the address of the member, it is very easy to forget the `<>`
+//! after the interface name, which would result in a compilation error --
+//! except for the virtuals map, which substitutes the correct member function
+//! pointer for the user so they don't have to think about it.
+template <auto _Mbr, auto _BoundMbr>
+struct __virtuals_map_pair
+{
+  // map ifoo<>::meow to itself
+  _CCCL_NODISCARD _CUDAX_TRIVIAL_HOST_API constexpr auto operator()(__ctag<_Mbr>) const noexcept
+  {
+    return _Mbr;
+  }
+
+  // map ifoo<_Super>::meow to ifoo<>::meow
+  _CCCL_NODISCARD _CUDAX_TRIVIAL_HOST_API constexpr auto operator()(__ctag<_BoundMbr>) const noexcept
+  {
+    return _Mbr;
+  }
+};
+
+template <class, class>
+struct __virtuals_map;
+
+template <class _Interface, auto... _Mbrs, class _BoundInterface, auto... _BoundMbrs>
+struct __virtuals_map<overrides_for<_Interface, _Mbrs...>, overrides_for<_BoundInterface, _BoundMbrs...>>
+    : __virtuals_map_pair<_Mbrs, _BoundMbrs>...
+{
+  using __virtuals_map_pair<_Mbrs, _BoundMbrs>::operator()...;
+};
+
+template <class _Interface, class _Super>
+using __virtuals_map_for _CCCL_NODEBUG_ALIAS =
+  __virtuals_map<__overrides_for<_Interface>, __overrides_for<__rebind_interface<_Interface, _Super>>>;
+
+//!
+//! virtcall
+//!
+
+// If the interface is __ireference<MyInterface const>, then calls to non-const
+// member functions are not allowed.
+template <auto, class... _Interface>
+inline constexpr bool __valid_virtcall = sizeof...(_Interface) == 1;
+
+template <auto _Mbr, class _Interface>
+inline constexpr bool __valid_virtcall<_Mbr, __ireference<_Interface const>> = __virtual_fn<_Mbr>::__const_fn;
+
+template <auto _Mbr, class _Interface, class _Super, class _Self, class... _Args>
+_CUDAX_HOST_API auto __virtcall(_Self* __self, _Args&&... __args) //
+  noexcept(__virtual_fn<_Mbr>::__nothrow_fn) //
+  -> typename __virtual_fn<_Mbr>::__result_t
+{
+  auto* __vptr = __basic_any_access::__get_vptr(*__self)->__query_interface(_Interface());
+  auto* __obj  = __basic_any_access::__get_optr(*__self);
+  // map the member function pointer to the correct one if necessary
+  constexpr auto _Mbr2 = __virtuals_map_for<_Interface, _Super>{}(__ctag<_Mbr>());
+  return __vptr->__virtual_fn<_Mbr2>::__fn_(__obj, static_cast<_Args&&>(__args)...);
+}
+
+_CCCL_TEMPLATE(auto _Mbr, template <class...> class _Interface, class _Super, class... _Args)
+_CCCL_REQUIRES(__valid_virtcall<_Mbr, _Super>)
+_CUDAX_TRIVIAL_HOST_API auto virtcall(_Interface<_Super>* __self, _Args&&... __args) //
+  noexcept(__virtual_fn<_Mbr>::__nothrow_fn) //
+  -> typename __virtual_fn<_Mbr>::__result_t
+{
+  return __cudax::__virtcall<_Mbr, _Interface<>, _Super>(
+    __cudax::basic_any_from(__self), static_cast<_Args&&>(__args)...);
+}
+
+_CCCL_TEMPLATE(auto _Mbr, template <class...> class _Interface, class _Super, class... _Args)
+_CCCL_REQUIRES(__valid_virtcall<_Mbr, _Super>)
+_CUDAX_TRIVIAL_HOST_API auto virtcall(_Interface<_Super> const* __self, _Args&&... __args) //
+  noexcept(__virtual_fn<_Mbr>::__nothrow_fn) //
+  -> typename __virtual_fn<_Mbr>::__result_t
+{
+  return __cudax::__virtcall<_Mbr, _Interface<>, _Super>(
+    __cudax::basic_any_from(__self), static_cast<_Args&&>(__args)...);
+}
+
+_CCCL_TEMPLATE(auto _Mbr, template <class...> class _Interface, class... _Super, class... _Args)
+_CCCL_REQUIRES((!__valid_virtcall<_Mbr, _Super...>) )
+_CUDAX_TRIVIAL_HOST_API auto virtcall(_Interface<_Super...> const*, _Args&&...) //
+  noexcept(__virtual_fn<_Mbr>::__nothrow_fn) //
+  -> typename __virtual_fn<_Mbr>::__result_t
+{
+  constexpr bool __const_correct_virtcall = __valid_virtcall<_Mbr, _Super...> || sizeof...(_Super) == 0;
+  // If this static assert fires, then you have called a non-const member
+  // function on a `basic_any<I const&>`. This would violate const-correctness.
+  static_assert(__const_correct_virtcall, "This function call is not const correct.");
+  // This overload can also be selected when called from the thunks of
+  // unspecialized interfaces. Those thunks should never be called, but they
+  // must exist to satisfy the compiler.
+  _CCCL_UNREACHABLE();
+}
+
+} // namespace cuda::experimental
+
+_CCCL_POP_MACROS
+
+#endif // __CUDAX_DETAIL_BASIC_ANY_VIRTCALL_H
diff --git a/cudax/include/cuda/experimental/__utility/basic_any/virtual_functions.cuh b/cudax/include/cuda/experimental/__utility/basic_any/virtual_functions.cuh
new file mode 100644
index 00000000000..5aa7f51a7ec
--- /dev/null
+++ b/cudax/include/cuda/experimental/__utility/basic_any/virtual_functions.cuh
@@ -0,0 +1,177 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of CUDA Experimental in CUDA C++ Core Libraries,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef __CUDAX_DETAIL_BASIC_ANY_VIRUAL_FUNCTIONS_H
+#define __CUDAX_DETAIL_BASIC_ANY_VIRUAL_FUNCTIONS_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__algorithm/max.h>
+#include <cuda/std/__type_traits/is_nothrow_move_constructible.h>
+#include <cuda/std/__type_traits/maybe_const.h>
+#include <cuda/std/__type_traits/type_list.h>
+#include <cuda/std/__utility/swap.h>
+#include <cuda/std/__utility/typeid.h>
+
+#include <cuda/experimental/__utility/basic_any/basic_any_fwd.cuh>
+
+_CCCL_PUSH_MACROS
+#undef interface
+
+namespace cuda::experimental
+{
+//!
+//! __override_tag
+//!
+template <class _Tp, auto _Override>
+struct __override_tag_;
+
+template <class _Tp, auto _Override>
+using __override_tag _CCCL_NODEBUG_ALIAS = __override_tag_<_Tp, _Override>*;
+
+_CCCL_DIAG_PUSH
+_CCCL_DIAG_SUPPRESS_GCC("-Wstrict-aliasing")
+
+template <class _Fn, class _Cp>
+_CUDAX_HOST_API auto __class_of_(_Fn _Cp::*) -> _Cp;
+
+template <class _Fn>
+using __class_of _CCCL_NODEBUG_ALIAS = decltype(__cudax::__class_of_(_Fn()));
+
+//! We use a C-style cast instead of a static_cast because a C-style cast will
+//! ignore accessibility, letting us cast to a private base class.
+template <class _DstPtr, class _Src>
+_CUDAX_TRIVIAL_HOST_API auto __c_style_cast(_Src* __ptr) noexcept -> _DstPtr
+{
+  static_assert(_CUDA_VSTD::is_pointer_v<_DstPtr>, "");
+  static_assert(_CUDA_VSTD::is_base_of_v<_CUDA_VSTD::remove_pointer_t<_DstPtr>, _Src>, "invalid C-style cast detected");
+  return (_DstPtr) __ptr; // NOLINT(cppcoreguidelines-pro-type-cstyle-cast)
+}
+
+template <class _Tp, auto _Fn, class _Ret, bool _IsConst, bool _IsNothrow, class... _Args>
+_CCCL_NODISCARD _CUDAX_HOST_API auto __override_fn_([[maybe_unused]] _CUDA_VSTD::__maybe_const<_IsConst, void>* __pv,
+                                                    [[maybe_unused]] _Args... __args) noexcept(_IsNothrow) -> _Ret
+{
+  using __value_type _CCCL_NODEBUG_ALIAS = _CUDA_VSTD::__maybe_const<_IsConst, _Tp>;
+
+  if constexpr (_CUDA_VSTD::is_same_v<_Tp, void>)
+  {
+    // This instantiation is created only during the computation of the vtable
+    // type. It is never actually called.
+    _CCCL_UNREACHABLE();
+  }
+  else if constexpr (_CUDA_VSTD::is_member_function_pointer_v<decltype(_Fn)>)
+  {
+    // _Fn may be a pointer to a member function of a private base of _Tp. So
+    // after static_cast-ing to _Tp*, we need to use a C-style cast to get a
+    // pointer to the correct base class.
+    using __class_type  = _CUDA_VSTD::__maybe_const<_IsConst, __class_of<decltype(_Fn)>>;
+    __class_type& __obj = *__cudax::__c_style_cast<__class_type*>(static_cast<__value_type*>(__pv));
+    return (__obj.*_Fn)(static_cast<_Args&&>(__args)...);
+  }
+  else
+  {
+    __value_type& __obj = *static_cast<__value_type*>(__pv);
+    return (*_Fn)(__obj, static_cast<_Args&&>(__args)...);
+  }
+}
+
+_CCCL_DIAG_POP
+
+template <class _Fn, class _Tp = void, auto _Override = 0>
+extern _CUDA_VSTD::__undefined<_Fn> __virtual_override_fn;
+
+template <class _Tp, auto _Override, class _Ret, class _Cp, class... _Args>
+inline constexpr __identity_t<_Ret (*)(void*, _Args...)> //
+  __virtual_override_fn<_Ret (*)(_Cp&, _Args...), _Tp, _Override> = //
+  &__override_fn_<_Tp, _Override, _Ret, false, false, _Args...>;
+
+template <class _Tp, auto _Override, class _Ret, class _Cp, class... _Args>
+inline constexpr __identity_t<_Ret (*)(void const*, _Args...)>
+  __virtual_override_fn<_Ret (*)(_Cp const&, _Args...), _Tp, _Override> =
+    &__override_fn_<_Tp, _Override, _Ret, true, false, _Args...>;
+
+template <class _Tp, auto _Override, class _Ret, class _Cp, class... _Args>
+inline constexpr __identity_t<_Ret (*)(void*, _Args...) noexcept>
+  __virtual_override_fn<_Ret (*)(_Cp&, _Args...) noexcept, _Tp, _Override> =
+    &__override_fn_<_Tp, _Override, _Ret, false, true, _Args...>;
+
+template <class _Tp, auto _Override, class _Ret, class _Cp, class... _Args>
+inline constexpr __identity_t<_Ret (*)(void const*, _Args...) noexcept>
+  __virtual_override_fn<_Ret (*)(_Cp const&, _Args...) noexcept, _Tp, _Override> =
+    &__override_fn_<_Tp, _Override, _Ret, true, true, _Args...>;
+
+// TODO: Add support for member functions with reference qualifiers.
+
+template <class _Tp, auto _Override, class _Ret, class _Cp, class... _Args>
+inline constexpr __identity_t<_Ret (*)(void*, _Args...)> //
+  __virtual_override_fn<_Ret (_Cp::*)(_Args...), _Tp, _Override> = //
+  &__override_fn_<_Tp, _Override, _Ret, false, false, _Args...>;
+
+template <class _Tp, auto _Override, class _Ret, class _Cp, class... _Args>
+inline constexpr __identity_t<_Ret (*)(void const*, _Args...)> //
+  __virtual_override_fn<_Ret (_Cp::*)(_Args...) const, _Tp, _Override> =
+    &__override_fn_<_Tp, _Override, _Ret, true, false, _Args...>;
+
+template <class _Tp, auto _Override, class _Ret, class _Cp, class... _Args>
+inline constexpr __identity_t<_Ret (*)(void*, _Args...) noexcept>
+  __virtual_override_fn<_Ret (_Cp::*)(_Args...) noexcept, _Tp, _Override> =
+    &__override_fn_<_Tp, _Override, _Ret, false, true, _Args...>;
+
+template <class _Tp, auto _Override, class _Ret, class _Cp, class... _Args>
+inline constexpr __identity_t<_Ret (*)(void const*, _Args...) noexcept>
+  __virtual_override_fn<_Ret (_Cp::*)(_Args...) const noexcept, _Tp, _Override> =
+    &__override_fn_<_Tp, _Override, _Ret, true, true, _Args...>;
+
+template <class _Ret, class... _Args>
+_CUDAX_HOST_API auto __get_virtual_result(_Ret (*)(_Args...)) -> _Ret;
+
+template <class _Ret, class... _Args>
+_CUDAX_HOST_API auto __get_virtual_result(_Ret (*)(_Args...) noexcept) noexcept -> _Ret;
+
+template <class _Ret, class... _Args>
+_CUDAX_HOST_API auto __is_virtual_const(_Ret (*)(void*, _Args...)) -> _CUDA_VSTD::false_type;
+
+template <class _Ret, class... _Args>
+_CUDAX_HOST_API auto __is_virtual_const(_Ret (*)(void const*, _Args...)) -> _CUDA_VSTD::true_type;
+
+//!
+//! __virtual_fn
+//!
+template <auto _Fn>
+struct __virtual_fn
+{
+  using __function_t _CCCL_NODEBUG_ALIAS = decltype(__virtual_override_fn<decltype(_Fn)>);
+  using __result_t _CCCL_NODEBUG_ALIAS   = decltype(__get_virtual_result(__function_t{}));
+
+  static constexpr bool __const_fn   = decltype(__cudax::__is_virtual_const(__function_t{}))::value;
+  static constexpr bool __nothrow_fn = noexcept(__cudax::__get_virtual_result(__function_t{}));
+
+  template <class _Tp, auto _Override>
+  _CUDAX_HOST_API constexpr __virtual_fn(__override_tag<_Tp, _Override>) noexcept
+      : __fn_(__virtual_override_fn<decltype(_Fn), _Tp, _Override>)
+  {}
+
+  __function_t __fn_;
+};
+
+} // namespace cuda::experimental
+
+_CCCL_POP_MACROS
+
+#endif // __CUDAX_DETAIL_BASIC_ANY_VIRUAL_FUNCTIONS_H
diff --git a/cudax/include/cuda/experimental/__utility/basic_any/virtual_ptrs.cuh b/cudax/include/cuda/experimental/__utility/basic_any/virtual_ptrs.cuh
new file mode 100644
index 00000000000..b57f8abb0d8
--- /dev/null
+++ b/cudax/include/cuda/experimental/__utility/basic_any/virtual_ptrs.cuh
@@ -0,0 +1,82 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of CUDA Experimental in CUDA C++ Core Libraries,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef __CUDAX_DETAIL_BASIC_ANY_VIRTUAL_PTRS_H
+#define __CUDAX_DETAIL_BASIC_ANY_VIRTUAL_PTRS_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__exception/terminate.h>
+#include <cuda/std/__utility/typeid.h>
+
+#include <cuda/experimental/__utility/basic_any/basic_any_fwd.cuh>
+#include <cuda/experimental/__utility/basic_any/interfaces.cuh>
+
+_CCCL_PUSH_MACROS
+#undef interface
+
+namespace cuda::experimental
+{
+struct __base_vptr
+{
+  __base_vptr() = default;
+
+  _CUDAX_TRIVIAL_HOST_API constexpr __base_vptr(__rtti_base const* __vptr) noexcept
+      : __vptr_(__vptr)
+  {}
+
+  template <class _VTable>
+  _CCCL_NODISCARD _CUDAX_TRIVIAL_HOST_API explicit constexpr operator _VTable const*() const noexcept
+  {
+    auto const* __vptr = static_cast<_VTable const*>(__vptr_);
+    _CCCL_ASSERT(_CCCL_TYPEID(_VTable) == *__vptr->__typeid_, "bad vtable cast detected");
+    return __vptr;
+  }
+
+  _CCCL_NODISCARD _CUDAX_TRIVIAL_HOST_API explicit constexpr operator bool() const noexcept
+  {
+    return __vptr_ != nullptr;
+  }
+
+  _CCCL_NODISCARD _CUDAX_TRIVIAL_HOST_API constexpr auto operator->() const noexcept -> __rtti_base const*
+  {
+    return __vptr_;
+  }
+
+#if defined(__cpp_three_way_comparison)
+  bool operator==(__base_vptr const& __other) const noexcept = default;
+#else // ^^^ __cpp_three_way_comparison ^^^ / vvv !__cpp_three_way_comparison vvv
+  _CCCL_NODISCARD_FRIEND _CUDAX_HOST_API constexpr auto operator==(__base_vptr __lhs, __base_vptr __rhs) noexcept -> bool
+  {
+    return __lhs.__vptr_ == __rhs.__vptr_;
+  }
+
+  _CCCL_NODISCARD_FRIEND _CUDAX_HOST_API constexpr auto operator!=(__base_vptr __lhs, __base_vptr __rhs) noexcept -> bool
+  {
+    return !(__lhs == __rhs);
+  }
+#endif // !__cpp_three_way_comparison
+
+  __rtti_base const* __vptr_{};
+};
+
+} // namespace cuda::experimental
+
+_CCCL_POP_MACROS
+
+#endif // __CUDAX_DETAIL_BASIC_ANY_VIRTUAL_PTRS_H
diff --git a/cudax/include/cuda/experimental/__utility/basic_any/virtual_tables.cuh b/cudax/include/cuda/experimental/__utility/basic_any/virtual_tables.cuh
new file mode 100644
index 00000000000..466fd6a51f6
--- /dev/null
+++ b/cudax/include/cuda/experimental/__utility/basic_any/virtual_tables.cuh
@@ -0,0 +1,148 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of CUDA Experimental in CUDA C++ Core Libraries,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef __CUDAX_DETAIL_BASIC_ANY_VIRTUAL_TABLES_H
+#define __CUDAX_DETAIL_BASIC_ANY_VIRTUAL_TABLES_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__utility/typeid.h>
+
+#include <cuda/experimental/__utility/basic_any/basic_any_fwd.cuh>
+#include <cuda/experimental/__utility/basic_any/interfaces.cuh>
+#include <cuda/experimental/__utility/basic_any/rtti.cuh>
+#include <cuda/experimental/__utility/basic_any/virtual_functions.cuh>
+#include <cuda/experimental/__utility/basic_any/virtual_ptrs.cuh>
+
+_CCCL_PUSH_MACROS
+#undef interface
+
+namespace cuda::experimental
+{
+template <class _Interface>
+using __vtable_for _CCCL_NODEBUG_ALIAS = typename __overrides_for<_Interface>::__vtable;
+
+//!
+//! __basic_vtable
+//!
+template <class _Interface, auto... _Mbrs>
+struct _LIBCUDACXX_DECLSPEC_EMPTY_BASES __basic_vtable
+    : __rtti_base
+    , __virtual_fn<_Mbrs>...
+{
+  using interface _CCCL_NODEBUG_ALIAS = _Interface;
+  static constexpr size_t __cbases    = _CUDA_VSTD::__type_list_size<__unique_interfaces<interface>>::value;
+
+  template <class _VPtr, class _Tp, auto... _OtherMembers, class... _Interfaces>
+  _CUDAX_HOST_API constexpr __basic_vtable(
+    _VPtr __vptr, overrides_for<_Tp, _OtherMembers...>, __tag<_Interfaces...>) noexcept
+      : __rtti_base{__vtable_kind::__normal, __cbases, _CCCL_TYPEID(__basic_vtable)}
+      , __virtual_fn<_Mbrs>{__override_tag<_Tp, _OtherMembers>{}}...
+      , __vptr_map_{__base_vptr{__vptr->__query_interface(_Interfaces())}...}
+  {}
+
+  template <class _Tp, class _VPtr>
+  _CUDAX_HOST_API constexpr __basic_vtable(__tag<_Tp>, _VPtr __vptr) noexcept
+      : __basic_vtable{
+          __vptr, __overrides_for<interface, _Tp>(), __unique_interfaces<interface, _CUDA_VSTD::__type_quote<__tag>>()}
+  {}
+
+  _CCCL_NODISCARD _CUDAX_HOST_API auto __query_interface(interface) const noexcept -> __vptr_for<interface>
+  {
+    return this;
+  }
+
+  template <class... _Others>
+  _CCCL_NODISCARD _CUDAX_HOST_API auto
+  __query_interface(__iset<_Others...>) const noexcept -> __vptr_for<__iset<_Others...>>
+  {
+    using __remainder _CCCL_NODEBUG_ALIAS =
+      _CUDA_VSTD::__type_list_size<_CUDA_VSTD::__type_find<__unique_interfaces<interface>, __iset<_Others...>>>;
+    constexpr size_t __index = __cbases - __remainder::value;
+    if constexpr (__index < __cbases)
+    {
+      // `_Interface` extends __iset<_Others...> exactly. We can return an actual
+      // vtable pointer.
+      return static_cast<__vtable_for<__iset<_Others...>> const*>(__vptr_map_[__index]);
+    }
+    else
+    {
+      // Otherwise, we have to return a subset vtable pointer, which does
+      // dynamic interface lookup.
+      return static_cast<__vptr_for<__iset<_Others...>>>(__query_interface(iunknown()));
+    }
+  }
+
+  template <class _Other>
+  _CCCL_NODISCARD _CUDAX_HOST_API auto __query_interface(_Other) const noexcept -> __vptr_for<_Other>
+  {
+    constexpr size_t __index = __index_of_base<_Other, interface>::value;
+    static_assert(__index < __cbases);
+    return static_cast<__vptr_for<_Other>>(__vptr_map_[__index]);
+  }
+
+  __base_vptr __vptr_map_[__cbases];
+};
+
+//!
+//! __vtable implementation details
+//!
+
+template <class... _Interfaces>
+struct _LIBCUDACXX_DECLSPEC_EMPTY_BASES __vtable_tuple
+    : __rtti_ex<sizeof...(_Interfaces)>
+    , __vtable_for<_Interfaces>...
+{
+  static_assert((_CUDA_VSTD::is_class_v<_Interfaces> && ...), "expected class types");
+
+  template <class _Tp, class _Super>
+  _CUDAX_HOST_API constexpr __vtable_tuple(__tag<_Tp, _Super> __type) noexcept
+      : __rtti_ex<sizeof...(_Interfaces)>{__type, __tag<_Interfaces...>(), this}
+#if _CCCL_COMPILER(MSVC)
+      // workaround for MSVC bug
+      , __overrides_for<_Interfaces>::__vtable{__tag<_Tp>(), this}...
+#else // ^^^ MSVC ^^^ / vvv !MSVC vvv
+      , __vtable_for<_Interfaces>{__tag<_Tp>(), this}...
+#endif // !MSVC
+  {
+    static_assert(_CUDA_VSTD::is_class_v<_Super>, "expected a class type");
+  }
+
+  _CCCL_TEMPLATE(class _Interface)
+  _CCCL_REQUIRES(_CUDA_VSTD::__is_included_in_v<_Interface, _Interfaces...>)
+  _CCCL_NODISCARD _CUDAX_HOST_API constexpr auto __query_interface(_Interface) const noexcept -> __vptr_for<_Interface>
+  {
+    return static_cast<__vptr_for<_Interface>>(this);
+  }
+};
+
+// The vtable type for type `_Interface` is a `__vtable_tuple` of `_Interface`
+// and all of its base interfaces.
+template <class _Interface>
+using __vtable _CCCL_NODEBUG_ALIAS = __unique_interfaces<_Interface, _CUDA_VSTD::__type_quote<__vtable_tuple>>;
+
+// __vtable_for_v<_Interface, _Tp> is an instance of `__vtable<_Interface>` that
+// contains the overrides for `_Tp`.
+template <class _Interface, class _Tp>
+inline constexpr __vtable<_Interface> __vtable_for_v{__tag<_Tp, _Interface>()};
+
+} // namespace cuda::experimental
+
+_CCCL_POP_MACROS
+
+#endif // __CUDAX_DETAIL_BASIC_ANY_VIRTUAL_TABLES_H
diff --git a/cudax/test/CMakeLists.txt b/cudax/test/CMakeLists.txt
index 9af2c83cc6f..5752b89ad83 100644
--- a/cudax/test/CMakeLists.txt
+++ b/cudax/test/CMakeLists.txt
@@ -41,6 +41,7 @@ function(cudax_add_catch2_test target_name_var test_name cn_target) # ARGN=test
     "-DLIBCUDACXX_ENABLE_EXPERIMENTAL_MEMORY_RESOURCE"
     $<$<COMPILE_LANG_AND_ID:CUDA,NVIDIA>:--extended-lambda>
   )
+
   cudax_clone_target_properties(${test_target} ${cn_target})
   set_target_properties(${test_target} PROPERTIES
     CUDA_ARCHITECTURES "${CMAKE_CUDA_ARCHITECTURES}"
@@ -96,6 +97,7 @@ foreach(cn_target IN LISTS cudax_TARGETS)
   )
 
   cudax_add_catch2_test(test_target misc ${cn_target}
+    utility/basic_any.cu
     utility/driver_api.cu
     utility/ensure_current_device.cu
   )
diff --git a/cudax/test/memory_resource/any_async_resource.cu b/cudax/test/memory_resource/any_async_resource.cu
index 89c28b8a279..36f067a9743 100644
--- a/cudax/test/memory_resource/any_async_resource.cu
+++ b/cudax/test/memory_resource/any_async_resource.cu
@@ -18,7 +18,7 @@ TEMPLATE_TEST_CASE_METHOD(test_fixture, "any_async_resource", "[container][resou
 {
   using TestResource = TestType;
   static_assert(cuda::mr::resource_with<TestResource, cuda::mr::host_accessible>);
-  constexpr bool is_big = sizeof(TestResource) > sizeof(cuda::mr::_AnyResourceStorage);
+  constexpr bool is_big = sizeof(TestResource) > cudax::__default_buffer_size;
 
   SECTION("construct and destruct")
   {
@@ -141,7 +141,7 @@ TEMPLATE_TEST_CASE_METHOD(test_fixture, "any_async_resource", "[container][resou
       ++expected.move_count;
       CHECK(this->counts == expected);
 
-      cuda::mr::resource_ref<cuda::mr::host_accessible> ref = mr;
+      cudax::resource_ref<cuda::mr::host_accessible> ref = mr;
 
       CHECK(this->counts == expected);
       auto* ptr = ref.allocate(bytes(100), align(8));
diff --git a/cudax/test/memory_resource/any_resource.cu b/cudax/test/memory_resource/any_resource.cu
index c013785f32f..f1825365529 100644
--- a/cudax/test/memory_resource/any_resource.cu
+++ b/cudax/test/memory_resource/any_resource.cu
@@ -8,27 +8,41 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include <cuda/experimental/memory_resource.cuh>
+#ifndef __CUDA_ARCH__
 
-#include "test_resource.cuh"
-#include <catch2/catch.hpp>
-#include <testing.cuh>
+#  include <cuda/memory_resource>
+
+#  include <cuda/experimental/memory_resource.cuh>
+
+#  include "test_resource.cuh"
+#  include <catch2/catch.hpp>
+#  include <testing.cuh>
+
+static_assert(cuda::has_property<cudax::any_resource<cuda::mr::host_accessible, get_data>, cuda::mr::host_accessible>);
+static_assert(cuda::has_property<cudax::any_resource<cuda::mr::host_accessible, get_data>, get_data>);
+static_assert(
+  !cuda::has_property<cudax::any_resource<cuda::mr::host_accessible, get_data>, cuda::mr::device_accessible>);
+
+struct unused_property
+{};
 
 TEMPLATE_TEST_CASE_METHOD(test_fixture, "any_resource", "[container][resource]", big_resource, small_resource)
 {
   using TestResource    = TestType;
-  constexpr bool is_big = sizeof(TestResource) > sizeof(cuda::mr::_AnyResourceStorage);
+  constexpr bool is_big = sizeof(TestResource) > cudax::__default_buffer_size;
 
   SECTION("construct and destruct")
   {
     Counts expected{};
     CHECK(this->counts == expected);
     {
-      cudax::any_resource<cuda::mr::host_accessible> mr{TestResource{42, this}};
+      cudax::any_resource<cuda::mr::host_accessible, get_data> mr{TestResource{42, this}};
       expected.new_count += is_big;
       ++expected.object_count;
       ++expected.move_count;
       CHECK(this->counts == expected);
+      CHECK(get_property(mr, get_data{}) == 42);
+      get_property(mr, cuda::mr::host_accessible{});
     }
     expected.delete_count += is_big;
     --expected.object_count;
@@ -43,7 +57,7 @@ TEMPLATE_TEST_CASE_METHOD(test_fixture, "any_resource", "[container][resource]",
     Counts expected{};
     CHECK(this->counts == expected);
     {
-      cudax::any_resource<cuda::mr::host_accessible> mr{TestResource{42, this}};
+      cudax::any_resource<cuda::mr::host_accessible, get_data> mr{TestResource{42, this}};
       expected.new_count += is_big;
       ++expected.object_count;
       ++expected.move_count;
@@ -78,7 +92,7 @@ TEMPLATE_TEST_CASE_METHOD(test_fixture, "any_resource", "[container][resource]",
     Counts expected{};
     CHECK(this->counts == expected);
     {
-      cudax::any_resource<cuda::mr::host_accessible> mr{TestResource{42, this}};
+      cudax::any_resource<cuda::mr::host_accessible, get_data> mr{TestResource{42, this}};
       expected.new_count += is_big;
       ++expected.object_count;
       ++expected.move_count;
@@ -101,17 +115,69 @@ TEMPLATE_TEST_CASE_METHOD(test_fixture, "any_resource", "[container][resource]",
   // Reset the counters:
   this->counts = Counts();
 
-  SECTION("conversion to resource_ref")
+  SECTION("equality comparable")
+  {
+    Counts expected{};
+    CHECK(this->counts == expected);
+    {
+      cudax::managed_memory_resource managed1{}, managed2{};
+      CHECK(managed1 == managed2);
+      cudax::any_resource<cuda::mr::device_accessible> mr{managed1};
+      CHECK(mr == managed1);
+    }
+    CHECK(this->counts == expected);
+  }
+
+  // Reset the counters:
+  this->counts = Counts();
+
+  SECTION("conversion from any_resource to cudax::resource_ref")
   {
     Counts expected{};
     {
-      cudax::any_resource<cuda::mr::host_accessible> mr{TestResource{42, this}};
+      cudax::any_resource<cuda::mr::host_accessible, cuda::mr::device_accessible, get_data> mr{TestResource{42, this}};
       expected.new_count += is_big;
       ++expected.object_count;
       ++expected.move_count;
       CHECK(this->counts == expected);
 
-      cuda::mr::resource_ref<cuda::mr::host_accessible> ref = mr;
+      // conversion from any_resource to cuda::mr::resource_ref:
+      cuda::mr::resource_ref<cuda::mr::host_accessible, cuda::mr::device_accessible, get_data> ref = mr;
+
+      // conversion from any_resource to cuda::mr::resource_ref with narrowing:
+      cuda::mr::resource_ref<cuda::mr::host_accessible, get_data> ref2 = mr;
+      CHECK(get_property(ref2, get_data{}) == 42);
+
+      CHECK(this->counts == expected);
+      auto* ptr = ref.allocate(bytes(100), align(8));
+      CHECK(ptr == this);
+      ++expected.allocate_count;
+      CHECK(this->counts == expected);
+      ref.deallocate(ptr, bytes(0), align(0));
+      ++expected.deallocate_count;
+      CHECK(this->counts == expected);
+    }
+    expected.delete_count += is_big;
+    --expected.object_count;
+    CHECK(this->counts == expected);
+  }
+
+  SECTION("conversion from any_resource to cuda::mr::resource_ref")
+  {
+    Counts expected{};
+    {
+      cudax::any_resource<cuda::mr::host_accessible, cuda::mr::device_accessible, get_data> mr{TestResource{42, this}};
+      expected.new_count += is_big;
+      ++expected.object_count;
+      ++expected.move_count;
+      CHECK(this->counts == expected);
+
+      // conversion from any_resource to cuda::mr::resource_ref:
+      cuda::mr::resource_ref<cuda::mr::host_accessible, cuda::mr::device_accessible, get_data> ref = mr;
+
+      // conversion from any_resource to cuda::mr::resource_ref with narrowing:
+      cuda::mr::resource_ref<cuda::mr::host_accessible, get_data> ref2 = mr;
+      CHECK(get_property(ref2, get_data{}) == 42);
 
       CHECK(this->counts == expected);
       auto* ptr = ref.allocate(bytes(100), align(8));
@@ -130,13 +196,83 @@ TEMPLATE_TEST_CASE_METHOD(test_fixture, "any_resource", "[container][resource]",
   // Reset the counters:
   this->counts = Counts();
 
+  SECTION("conversion from resource_ref to any_resource")
+  {
+    Counts expected{};
+    {
+      TestResource test{42, this};
+      ++expected.object_count;
+      cudax::resource_ref<cuda::mr::host_accessible, get_data> ref{test};
+      CHECK(this->counts == expected);
+
+      cudax::any_resource<cuda::mr::host_accessible, get_data> mr = ref;
+      expected.new_count += is_big;
+      ++expected.object_count;
+      ++expected.copy_count;
+      CHECK(this->counts == expected);
+
+      auto* ptr = ref.allocate(bytes(100), align(8));
+      CHECK(ptr == this);
+      ++expected.allocate_count;
+      CHECK(this->counts == expected);
+      ref.deallocate(ptr, bytes(0), align(0));
+      ++expected.deallocate_count;
+      CHECK(this->counts == expected);
+    }
+    expected.delete_count += is_big;
+    expected.object_count -= 2;
+    CHECK(this->counts == expected);
+  }
+
+  // Reset the counters:
+  this->counts = Counts();
+
+  SECTION("test slicing off of properties")
+  {
+    Counts expected{};
+    CHECK(this->counts == expected);
+    {
+      cudax::any_resource<cuda::mr::host_accessible, cuda::mr::device_accessible, get_data> mr{TestResource{42, this}};
+      expected.new_count += is_big;
+      ++expected.object_count;
+      ++expected.move_count;
+      CHECK(this->counts == expected);
+
+      cudax::any_resource<cuda::mr::device_accessible, get_data> mr2 = mr;
+      expected.new_count += is_big;
+      ++expected.object_count;
+      ++expected.copy_count;
+      CHECK(this->counts == expected);
+
+      CHECK(get_property(mr2, get_data{}) == 42);
+      auto data = try_get_property(mr2, get_data{});
+      static_assert(cuda::std::is_same_v<decltype(data), cuda::std::optional<int>>);
+      CHECK(data.has_value());
+      CHECK(data.value() == 42);
+
+      auto host = try_get_property(mr2, cuda::mr::host_accessible{});
+      static_assert(cuda::std::is_same_v<decltype(host), bool>);
+      CHECK(host);
+
+      auto unused = try_get_property(mr2, unused_property{});
+      static_assert(cuda::std::is_same_v<decltype(unused), bool>);
+      CHECK(!unused);
+    }
+    expected.delete_count += 2 * is_big;
+    expected.object_count -= 2;
+    CHECK(this->counts == expected);
+  }
+
+  // Reset the counters:
+  this->counts = Counts();
+
   SECTION("make_any_resource")
   {
     Counts expected{};
     CHECK(this->counts == expected);
     {
-      cudax::any_resource<cuda::mr::host_accessible> mr =
-        cudax::make_any_resource<TestResource, cuda::mr::host_accessible>(42, this);
+      cudax::any_resource<cuda::mr::host_accessible, get_data> mr =
+        cudax::make_any_resource<TestResource, cuda::mr::host_accessible, get_data>(42, this);
       expected.new_count += is_big;
       ++expected.object_count;
       CHECK(this->counts == expected);
@@ -148,3 +284,5 @@ TEMPLATE_TEST_CASE_METHOD(test_fixture, "any_resource", "[container][resource]",
   // Reset the counters:
   this->counts = Counts();
 }
+
+#endif // __CUDA_ARCH__
diff --git a/cudax/test/memory_resource/device_memory_resource.cu b/cudax/test/memory_resource/device_memory_resource.cu
index 29b5d4d9baf..77d3e4f841c 100644
--- a/cudax/test/memory_resource/device_memory_resource.cu
+++ b/cudax/test/memory_resource/device_memory_resource.cu
@@ -428,7 +428,7 @@ TEST_CASE("device_memory_resource comparison", "[memory_resource]")
 
   { // comparison against a device_memory_resource wrapped inside a resource_ref<device_accessible>
     cuda::experimental::device_memory_resource second{};
-    cuda::mr::resource_ref<cuda::mr::device_accessible> second_ref{second};
+    cuda::experimental::resource_ref<cuda::mr::device_accessible> second_ref{second};
     CHECK(first == second_ref);
     CHECK(!(first != second_ref));
     CHECK(second_ref == first);
@@ -437,7 +437,7 @@ TEST_CASE("device_memory_resource comparison", "[memory_resource]")
 
   { // comparison against a device_memory_resource wrapped inside a async_resource_ref
     cuda::experimental::device_memory_resource second{};
-    cuda::mr::async_resource_ref<cuda::mr::device_accessible> second_ref{second};
+    cuda::experimental::async_resource_ref<cuda::mr::device_accessible> second_ref{second};
 
     CHECK(first == second_ref);
     CHECK(!(first != second_ref));
diff --git a/cudax/test/memory_resource/shared_resource.cu b/cudax/test/memory_resource/shared_resource.cu
index 02e98f10cf9..f31476983ae 100644
--- a/cudax/test/memory_resource/shared_resource.cu
+++ b/cudax/test/memory_resource/shared_resource.cu
@@ -105,7 +105,7 @@ TEMPLATE_TEST_CASE_METHOD(test_fixture, "shared_resource", "[container][resource
       ++expected.object_count;
       CHECK(this->counts == expected);
 
-      cuda::mr::resource_ref<cuda::mr::host_accessible> ref = mr;
+      cudax::resource_ref<cuda::mr::host_accessible> ref = mr;
 
       CHECK(this->counts == expected);
       auto* ptr = ref.allocate(bytes(100), align(8));
diff --git a/cudax/test/memory_resource/test_resource.cuh b/cudax/test/memory_resource/test_resource.cuh
index 524ad12089e..e96f3256407 100644
--- a/cudax/test/memory_resource/test_resource.cuh
+++ b/cudax/test/memory_resource/test_resource.cuh
@@ -2,6 +2,10 @@
 
 #include <cuda_runtime_api.h>
 
+#include <cuda/stream_ref>
+
+#include <cuda/experimental/__memory_resource/any_resource.cuh>
+
 #include <cstddef>
 #include <cstdint>
 
@@ -90,6 +94,11 @@ inline thread_local Counts* test_fixture_::counts_ = nullptr;
 template <class>
 using test_fixture = test_fixture_;
 
+struct get_data
+{
+  using value_type = int;
+};
+
 template <class T>
 struct test_resource
 {
@@ -128,6 +137,14 @@ struct test_resource
     --fixture->counts.object_count;
   }
 
+  test_resource& operator=(test_resource other) noexcept
+  {
+    other._assert_valid();
+    ::cuda::std::swap(data, other.data);
+    ::cuda::std::swap(fixture, other.fixture);
+    return *this;
+  }
+
   void* allocate(std::size_t bytes, std::size_t align)
   {
     _assert_valid();
@@ -199,10 +216,14 @@ struct test_resource
   }
 
   friend constexpr void get_property(const test_resource&, cuda::mr::host_accessible) noexcept {}
+  friend constexpr int get_property(const test_resource& self, get_data) noexcept
+  {
+    return self.data;
+  }
 };
 
 using big_resource   = test_resource<uintptr_t>;
 using small_resource = test_resource<unsigned int>;
 
-static_assert(sizeof(big_resource) > sizeof(cuda::mr::_AnyResourceStorage));
-static_assert(sizeof(small_resource) <= sizeof(cuda::mr::_AnyResourceStorage));
+static_assert(sizeof(big_resource) > cuda::experimental::__default_buffer_size);
+static_assert(sizeof(small_resource) <= cuda::experimental::__default_buffer_size);
diff --git a/cudax/test/utility/basic_any.cu b/cudax/test/utility/basic_any.cu
new file mode 100644
index 00000000000..c3ac5673b27
--- /dev/null
+++ b/cudax/test/utility/basic_any.cu
@@ -0,0 +1,553 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of CUDA Experimental in CUDA C++ Core Libraries,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#include <cuda/std/__type_traits/is_standard_layout.h>
+
+#include <cuda/experimental/__utility/basic_any.cuh>
+
+#include <testing.cuh>
+
+// basic_any is not yet supported in device code because of nvbugs/4886070
+#ifndef __CUDA_ARCH__
+#  undef interface
+
+using immovable = cudax::detail::__immovable;
+
+struct TestCounters
+{
+  int objects = 0;
+};
+
+template <class TestType>
+struct BasicAnyTestsFixture : TestCounters
+{
+  BasicAnyTestsFixture() {}
+};
+
+template <class...>
+struct iempty : cudax::interface<iempty>
+{};
+
+static_assert(cudax::extension_of<iempty<>, iempty<>>);
+static_assert(cudax::extension_of<iempty<>, cudax::iunknown>);
+
+template <class...>
+struct ibase : cudax::interface<ibase, cudax::extends<cudax::imovable<>>>
+{
+  int foo(int i)
+  {
+    return cudax::virtcall<&ibase::foo>(this, i);
+  }
+
+  template <class T>
+  using overrides = cudax::overrides_for<T, &T::foo>;
+};
+
+template <class...>
+struct iderived : cudax::interface<iderived, cudax::extends<ibase<>, cudax::icopyable<>>>
+{
+  int bar(int i)
+  {
+    return cudax::virtcall<&iderived::bar>(this, i);
+  }
+
+  template <class T>
+  using overrides = cudax::overrides_for<T, &T::bar>;
+};
+
+template <bool Small>
+struct SmallOrLarge
+{
+  unsigned int cookie = 0xDEADBEEF;
+};
+
+template <>
+struct SmallOrLarge<false>
+{
+  unsigned int cookie = 0xDEADBEEF;
+  std::byte buffer[cudax::__default_buffer_size]{};
+};
+
+constexpr bool Small = true;
+constexpr bool Large = false;
+
+using SmallType = SmallOrLarge<Small>;
+using LargeType = SmallOrLarge<Large>;
+
+template <bool Small>
+struct Foo
+{
+  _CCCL_HOST_DEVICE Foo(int i, TestCounters* c)
+      : j(i)
+      , counters(c)
+  {
+    ++counters->objects;
+  }
+
+  _CCCL_HOST_DEVICE Foo(Foo&& other) noexcept
+      : j(other.j)
+      , counters(other.counters)
+  {
+    ++counters->objects;
+    other.j = INT_MAX;
+  }
+
+  _CCCL_HOST_DEVICE Foo(Foo const& other) noexcept // TODO: test that types with throwing moves are "large"
+      : j(other.j)
+      , counters(other.counters)
+  {
+    ++counters->objects;
+  }
+
+  _CCCL_HOST_DEVICE ~Foo()
+  {
+    --counters->objects;
+  }
+
+  _CCCL_HOST_DEVICE Foo& operator=(Foo&& other) noexcept
+  {
+    operator=(other);
+    other.j = INT_MAX;
+    return *this;
+  }
+
+  _CCCL_HOST_DEVICE Foo& operator=(Foo const& other) noexcept
+  {
+    j        = other.j;
+    counters = other.counters;
+    return *this;
+  }
+
+  _CCCL_HOST_DEVICE int foo(int i)
+  {
+    return i + j;
+  }
+
+  int j;
+  TestCounters* counters;
+  SmallOrLarge<Small> k;
+};
+
+template <bool Small>
+struct Bar : Foo<Small>
+{
+  using Foo<Small>::Foo;
+
+  _CCCL_HOST_DEVICE int bar(int i)
+  {
+    return i * this->j;
+  }
+};
+
+template <class...>
+struct iregular : cudax::interface<iregular, cudax::extends<cudax::icopyable<>, cudax::iequality_comparable<>>>
+{};
+
+struct Regular
+{
+  _CCCL_HOST_DEVICE bool operator==(Regular const& other) const
+  {
+    return i == other.i;
+  }
+
+  _CCCL_HOST_DEVICE bool operator!=(Regular const& other) const
+  {
+    return !operator==(other);
+  }
+
+  int i = 0;
+};
+
+TEMPLATE_TEST_CASE_METHOD(BasicAnyTestsFixture, "basic_any tests", "[utility][basic_any]", SmallType, LargeType)
+{
+  constexpr bool IsSmall = std::is_same_v<TestType, SmallType>;
+
+  SECTION("type traits")
+  {
+    STATIC_REQUIRE(_CUDA_VSTD::is_standard_layout_v<cudax::basic_any<iregular<>>>);
+    STATIC_REQUIRE(_CUDA_VSTD::is_standard_layout_v<cudax::basic_any<iregular<>*>>);
+    STATIC_REQUIRE(_CUDA_VSTD::is_standard_layout_v<cudax::basic_any<iregular<>&>>);
+  }
+
+  SECTION("empty interface can hold anything")
+  {
+    STATIC_REQUIRE_FALSE(_CUDA_VSTD::move_constructible<cudax::basic_any<iempty<>>>);
+    cudax::basic_any<iempty<>> a{42};
+    CHECK(a.has_value() == true);
+    CHECK(a.type() == _CCCL_TYPEID(int));
+    CHECK(a.interface() == _CCCL_TYPEID(iempty<>));
+    REQUIRE(cudax::any_cast<int>(&a));
+    CHECK(cudax::any_cast<int>(&a) == cudax::any_cast<void>(&a));
+    CHECK(*cudax::any_cast<int>(&a) == 42);
+
+    a.emplace<immovable>();
+    CHECK(a.has_value() == true);
+    CHECK(a.type() == _CCCL_TYPEID(immovable));
+    CHECK(a.interface() == _CCCL_TYPEID(iempty<>));
+
+    a.reset();
+    CHECK(a.has_value() == false);
+    CHECK(a.type() == _CCCL_TYPEID(void));
+    CHECK(a.interface() == _CCCL_TYPEID(iempty<>));
+  }
+
+  SECTION("interface with one member function")
+  {
+    STATIC_REQUIRE(_CUDA_VSTD::move_constructible<cudax::basic_any<ibase<>>>);
+    STATIC_REQUIRE_FALSE(_CUDA_VSTD::copy_constructible<cudax::basic_any<ibase<>>>);
+
+    cudax::basic_any<ibase<>> a{_CUDA_VSTD::in_place_type<Foo<IsSmall>>, 42, this};
+    CHECK(a.has_value() == true);
+    CHECK(a.type() == _CCCL_TYPEID(Foo<IsSmall>));
+    CHECK(a.interface() == _CCCL_TYPEID(ibase<>));
+    CHECK(a.__in_situ() == IsSmall);
+    CHECK(this->objects == 1);
+    CHECK(a.foo(1) == 43);
+
+    a.emplace<Foo<IsSmall>>(43, this);
+    CHECK(a.foo(2) == 45);
+    CHECK(this->objects == 1);
+
+    a.reset();
+    CHECK(a.has_value() == false);
+    CHECK(a.type() == _CCCL_TYPEID(void));
+    CHECK(a.interface() == _CCCL_TYPEID(ibase<>));
+    CHECK(this->objects == 0);
+  }
+
+  SECTION("single interface extension")
+  {
+    STATIC_REQUIRE(_CUDA_VSTD::move_constructible<cudax::basic_any<iderived<>>>);
+    STATIC_REQUIRE(_CUDA_VSTD::copy_constructible<cudax::basic_any<iderived<>>>);
+
+    cudax::basic_any<iderived<>> a{_CUDA_VSTD::in_place_type<Bar<IsSmall>>, 42, this};
+    CHECK(a.has_value() == true);
+    CHECK(a.type() == _CCCL_TYPEID(Bar<IsSmall>));
+    CHECK(a.interface() == _CCCL_TYPEID(iderived<>));
+    CHECK(a.__in_situ() == IsSmall);
+    CHECK(this->objects == 1);
+    CHECK(a.foo(2) == 44);
+    CHECK(a.bar(2) == 84);
+    CHECK(cudax::any_cast<Bar<IsSmall>>(&a)->j == 42);
+
+    // construct a base any from a derived any:
+    cudax::basic_any<ibase<>> b{_CUDA_VSTD::move(a)};
+    CHECK(b.has_value() == true);
+    CHECK(b.type() == _CCCL_TYPEID(Bar<IsSmall>));
+    CHECK(b.interface() == _CCCL_TYPEID(iderived<>));
+    CHECK(b.__in_situ() == IsSmall);
+    CHECK(this->objects == 1);
+    CHECK(b.foo(1) == 43);
+    CHECK(cudax::any_cast<Bar<IsSmall>>(&b)->j == 42);
+
+    a.emplace<Bar<IsSmall>>(-1, this);
+    CHECK(a.foo(2) == 1);
+    b = std::move(a);
+    CHECK(b.foo(2) == 1);
+    CHECK(cudax::any_cast<Bar<IsSmall>>(&b)->j == -1);
+
+    a.reset();
+    CHECK(this->objects == 1);
+    b.reset();
+    CHECK(this->objects == 0);
+  }
+
+  SECTION("any iempty pointer to model")
+  {
+    STATIC_REQUIRE(_CUDA_VSTD::regular<cudax::basic_any<iempty<>*>>);
+    STATIC_REQUIRE(sizeof(cudax::basic_any<iempty<>*>) == 2 * sizeof(void*));
+
+    CHECK(cudax::basic_any<iempty<>*>{} == nullptr);
+    CHECK(nullptr == cudax::basic_any<iempty<>*>{});
+
+    immovable im;
+    cudax::basic_any<iempty<>*> a = &im;
+    CHECK(a.has_value() == true);
+    CHECK(a.type() == _CCCL_TYPEID(immovable*));
+    CHECK(a.interface() == _CCCL_TYPEID(iempty<>));
+    CHECK(a.__in_situ() == true);
+
+    [[maybe_unused]]
+    immovable** p = cudax::any_cast<immovable*>(&a);
+    CHECK((p && *p == &im));
+
+    int i    = 42;
+    int*& pi = a.emplace<int*>(&i);
+    CHECK(a.has_value() == true);
+    CHECK(a.type() == _CCCL_TYPEID(int*));
+    CHECK(a.interface() == _CCCL_TYPEID(iempty<>));
+    CHECK(a.__in_situ() == true);
+    CHECK(a == a);
+    CHECK(a != nullptr);
+    CHECK(nullptr != a);
+    CHECK(pi == &i);
+
+    int* const* ppi = cudax::any_cast<int*>(&std::as_const(a));
+    CHECK(&pi == ppi);
+
+    cudax::basic_any<iempty<> const*> b = a;
+    CHECK(b);
+    REQUIRE(cudax::any_cast<int const*>(&b));
+    CHECK(&i == *cudax::any_cast<int const*>(&b));
+    CHECK(a == b);
+    CHECK(b == a);
+    b = nullptr;
+    CHECK(a);
+    CHECK(!b);
+    CHECK(a != b);
+    CHECK(b != a);
+
+    int const k                                  = 0;
+    cudax::basic_any<cudax::imovable<> const*> c = &k;
+    STATIC_REQUIRE(!_CUDA_VSTD::constructible_from<cudax::basic_any<cudax::imovable<>>, decltype(*c)>);
+    (void) c;
+  }
+
+  SECTION("any ibase pointer to model")
+  {
+    Foo<IsSmall> foo{42, this};
+    cudax::basic_any<ibase<>*> a = &foo;
+    CHECK(a.has_value() == true);
+    CHECK(a.type() == _CCCL_TYPEID(Foo<IsSmall>*));
+    CHECK(a.interface() == _CCCL_TYPEID(ibase<>));
+    CHECK(a.__in_situ() == true);
+    CHECK(this->objects == 1);
+    CHECK(a->foo(1) == 43);
+
+    Foo<IsSmall> foo2{43, this};
+    a.emplace<Foo<IsSmall>*>(&foo2);
+    CHECK(this->objects == 2);
+    CHECK(a->foo(2) == 45);
+
+    a.reset();
+    CHECK(a.has_value() == false);
+    CHECK(a.type() == _CCCL_TYPEID(void));
+    CHECK(a.interface() == _CCCL_TYPEID(ibase<>));
+    CHECK(this->objects == 2);
+  }
+
+  SECTION("any pointers from derived to base conversions")
+  {
+    STATIC_REQUIRE(_CUDA_VSTD::constructible_from<cudax::basic_any<ibase<>*>, cudax::basic_any<iderived<>*>>);
+    STATIC_REQUIRE(_CUDA_VSTD::constructible_from<cudax::basic_any<ibase<> const*>, cudax::basic_any<iderived<>*>>);
+    STATIC_REQUIRE(_CUDA_VSTD::constructible_from<cudax::basic_any<iderived<> const*>, cudax::basic_any<iderived<>*>>);
+
+    STATIC_REQUIRE(!_CUDA_VSTD::constructible_from<cudax::basic_any<iderived<>*>, cudax::basic_any<ibase<>*>>);
+    STATIC_REQUIRE(!_CUDA_VSTD::constructible_from<cudax::basic_any<iderived<>*>, cudax::basic_any<ibase<> const*>>);
+    STATIC_REQUIRE(!_CUDA_VSTD::constructible_from<cudax::basic_any<iderived<>*>, cudax::basic_any<iderived<> const*>>);
+    STATIC_REQUIRE(!_CUDA_VSTD::constructible_from<cudax::basic_any<iderived<>*>, cudax::basic_any<iderived<>*>*>);
+
+    STATIC_REQUIRE(!_CUDA_VSTD::convertible_to<cudax::basic_any<ibase<>*>, cudax::basic_any<iderived<>*>>);
+    STATIC_REQUIRE(!_CUDA_VSTD::convertible_to<cudax::basic_any<ibase<> const*>, cudax::basic_any<iderived<>*>>);
+    STATIC_REQUIRE(!_CUDA_VSTD::convertible_to<cudax::basic_any<iderived<> const*>, cudax::basic_any<iderived<>*>>);
+
+    STATIC_REQUIRE(_CUDA_VSTD::convertible_to<cudax::basic_any<iderived<>*>, cudax::basic_any<ibase<>*>>);
+    STATIC_REQUIRE(_CUDA_VSTD::convertible_to<cudax::basic_any<iderived<>*>, cudax::basic_any<ibase<> const*>>);
+    STATIC_REQUIRE(_CUDA_VSTD::convertible_to<cudax::basic_any<iderived<>*>, cudax::basic_any<iderived<> const*>>);
+    STATIC_REQUIRE(!_CUDA_VSTD::constructible_from<cudax::basic_any<iderived<>*>*, cudax::basic_any<iderived<>*>>);
+
+    Bar<IsSmall> bar{42, this};
+    cudax::basic_any<iderived<>*> a{&bar};
+    CHECK(a.has_value() == true);
+    CHECK(a.type() == _CCCL_TYPEID(Bar<IsSmall>*));
+    CHECK(a.interface() == _CCCL_TYPEID(iderived<>));
+    CHECK(a.__in_situ() == true);
+    CHECK(this->objects == 1);
+    CHECK(a->foo(2) == 44);
+    CHECK(a->bar(2) == 84);
+    REQUIRE(cudax::any_cast<Bar<IsSmall>*>(&a));
+    CHECK((*cudax::any_cast<Bar<IsSmall>*>(&a))->j == 42);
+
+    // construct a base any from a derived any:
+    cudax::basic_any<ibase<>*> b{a};
+    CHECK(b.has_value() == true);
+    CHECK(b.type() == _CCCL_TYPEID(Bar<IsSmall>*));
+    CHECK(b.interface() == _CCCL_TYPEID(iderived<>));
+    CHECK(b.__in_situ() == true);
+    CHECK(this->objects == 1);
+    CHECK(b->foo(1) == 43);
+    REQUIRE(cudax::any_cast<Bar<IsSmall>*>(&b));
+    CHECK((*cudax::any_cast<Bar<IsSmall>*>(&b))->j == 42);
+
+    Bar<IsSmall> bar2{-1, this};
+    a.emplace<Bar<IsSmall>*>(&bar2);
+    CHECK(a->foo(2) == 1);
+    b = std::move(a);
+    CHECK(b->foo(2) == 1);
+    REQUIRE(cudax::any_cast<Bar<IsSmall>*>(&b));
+    CHECK((*cudax::any_cast<Bar<IsSmall>*>(&b))->j == -1);
+
+    a.reset();
+    CHECK(this->objects == 2);
+    b.reset();
+    CHECK(this->objects == 2);
+  }
+
+  SECTION("any value/pointer interop")
+  {
+    cudax::basic_any<iderived<>> a{_CUDA_VSTD::in_place_type<Bar<IsSmall>>, 42, this};
+    CHECK(a.__in_situ() == IsSmall);
+    CHECK(this->objects == 1);
+
+    cudax::basic_any<iderived<>*> pa1 = &a;
+    CHECK(pa1);
+    CHECK(pa1 == &a);
+    CHECK(&a == pa1);
+    CHECK_FALSE(pa1 != &a);
+    CHECK_FALSE(&a != pa1);
+    CHECK(pa1->bar(2) == 84);
+
+    Bar<IsSmall> bar{-1, this};
+    cudax::basic_any<ibase<> const*> pb2 = &bar;
+    CHECK(pb2 == &bar);
+    CHECK(&bar == pb2);
+    CHECK_FALSE(pb2 != &bar);
+    CHECK_FALSE(&bar != pb2);
+    CHECK(this->objects == 2);
+
+    cudax::basic_any<iderived<> const*> pb3 = &bar;
+    a                                       = *pb3;
+    CHECK(a.has_value() == true);
+    CHECK(a.type() == _CCCL_TYPEID(Bar<IsSmall>));
+    CHECK(a.interface() == _CCCL_TYPEID(iderived<>));
+    CHECK(a.__in_situ() == IsSmall);
+    CHECK(this->objects == 2);
+    CHECK(a.foo(2) == 1);
+
+    bar.j = -2;
+    a     = *pb3;
+    CHECK(a.foo(2) == 0);
+    CHECK(bar.j == -2);
+
+    bar.j = 10;
+    a     = std::move(*pb3);
+    CHECK(a.foo(2) == 12);
+    CHECK(bar.j == 10);
+
+    cudax::basic_any<iderived<>*> pb4 = &bar;
+    bar.j                             = 20;
+    a                                 = std::move(*pb4);
+    CHECK(a.foo(2) == 22);
+    CHECK(bar.j == INT_MAX); // bar is moved from
+  }
+
+  SECTION("cudax::basic_any references")
+  {
+    Bar<IsSmall> bar{42, this};
+    cudax::basic_any<iderived<>&> a{bar};
+    CHECK(a.has_value() == true);
+    CHECK(a.type() == _CCCL_TYPEID(Bar<IsSmall>));
+    CHECK(a.interface() == _CCCL_TYPEID(iderived<>));
+    CHECK(a.__in_situ() == true);
+    CHECK(cudax::any_cast<Bar<IsSmall>>(&a) == &bar);
+    CHECK(this->objects == 1);
+
+    cudax::basic_any<ibase<>&> b = a;
+    CHECK(b.has_value() == true);
+    CHECK(b.type() == _CCCL_TYPEID(Bar<IsSmall>));
+    CHECK(b.interface() == _CCCL_TYPEID(iderived<>));
+    CHECK(b.__in_situ() == true);
+    CHECK(this->objects == 1);
+
+    cudax::basic_any<iderived<>*> pa = &a;
+    CHECK(pa == &bar);
+
+    cudax::basic_any<iderived<>> c = a; // should copy the referenced object
+    CHECK(c.has_value() == true);
+    CHECK(c.type() == _CCCL_TYPEID(Bar<IsSmall>));
+    CHECK(c.interface() == _CCCL_TYPEID(iderived<>));
+    CHECK(c.__in_situ() == IsSmall);
+    CHECK(this->objects == 2);
+    REQUIRE(cudax::any_cast<Bar<IsSmall>>(&c));
+    CHECK(cudax::any_cast<Bar<IsSmall>>(&c) != &bar);
+    CHECK(cudax::any_cast<Bar<IsSmall>>(&c)->j == 42);
+
+    bar.j = -1;
+    c     = a; // should copy the referenced object
+    CHECK(this->objects == 2);
+    CHECK(cudax::any_cast<Bar<IsSmall>>(&c)->j == -1);
+    CHECK(a.bar(2) == -2);
+
+    STATIC_REQUIRE(
+      _CUDA_VSTD::constructible_from<cudax::basic_any<cudax::imovable<>>, cudax::basic_any<cudax::imovable<>>>);
+    STATIC_REQUIRE(
+      !_CUDA_VSTD::constructible_from<cudax::basic_any<cudax::imovable<>>, cudax::basic_any<cudax::imovable<>&>>);
+    STATIC_REQUIRE(
+      !_CUDA_VSTD::constructible_from<cudax::basic_any<cudax::imovable<>>, cudax::basic_any<cudax::imovable<> const&>>);
+
+    STATIC_REQUIRE(
+      !_CUDA_VSTD::constructible_from<cudax::basic_any<cudax::imovable<>>, cudax::basic_any<cudax::imovable<>*>>);
+
+    STATIC_REQUIRE(
+      !_CUDA_VSTD::constructible_from<cudax::basic_any<cudax::imovable<> const&>, cudax::basic_any<cudax::imovable<>>>);
+    STATIC_REQUIRE(
+      _CUDA_VSTD::constructible_from<cudax::basic_any<cudax::imovable<> const&>, cudax::basic_any<cudax::imovable<>>&>);
+  }
+
+  SECTION("cudax::dynamic_any_cast")
+  {
+    using cast_to_derived = decltype(cudax::dynamic_any_cast<iderived<>>);
+
+    STATIC_REQUIRE_FALSE(std::is_invocable_v<cast_to_derived, cudax::basic_any<ibase<>>&>);
+    STATIC_REQUIRE_FALSE(std::is_invocable_v<cast_to_derived, cudax::basic_any<ibase<>&>>);
+    STATIC_REQUIRE(std::is_invocable_v<cast_to_derived, cudax::basic_any<cudax::__ireference<ibase<>>>>);
+    STATIC_REQUIRE_FALSE(std::is_invocable_v<cast_to_derived, cudax::basic_any<cudax::__ireference<ibase<>>>&>);
+
+    // dynamic cast to a value
+    cudax::basic_any<iderived<>> a{_CUDA_VSTD::in_place_type<Bar<IsSmall>>, 42, this};
+    cudax::basic_any<ibase<>> b = a;
+    auto c                      = cudax::dynamic_any_cast<iderived<>>(std::move(b));
+    CHECK(c.has_value());
+    CHECK(a.bar(2) == c.bar(2));
+    CHECK(cudax::any_cast<Bar<IsSmall>>(&a) != cudax::any_cast<Bar<IsSmall>>(&c));
+
+    cudax::basic_any<ibase<>*> pa = &a;
+    auto d                        = cudax::dynamic_any_cast<iderived<>>(std::move(*pa));
+    CHECK(d.has_value());
+    CHECK(cudax::any_cast<Bar<IsSmall>>(&a)->j == INT_MAX); // moved from
+    CHECK(cudax::any_cast<Bar<IsSmall>>(&d)->j == 42);
+
+    // basic_anyer
+    cudax::basic_any<ibase<>*> pb = &d;
+    auto pd                       = cudax::dynamic_any_cast<iderived<>*>(pb);
+    CHECK(pd != nullptr);
+    CHECK(cudax::any_cast<Bar<IsSmall>>(&*pd)->j == 42);
+  }
+
+  SECTION("equality_comparable")
+  {
+    cudax::basic_any<iregular<>> a{42};
+    cudax::basic_any<iregular<>> b{42};
+    cudax::basic_any<iregular<>> c{43};
+    cudax::basic_any<iregular<>> d{_CUDA_VSTD::in_place_type<Regular>, 42};
+
+    CHECK(a == a);
+    CHECK(a == b);
+    CHECK_FALSE(a == c);
+    CHECK_FALSE(a == d);
+    CHECK_FALSE(a != a);
+    CHECK_FALSE(a != b);
+    CHECK(a != c);
+    CHECK(a != d);
+
+    cudax::basic_any<iregular<> const&> e = a;
+    CHECK(e == e);
+    CHECK(e == a);
+    CHECK(e == b);
+    CHECK_FALSE(e == c);
+    CHECK_FALSE(e == d);
+    CHECK_FALSE(e != e);
+    CHECK_FALSE(e != b);
+    CHECK(e != c);
+    CHECK(e != d);
+  }
+}
+
+#endif // __CUDA_ARCH__
diff --git a/docs/libcudacxx/extended_api/memory_resource.rst b/docs/libcudacxx/extended_api/memory_resource.rst
index 5a8118f69a3..c06cc3c118a 100644
--- a/docs/libcudacxx/extended_api/memory_resource.rst
+++ b/docs/libcudacxx/extended_api/memory_resource.rst
@@ -36,7 +36,7 @@ At a high level, the header provides:
      - Concepts that provide proper constraints for arbitrary memory resources.
      - CCCL 2.2.0 / CUDA 12.3
    * - :ref:`cuda::mr::{async}_resource_ref <libcudacxx-extended-api-memory-resources-resource-ref>`
-     - A type-erased memory resource wrapper that enables consumers to specify properties of resources that they expect.
+     - A non-owning type-erased memory resource wrapper that enables consumers to specify properties of resources that they expect.
      - CCCL 2.2.0 / CUDA 12.3
 
 These features are an evolution of `std::pmr::memory_resource <https://en.cppreference.com/w/cpp/header/memory_resource>`__
diff --git a/libcudacxx/include/cuda/__memory_resource/resource_ref.h b/libcudacxx/include/cuda/__memory_resource/resource_ref.h
index 81831720349..7ee6a9e2a27 100644
--- a/libcudacxx/include/cuda/__memory_resource/resource_ref.h
+++ b/libcudacxx/include/cuda/__memory_resource/resource_ref.h
@@ -147,7 +147,7 @@ struct _Resource_vtable_builder
   using __wrapper_type = _CUDA_VSTD::integral_constant<_WrapperType, _Wrapper_type>;
 
   template <class _Resource, class _Property>
-  static __property_value_t<_Property> _Get_property(void* __res) noexcept
+  static __property_value_t<_Property> _Get_property(const void* __res) noexcept
   {
     return get_property(*static_cast<const _Resource*>(__res), _Property{});
   }
@@ -292,7 +292,7 @@ struct _Resource_vtable_builder
 };
 
 template <class _Property>
-using __property_fn_t = __property_value_t<_Property> (*)(void*);
+using __property_fn_t = __property_value_t<_Property> (*)(const void*);
 
 template <class _Property>
 struct _Property_vtable
@@ -374,8 +374,11 @@ using _Filtered_vtable = typename _Filtered<_Properties...>::_Filtered_vtable::_
 template <_WrapperType _Wrapper_type>
 using __alloc_object_storage_t = _CUDA_VSTD::_If<_Wrapper_type == _WrapperType::_Reference, void*, _AnyResourceStorage>;
 
+struct _Resource_ref_base
+{};
+
 template <class _Vtable, _WrapperType _Wrapper_type>
-struct _Alloc_base
+struct _LIBCUDACXX_DECLSPEC_EMPTY_BASES _Alloc_base : _Resource_ref_base
 {
   static_assert(_CUDA_VSTD::is_base_of_v<_Alloc_vtable, _Vtable>, "");
 
@@ -445,19 +448,8 @@ struct _Async_alloc_base : public _Alloc_base<_Vtable, _Wrapper_type>
   }
 };
 
-template <class _VTable, _WrapperType _Wrapper_type>
-constexpr bool _Is_resource_base_fn(const _Alloc_base<_VTable, _Wrapper_type>*) noexcept
-{
-  return true;
-}
-
-constexpr bool _Is_resource_base_fn(...) noexcept
-{
-  return false;
-}
-
 template <class _Resource>
-_CCCL_CONCEPT _Is_resource_base = _Is_resource_base_fn(static_cast<_Resource*>(nullptr));
+_CCCL_CONCEPT _Is_resource_ref = _CUDA_VSTD::convertible_to<_Resource&, _Resource_ref_base>;
 
 template <_AllocType _Alloc_type, _WrapperType _Wrapper_type>
 using _Resource_base =
@@ -522,7 +514,7 @@ class basic_resource_ref
   //! as well as all properties
   //! @param __res The resource to be wrapped within the \c basic_resource_ref
   _CCCL_TEMPLATE(class _Resource, _AllocType _Alloc_type2 = _Alloc_type)
-  _CCCL_REQUIRES((!_Is_resource_base<_Resource>) _CCCL_AND(_Alloc_type2 == _AllocType::_Default)
+  _CCCL_REQUIRES((!_Is_resource_ref<_Resource>) _CCCL_AND(_Alloc_type2 == _AllocType::_Default)
                    _CCCL_AND resource_with<_Resource, _Properties...>)
   basic_resource_ref(_Resource& __res) noexcept
       : _Resource_base<_Alloc_type, _WrapperType::_Reference>(
@@ -534,7 +526,7 @@ class basic_resource_ref
   //! properties. This ignores the async interface of the passed in resource
   //! @param __res The resource to be wrapped within the \c resource_ref
   _CCCL_TEMPLATE(class _Resource, _AllocType _Alloc_type2 = _Alloc_type)
-  _CCCL_REQUIRES((!_Is_resource_base<_Resource>) _CCCL_AND(_Alloc_type2 == _AllocType::_Async)
+  _CCCL_REQUIRES((!_Is_resource_ref<_Resource>) _CCCL_AND(_Alloc_type2 == _AllocType::_Async)
                    _CCCL_AND async_resource_with<_Resource, _Properties...>)
   basic_resource_ref(_Resource& __res) noexcept
       : _Resource_base<_Alloc_type, _WrapperType::_Reference>(
@@ -546,7 +538,7 @@ class basic_resource_ref
   //! as well as all properties
   //! @param __res Pointer to a resource to be wrapped within the \c basic_resource_ref
   _CCCL_TEMPLATE(class _Resource, _AllocType _Alloc_type2 = _Alloc_type)
-  _CCCL_REQUIRES((!_Is_resource_base<_Resource>) _CCCL_AND(_Alloc_type2 == _AllocType::_Default)
+  _CCCL_REQUIRES((!_Is_resource_ref<_Resource>) _CCCL_AND(_Alloc_type2 == _AllocType::_Default)
                    _CCCL_AND resource_with<_Resource, _Properties...>)
   basic_resource_ref(_Resource* __res) noexcept
       : _Resource_base<_Alloc_type, _WrapperType::_Reference>(
@@ -558,7 +550,7 @@ class basic_resource_ref
   //! properties. This ignores the async interface of the passed in resource
   //! @param __res Pointer to a resource to be wrapped within the \c resource_ref
   _CCCL_TEMPLATE(class _Resource, _AllocType _Alloc_type2 = _Alloc_type)
-  _CCCL_REQUIRES((!_Is_resource_base<_Resource>) _CCCL_AND(_Alloc_type2 == _AllocType::_Async)
+  _CCCL_REQUIRES((!_Is_resource_ref<_Resource>) _CCCL_AND(_Alloc_type2 == _AllocType::_Async)
                    _CCCL_AND async_resource_with<_Resource, _Properties...>)
   basic_resource_ref(_Resource* __res) noexcept
       : _Resource_base<_Alloc_type, _WrapperType::_Reference>(