diff --git a/.github/workflows/code_coverage.yml b/.github/workflows/code_coverage.yml
index 6ed2b7179f..a46c923465 100644
--- a/.github/workflows/code_coverage.yml
+++ b/.github/workflows/code_coverage.yml
@@ -91,7 +91,7 @@ jobs:
       run: export TEST_LEVEL_FLAG="-DT8CODE_TEST_LEVEL=${{ inputs.TEST_LEVEL }}"
            && echo TEST_LEVEL_FLAG="$TEST_LEVEL_FLAG" >> $GITHUB_ENV
     - name: build config variables
-      run: export CONFIG_OPTIONS="${TEST_LEVEL_FLAG} -DT8CODE_CODE_COVERAGE=ON -DT8CODE_USE_SYSTEM_SC=ON -DT8CODE_USE_SYSTEM_P4EST=ON -DT8CODE_BUILD_PEDANTIC=ON -DT8CODE_BUILD_WALL=ON -DT8CODE_BUILD_WERROR=ON -DT8CODE_ENABLE_MPI=$MPI -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DT8CODE_BUILD_FORTRAN_INTERFACE=ON -DSC_DIR=$SC_PATH/install/cmake -DP4EST_DIR=$P4EST_PATH/install/cmake -DT8CODE_BUILD_BENCHMARKS=OFF -DT8CODE_BUILD_DOCUMENTATION=OFF -DT8CODE_BUILD_EXAMPLES=OFF -DT8CODE_BUILD_TUTORIALS=OFF"
+      run: export CONFIG_OPTIONS="${TEST_LEVEL_FLAG} -DT8CODE_CODE_COVERAGE=ON -DT8CODE_USE_SYSTEM_SC=ON -DT8CODE_USE_SYSTEM_P4EST=ON -DT8CODE_BUILD_PEDANTIC=ON -DT8CODE_BUILD_WALL=ON -DT8CODE_BUILD_WERROR=ON -DT8CODE_ENABLE_MPI=$MPI -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DT8CODE_BUILD_FORTRAN_INTERFACE=ON -DT8CODE_BUILD_MESH_HANDLE=ON -DSC_DIR=$SC_PATH/install/cmake -DP4EST_DIR=$P4EST_PATH/install/cmake -DT8CODE_BUILD_BENCHMARKS=OFF -DT8CODE_BUILD_DOCUMENTATION=OFF -DT8CODE_BUILD_EXAMPLES=OFF -DT8CODE_BUILD_TUTORIALS=OFF"
         && echo CONFIG_OPTIONS="$CONFIG_OPTIONS" >> $GITHUB_ENV
     # cmake
     - name: echo cmake line
diff --git a/.github/workflows/tests_cmake_t8code_api.yml b/.github/workflows/tests_cmake_t8code_api.yml
index 3291090385..d9524c4867 100644
--- a/.github/workflows/tests_cmake_t8code_api.yml
+++ b/.github/workflows/tests_cmake_t8code_api.yml
@@ -85,37 +85,35 @@ jobs:
       run: export TEST_LEVEL_FLAG="-DT8CODE_TEST_LEVEL=${{ inputs.TEST_LEVEL }}"
            && echo TEST_LEVEL_FLAG="$TEST_LEVEL_FLAG" >> $GITHUB_ENV
     - name: build config variables
-      run: export CONFIG_OPTIONS="${TEST_LEVEL_FLAG} -GNinja -DCMAKE_C_FLAGS_DEBUG=${DEBUG_CONFIG} -DCMAKE_CXX_FLAGS_DEBUG=${DEBUG_CONFIG} -DT8CODE_BUILD_FORTRAN_INTERFACE=ON -DT8CODE_USE_SYSTEM_SC=ON -DT8CODE_USE_SYSTEM_P4EST=ON -DT8CODE_BUILD_PEDANTIC=ON -DT8CODE_BUILD_WALL=ON -DT8CODE_BUILD_WERROR=ON -DT8CODE_BUILD_WEXTRA=ON -DT8CODE_ENABLE_MPI=$MPI -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DSC_DIR=$SC_PATH/install/cmake -DP4EST_DIR=$P4EST_PATH/install/cmake"
+      run: export CONFIG_OPTIONS="${TEST_LEVEL_FLAG} -GNinja -DCMAKE_C_FLAGS_DEBUG=${DEBUG_CONFIG} -DCMAKE_CXX_FLAGS_DEBUG=${DEBUG_CONFIG} -DT8CODE_BUILD_FORTRAN_INTERFACE=ON -DT8CODE_BUILD_MESH_HANDLE=ON -DT8CODE_USE_SYSTEM_SC=ON -DT8CODE_USE_SYSTEM_P4EST=ON -DT8CODE_BUILD_PEDANTIC=ON -DT8CODE_BUILD_WALL=ON -DT8CODE_BUILD_WERROR=ON -DT8CODE_BUILD_WEXTRA=ON -DT8CODE_ENABLE_MPI=$MPI -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DSC_DIR=$SC_PATH/install/cmake -DP4EST_DIR=$P4EST_PATH/install/cmake"
            && echo CONFIG_OPTIONS="$CONFIG_OPTIONS" >> $GITHUB_ENV
-    # cmake and test with fortran
-    - name: check fortran
-      run: echo "Checking fortran"
+    # cmake and test with api options
     - name: echo cmake line
       run: echo cmake ../ $CONFIG_OPTIONS 
-    - name: cmake MPI fortran debug
-      run: mkdir build_fortran && cd build_fortran && cmake ../ $CONFIG_OPTIONS
+    - name: cmake
+      run: mkdir build_api && cd build_api && cmake ../ $CONFIG_OPTIONS
     - name: OnFailUploadLog
       if: failure()
       uses: actions/upload-artifact@v5
       with:
-        name: cmake_${{ inputs.BUILD_TYPE }}_MPI_${{ inputs.MPI }}_fortran.log
-        path: build_fortran/CMakeFiles/CMakeOutput.log
-    - name: make
-      run: cd build_fortran && ninja $MAKEFLAGS
+        name: cmake_${{ inputs.BUILD_TYPE }}_MPI_${{ inputs.MPI }}_api.log
+        path: build_api/CMakeFiles/CMakeOutput.log
+    - name: ninja
+      run: cd build_api && ninja $MAKEFLAGS
     - name: ninja install
