Geometry Nodes: refactor virtual array system

Goals of this refactor:
* Simplify creating virtual arrays.
* Simplify passing virtual arrays around.
* Simplify converting between typed and generic virtual arrays.
* Reduce memory allocations.

As a quick reminder, a virtual arrays is a data structure that behaves like an
array (i.e. it can be accessed using an index). However, it may not actually
be stored as array internally. The two most important implementations
of virtual arrays are those that correspond to an actual plain array and those
that have the same value for every index. However, many more
implementations exist for various reasons (interfacing with legacy attributes,
unified iterator over all points in multiple splines, ...).

With this refactor the core types (`VArray`, `GVArray`, `VMutableArray` and
`GVMutableArray`) can be used like "normal values". They typically live
on the stack. Before, they were usually inside a `std::unique_ptr`. This makes
passing them around much easier. Creation of new virtual arrays is also
much simpler now due to some constructors. Memory allocations are
reduced by making use of small object optimization inside the core types.

Previously, `VArray` was a class with virtual methods that had to be overridden
to change the behavior of a the virtual array. Now,`VArray` has a fixed size
and has no virtual methods. Instead it contains a `VArrayImpl` that is
similar to the old `VArray`. `VArrayImpl` should rarely ever be used directly,
unless a new virtual array implementation is added.

To support the small object optimization for many `VArrayImpl` classes,
a new `blender::Any` type is added. It is similar to `std::any` with two
additional features. It has an adjustable inline buffer size and alignment.
The inline buffer size of `std::any` can't be relied on and is usually too
small for our use case here. Furthermore, `blender::Any` can store
additional user-defined type information without increasing the
stack size.

Differential Revision: https://developer.blender.org/D12986

16 files changed, 409 insertions, 448 deletions

