diff --git a/mesh_handle/abstract_element.hxx b/mesh_handle/abstract_element.hxx
index 9cbd5c7b5b..2c23172243 100644
--- a/mesh_handle/abstract_element.hxx
+++ b/mesh_handle/abstract_element.hxx
@@ -38,11 +38,6 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 
 namespace t8_mesh_handle
 {
-/* Forward declaration of the \ref mesh class of the handle.
- */
-template <template <typename> class... TCompetence>
-class mesh;
-
 /** 
  * Common interface of the mesh elements and the ghost elements of the \ref mesh handle.
  * An element without specified template parameters provides default implementations for basic functionality 
@@ -61,13 +56,13 @@ class mesh;
  *
  * \tparam TCompetence The competences you want to add to the default functionality of the element.
  */
-template <template <typename> class... TCompetence>
-class abstract_element: public TCompetence<abstract_element<TCompetence...>>... {
+template <typename mesh_class, template <typename> class... TCompetence>
+class abstract_element: public TCompetence<abstract_element<mesh_class, TCompetence...>>... {
  protected:
   using SelfType
-    = abstract_element<TCompetence...>;    /**< Type of the current class with all template parameters specified. */
-  using mesh_class = mesh<TCompetence...>; /**< Type of the mesh class the used. */
-  friend mesh_class; /**< Define mesh_class as friend to be able to access e.g. the constructor. */
+    = abstract_element<mesh_class,
+                       TCompetence...>; /**< Type of the current class with all template parameters specified. */
+  friend mesh_class;                    /**< Define mesh_class as friend to be able to access e.g. the constructor. */
 
   /**
    * Protected constructor for an element of a mesh. 
@@ -82,6 +77,20 @@ class abstract_element: public TCompetence<abstract_element<TCompetence...>>...
   }
 
   // --- Variables to check which functionality is defined in TCompetence. ---
+  /** Helper function to check if class T implements the function volume_cache_filled.
+   * \tparam T The competence to be checked.
+   * \return true if T implements the function, false if not.
+   */
+  template <template <typename> class T>
+  static constexpr bool
+  volume_cache_defined ()
+  {
+    return requires (T<SelfType>& competence) { competence.volume_cache_filled (); };
+  }
+  /** This variable is true if any of the given competences \a TCompetence implements 
+  a function volume_cache_filled. */
+  static constexpr bool volume_cache_exists = (false || ... || volume_cache_defined<TCompetence> ());
+
   /** Helper function to check if class T implements the function vertex_cache_filled.
    * \tparam T The competence to be checked.
    * \return true if T implements the function, false if not.
@@ -112,6 +121,15 @@ class abstract_element: public TCompetence<abstract_element<TCompetence...>>...
 
  public:
   // --- Functions to check if caches exist. ---
+  /**
+   * Function that checks if a cache for the element's volume exists.
+   * \return true if a cache exists, false otherwise.
+   */
+  static constexpr bool
+  has_volume_cache ()
+  {
+    return volume_cache_exists;
+  }
   /**
    * Function that checks if a cache for the vertex coordinates exists.
    * \return true if a cache for the vertex coordinates exists, false otherwise.
@@ -168,6 +186,25 @@ class abstract_element: public TCompetence<abstract_element<TCompetence...>>...
     return t8_forest_get_scheme (m_mesh->m_forest)->element_get_shape (get_tree_class (), get_element ());
   }
 
+  /**
+   * Getter for the element's volume.
+   *  This function uses or sets the cached version defined in TCompetence if available and calculates if not.
+   * \return The volume of the element.
+   */
+  double
+  get_volume () const
+  {
+    if constexpr (volume_cache_exists) {
+      if (this->volume_cache_filled ()) {
+        return this->m_volume.value ();
+      }
+      // Fill cache.
+      this->m_volume = t8_forest_element_volume (m_mesh->m_forest, m_tree_id, get_element ());
+      return this->m_volume.value ();
+    }
+    return t8_forest_element_volume (m_mesh->m_forest, m_tree_id, get_element ());
+  }
+
   /**
    * Getter for the vertex coordinates of the element.
    * This function uses or sets the cached version defined in TCompetence if available and calculates if not.
diff --git a/mesh_handle/competence_pack.hxx b/mesh_handle/competence_pack.hxx
new file mode 100644
index 0000000000..ee351401d2
--- /dev/null
+++ b/mesh_handle/competence_pack.hxx
@@ -0,0 +1,51 @@
+/*
+  This file is part of t8code.
+  t8code is a C library to manage a collection (a forest) of multiple
+  connected adaptive space-trees of general element classes in parallel.
+
+  Copyright (C) 2025 the developers
+
+  t8code is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2 of the License, or
+  (at your option) any later version.
+
+  t8code is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with t8code; if not, write to the Free Software Foundation, Inc.,
+  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+*/
+
+/** \file competence_pack.hxx
+ * Define to pack different competences into one template parameter for the \ref t8_mesh_handle::mesh class.
+ */
+#ifndef T8_COMPETENCE_PACK_HXX
+#define T8_COMPETENCE_PACK_HXX
+
+#include "competences.hxx"
+namespace t8_mesh_handle
+{
+/** Class to pack different competences into one template parameter for the \ref mesh class.
+ * \tparam TCompetence The competences to be packed.
+ */
+template <template <typename> class... TCompetence>
+struct competence_pack
+{
+  /** Apply the competence pack to a template class, e.g. the \ref abstract_element class.
+   * \tparam Target The target template class to apply the \a TCompetence pack to.
+   */
+  template <typename mesh_class, template <typename, template <typename> class...> class Target>
+  using apply = Target<mesh_class, TCompetence...>;
+
+  using is_competence_pack = void; /**< Tag to identify this class. */
+};
+
+/** Predefined competence pack combining all caching competences. */
+using cache_competences = competence_pack<cache_volume, cache_vertex_coordinates, cache_centroid, cache_neighbors>;
+
+}  // namespace t8_mesh_handle
+#endif /* !T8_COMPETENCE_PACK_HXX */
diff --git a/mesh_handle/competences.hxx b/mesh_handle/competences.hxx
index 0e65be03bc..30d79af5ca 100644
--- a/mesh_handle/competences.hxx
+++ b/mesh_handle/competences.hxx
@@ -48,6 +48,29 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 namespace t8_mesh_handle
 {
 
+/**
+ * Competence to cache the volume of an element at the first function call.
+ * \tparam TUnderlying Use the \ref abstract_element with specified competences as template parameter.
+ */
+template <typename TUnderlying>
+struct cache_volume: public t8_crtp_operator<TUnderlying, cache_volume>
+{
+ public:
+  /**
+   * Function that checks if the cache for the volume has been filled.
+   * \return true if the cache has been filled, false otherwise.
+   */
+  bool
+  volume_cache_filled () const
+  {
+    return m_volume.has_value ();
+  }
+
+ protected:
+  mutable std::optional<double>
+    m_volume; /**< Cache for the volume. Use optional to allow no value if cache is not filled. */
+};
+
 /**
  * Competence to cache the vertex coordinates of an element at the first function call.
  * \tparam TUnderlying Use the \ref abstract_element with specified competences as template parameter.
diff --git a/mesh_handle/ghost_element.hxx b/mesh_handle/ghost_element.hxx
index 5af7e32043..0221f5b7c8 100644
--- a/mesh_handle/ghost_element.hxx
+++ b/mesh_handle/ghost_element.hxx
@@ -33,11 +33,6 @@
 
 namespace t8_mesh_handle
 {
-/* Forward declaration of the \ref mesh class of the handle.
- */
-template <template <typename> class... TCompetence>
-class mesh;
-
 /** 
  * Class for the ghost elements of the \ref mesh handle. 
  * This class is a child class of the abstract element class and implements the functionality specific to ghost elements.
@@ -45,10 +40,9 @@ class mesh;
  *
  * \tparam TCompetence The competences you want to add to the default functionality of the element.
  */
-template <template <typename> class... TCompetence>
-class ghost_element: public abstract_element<TCompetence...> {
-  using Base = abstract_element<TCompetence...>;
-  using mesh_class = mesh<TCompetence...>;
+template <typename mesh_class, template <typename> class... TCompetence>
+class ghost_element: public abstract_element<mesh_class, TCompetence...> {
+  using Base = abstract_element<mesh_class, TCompetence...>;
   friend mesh_class;
 
   /**
diff --git a/mesh_handle/mesh.hxx b/mesh_handle/mesh.hxx
index 88c6371762..86655a5ddb 100644
--- a/mesh_handle/mesh.hxx
+++ b/mesh_handle/mesh.hxx
@@ -32,25 +32,36 @@
 #include "abstract_element.hxx"
 #include "mesh_element.hxx"
 #include "ghost_element.hxx"
+#include "competence_pack.hxx"
 #include <t8_forest/t8_forest_ghost.h>
 #include <vector>
+#include <type_traits>
 
 namespace t8_mesh_handle
 {
 
 /**
  * Wrapper for a forest that enables it to be handled as a simple mesh object.
- * \tparam TCompetence The competences you want to add to the default functionality of the mesh.
+ * \tparam TCompetencePack The competences you want to add to the default functionality of the mesh.
  *         \see abstract_element for more details on the choice of the template parameter.   
+ *         \note Please pack your competences using the \ref competence_pack class.
+ * \tparam TUserData The user data type you want to associate with the mesh. Use void (this is also the default) if you do not want to set user data.
+ * \tparam TElementData The element data type you want to use for each element of the mesh. 
+ *         Use void (this is also the default) if you do not want to set element data.
  */
-template <template <typename> class... TCompetence>
+template <typename TCompetencePack = competence_pack<>, typename TUserData = void, typename TElementData = void>
 class mesh {
  public:
+  using SelfType = mesh<TCompetencePack, TUserData,
+                        TElementData>; /**< Type of the current class with all template parameters specified. */
   /** Type definitions of the element classes with given competences. */
-  using abstract_element_class = abstract_element<
-    TCompetence...>; /**< The abstract element class of the mesh (could be a mesh element of ghost). */
-  using mesh_element_class = mesh_element<TCompetence...>;   /**< The mesh element class of the mesh. */
-  using ghost_element_class = ghost_element<TCompetence...>; /**< The ghost element class of the mesh. */
+  using abstract_element_class = TCompetencePack::template apply<
+    SelfType, abstract_element>; /**< The abstract element class of the mesh (could be a mesh element of ghost). */
+  using mesh_element_class
+    = TCompetencePack::template apply<SelfType, mesh_element>; /**< The mesh element class of the mesh. */
+  using ghost_element_class
+    = TCompetencePack::template apply<SelfType, ghost_element>; /**< The ghost element class of the mesh. */
+
   // Declare all element classes as friend such that private members (e.g. the forest) can be accessed.
   friend abstract_element_class; /**< Abstract element class as friend. */
   friend mesh_element_class;     /**< Mesh element class as friend. */
@@ -61,10 +72,11 @@ class mesh {
 
   /** 
    * Constructor for a mesh of the handle. 
-   * \param [in] input_forest The forest from which the mesh should be created. 
+   * \param [in] forest The forest from which the mesh should be created. 
    */
-  mesh (t8_forest_t input_forest): m_forest (input_forest)
+  mesh (t8_forest_t forest): m_forest (forest)
   {
+    T8_ASSERT ((std::is_same<typename TCompetencePack::is_competence_pack, void>::value));
     T8_ASSERT (t8_forest_is_committed (m_forest));
     update_elements ();
   }
@@ -89,6 +101,16 @@ class mesh {
     return t8_forest_get_num_ghosts (m_forest);
   }
 
+  /** 
+   * Getter for the dimension the mesh handle lives in.
+   * \return The dimension.
+   */
+  int
+  get_dimension () const
+  {
+    return t8_forest_get_dimension (m_forest);
+  }
+
   /**
    * Returns a constant iterator to the first (local) mesh element.
    * \return Constant iterator to the first (local) mesh element.
@@ -171,9 +193,9 @@ class mesh {
   }
 
   /** 
-  * Setter for the forest. 
-  * \param [in] input_forest The forest from which the mesh should be a wrapper. 
-  */
+   * Setter for the forest. 
+   * \param [in] input_forest The forest from which the mesh should be a wrapper. 
+   */
   void
   set_forest (t8_forest_t input_forest)
   {
@@ -182,6 +204,67 @@ class mesh {
     update_elements ();
   }
 
+  /** 
+   * Set the user data of the mesh. This can i.e. be used to pass user defined arguments to the adapt routine.
+   * \param [in] data The user data of class TUserData. Data will never be touched by mesh handling routines.
+   */
+  template <typename U = TUserData, typename = std::enable_if_t<!std::is_void<U>::value>>
+  void
+  set_user_data (const U& data)
+  {
+    t8_forest_set_user_data (m_forest, data);
+  }
+
+  /** 
+   * Get the user data of the mesh. 
+   * \return The user data previously set using \ref set_user_data.   
+   */
+  template <typename U = TUserData, typename = std::enable_if_t<!std::is_void<U>::value>>
+  const U&
+  get_user_data () const
+  {
+    return *static_cast<const U*> (t8_forest_get_user_data (m_forest));
+  }
+
+  /** 
+   * Set the element data vector. The vector should have the length of num_local_elements.
+   * \param [in] element_data The element data vector to set with one entry of class TElementData 
+   *            for each local mesh element (excluding ghosts).
+   */
+  template <typename E = TElementData, typename = std::enable_if_t<!std::is_void<E>::value>>
+  void
+  set_element_data (const std::vector<E>& element_data)
+  {
+    T8_ASSERT (element_data.size () == get_num_local_elements ());
+    m_element_data.clear ();
+    m_element_data.resize (get_num_local_elements () + get_num_local_ghosts ());
+    std::copy (element_data.begin (), element_data.end (), m_element_data.begin ());
+  }
+
+  /** 
+   * Get the element data vector including ghost entries.
+   * The element data of the local mesh elements is the one set using \ref set_element_data.
+   * In this function, additionally the ghost entries are filled exchanging the correct entries of the
+   *   element vector between processes.
+   * \return Element data vector of size num_local_elements + num_local_ghosts with data of Type TElementData.
+   */
+  template <typename E = TElementData, typename = std::enable_if_t<!std::is_void<E>::value>>
+  const std::vector<E>&
+  get_element_data ()
+  {
+    // t8_forest_ghost_exchange_data expects an sc_array, so we need to wrap our data array to one.
+    sc_array* sc_array_wrapper;
+    T8_ASSERT (m_element_data.size () == get_num_local_elements () + get_num_local_ghosts ());
+    sc_array_wrapper = sc_array_new_data (m_element_data.data (), sizeof (TElementData),
+                                          get_num_local_elements () + get_num_local_ghosts ());
+
+    // Data exchange: entries with indices > num_local_elements will get overwritten.
+    t8_forest_ghost_exchange_data (m_forest, sc_array_wrapper);
+
+    sc_array_destroy (sc_array_wrapper);
+    return m_element_data;
+  }
+
  private:
   /** 
    * Update the storage of the mesh elements according to the current forest. 
@@ -189,7 +272,6 @@ class mesh {
   void
   update_elements ()
   {
-    // Clear the element vector if already created.
     m_elements.clear ();
     m_elements.reserve (get_num_local_elements ());
     // Iterate through forest elements and fill the element vector with newly created mesh elements.
@@ -208,7 +290,6 @@ class mesh {
   void
   update_ghost_elements ()
   {
-    // Clear the ghost vector if already created.
     m_ghosts.clear ();
     m_ghosts.reserve (get_num_local_ghosts ());
     t8_locidx_t num_loc_trees = t8_forest_get_num_local_trees (m_forest);
@@ -224,6 +305,8 @@ class mesh {
   t8_forest_t m_forest;                       /**< The forest the mesh should be defined for. */
   std::vector<mesh_element_class> m_elements; /**< Vector storing the (local) mesh elements. */
   std::vector<ghost_element_class> m_ghosts;  /**< Vector storing the (local) ghost elements. */
+  std::conditional_t<!std::is_void_v<TElementData>, std::vector<TElementData>, std::nullptr_t>
+    m_element_data; /**< Vector storing the (local) element data. */
 };
 
 }  // namespace t8_mesh_handle
diff --git a/mesh_handle/mesh_element.hxx b/mesh_handle/mesh_element.hxx
index 5456e9f067..8bc08f30da 100644
--- a/mesh_handle/mesh_element.hxx
+++ b/mesh_handle/mesh_element.hxx
@@ -37,11 +37,6 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 
 namespace t8_mesh_handle
 {
-/* Forward declaration of the \ref mesh class of the handle.
- */
-template <template <typename> class... TCompetence>
-class mesh;
-
 /** 
  * Class for the mesh elements of the mesh handle. 
  * This class is a child class of the abstract element class and implements the functionality specific to mesh elements 
@@ -49,11 +44,10 @@ class mesh;
  *
  * \tparam TCompetence The competences you want to add to the default functionality of the element.
  */
-template <template <typename> class... TCompetence>
-class mesh_element: public abstract_element<TCompetence...> {
-  using Base = abstract_element<TCompetence...>;
-  using SelfType = mesh_element<TCompetence...>;
-  using mesh_class = Base::mesh_class;
+template <typename mesh_class, template <typename> class... TCompetence>
+class mesh_element: public abstract_element<mesh_class, TCompetence...> {
+  using Base = abstract_element<mesh_class, TCompetence...>;
+  using SelfType = mesh_element<mesh_class, TCompetence...>;
   friend mesh_class;
 
   // --- Variables to check which functionality is defined in TCompetence. ---
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 792bc799d6..6b6ff0e5a2 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -214,6 +214,7 @@ if( T8CODE_BUILD_MESH_HANDLE )
   add_t8_cpp_test( NAME t8_gtest_handle_ghost_parallel            SOURCES mesh_handle/t8_gtest_ghost.cxx )
   add_t8_cpp_test( NAME t8_gtest_custom_competence_serial         SOURCES mesh_handle/t8_gtest_custom_competence.cxx )
   add_t8_cpp_test( NAME t8_gtest_cache_competence_serial          SOURCES mesh_handle/t8_gtest_cache_competence.cxx )
+  add_t8_cpp_test( NAME t8_gtest_handle_data_parallel             SOURCES mesh_handle/t8_gtest_handle_data.cxx )
 endif()
 
 copy_test_file( test_cube_unstructured_1.inp )
diff --git a/test/mesh_handle/t8_gtest_cache_competence.cxx b/test/mesh_handle/t8_gtest_cache_competence.cxx
index 7198fa3b50..eb4fe57bb4 100644
--- a/test/mesh_handle/t8_gtest_cache_competence.cxx
+++ b/test/mesh_handle/t8_gtest_cache_competence.cxx
@@ -30,6 +30,7 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 
 #include <mesh_handle/mesh.hxx>
 #include <mesh_handle/competences.hxx>
+#include <mesh_handle/competence_pack.hxx>
 #include <t8_cmesh/t8_cmesh.h>
 #include <t8_cmesh/t8_cmesh_examples.h>
 #include <t8_forest/t8_forest_general.h>
@@ -37,6 +38,21 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 #include <t8_types/t8_vec.hxx>
 #include <vector>
 
+/** Child class of \ref t8_mesh_handle::cache_volume that allows to modify the cache variable for test purposes. */
+template <typename TUnderlying>
+struct cache_volume_overwrite: public t8_mesh_handle::cache_volume<TUnderlying>
+{
+ public:
+  /** Overwrites the cache variable for the volume.
+   * \param [in] new_volume New volume. 
+   */
+  void
+  overwrite_cache (double new_volume) const
+  {
+    this->m_volume = new_volume;
+  }
+};
+
 /** Child class of \ref t8_mesh_handle::cache_vertex_coordinates that allows to modify the cache variable for test purposes. */
 template <typename TUnderlying>
 struct cache_vertex_coordinates_overwrite: public t8_mesh_handle::cache_vertex_coordinates<TUnderlying>
@@ -89,17 +105,42 @@ class t8_gtest_cache_competence: public testing::Test {
   int level;
 };
 
+/** Use child class of \ref t8_mesh_handle::cache_volume class to check that the cache is actually set 
+ * and accessed correctly. This is done by modifying the cache to an unrealistic value and 
+ * checking that the functionality actually outputs this unrealistic value.
+ */
+TEST_F (t8_gtest_cache_competence, cache_volume)
+{
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_volume_overwrite>>;
+  using element_class = typename mesh_class::abstract_element_class;
+  mesh_class mesh = mesh_class (forest);
+  EXPECT_TRUE (element_class::has_volume_cache ());
+
+  double unrealistic_volume = -3000;
+  for (auto it = mesh.begin (); it != mesh.end (); ++it) {
+    // Check that cache is empty at the beginning.
+    EXPECT_FALSE (it->volume_cache_filled ());
+    // Fill cache and check that volume is valid.
+    EXPECT_GE (it->get_volume (), 0);
+    // Check that cache is set.
+    EXPECT_TRUE (it->volume_cache_filled ());
+    // Overwrite the cache with unrealistic values.
+    it->overwrite_cache (unrealistic_volume);
+    // Check that the cache is actually used.
+    EXPECT_EQ (it->get_volume (), unrealistic_volume);
+  }
+}
+
 /** Use child class of \ref t8_mesh_handle::cache_vertex_coordinates class to check that the cache is actually set 
  * and accessed correctly. This is done by modifying the cache to an unrealistic value and 
  * checking that the functionality actually outputs this unrealistic value.
  */
 TEST_F (t8_gtest_cache_competence, cache_vertex_coordinates)
 {
-  using mesh_class = t8_mesh_handle::mesh<cache_vertex_coordinates_overwrite>;
-  using element_class = mesh_class::abstract_element_class;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_vertex_coordinates_overwrite>>;
+  using element_class = typename mesh_class::abstract_element_class;
   mesh_class mesh = mesh_class (forest);
   EXPECT_TRUE (element_class::has_vertex_cache ());
-  EXPECT_FALSE (element_class::has_centroid_cache ());
 
   std::vector<t8_3D_point> unrealistic_vertex = { t8_3D_point ({ 41, 42, 43 }), t8_3D_point ({ 99, 100, 101 }) };
   for (auto it = mesh.begin (); it != mesh.end (); ++it) {
@@ -128,10 +169,9 @@ TEST_F (t8_gtest_cache_competence, cache_vertex_coordinates)
  */
 TEST_F (t8_gtest_cache_competence, cache_centroid)
 {
-  using mesh_class = t8_mesh_handle::mesh<cache_centroid_overwrite>;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_centroid_overwrite>>;
   using element_class = mesh_class::abstract_element_class;
   mesh_class mesh = mesh_class (forest);
-  EXPECT_FALSE (element_class::has_vertex_cache ());
   EXPECT_TRUE (element_class::has_centroid_cache ());
 
   t8_3D_point unrealistic_centroid ({ 999, 1000, 998 });
diff --git a/test/mesh_handle/t8_gtest_compare_handle_to_forest.cxx b/test/mesh_handle/t8_gtest_compare_handle_to_forest.cxx
index bd0e69f5a8..b8ff456865 100644
--- a/test/mesh_handle/t8_gtest_compare_handle_to_forest.cxx
+++ b/test/mesh_handle/t8_gtest_compare_handle_to_forest.cxx
@@ -32,6 +32,7 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 #include <t8_cmesh/t8_cmesh.h>
 #include <t8_cmesh/t8_cmesh_examples.h>
 #include <t8_forest/t8_forest_general.h>
+#include <t8_forest/t8_forest_geometrical.h>
 #include <t8_schemes/t8_default/t8_default.hxx>
 
 /** Tests that the functionality of the handle gives the same results as if worked with the forest directly.
@@ -61,6 +62,7 @@ TEST (t8_gtest_compare_handle_to_forest, compare_handle_to_forest)
       // --- Compare basics. ---
       EXPECT_EQ (mesh_iterator->get_level (), scheme->element_get_level (tree_class, elem));
       EXPECT_EQ (mesh_iterator->get_shape (), scheme->element_get_shape (tree_class, elem));
+      EXPECT_EQ (mesh_iterator->get_volume (), t8_forest_element_volume (forest, itree, elem));
       // --- Compare centroid. ---
       t8_3D_point centroid;
       t8_forest_element_centroid (forest, itree, elem, centroid.data ());
diff --git a/test/mesh_handle/t8_gtest_custom_competence.cxx b/test/mesh_handle/t8_gtest_custom_competence.cxx
index 491556f2e1..96a1b3a72e 100644
--- a/test/mesh_handle/t8_gtest_custom_competence.cxx
+++ b/test/mesh_handle/t8_gtest_custom_competence.cxx
@@ -30,6 +30,7 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 
 #include <mesh_handle/mesh.hxx>
 #include <mesh_handle/competences.hxx>
+#include <mesh_handle/competence_pack.hxx>
 #include <t8_cmesh/t8_cmesh.h>
 #include <t8_cmesh/t8_cmesh_examples.h>
 #include <t8_forest/t8_forest_general.h>
@@ -89,7 +90,8 @@ TEST (t8_gtest_custom_competence, custom_competence)
   t8_forest_t forest = t8_forest_new_uniform (cmesh, scheme, level, 0, sc_MPI_COMM_WORLD);
 
   // Check mesh with custom defined competence.
-  t8_mesh_handle::mesh<dummy_get_level> mesh = t8_mesh_handle::mesh<dummy_get_level> (forest);
+  using mesh_class_custom = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<dummy_get_level>>;
+  mesh_class_custom mesh = mesh_class_custom (forest);
 
   for (auto it = mesh.begin (); it != mesh.end (); ++it) {
     EXPECT_EQ (it->get_level (), it->get_level_dummy ());
@@ -97,7 +99,8 @@ TEST (t8_gtest_custom_competence, custom_competence)
   }
 
   // Test with two custom competences and a predefined competence.
-  using mesh_class = t8_mesh_handle::mesh<dummy_get_level, dummy_trivial, t8_mesh_handle::cache_centroid>;
+  using competences = t8_mesh_handle::competence_pack<dummy_get_level, dummy_trivial, t8_mesh_handle::cache_centroid>;
+  using mesh_class = t8_mesh_handle::mesh<competences>;
   mesh_class mesh_more_competences = mesh_class (forest);
 
   for (auto it = mesh_more_competences.begin (); it != mesh_more_competences.end (); ++it) {
diff --git a/test/mesh_handle/t8_gtest_ghost.cxx b/test/mesh_handle/t8_gtest_ghost.cxx
index f63c824b03..5270779f06 100644
--- a/test/mesh_handle/t8_gtest_ghost.cxx
+++ b/test/mesh_handle/t8_gtest_ghost.cxx
@@ -31,6 +31,7 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 
 #include <mesh_handle/mesh.hxx>
 #include <mesh_handle/competences.hxx>
+#include <mesh_handle/competence_pack.hxx>
 #include <t8_cmesh/t8_cmesh.h>
 #include <t8_cmesh/t8_cmesh_examples.h>
 #include <t8_forest/t8_forest_general.h>
@@ -67,6 +68,10 @@ TEST_P (t8_mesh_ghost_test, check_ghosts)
 
   t8_mesh_handle::mesh<> mesh = t8_mesh_handle::mesh<> (forest);
   EXPECT_EQ (mesh.get_num_local_ghosts (), t8_forest_get_num_ghosts (forest));
+  if ((mesh.get_dimension () > 1) && (mesh.get_num_local_elements () > 1)) {
+    // Ensure that we actually have ghost elements in this test.
+    EXPECT_GT (mesh.get_num_local_ghosts (), 0);
+  }
 
   // Check that functionality of mesh elements is still valid.
   for (auto it = mesh.begin (); it != mesh.end (); ++it) {
@@ -192,8 +197,8 @@ struct cache_neighbors_overwrite: public t8_mesh_handle::cache_neighbors<TUnderl
  */
 TEST_P (t8_mesh_ghost_test, cache_neighbors)
 {
-  using mesh_class = t8_mesh_handle::mesh<cache_neighbors_overwrite>;
-  using element_class = mesh_class::mesh_element_class;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_neighbors_overwrite>>;
+  using element_class = typename mesh_class::mesh_element_class;
   mesh_class mesh = mesh_class (forest);
   EXPECT_TRUE (element_class::has_face_neighbor_cache ());
 
diff --git a/test/mesh_handle/t8_gtest_handle_data.cxx b/test/mesh_handle/t8_gtest_handle_data.cxx
new file mode 100644
index 0000000000..196d28a38a
--- /dev/null
+++ b/test/mesh_handle/t8_gtest_handle_data.cxx
@@ -0,0 +1,119 @@
+/*
+This file is part of t8code.
+t8code is a C library to manage a collection (a forest) of multiple
+connected adaptive space-trees of general element classes in parallel.
+
+Copyright (C) 2025 the developers
+
+t8code is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+t8code is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with t8code; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+*/
+
+/**
+ * \file t8_gtest_handle_data.cxx
+ * Tests to check that \ref t8_mesh_handle::mesh user data and element data functionality works as intended.
+ */
+
+#include <gtest/gtest.h>
+#include <t8.h>
+
+#include <mesh_handle/mesh.hxx>
+#include <mesh_handle/competence_pack.hxx>
+#include <t8_cmesh/t8_cmesh.h>
+#include <t8_cmesh/t8_cmesh_examples.h>
+#include <t8_forest/t8_forest_general.h>
+#include <t8_schemes/t8_default/t8_default.hxx>
+#include <t8_types/t8_vec.hxx>
+#include <vector>
+
+// --- Test for user data. ---
+// Dummy user data taken from a tutorial for test purposes.
+struct dummy_user_data
+{
+  t8_3D_point midpoint;             /* The midpoint of our sphere. */
+  double refine_if_inside_radius;   /* if an element's center is smaller than this value, we refine the element. */
+  double coarsen_if_outside_radius; /* if an element's center is larger this value, we coarsen its family. */
+};
+
+/** Check that user data can be set and accesses for the handle.
+ */
+TEST (t8_gtest_handle_data, set_and_get_user_data)
+{
+  // Define forest and mesh handle.
+  const int level = 2;
+  t8_cmesh_t cmesh = t8_cmesh_new_hypercube_hybrid (sc_MPI_COMM_WORLD, 0, 0);
+  const t8_scheme *init_scheme = t8_scheme_new_default ();
+  t8_forest_t forest = t8_forest_new_uniform (cmesh, init_scheme, level, 0, sc_MPI_COMM_WORLD);
+
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<>, dummy_user_data>;
+  mesh_class mesh = mesh_class (forest);
+
+  struct dummy_user_data user_data = {
+    t8_3D_point ({ 41, 42, 43 }), /* Midpoints of the sphere. */
+    0.2,                          /* Refine if inside this radius. */
+    0.4                           /* Coarsen if outside this radius. */
+  };
+
+  // Set user data for the mesh handle and check that the getter returns the same data.
+  mesh.set_user_data (&user_data);
+  auto mesh_user_data = mesh.get_user_data ();
+  EXPECT_EQ (mesh_user_data.midpoint, user_data.midpoint);
+  EXPECT_EQ (mesh_user_data.refine_if_inside_radius, user_data.refine_if_inside_radius);
+  EXPECT_EQ (mesh_user_data.coarsen_if_outside_radius, user_data.coarsen_if_outside_radius);
+
+  // Unref the forest.
+  t8_forest_unref (&forest);
+}
+
+// --- Test for element data. ---
+// Dummy element data taken from a tutorial for test purposes.
+struct data_per_element
+{
+  int level;
+  double volume;
+};
+
+/** Check that element data can be set for the handle and 
+ * that the getter has exchanged data for the ghosts.
+ */
+TEST (t8_gtest_handle_data, set_and_get_element_data)
+{
+  // Define forest and mesh handle.
+  const int level = 2;
+  t8_cmesh_t cmesh = t8_cmesh_new_hypercube_hybrid (sc_MPI_COMM_WORLD, 0, 0);
+  const t8_scheme *init_scheme = t8_scheme_new_default ();
+  t8_forest_t forest = t8_forest_new_uniform (cmesh, init_scheme, level, 1, sc_MPI_COMM_WORLD);
+
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<>, void, data_per_element>;
+  mesh_class mesh = mesh_class (forest);
+  if ((mesh.get_dimension () > 1) && (mesh.get_num_local_elements () > 1)) {
+    // Ensure that we actually test with ghost elements.
+    EXPECT_GT (mesh.get_num_local_ghosts (), 0);
+  }
+  // Create element data for all local mesh elements.
+  std::vector<data_per_element> element_data;
+  for (const auto &elem : mesh) {
+    element_data.push_back ({ elem.get_level (), elem.get_volume () });
+  }
+  mesh.set_element_data (element_data);
+  // Get element data and check that the data for all elements (including ghosts) is correct.
+  auto mesh_element_data = mesh.get_element_data ();
+  for (t8_locidx_t ielem = 0; ielem < mesh.get_num_local_elements () + mesh.get_num_local_ghosts (); ielem++) {
+    EXPECT_EQ (mesh_element_data[ielem].level, level) << "ielem = " << ielem;
+    EXPECT_EQ (mesh_element_data[ielem].volume, mesh[ielem].get_volume ()) << "ielem = " << ielem;
+  }
+
+  // Unref the forest.
+  t8_forest_unref (&forest);
+}
diff --git a/test/mesh_handle/t8_gtest_mesh_handle.cxx b/test/mesh_handle/t8_gtest_mesh_handle.cxx
index 194aac5d7f..7b39beac29 100644
--- a/test/mesh_handle/t8_gtest_mesh_handle.cxx
+++ b/test/mesh_handle/t8_gtest_mesh_handle.cxx
@@ -31,6 +31,7 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 
 #include <mesh_handle/mesh.hxx>
 #include <mesh_handle/competences.hxx>
+#include <mesh_handle/competence_pack.hxx>
 #include <t8_cmesh/t8_cmesh.h>
 #include <t8_cmesh/t8_cmesh_examples.h>
 #include <t8_forest/t8_forest_general.h>
@@ -63,7 +64,7 @@ TEST_P (t8_mesh_handle_test, test_iterator)
 {
   // --- Check default functionality. ---
   using mesh_class = t8_mesh_handle::mesh<>;
-  using element_class = mesh_class::abstract_element_class;
+  using element_class = typename mesh_class::abstract_element_class;
   mesh_class mesh = mesh_class (forest);
   EXPECT_FALSE (element_class::has_vertex_cache ());
   EXPECT_FALSE (element_class::has_centroid_cache ());
@@ -97,8 +98,9 @@ TEST_P (t8_mesh_handle_test, test_iterator)
 TEST_P (t8_mesh_handle_test, test_competences)
 {
   // --- Version with cached vertex coordinates. ---
-  using mesh_class_vertex = t8_mesh_handle::mesh<t8_mesh_handle::cache_vertex_coordinates>;
-  using element_class_vertex = mesh_class_vertex::abstract_element_class;
+  using competence_vertex_coordinates = t8_mesh_handle::competence_pack<t8_mesh_handle::cache_vertex_coordinates>;
+  using mesh_class_vertex = t8_mesh_handle::mesh<competence_vertex_coordinates>;
+  using element_class_vertex = typename mesh_class_vertex::abstract_element_class;
   mesh_class_vertex mesh_vertex = mesh_class_vertex (forest);
   EXPECT_TRUE (element_class_vertex::has_vertex_cache ());
   EXPECT_FALSE (element_class_vertex::has_centroid_cache ());
@@ -133,8 +135,9 @@ TEST_P (t8_mesh_handle_test, test_competences)
   }
 
   // --- Version with cached centroid variable. ---
-  using mesh_class_centroid = t8_mesh_handle::mesh<t8_mesh_handle::cache_centroid>;
-  using element_class_centroid = mesh_class_centroid::abstract_element_class;
+  using competence_centroid = t8_mesh_handle::competence_pack<t8_mesh_handle::cache_centroid>;
+  using mesh_class_centroid = t8_mesh_handle::mesh<competence_centroid>;
+  using element_class_centroid = typename mesh_class_centroid::abstract_element_class;
   mesh_class_centroid mesh_centroid = mesh_class_centroid (forest);
   EXPECT_FALSE (element_class_centroid::has_vertex_cache ());
   EXPECT_TRUE (element_class_centroid::has_centroid_cache ());
@@ -160,17 +163,20 @@ TEST_P (t8_mesh_handle_test, test_competences)
 TEST_P (t8_mesh_handle_test, test_2_competences)
 {
   // --- Use competences to cache level and centroid. ---
-  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::cache_vertex_coordinates, t8_mesh_handle::cache_centroid>;
-  using element_class = mesh_class::abstract_element_class;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::cache_competences>;
+  using element_class = typename mesh_class::abstract_element_class;
   mesh_class mesh = mesh_class (forest);
+  EXPECT_TRUE (element_class::has_volume_cache ());
   EXPECT_TRUE (element_class::has_vertex_cache ());
   EXPECT_TRUE (element_class::has_centroid_cache ());
 
   // Iterate with the iterator over all mesh elements.
   for (auto it = mesh.begin (); it != mesh.end (); ++it) {
+    EXPECT_FALSE (it->volume_cache_filled ());
     EXPECT_FALSE (it->centroid_cache_filled ());
     EXPECT_FALSE (it->vertex_cache_filled ());
     EXPECT_EQ (level, it->get_level ());
+    EXPECT_GE (it->get_volume (), 0);
     auto centroid = it->get_centroid ();
     for (const auto& coordinate : centroid) {
       EXPECT_GE (1, coordinate);
@@ -186,9 +192,11 @@ TEST_P (t8_mesh_handle_test, test_2_competences)
   }
   // Test dereference operator. (Here the cached values should be used.)
   for (auto it = mesh.begin (); it != mesh.end (); ++it) {
+    EXPECT_TRUE (it->volume_cache_filled ());
     EXPECT_TRUE (it->centroid_cache_filled ());
     EXPECT_TRUE (it->vertex_cache_filled ());
     EXPECT_EQ (level, (*it).get_level ());
+    EXPECT_GE (it->get_volume (), 0);
     auto centroid = (*it).get_centroid ();
     for (const auto& coordinate : centroid) {
       EXPECT_GE (1, coordinate);