diff --git a/mesh_handle/README.md b/mesh_handle/README.md
index 5339218920..7cb21192ec 100644
--- a/mesh_handle/README.md
+++ b/mesh_handle/README.md
@@ -6,6 +6,7 @@ Some application codes are designed for unstructured or uniform meshes and canno
 
 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 folder's most important files are: 
+The [mesh.hxx](mesh.hxx) defines the mesh class of the handle. This is the central file of the mesh handle. 
+The [element.hxx](element.hxx) defines the elements (mesh or ghost elements) of the mesh handle.
 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
index c452555fd4..d4bc37a5b0 100644
--- a/mesh_handle/competences.hxx
+++ b/mesh_handle/competences.hxx
@@ -26,7 +26,8 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
  * 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. 
+ * We use the CRTP pattern as we may need to access members of the derived classes like 
+ * \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, 
@@ -41,8 +42,6 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 #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>
 
@@ -95,5 +94,49 @@ struct cache_centroid: public t8_crtp_operator<TUnderlying, cache_centroid>
     m_centroid; /**< Cache for the coordinates of the centroid. Use optional to allow no value if cache is not filled. */
 };
 
+/**
+ * Competence to cache the neighbors of an element at a specific face at the first function call.
+ * \tparam TUnderlying Use the \ref element with specified competences as template parameter.
+ */
+template <typename TUnderlying>
+struct cache_neighbors: t8_crtp_operator<TUnderlying, cache_centroid>
+{
+ public:
+  /**
+   * Function that checks if the neighbor cache for a face has been filled.
+   * \param [in] face The face for which the cache should be checked.
+   * \return true if the cache has been filled, false otherwise.
+   */
+  bool
+  neighbor_cache_filled (int face) const
+  {
+    return m_num_neighbors[face].has_value ();
+  }
+
+  /**
+   * Function that checks if the neighbor cache for any face has been filled.
+   * \return true if the cache has been filled, false otherwise.
+   */
+  bool
+  neighbor_cache_filled_any () const
+  {
+    for (int iface = 0; iface < this->underlying ().get_num_faces (); ++iface) {
+      if (neighbor_cache_filled (iface)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+ protected:
+  mutable std::vector<std::vector<const TUnderlying *>>
+    m_neighbors; /**< Neighboring elements at each face. The length of the vectors is stored in \ref m_num_neighbors. */
+  mutable std::vector<std::optional<int>>
+    m_num_neighbors; /**< Vector with the numbers of neighbor elements at each face. 
+                        num_neighbors is stored to indicate that the cache is filled if a face does not have any neighbor. */
+  mutable std::vector<std::vector<int>>
+    m_dual_faces; /**< Face id's of the neighboring elements' faces for each face. */
+};
+
 }  // namespace t8_mesh_handle
 #endif /* !T8_COMPETENCES_HXX */
diff --git a/mesh_handle/element.hxx b/mesh_handle/element.hxx
index 685792e9f7..6701418ea9 100644
--- a/mesh_handle/element.hxx
+++ b/mesh_handle/element.hxx
@@ -21,7 +21,7 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 */
 
 /** \file element.hxx
- * Definition of the elements used in the \ref t8_mesh_handle::mesh class.
+ * Definition of the element class of the \ref t8_mesh_handle::mesh handle (can be ghost or mesh elements).
  */
 
 #ifndef T8_ELEMENT_HXX
@@ -34,25 +34,26 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 #include <t8_forest/t8_forest_geometrical.h>
 #include <t8_schemes/t8_scheme.hxx>
 #include <t8_types/t8_vec.hxx>
-#include <array>
 #include <vector>
+#include <optional>
 
 namespace t8_mesh_handle
 {
-/* Forward declaration of the \ref mesh class of the handle.
+/** Forward declaration of the \ref mesh class of the handle.
  */
-template <class TMeshElement>
+template <template <typename> class... TCompetence>
 class mesh;
 
 /** 
- * Class for the elements of the mesh handle. 
- * The element without specified template parameters provides default implementations for basic functionality 
+ * Definition of the mesh element class of the \ref mesh handle.
+ * An 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.
+ * recalculation 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. 
+ * Please note that the competence should be valid for both, mesh elements and ghost elements.
  *
  * 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 
@@ -63,9 +64,40 @@ class mesh;
  */
 template <template <typename> class... TCompetence>
 class element: public TCompetence<element<TCompetence...>>... {
-  using SelfType = element<TCompetence...>;
-
  private:
+  using SelfType = element<TCompetence...>; /**< Type of the current class with all template parameters specified. */
+  using mesh_class = mesh<TCompetence...>;  /**< Type of the mesh class used. */
+  friend mesh_class; /**< Define mesh_class as friend to be able to access e.g. the constructor. */
+
+  /**
+   * Private constructor for an element of a mesh. This could be a simple mesh element or a ghost element.
+   * This constructor should only be called by the mesh_class (and invisible for the user).
+   * \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.
+   * \param [in] is_ghost_element Flag to indicate that this element is a ghost element. Default is false.
+   */
+  element (mesh_class* mesh, t8_locidx_t tree_id, t8_locidx_t element_id, bool is_ghost_element = false)
+    : m_mesh (mesh), m_tree_id (tree_id), m_element_id (element_id), m_is_ghost_element (is_ghost_element)
+  {
+    if (m_is_ghost_element) {
+      // The local ghost tree id is per definition the local tree id - number of local (non-ghost) trees.
+      m_element = t8_forest_ghost_get_leaf_element (
+        m_mesh->m_forest, m_tree_id - t8_forest_get_num_local_trees (m_mesh->m_forest), m_element_id);
+    }
+    else {
+      m_element = t8_forest_get_leaf_element_in_tree (m_mesh->m_forest, m_tree_id, m_element_id);
+    }
+
+    if constexpr (neighbor_cache_exists) {
+      // Resize neighbor caches for clean access to the caches.
+      const int num_faces = this->get_num_faces ();
+      this->m_num_neighbors.resize (num_faces);
+      this->m_dual_faces.resize (num_faces);
+      this->m_neighbors.resize (num_faces);
+    }
+  }
+
   // --- 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.
@@ -77,8 +109,8 @@ class element: public TCompetence<element<TCompetence...>>... {
   {
     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 */
+  /** This variable is true if any of the given competences \a 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.
@@ -91,23 +123,26 @@ class element: public TCompetence<element<TCompetence...>>... {
   {
     return requires (T<SelfType>& competence) { competence.centroid_cache_filled (); };
   }
-  /* This variable is true if any of the given competences \ref TCompetence implements 
+  /** This variable is true if any of the given competences \a 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.
+  /** Helper function to check if class T implements the function neighbor_cache_filled.
+   * \tparam T The competence to be checked.
+   * \return true if T implements the function, false if not.
    */
-  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)
+  template <template <typename> class T>
+  static constexpr bool
+  neighbor_cache_defined ()
   {
+    return requires (T<SelfType>& competence) { competence.neighbor_cache_filled (0); };
   }
+  /** This variable is true if any of the given competences \a TCompetence implements 
+  a function neighbor_cache_filled. */
+  static constexpr bool neighbor_cache_exists = (false || ... || neighbor_cache_defined<TCompetence> ());
 
-  // --- Functions to check if caches exist. ---
+ public:
+  // --- Public 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.
@@ -128,22 +163,44 @@ class element: public TCompetence<element<TCompetence...>>... {
     return centroid_cache_exists;
   }
 
+  /**
+   * Function that checks if a cache for the face neighbors exists.
+   * \return true if a cache exists, false otherwise.
+   */
+  static constexpr bool
+  has_face_neighbor_cache ()
+  {
+    return neighbor_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.
+   * Getter for the refinement level of the element.
    * For this easily accessible variable, it makes no sense to provide a cached version.
-   * \return Refinement level of the mesh element.
+   * \return Refinement level of the element.
    */
   t8_element_level
   get_level () const
   {
-    const t8_eclass_t tree_class = get_tree_class ();
+    const t8_eclass_t eclass = 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);
+    return t8_forest_get_scheme (m_mesh->m_forest)->element_get_level (eclass, element);
+  }
+
+  /**
+   * Getter for the number of faces of the element.
+   * For this easily accessible variable, it makes no sense to provide a cached version.
+   * \return Number of faces of the element.
+   */
+  int
+  get_num_faces () const
+  {
+    return t8_forest_get_scheme (m_mesh->m_forest)->element_get_num_faces (get_tree_class (), get_element ());
   }
 
   /**
    * Getter for the element's shape.
+   * For this easily accessible variable, it makes no sense to provide a cached version.
    * \return The shape of the element.
    */
   t8_element_shape_t
@@ -153,7 +210,7 @@ class element: public TCompetence<element<TCompetence...>>... {
   }
 
   /**
-   * Getter for the vertex coordinates of the mesh 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.
    * \return Vector with one coordinate array for each vertex of the element.
    */
@@ -183,7 +240,7 @@ class element: public TCompetence<element<TCompetence...>>... {
   }
 
   /**
-   * Getter for the center of mass of the mesh element.
+   * Getter for the center of mass of the element.
    * This function uses the cached version defined in TCompetence if available and calculates if not.
    * \return Coordinates of the center.
    */
@@ -205,9 +262,74 @@ class element: public TCompetence<element<TCompetence...>>... {
     return coordinates;
   }
 
+  /** Getter for the face neighbors of the mesh element at a given face.
+   * This function uses the cached version defined in TCompetence if available and calculates if not.
+   * \param [in]  face          The index of the face across which the face neighbors are searched.
+   * \param [out] dual_faces    On output the face id's of the neighboring elements' faces.
+   * \return Vector of length num_neighbors with pointers to the elements neighboring at the given face.
+   */
+  std::vector<const SelfType*>
+  get_face_neighbors (int face, std::optional<std::reference_wrapper<std::vector<int>>> dual_faces = std::nullopt) const
+  {
+    SC_CHECK_ABORT (!m_is_ghost_element, "get_face_neighbors is not implemented for ghost elements.\n");
+    if constexpr (neighbor_cache_exists) {
+      if (this->neighbor_cache_filled (face)) {
+        if (dual_faces) {
+          dual_faces->get () = this->m_dual_faces[face];
+        }
+        return this->m_neighbors[face];
+      }
+    }
+    std::vector<std::reference_wrapper<SelfType>> neighbor_elements;
+    t8_element_t** neighbors; /**< Neighboring elements. */
+    int* dual_faces_internal; /**< Face indices of the neighbor elements. */
+    int num_neighbors;        /**< Number of neighboring elements. */
+    t8_locidx_t* neighids;    /**< Neighboring elements ids. */
+    t8_eclass_t neigh_class;  /**< Neighboring elements tree class. */
+
+    t8_forest_leaf_face_neighbors (m_mesh->m_forest, m_tree_id, get_element (), &neighbors, face, &dual_faces_internal,
+                                   &num_neighbors, &neighids, &neigh_class, t8_forest_is_balanced (m_mesh->m_forest));
+    if (dual_faces) {
+      dual_faces->get ().assign (dual_faces_internal, dual_faces_internal + num_neighbors);
+    }
+    std::vector<const SelfType*> neighbors_handle;
+    for (int ineighs = 0; ineighs < num_neighbors; ineighs++) {
+      neighbors_handle.push_back (&((*m_mesh)[neighids[ineighs]]));
+    }
+    if constexpr (neighbor_cache_exists) {
+      // Also store num_neighbors in cache to indicate that the cache is filled if a face does not have any neighbor.
+      this->m_num_neighbors[face] = num_neighbors;
+      this->m_dual_faces[face].assign (dual_faces_internal, dual_faces_internal + num_neighbors);
+      this->m_neighbors[face] = std::move (neighbors_handle);
+    }
+    if (num_neighbors > 0) {
+      // Free allocated memory.
+      t8_forest_get_scheme (m_mesh->m_forest)->element_destroy (get_tree_class (), num_neighbors, neighbors);
+      T8_FREE (neighbors);
+      T8_FREE (dual_faces_internal);
+      T8_FREE (neighids);
+    }
+    if constexpr (neighbor_cache_exists) {
+      return this->m_neighbors[face];
+    }
+    return neighbors_handle;
+  }
+
+  /**
+   * Function to fill the face neighbor cache for all faces of the mesh element.
+   */
+  void
+  fill_face_neighbor_cache () const
+    requires (neighbor_cache_exists)
+  {
+    for (int iface = 0; iface < get_num_faces (); iface++) {
+      get_face_neighbors (iface);
+    }
+  }
+
   //--- Getter for the member variables. ---
   /**
-   * Getter for the tree id of the mesh element.
+   * Getter for the tree id of the element.
    * \return The element's local tree id.
    */
   t8_locidx_t
@@ -217,8 +339,8 @@ class element: public TCompetence<element<TCompetence...>>... {
   }
 
   /**
-   * Getter for the local element id of the mesh element.
-   * \return The local element id of the mesh element.
+   * Getter for the local element id in the tree of the element.
+   * \return The local element id in the tree of the element.
    */
   t8_locidx_t
   get_local_element_id () const
@@ -227,29 +349,55 @@ class element: public TCompetence<element<TCompetence...>>... {
   }
 
   /**
-   * Getter for the mesh to which the mesh element is belonging.
+   * Getter for the flat local element id. This is the index of the element in the mesh to which the element belongs.
+   * \return The flat local element id of the element.
+   */
+  t8_locidx_t
+  get_flat_element_id () const
+  {
+    if (m_is_ghost_element) {
+      return m_mesh->get_num_local_elements ()
+             + t8_forest_ghost_get_tree_element_offset (m_mesh->m_forest,
+                                                        m_tree_id - t8_forest_get_num_local_trees (m_mesh->m_forest))
+             + m_element_id;
+    }
+    return t8_forest_get_tree_element_offset (m_mesh->m_forest, m_tree_id) + m_element_id;
+  }
+
+  /**
+   * Getter for the mesh to which the element belongs.
    * \return Reference to the mesh.
    */
-  const mesh<SelfType>*
+  const mesh_class*
   get_mesh () const
   {
     return m_mesh;
   }
 
+  /**
+   * Function to check if the element is a ghost element.
+   * \return true if the element is a ghost element, false otherwise.
+   */
+  bool
+  is_ghost_element () const
+  {
+    return m_is_ghost_element;
+  }
+
  private:
   //--- Private getter for internal use. ---
   /**
-   * Getter for the leaf element of the mesh element.
+   * Getter for the leaf element of the 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);
+    return m_element;
   }
 
   /**
-   * Getter for the eclass of the tree of the mesh element.
+   * Getter for the eclass of the tree of the element.
    * \return The eclass of the element's tree.
    */
   t8_eclass_t
@@ -258,9 +406,11 @@ class element: public TCompetence<element<TCompetence...>>... {
     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. */
+  const mesh_class* m_mesh;       /**< Pointer to the mesh the element is defined for. */
+  const t8_locidx_t m_tree_id;    /**< The tree id of the element in the forest defined in the mesh. */
+  const t8_locidx_t m_element_id; /**< The element id of the element in the forest defined in the mesh. */
+  const bool m_is_ghost_element;  /**< Flag to indicate if the element is a ghost element. */
+  const t8_element_t* m_element;  /**< Cache the pointer to element in the forest as this is often needed. */
 };
 
 }  // namespace t8_mesh_handle
diff --git a/mesh_handle/mesh.hxx b/mesh_handle/mesh.hxx
index 82423a6d19..152e2e2bd8 100644
--- a/mesh_handle/mesh.hxx
+++ b/mesh_handle/mesh.hxx
@@ -30,8 +30,7 @@
 #include <t8.h>
 #include <t8_forest/t8_forest_general.h>
 #include "element.hxx"
-#include <iterator>
-#include <memory>
+#include <t8_forest/t8_forest_ghost.h>
 #include <vector>
 
 namespace t8_mesh_handle
@@ -39,17 +38,16 @@ 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.
+ * \tparam TCompetence The competences you want to add to the default functionality of the mesh.
+ *         \see element for more details on the choice of the template parameter.   
  */
-template <class TMeshElement = element<>>
+template <template <typename> class... TCompetence>
 class mesh {
  public:
-  friend TMeshElement; /**< Make the element class a friend to access private members of the mesh (e.g. the forest). */
-
+  using element_class = element<TCompetence...>; /**< The element class of the mesh with given competences. */
+  friend element_class; /**< Element class as friend such that private members (e.g. the forest) can be accessed. */
   using mesh_const_iterator =
-    typename std::vector<TMeshElement>::const_iterator; /**< Constant iterator type for the mesh elements. */
+    typename std::vector<element_class>::const_iterator; /**< Constant iterator type for the mesh elements. */
 
   /** 
    * Constructor for a mesh of the handle. 
@@ -57,19 +55,40 @@ class mesh {
    */
   mesh (t8_forest_t input_forest): m_forest (input_forest)
   {
+    T8_ASSERT (t8_forest_is_committed (m_forest));
     update_elements ();
   }
 
   /**
-  * Getter for the number of local elements in the mesh.
-  * \return Number of local elements in the mesh.
-  */
+   * 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);
   }
 
+  /**
+   * Getter for the number of ghost elements.
+   * \return Number of ghost elements in the mesh.
+   */
+  t8_locidx_t
+  get_num_ghosts () const
+  {
+    return t8_forest_get_num_ghosts (m_forest);
+  }
+
+  /** 
+   * Getter for the dimension of the mesh.
+   * \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.
@@ -91,14 +110,23 @@ class mesh {
   }
 
   /**
-   * Getter for a mesh element given its local index.
+   * Getter for an element given its local index. This could be a (local) mesh element or 
+   *  a ghost element. 
+   * The indices 0, 1, ... num_local_el - 1 refer to local mesh elements and 
+   *    num_local_el , ... , num_local_el + num_ghosts - 1 refer to ghost elements.
    * \param [in] local_index The local index of the element to access.
-   * \return Reference to the mesh element.
+   * \return Reference to the element.
    */
-  const TMeshElement&
+  const element_class&
   operator[] (t8_locidx_t local_index) const
   {
-    return m_elements[local_index];
+    T8_ASSERT (0 <= local_index && local_index < get_num_local_elements () + get_num_ghosts ());
+    if (local_index < get_num_local_elements ()) {
+      return m_elements[local_index];
+    }
+    else {
+      return m_ghosts[local_index - get_num_local_elements ()];
+    }
   }
 
   /**
@@ -118,6 +146,7 @@ class mesh {
   void
   set_forest (t8_forest_t input_forest)
   {
+    T8_ASSERT (t8_forest_is_committed (input_forest));
     m_forest = input_forest;
     update_elements ();
   }
@@ -136,13 +165,34 @@ class mesh {
     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);
+        m_elements.push_back (element_class (this, itree, ielem));
+      }
+    }
+    update_ghost_elements ();
+  }
+
+  /** 
+   * Update the storage of the ghost elements according to the current forest. 
+   */
+  void
+  update_ghost_elements ()
+  {
+    // Clear the ghost vector if already created.
+    m_ghosts.clear ();
+    m_ghosts.reserve (get_num_ghosts ());
+    t8_locidx_t num_loc_trees = t8_forest_get_num_local_trees (m_forest);
+
+    for (t8_locidx_t itree = 0; itree < t8_forest_get_num_ghost_trees (m_forest); ++itree) {
+      const t8_locidx_t num_elems = t8_forest_ghost_tree_num_leaf_elements (m_forest, itree);
+      for (t8_locidx_t ielem = 0; ielem < num_elems; ++ielem) {
+        m_ghosts.push_back (element_class (this, num_loc_trees + itree, ielem, true));
       }
     }
   }
 
-  t8_forest_t m_forest;                 /**< The forest the mesh should be defined for. */
-  std::vector<TMeshElement> m_elements; /**< Vector storing the mesh elements. */
+  t8_forest_t m_forest;                  /**< The forest the mesh should be defined for. */
+  std::vector<element_class> m_elements; /**< Vector storing the (local) mesh elements. */
+  std::vector<element_class> m_ghosts;   /**< Vector storing the (local) ghost elements. */
 };
 
 }  // namespace t8_mesh_handle
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 569460e057..f292445e87 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -213,6 +213,7 @@ add_t8_cpp_test( NAME t8_gtest_vector_split_serial          SOURCES t8_helper_fu
 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_compare_handle_to_forest_serial  SOURCES mesh_handle/t8_gtest_compare_handle_to_forest.cxx )
+  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 )
 endif()