-      run: cd build_fortran && ninja install $MAKEFLAGS
+      run: cd build_api && ninja install $MAKEFLAGS
     - name: serial tests (if MPI is enabled)
-      run: cd build_fortran && ctest $MAKEFLAGS -R _serial
+      run: cd build_api && ctest $MAKEFLAGS -R _serial
       if: ${{ inputs.MPI == 'ON' }}
     - name: parallel tests (if MPI is enabled)
-      run: cd build_fortran && ctest -R _parallel
+      run: cd build_api && ctest -R _parallel
       if: ${{ inputs.MPI == 'ON' }}
     - name: tests (if MPI is disabled)
-      run: cd build_fortran && ctest $MAKEFLAGS
+      run: cd build_api && ctest $MAKEFLAGS
       if: ${{ inputs.MPI == 'OFF' }}
     - name: OnFailUploadLog
       if: failure()
       uses: actions/upload-artifact@v5
       with:
-        name: test-suite_${{ inputs.BUILD_TYPE }}_MPI_${{ inputs.MPI }}_fortran.log
-        path: build_fortran/Testing/Temporary/LastTest.log
+        name: test-suite_${{ inputs.BUILD_TYPE }}_MPI_${{ inputs.MPI }}_api.log
+        path: build_api/Testing/Temporary/LastTest.log
diff --git a/.github/workflows/tests_cmake_valgrind.yml b/.github/workflows/tests_cmake_valgrind.yml
index 0d85804095..f0174e6eb3 100644
--- a/.github/workflows/tests_cmake_valgrind.yml
+++ b/.github/workflows/tests_cmake_valgrind.yml
@@ -86,7 +86,7 @@ jobs:
       run: export TEST_LEVEL_FLAG="-DT8CODE_TEST_LEVEL=${{ inputs.TEST_LEVEL }}"
            && echo TEST_LEVEL_FLAG="$TEST_LEVEL_FLAG" >> $GITHUB_ENV
     - name: build config variables