diff --git a/source/blender/blenkernel/BKE_attribute_access.hh b/source/blender/blenkernel/BKE_attribute_access.hh
index 6a87375e5e2..47f62b52a0f 100644
--- a/source/blender/blenkernel/BKE_attribute_access.hh
+++ b/source/blender/blenkernel/BKE_attribute_access.hh
@@ -115,10 +115,10 @@ struct AttributeInitDefault : public AttributeInit {
  * Note that this can be used to fill the new attribute with the default
  */
 struct AttributeInitVArray : public AttributeInit {
-  const blender::fn::GVArray *varray;
+  blender::fn::GVArray varray;
 
-  AttributeInitVArray(const blender::fn::GVArray *varray)
-      : AttributeInit(Type::VArray), varray(varray)
+  AttributeInitVArray(blender::fn::GVArray varray)
+      : AttributeInit(Type::VArray), varray(std::move(varray))
   {
   }
 };
@@ -150,9 +150,7 @@ namespace blender::bke {
 
 using fn::CPPType;
 using fn::GVArray;
-using fn::GVArrayPtr;
 using fn::GVMutableArray;
-using fn::GVMutableArrayPtr;
 
 const CPPType *custom_data_type_to_cpp_type(const CustomDataType type);
 CustomDataType cpp_type_to_custom_data_type(const CPPType &type);
@@ -164,14 +162,14 @@ AttributeDomain attribute_domain_highest_priority(Span<AttributeDomain> domains)
  */
 struct ReadAttributeLookup {
   /* The virtual array that is used to read from this attribute. */
-  GVArrayPtr varray;
+  GVArray varray;
   /* Domain the attribute lives on in the geometry. */
   AttributeDomain domain;
 
   /* Convenience function to check if the attribute has been found. */
   operator bool() const
   {
-    return this->varray.get() != nullptr;
+    return this->varray;
   }
 };
 
@@ -180,7 +178,7 @@ struct ReadAttributeLookup {
  */
 struct WriteAttributeLookup {
   /* The virtual array that is used to read from and write to the attribute. */
-  GVMutableArrayPtr varray;
+  GVMutableArray varray;
   /* Domain the attributes lives on in the geometry. */
   AttributeDomain domain;
   /* Call this after changing the attribute to invalidate caches that depend on this attribute. */
@@ -189,7 +187,7 @@ struct WriteAttributeLookup {
   /* Convenience function to check if the attribute has been found. */
   operator bool() const
   {
-    return this->varray.get() != nullptr;
+    return this->varray;
   }
 };
 
@@ -209,7 +207,7 @@ class OutputAttribute {
   using SaveFn = std::function<void(OutputAttribute &)>;
 
  private:
-  GVMutableArrayPtr varray_;
+  GVMutableArray varray_;
   AttributeDomain domain_ = ATTR_DOMAIN_AUTO;
   SaveFn save_;
   std::unique_ptr<fn::GVMutableArray_GSpan> optional_span_varray_;
@@ -219,7 +217,7 @@ class OutputAttribute {
  public:
   OutputAttribute();
   OutputAttribute(OutputAttribute &&other);
-  OutputAttribute(GVMutableArrayPtr varray,
+  OutputAttribute(GVMutableArray varray,
                   AttributeDomain domain,
                   SaveFn save,
                   const bool ignore_old_values);
@@ -229,7 +227,7 @@ class OutputAttribute {
   operator bool() const;
 
   GVMutableArray &operator*();
-  GVMutableArray *operator->();
+  fn::GVMutableArray *operator->();
   GVMutableArray &varray();
   AttributeDomain domain() const;
   const CPPType &cpp_type() const;
@@ -247,16 +245,14 @@ class OutputAttribute {
 template<typename T> class OutputAttribute_Typed {
  private:
   OutputAttribute attribute_;
-  std::unique_ptr<fn::GVMutableArray_Typed<T>> optional_varray_;
-  VMutableArray<T> *varray_ = nullptr;
+  VMutableArray<T> varray_;
 
  public:
   OutputAttribute_Typed();
   OutputAttribute_Typed(OutputAttribute attribute) : attribute_(std::move(attribute))
   {
     if (attribute_) {
-      optional_varray_ = std::make_unique<fn::GVMutableArray_Typed<T>>(attribute_.varray());
-      varray_ = &**optional_varray_;
+      varray_ = attribute_.varray().template typed<T>();
     }
   }
 
@@ -275,22 +271,22 @@ template<typename T> class OutputAttribute_Typed {
 
   operator bool() const
   {
-    return varray_ != nullptr;
+    return varray_;
   }
 
   VMutableArray<T> &operator*()
   {
-    return *varray_;
+    return varray_;
   }
 
   VMutableArray<T> *operator->()
   {
-    return varray_;
+    return &varray_;
   }
 
   VMutableArray<T> &varray()
   {
-    return *varray_;
+    return varray_;
   }
 
   AttributeDomain domain() const
@@ -351,18 +347,17 @@ class CustomDataAttributes {
 
   std::optional<blender::fn::GSpan> get_for_read(const AttributeIDRef &attribute_id) const;
 
-  blender::fn::GVArrayPtr get_for_read(const AttributeIDRef &attribute_id,
-                                       const CustomDataType data_type,
-                                       const void *default_value) const;
+  blender::fn::GVArray get_for_read(const AttributeIDRef &attribute_id,
+                                    const CustomDataType data_type,
+                                    const void *default_value) const;
 
   template<typename T>
-  blender::fn::GVArray_Typed<T> get_for_read(const AttributeIDRef &attribute_id,
-                                             const T &default_value) const
+  blender::VArray<T> get_for_read(const AttributeIDRef &attribute_id, const T &default_value) const
   {
     const blender::fn::CPPType &cpp_type = blender::fn::CPPType::get<T>();
     const CustomDataType type = blender::bke::cpp_type_to_custom_data_type(cpp_type);
-    GVArrayPtr varray = this->get_for_read(attribute_id, type, &default_value);
-    return blender::fn::GVArray_Typed<T>(std::move(varray));
+    GVArray varray = this->get_for_read(attribute_id, type, &default_value);
+    return varray.typed<T>();
   }
 
   std::optional<blender::fn::GMutableSpan> get_for_write(const AttributeIDRef &attribute_id);
@@ -465,7 +460,7 @@ inline bool AttributeIDRef::should_be_kept() const
 inline OutputAttribute::OutputAttribute() = default;
 inline OutputAttribute::OutputAttribute(OutputAttribute &&other) = default;
 
-inline OutputAttribute::OutputAttribute(GVMutableArrayPtr varray,
+inline OutputAttribute::OutputAttribute(GVMutableArray varray,
                                         AttributeDomain domain,
                                         SaveFn save,
                                         const bool ignore_old_values)
@@ -478,22 +473,22 @@ inline OutputAttribute::OutputAttribute(GVMutableArrayPtr varray,
 
 inline OutputAttribute::operator bool() const
 {
-  return varray_.get() != nullptr;
+  return varray_;
 }
 
 inline GVMutableArray &OutputAttribute::operator*()
 {
-  return *varray_;
+  return varray_;
 }
 
-inline GVMutableArray *OutputAttribute::operator->()
+inline fn::GVMutableArray *OutputAttribute::operator->()
 {
-  return varray_.get();
+  return &varray_;
 }
 
 inline GVMutableArray &OutputAttribute::varray()
 {
-  return *varray_;
+  return varray_;
 }
 
 inline AttributeDomain OutputAttribute::domain() const
@@ -503,7 +498,7 @@ inline AttributeDomain OutputAttribute::domain() const
 
 inline const CPPType &OutputAttribute::cpp_type() const
 {
-  return varray_->type();
+  return varray_.type();
 }
 
 inline CustomDataType OutputAttribute::custom_data_type() const
diff --git a/source/blender/blenkernel/BKE_geometry_set.hh b/source/blender/blenkernel/BKE_geometry_set.hh
index 58a89d0207a..63ada807c55 100644
--- a/source/blender/blenkernel/BKE_geometry_set.hh
+++ b/source/blender/blenkernel/BKE_geometry_set.hh
@@ -119,10 +119,21 @@ class GeometryComponent {
   /* Get a read-only attribute for the domain based on the given attribute. This can be used to
    * interpolate from one domain to another.
    * Returns null if the interpolation is not implemented. */
-  virtual std::unique_ptr<blender::fn::GVArray> attribute_try_adapt_domain(
-      std::unique_ptr<blender::fn::GVArray> varray,
-      const AttributeDomain from_domain,
-      const AttributeDomain to_domain) const;
+  blender::fn::GVArray attribute_try_adapt_domain(const blender::fn::GVArray &varray,
+                                                  const AttributeDomain from_domain,
+                                                  const AttributeDomain to_domain) const
+  {
+    return this->attribute_try_adapt_domain_impl(varray, from_domain, to_domain);
+  }
+
+  template<typename T>
+  blender::VArray<T> attribute_try_adapt_domain(const blender::VArray<T> &varray,
+                                                const AttributeDomain from_domain,
+                                                const AttributeDomain to_domain) const
+  {
+    return this->attribute_try_adapt_domain_impl(varray, from_domain, to_domain)
+        .template typed<T>();
+  }
 
   /* Returns true when the attribute has been deleted. */
   bool attribute_try_delete(const blender::bke::AttributeIDRef &attribute_id);
@@ -146,16 +157,15 @@ class GeometryComponent {
   /* Get a virtual array to read the data of an attribute on the given domain and data type.
    * Returns null when the attribute does not exist or cannot be converted to the requested domain
    * and data type. */
-  std::unique_ptr<blender::fn::GVArray> attribute_try_get_for_read(
-      const blender::bke::AttributeIDRef &attribute_id,
-      const AttributeDomain domain,
-      const CustomDataType data_type) const;
+  blender::fn::GVArray attribute_try_get_for_read(const blender::bke::AttributeIDRef &attribute_id,
+                                                  const AttributeDomain domain,
+                                                  const CustomDataType data_type) const;
 
   /* Get a virtual array to read the data of an attribute on the given domain. The data type is
    * left unchanged. Returns null when the attribute does not exist or cannot be adapted to the
    * requested domain. */
-  std::unique_ptr<blender::fn::GVArray> attribute_try_get_for_read(
-      const blender::bke::AttributeIDRef &attribute_id, const AttributeDomain domain) const;
+  blender::fn::GVArray attribute_try_get_for_read(const blender::bke::AttributeIDRef &attribute_id,
+                                                  const AttributeDomain domain) const;
 
   /* Get a virtual array to read data of an attribute with the given data type. The domain is
    * left unchanged. Returns null when the attribute does not exist or cannot be converted to the
@@ -165,25 +175,22 @@ class GeometryComponent {
 
   /* Get a virtual array to read the data of an attribute. If that is not possible, the returned
    * virtual array will contain a default value. This never returns null. */
-  std::unique_ptr<blender::fn::GVArray> attribute_get_for_read(
-      const blender::bke::AttributeIDRef &attribute_id,
-      const AttributeDomain domain,
-      const CustomDataType data_type,
-      const void *default_value = nullptr) const;
+  blender::fn::GVArray attribute_get_for_read(const blender::bke::AttributeIDRef &attribute_id,
+                                              const AttributeDomain domain,
+                                              const CustomDataType data_type,
+                                              const void *default_value = nullptr) const;
 
   /* Should be used instead of the method above when the requested data type is known at compile
    * time for better type safety. */
   template<typename T>
-  blender::fn::GVArray_Typed<T> attribute_get_for_read(
-      const blender::bke::AttributeIDRef &attribute_id,
-      const AttributeDomain domain,
-      const T &default_value) const
+  blender::VArray<T> attribute_get_for_read(const blender::bke::AttributeIDRef &attribute_id,
+                                            const AttributeDomain domain,
+                                            const T &default_value) const
   {
     const blender::fn::CPPType &cpp_type = blender::fn::CPPType::get<T>();
     const CustomDataType type = blender::bke::cpp_type_to_custom_data_type(cpp_type);
-    std::unique_ptr varray = this->attribute_get_for_read(
-        attribute_id, domain, type, &default_value);
-    return blender::fn::GVArray_Typed<T>(std::move(varray));
+    return this->attribute_get_for_read(attribute_id, domain, type, &default_value)
+        .template typed<T>();
   }
 
   /**
@@ -234,6 +241,11 @@ class GeometryComponent {
 
  private:
   virtual const blender::bke::ComponentAttributeProviders *get_attribute_providers() const;
+
+  virtual blender::fn::GVArray attribute_try_adapt_domain_impl(
+      const blender::fn::GVArray &varray,
+      const AttributeDomain from_domain,
+      const AttributeDomain to_domain) const;
 };
 
 template<typename T>
@@ -391,10 +403,6 @@ class MeshComponent : public GeometryComponent {
   Mesh *get_for_write();
 
   int attribute_domain_size(const AttributeDomain domain) const final;
-  std::unique_ptr<blender::fn::GVArray> attribute_try_adapt_domain(
-      std::unique_ptr<blender::fn::GVArray> varray,
-      const AttributeDomain from_domain,
-      const AttributeDomain to_domain) const final;
 
   bool is_empty() const final;
 
@@ -405,6 +413,11 @@ class MeshComponent : public GeometryComponent {
 
  private:
   const blender::bke::ComponentAttributeProviders *get_attribute_providers() const final;
+
+  blender::fn::GVArray attribute_try_adapt_domain_impl(
+      const blender::fn::GVArray &varray,
+      const AttributeDomain from_domain,
+      const AttributeDomain to_domain) const final;
 };
 
 /** A geometry component that stores a point cloud. */
@@ -469,10 +482,6 @@ class CurveComponent : public GeometryComponent {
   CurveEval *get_for_write();
 
   int attribute_domain_size(const AttributeDomain domain) const final;
-  std::unique_ptr<blender::fn::GVArray> attribute_try_adapt_domain(
-      std::unique_ptr<blender::fn::GVArray> varray,
-      const AttributeDomain from_domain,
-      const AttributeDomain to_domain) const final;
 
   bool is_empty() const final;
 
@@ -485,6 +494,11 @@ class CurveComponent : public GeometryComponent {
 
  private:
   const blender::bke::ComponentAttributeProviders *get_attribute_providers() const final;
+
+  blender::fn::GVArray attribute_try_adapt_domain_impl(
+      const blender::fn::GVArray &varray,
+      const AttributeDomain from_domain,
+      const AttributeDomain to_domain) const final;
 };
 
 class InstanceReference {
@@ -759,9 +773,9 @@ class AttributeFieldInput : public fn::FieldInput {
     return name_;
   }
 
-  const GVArray *get_varray_for_context(const fn::FieldContext &context,
-                                        IndexMask mask,
-                                        ResourceScope &scope) const override;
+  GVArray get_varray_for_context(const fn::FieldContext &context,
+                                 IndexMask mask,
+                                 ResourceScope &scope) const override;
 
   std::string socket_inspection_name() const override;
 
@@ -776,9 +790,9 @@ class IDAttributeFieldInput : public fn::FieldInput {
     category_ = Category::Generated;
   }
 
-  const GVArray *get_varray_for_context(const fn::FieldContext &context,
-                                        IndexMask mask,
-                                        ResourceScope &scope) const override;
+  GVArray get_varray_for_context(const fn::FieldContext &context,
+                                 IndexMask mask,
+                                 ResourceScope &scope) const override;
 
   std::string socket_inspection_name() const override;
 
@@ -815,9 +829,9 @@ class AnonymousAttributeFieldInput : public fn::FieldInput {
     return fn::Field<T>{field_input};
   }
 
-  const GVArray *get_varray_for_context(const fn::FieldContext &context,
-                                        IndexMask mask,
-                                        ResourceScope &scope) const override;
+  GVArray get_varray_for_context(const fn::FieldContext &context,
+                                 IndexMask mask,
+                                 ResourceScope &scope) const override;
 
   std::string socket_inspection_name() const override;
 
diff --git a/source/blender/blenkernel/BKE_spline.hh b/source/blender/blenkernel/BKE_spline.hh
index 1d34768b1a2..c332e9a8dac 100644
--- a/source/blender/blenkernel/BKE_spline.hh
+++ b/source/blender/blenkernel/BKE_spline.hh
@@ -187,14 +187,14 @@ class Spline {
                                  blender::MutableSpan<T> dst) const
   {
     this->sample_with_index_factors(
-        blender::fn::GVArray_For_VArray(src), index_factors, blender::fn::GMutableSpan(dst));
+        blender::fn::GVArray(src), index_factors, blender::fn::GMutableSpan(dst));
   }
   template<typename T>
   void sample_with_index_factors(blender::Span<T> src,
                                  blender::Span<float> index_factors,
                                  blender::MutableSpan<T> dst) const
   {
-    this->sample_with_index_factors(blender::VArray_For_Span(src), index_factors, dst);
+    this->sample_with_index_factors(blender::VArray<T>::ForSpan(src), index_factors, dst);
   }
 
   /**
@@ -202,13 +202,11 @@ class Spline {
    * evaluated points. For poly splines, the lifetime of the returned virtual array must not
    * exceed the lifetime of the input data.
    */
-  virtual blender::fn::GVArrayPtr interpolate_to_evaluated(
-      const blender::fn::GVArray &src) const = 0;
-  blender::fn::GVArrayPtr interpolate_to_evaluated(blender::fn::GSpan data) const;
-  template<typename T>
-  blender::fn::GVArray_Typed<T> interpolate_to_evaluated(blender::Span<T> data) const
+  virtual blender::fn::GVArray interpolate_to_evaluated(const blender::fn::GVArray &src) const = 0;
+  blender::fn::GVArray interpolate_to_evaluated(blender::fn::GSpan data) const;
+  template<typename T> blender::VArray<T> interpolate_to_evaluated(blender::Span<T> data) const
   {
-    return blender::fn::GVArray_Typed<T>(this->interpolate_to_evaluated(blender::fn::GSpan(data)));
+    return this->interpolate_to_evaluated(blender::fn::GSpan(data)).typed<T>();
   }
 
  protected:
@@ -350,7 +348,7 @@ class BezierSpline final : public Spline {
   };
   InterpolationData interpolation_data_from_index_factor(const float index_factor) const;
 
-  virtual blender::fn::GVArrayPtr interpolate_to_evaluated(
+  virtual blender::fn::GVArray interpolate_to_evaluated(
       const blender::fn::GVArray &src) const override;
 
   void evaluate_segment(const int index,
@@ -487,7 +485,7 @@ class NURBSpline final : public Spline {
 
   blender::Span<blender::float3> evaluated_positions() const final;
 
-  blender::fn::GVArrayPtr interpolate_to_evaluated(const blender::fn::GVArray &src) const final;
+  blender::fn::GVArray interpolate_to_evaluated(const blender::fn::GVArray &src) const final;
 
  protected:
   void correct_end_tangents() const final;
@@ -538,7 +536,7 @@ class PolySpline final : public Spline {
 
   blender::Span<blender::float3> evaluated_positions() const final;
 
-  blender::fn::GVArrayPtr interpolate_to_evaluated(const blender::fn::GVArray &src) const final;
+  blender::fn::GVArray interpolate_to_evaluated(const blender::fn::GVArray &src) const final;
 
  protected:
   void correct_end_tangents() const final;
diff --git a/source/blender/blenkernel/intern/attribute_access.cc b/source/blender/blenkernel/intern/attribute_access.cc
index cd394a4ca42..f3ece270618 100644
--- a/source/blender/blenkernel/intern/attribute_access.cc
+++ b/source/blender/blenkernel/intern/attribute_access.cc
@@ -50,9 +50,7 @@ using blender::bke::AttributeIDRef;
 using blender::bke::OutputAttribute;
 using blender::fn::GMutableSpan;
 using blender::fn::GSpan;
-using blender::fn::GVArray_For_GSpan;
-using blender::fn::GVArray_For_SingleValue;
-using blender::fn::GVMutableArray_For_GMutableSpan;
+using blender::fn::GVMutableArrayImpl_For_GMutableSpan;
 
 namespace blender::bke {
 
@@ -207,7 +205,7 @@ fn::GMutableSpan OutputAttribute::as_span()
 {
   if (!optional_span_varray_) {
     const bool materialize_old_values = !ignore_old_values_;
-    optional_span_varray_ = std::make_unique<fn::GVMutableArray_GSpan>(*varray_,
+    optional_span_varray_ = std::make_unique<fn::GVMutableArray_GSpan>(varray_,
                                                                        materialize_old_values);
   }
   fn::GVMutableArray_GSpan &span_varray = *optional_span_varray_;
@@ -257,8 +255,8 @@ static bool add_builtin_type_custom_data_layer_from_init(CustomData &custom_data
       if (data == nullptr) {
         return false;
       }
-      const GVArray *varray = static_cast<const AttributeInitVArray &>(initializer).varray;
-      varray->materialize_to_uninitialized(IndexRange(varray->size()), data);
+      const GVArray &varray = static_cast<const AttributeInitVArray &>(initializer).varray;
+      varray.materialize_to_uninitialized(varray.index_range(), data);
       return true;
     }
     case AttributeInit::Type::MoveArray: {
@@ -313,8 +311,8 @@ static bool add_custom_data_layer_from_attribute_init(const AttributeIDRef &attr
       if (data == nullptr) {
         return false;
       }
-      const GVArray *varray = static_cast<const AttributeInitVArray &>(initializer).varray;
-      varray->materialize_to_uninitialized(IndexRange(varray->size()), data);
+      const GVArray &varray = static_cast<const AttributeInitVArray &>(initializer).varray;
+      varray.materialize_to_uninitialized(varray.index_range(), data);
       return true;
     }
     case AttributeInit::Type::MoveArray: {
@@ -345,8 +343,7 @@ static bool custom_data_layer_matches_attribute_id(const CustomDataLayer &layer,
   return layer.name == attribute_id.name();
 }
 
-GVArrayPtr BuiltinCustomDataLayerProvider::try_get_for_read(
-    const GeometryComponent &component) const
+GVArray BuiltinCustomDataLayerProvider::try_get_for_read(const GeometryComponent &component) const
 {
   const CustomData *custom_data = custom_data_access_.get_const_custom_data(component);
   if (custom_data == nullptr) {
@@ -511,7 +508,7 @@ ReadAttributeLookup CustomDataAttributeProvider::try_get_for_read(
       continue;
     }
     GSpan data{*type, layer.data, domain_size};
-    return {std::make_unique<GVArray_For_GSpan>(data), domain_};
+    return {GVArray::ForSpan(data), domain_};
   }
   return {};
 }
@@ -541,7 +538,7 @@ WriteAttributeLookup CustomDataAttributeProvider::try_get_for_write(
       continue;
     }
     GMutableSpan data{*type, layer.data, domain_size};
-    return {std::make_unique<GVMutableArray_For_GMutableSpan>(data), domain_};
+    return {GVMutableArray::ForSpan(data), domain_};
   }
   return {};
 }
@@ -751,25 +748,25 @@ std::optional<GSpan> CustomDataAttributes::get_for_read(const AttributeIDRef &at
  * value if the attribute doesn't exist. If no default value is provided, the default value for the
  * type will be used.
  */
-GVArrayPtr CustomDataAttributes::get_for_read(const AttributeIDRef &attribute_id,
-                                              const CustomDataType data_type,
-                                              const void *default_value) const
+GVArray CustomDataAttributes::get_for_read(const AttributeIDRef &attribute_id,
+                                           const CustomDataType data_type,
+                                           const void *default_value) const
 {
   const CPPType *type = blender::bke::custom_data_type_to_cpp_type(data_type);
 
   std::optional<GSpan> attribute = this->get_for_read(attribute_id);
   if (!attribute) {
     const int domain_size = this->size_;
-    return std::make_unique<GVArray_For_SingleValue>(
+    return GVArray::ForSingle(
         *type, domain_size, (default_value == nullptr) ? type->default_value() : default_value);
   }
 
   if (attribute->type() == *type) {
-    return std::make_unique<GVArray_For_GSpan>(*attribute);
+    return GVArray::ForSpan(*attribute);
   }
   const blender::nodes::DataTypeConversions &conversions =
       blender::nodes::get_implicit_type_conversions();
-  return conversions.try_convert(std::make_unique<GVArray_For_GSpan>(*attribute), *type);
+  return conversions.try_convert(GVArray::ForSpan(*attribute), *type);
 }
 
 std::optional<GMutableSpan> CustomDataAttributes::get_for_write(const AttributeIDRef &attribute_id)
@@ -922,8 +919,8 @@ blender::bke::ReadAttributeLookup GeometryComponent::attribute_try_get_for_read(
   return {};
 }
 
-std::unique_ptr<blender::fn::GVArray> GeometryComponent::attribute_try_adapt_domain(
-    std::unique_ptr<blender::fn::GVArray> varray,
+blender::fn::GVArray GeometryComponent::attribute_try_adapt_domain_impl(
+    const blender::fn::GVArray &varray,
     const AttributeDomain from_domain,
     const AttributeDomain to_domain) const
 {
@@ -1110,15 +1107,15 @@ std::optional<AttributeMetaData> GeometryComponent::attribute_get_meta_data(
   return result;
 }
 
-static std::unique_ptr<blender::fn::GVArray> try_adapt_data_type(
-    std::unique_ptr<blender::fn::GVArray> varray, const blender::fn::CPPType &to_type)
+static blender::fn::GVArray try_adapt_data_type(blender::fn::GVArray varray,
+                                                const blender::fn::CPPType &to_type)
 {
   const blender::nodes::DataTypeConversions &conversions =
       blender::nodes::get_implicit_type_conversions();
   return conversions.try_convert(std::move(varray), to_type);
 }
 
-std::unique_ptr<blender::fn::GVArray> GeometryComponent::attribute_try_get_for_read(
+blender::fn::GVArray GeometryComponent::attribute_try_get_for_read(
     const AttributeIDRef &attribute_id,
     const AttributeDomain domain,
     const CustomDataType data_type) const
@@ -1128,7 +1125,7 @@ std::unique_ptr<blender::fn::GVArray> GeometryComponent::attribute_try_get_for_r
     return {};
   }
 
-  std::unique_ptr<blender::fn::GVArray> varray = std::move(attribute.varray);
+  blender::fn::GVArray varray = std::move(attribute.varray);
   if (!ELEM(domain, ATTR_DOMAIN_AUTO, attribute.domain)) {
     varray = this->attribute_try_adapt_domain(std::move(varray), attribute.domain, domain);
     if (!varray) {
@@ -1138,7 +1135,7 @@ std::unique_ptr<blender::fn::GVArray> GeometryComponent::attribute_try_get_for_r
 
   const blender::fn::CPPType *cpp_type = blender::bke::custom_data_type_to_cpp_type(data_type);
   BLI_assert(cpp_type != nullptr);
-  if (varray->type() != *cpp_type) {
+  if (varray.type() != *cpp_type) {
     varray = try_adapt_data_type(std::move(varray), *cpp_type);
     if (!varray) {
       return {};
@@ -1148,7 +1145,7 @@ std::unique_ptr<blender::fn::GVArray> GeometryComponent::attribute_try_get_for_r
   return varray;
 }
 
-std::unique_ptr<blender::bke::GVArray> GeometryComponent::attribute_try_get_for_read(
+blender::fn::GVArray GeometryComponent::attribute_try_get_for_read(
     const AttributeIDRef &attribute_id, const AttributeDomain domain) const
 {
   if (!this->attribute_domain_supported(domain)) {
@@ -1176,7 +1173,7 @@ blender::bke::ReadAttributeLookup GeometryComponent::attribute_try_get_for_read(
   }
   const blender::fn::CPPType *type = blender::bke::custom_data_type_to_cpp_type(data_type);
   BLI_assert(type != nullptr);
-  if (attribute.varray->type() == *type) {
+  if (attribute.varray.type() == *type) {
     return attribute;
   }
   const blender::nodes::DataTypeConversions &conversions =
@@ -1184,14 +1181,12 @@ blender::bke::ReadAttributeLookup GeometryComponent::attribute_try_get_for_read(
   return {conversions.try_convert(std::move(attribute.varray), *type), attribute.domain};
 }
 
-std::unique_ptr<blender::bke::GVArray> GeometryComponent::attribute_get_for_read(
-    const AttributeIDRef &attribute_id,
-    const AttributeDomain domain,
-    const CustomDataType data_type,
-    const void *default_value) const
+blender::fn::GVArray GeometryComponent::attribute_get_for_read(const AttributeIDRef &attribute_id,
+                                                               const AttributeDomain domain,
+                                                               const CustomDataType data_type,
+                                                               const void *default_value) const
 {
-  std::unique_ptr<blender::bke::GVArray> varray = this->attribute_try_get_for_read(
-      attribute_id, domain, data_type);
+  blender::fn::GVArray varray = this->attribute_try_get_for_read(attribute_id, domain, data_type);
   if (varray) {
     return varray;
   }
@@ -1200,11 +1195,11 @@ std::unique_ptr<blender::bke::GVArray> GeometryComponent::attribute_get_for_read
     default_value = type->default_value();
   }
   const int domain_size = this->attribute_domain_size(domain);
-  return std::make_unique<blender::fn::GVArray_For_SingleValue>(*type, domain_size, default_value);
+  return blender::fn::GVArray::ForSingle(*type, domain_size, default_value);
 }
 
 class GVMutableAttribute_For_OutputAttribute
-    : public blender::fn::GVMutableArray_For_GMutableSpan {
+    : public blender::fn::GVMutableArrayImpl_For_GMutableSpan {
  public:
   GeometryComponent *component;
   std::string attribute_name;
@@ -1213,7 +1208,7 @@ class GVMutableAttribute_For_OutputAttribute
   GVMutableAttribute_For_OutputAttribute(GMutableSpan data,
                                          GeometryComponent &component,
                                          const AttributeIDRef &attribute_id)
-      : blender::fn::GVMutableArray_For_GMutableSpan(data), component(&component)
+      : blender::fn::GVMutableArrayImpl_For_GMutableSpan(data), component(&component)
   {
     if (attribute_id.is_named()) {
       this->attribute_name = attribute_id.name();
@@ -1239,7 +1234,8 @@ static void save_output_attribute(OutputAttribute &output_attribute)
   using namespace blender::bke;
 
   GVMutableAttribute_For_OutputAttribute &varray =
-      dynamic_cast<GVMutableAttribute_For_OutputAttribute &>(output_attribute.varray());
+      dynamic_cast<GVMutableAttribute_For_OutputAttribute &>(
+          *output_attribute.varray().get_implementation());
 
   GeometryComponent &component = *varray.component;
   AttributeIDRef attribute_id;
@@ -1267,7 +1263,7 @@ static void save_output_attribute(OutputAttribute &output_attribute)
   BUFFER_FOR_CPP_TYPE_VALUE(varray.type(), buffer);
   for (const int i : IndexRange(varray.size())) {
     varray.get(i, buffer);
-    write_attribute.varray->set_by_relocate(i, buffer);
+    write_attribute.varray.set_by_relocate(i, buffer);
   }
   if (write_attribute.tag_modified_fn) {
     write_attribute.tag_modified_fn();
@@ -1310,9 +1306,9 @@ static OutputAttribute create_output_attribute(GeometryComponent &component,
     if (!attribute) {
       if (default_value) {
         const int64_t domain_size = component.attribute_domain_size(domain);
-        const GVArray_For_SingleValueRef default_varray{*cpp_type, domain_size, default_value};
-        component.attribute_try_create_builtin(attribute_name,
-                                               AttributeInitVArray(&default_varray));
+        component.attribute_try_create_builtin(
+            attribute_name,
+            AttributeInitVArray(GVArray::ForSingleRef(*cpp_type, domain_size, default_value)));
       }
       else {
         component.attribute_try_create_builtin(attribute_name, AttributeInitDefault());
@@ -1327,9 +1323,8 @@ static OutputAttribute create_output_attribute(GeometryComponent &component,
       /* Builtin attribute is on different domain. */
       return {};
     }
-
-    GVMutableArrayPtr varray = std::move(attribute.varray);
-    if (varray->type() == *cpp_type) {
+    GVMutableArray varray = std::move(attribute.varray);
+    if (varray.type() == *cpp_type) {
       /* Builtin attribute matches exactly. */
       return OutputAttribute(std::move(varray),
                              domain,
@@ -1349,9 +1344,11 @@ static OutputAttribute create_output_attribute(GeometryComponent &component,
   WriteAttributeLookup attribute = component.attribute_try_get_for_write(attribute_id);
   if (!attribute) {
     if (default_value) {
-      const GVArray_For_SingleValueRef default_varray{*cpp_type, domain_size, default_value};
       component.attribute_try_create(
-          attribute_id, domain, data_type, AttributeInitVArray(&default_varray));
+          attribute_id,
+          domain,
+          data_type,
+          AttributeInitVArray(GVArray::ForSingleRef(*cpp_type, domain_size, default_value)));
     }
     else {
       component.attribute_try_create(attribute_id, domain, data_type, AttributeInitDefault());
@@ -1363,7 +1360,7 @@ static OutputAttribute create_output_attribute(GeometryComponent &component,
       return {};
     }
   }
-  if (attribute.domain == domain && attribute.varray->type() == *cpp_type) {
+  if (attribute.domain == domain && attribute.varray.type() == *cpp_type) {
     /* Existing generic attribute matches exactly. */
 
     return OutputAttribute(std::move(attribute.varray),
@@ -1382,11 +1379,11 @@ static OutputAttribute create_output_attribute(GeometryComponent &component,
   }
   else {
     /* Fill the temporary array with values from the existing attribute. */
-    GVArrayPtr old_varray = component.attribute_get_for_read(
+    GVArray old_varray = component.attribute_get_for_read(
         attribute_id, domain, data_type, default_value);
-    old_varray->materialize_to_uninitialized(IndexRange(domain_size), data);
+    old_varray.materialize_to_uninitialized(IndexRange(domain_size), data);
   }
-  GVMutableArrayPtr varray = std::make_unique<GVMutableAttribute_For_OutputAttribute>(
+  GVMutableArray varray = GVMutableArray::For<GVMutableAttribute_For_OutputAttribute>(
       GMutableSpan{*cpp_type, data, domain_size}, component, attribute_id);
 
   return OutputAttribute(std::move(varray), domain, save_output_attribute, true);
@@ -1410,21 +1407,21 @@ OutputAttribute GeometryComponent::attribute_try_get_for_output_only(
 
 namespace blender::bke {
 
-const GVArray *AttributeFieldInput::get_varray_for_context(const fn::FieldContext &context,
-                                                           IndexMask UNUSED(mask),
-                                                           ResourceScope &scope) const
+GVArray AttributeFieldInput::get_varray_for_context(const fn::FieldContext &context,
+                                                    IndexMask UNUSED(mask),
+                                                    ResourceScope &UNUSED(scope)) const
 {
   if (const GeometryComponentFieldContext *geometry_context =
           dynamic_cast<const GeometryComponentFieldContext *>(&context)) {
     const GeometryComponent &component = geometry_context->geometry_component();
     const AttributeDomain domain = geometry_context->domain();
     const CustomDataType data_type = cpp_type_to_custom_data_type(*type_);
-    GVArrayPtr attribute = component.attribute_try_get_for_read(name_, domain, data_type);
+    GVArray attribute = component.attribute_try_get_for_read(name_, domain, data_type);
     if (attribute) {
-      return scope.add(std::move(attribute));
+      return attribute;
     }
   }
-  return nullptr;
+  return {};
 }
 
 std::string AttributeFieldInput::socket_inspection_name() const
@@ -1457,25 +1454,25 @@ static StringRef get_random_id_attribute_name(const AttributeDomain domain)
   }
 }
 
-const GVArray *IDAttributeFieldInput::get_varray_for_context(const fn::FieldContext &context,
-                                                             IndexMask mask,
-                                                             ResourceScope &scope) const
+GVArray IDAttributeFieldInput::get_varray_for_context(const fn::FieldContext &context,
+                                                      IndexMask mask,
+                                                      ResourceScope &scope) const
 {
   if (const GeometryComponentFieldContext *geometry_context =
           dynamic_cast<const GeometryComponentFieldContext *>(&context)) {
     const GeometryComponent &component = geometry_context->geometry_component();
     const AttributeDomain domain = geometry_context->domain();
     const StringRef name = get_random_id_attribute_name(domain);
-    GVArrayPtr attribute = component.attribute_try_get_for_read(name, domain, CD_PROP_INT32);
+    GVArray attribute = component.attribute_try_get_for_read(name, domain, CD_PROP_INT32);
     if (attribute) {
-      BLI_assert(attribute->size() == component.attribute_domain_size(domain));
-      return scope.add(std::move(attribute));
+      BLI_assert(attribute.size() == component.attribute_domain_size(domain));
+      return attribute;
     }
 
     /* Use the index as the fallback if no random ID attribute exists. */
     return fn::IndexFieldInput::get_index_varray(mask, scope);
   }
-  return nullptr;
+  return {};
 }
 
 std::string IDAttributeFieldInput::socket_inspection_name() const
@@ -1495,19 +1492,20 @@ bool IDAttributeFieldInput::is_equal_to(const fn::FieldNode &other) const
   return dynamic_cast<const IDAttributeFieldInput *>(&other) != nullptr;
 }
 
-const GVArray *AnonymousAttributeFieldInput::get_varray_for_context(
-    const fn::FieldContext &context, IndexMask UNUSED(mask), ResourceScope &scope) const
+GVArray AnonymousAttributeFieldInput::get_varray_for_context(const fn::FieldContext &context,
+                                                             IndexMask UNUSED(mask),
+                                                             ResourceScope &UNUSED(scope)) const
 {
   if (const GeometryComponentFieldContext *geometry_context =
           dynamic_cast<const GeometryComponentFieldContext *>(&context)) {
     const GeometryComponent &component = geometry_context->geometry_component();
     const AttributeDomain domain = geometry_context->domain();
     const CustomDataType data_type = cpp_type_to_custom_data_type(*type_);
-    GVArrayPtr attribute = component.attribute_try_get_for_read(
+    GVArray attribute = component.attribute_try_get_for_read(
         anonymous_id_.get(), domain, data_type);
-    return scope.add(std::move(attribute));
+    return attribute;
   }
-  return nullptr;
+  return {};
 }
 
 std::string AnonymousAttributeFieldInput::socket_inspection_name() const
diff --git a/source/blender/blenkernel/intern/attribute_access_intern.hh b/source/blender/blenkernel/intern/attribute_access_intern.hh
index 140498bdb01..b77d7010efa 100644
--- a/source/blender/blenkernel/intern/attribute_access_intern.hh
+++ b/source/blender/blenkernel/intern/attribute_access_intern.hh
@@ -24,9 +24,6 @@
 
 namespace blender::bke {
 
-using fn::GVArrayPtr;
-using fn::GVMutableArrayPtr;
-
 /**
  * Utility to group together multiple functions that are used to access custom data on geometry
  * components in a generic way.
@@ -86,7 +83,7 @@ class BuiltinAttributeProvider {
   {
   }
 
-  virtual GVArrayPtr try_get_for_read(const GeometryComponent &component) const = 0;
+  virtual GVArray try_get_for_read(const GeometryComponent &component) const = 0;
   virtual WriteAttributeLookup try_get_for_write(GeometryComponent &component) const = 0;
   virtual bool try_delete(GeometryComponent &component) const = 0;
   virtual bool try_create(GeometryComponent &UNUSED(component),
@@ -188,8 +185,8 @@ class CustomDataAttributeProvider final : public DynamicAttributesProvider {
  */
 class NamedLegacyCustomDataProvider final : public DynamicAttributesProvider {
  private:
-  using AsReadAttribute = GVArrayPtr (*)(const void *data, const int domain_size);
-  using AsWriteAttribute = GVMutableArrayPtr (*)(void *data, const int domain_size);
+  using AsReadAttribute = GVArray (*)(const void *data, const int domain_size);
+  using AsWriteAttribute = GVMutableArray (*)(void *data, const int domain_size);
   const AttributeDomain domain_;
   const CustomDataType attribute_type_;
   const CustomDataType stored_type_;
@@ -232,8 +229,8 @@ class NamedLegacyCustomDataProvider final : public DynamicAttributesProvider {
  * if the stored type is the same as the attribute type.
  */
 class BuiltinCustomDataLayerProvider final : public BuiltinAttributeProvider {
-  using AsReadAttribute = GVArrayPtr (*)(const void *data, const int domain_size);
-  using AsWriteAttribute = GVMutableArrayPtr (*)(void *data, const int domain_size);
+  using AsReadAttribute = GVArray (*)(const void *data, const int domain_size);
+  using AsWriteAttribute = GVMutableArray (*)(void *data, const int domain_size);
   using UpdateOnRead = void (*)(const GeometryComponent &component);
   using UpdateOnWrite = void (*)(GeometryComponent &component);
   const CustomDataType stored_type_;
@@ -266,7 +263,7 @@ class BuiltinCustomDataLayerProvider final : public BuiltinAttributeProvider {
   {
   }
 
-  GVArrayPtr try_get_for_read(const GeometryComponent &component) const final;
+  GVArray try_get_for_read(const GeometryComponent &component) const final;
   WriteAttributeLookup try_get_for_write(GeometryComponent &component) const final;
   bool try_delete(GeometryComponent &component) const final;
   bool try_create(GeometryComponent &component, const AttributeInit &initializer) const final;
diff --git a/source/blender/blenkernel/intern/curve_to_mesh_convert.cc b/source/blender/blenkernel/intern/curve_to_mesh_convert.cc
index 1ef205c6903..03525e32a52 100644
--- a/source/blender/blenkernel/intern/curve_to_mesh_convert.cc
+++ b/source/blender/blenkernel/intern/curve_to_mesh_convert.cc
@@ -32,8 +32,6 @@
 
 using blender::fn::GMutableSpan;
 using blender::fn::GSpan;
-using blender::fn::GVArray_Typed;
-using blender::fn::GVArrayPtr;
 
 namespace blender::bke {
 
@@ -76,7 +74,7 @@ static void vert_extrude_to_mesh_data(const Spline &spline,
   Span<float3> positions = spline.evaluated_positions();
   Span<float3> tangents = spline.evaluated_tangents();
   Span<float3> normals = spline.evaluated_normals();
-  GVArray_Typed<float> radii = spline.interpolate_to_evaluated(spline.radii());
+  VArray<float> radii = spline.interpolate_to_evaluated(spline.radii());
   for (const int i : IndexRange(eval_size)) {
     float4x4 point_matrix = float4x4::from_normalized_axis_data(
         positions[i], normals[i], tangents[i]);
@@ -227,7 +225,7 @@ static void spline_extrude_to_mesh_data(const ResultInfo &info,
   Span<float3> normals = spline.evaluated_normals();
   Span<float3> profile_positions = profile.evaluated_positions();
 
-  GVArray_Typed<float> radii = spline.interpolate_to_evaluated(spline.radii());
+  VArray<float> radii = spline.interpolate_to_evaluated(spline.radii());
   for (const int i_ring : IndexRange(info.spline_vert_len)) {
     float4x4 point_matrix = float4x4::from_normalized_axis_data(
         positions[i_ring], normals[i_ring], tangents[i_ring]);
@@ -495,8 +493,8 @@ static void copy_curve_point_attribute_to_mesh(const GSpan src,
                                                const ResultInfo &info,
                                                ResultAttributeData &dst)
 {
-  GVArrayPtr interpolated_gvarray = info.spline.interpolate_to_evaluated(src);
-  GSpan interpolated = interpolated_gvarray->get_internal_span();
+  GVArray interpolated_gvarray = info.spline.interpolate_to_evaluated(src);
+  GSpan interpolated = interpolated_gvarray.get_internal_span();
 
   attribute_math::convert_to_static_type(src.type(), [&](auto dummy) {
     using T = decltype(dummy);
@@ -561,8 +559,8 @@ static void copy_profile_point_attribute_to_mesh(const GSpan src,
                                                  const ResultInfo &info,
                                                  ResultAttributeData &dst)
 {
-  GVArrayPtr interpolated_gvarray = info.profile.interpolate_to_evaluated(src);
-  GSpan interpolated = interpolated_gvarray->get_internal_span();
+  GVArray interpolated_gvarray = info.profile.interpolate_to_evaluated(src);
+  GSpan interpolated = interpolated_gvarray.get_internal_span();
 
   attribute_math::convert_to_static_type(src.type(), [&](auto dummy) {
     using T = decltype(dummy);
diff --git a/source/blender/blenkernel/intern/geometry_component_curve.cc b/source/blender/blenkernel/intern/geometry_component_curve.cc
index d3c3fcc1e67..0b80ff5acdf 100644
--- a/source/blender/blenkernel/intern/geometry_component_curve.cc
+++ b/source/blender/blenkernel/intern/geometry_component_curve.cc
@@ -28,10 +28,8 @@
 
 using blender::fn::GMutableSpan;
 using blender::fn::GSpan;
-using blender::fn::GVArray_For_GSpan;
+using blender::fn::GVArray;
 using blender::fn::GVArray_GSpan;
-using blender::fn::GVArrayPtr;
-using blender::fn::GVMutableArray_For_GMutableSpan;
 
 /* -------------------------------------------------------------------- */
 /** \name Geometry Component Implementation
@@ -253,15 +251,15 @@ void adapt_curve_domain_point_to_spline_impl(const CurveEval &curve,
   }
 }
 
-static GVArrayPtr adapt_curve_domain_point_to_spline(const CurveEval &curve, GVArrayPtr varray)
+static GVArray adapt_curve_domain_point_to_spline(const CurveEval &curve, GVArray varray)
 {
-  GVArrayPtr new_varray;
-  attribute_math::convert_to_static_type(varray->type(), [&](auto dummy) {
+  GVArray new_varray;
+  attribute_math::convert_to_static_type(varray.type(), [&](auto dummy) {
     using T = decltype(dummy);
     if constexpr (!std::is_void_v<attribute_math::DefaultMixer<T>>) {
       Array<T> values(curve.splines().size());
-      adapt_curve_domain_point_to_spline_impl<T>(curve, varray->typed<T>(), values);
-      new_varray = std::make_unique<fn::GVArray_For_ArrayContainer<Array<T>>>(std::move(values));
+      adapt_curve_domain_point_to_spline_impl<T>(curve, varray.typed<T>(), values);
+      new_varray = VArray<T>::ForContainer(std::move(values));
     }
   });
   return new_varray;
@@ -272,29 +270,29 @@ static GVArrayPtr adapt_curve_domain_point_to_spline(const CurveEval &curve, GVA
  * attributes. The goal is to avoid copying the spline value for every one of its control points
  * unless it is necessary (in that case the materialize functions will be called).
  */
-template<typename T> class VArray_For_SplineToPoint final : public VArray<T> {
-  GVArrayPtr original_varray_;
+template<typename T> class VArray_For_SplineToPoint final : public VArrayImpl<T> {
+  GVArray original_varray_;
   /* Store existing data materialized if it was not already a span. This is expected
    * to be worth it because a single spline's value will likely be accessed many times. */
-  fn::GVArray_Span<T> original_data_;
+  VArray_Span<T> original_data_;
   Array<int> offsets_;
 
  public:
-  VArray_For_SplineToPoint(GVArrayPtr original_varray, Array<int> offsets)
-      : VArray<T>(offsets.last()),
+  VArray_For_SplineToPoint(GVArray original_varray, Array<int> offsets)
+      : VArrayImpl<T>(offsets.last()),
         original_varray_(std::move(original_varray)),
-        original_data_(*original_varray_),
+        original_data_(original_varray_.typed<T>()),
         offsets_(std::move(offsets))
   {
   }
 
-  T get_impl(const int64_t index) const final
+  T get(const int64_t index) const final
   {
     const PointIndices indices = lookup_point_indices(offsets_, index);
     return original_data_[indices.spline_index];
   }
 
-  void materialize_impl(const IndexMask mask, MutableSpan<T> r_span) const final
+  void materialize(const IndexMask mask, MutableSpan<T> r_span) const final
   {
     const int total_size = offsets_.last();
     if (mask.is_range() && mask.as_range() == IndexRange(total_size)) {
@@ -315,7 +313,7 @@ template<typename T> class VArray_For_SplineToPoint final : public VArray<T> {
     }
   }
 
-  void materialize_to_uninitialized_impl(const IndexMask mask, MutableSpan<T> r_span) const final
+  void materialize_to_uninitialized(const IndexMask mask, MutableSpan<T> r_span) const final
   {
     T *dst = r_span.data();
     const int total_size = offsets_.last();
@@ -338,29 +336,29 @@ template<typename T> class VArray_For_SplineToPoint final : public VArray<T> {
   }
 };
 
-static GVArrayPtr adapt_curve_domain_spline_to_point(const CurveEval &curve, GVArrayPtr varray)
+static GVArray adapt_curve_domain_spline_to_point(const CurveEval &curve, GVArray varray)
 {
-  GVArrayPtr new_varray;
-  attribute_math::convert_to_static_type(varray->type(), [&](auto dummy) {
+  GVArray new_varray;
+  attribute_math::convert_to_static_type(varray.type(), [&](auto dummy) {
     using T = decltype(dummy);
 
     Array<int> offsets = curve.control_point_offsets();
-    new_varray = std::make_unique<fn::GVArray_For_EmbeddedVArray<T, VArray_For_SplineToPoint<T>>>(
-        offsets.last(), std::move(varray), std::move(offsets));
+    new_varray = VArray<T>::template For<VArray_For_SplineToPoint<T>>(std::move(varray),
+                                                                      std::move(offsets));
   });
   return new_varray;
 }
 
 }  // namespace blender::bke
 
-GVArrayPtr CurveComponent::attribute_try_adapt_domain(GVArrayPtr varray,
-                                                      const AttributeDomain from_domain,
-                                                      const AttributeDomain to_domain) const
+GVArray CurveComponent::attribute_try_adapt_domain_impl(const GVArray &varray,
+                                                        const AttributeDomain from_domain,
+                                                        const AttributeDomain to_domain) const
 {
   if (!varray) {
     return {};
   }
-  if (varray->size() == 0) {
+  if (varray.is_empty()) {
     return {};
   }
   if (from_domain == to_domain) {
@@ -402,8 +400,8 @@ static const CurveEval *get_curve_from_component_for_read(const GeometryComponen
 namespace blender::bke {
 
 class BuiltinSplineAttributeProvider final : public BuiltinAttributeProvider {
-  using AsReadAttribute = GVArrayPtr (*)(const CurveEval &data);
-  using AsWriteAttribute = GVMutableArrayPtr (*)(CurveEval &data);
+  using AsReadAttribute = GVArray (*)(const CurveEval &data);
+  using AsWriteAttribute = GVMutableArray (*)(CurveEval &data);
   const AsReadAttribute as_read_attribute_;
   const AsWriteAttribute as_write_attribute_;
 
@@ -424,7 +422,7 @@ class BuiltinSplineAttributeProvider final : public BuiltinAttributeProvider {
   {
   }
 
-  GVArrayPtr try_get_for_read(const GeometryComponent &component) const final
+  GVArray try_get_for_read(const GeometryComponent &component) const final
   {
     const CurveEval *curve = get_curve_from_component_for_read(component);
     if (curve == nullptr) {
@@ -483,19 +481,15 @@ static void set_spline_resolution(SplinePtr &spline, const int resolution)
   }
 }
 
-static GVArrayPtr make_resolution_read_attribute(const CurveEval &curve)
+static GVArray make_resolution_read_attribute(const CurveEval &curve)
 {
-  return std::make_unique<fn::GVArray_For_DerivedSpan<SplinePtr, int, get_spline_resolution>>(
-      curve.splines());
+  return VArray<int>::ForDerivedSpan<SplinePtr, get_spline_resolution>(curve.splines());
 }
 
-static GVMutableArrayPtr make_resolution_write_attribute(CurveEval &curve)
+static GVMutableArray make_resolution_write_attribute(CurveEval &curve)
 {
-  return std::make_unique<fn::GVMutableArray_For_DerivedSpan<SplinePtr,
-                                                             int,
-                                                             get_spline_resolution,
-                                                             set_spline_resolution>>(
-      curve.splines());
+  return VMutableArray<int>::
+      ForDerivedSpan<SplinePtr, get_spline_resolution, set_spline_resolution>(curve.splines());
 }
 
 static bool get_cyclic_value(const SplinePtr &spline)
@@ -511,16 +505,14 @@ static void set_cyclic_value(SplinePtr &spline, const bool value)
   }
 }
 
-static GVArrayPtr make_cyclic_read_attribute(const CurveEval &curve)
+static GVArray make_cyclic_read_attribute(const CurveEval &curve)
 {
-  return std::make_unique<fn::GVArray_For_DerivedSpan<SplinePtr, bool, get_cyclic_value>>(
-      curve.splines());
+  return VArray<bool>::ForDerivedSpan<SplinePtr, get_cyclic_value>(curve.splines());
 }
 
-static GVMutableArrayPtr make_cyclic_write_attribute(CurveEval &curve)
+static GVMutableArray make_cyclic_write_attribute(CurveEval &curve)
 {
-  return std::make_unique<
-      fn::GVMutableArray_For_DerivedSpan<SplinePtr, bool, get_cyclic_value, set_cyclic_value>>(
+  return VMutableArray<bool>::ForDerivedSpan<SplinePtr, get_cyclic_value, set_cyclic_value>(
       curve.splines());
 }
 
@@ -623,9 +615,9 @@ static void point_attribute_materialize_to_uninitialized(Span<Span<T>> data,
   }
 }
 
-static GVArrayPtr varray_from_initializer(const AttributeInit &initializer,
-                                          const CustomDataType data_type,
-                                          const Span<SplinePtr> splines)
+static GVArray varray_from_initializer(const AttributeInit &initializer,
+                                       const CustomDataType data_type,
+                                       const Span<SplinePtr> splines)
 {
   switch (initializer.type) {
     case AttributeInit::Type::Default:
@@ -634,16 +626,15 @@ static GVArrayPtr varray_from_initializer(const AttributeInit &initializer,
       BLI_assert_unreachable();
       return {};
     case AttributeInit::Type::VArray:
-      return static_cast<const AttributeInitVArray &>(initializer).varray->shallow_copy();
+      return static_cast<const AttributeInitVArray &>(initializer).varray;
     case AttributeInit::Type::MoveArray:
       int total_size = 0;
       for (const SplinePtr &spline : splines) {
         total_size += spline->size();
       }
-      return std::make_unique<fn::GVArray_For_GSpan>(
-          GSpan(*bke::custom_data_type_to_cpp_type(data_type),
-                static_cast<const AttributeInitMove &>(initializer).data,
-                total_size));
+      return GVArray::ForSpan(GSpan(*bke::custom_data_type_to_cpp_type(data_type),
+                                    static_cast<const AttributeInitMove &>(initializer).data,
+                                    total_size));
   }
   BLI_assert_unreachable();
   return {};
@@ -691,11 +682,11 @@ static bool create_point_attribute(GeometryComponent &component,
   /* We just created the attribute, it should exist. */
   BLI_assert(write_attribute);
 
-  GVArrayPtr source_varray = varray_from_initializer(initializer, data_type, splines);
+  GVArray source_varray = varray_from_initializer(initializer, data_type, splines);
   /* TODO: When we can call a variant of #set_all with a virtual array argument,
    * this theoretically unnecessary materialize step could be removed. */
-  GVArray_GSpan source_varray_span{*source_varray};
-  write_attribute.varray->set_all(source_varray_span.data());
+  GVArray_GSpan source_varray_span{source_varray};
+  write_attribute.varray.set_all(source_varray_span.data());
 
   if (initializer.type == AttributeInit::Type::MoveArray) {
     MEM_freeN(static_cast<const AttributeInitMove &>(initializer).data);
@@ -723,29 +714,29 @@ static bool remove_point_attribute(GeometryComponent &component,
 /**
  * Virtual array for any control point data accessed with spans and an offset array.
  */
-template<typename T> class VArray_For_SplinePoints : public VArray<T> {
+template<typename T> class VArray_For_SplinePoints : public VArrayImpl<T> {
  private:
   const Array<Span<T>> data_;
   Array<int> offsets_;
 
  public:
   VArray_For_SplinePoints(Array<Span<T>> data, Array<int> offsets)
-      : VArray<T>(offsets.last()), data_(std::move(data)), offsets_(std::move(offsets))
+      : VArrayImpl<T>(offsets.last()), data_(std::move(data)), offsets_(std::move(offsets))
   {
   }
 
-  T get_impl(const int64_t index) const final
+  T get(const int64_t index) const final
   {
     const PointIndices indices = lookup_point_indices(offsets_, index);
     return data_[indices.spline_index][indices.point_index];
   }
 
-  void materialize_impl(const IndexMask mask, MutableSpan<T> r_span) const final
+  void materialize(const IndexMask mask, MutableSpan<T> r_span) const final
   {
     point_attribute_materialize(data_.as_span(), offsets_, mask, r_span);
   }
 
-  void materialize_to_uninitialized_impl(const IndexMask mask, MutableSpan<T> r_span) const final
+  void materialize_to_uninitialized(const IndexMask mask, MutableSpan<T> r_span) const final
   {
     point_attribute_materialize_to_uninitialized(data_.as_span(), offsets_, mask, r_span);
   }
@@ -754,30 +745,30 @@ template<typename T> class VArray_For_SplinePoints : public VArray<T> {
 /**
  * Mutable virtual array for any control point data accessed with spans and an offset array.
  */
-template<typename T> class VMutableArray_For_SplinePoints final : public VMutableArray<T> {
+template<typename T> class VMutableArray_For_SplinePoints final : public VMutableArrayImpl<T> {
  private:
   Array<MutableSpan<T>> data_;
   Array<int> offsets_;
 
  public:
   VMutableArray_For_SplinePoints(Array<MutableSpan<T>> data, Array<int> offsets)
-      : VMutableArray<T>(offsets.last()), data_(std::move(data)), offsets_(std::move(offsets))
+      : VMutableArrayImpl<T>(offsets.last()), data_(std::move(data)), offsets_(std::move(offsets))
   {
   }
 
-  T get_impl(const int64_t index) const final
+  T get(const int64_t index) const final
   {
     const PointIndices indices = lookup_point_indices(offsets_, index);
     return data_[indices.spline_index][indices.point_index];
   }
 
-  void set_impl(const int64_t index, T value) final
+  void set(const int64_t index, T value) final
   {
     const PointIndices indices = lookup_point_indices(offsets_, index);
     data_[indices.spline_index][indices.point_index] = value;
   }
 
-  void set_all_impl(Span<T> src) final
+  void set_all(Span<T> src) final
   {
     for (const int spline_index : data_.index_range()) {
       const int offset = offsets_[spline_index];
@@ -786,30 +777,28 @@ template<typename T> class VMutableArray_For_SplinePoints final : public VMutabl
     }
   }
 
-  void materialize_impl(const IndexMask mask, MutableSpan<T> r_span) const final
+  void materialize(const IndexMask mask, MutableSpan<T> r_span) const final
   {
     point_attribute_materialize({(Span<T> *)data_.data(), data_.size()}, offsets_, mask, r_span);
   }
 
-  void materialize_to_uninitialized_impl(const IndexMask mask, MutableSpan<T> r_span) const final
+  void materialize_to_uninitialized(const IndexMask mask, MutableSpan<T> r_span) const final
   {
     point_attribute_materialize_to_uninitialized(
         {(Span<T> *)data_.data(), data_.size()}, offsets_, mask, r_span);
   }
 };
 
-template<typename T> GVArrayPtr point_data_gvarray(Array<Span<T>> spans, Array<int> offsets)
+template<typename T> VArray<T> point_data_varray(Array<Span<T>> spans, Array<int> offsets)
 {
-  return std::make_unique<fn::GVArray_For_EmbeddedVArray<T, VArray_For_SplinePoints<T>>>(
-      offsets.last(), std::move(spans), std::move(offsets));
+  return VArray<T>::template For<VArray_For_SplinePoints<T>>(std::move(spans), std::move(offsets));
 }
 
 template<typename T>
-GVMutableArrayPtr point_data_gvarray(Array<MutableSpan<T>> spans, Array<int> offsets)
+VMutableArray<T> point_data_varray(Array<MutableSpan<T>> spans, Array<int> offsets)
 {
-  return std::make_unique<
-      fn::GVMutableArray_For_EmbeddedVMutableArray<T, VMutableArray_For_SplinePoints<T>>>(
-      offsets.last(), std::move(spans), std::move(offsets));
+  return VMutableArray<T>::template For<VMutableArray_For_SplinePoints<T>>(std::move(spans),
+                                                                           std::move(offsets));
 }
 
 /**
@@ -820,24 +809,24 @@ GVMutableArrayPtr point_data_gvarray(Array<MutableSpan<T>> spans, Array<int> off
  * \note There is no need to check the handle type to avoid changing auto handles, since
  * retrieving write access to the position data will mark them for recomputation anyway.
  */
-class VMutableArray_For_SplinePosition final : public VMutableArray<float3> {
+class VMutableArray_For_SplinePosition final : public VMutableArrayImpl<float3> {
  private:
   MutableSpan<SplinePtr> splines_;
   Array<int> offsets_;
 
  public:
   VMutableArray_For_SplinePosition(MutableSpan<SplinePtr> splines, Array<int> offsets)
-      : VMutableArray<float3>(offsets.last()), splines_(splines), offsets_(std::move(offsets))
+      : VMutableArrayImpl<float3>(offsets.last()), splines_(splines), offsets_(std::move(offsets))
   {
   }
 
-  float3 get_impl(const int64_t index) const final
+  float3 get(const int64_t index) const final
   {
     const PointIndices indices = lookup_point_indices(offsets_, index);
     return splines_[indices.spline_index]->positions()[indices.point_index];
   }
 
-  void set_impl(const int64_t index, float3 value) final
+  void set(const int64_t index, float3 value) final
   {
     const PointIndices indices = lookup_point_indices(offsets_, index);
     Spline &spline = *splines_[indices.spline_index];
@@ -852,7 +841,7 @@ class VMutableArray_For_SplinePosition final : public VMutableArray<float3> {
     }
   }
 
-  void set_all_impl(Span<float3> src) final
+  void set_all(Span<float3> src) final
   {
     for (const int spline_index : splines_.index_range()) {
       Spline &spline = *splines_[spline_index];
@@ -885,21 +874,20 @@ class VMutableArray_For_SplinePosition final : public VMutableArray<float3> {
     return spans;
   }
 
-  void materialize_impl(const IndexMask mask, MutableSpan<float3> r_span) const final
+  void materialize(const IndexMask mask, MutableSpan<float3> r_span) const final
   {
     Array<Span<float3>> spans = this->get_position_spans();
     point_attribute_materialize(spans.as_span(), offsets_, mask, r_span);
   }
 
-  void materialize_to_uninitialized_impl(const IndexMask mask,
-                                         MutableSpan<float3> r_span) const final
+  void materialize_to_uninitialized(const IndexMask mask, MutableSpan<float3> r_span) const final
   {
     Array<Span<float3>> spans = this->get_position_spans();
     point_attribute_materialize_to_uninitialized(spans.as_span(), offsets_, mask, r_span);
   }
 };
 
-class VArray_For_BezierHandle final : public VArray<float3> {
+class VArray_For_BezierHandle final : public VArrayImpl<float3> {
  private:
   Span<SplinePtr> splines_;
   Array<int> offsets_;
@@ -907,7 +895,7 @@ class VArray_For_BezierHandle final : public VArray<float3> {
 
  public:
   VArray_For_BezierHandle(Span<SplinePtr> splines, Array<int> offsets, const bool is_right)
-      : VArray<float3>(offsets.last()),
+      : VArrayImpl<float3>(offsets.last()),
         splines_(std::move(splines)),
         offsets_(std::move(offsets)),
         is_right_(is_right)
@@ -929,7 +917,7 @@ class VArray_For_BezierHandle final : public VArray<float3> {
     return float3(0);
   }
 
-  float3 get_impl(const int64_t index) const final
+  float3 get(const int64_t index) const final
   {
     return get_internal(index, splines_, offsets_, is_right_);
   }
@@ -976,19 +964,18 @@ class VArray_For_BezierHandle final : public VArray<float3> {
     point_attribute_materialize_to_uninitialized(spans.as_span(), offsets, mask, r_span);
   }
 
-  void materialize_impl(const IndexMask mask, MutableSpan<float3> r_span) const final
+  void materialize(const IndexMask mask, MutableSpan<float3> r_span) const final
   {
     materialize_internal(mask, splines_, offsets_, is_right_, r_span);
   }
 
-  void materialize_to_uninitialized_impl(const IndexMask mask,
-                                         MutableSpan<float3> r_span) const final
+  void materialize_to_uninitialized(const IndexMask mask, MutableSpan<float3> r_span) const final
   {
     materialize_to_uninitialized_internal(mask, splines_, offsets_, is_right_, r_span);
   }
 };
 
-class VMutableArray_For_BezierHandles final : public VMutableArray<float3> {
+class VMutableArray_For_BezierHandles final : public VMutableArrayImpl<float3> {
  private:
   MutableSpan<SplinePtr> splines_;
   Array<int> offsets_;
@@ -998,19 +985,19 @@ class VMutableArray_For_BezierHandles final : public VMutableArray<float3> {
   VMutableArray_For_BezierHandles(MutableSpan<SplinePtr> splines,
                                   Array<int> offsets,
                                   const bool is_right)
-      : VMutableArray<float3>(offsets.last()),
+      : VMutableArrayImpl<float3>(offsets.last()),
         splines_(splines),
         offsets_(std::move(offsets)),
         is_right_(is_right)
   {
   }
 
-  float3 get_impl(const int64_t index) const final
+  float3 get(const int64_t index) const final
   {
     return VArray_For_BezierHandle::get_internal(index, splines_, offsets_, is_right_);
   }
 
-  void set_impl(const int64_t index, float3 value) final
+  void set(const int64_t index, float3 value) final
   {
     const PointIndices indices = lookup_point_indices(offsets_, index);
     Spline &spline = *splines_[indices.spline_index];
@@ -1026,7 +1013,7 @@ class VMutableArray_For_BezierHandles final : public VMutableArray<float3> {
     }
   }
 
-  void set_all_impl(Span<float3> src) final
+  void set_all(Span<float3> src) final
   {
     for (const int spline_index : splines_.index_range()) {
       Spline &spline = *splines_[spline_index];
@@ -1049,13 +1036,12 @@ class VMutableArray_For_BezierHandles final : public VMutableArray<float3> {
     }
   }
 
-  void materialize_impl(const IndexMask mask, MutableSpan<float3> r_span) const final
+  void materialize(const IndexMask mask, MutableSpan<float3> r_span) const final
   {
     VArray_For_BezierHandle::materialize_internal(mask, splines_, offsets_, is_right_, r_span);
   }
 
-  void materialize_to_uninitialized_impl(const IndexMask mask,
-                                         MutableSpan<float3> r_span) const final
+  void materialize_to_uninitialized(const IndexMask mask, MutableSpan<float3> r_span) const final
   {
     VArray_For_BezierHandle::materialize_to_uninitialized_internal(
         mask, splines_, offsets_, is_right_, r_span);
@@ -1097,7 +1083,7 @@ template<typename T> class BuiltinPointAttributeProvider : public BuiltinAttribu
   {
   }
 
-  GVArrayPtr try_get_for_read(const GeometryComponent &component) const override
+  GVArray try_get_for_read(const GeometryComponent &component) const override
   {
     const CurveEval *curve = get_curve_from_component_for_read(component);
     if (curve == nullptr) {
@@ -1110,7 +1096,7 @@ template<typename T> class BuiltinPointAttributeProvider : public BuiltinAttribu
 
     Span<SplinePtr> splines = curve->splines();
     if (splines.size() == 1) {
-      return std::make_unique<fn::GVArray_For_GSpan>(get_span_(*splines.first()));
+      return GVArray::ForSpan(get_span_(*splines.first()));
     }
 
     Array<int> offsets = curve->control_point_offsets();
@@ -1119,7 +1105,7 @@ template<typename T> class BuiltinPointAttributeProvider : public BuiltinAttribu
       spans[i] = get_span_(*splines[i]);
     }
 
-    return point_data_gvarray(spans, offsets);
+    return point_data_varray(spans, offsets);
   }
 
   WriteAttributeLookup try_get_for_write(GeometryComponent &component) const override
@@ -1144,8 +1130,7 @@ template<typename T> class BuiltinPointAttributeProvider : public BuiltinAttribu
 
     MutableSpan<SplinePtr> splines = curve->splines();
     if (splines.size() == 1) {
-      return {std::make_unique<fn::GVMutableArray_For_GMutableSpan>(
-                  get_mutable_span_(*splines.first())),
+      return {GVMutableArray::ForSpan(get_mutable_span_(*splines.first())),
               domain_,
               std::move(tag_modified_fn)};
     }
@@ -1156,7 +1141,7 @@ template<typename T> class BuiltinPointAttributeProvider : public BuiltinAttribu
       spans[i] = get_mutable_span_(*splines[i]);
     }
 
-    return {point_data_gvarray(spans, offsets), domain_, tag_modified_fn};
+    return {point_data_varray(spans, offsets), domain_, tag_modified_fn};
   }
 
   bool try_delete(GeometryComponent &component) const final
@@ -1248,10 +1233,8 @@ class PositionAttributeProvider final : public BuiltinPointAttributeProvider<flo
     };
 
     Array<int> offsets = curve->control_point_offsets();
-    return {std::make_unique<
-                fn::GVMutableArray_For_EmbeddedVMutableArray<float3,
-                                                             VMutableArray_For_SplinePosition>>(
-                offsets.last(), curve->splines(), std::move(offsets)),
+    return {VMutableArray<float3>::For<VMutableArray_For_SplinePosition>(curve->splines(),
+                                                                         std::move(offsets)),
             domain_,
             tag_modified_fn};
   }
@@ -1273,7 +1256,7 @@ class BezierHandleAttributeProvider : public BuiltinAttributeProvider {
   {
   }
 
-  GVArrayPtr try_get_for_read(const GeometryComponent &component) const override
+  GVArray try_get_for_read(const GeometryComponent &component) const override
   {
     const CurveEval *curve = get_curve_from_component_for_read(component);
     if (curve == nullptr) {
@@ -1285,8 +1268,8 @@ class BezierHandleAttributeProvider : public BuiltinAttributeProvider {
     }
 
     Array<int> offsets = curve->control_point_offsets();
-    return std::make_unique<fn::GVArray_For_EmbeddedVArray<float3, VArray_For_BezierHandle>>(
-        offsets.last(), curve->splines(), std::move(offsets), is_right_);
+    return VArray<float3>::For<VArray_For_BezierHandle>(
+        curve->splines(), std::move(offsets), is_right_);
   }
 
   WriteAttributeLookup try_get_for_write(GeometryComponent &component) const override
@@ -1303,12 +1286,10 @@ class BezierHandleAttributeProvider : public BuiltinAttributeProvider {
     auto tag_modified_fn = [curve]() { curve->mark_cache_invalid(); };
 
     Array<int> offsets = curve->control_point_offsets();
-    return {
-        std::make_unique<
-            fn::GVMutableArray_For_EmbeddedVMutableArray<float3, VMutableArray_For_BezierHandles>>(
-            offsets.last(), curve->splines(), std::move(offsets), is_right_),
-        domain_,
-        tag_modified_fn};
+    return {VMutableArray<float3>::For<VMutableArray_For_BezierHandles>(
+                curve->splines(), std::move(offsets), is_right_),
+            domain_,
+            tag_modified_fn};
   }
 
   bool try_delete(GeometryComponent &UNUSED(component)) const final
@@ -1387,7 +1368,7 @@ class DynamicPointAttributeProvider final : public DynamicAttributesProvider {
 
     /* First check for the simpler situation when we can return a simpler span virtual array. */
     if (spans.size() == 1) {
-      return {std::make_unique<GVArray_For_GSpan>(spans.first()), ATTR_DOMAIN_POINT};
+      return {GVArray::ForSpan(spans.first()), ATTR_DOMAIN_POINT};
     }
 
     ReadAttributeLookup attribute = {};
@@ -1399,7 +1380,7 @@ class DynamicPointAttributeProvider final : public DynamicAttributesProvider {
         data[i] = spans[i].typed<T>();
         BLI_assert(data[i].data() != nullptr);
       }
-      attribute = {point_data_gvarray(data, offsets), ATTR_DOMAIN_POINT};
+      attribute = {point_data_varray(data, offsets), ATTR_DOMAIN_POINT};
     });
     return attribute;
   }
@@ -1440,7 +1421,7 @@ class DynamicPointAttributeProvider final : public DynamicAttributesProvider {
 
     /* First check for the simpler situation when we can return a simpler span virtual array. */
     if (spans.size() == 1) {
-      return {std::make_unique<GVMutableArray_For_GMutableSpan>(spans.first()), ATTR_DOMAIN_POINT};
+      return {GVMutableArray::ForSpan(spans.first()), ATTR_DOMAIN_POINT};
     }
 
     WriteAttributeLookup attribute = {};
@@ -1452,7 +1433,7 @@ class DynamicPointAttributeProvider final : public DynamicAttributesProvider {
         data[i] = spans[i].typed<T>();
         BLI_assert(data[i].data() != nullptr);
       }
-      attribute = {point_data_gvarray(data, offsets), ATTR_DOMAIN_POINT};
+      attribute = {point_data_varray(data, offsets), ATTR_DOMAIN_POINT};
     });
     return attribute;
   }
diff --git a/source/blender/blenkernel/intern/geometry_component_instances.cc b/source/blender/blenkernel/intern/geometry_component_instances.cc
index 5fe77000519..047bceda4fe 100644
--- a/source/blender/blenkernel/intern/geometry_component_instances.cc
+++ b/source/blender/blenkernel/intern/geometry_component_instances.cc
@@ -389,25 +389,22 @@ class InstancePositionAttributeProvider final : public BuiltinAttributeProvider
   {
   }
 
-  GVArrayPtr try_get_for_read(const GeometryComponent &component) const final
+  GVArray try_get_for_read(const GeometryComponent &component) const final
   {
     const InstancesComponent &instances_component = static_cast<const InstancesComponent &>(
         component);
     Span<float4x4> transforms = instances_component.instance_transforms();
-    return std::make_unique<fn::GVArray_For_DerivedSpan<float4x4, float3, get_transform_position>>(
-        transforms);
+    return VArray<float3>::ForDerivedSpan<float4x4, get_transform_position>(transforms);
   }
 
   WriteAttributeLookup try_get_for_write(GeometryComponent &component) const final
   {
     InstancesComponent &instances_component = static_cast<InstancesComponent &>(component);
     MutableSpan<float4x4> transforms = instances_component.instance_transforms();
-    return {
-        std::make_unique<fn::GVMutableArray_For_DerivedSpan<float4x4,
-                                                            float3,
-                                                            get_transform_position,
-                                                            set_transform_position>>(transforms),
-        domain_};
+    return {VMutableArray<float3>::ForDerivedSpan<float4x4,
+                                                  get_transform_position,
+                                                  set_transform_position>(transforms),
+            domain_};
   }
 
   bool try_delete(GeometryComponent &UNUSED(component)) const final
@@ -435,13 +432,13 @@ class InstanceIDAttributeProvider final : public BuiltinAttributeProvider {
   {
   }
 
-  GVArrayPtr try_get_for_read(const GeometryComponent &component) const final
+  GVArray try_get_for_read(const GeometryComponent &component) const final
   {
     const InstancesComponent &instances = static_cast<const InstancesComponent &>(component);
     if (instances.instance_ids().is_empty()) {
       return {};
     }
-    return std::make_unique<fn::GVArray_For_Span<int>>(instances.instance_ids());
+    return VArray<int>::ForSpan(instances.instance_ids());
   }
 
   WriteAttributeLookup try_get_for_write(GeometryComponent &component) const final
@@ -450,8 +447,7 @@ class InstanceIDAttributeProvider final : public BuiltinAttributeProvider {
     if (instances.instance_ids().is_empty()) {
       return {};
     }
-    return {std::make_unique<fn::GVMutableArray_For_MutableSpan<int>>(instances.instance_ids()),
-            domain_};
+    return {VMutableArray<int>::ForSpan(instances.instance_ids()), domain_};
   }
 
   bool try_delete(GeometryComponent &component) const final
@@ -477,8 +473,8 @@ class InstanceIDAttributeProvider final : public BuiltinAttributeProvider {
         break;
       }
       case AttributeInit::Type::VArray: {
-        const GVArray *varray = static_cast<const AttributeInitVArray &>(initializer).varray;
-        varray->materialize_to_uninitialized(IndexRange(varray->size()), ids.data());
+        const GVArray &varray = static_cast<const AttributeInitVArray &>(initializer).varray;
+        varray.materialize_to_uninitialized(varray.index_range(), ids.data());
         break;
       }
       case AttributeInit::Type::MoveArray: {
diff --git a/source/blender/blenkernel/intern/geometry_component_mesh.cc b/source/blender/blenkernel/intern/geometry_component_mesh.cc
index c3e39c0b2cb..86a52b420b6 100644
--- a/source/blender/blenkernel/intern/geometry_component_mesh.cc
+++ b/source/blender/blenkernel/intern/geometry_component_mesh.cc
@@ -32,8 +32,6 @@
 /* Can't include BKE_object_deform.h right now, due to an enum forward declaration. */
 extern "C" MDeformVert *BKE_object_defgroup_data_create(ID *id);
 
-using blender::fn::GVArray;
-
 /* -------------------------------------------------------------------- */
 /** \name Geometry Component Implementation
  * \{ */
@@ -203,17 +201,17 @@ void adapt_mesh_domain_corner_to_point_impl(const Mesh &mesh,
   }
 }
 
-static GVArrayPtr adapt_mesh_domain_corner_to_point(const Mesh &mesh, GVArrayPtr varray)
+static GVArray adapt_mesh_domain_corner_to_point(const Mesh &mesh, const GVArray &varray)
 {
-  GVArrayPtr new_varray;
-  attribute_math::convert_to_static_type(varray->type(), [&](auto dummy) {
+  GVArray new_varray;
+  attribute_math::convert_to_static_type(varray.type(), [&](auto dummy) {
     using T = decltype(dummy);
     if constexpr (!std::is_void_v<attribute_math::DefaultMixer<T>>) {
       /* We compute all interpolated values at once, because for this interpolation, one has to
        * iterate over all loops anyway. */
       Array<T> values(mesh.totvert);
-      adapt_mesh_domain_corner_to_point_impl<T>(mesh, varray->typed<T>(), values);
-      new_varray = std::make_unique<fn::GVArray_For_ArrayContainer<Array<T>>>(std::move(values));
+      adapt_mesh_domain_corner_to_point_impl<T>(mesh, varray.typed<T>(), values);
+      new_varray = VArray<T>::ForContainer(std::move(values));
     }
   });
   return new_varray;
@@ -239,14 +237,14 @@ static void adapt_mesh_domain_point_to_corner_impl(const Mesh &mesh,
   }
 }
 
-static GVArrayPtr adapt_mesh_domain_point_to_corner(const Mesh &mesh, GVArrayPtr varray)
+static GVArray adapt_mesh_domain_point_to_corner(const Mesh &mesh, const GVArray &varray)
 {
-  GVArrayPtr new_varray;
-  attribute_math::convert_to_static_type(varray->type(), [&](auto dummy) {
+  GVArray new_varray;
+  attribute_math::convert_to_static_type(varray.type(), [&](auto dummy) {
     using T = decltype(dummy);
     Array<T> values(mesh.totloop);
-    adapt_mesh_domain_point_to_corner_impl<T>(mesh, varray->typed<T>(), values);
-    new_varray = std::make_unique<fn::GVArray_For_ArrayContainer<Array<T>>>(std::move(values));
+    adapt_mesh_domain_point_to_corner_impl<T>(mesh, varray.typed<T>(), values);
+    new_varray = VArray<T>::ForContainer(std::move(values));
   });
   return new_varray;
 }
@@ -295,15 +293,15 @@ void adapt_mesh_domain_corner_to_face_impl(const Mesh &mesh,
   }
 }
 
-static GVArrayPtr adapt_mesh_domain_corner_to_face(const Mesh &mesh, GVArrayPtr varray)
+static GVArray adapt_mesh_domain_corner_to_face(const Mesh &mesh, const GVArray &varray)
 {
-  GVArrayPtr new_varray;
-  attribute_math::convert_to_static_type(varray->type(), [&](auto dummy) {
+  GVArray new_varray;
+  attribute_math::convert_to_static_type(varray.type(), [&](auto dummy) {
     using T = decltype(dummy);
     if constexpr (!std::is_void_v<attribute_math::DefaultMixer<T>>) {
       Array<T> values(mesh.totpoly);
-      adapt_mesh_domain_corner_to_face_impl<T>(mesh, varray->typed<T>(), values);
-      new_varray = std::make_unique<fn::GVArray_For_ArrayContainer<Array<T>>>(std::move(values));
+      adapt_mesh_domain_corner_to_face_impl<T>(mesh, varray.typed<T>(), values);
+      new_varray = VArray<T>::ForContainer(std::move(values));
     }
   });
   return new_varray;
@@ -368,15 +366,15 @@ void adapt_mesh_domain_corner_to_edge_impl(const Mesh &mesh,
   }
 }
 
-static GVArrayPtr adapt_mesh_domain_corner_to_edge(const Mesh &mesh, GVArrayPtr varray)
+static GVArray adapt_mesh_domain_corner_to_edge(const Mesh &mesh, const GVArray &varray)
 {
-  GVArrayPtr new_varray;
-  attribute_math::convert_to_static_type(varray->type(), [&](auto dummy) {
+  GVArray new_varray;
+  attribute_math::convert_to_static_type(varray.type(), [&](auto dummy) {
     using T = decltype(dummy);
     if constexpr (!std::is_void_v<attribute_math::DefaultMixer<T>>) {
       Array<T> values(mesh.totedge);
-      adapt_mesh_domain_corner_to_edge_impl<T>(mesh, varray->typed<T>(), values);
-      new_varray = std::make_unique<fn::GVArray_For_ArrayContainer<Array<T>>>(std::move(values));
+      adapt_mesh_domain_corner_to_edge_impl<T>(mesh, varray.typed<T>(), values);
+      new_varray = VArray<T>::ForContainer(std::move(values));
     }
   });
   return new_varray;
@@ -424,15 +422,15 @@ void adapt_mesh_domain_face_to_point_impl(const Mesh &mesh,
   }
 }
 
-static GVArrayPtr adapt_mesh_domain_face_to_point(const Mesh &mesh, GVArrayPtr varray)
+static GVArray adapt_mesh_domain_face_to_point(const Mesh &mesh, const GVArray &varray)
 {
-  GVArrayPtr new_varray;
-  attribute_math::convert_to_static_type(varray->type(), [&](auto dummy) {
+  GVArray new_varray;
+  attribute_math::convert_to_static_type(varray.type(), [&](auto dummy) {
     using T = decltype(dummy);
     if constexpr (!std::is_void_v<attribute_math::DefaultMixer<T>>) {
       Array<T> values(mesh.totvert);
-      adapt_mesh_domain_face_to_point_impl<T>(mesh, varray->typed<T>(), values);
-      new_varray = std::make_unique<fn::GVArray_For_ArrayContainer<Array<T>>>(std::move(values));
+      adapt_mesh_domain_face_to_point_impl<T>(mesh, varray.typed<T>(), values);
+      new_varray = VArray<T>::ForContainer(std::move(values));
     }
   });
   return new_varray;
@@ -453,15 +451,15 @@ void adapt_mesh_domain_face_to_corner_impl(const Mesh &mesh,
   }
 }
 
-static GVArrayPtr adapt_mesh_domain_face_to_corner(const Mesh &mesh, GVArrayPtr varray)
+static GVArray adapt_mesh_domain_face_to_corner(const Mesh &mesh, const GVArray &varray)
 {
-  GVArrayPtr new_varray;
-  attribute_math::convert_to_static_type(varray->type(), [&](auto dummy) {
+  GVArray new_varray;
+  attribute_math::convert_to_static_type(varray.type(), [&](auto dummy) {
     using T = decltype(dummy);
     if constexpr (!std::is_void_v<attribute_math::DefaultMixer<T>>) {
       Array<T> values(mesh.totloop);
-      adapt_mesh_domain_face_to_corner_impl<T>(mesh, varray->typed<T>(), values);
-      new_varray = std::make_unique<fn::GVArray_For_ArrayContainer<Array<T>>>(std::move(values));
+      adapt_mesh_domain_face_to_corner_impl<T>(mesh, varray.typed<T>(), values);
+      new_varray = VArray<T>::ForContainer(std::move(values));
     }
   });
   return new_varray;
@@ -507,15 +505,15 @@ void adapt_mesh_domain_face_to_edge_impl(const Mesh &mesh,
   }
 }
 
-static GVArrayPtr adapt_mesh_domain_face_to_edge(const Mesh &mesh, GVArrayPtr varray)
+static GVArray adapt_mesh_domain_face_to_edge(const Mesh &mesh, const GVArray &varray)
 {
-  GVArrayPtr new_varray;
-  attribute_math::convert_to_static_type(varray->type(), [&](auto dummy) {
+  GVArray new_varray;
+  attribute_math::convert_to_static_type(varray.type(), [&](auto dummy) {
     using T = decltype(dummy);
     if constexpr (!std::is_void_v<attribute_math::DefaultMixer<T>>) {
       Array<T> values(mesh.totedge);
-      adapt_mesh_domain_face_to_edge_impl<T>(mesh, varray->typed<T>(), values);
-      new_varray = std::make_unique<fn::GVArray_For_ArrayContainer<Array<T>>>(std::move(values));
+      adapt_mesh_domain_face_to_edge_impl<T>(mesh, varray.typed<T>(), values);
+      new_varray = VArray<T>::ForContainer(std::move(values));
     }
   });
   return new_varray;
@@ -567,15 +565,15 @@ void adapt_mesh_domain_point_to_face_impl(const Mesh &mesh,
   }
 }
 
-static GVArrayPtr adapt_mesh_domain_point_to_face(const Mesh &mesh, GVArrayPtr varray)
+static GVArray adapt_mesh_domain_point_to_face(const Mesh &mesh, const GVArray &varray)
 {
-  GVArrayPtr new_varray;
-  attribute_math::convert_to_static_type(varray->type(), [&](auto dummy) {
+  GVArray new_varray;
+  attribute_math::convert_to_static_type(varray.type(), [&](auto dummy) {
     using T = decltype(dummy);
     if constexpr (!std::is_void_v<attribute_math::DefaultMixer<T>>) {
       Array<T> values(mesh.totpoly);
-      adapt_mesh_domain_point_to_face_impl<T>(mesh, varray->typed<T>(), values);
-      new_varray = std::make_unique<fn::GVArray_For_ArrayContainer<Array<T>>>(std::move(values));
+      adapt_mesh_domain_point_to_face_impl<T>(mesh, varray.typed<T>(), values);
+      new_varray = VArray<T>::ForContainer(std::move(values));
     }
   });
   return new_varray;
@@ -617,15 +615,15 @@ void adapt_mesh_domain_point_to_edge_impl(const Mesh &mesh,
   }
 }
 
-static GVArrayPtr adapt_mesh_domain_point_to_edge(const Mesh &mesh, GVArrayPtr varray)
+static GVArray adapt_mesh_domain_point_to_edge(const Mesh &mesh, const GVArray &varray)
 {
-  GVArrayPtr new_varray;
-  attribute_math::convert_to_static_type(varray->type(), [&](auto dummy) {
+  GVArray new_varray;
+  attribute_math::convert_to_static_type(varray.type(), [&](auto dummy) {
     using T = decltype(dummy);
     if constexpr (!std::is_void_v<attribute_math::DefaultMixer<T>>) {
       Array<T> values(mesh.totedge);
-      adapt_mesh_domain_point_to_edge_impl<T>(mesh, varray->typed<T>(), values);
-      new_varray = std::make_unique<fn::GVArray_For_ArrayContainer<Array<T>>>(std::move(values));
+      adapt_mesh_domain_point_to_edge_impl<T>(mesh, varray.typed<T>(), values);
+      new_varray = VArray<T>::ForContainer(std::move(values));
     }
   });
   return new_varray;
@@ -678,15 +676,15 @@ void adapt_mesh_domain_edge_to_corner_impl(const Mesh &mesh,
   }
 }
 
-static GVArrayPtr adapt_mesh_domain_edge_to_corner(const Mesh &mesh, GVArrayPtr varray)
+static GVArray adapt_mesh_domain_edge_to_corner(const Mesh &mesh, const GVArray &varray)
 {
-  GVArrayPtr new_varray;
-  attribute_math::convert_to_static_type(varray->type(), [&](auto dummy) {
+  GVArray new_varray;
+  attribute_math::convert_to_static_type(varray.type(), [&](auto dummy) {
     using T = decltype(dummy);
     if constexpr (!std::is_void_v<attribute_math::DefaultMixer<T>>) {
       Array<T> values(mesh.totloop);
-      adapt_mesh_domain_edge_to_corner_impl<T>(mesh, varray->typed<T>(), values);
-      new_varray = std::make_unique<fn::GVArray_For_ArrayContainer<Array<T>>>(std::move(values));
+      adapt_mesh_domain_edge_to_corner_impl<T>(mesh, varray.typed<T>(), values);
+      new_varray = VArray<T>::ForContainer(std::move(values));
     }
   });
   return new_varray;
@@ -728,15 +726,15 @@ void adapt_mesh_domain_edge_to_point_impl(const Mesh &mesh,
   }
 }
 
-static GVArrayPtr adapt_mesh_domain_edge_to_point(const Mesh &mesh, GVArrayPtr varray)
+static GVArray adapt_mesh_domain_edge_to_point(const Mesh &mesh, const GVArray &varray)
 {
-  GVArrayPtr new_varray;
-  attribute_math::convert_to_static_type(varray->type(), [&](auto dummy) {
+  GVArray new_varray;
+  attribute_math::convert_to_static_type(varray.type(), [&](auto dummy) {
     using T = decltype(dummy);
     if constexpr (!std::is_void_v<attribute_math::DefaultMixer<T>>) {
       Array<T> values(mesh.totvert);
-      adapt_mesh_domain_edge_to_point_impl<T>(mesh, varray->typed<T>(), values);
-      new_varray = std::make_unique<fn::GVArray_For_ArrayContainer<Array<T>>>(std::move(values));
+      adapt_mesh_domain_edge_to_point_impl<T>(mesh, varray.typed<T>(), values);
+      new_varray = VArray<T>::ForContainer(std::move(values));
     }
   });
   return new_varray;
@@ -788,15 +786,15 @@ void adapt_mesh_domain_edge_to_face_impl(const Mesh &mesh,
   }
 }
 
-static GVArrayPtr adapt_mesh_domain_edge_to_face(const Mesh &mesh, GVArrayPtr varray)
+static GVArray adapt_mesh_domain_edge_to_face(const Mesh &mesh, const GVArray &varray)
 {
-  GVArrayPtr new_varray;
-  attribute_math::convert_to_static_type(varray->type(), [&](auto dummy) {
+  GVArray new_varray;
+  attribute_math::convert_to_static_type(varray.type(), [&](auto dummy) {
     using T = decltype(dummy);
     if constexpr (!std::is_void_v<attribute_math::DefaultMixer<T>>) {
       Array<T> values(mesh.totpoly);
-      adapt_mesh_domain_edge_to_face_impl<T>(mesh, varray->typed<T>(), values);
-      new_varray = std::make_unique<fn::GVArray_For_ArrayContainer<Array<T>>>(std::move(values));
+      adapt_mesh_domain_edge_to_face_impl<T>(mesh, varray.typed<T>(), values);
+      new_varray = VArray<T>::ForContainer(std::move(values));
     }
   });
   return new_varray;
@@ -804,15 +802,15 @@ static GVArrayPtr adapt_mesh_domain_edge_to_face(const Mesh &mesh, GVArrayPtr va
 
 }  // namespace blender::bke
 
-blender::fn::GVArrayPtr MeshComponent::attribute_try_adapt_domain(
-    blender::fn::GVArrayPtr varray,
+blender::fn::GVArray MeshComponent::attribute_try_adapt_domain_impl(
+    const blender::fn::GVArray &varray,
     const AttributeDomain from_domain,
     const AttributeDomain to_domain) const
 {
   if (!varray) {
     return {};
   }
-  if (varray->size() == 0) {
+  if (varray.size() == 0) {
     return {};
   }
   if (from_domain == to_domain) {
@@ -823,11 +821,11 @@ blender::fn::GVArrayPtr MeshComponent::attribute_try_adapt_domain(
     case ATTR_DOMAIN_CORNER: {
       switch (to_domain) {
         case ATTR_DOMAIN_POINT:
-          return blender::bke::adapt_mesh_domain_corner_to_point(*mesh_, std::move(varray));
+          return blender::bke::adapt_mesh_domain_corner_to_point(*mesh_, varray);
         case ATTR_DOMAIN_FACE:
-          return blender::bke::adapt_mesh_domain_corner_to_face(*mesh_, std::move(varray));
+          return blender::bke::adapt_mesh_domain_corner_to_face(*mesh_, varray);
         case ATTR_DOMAIN_EDGE:
-          return blender::bke::adapt_mesh_domain_corner_to_edge(*mesh_, std::move(varray));
+          return blender::bke::adapt_mesh_domain_corner_to_edge(*mesh_, varray);
         default:
           break;
       }
@@ -836,11 +834,11 @@ blender::fn::GVArrayPtr MeshComponent::attribute_try_adapt_domain(
     case ATTR_DOMAIN_POINT: {
       switch (to_domain) {
         case ATTR_DOMAIN_CORNER:
-          return blender::bke::adapt_mesh_domain_point_to_corner(*mesh_, std::move(varray));
+          return blender::bke::adapt_mesh_domain_point_to_corner(*mesh_, varray);
         case ATTR_DOMAIN_FACE:
-          return blender::bke::adapt_mesh_domain_point_to_face(*mesh_, std::move(varray));
+          return blender::bke::adapt_mesh_domain_point_to_face(*mesh_, varray);
         case ATTR_DOMAIN_EDGE:
-          return blender::bke::adapt_mesh_domain_point_to_edge(*mesh_, std::move(varray));
+          return blender::bke::adapt_mesh_domain_point_to_edge(*mesh_, varray);
         default:
           break;
       }
@@ -849,11 +847,11 @@ blender::fn::GVArrayPtr MeshComponent::attribute_try_adapt_domain(
     case ATTR_DOMAIN_FACE: {
       switch (to_domain) {
         case ATTR_DOMAIN_POINT:
-          return blender::bke::adapt_mesh_domain_face_to_point(*mesh_, std::move(varray));
+          return blender::bke::adapt_mesh_domain_face_to_point(*mesh_, varray);
         case ATTR_DOMAIN_CORNER:
-          return blender::bke::adapt_mesh_domain_face_to_corner(*mesh_, std::move(varray));
+          return blender::bke::adapt_mesh_domain_face_to_corner(*mesh_, varray);
         case ATTR_DOMAIN_EDGE:
-          return blender::bke::adapt_mesh_domain_face_to_edge(*mesh_, std::move(varray));
+          return blender::bke::adapt_mesh_domain_face_to_edge(*mesh_, varray);
         default:
           break;
       }
@@ -862,11 +860,11 @@ blender::fn::GVArrayPtr MeshComponent::attribute_try_adapt_domain(
     case ATTR_DOMAIN_EDGE: {
       switch (to_domain) {
         case ATTR_DOMAIN_CORNER:
-          return blender::bke::adapt_mesh_domain_edge_to_corner(*mesh_, std::move(varray));
+          return blender::bke::adapt_mesh_domain_edge_to_corner(*mesh_, varray);
         case ATTR_DOMAIN_POINT:
-          return blender::bke::adapt_mesh_domain_edge_to_point(*mesh_, std::move(varray));
+          return blender::bke::adapt_mesh_domain_edge_to_point(*mesh_, varray);
         case ATTR_DOMAIN_FACE:
-          return blender::bke::adapt_mesh_domain_edge_to_face(*mesh_, std::move(varray));
+          return blender::bke::adapt_mesh_domain_edge_to_face(*mesh_, varray);
         default:
           break;
       }
@@ -896,9 +894,9 @@ static const Mesh *get_mesh_from_component_for_read(const GeometryComponent &com
 namespace blender::bke {
 
 template<typename StructT, typename ElemT, ElemT (*GetFunc)(const StructT &)>
-static GVArrayPtr make_derived_read_attribute(const void *data, const int domain_size)
+static GVArray make_derived_read_attribute(const void *data, const int domain_size)
 {
-  return std::make_unique<fn::GVArray_For_DerivedSpan<StructT, ElemT, GetFunc>>(
+  return VArray<ElemT>::template ForDerivedSpan<StructT, GetFunc>(
       Span<StructT>((const StructT *)data, domain_size));
 }
 
@@ -906,23 +904,22 @@ template<typename StructT,
          typename ElemT,
          ElemT (*GetFunc)(const StructT &),
          void (*SetFunc)(StructT &, ElemT)>
-static GVMutableArrayPtr make_derived_write_attribute(void *data, const int domain_size)
+static GVMutableArray make_derived_write_attribute(void *data, const int domain_size)
 {
-  return std::make_unique<fn::GVMutableArray_For_DerivedSpan<StructT, ElemT, GetFunc, SetFunc>>(
+  return VMutableArray<ElemT>::template ForDerivedSpan<StructT, GetFunc, SetFunc>(
       MutableSpan<StructT>((StructT *)data, domain_size));
 }
 
 template<typename T>
-static GVArrayPtr make_array_read_attribute(const void *data, const int domain_size)
+static GVArray make_array_read_attribute(const void *data, const int domain_size)
 {
-  return std::make_unique<fn::GVArray_For_Span<T>>(Span<T>((const T *)data, domain_size));
+  return VArray<T>::ForSpan(Span<T>((const T *)data, domain_size));
 }
 
 template<typename T>
-static GVMutableArrayPtr make_array_write_attribute(void *data, const int domain_size)
+static GVMutableArray make_array_write_attribute(void *data, const int domain_size)
 {
-  return std::make_unique<fn::GVMutableArray_For_MutableSpan<T>>(
-      MutableSpan<T>((T *)data, domain_size));
+  return VMutableArray<T>::ForSpan(MutableSpan<T>((T *)data, domain_size));
 }
 
 static float3 get_vertex_position(const MVert &vert)
@@ -999,23 +996,23 @@ static void set_crease(MEdge &edge, float value)
   edge.crease = round_fl_to_uchar_clamp(value * 255.0f);
 }
 
-class VMutableArray_For_VertexWeights final : public VMutableArray<float> {
+class VMutableArray_For_VertexWeights final : public VMutableArrayImpl<float> {
  private:
   MDeformVert *dverts_;
   const int dvert_index_;
 
  public:
   VMutableArray_For_VertexWeights(MDeformVert *dverts, const int totvert, const int dvert_index)
-      : VMutableArray<float>(totvert), dverts_(dverts), dvert_index_(dvert_index)
+      : VMutableArrayImpl<float>(totvert), dverts_(dverts), dvert_index_(dvert_index)
   {
   }
 
-  float get_impl(const int64_t index) const override
+  float get(const int64_t index) const override
   {
     return get_internal(dverts_, dvert_index_, index);
   }
 
-  void set_impl(const int64_t index, const float value) override
+  void set(const int64_t index, const float value) override
   {
     MDeformWeight *weight = BKE_defvert_ensure_index(&dverts_[index], dvert_index_);
     weight->weight = value;
@@ -1036,18 +1033,18 @@ class VMutableArray_For_VertexWeights final : public VMutableArray<float> {
   }
 };
 
-class VArray_For_VertexWeights final : public VArray<float> {
+class VArray_For_VertexWeights final : public VArrayImpl<float> {
  private:
   const MDeformVert *dverts_;
   const int dvert_index_;
 
  public:
   VArray_For_VertexWeights(const MDeformVert *dverts, const int totvert, const int dvert_index)
-      : VArray<float>(totvert), dverts_(dverts), dvert_index_(dvert_index)
+      : VArrayImpl<float>(totvert), dverts_(dverts), dvert_index_(dvert_index)
   {
   }
 
-  float get_impl(const int64_t index) const override
+  float get(const int64_t index) const override
   {
     return VMutableArray_For_VertexWeights::get_internal(dverts_, dvert_index_, index);
   }
@@ -1078,12 +1075,10 @@ class VertexGroupsAttributeProvider final : public DynamicAttributesProvider {
     }
     if (mesh->dvert == nullptr) {
       static const float default_value = 0.0f;
-      return {std::make_unique<fn::GVArray_For_SingleValueRef>(
-                  CPPType::get<float>(), mesh->totvert, &default_value),
-              ATTR_DOMAIN_POINT};
+      return {VArray<float>::ForSingle(default_value, mesh->totvert), ATTR_DOMAIN_POINT};
     }
-    return {std::make_unique<fn::GVArray_For_EmbeddedVArray<float, VArray_For_VertexWeights>>(
-                mesh->totvert, mesh->dvert, mesh->totvert, vertex_group_index),
+    return {VArray<float>::For<VArray_For_VertexWeights>(
+                mesh->dvert, mesh->totvert, vertex_group_index),
             ATTR_DOMAIN_POINT};
   }
 
@@ -1114,11 +1109,9 @@ class VertexGroupsAttributeProvider final : public DynamicAttributesProvider {
       mesh->dvert = (MDeformVert *)CustomData_duplicate_referenced_layer(
           &mesh->vdata, CD_MDEFORMVERT, mesh->totvert);
     }
-    return {
-        std::make_unique<
-            fn::GVMutableArray_For_EmbeddedVMutableArray<float, VMutableArray_For_VertexWeights>>(
-            mesh->totvert, mesh->dvert, mesh->totvert, vertex_group_index),
-        ATTR_DOMAIN_POINT};
+    return {VMutableArray<float>::For<VMutableArray_For_VertexWeights>(
+                mesh->dvert, mesh->totvert, vertex_group_index),
+            ATTR_DOMAIN_POINT};
   }
 
   bool try_delete(GeometryComponent &component, const AttributeIDRef &attribute_id) const final
@@ -1184,7 +1177,7 @@ class NormalAttributeProvider final : public BuiltinAttributeProvider {
   {
   }
 
-  GVArrayPtr try_get_for_read(const GeometryComponent &component) const final
+  GVArray try_get_for_read(const GeometryComponent &component) const final
   {
     const MeshComponent &mesh_component = static_cast<const MeshComponent &>(component);
     const Mesh *mesh = mesh_component.get_for_read();
@@ -1197,8 +1190,7 @@ class NormalAttributeProvider final : public BuiltinAttributeProvider {
         CustomData_has_layer(&mesh->pdata, CD_NORMAL)) {
       const void *data = CustomData_get_layer(&mesh->pdata, CD_NORMAL);
 
-      return std::make_unique<fn::GVArray_For_Span<float3>>(
-          Span<float3>((const float3 *)data, mesh->totpoly));
+      return VArray<float3>::ForSpan(Span<float3>((const float3 *)data, mesh->totpoly));
     }
 
     Array<float3> normals(mesh->totpoly);
@@ -1207,7 +1199,7 @@ class NormalAttributeProvider final : public BuiltinAttributeProvider {
       BKE_mesh_calc_poly_normal(poly, &mesh->mloop[poly->loopstart], mesh->mvert, normals[i]);
     }
 
-    return std::make_unique<fn::GVArray_For_ArrayContainer<Array<float3>>>(std::move(normals));
+    return VArray<float3>::ForContainer(std::move(normals));
   }
 
   WriteAttributeLookup try_get_for_write(GeometryComponent &UNUSED(component)) const final
diff --git a/source/blender/blenkernel/intern/geometry_component_pointcloud.cc b/source/blender/blenkernel/intern/geometry_component_pointcloud.cc
index dfb65a9078d..c6a1c61a96d 100644
--- a/source/blender/blenkernel/intern/geometry_component_pointcloud.cc
+++ b/source/blender/blenkernel/intern/geometry_component_pointcloud.cc
@@ -141,16 +141,15 @@ int PointCloudComponent::attribute_domain_size(const AttributeDomain domain) con
 namespace blender::bke {
 
 template<typename T>
-static GVArrayPtr make_array_read_attribute(const void *data, const int domain_size)
+static GVArray make_array_read_attribute(const void *data, const int domain_size)
 {
-  return std::make_unique<fn::GVArray_For_Span<T>>(Span<T>((const T *)data, domain_size));
+  return VArray<T>::ForSpan(Span<T>((const T *)data, domain_size));
 }
 
 template<typename T>
-static GVMutableArrayPtr make_array_write_attribute(void *data, const int domain_size)
+static GVMutableArray make_array_write_attribute(void *data, const int domain_size)
 {
-  return std::make_unique<fn::GVMutableArray_For_MutableSpan<T>>(
-      MutableSpan<T>((T *)data, domain_size));
+  return VMutableArray<T>::ForSpan(MutableSpan<T>((T *)data, domain_size));
 }
 
 /**
diff --git a/source/blender/blenkernel/intern/geometry_set_instances.cc b/source/blender/blenkernel/intern/geometry_set_instances.cc
index 4133841ba49..c73da7d9659 100644
--- a/source/blender/blenkernel/intern/geometry_set_instances.cc
+++ b/source/blender/blenkernel/intern/geometry_set_instances.cc
@@ -360,12 +360,12 @@ static void join_attributes(Span<GeometryInstanceGroup> set_groups,
     result.attribute_try_create(
         entry.key, domain_output, data_type_output, AttributeInitDefault());
     WriteAttributeLookup write_attribute = result.attribute_try_get_for_write(attribute_id);
-    if (!write_attribute || &write_attribute.varray->type() != cpp_type ||
+    if (!write_attribute || &write_attribute.varray.type() != cpp_type ||
         write_attribute.domain != domain_output) {
       continue;
     }
 
-    fn::GVMutableArray_GSpan dst_span{*write_attribute.varray};
+    fn::GVMutableArray_GSpan dst_span{write_attribute.varray};
 
     int offset = 0;
     for (const GeometryInstanceGroup &set_group : set_groups) {
@@ -377,11 +377,11 @@ static void join_attributes(Span<GeometryInstanceGroup> set_groups,
           if (domain_size == 0) {
             continue; /* Domain size is 0, so no need to increment the offset. */
           }
-          GVArrayPtr source_attribute = component.attribute_try_get_for_read(
+          GVArray source_attribute = component.attribute_try_get_for_read(
               attribute_id, domain_output, data_type_output);
 
           if (source_attribute) {
-            fn::GVArray_GSpan src_span{*source_attribute};
+            fn::GVArray_GSpan src_span{source_attribute};
             const void *src_buffer = src_span.data();
             for (const int UNUSED(i) : set_group.transforms.index_range()) {
               void *dst_buffer = dst_span[offset];
diff --git a/source/blender/blenkernel/intern/mesh_sample.cc b/source/blender/blenkernel/intern/mesh_sample.cc
index 2274d34f0f1..a046cc68bf2 100644
--- a/source/blender/blenkernel/intern/mesh_sample.cc
+++ b/source/blender/blenkernel/intern/mesh_sample.cc
@@ -269,7 +269,7 @@ void MeshAttributeInterpolator::sample_attribute(const ReadAttributeLookup &src_
                                                  eAttributeMapMode mode)
 {
   if (src_attribute && dst_attribute) {
-    this->sample_data(*src_attribute.varray, src_attribute.domain, mode, dst_attribute.as_span());
+    this->sample_data(src_attribute.varray, src_attribute.domain, mode, dst_attribute.as_span());
   }
 }
 
diff --git a/source/blender/blenkernel/intern/spline_base.cc b/source/blender/blenkernel/intern/spline_base.cc
index c2c9d178171..52bbd2bec57 100644
--- a/source/blender/blenkernel/intern/spline_base.cc
+++ b/source/blender/blenkernel/intern/spline_base.cc
@@ -30,14 +30,12 @@ using blender::float3;
 using blender::IndexRange;
 using blender::MutableSpan;
 using blender::Span;
+using blender::VArray;
 using blender::attribute_math::convert_to_static_type;
 using blender::bke::AttributeIDRef;
 using blender::fn::GMutableSpan;
 using blender::fn::GSpan;
 using blender::fn::GVArray;
-using blender::fn::GVArray_For_GSpan;
-using blender::fn::GVArray_Typed;
-using blender::fn::GVArrayPtr;
 
 Spline::Type Spline::type() const
 {
@@ -416,7 +414,7 @@ Span<float3> Spline::evaluated_normals() const
   }
 
   /* Rotate the generated normals with the interpolated tilt data. */
-  GVArray_Typed<float> tilts = this->interpolate_to_evaluated(this->tilts());
+  VArray<float> tilts = this->interpolate_to_evaluated(this->tilts());
   for (const int i : normals.index_range()) {
     normals[i] = rotate_direction_around_axis(normals[i], tangents[i], tilts[i]);
   }
@@ -529,9 +527,9 @@ void Spline::bounds_min_max(float3 &min, float3 &max, const bool use_evaluated)
   }
 }
 
-GVArrayPtr Spline::interpolate_to_evaluated(GSpan data) const
+GVArray Spline::interpolate_to_evaluated(GSpan data) const
 {
-  return this->interpolate_to_evaluated(GVArray_For_GSpan(data));
+  return this->interpolate_to_evaluated(GVArray::ForSpan(data));
 }
 
 /**
@@ -547,7 +545,7 @@ void Spline::sample_with_index_factors(const GVArray &src,
 
   blender::attribute_math::convert_to_static_type(src.type(), [&](auto dummy) {
     using T = decltype(dummy);
-    const GVArray_Typed<T> src_typed = src.typed<T>();
+    const VArray<T> src_typed = src.typed<T>();
     MutableSpan<T> dst_typed = dst.typed<T>();
     if (src.size() == 1) {
       dst_typed.fill(src_typed[0]);
diff --git a/source/blender/blenkernel/intern/spline_bezier.cc b/source/blender/blenkernel/intern/spline_bezier.cc
index 166fe0f5464..28db3da65d0 100644
--- a/source/blender/blenkernel/intern/spline_bezier.cc
+++ b/source/blender/blenkernel/intern/spline_bezier.cc
@@ -25,9 +25,8 @@ using blender::float3;
 using blender::IndexRange;
 using blender::MutableSpan;
 using blender::Span;
+using blender::VArray;
 using blender::fn::GVArray;
-using blender::fn::GVArray_For_ArrayContainer;
-using blender::fn::GVArrayPtr;
 
 void BezierSpline::copy_settings(Spline &dst) const
 {
@@ -702,26 +701,26 @@ static void interpolate_to_evaluated_impl(const BezierSpline &spline,
   }
 }
 
-GVArrayPtr BezierSpline::interpolate_to_evaluated(const GVArray &src) const
+GVArray BezierSpline::interpolate_to_evaluated(const GVArray &src) const
 {
   BLI_assert(src.size() == this->size());
 
   if (src.is_single()) {
-    return src.shallow_copy();
+    return src;
   }
 
   const int eval_size = this->evaluated_points_size();
   if (eval_size == 1) {
-    return src.shallow_copy();
+    return src;
   }
 
-  GVArrayPtr new_varray;
+  GVArray new_varray;
   blender::attribute_math::convert_to_static_type(src.type(), [&](auto dummy) {
     using T = decltype(dummy);
     if constexpr (!std::is_void_v<blender::attribute_math::DefaultMixer<T>>) {
       Array<T> values(eval_size);
       interpolate_to_evaluated_impl<T>(*this, src.typed<T>(), values);
-      new_varray = std::make_unique<GVArray_For_ArrayContainer<Array<T>>>(std::move(values));
+      new_varray = VArray<T>::ForContainer(std::move(values));
     }
   });
 
diff --git a/source/blender/blenkernel/intern/spline_nurbs.cc b/source/blender/blenkernel/intern/spline_nurbs.cc
index 6d30d8ba916..7fa332a0330 100644
--- a/source/blender/blenkernel/intern/spline_nurbs.cc
+++ b/source/blender/blenkernel/intern/spline_nurbs.cc
@@ -26,10 +26,8 @@ using blender::float3;
 using blender::IndexRange;
 using blender::MutableSpan;
 using blender::Span;
+using blender::VArray;
 using blender::fn::GVArray;
-using blender::fn::GVArray_For_ArrayContainer;
-using blender::fn::GVArray_Typed;
-using blender::fn::GVArrayPtr;
 
 void NURBSpline::copy_settings(Spline &dst) const
 {
@@ -410,23 +408,23 @@ void interpolate_to_evaluated_impl(Span<NURBSpline::BasisCache> weights,
   mixer.finalize();
 }
 
-GVArrayPtr NURBSpline::interpolate_to_evaluated(const GVArray &src) const
+GVArray NURBSpline::interpolate_to_evaluated(const GVArray &src) const
 {
   BLI_assert(src.size() == this->size());
 
   if (src.is_single()) {
-    return src.shallow_copy();
+    return src;
   }
 
   Span<BasisCache> basis_cache = this->calculate_basis_cache();
 
-  GVArrayPtr new_varray;
+  GVArray new_varray;
   blender::attribute_math::convert_to_static_type(src.type(), [&](auto dummy) {
     using T = decltype(dummy);
     if constexpr (!std::is_void_v<blender::attribute_math::DefaultMixer<T>>) {
       Array<T> values(this->evaluated_points_size());
       interpolate_to_evaluated_impl<T>(basis_cache, src.typed<T>(), values);
-      new_varray = std::make_unique<GVArray_For_ArrayContainer<Array<T>>>(std::move(values));
+      new_varray = VArray<T>::ForContainer(std::move(values));
     }
   });
 
@@ -448,8 +446,8 @@ Span<float3> NURBSpline::evaluated_positions() const
   evaluated_position_cache_.resize(eval_size);
 
   /* TODO: Avoid copying the evaluated data from the temporary array. */
-  GVArray_Typed<float3> evaluated = Spline::interpolate_to_evaluated(positions_.as_span());
-  evaluated->materialize(evaluated_position_cache_);
+  VArray<float3> evaluated = Spline::interpolate_to_evaluated(positions_.as_span());
+  evaluated.materialize(evaluated_position_cache_);
 
   position_cache_dirty_ = false;
   return evaluated_position_cache_;
diff --git a/source/blender/blenkernel/intern/spline_poly.cc b/source/blender/blenkernel/intern/spline_poly.cc
index 338b5d0ac9e..d495c977285 100644
--- a/source/blender/blenkernel/intern/spline_poly.cc
+++ b/source/blender/blenkernel/intern/spline_poly.cc
@@ -23,7 +23,6 @@ using blender::float3;
 using blender::MutableSpan;
 using blender::Span;
 using blender::fn::GVArray;
-using blender::fn::GVArrayPtr;
 
 void PolySpline::copy_settings(Spline &UNUSED(dst)) const
 {
@@ -122,9 +121,8 @@ Span<float3> PolySpline::evaluated_positions() const
  * the original data. Therefore the lifetime of the returned virtual array must not be longer than
  * the source data.
  */
-GVArrayPtr PolySpline::interpolate_to_evaluated(const GVArray &src) const
+GVArray PolySpline::interpolate_to_evaluated(const GVArray &src) const
 {
   BLI_assert(src.size() == this->size());
-
-  return src.shallow_copy();
+  return src;
 }