diff --git a/test/mesh_handle/t8_gtest_cache_competence.cxx b/test/mesh_handle/t8_gtest_cache_competence.cxx
index 49ec011b1b..e5f315b2f3 100644
--- a/test/mesh_handle/t8_gtest_cache_competence.cxx
+++ b/test/mesh_handle/t8_gtest_cache_competence.cxx
@@ -26,11 +26,9 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
  */
 
 #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>
@@ -97,12 +95,11 @@ class t8_gtest_cache_competence: public testing::Test {
  */
 TEST_F (t8_gtest_cache_competence, cache_vertex_coordinates)
 {
-  ASSERT_EQ (true, t8_forest_is_committed (forest));
-
-  using mesh_element = t8_mesh_handle::element<cache_vertex_coordinates_overwrite>;
-  t8_mesh_handle::mesh<mesh_element> mesh = t8_mesh_handle::mesh<mesh_element> (forest);
-  EXPECT_TRUE (mesh_element::has_vertex_cache ());
-  EXPECT_FALSE (mesh_element::has_centroid_cache ());
+  using mesh_class = t8_mesh_handle::mesh<cache_vertex_coordinates_overwrite>;
+  using element_class = mesh_class::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) {
@@ -131,12 +128,11 @@ TEST_F (t8_gtest_cache_competence, cache_vertex_coordinates)
  */
 TEST_F (t8_gtest_cache_competence, cache_centroid)
 {
-  ASSERT_EQ (true, t8_forest_is_committed (forest));
-
-  using mesh_element = t8_mesh_handle::element<cache_centroid_overwrite>;
-  t8_mesh_handle::mesh<mesh_element> mesh = t8_mesh_handle::mesh<mesh_element> (forest);
-  EXPECT_FALSE (mesh_element::has_vertex_cache ());
-  EXPECT_TRUE (mesh_element::has_centroid_cache ());
+  using mesh_class = t8_mesh_handle::mesh<cache_centroid_overwrite>;
+  using element_class = mesh_class::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 });
   for (auto it = mesh.begin (); it != mesh.end (); ++it) {
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 3dfeed3cbe..bd0e69f5a8 100644
--- a/test/mesh_handle/t8_gtest_compare_handle_to_forest.cxx
+++ b/test/mesh_handle/t8_gtest_compare_handle_to_forest.cxx
@@ -29,7 +29,6 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 #include <t8.h>
 
 #include <mesh_handle/mesh.hxx>
-#include <mesh_handle/element.hxx>
 #include <t8_cmesh/t8_cmesh.h>
 #include <t8_cmesh/t8_cmesh_examples.h>
 #include <t8_forest/t8_forest_general.h>
@@ -40,16 +39,15 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
  */
 TEST (t8_gtest_compare_handle_to_forest, compare_handle_to_forest)
 {
-  // Define forest and mesh handle mesh.
+  // 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);
-  ASSERT_EQ (true, t8_forest_is_committed (forest));
 
-  t8_mesh_handle::mesh<t8_mesh_handle::element<>> mesh = t8_mesh_handle::mesh<t8_mesh_handle::element<>> (forest);
+  t8_mesh_handle::mesh<> mesh = t8_mesh_handle::mesh<> (forest);
 
-  //Iterate over the elements of the forest and of the mesh handle simultaneously and compare results of different functions.
+  // Iterate over the elements of the forest and of the mesh handle simultaneously and compare results of different functions.
   const t8_scheme *scheme = t8_forest_get_scheme (forest);
   // Use iterator for the mesh handle and two nested for-loops for the forest.
   auto mesh_iterator = mesh.begin ();
diff --git a/test/mesh_handle/t8_gtest_custom_competence.cxx b/test/mesh_handle/t8_gtest_custom_competence.cxx
index 5aba5dbcb7..491556f2e1 100644
--- a/test/mesh_handle/t8_gtest_custom_competence.cxx
+++ b/test/mesh_handle/t8_gtest_custom_competence.cxx
@@ -26,11 +26,9 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
  */
 
 #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>
@@ -89,11 +87,9 @@ TEST (t8_gtest_custom_competence, custom_competence)
   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);
+  t8_mesh_handle::mesh<dummy_get_level> mesh = t8_mesh_handle::mesh<dummy_get_level> (forest);
 
   for (auto it = mesh.begin (); it != mesh.end (); ++it) {
     EXPECT_EQ (it->get_level (), it->get_level_dummy ());
@@ -101,12 +97,10 @@ TEST (t8_gtest_custom_competence, custom_competence)
   }
 
   // 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);
+  using mesh_class = t8_mesh_handle::mesh<dummy_get_level, dummy_trivial, t8_mesh_handle::cache_centroid>;
+  mesh_class mesh_more_competences = mesh_class (forest);
 
-  for (auto it = mesh_2competences.begin (); it != mesh_2competences.end (); ++it) {
+  for (auto it = mesh_more_competences.begin (); it != mesh_more_competences.end (); ++it) {
     EXPECT_EQ (it->get_level (), it->get_level_dummy ());
     EXPECT_EQ (it->get_value_dummy (), 1);
     EXPECT_FALSE (it->centroid_cache_filled ());
diff --git a/test/mesh_handle/t8_gtest_ghost.cxx b/test/mesh_handle/t8_gtest_ghost.cxx
new file mode 100644
index 0000000000..011605b021
--- /dev/null
+++ b/test/mesh_handle/t8_gtest_ghost.cxx
@@ -0,0 +1,211 @@
+/*
+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_ghost.cxx
+ * Tests if the ghost elements and the \ref t8_mesh_handle::element::get_face_neighbor implementation work as intended.
+ */
+
+#include <gtest/gtest.h>
+#include <test/t8_gtest_macros.hxx>
+#include <t8.h>
+
+#include <mesh_handle/mesh.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_forest/t8_forest_balance.h>
+#include <t8_forest/t8_forest_ghost.h>
+#include <t8_schemes/t8_default/t8_default.hxx>
+#include <vector>
+
+/** Parametrized test fixture for the ghost tests. */
+class t8_mesh_ghost_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, 1, sc_MPI_COMM_WORLD);
+  }
+  void
+  TearDown () override
+  {
+    t8_forest_unref (&forest);
+  }
+  t8_forest_t forest;
+  int level;
+};
+
+/** Check the implementation of ghosts and all functions accessible by ghosts. */
+TEST_P (t8_mesh_ghost_test, check_ghosts)
+{
+  t8_forest_ghost_print (forest);
+
+  t8_mesh_handle::mesh<> mesh = t8_mesh_handle::mesh<> (forest);
+  EXPECT_EQ (mesh.get_num_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_ghosts (), 0);
+  }
+  else {
+    GTEST_SKIP () << "Skipping test as no ghost elements are created for 1D or single element meshes.";
+  }
+
+  // Check functions for ghost elements.
+  const t8_locidx_t num_local_elements = mesh.get_num_local_elements ();
+  const t8_locidx_t num_ghost_elements = mesh.get_num_ghosts ();
+  for (t8_locidx_t ighost = num_local_elements; ighost < num_local_elements + num_ghost_elements; ++ighost) {
+    EXPECT_TRUE (mesh[ighost].is_ghost_element ());
+    EXPECT_EQ (level, mesh[ighost].get_level ());
+    auto centroid = mesh[ighost].get_centroid ();
+    for (const auto& coordinate : centroid) {
+      EXPECT_GE (1, coordinate);
+      EXPECT_LE (0, coordinate);
+    }
+    auto vertex_coordinates = mesh[ighost].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 that the function \ref t8_mesh_handle::element::get_face_neighbors of the handle works as intended (equal results to forest).*/
+TEST_P (t8_mesh_ghost_test, compare_neighbors_to_forest)
+{
+  ASSERT_TRUE (t8_forest_is_committed (forest));
+
+  t8_mesh_handle::mesh<> mesh = t8_mesh_handle::mesh<> (forest);
+  EXPECT_EQ (mesh.get_num_ghosts (), t8_forest_get_num_ghosts (forest));
+
+  // Iterate over the elements of the forest and of the mesh handle simultaneously and compare results.
+  const t8_scheme* scheme = t8_forest_get_scheme (forest);
+  auto mesh_iterator = mesh.begin ();
+  for (t8_locidx_t itree = 0; itree < t8_forest_get_num_local_trees (forest); ++itree) {
+    const t8_eclass_t tree_class = t8_forest_get_tree_class (forest, itree);
+    for (t8_locidx_t ielem = 0; ielem < t8_forest_get_tree_num_leaf_elements (forest, itree); ++ielem) {
+      // --- Compare elements. ---
+      EXPECT_EQ (mesh_iterator->get_local_tree_id (), itree);
+      EXPECT_EQ (mesh_iterator->get_local_element_id (), ielem);
+      // --- Compare neighbors. ---
+      const t8_element_t* elem = t8_forest_get_leaf_element_in_tree (forest, itree, ielem);
+      const int num_faces = scheme->element_get_num_faces (tree_class, elem);
+      EXPECT_EQ (mesh_iterator->get_num_faces (), num_faces);
+      for (int iface = 0; iface < num_faces; iface++) {
+        // --- Get neighbors from forest. ---
+        t8_element_t** neighbors;
+        int num_neighbors;
+        const int forest_is_balanced = t8_forest_is_balanced (forest);
+        t8_eclass_t neigh_eclass;
+        int* dual_faces;
+        t8_locidx_t* neigh_ids;
+        t8_forest_leaf_face_neighbors (forest, itree, elem, &neighbors, iface, &dual_faces, &num_neighbors, &neigh_ids,
+                                       &neigh_eclass, forest_is_balanced);
+        // --- Get neighbors from mesh element. ---
+        std::vector<int> dual_faces_handle;
+        auto neighbors_handle = mesh_iterator->get_face_neighbors (iface, dual_faces_handle);
+        // --- Compare results. ---
+        EXPECT_EQ (num_neighbors, (int) neighbors_handle.size ());
+        EXPECT_EQ (dual_faces_handle, std::vector<int> (dual_faces, dual_faces + num_neighbors));
+        for (int ineighs = 0; ineighs < num_neighbors; ineighs++) {
+          EXPECT_EQ (neighbors_handle[ineighs]->get_flat_element_id (), neigh_ids[ineighs]);
+        }
+        for (int ineigh = 0; ineigh < num_neighbors; ineigh++) {
+          EXPECT_EQ (scheme->element_get_shape (neigh_eclass, neighbors[ineigh]),
+                     neighbors_handle[ineigh]->get_shape ());
+        }
+        // Free memory.
+        if (num_neighbors > 0) {
+          scheme->element_destroy (neigh_eclass, num_neighbors, neighbors);
+          T8_FREE (neigh_ids);
+          T8_FREE (neighbors);
+          T8_FREE (dual_faces);
+        }
+      }
+      // Evolve mesh iterator.
+      mesh_iterator++;
+    }
+  }
+}
+
+/** Child class of \ref t8_mesh_handle::cache_neighbors that allows to modify the cache variables for test purposes. */
+template <typename TUnderlying>
+struct cache_neighbors_overwrite: public t8_mesh_handle::cache_neighbors<TUnderlying>
+{
+ public:
+  /** Overwrites the cache variables for the a \ref face.
+   * \param [in] face              Face for which the cache should be overwritten.
+   * \param [in] neighbors         New cache vector for the neighbors.
+   * \param [in] dual_faces        New cache vector for the dual faces.
+   */
+  void
+  overwrite_cache (int face, std::vector<const TUnderlying*> neighbors, std::vector<int> dual_faces) const
+  {
+    this->m_neighbors[face] = neighbors;
+    this->m_dual_faces[face] = dual_faces;
+  }
+};
+
+/** Use child class of \ref t8_mesh_handle::cache_neighbors class to check that the cache is actually set 
+ * and accessed correctly. This is done by modifying the cache variables to a unrealistic values and 
+ * checking that the functionality actually outputs this unrealistic value.
+ */
+TEST_P (t8_mesh_ghost_test, cache_neighbors)
+{
+  using mesh_class = t8_mesh_handle::mesh<cache_neighbors_overwrite>;
+  using element_class = mesh_class::element_class;
+  mesh_class mesh = mesh_class (forest);
+  EXPECT_TRUE (element_class::has_face_neighbor_cache ());
+
+  if (mesh.get_num_local_elements () == 0) {
+    GTEST_SKIP () << "No local elements in the mesh to test the cache functionality.";
+  }
+  const std::vector<const element_class*> unrealistic_neighbors
+    = { &mesh[0], &mesh[mesh.get_num_local_elements () - 1] };
+  const std::vector<int> unrealistic_dual_faces = { 100, 1012000 };
+  for (auto it = mesh.begin (); it != mesh.end (); ++it) {
+    // Check that cache is empty at the beginning.
+    EXPECT_FALSE (it->neighbor_cache_filled_any ());
+    it->fill_face_neighbor_cache ();
+    for (int iface = 0; iface < it->get_num_faces (); iface++) {
+      EXPECT_TRUE (it->neighbor_cache_filled (iface));
+      std::vector<int> dual_faces;
+      auto neighbors = it->get_face_neighbors (iface, dual_faces);
+      // Overwrite cache with unrealistic values.
+      it->overwrite_cache (iface, unrealistic_neighbors, unrealistic_dual_faces);
+      EXPECT_TRUE (it->neighbor_cache_filled (iface));
+      neighbors = it->get_face_neighbors (iface, dual_faces);
+      // --- Compare results. ---
+      EXPECT_EQ (neighbors, unrealistic_neighbors);
+      EXPECT_EQ (dual_faces, unrealistic_dual_faces);
+    }
+  }
+}
+
+INSTANTIATE_TEST_SUITE_P (t8_gtest_ghost, t8_mesh_ghost_test, testing::Combine (AllEclasses, testing::Range (1, 2)));
diff --git a/test/mesh_handle/t8_gtest_mesh_handle.cxx b/test/mesh_handle/t8_gtest_mesh_handle.cxx
index c454779096..ad1ff606fe 100644
--- a/test/mesh_handle/t8_gtest_mesh_handle.cxx
+++ b/test/mesh_handle/t8_gtest_mesh_handle.cxx
@@ -26,12 +26,10 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
  */
 
 #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>
@@ -63,12 +61,12 @@ class t8_mesh_handle_test: public testing::TestWithParam<std::tuple<t8_eclass_t,
 /** 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 ());
+  using mesh_class = t8_mesh_handle::mesh<>;
+  using element_class = mesh_class::element_class;
+  mesh_class mesh = mesh_class (forest);
+  EXPECT_FALSE (element_class::has_vertex_cache ());
+  EXPECT_FALSE (element_class::has_centroid_cache ());
 
   // Iterate with the iterator over all mesh elements and check some functionality.
   for (auto it = mesh.begin (); it != mesh.end (); ++it) {
@@ -98,17 +96,15 @@ TEST_P (t8_mesh_handle_test, test_iterator)
 /** 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 ());
+  using mesh_class_vertex = t8_mesh_handle::mesh<t8_mesh_handle::cache_vertex_coordinates>;
+  using element_class_vertex = mesh_class_vertex::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 ());
 
   // Iterate with the iterator over all mesh elements and check functionality.
-  for (auto it = mesh_vertex_coordinates.begin (); it != mesh_vertex_coordinates.end (); ++it) {
+  for (auto it = mesh_vertex.begin (); it != mesh_vertex.end (); ++it) {
     EXPECT_FALSE (it->vertex_cache_filled ());
     EXPECT_EQ (level, it->get_level ());
     auto centroid = it->get_centroid ();
@@ -125,7 +121,7 @@ TEST_P (t8_mesh_handle_test, test_competences)
     }
   }
   // Check cached value.
-  for (auto it = mesh_vertex_coordinates.begin (); it != mesh_vertex_coordinates.end (); ++it) {
+  for (auto it = mesh_vertex.begin (); it != mesh_vertex.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) {
@@ -137,10 +133,11 @@ TEST_P (t8_mesh_handle_test, test_competences)
   }
 
   // --- 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 ());
+  using mesh_class_centroid = t8_mesh_handle::mesh<t8_mesh_handle::cache_centroid>;
+  using element_class_centroid = mesh_class_centroid::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 ());
 
   // Iterate with the iterator over all mesh elements.
   for (auto it = mesh_centroid.begin (); it != mesh_centroid.end (); ++it) {
@@ -162,14 +159,12 @@ TEST_P (t8_mesh_handle_test, test_competences)
 /** 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 ());
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::cache_vertex_coordinates, t8_mesh_handle::cache_centroid>;
+  using element_class = mesh_class::element_class;
+  mesh_class mesh = mesh_class (forest);
+  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) {