-      run: export CONFIG_OPTIONS="${TEST_LEVEL_FLAG} -GNinja -DT8CODE_USE_SYSTEM_SC=ON -DT8CODE_USE_SYSTEM_P4EST=ON -DT8CODE_BUILD_PEDANTIC=ON -DT8CODE_BUILD_WALL=ON -DT8CODE_BUILD_WERROR=ON -DT8CODE_ENABLE_MPI=$MPI -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DSC_DIR=$SC_PATH/install/cmake -DP4EST_DIR=$P4EST_PATH/install/cmake -DT8CODE_BUILD_FORTRAN_INTERFACE=ON"
+      run: export CONFIG_OPTIONS="${TEST_LEVEL_FLAG} -GNinja -DT8CODE_USE_SYSTEM_SC=ON -DT8CODE_USE_SYSTEM_P4EST=ON -DT8CODE_BUILD_PEDANTIC=ON -DT8CODE_BUILD_WALL=ON -DT8CODE_BUILD_WERROR=ON -DT8CODE_ENABLE_MPI=$MPI -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DSC_DIR=$SC_PATH/install/cmake -DP4EST_DIR=$P4EST_PATH/install/cmake -DT8CODE_BUILD_FORTRAN_INTERFACE=ON -DT8CODE_BUILD_MESH_HANDLE=ON"
         && echo CONFIG_OPTIONS="$CONFIG_OPTIONS" >> $GITHUB_ENV
     # cmake
     - name: echo cmake line
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 84bed9ad77..c3197a2932 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -48,6 +48,7 @@ cmake_dependent_option( T8CODE_BUILD_TPL_EXAMPLES "Build the examples from libsc
 
 option( T8CODE_BUILD_TUTORIALS "Build t8code's tutorials" ON )
 option( T8CODE_BUILD_BENCHMARKS "Build t8code's benchmarks" ON )
+option( T8CODE_BUILD_MESH_HANDLE "Build t8code's mesh handle" OFF )
 option( T8CODE_BUILD_FORTRAN_INTERFACE "Build t8code's Fortran interface" OFF )
 
 option( T8CODE_ENABLE_MPI "Enable t8code's features which rely on MPI" ON )
@@ -247,6 +248,10 @@ endif()
 
 add_subdirectory( ${CMAKE_CURRENT_LIST_DIR}/src )
 
+if( T8CODE_BUILD_MESH_HANDLE )
+  add_subdirectory( ${CMAKE_CURRENT_LIST_DIR}/mesh_handle )
+endif()
+
 if ( T8CODE_BUILD_TESTS )
     add_subdirectory( ${CMAKE_CURRENT_LIST_DIR}/test )
 endif()
diff --git a/doc/Doxyfile.in b/doc/Doxyfile.in
index 46db9b0d99..61ae0865d7 100644
--- a/doc/Doxyfile.in
+++ b/doc/Doxyfile.in
@@ -982,6 +982,7 @@ WARN_LOGFILE           =
 # Note: If this tag is empty the current directory is searched.
 
 INPUT                  = @top_srcdir@/src \
+                         @top_srcdir@/mesh_handle \
                          @top_srcdir@/doc/mainpage.dox
 
 # This tag can be used to specify the character encoding of the source files
diff --git a/mesh_handle/CMakeLists.txt b/mesh_handle/CMakeLists.txt
new file mode 100644
index 0000000000..c2d9e1815f
--- /dev/null
+++ b/mesh_handle/CMakeLists.txt
@@ -0,0 +1,54 @@
+#  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 types 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.
+
+# Define own library for mesh handle.
+if ( T8CODE_BUILD_AS_SHARED_LIBRARY )
+    add_library( T8_MESH_HANDLE SHARED )
+    set_target_properties( T8_MESH_HANDLE PROPERTIES POSITION_INDEPENDENT_CODE ON )
+else()
+    add_library( T8_MESH_HANDLE STATIC )
+endif()
+
+add_library( T8CODE::T8_MESH_HANDLE ALIAS T8_MESH_HANDLE )
+set_target_properties(T8_MESH_HANDLE PROPERTIES OUTPUT_NAME mesh_handle)
+
+target_include_directories( T8_MESH_HANDLE PUBLIC
+  $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/..>
+  $<INSTALL_INTERFACE:${CMAKE_INSTALL_PREFIX}/include/mesh_handle>
+) 
+
+target_sources(T8_MESH_HANDLE PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/mesh.cxx)
+install( DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+         DESTINATION include/
+         FILES_MATCHING PATTERN "*.hxx"
+)
+
+target_link_libraries(T8_MESH_HANDLE PUBLIC T8)
+
+install( TARGETS T8_MESH_HANDLE
+         EXPORT ${PROJECT_NAME}-targets
+         ARCHIVE DESTINATION lib
+         LIBRARY DESTINATION lib
+         RUNTIME DESTINATION bin
+)
+
+if( T8CODE_EXPORT_COMPILE_COMMANDS )
+    set_target_properties( T8_MESH_HANDLE PROPERTIES EXPORT_COMPILE_COMMANDS ON )
+endif( T8CODE_EXPORT_COMPILE_COMMANDS )
diff --git a/mesh_handle/README.md b/mesh_handle/README.md
new file mode 100644
index 0000000000..5339218920
--- /dev/null
+++ b/mesh_handle/README.md
@@ -0,0 +1,11 @@
+# mesh_handle #
+**REMARK: Please note that this feature is still work-in-progress, so a lot of functionality is still missing, but will be added step by step.**
+
+In this folder, we define a mesh handle.  
+Some application codes are designed for unstructured or uniform meshes and cannot use t8code's tree-based structures directly. For this purpose, an iterable mesh data structure is created as an intermediate level. This frees the users from having to work with the forest-of-trees based concept and increases the usability. Please note that it is not guaranteed that the mesh is conformal and does not contain hanging nodes.
+
+If you want to use the handle, note that is has its own library. Turn the option `T8CODE_BUILD_MESH_HANDLE` to `ON` and link against the target `T8_MESH_HANDLE` in addition to the usual t8code target please.
+
+The [mesh.hxx](mesh.hxx) defines the mesh class of the handle.
+The [element.hxx](element.hxx) defines the elements used in the mesh class.
+The [competences.hxx](competences.hxx) defines additional competences/functionality of an element to access additional data.
diff --git a/mesh_handle/competences.hxx b/mesh_handle/competences.hxx
new file mode 100644
index 0000000000..c452555fd4
--- /dev/null
+++ b/mesh_handle/competences.hxx
@@ -0,0 +1,99 @@
+/*
+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 competences.hxx
+ * Definition of the additional competences/functionalities that can be used for the mesh class.
+ * Especially, competences to cache functionalities of elements instead of calculating them each time a function
+ * is called are provided.
+ *
+ * All competences have the same inheritance pattern: 
+ * We use the CRTP pattern as we may need to access members of the derived class \ref t8_mesh_handle::element. 
+ * The t8_crtp_operator is used for convenience/clear code (avoid to type a static cast explicitly each time 
+ * we need functionality of TUnderlying).
+ * Especially for the competences to cache functionality, the access of members is not necessary, 
+ * such that it is not obvious why we use the crtp. For competences that extend the functionality of the element, 
+ * this is required. 
+ * We use it for all competences for consistency and compatibility with the \ref t8_mesh_handle::element class.
+ */
+
+#ifndef T8_COMPETENCES_HXX
+#define T8_COMPETENCES_HXX
+
+#include <t8.h>
+#include <t8_types/t8_operators.hxx>
+#include <t8_types/t8_vec.hxx>
+#include <t8_eclass.h>
+#include <array>
+#include <vector>
+#include <optional>
+
+namespace t8_mesh_handle
+{
+
+/**
+ * Competence to cache the vertex coordinates of an element at the first function call.
+ * \tparam TUnderlying Use the \ref element with specified competences as template parameter.
+ */
+template <typename TUnderlying>
+struct cache_vertex_coordinates: public t8_crtp_operator<TUnderlying, cache_vertex_coordinates>
+{
+ public:
+  /**
+   * Function that checks if the cache for the vertex coordinates has been filled.
+   * \return true if the cache for the vertex coordinates has been filled, false otherwise.
+   */
+  bool
+  vertex_cache_filled () const
+  {
+    return !m_vertex_coordinates.empty ();
+  }
+
+ protected:
+  mutable std::vector<t8_3D_point>
+    m_vertex_coordinates; /**< Cache for the vector of vertex coordinate arrays. Empty vector if not filled. */
+};
+
+/**
+ * Competence to cache the centroid of an element at the first function call.
+ * \tparam TUnderlying Use the \ref element with specified competences as template parameter.
+ */
+template <typename TUnderlying>
+struct cache_centroid: public t8_crtp_operator<TUnderlying, cache_centroid>
+{
+ public:
+  /**
+   * Function that checks if the cache for the centroid has been filled.
+   * \return true if the cache for the centroid has been filled, false otherwise.
+   */
+  bool
+  centroid_cache_filled () const
+  {
+    return m_centroid.has_value ();
+  }
+
+ protected:
+  mutable std::optional<t8_3D_point>
+    m_centroid; /**< Cache for the coordinates of the centroid. Use optional to allow no value if cache is not filled. */
+};
+
+}  // namespace t8_mesh_handle
+#endif /* !T8_COMPETENCES_HXX */
diff --git a/mesh_handle/element.hxx b/mesh_handle/element.hxx
new file mode 100644
index 0000000000..685792e9f7
--- /dev/null
+++ b/mesh_handle/element.hxx
@@ -0,0 +1,267 @@
+/*
+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 element.hxx
+ * Definition of the elements used in the \ref t8_mesh_handle::mesh class.
+ */
+
+#ifndef T8_ELEMENT_HXX
+#define T8_ELEMENT_HXX
+
+#include <t8.h>
+#include <t8_element.h>
+#include <t8_eclass.h>
+#include <t8_forest/t8_forest_general.h>
+#include <t8_forest/t8_forest_geometrical.h>
+#include <t8_schemes/t8_scheme.hxx>
+#include <t8_types/t8_vec.hxx>
+#include <array>
+#include <vector>
+
+namespace t8_mesh_handle
+{
+/* Forward declaration of the \ref mesh class of the handle.
+ */
+template <class TMeshElement>
+class mesh;
+
+/** 
+ * Class for the elements of the mesh handle. 
+ * The element without specified template parameters provides default implementations for basic functionality 
+ * as accessing the refinement level or the centroid. With this implementation, the functionality is calculated each time
+ * the function is called. 
+ * Use the competences defined in \ref competences.hxx as template parameter to cache the functionality instead of 
+ * recalculating in every function call.
+ * To add functionality to the element, you can also simply write your own competence class and give it as a template parameter.
+ * You can access the functions implemented in your competence via the element. 
+ *
+ * The inheritance pattern is inspired by the \ref T8Type class (which also uses the CRTP).
+ * We decided to use this structure 1.) to be able to add new functionality easily and 
+ *    2.) for the cached options to keep the number of class member variables of the default to a minimum to save memory.
+ * The choice between calculate and cache is a tradeoff between runtime and memory usage. 
+ *
+ * \tparam TCompetence The competences you want to add to the default functionality of the element.
+ */
+template <template <typename> class... TCompetence>
+class element: public TCompetence<element<TCompetence...>>... {
+  using SelfType = element<TCompetence...>;
+
+ private:
+  // --- Variables to check which functionality is defined in 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.
+   */
+  template <template <typename> class T>
+  static constexpr bool
+  vertex_cache_defined ()
+  {
+    return requires (T<SelfType>& competence) { competence.vertex_cache_filled (); };
+  }
+  /* This variable is true if any of the given competences \ref TCompetence implements 
+  a function vertex_cache_filled */
+  static constexpr bool vertex_cache_exists = (false || ... || vertex_cache_defined<TCompetence> ());
+
+  /** Helper function to check if class T implements the function centroid_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
+  centroid_cache_defined ()
+  {
+    return requires (T<SelfType>& competence) { competence.centroid_cache_filled (); };
+  }
+  /* This variable is true if any of the given competences \ref TCompetence implements 
+  a function centroid_cache_filled. */
+  static constexpr bool centroid_cache_exists = (false || ... || centroid_cache_defined<TCompetence> ());
+
+ public:
+  /**
+   * Constructor for an element of a mesh.
+   * \param [in] mesh           Pointer to the mesh the element should belong to.
+   * \param [in] tree_id        The tree id of the element in the forest defining the mesh.
+   * \param [in] element_id     The element id of the element in the forest defining the mesh.
+   */
+  element (mesh<SelfType>* mesh, t8_locidx_t tree_id, t8_locidx_t element_id)
+    : m_mesh (mesh), m_tree_id (tree_id), m_element_id (element_id)
+  {
+  }
+
+  // --- Functions to check if caches exist. ---
+  /**
+   * Function that checks if a cache for the vertex coordinates exists.
+   * \return true if a cache for the vertex coordinates exists, false otherwise.
+   */
+  static constexpr bool
+  has_vertex_cache ()
+  {
+    return vertex_cache_exists;
+  }
+
+  /**
+   * Function that checks if a cache for the centroid exists.
+   * \return true if a cache for the centroid exists, false otherwise.
+   */
+  static constexpr bool
+  has_centroid_cache ()
+  {
+    return centroid_cache_exists;
+  }
+
+  // --- Functionality of the element. In each function, it is checked if a cached version exists (and is used then). ---
+  /**
+   * Getter for the refinement level of the mesh element.
+   * For this easily accessible variable, it makes no sense to provide a cached version.
+   * \return Refinement level of the mesh element.
+   */
+  t8_element_level
+  get_level () const
+  {
+    const t8_eclass_t tree_class = get_tree_class ();
+    const t8_element_t* element = get_element ();
+    return t8_forest_get_scheme (m_mesh->m_forest)->element_get_level (tree_class, element);
+  }
+
+  /**
+   * Getter for the element's shape.
+   * \return The shape of the element.
+   */
+  t8_element_shape_t
+  get_shape () const
+  {
+    return t8_forest_get_scheme (m_mesh->m_forest)->element_get_shape (get_tree_class (), get_element ());
+  }
+
+  /**
+   * Getter for the vertex coordinates of the mesh element.
+   * This function uses or sets the cached version defined in TCompetence if available and calculates if not.
+   * \return Vector with one coordinate array for each vertex of the element.
+   */
+  std::vector<t8_3D_point>
+  get_vertex_coordinates () const
+  {
+    // Check if we have a cached version and if the cache has already been filled.
+    if constexpr (vertex_cache_exists) {
+      if (this->vertex_cache_filled ()) {
+        return this->m_vertex_coordinates;
+      }
+    }
+    // Calculate the vertex coordinates.
+    const t8_element_t* element = get_element ();
+    const int num_corners
+      = t8_forest_get_scheme (m_mesh->m_forest)->element_get_num_corners (get_tree_class (), element);
+    std::vector<t8_3D_point> vertex_coordinates (num_corners);
+    for (int icorner = 0; icorner < num_corners; ++icorner) {
+      t8_forest_element_coordinate (m_mesh->m_forest, m_tree_id, element, icorner, vertex_coordinates[icorner].data ());
+    }
+    // Fill the cache in the cached version.
+    if constexpr (vertex_cache_exists) {
+      this->m_vertex_coordinates = std::move (vertex_coordinates);
+      return this->m_vertex_coordinates;
+    }
+    return vertex_coordinates;
+  }
+
+  /**
+   * Getter for the center of mass of the mesh element.
+   * This function uses the cached version defined in TCompetence if available and calculates if not.
+   * \return Coordinates of the center.
+   */
+  t8_3D_point
+  get_centroid () const
+  {
+    // Check if we have a cached version and if the cache has already been filled.
+    if constexpr (centroid_cache_exists) {
+      if (this->centroid_cache_filled ()) {
+        return this->m_centroid.value ();
+      }
+    }
+    t8_3D_point coordinates;
+    t8_forest_element_centroid (m_mesh->m_forest, m_tree_id, get_element (), coordinates.data ());
+    // Fill the cache in the cached version.
+    if constexpr (centroid_cache_exists) {
+      this->m_centroid = coordinates;
+    }
+    return coordinates;
+  }
+
+  //--- Getter for the member variables. ---
+  /**
+   * Getter for the tree id of the mesh element.
+   * \return The element's local tree id.
+   */
+  t8_locidx_t
+  get_local_tree_id () const
+  {
+    return m_tree_id;
+  }
+
+  /**
+   * Getter for the local element id of the mesh element.
+   * \return The local element id of the mesh element.
+   */
+  t8_locidx_t
+  get_local_element_id () const
+  {
+    return m_element_id;
+  }
+
+  /**
+   * Getter for the mesh to which the mesh element is belonging.
+   * \return Reference to the mesh.
+   */
+  const mesh<SelfType>*
+  get_mesh () const
+  {
+    return m_mesh;
+  }
+
+ private:
+  //--- Private getter for internal use. ---
+  /**
+   * Getter for the leaf element of the mesh element.
+   * \return The leaf element.
+   */
+  const t8_element_t*
+  get_element () const
+  {
+    return t8_forest_get_leaf_element_in_tree (m_mesh->m_forest, m_tree_id, m_element_id);
+  }
+
+  /**
+   * Getter for the eclass of the tree of the mesh element.
+   * \return The eclass of the element's tree.
+   */
+  t8_eclass_t
+  get_tree_class () const
+  {
+    return t8_forest_get_tree_class (m_mesh->m_forest, m_tree_id);
+  }
+
+  mesh<SelfType>* m_mesh;   /**< Pointer to the mesh the element is defined for. */
+  t8_locidx_t m_tree_id;    /**< The tree id of the element in the forest defined in the mesh. */
+  t8_locidx_t m_element_id; /**< The element id of the element in the forest defined in the mesh. */
+};
+
+}  // namespace t8_mesh_handle
+#endif /* !T8_ELEMENT_HXX */
diff --git a/mesh_handle/mesh.cxx b/mesh_handle/mesh.cxx
new file mode 100644
index 0000000000..dfd84b9efa
--- /dev/null
+++ b/mesh_handle/mesh.cxx
@@ -0,0 +1,30 @@
+/*
+  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 mesh.cxx
+ * This file is only necessary for cmake to build the library as static or shared library. 
+ * (At least one source file is needed.)
+ * The implementation of the mesh class is in the header file \ref mesh.hxx as it is a
+ * templated class.
+ */
+
+#include "mesh.hxx"
diff --git a/mesh_handle/mesh.hxx b/mesh_handle/mesh.hxx
new file mode 100644
index 0000000000..82423a6d19
--- /dev/null
+++ b/mesh_handle/mesh.hxx
@@ -0,0 +1,149 @@
+/*
+  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 mesh.hxx
+ * Definition of the mesh class of the handle.
+ */
+
+#ifndef T8_MESH_HXX
+#define T8_MESH_HXX
+
+#include <t8.h>
+#include <t8_forest/t8_forest_general.h>
+#include "element.hxx"
+#include <iterator>
+#include <memory>
+#include <vector>
+
+namespace t8_mesh_handle
+{
+
+/**
+ * Wrapper for a forest that enables it to be handled as a simple mesh object.
+ * \tparam TMeshElement The element class that should be used for the elements in the mesh class. 
+ *                                  This template parameter defines which element functionality is available 
+ *                                  and if it is cached or calculated.
+ */
+template <class TMeshElement = element<>>
+class mesh {
+ public:
+  friend TMeshElement; /**< Make the element class a friend to access private members of the mesh (e.g. the forest). */
+
+  using mesh_const_iterator =
+    typename std::vector<TMeshElement>::const_iterator; /**< Constant iterator type for the mesh elements. */
+
+  /** 
+   * Constructor for a mesh of the handle. 
+   * \param [in] input_forest The forest from which the mesh should be created. 
+   */
+  mesh (t8_forest_t input_forest): m_forest (input_forest)
+  {
+    update_elements ();
+  }
+
+  /**
+  * Getter for the number of local elements in the mesh.
+  * \return Number of local elements in the mesh.
+  */
+  t8_locidx_t
+  get_num_local_elements () const
+  {
+    return t8_forest_get_local_num_leaf_elements (m_forest);
+  }
+
+  /**
+   * Returns a constant iterator to the first (local) mesh element.
+   * \return Constant iterator to the first (local) mesh element.
+   */
+  mesh_const_iterator
+  begin () const
+  {
+    return m_elements.cbegin ();
+  }
+
+  /**
+   * Returns a constant iterator to a mesh element following the last (local) element of the mesh.
+   * \return Constant iterator to the mesh element following the last (local) element of the mesh.
+   */
+  mesh_const_iterator
+  end () const
+  {
+    return m_elements.cend ();
+  }
+
+  /**
+   * Getter for a mesh element given its local index.
+   * \param [in] local_index The local index of the element to access.
+   * \return Reference to the mesh element.
+   */
+  const TMeshElement&
+  operator[] (t8_locidx_t local_index) const
+  {
+    return m_elements[local_index];
+  }
+
+  /**
+   * Getter for the forest the mesh is defined for.
+   * \return The forest the mesh is defined for.
+   */
+  t8_forest_t
+  get_forest () const
+  {
+    return m_forest;
+  }
+
+  /** 
+  * 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)
+  {
+    m_forest = input_forest;
+    update_elements ();
+  }
+
+ private:
+  /** 
+   * Update the storage of the mesh elements according to the current forest. 
+   */
+  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.
+    for (t8_locidx_t itree = 0; itree < t8_forest_get_num_local_trees (m_forest); ++itree) {
+      const t8_locidx_t num_elems = t8_forest_get_tree_num_leaf_elements (m_forest, itree);
+      for (t8_locidx_t ielem = 0; ielem < num_elems; ++ielem) {
+        m_elements.emplace_back (this, itree, ielem);
+      }
+    }
+  }
+
+  t8_forest_t m_forest;                 /**< The forest the mesh should be defined for. */
+  std::vector<TMeshElement> m_elements; /**< Vector storing the mesh elements. */
+};
+
+}  // namespace t8_mesh_handle
+#endif /* !T8_MESH_HXX */
diff --git a/src/config.cmake.in b/src/config.cmake.in
index 2086547f60..c675f1b087 100644
--- a/src/config.cmake.in
+++ b/src/config.cmake.in
@@ -9,6 +9,7 @@ set( T8CODE_BUILD_AS_SHARED_LIBRARY @T8CODE_BUILD_AS_SHARED_LIBRARY@ )
 set( T8CODE_BUILD_TESTS @T8CODE_BUILD_TESTS@ )
 set( T8CODE_BUILD_TUTORIALS @T8CODE_BUILD_TUTORIALS@ )
 set( T8CODE_BUILD_EXAMPLES @T8CODE_BUILD_EXAMPLES@ )
+set( T8CODE_BUILD_MESH_HANDLE @T8CODE_BUILD_MESH_HANDLE@ )
 
 set( T8CODE_ENABLE_MPI @T8CODE_ENABLE_MPI@ )
 set( T8CODE_ENABLE_VTK @T8CODE_ENABLE_VTK@ )
diff --git a/src/t8_types/t8_crtp.hxx b/src/t8_types/t8_crtp.hxx
index 0ae18e09b8..73bc29d04a 100644
--- a/src/t8_types/t8_crtp.hxx
+++ b/src/t8_types/t8_crtp.hxx
@@ -29,8 +29,6 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 #ifndef T8_CRTP_HXX
 #define T8_CRTP_HXX
 
-#include <iostream>
-
 /**
   * The basic CRTP pattern.
   * \tparam TUnderlying The Underlying type.
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 3a3f1ede96..470fdbc405 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -38,13 +38,19 @@ function( add_t8_test )
 
     add_executable( ${ADD_T8_TEST_NAME} ${ADD_T8_TEST_SOURCES} )
 
-    # Check if test is a Fortran file and if MPI is enabled.
-    string ( FIND ${ADD_T8_TEST_NAME} "fortran" is_fortran_file  )
-    if ( (${is_fortran_file} GREATER_EQUAL 0) AND T8CODE_ENABLE_MPI )
-      target_include_directories( ${ADD_T8_TEST_NAME} PRIVATE ${CMAKE_BINARY_DIR}/src )
-      target_link_libraries( ${ADD_T8_TEST_NAME} PRIVATE T8 gtest pthread MPI::MPI_Fortran )
-    else()
-      target_link_libraries( ${ADD_T8_TEST_NAME} PRIVATE T8 gtest pthread )
+    # Link base libraries.
+    target_include_directories( ${ADD_T8_TEST_NAME} PRIVATE ${CMAKE_BINARY_DIR}/src )
+    target_link_libraries( ${ADD_T8_TEST_NAME} PRIVATE T8 gtest pthread )
+
+    # Check if test is a Fortran or mesh handle file.
+    string( FIND ${ADD_T8_TEST_NAME} "fortran" is_fortran_file )
+    string( FIND ${TEST_BUILD_DIR} "mesh_handle" is_mesh_handle_file )
+
+    if ( (${is_fortran_file} GREATER_EQUAL 0) AND T8CODE_ENABLE_MPI ) 
+        target_link_libraries( ${ADD_T8_TEST_NAME} PRIVATE MPI::MPI_Fortran )
+    endif ()
+    if ( (${is_mesh_handle_file} GREATER_EQUAL 0) )
+        target_link_libraries( ${ADD_T8_TEST_NAME} PRIVATE T8_MESH_HANDLE )
     endif ()
 
     set_target_properties(${ADD_T8_TEST_NAME} PROPERTIES
@@ -201,6 +207,11 @@ endif()
 
 add_t8_cpp_test( NAME t8_gtest_vector_split_serial          SOURCES t8_helper_functions/t8_gtest_vector_split.cxx )
 
+if( T8CODE_BUILD_MESH_HANDLE )
+  add_t8_cpp_test( NAME t8_gtest_mesh_handle_parallel        SOURCES mesh_handle/t8_gtest_mesh_handle.cxx )
+  add_t8_cpp_test( NAME t8_gtest_custom_competence_serial    SOURCES mesh_handle/t8_gtest_custom_competence.cxx )
+endif()
+
 copy_test_file( test_cube_unstructured_1.inp )
 copy_test_file( test_cube_unstructured_2.inp )
 copy_test_file( test_vtk_tri.vtu )
diff --git a/test/mesh_handle/t8_gtest_custom_competence.cxx b/test/mesh_handle/t8_gtest_custom_competence.cxx
new file mode 100644
index 0000000000..5aba5dbcb7
--- /dev/null
+++ b/test/mesh_handle/t8_gtest_custom_competence.cxx
@@ -0,0 +1,123 @@
+/*
+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_custom_competence.cxx
+ * Checks that custom-defined competences can be used as template parameters for the mesh. 
+ */
+
+#include <gtest/gtest.h>
+#include <test/t8_gtest_schemes.hxx>
+#include <t8.h>
+
+#include <mesh_handle/mesh.hxx>
+#include <mesh_handle/element.hxx>
+#include <mesh_handle/competences.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_operators.hxx>
+
+/**
+ * Custom competence that needs access to the public members of the elements.
+ * \tparam TUnderlying Use the \ref t8_mesh_handle::element with specified competences as template parameter.
+ */
+template <typename TUnderlying>
+struct dummy_get_level: public t8_crtp_operator<TUnderlying, dummy_get_level>
+{
+ public:
+  /** Getter for the level of the element. This function needs to access several members 
+  *     of the element such that we need the crtp structure here. 
+  * \return Level of the element.
+  */
+  t8_element_level
+  get_level_dummy () const
+  {
+    auto forest = this->underlying ().get_mesh ()->get_forest ();
+    const t8_eclass_t tree_class = t8_forest_get_tree_class (forest, this->underlying ().get_local_tree_id ());
+    const t8_element_t *element = t8_forest_get_leaf_element_in_tree (forest, this->underlying ().get_local_tree_id (),
+                                                                      this->underlying ().get_local_element_id ());
+    return t8_forest_get_scheme (forest)->element_get_level (tree_class, element);
+  }
+};
+
+/** Trivial competence to demonstrate that we can use more than one custom competence.
+ * \tparam TUnderlying Use the \ref t8_mesh_handle::element with specified competences as template parameter.
+ */
+template <typename TUnderlying>
+struct dummy_trivial: public t8_crtp_operator<TUnderlying, dummy_trivial>
+{
+ public:
+  /** Dummy getter that always returns 1.
+   * \return Always returns 1.
+   */
+  int
+  get_value_dummy () const
+  {
+    return 1;
+  }
+};
+
+/** This tests checks that custom defined competences can be used for the mesh class 
+ *  and that we can use the functionality defined in the competence. 
+ * Also checks that we can use more than one custom competence and that predefined competences can be additionally used.
+ */
+TEST (t8_gtest_custom_competence, custom_competence)
+{
+  // Define forest to construct mesh.
+  const int level = 1;
+  t8_cmesh_t cmesh = t8_cmesh_new_hypercube_hybrid (sc_MPI_COMM_WORLD, 0, 0);
+  const t8_scheme *scheme = t8_scheme_new_default ();
+  t8_forest_t forest = t8_forest_new_uniform (cmesh, scheme, level, 0, sc_MPI_COMM_WORLD);
+  ASSERT_EQ (true, t8_forest_is_committed (forest));
+
+  // Check mesh with custom defined competence.
+  t8_mesh_handle::mesh<t8_mesh_handle::element<dummy_get_level>> mesh
+    = t8_mesh_handle::mesh<t8_mesh_handle::element<dummy_get_level>> (forest);
+
+  for (auto it = mesh.begin (); it != mesh.end (); ++it) {
+    EXPECT_EQ (it->get_level (), it->get_level_dummy ());
+    EXPECT_EQ (level, it->get_level_dummy ());
+  }
+
+  // Test with two custom competences and a predefined competence.
+  t8_mesh_handle::mesh<t8_mesh_handle::element<dummy_get_level, dummy_trivial, t8_mesh_handle::cache_centroid>>
+    mesh_2competences
+    = t8_mesh_handle::mesh<t8_mesh_handle::element<dummy_get_level, dummy_trivial, t8_mesh_handle::cache_centroid>> (
+      forest);
+
+  for (auto it = mesh_2competences.begin (); it != mesh_2competences.end (); ++it) {
+    EXPECT_EQ (it->get_level (), it->get_level_dummy ());
+    EXPECT_EQ (it->get_value_dummy (), 1);
+    EXPECT_FALSE (it->centroid_cache_filled ());
+    auto centroid = it->get_centroid ();
+    for (const auto &coordinate : centroid) {
+      EXPECT_GE (1, coordinate);
+      EXPECT_LE (0, coordinate);
+    }
+    EXPECT_TRUE (it->centroid_cache_filled ());
+  }
+
+  // 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
new file mode 100644
index 0000000000..c454779096
--- /dev/null
+++ b/test/mesh_handle/t8_gtest_mesh_handle.cxx
@@ -0,0 +1,212 @@
+/*
+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_mesh_handle.cxx
+ * Tests if the mesh class of the handle works as intended for different types of predefined template parameter classes. 
+ */
+
+#include <gtest/gtest.h>
+#include <test/t8_gtest_schemes.hxx>
+#include <test/t8_gtest_macros.hxx>
+#include <t8.h>
+
+#include <mesh_handle/mesh.hxx>
+#include <mesh_handle/element.hxx>
+#include <mesh_handle/competences.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>
+
+/** Parametrized test fixture for the mesh handle tests. */
+class t8_mesh_handle_test: public testing::TestWithParam<std::tuple<t8_eclass_t, int>> {
+ protected:
+  void
+  SetUp () override
+  {
+    const t8_scheme* scheme = t8_scheme_new_default ();
+    t8_eclass_t eclass = std::get<0> (GetParam ());
+    level = std::get<1> (GetParam ());
+    t8_cmesh_t cmesh = t8_cmesh_new_hypercube (eclass, sc_MPI_COMM_WORLD, 0, 1, 0);
+    forest = t8_forest_new_uniform (cmesh, scheme, level, 0, sc_MPI_COMM_WORLD);
+  }
+  void
+  TearDown () override
+  {
+    t8_forest_unref (&forest);
+  }
+
+  t8_forest_t forest;
+  int level;
+};
+
+/** Test some default functionality and the iterator of \ref t8_mesh_handle::mesh class. */
+TEST_P (t8_mesh_handle_test, test_iterator)
+{
+  ASSERT_TRUE (t8_forest_is_committed (forest));
+
+  // --- Check default functionality. ---
+  t8_mesh_handle::mesh<t8_mesh_handle::element<>> mesh = t8_mesh_handle::mesh<t8_mesh_handle::element<>> (forest);
+  EXPECT_FALSE (t8_mesh_handle::element<>::has_vertex_cache ());
+  EXPECT_FALSE (t8_mesh_handle::element<>::has_centroid_cache ());
+
+  // Iterate with the iterator over all mesh elements and check some functionality.
+  for (auto it = mesh.begin (); it != mesh.end (); ++it) {
+    EXPECT_FALSE (it->has_vertex_cache ());
+    EXPECT_FALSE (it->has_centroid_cache ());
+    auto centroid = it->get_centroid ();
+    for (const auto& coordinate : centroid) {
+      EXPECT_GE (1, coordinate);
+      EXPECT_LE (0, coordinate);
+    }
+    // Test dereference operator.
+    auto vertex_coordinates = (*it).get_vertex_coordinates ();
+    for (int ivertex = 0; ivertex < (int) vertex_coordinates.size (); ++ivertex) {
+      for (const auto& coordinate : vertex_coordinates[ivertex]) {
+        EXPECT_GE (1, coordinate);
+        EXPECT_LE (0, coordinate);
+      }
+    }
+  }
+
+  // Check loop with indices.
+  for (int ielement = 0; ielement < mesh.get_num_local_elements (); ielement++) {
+    EXPECT_EQ (level, mesh[ielement].get_level ());
+  }
+}
+
+/** Test competences. */
+TEST_P (t8_mesh_handle_test, test_competences)
+{
+  ASSERT_TRUE (t8_forest_is_committed (forest));
+
+  // --- Version with cached vertex coordinates. ---
+  using mesh_element_vertex = t8_mesh_handle::element<t8_mesh_handle::cache_vertex_coordinates>;
+  t8_mesh_handle::mesh<mesh_element_vertex> mesh_vertex_coordinates
+    = t8_mesh_handle::mesh<mesh_element_vertex> (forest);
+  EXPECT_TRUE (mesh_element_vertex::has_vertex_cache ());
+  EXPECT_FALSE (mesh_element_vertex::has_centroid_cache ());
+
+  // Iterate with the iterator over all mesh elements and check functionality.
+  for (auto it = mesh_vertex_coordinates.begin (); it != mesh_vertex_coordinates.end (); ++it) {
+    EXPECT_FALSE (it->vertex_cache_filled ());
+    EXPECT_EQ (level, it->get_level ());
+    auto centroid = it->get_centroid ();
+    for (const auto& coordinate : centroid) {
+      EXPECT_GE (1, coordinate);
+      EXPECT_LE (0, coordinate);
+    }
+    auto vertex_coordinates = it->get_vertex_coordinates ();
+    for (int ivertex = 0; ivertex < (int) vertex_coordinates.size (); ++ivertex) {
+      for (const auto& coordinate : vertex_coordinates[ivertex]) {
+        EXPECT_GE (1, coordinate);
+        EXPECT_LE (0, coordinate);
+      }
+    }
+  }
+  // Check cached value.
+  for (auto it = mesh_vertex_coordinates.begin (); it != mesh_vertex_coordinates.end (); ++it) {
+    EXPECT_TRUE (it->vertex_cache_filled ());
+    auto vertex_coordinates = it->get_vertex_coordinates ();
+    for (int ivertex = 0; ivertex < (int) vertex_coordinates.size (); ++ivertex) {
+      for (const auto& coordinate : vertex_coordinates[ivertex]) {
+        EXPECT_GE (1, coordinate);
+        EXPECT_LE (0, coordinate);
+      }
+    }
+  }
+
+  // --- Version with cached centroid variable. ---
+  using mesh_element_centroid = t8_mesh_handle::element<t8_mesh_handle::cache_centroid>;
+  t8_mesh_handle::mesh<mesh_element_centroid> mesh_centroid = t8_mesh_handle::mesh<mesh_element_centroid> (forest);
+  EXPECT_FALSE (mesh_element_centroid::has_vertex_cache ());
+  EXPECT_TRUE (mesh_element_centroid::has_centroid_cache ());
+
+  // Iterate with the iterator over all mesh elements.
+  for (auto it = mesh_centroid.begin (); it != mesh_centroid.end (); ++it) {
+    EXPECT_FALSE (it->centroid_cache_filled ());
+    auto centroid = it->get_centroid ();
+    for (const auto& coordinate : centroid) {
+      EXPECT_GE (1, coordinate);
+      EXPECT_LE (0, coordinate);
+    }
+    EXPECT_TRUE (it->centroid_cache_filled ());
+    auto centroid_cached = it->get_centroid ();
+    for (const auto& coordinate : centroid_cached) {
+      EXPECT_GE (1, coordinate);
+      EXPECT_LE (0, coordinate);
+    }
+  }
+}
+
+/** Test mesh (element) class with more than one competence. */
+TEST_P (t8_mesh_handle_test, test_2_competences)
+{
+  ASSERT_TRUE (t8_forest_is_committed (forest));
+
+  // --- Use competences to cache level and centroid. ---
+  using mesh_element
+    = t8_mesh_handle::element<t8_mesh_handle::cache_vertex_coordinates, t8_mesh_handle::cache_centroid>;
+  t8_mesh_handle::mesh<mesh_element> mesh = t8_mesh_handle::mesh<mesh_element> (forest);
+  EXPECT_TRUE (mesh_element::has_vertex_cache ());
+  EXPECT_TRUE (mesh_element::has_centroid_cache ());
+
+  // Iterate with the iterator over all mesh elements.
+  for (auto it = mesh.begin (); it != mesh.end (); ++it) {
+    EXPECT_FALSE (it->centroid_cache_filled ());
+    EXPECT_FALSE (it->vertex_cache_filled ());
+    EXPECT_EQ (level, it->get_level ());
+    auto centroid = it->get_centroid ();
+    for (const auto& coordinate : centroid) {
+      EXPECT_GE (1, coordinate);
+      EXPECT_LE (0, coordinate);
+    }
+    auto vertex_coordinates = it->get_vertex_coordinates ();
+    for (int ivertex = 0; ivertex < (int) vertex_coordinates.size (); ++ivertex) {
+      for (const auto& coordinate : vertex_coordinates[ivertex]) {
+        EXPECT_GE (1, coordinate);
+        EXPECT_LE (0, coordinate);
+      }
+    }
+  }
+  // Test dereference operator. (Here the cached values should be used.)
+  for (auto it = mesh.begin (); it != mesh.end (); ++it) {
+    EXPECT_TRUE (it->centroid_cache_filled ());
+    EXPECT_TRUE (it->vertex_cache_filled ());
+    EXPECT_EQ (level, (*it).get_level ());
+    auto centroid = (*it).get_centroid ();
+    for (const auto& coordinate : centroid) {
+      EXPECT_GE (1, coordinate);
+      EXPECT_LE (0, coordinate);
+    }
+    auto vertex_coordinates = it->get_vertex_coordinates ();
+    for (int ivertex = 0; ivertex < (int) vertex_coordinates.size (); ++ivertex) {
+      for (const auto& coordinate : vertex_coordinates[ivertex]) {
+        EXPECT_GE (1, coordinate);
+        EXPECT_LE (0, coordinate);
+      }
+    }
+  }
+}
+
+INSTANTIATE_TEST_SUITE_P (t8_gtest_mesh, t8_mesh_handle_test, testing::Combine (AllEclasses, testing::Range (2, 3)));