diff --git a/.github/workflows/check_doxygen.yml b/.github/workflows/check_doxygen.yml
index 30d7b941a0..5faf11b80d 100644
--- a/.github/workflows/check_doxygen.yml
+++ b/.github/workflows/check_doxygen.yml
@@ -79,7 +79,7 @@ jobs:
       run: mkdir build && cd build && cmake ../ $CONFIG_OPTIONS
     - name: OnFailUploadLog
       if: failure()
-      uses: actions/upload-artifact@v6
+      uses: actions/upload-artifact@v7
       with:
         name: cmake_doc_build.log
         path: build/config.log
@@ -87,9 +87,13 @@ jobs:
       run: |
         cd build && cd doc
         doxygen Doxyfile >> doxygen.out 2> doxygen.err
+    - name: Show doxygen log
+      if: failure()
+      run: |
+        cat build/doc/doxygen.err
     - name: Upload doxygen log
       if: failure()
-      uses: actions/upload-artifact@v6
+      uses: actions/upload-artifact@v7
       with:
         name: doxygen-log
         path: build/doc/doxygen.err
diff --git a/.github/workflows/check_indentation.yml b/.github/workflows/check_indentation.yml
index 67611f21b3..57b0548d39 100644
--- a/.github/workflows/check_indentation.yml
+++ b/.github/workflows/check_indentation.yml
@@ -56,7 +56,7 @@ jobs:
     # Do this regardless of the result of the previous step.
     # We especially want to upload the result when the check fails.
       if: always()
-      uses: actions/upload-artifact@v6
+      uses: actions/upload-artifact@v7
       with:
         name: t8code indentation report
         path: scripts/indent_script_output.txt
diff --git a/.github/workflows/code_coverage.yml b/.github/workflows/code_coverage.yml
index a5f384f7c2..eb2181fdd4 100644
--- a/.github/workflows/code_coverage.yml
+++ b/.github/workflows/code_coverage.yml
@@ -57,7 +57,7 @@ jobs:
 # Setup
 #
     - name: Download artifacts
-      uses: actions/download-artifact@v7
+      uses: actions/download-artifact@v8
       with:
         name: SC_P4EST_MPI_${{ inputs.MPI }}
     - name: untar artifact
@@ -101,7 +101,7 @@ jobs:
       run: mkdir build && cd build && cmake ../ $CONFIG_OPTIONS -DCMAKE_Fortran_FLAGS="-fprofile-arcs -ftest-coverage" 
     - name: OnFailUploadLog
       if: failure()
-      uses: actions/upload-artifact@v6
+      uses: actions/upload-artifact@v7
       with:
         name: cmake_${{ inputs.BUILD_TYPE }}_MPI_${{ inputs.MPI }}.log
         path: build/CMakeFiles/CMakeOutput.log
diff --git a/.github/workflows/spell_check.yml b/.github/workflows/spell_check.yml
index 207182401d..1be227dff7 100644
--- a/.github/workflows/spell_check.yml
+++ b/.github/workflows/spell_check.yml
@@ -38,11 +38,11 @@ jobs:
       - name: check macros
         run: |
           for file in $(git diff --name-only --diff-filter=A); do
-            ./scripts/check_macros.sh "$file" &>> check_macros.txt
+            ./scripts/internal/check_macros.sh "$file" &>> check_macros.txt
           done
       - name: Archive script output
         if: failure()
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v7
         with:
           name: t8code check macros report
           path: check_macros.txt
diff --git a/.github/workflows/test_preparation.yml b/.github/workflows/test_preparation.yml
index 94fd0e6087..5d273c4259 100644
--- a/.github/workflows/test_preparation.yml
+++ b/.github/workflows/test_preparation.yml
@@ -189,7 +189,7 @@ jobs:
 
     ## upload artifacts
     - name: Upload build artifacts
-      uses: actions/upload-artifact@v6
+      uses: actions/upload-artifact@v7
       with:
         name: SC_P4EST_MPI_${{ inputs.MPI }}
         path: ./artifact.tar
diff --git a/.github/workflows/test_sc_p4est.yml b/.github/workflows/test_sc_p4est.yml
index 8e1a8649e2..41d1508cac 100644
--- a/.github/workflows/test_sc_p4est.yml
+++ b/.github/workflows/test_sc_p4est.yml
@@ -52,7 +52,7 @@ jobs:
 # Setup
 #
     - name: Download artifacts
-      uses: actions/download-artifact@v7
+      uses: actions/download-artifact@v8
       with:
         name: SC_P4EST_MPI_${{ inputs.MPI }}
     - name: untar artifact
@@ -85,7 +85,7 @@ jobs:
       run: cd $SC_DEBUG && ninja test
     - name: OnFailUploadLog
       if: failure()
-      uses: actions/upload-artifact@v6
+      uses: actions/upload-artifact@v7
       with:
         name: sc_debug_MPI_${{ inputs.MPI }}.log
         path: $SC_DEBUG/Testing/Temporary/LastTest.log
@@ -94,7 +94,7 @@ jobs:
       run: cd $SC_RELEASE && ninja test
     - name: OnFailUploadLog
       if: failure()
-      uses: actions/upload-artifact@v6
+      uses: actions/upload-artifact@v7
       with:
         name: sc_release_MPI_${{ inputs.MPI }}.log
         path: $SC_RELEASE/Testing/Temporary/LastTest.log
@@ -106,7 +106,7 @@ jobs:
       run: cd $P4EST_DEBUG && ninja test
     - name: OnFailUploadLog
       if: failure()
-      uses: actions/upload-artifact@v6
+      uses: actions/upload-artifact@v7
       with:
         name: sp4est_debug_MPI_${{ inputs.MPI }}.log
         path: $P4EST_DEBUG/Testing/Temporary/LastTest.log
@@ -115,7 +115,7 @@ jobs:
       run: cd $P4EST_RELEASE && ninja test
     - name: OnFailUploadLog
       if: failure()
-      uses: actions/upload-artifact@v6
+      uses: actions/upload-artifact@v7
       with:
         name: sp4est_release_MPI_${{ inputs.MPI }}.log
         path: $P4EST_RELEASE/Testing/Temporary/LastTest.log
diff --git a/.github/workflows/test_t8code.yml b/.github/workflows/test_t8code.yml
index 114d728937..c969e77283 100644
--- a/.github/workflows/test_t8code.yml
+++ b/.github/workflows/test_t8code.yml
@@ -55,7 +55,7 @@ jobs:
 # Setup
 #
     - name: Download artifacts
-      uses: actions/download-artifact@v7
+      uses: actions/download-artifact@v8
       with:
         name: SC_P4EST_MPI_${{ inputs.MPI }}
     - name: untar artifact
@@ -97,7 +97,7 @@ jobs:
       run: mkdir build && cd build && cmake ../ $CONFIG_OPTIONS
     - name: OnFailUploadLog
       if: failure()
-      uses: actions/upload-artifact@v6
+      uses: actions/upload-artifact@v7
       with:
         name: cmake_${{ inputs.BUILD_TYPE }}_MPI_${{ inputs.MPI }}.log
         path: build/CMakeFiles/CMakeOutput.log
@@ -116,7 +116,7 @@ jobs:
       if: ${{ inputs.MPI == 'OFF' }}
     - name: OnFailUploadLog
       if: failure()
-      uses: actions/upload-artifact@v6
+      uses: actions/upload-artifact@v7
       with:
         name: test-suite_${{ inputs.BUILD_TYPE }}_MPI_${{ inputs.MPI }}.log
         path: build/Testing/Temporary/LastTest.log
diff --git a/.github/workflows/test_t8code_api.yml b/.github/workflows/test_t8code_api.yml
index 18ca2ec5a4..a6f0f8d6d7 100644
--- a/.github/workflows/test_t8code_api.yml
+++ b/.github/workflows/test_t8code_api.yml
@@ -55,7 +55,7 @@ jobs:
 # Setup
 #
     - name: Download artifacts
-      uses: actions/download-artifact@v7
+      uses: actions/download-artifact@v8
       with:
         name: SC_P4EST_MPI_${{ inputs.MPI }}
     - name: untar artifact
@@ -95,7 +95,7 @@ jobs:
       run: mkdir build_api && cd build_api && cmake ../ $CONFIG_OPTIONS
     - name: OnFailUploadLog
       if: failure()
-      uses: actions/upload-artifact@v6
+      uses: actions/upload-artifact@v7
       with:
         name: cmake_${{ inputs.BUILD_TYPE }}_MPI_${{ inputs.MPI }}_api.log
         path: build_api/CMakeFiles/CMakeOutput.log
@@ -114,7 +114,7 @@ jobs:
       if: ${{ inputs.MPI == 'OFF' }}
     - name: OnFailUploadLog
       if: failure()
-      uses: actions/upload-artifact@v6
+      uses: actions/upload-artifact@v7
       with:
         name: test-suite_${{ inputs.BUILD_TYPE }}_MPI_${{ inputs.MPI }}_api.log
         path: build_api/Testing/Temporary/LastTest.log
diff --git a/.github/workflows/test_t8code_linkage.yml b/.github/workflows/test_t8code_linkage.yml
index e2a7c9bb54..c8352a2bc6 100644
--- a/.github/workflows/test_t8code_linkage.yml
+++ b/.github/workflows/test_t8code_linkage.yml
@@ -55,7 +55,7 @@ jobs:
 # Setup
 #
     - name: Download artifacts
-      uses: actions/download-artifact@v7
+      uses: actions/download-artifact@v8
       with:
         name: SC_P4EST_MPI_${{ inputs.MPI }}
     - name: untar artifact
@@ -96,7 +96,7 @@ jobs:
       run: mkdir build_occ && cd build_occ && cmake ../ $CONFIG_OPTIONS -DT8CODE_ENABLE_OCC=ON
     - name: OnFailUploadLog
       if: failure()
-      uses: actions/upload-artifact@v6
+      uses: actions/upload-artifact@v7
       with:
         name: cmake_${{ inputs.BUILD_TYPE }}_MPI_${{ inputs.MPI }}_OCC.log
         path: build_occ/CMakeFiles/CMakeOutput.log
@@ -115,7 +115,7 @@ jobs:
       if: ${{ inputs.MPI == 'OFF' }}
     - name: OnFailUploadLog
       if: failure()
-      uses: actions/upload-artifact@v6
+      uses: actions/upload-artifact@v7
       with:
         name: test-suite_${{ inputs.BUILD_TYPE }}_MPI_${{ inputs.MPI }}_OCC.log
         path: build_occ/Testing/Temporary/LastTest.log
@@ -128,7 +128,7 @@ jobs:
       run: mkdir build_vtk && cd build_vtk && cmake ../ $CONFIG_OPTIONS -DT8CODE_ENABLE_VTK=ON -DVTK_DIR=/usr/local/lib/cmake/vtk-9.1
     - name: OnFailUploadLog
       if: failure()
-      uses: actions/upload-artifact@v6
+      uses: actions/upload-artifact@v7
       with:
         name: cmake_${{ inputs.BUILD_TYPE }}_MPI_${{ inputs.MPI }}_VTK.log
         path: build_vtk/CMakeFiles/CMakeOutput.log
@@ -147,7 +147,7 @@ jobs:
       if: ${{ inputs.MPI == 'OFF' }}
     - name: OnFailUploadLog
       if: failure()
-      uses: actions/upload-artifact@v6
+      uses: actions/upload-artifact@v7
       with:
         name: test-suite_${{ inputs.BUILD_TYPE }}_MPI_${{ inputs.MPI }}_VTK.log
         path: build_vtk/Testing/Temporary/LastTest.log
diff --git a/.github/workflows/test_t8code_w_clang_and_ompi.yml b/.github/workflows/test_t8code_w_clang_and_ompi.yml
index 9f83240aa8..21ddfbebc0 100644
--- a/.github/workflows/test_t8code_w_clang_and_ompi.yml
+++ b/.github/workflows/test_t8code_w_clang_and_ompi.yml
@@ -126,7 +126,7 @@ jobs:
     # On failure, upload logs
     - name: OnFailUploadLog
       if: failure()
-      uses: actions/upload-artifact@v6
+      uses: actions/upload-artifact@v7
       with:
         name: cmake_w_clang_and_ompi_${{ inputs.BUILD_TYPE }}_MPI_${{ inputs.MPI }}.log
         path: build/CMakeFiles/CMakeOutput.log
@@ -158,7 +158,7 @@ jobs:
     # On failure, upload logs
     - name: OnFailUploadLog
       if: failure()
-      uses: actions/upload-artifact@v6
+      uses: actions/upload-artifact@v7
       with:
         name: test-suite_w_clang_and_ompi_${{ inputs.BUILD_TYPE }}_MPI_${{ inputs.MPI }}.log
         path: build/Testing/Temporary/LastTest.log
diff --git a/.github/workflows/test_t8code_w_shipped_submodules.yml b/.github/workflows/test_t8code_w_shipped_submodules.yml
index 9f98d789d9..0f3801c84b 100644
--- a/.github/workflows/test_t8code_w_shipped_submodules.yml
+++ b/.github/workflows/test_t8code_w_shipped_submodules.yml
@@ -94,7 +94,7 @@ jobs:
       run: mkdir build && cd build && cmake ../ $CONFIG_OPTIONS
     - name: OnFailUploadLog
       if: failure()
-      uses: actions/upload-artifact@v6
+      uses: actions/upload-artifact@v7
       with:
         name: cmake_w_submodules_${{ inputs.BUILD_TYPE }}_MPI_${{ inputs.MPI }}.log
         path: build/CMakeFiles/CMakeOutput.log
@@ -113,7 +113,7 @@ jobs:
       if: ${{ inputs.MPI == 'OFF' }}
     - name: OnFailUploadLog
       if: failure()
-      uses: actions/upload-artifact@v6
+      uses: actions/upload-artifact@v7
       with:
         name: test-suite_w_submodules_${{ inputs.BUILD_TYPE }}_MPI_${{ inputs.MPI }}.log
         path: build/Testing/Temporary/LastTest.log
diff --git a/.github/workflows/test_tarball.yml b/.github/workflows/test_tarball.yml
index 5fbd7b2df8..c1811f21e4 100644
--- a/.github/workflows/test_tarball.yml
+++ b/.github/workflows/test_tarball.yml
@@ -85,7 +85,7 @@ jobs:
       run: mkdir build && cd build && cmake ../ $CONFIG_OPTIONS
     - name: OnFailUploadLog
       if: failure()
-      uses: actions/upload-artifact@v6
+      uses: actions/upload-artifact@v7
       with:
         name: config.log
         path: build/config.log
@@ -94,7 +94,7 @@ jobs:
       run: cd build && ninja GenerateVersionFile && ninja package_source && mkdir tarballs && mv package/*Source.tar.gz tarballs
 # Upload the tarball
     - name: upload tarball
-      uses: actions/upload-artifact@v6
+      uses: actions/upload-artifact@v7
       with:
         name: tarballs
         path: build/tarballs
@@ -106,7 +106,7 @@ jobs:
     timeout-minutes: 15
     steps:
     - name: Download tarball
-      uses: actions/download-artifact@v7
+      uses: actions/download-artifact@v8
       with:
           name: tarballs
           path: tarballs
@@ -129,7 +129,7 @@ jobs:
       run: mkdir build_tar && cd build_tar && cmake $TAR_DIR $CONFIG_OPTIONS
     - name: OnFailUploadLog
       if: failure()
-      uses: actions/upload-artifact@v6
+      uses: actions/upload-artifact@v7
       with:
         name: build_tar.log
         path: build_tar/config.log
@@ -143,7 +143,7 @@ jobs:
       run: cd build_tar && ctest -R _parallel
     - name: OnFailUploadLog
       if: failure()
-      uses: actions/upload-artifact@v6
+      uses: actions/upload-artifact@v7
       with:
         name: build_tar.log
         path: build_tar/test-suite.log
diff --git a/.github/workflows/test_valgrind.yml b/.github/workflows/test_valgrind.yml
index 91dd1f6be4..8667118dc7 100644
--- a/.github/workflows/test_valgrind.yml
+++ b/.github/workflows/test_valgrind.yml
@@ -69,7 +69,7 @@ jobs:
 # Setup
 #
     - name: Download artifacts
-      uses: actions/download-artifact@v7
+      uses: actions/download-artifact@v8
       with:
         name: SC_P4EST_MPI_${{ inputs.MPI }}
     - name: untar artifact
@@ -113,7 +113,7 @@ jobs:
       run: mkdir build && cd build && cmake ../ $CONFIG_OPTIONS
     - name: OnFailUploadLog
       if: failure()
-      uses: actions/upload-artifact@v6
+      uses: actions/upload-artifact@v7
       with:
         name: cmake_${{ inputs.BUILD_TYPE }}_MPI_${{ inputs.MPI }}.log
         path: build/CMakeFiles/CMakeOutput.log
@@ -122,4 +122,4 @@ jobs:
     # Execute script that runs a Valgrind check for all test binaries.
     # We use 4 parallel processes to run the binaries in parallel with MPI.
     - name: Valgrind check
-      run: cd scripts && bash ./check_all_test_binaries_valgrind.sh --ntasks=4
+      run: cd scripts && bash ./check_all_test_binaries_valgrind.sh ../build/test/ --ntasks=4
diff --git a/.gitignore b/.gitignore
index d271517eda..ec93b8c0f4 100644
--- a/.gitignore
+++ b/.gitignore
@@ -26,59 +26,5 @@ Testing/
 *.vtu
 *.pvtu
 *~
-
-# ------------------------------------------------------------ #
-# Following list of files can be easily generated with:
-# $ git status --porcelain | grep '^??' | cut -c4- >> .gitignore
-
-benchmarks/t8_time_forest_partition
-benchmarks/t8_time_partition
-benchmarks/t8_time_prism_adapt
-example/IO/cmesh/gmsh/t8_load_and_refine_square_w_hole
-example/IO/cmesh/gmsh/t8_read_msh_file
-example/IO/cmesh/t8_cmesh_load_save
-example/IO/cmesh/tetgen/t8_forest_tetgen
-example/IO/cmesh/tetgen/t8_read_tetgen
-example/IO/cmesh/tetgen/t8_time_tetgen
-example/IO/cmesh/triangle/t8_read_triangle
-example/advect/t8_advection
-example/cmesh/t8_cmesh_create_partitioned
-example/cmesh/t8_cmesh_partition
-example/forest/t8_face_neighbor
-example/forest/t8_test_face_iterate
-example/forest/t8_test_ghost
-example/forest/t8_test_ghost_large_level_diff
-example/geometry/t8_example_geometries
-example/version/t8_version
-tutorials/t8_step0_helloworld
-tutorials/t8_step1_coarsemesh
-tutorials/t8_step2_uniform_forest
-tutorials/t8_step3_adapt_forest
-tutorials/t8_step4_partition_balance_ghost
-tutorials/t8_step5_element_data
-tutorials/t8_tutorial_search
-test/t8_cmesh/t8_test_cmesh_copy
-test/t8_cmesh/t8_test_cmesh_face_is_boundary
-test/t8_cmesh/t8_test_cmesh_partition
-test/t8_cmesh/t8_test_cmesh_readmshfile
-test/t8_cmesh/t8_test_hypercube
-test/t8_data/t8_test_shmem
-test/t8_forest/t8_test_find_owner
-test/t8_forest/t8_test_forest_commit
-test/t8_forest/t8_test_ghost_and_owner
-test/t8_forest/t8_test_ghost_exchange
-test/t8_forest/t8_test_half_neighbors
-test/t8_forest/t8_test_search
-test/t8_forest/t8_test_transform
-test/t8_forest/t8_test_user_data
-test/t8_geometry/t8_test_geometry
-test/t8_geometry/t8_test_point_inside
-test/t8_gtest_main
-test/t8_schemes/t8_test_descendant
-test/t8_schemes/t8_test_element_count_leaves
-test/t8_schemes/t8_test_find_parent
-test/t8_schemes/t8_test_init_linear_id
-test/t8_schemes/t8_test_pyra_face_descendant
-test/t8_schemes/t8_test_pyra_face_neigh
-test/t8_schemes/t8_test_successor
-test/t8_test_vtk_linkage
+*.brep
+*.msh
diff --git a/.typos.toml b/.typos.toml
index fdab8ed1cc..b956ef5a00 100644
--- a/.typos.toml
+++ b/.typos.toml
@@ -3,4 +3,4 @@ eles = "eles"
 packageid = "packageid"
 
 [files]
-extend-exclude = ["scripts/t8indent.sh", "thirdparty/", "t8code_logo.png", "cmake/FindOpenCASCADE.cmake", "src/t8_with_macro_error.h", "doc/Doxyfile.in"]
+extend-exclude = ["scripts/indent.sh", "thirdparty/", "t8code_logo.png", "cmake/FindOpenCASCADE.cmake", "src/t8_misc/t8_with_macro_error.h", "doc/Doxyfile.in"]
diff --git a/README.md b/README.md
index b741dcc40f..40cb23acef 100644
--- a/README.md
+++ b/README.md
@@ -186,7 +186,7 @@ to install the package on your system.
 
   [K] **Hanging node resolution 3D**:
   Tabea Leistikow (2024) *Derivation and implementation of a hanging nodes resolution scheme for hexahedral non-conforming meshes in t8code*. Master's thesis, Universität zu Köln.
-  Full text currently not available.
+  [Full text available](https://elib.dlr.de/204843/)
 
   ### Citing t8code
   
diff --git a/benchmarks/t8_time_fractal.cxx b/benchmarks/t8_time_fractal.cxx
index 8288f2f211..b3d4b7caf2 100644
--- a/benchmarks/t8_time_fractal.cxx
+++ b/benchmarks/t8_time_fractal.cxx
@@ -25,7 +25,7 @@
 #include <t8_forest/t8_forest_partition.h>
 #include <t8_forest/t8_forest_types.h>
 #include <t8_forest/t8_forest_adapt.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <t8_cmesh/t8_cmesh.h>
 #include <t8_cmesh/t8_cmesh_examples.h>
 #include <t8_schemes/t8_default/t8_default.hxx>
diff --git a/benchmarks/t8_time_set_join_by_vertices.cxx b/benchmarks/t8_time_set_join_by_vertices.cxx
index d9e7518b3a..b36714b631 100644
--- a/benchmarks/t8_time_set_join_by_vertices.cxx
+++ b/benchmarks/t8_time_set_join_by_vertices.cxx
@@ -26,7 +26,7 @@
 
 #include <t8.h>
 #include <t8_cmesh/t8_cmesh.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <t8_cmesh/t8_cmesh_io/t8_cmesh_readmshfile.h>
 #include <t8_cmesh/t8_cmesh_examples.h>
 #include <t8_cmesh/t8_cmesh_helpers.h>
diff --git a/doc/author_austin.txt b/doc/author_austin.txt
new file mode 100644
index 0000000000..396dab40a5
--- /dev/null
+++ b/doc/author_austin.txt
@@ -0,0 +1 @@
+I place my contributions to t8code under the FreeBSD license. Sam Austin <austinsp@mit.edu>
diff --git a/doc/author_doehring.txt b/doc/author_doehring.txt
new file mode 100644
index 0000000000..b3301e0c8e
--- /dev/null
+++ b/doc/author_doehring.txt
@@ -0,0 +1 @@
+I place my contributions to t8code under the FreeBSD license. Daniel Doehring (doehringd2@gmail.com)
diff --git a/example/IO/cmesh/vtk/t8_cmesh_read_from_vtk.cxx b/example/IO/cmesh/vtk/t8_cmesh_read_from_vtk.cxx
index f5b62c84b0..0da13bbcad 100644
--- a/example/IO/cmesh/vtk/t8_cmesh_read_from_vtk.cxx
+++ b/example/IO/cmesh/vtk/t8_cmesh_read_from_vtk.cxx
@@ -21,7 +21,7 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 #include <t8_cmesh/t8_cmesh.h>
 #include <sc_options.h>
 #include <t8.h>
-#include <t8_vtk.h>
+#include <t8_vtk/t8_vtk.h>
 
 #include <t8_forest/t8_forest.h>
 #include <t8_schemes/t8_default/t8_default.hxx>
diff --git a/example/cmesh/t8_cmesh_set_join_by_vertices.cxx b/example/cmesh/t8_cmesh_set_join_by_vertices.cxx
index e4529e8928..9ee2e87fba 100644
--- a/example/cmesh/t8_cmesh_set_join_by_vertices.cxx
+++ b/example/cmesh/t8_cmesh_set_join_by_vertices.cxx
@@ -24,7 +24,7 @@
 
 #include <t8.h>
 #include <t8_cmesh/t8_cmesh.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <t8_cmesh/t8_cmesh_io/t8_cmesh_readmshfile.h>
 #include <t8_cmesh/t8_cmesh_examples.h>
 #include <t8_cmesh/t8_cmesh_helpers.h>
diff --git a/example/forest/t8_test_face_iterate.cxx b/example/forest/t8_test_face_iterate.cxx
index 6b987f871c..fe51e449c3 100644
--- a/example/forest/t8_test_face_iterate.cxx
+++ b/example/forest/t8_test_face_iterate.cxx
@@ -23,7 +23,7 @@
 #include <t8_forest/t8_forest_iterate.h>
 #include <sc_options.h>
 #include <sc_refcount.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <t8_schemes/t8_scheme.hxx>
 #include <t8_forest/t8_forest_general.h>
 #include <t8_forest/t8_forest_io.h>
diff --git a/example/forest/t8_test_ghost.cxx b/example/forest/t8_test_ghost.cxx
index 4121ba77fb..ec58ef3392 100644
--- a/example/forest/t8_test_ghost.cxx
+++ b/example/forest/t8_test_ghost.cxx
@@ -22,7 +22,7 @@
 
 #include <sc_options.h>
 #include <sc_refcount.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <t8_schemes/t8_default/t8_default.hxx>
 #include <t8_forest/t8_forest_general.h>
 #include <t8_forest/t8_forest_io.h>
diff --git a/example/version/t8_version.cxx b/example/version/t8_version.cxx
index ff85cbf15f..89774d0c66 100644
--- a/example/version/t8_version.cxx
+++ b/example/version/t8_version.cxx
@@ -22,7 +22,7 @@
 
 #include <sc_options.h>
 #include <t8.h>
-#include <t8_version.h>
+#include <t8_misc/t8_version.h>
 
 int
 main (int argc, char **argv)
diff --git a/mesh_handle/README.md b/mesh_handle/README.md
index 570209c131..14902ea133 100644
--- a/mesh_handle/README.md
+++ b/mesh_handle/README.md
@@ -8,6 +8,8 @@ If you want to use the handle, note that is has its own library. Turn the option
 
 The folder's most important files are: 
 - The [mesh.hxx](mesh.hxx) defines the mesh of the handle. This is the central file of the mesh handle. 
+- The [constructor_wrappers.hxx](constructor_wrappers.hxx) allows to define a mesh handle using a cmesh instead of a forest and provides a very small number of examples where the user needs no cmesh.
 - 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.
-- The [constructor_wrappers.hxx](constructor_wrappers.hxx) allows to define a mesh handle using a cmesh instead of a forest and provides a very small number of examples where the user needs no cmesh.
\ No newline at end of file
+- The [competence_pack.hxx](competence_pack.hxx) is needed to pack element or mesh competences to pass it as template parameter to the mesh.
+- The [data_handler.hxx](data_handler.hxx) provides competences to work with element data.
diff --git a/mesh_handle/competence_pack.hxx b/mesh_handle/competence_pack.hxx
index f93c7219a1..de9bf9beb7 100644
--- a/mesh_handle/competence_pack.hxx
+++ b/mesh_handle/competence_pack.hxx
@@ -21,36 +21,86 @@
 */
 
 /** \file competence_pack.hxx
- * Define to pack different competences into one template parameter for the \ref t8_mesh_handle::mesh class.
+ * Define classes to pack different competences into one template parameter for the \ref t8_mesh_handle::mesh class.
+ * We have one class for element competences and one for mesh competences. 
  */
 
 #pragma once
 
 #include "competences.hxx"
+#include "internal/competence_pack_union.hxx"
 namespace t8_mesh_handle
 {
-/** Class to pack different competences into one template parameter for the \ref mesh class.
- * \tparam TCompetence The competences to be packed.
+// --- Element competence pack. ---
+/** Class to pack different element competences into one template parameter for the \ref mesh class.
+ * \tparam TElementCompetence The competences to be packed.
  */
-template <template <typename> class... TCompetence>
-struct competence_pack
+template <template <typename> class... TElementCompetence>
+struct element_competence_pack
 {
   /** Apply the competence pack to a template class, e.g. the \ref element class.
-   * \tparam Target The target template class to apply the \a TCompetence pack to.
+   * \tparam TMeshClass The mesh class given to the element class.
+   * \tparam Target The target template class to apply the \a TElementCompetence pack to.
    */
-  template <typename mesh_class, template <typename, template <typename> class...> class Target>
-  using apply = Target<mesh_class, TCompetence...>;
+  template <typename TMeshClass, template <typename, template <typename> class...> class Target>
+  using apply = Target<TMeshClass, TElementCompetence...>;
 
-  using is_competence_pack = void; /**< Tag to identify this class. */
+  using is_element_competence_pack = void; /**< Tag to identify this class. */
 };
 
-/** Predefined competence pack combining all caching competences. */
-using all_cache_competences
-  = competence_pack<cache_volume, cache_diameter, cache_vertex_coordinates, cache_centroid, cache_face_areas,
-                    cache_face_centroids, cache_face_normals, cache_neighbors>;
+/** Predefined element competence pack combining all caching competences. */
+using all_cache_element_competences
+  = element_competence_pack<cache_volume, cache_diameter, cache_vertex_coordinates, cache_centroid, cache_face_areas,
+                            cache_face_centroids, cache_face_normals, cache_neighbors>;
 
 /** Predefined competence pack combining all competences related to faces. */
-using cache_face_competences
-  = competence_pack<cache_face_areas, cache_face_centroids, cache_face_normals, cache_neighbors>;
+using cache_face_element_competences
+  = element_competence_pack<cache_face_areas, cache_face_centroids, cache_face_normals, cache_neighbors>;
+
+// --- Mesh competence pack. ---
+/** Class to pack different mesh competences into one template parameter for the \ref mesh class.
+ * \tparam TMeshCompetence The mesh competences to be packed.
+ */
+template <template <typename> class... TMeshCompetence>
+struct mesh_competence_pack
+{
+  /** Apply the mesh competence pack to a mesh type.
+   *  By inheriting from all mesh competences, the functionality of the competences gets added to the mesh type.
+   *  \tparam TMesh The mesh type to which the competences are applied.
+   */
+  template <typename TMesh>
+  struct apply: public TMeshCompetence<TMesh>...
+  {
+  };
+
+  using is_mesh_competence_pack = void; /**< Tag to identify this class. */
+};
+
+/** Compute the unique union of the competences of several \ref t8_mesh_handle::competence_pack 's.
+ *  This produces a new \ref t8_mesh_handle::competence_pack containing all competences of the competence packs 
+ *  with duplicates removed.
+ * \tparam TPacks The competence pack for which we should compute the unique union of the competences.
+ *         Each competence pack is expected to be of type \ref t8_mesh_handle::competence_pack.
+ */
+template <typename... TPacks>
+using union_competence_packs_type = typename detail::union_competence_packs<TPacks...>::type;
+
+/** Compute the unique union of the competences of several \ref t8_mesh_handle::competence_pack 's.
+ *  This produces a new \ref t8_mesh_handle::competence_pack containing all competences of the competence packs 
+ *  with duplicates removed.
+ * \tparam TPacks The competence pack for which we should compute the unique union of the competences.
+ *         Each competence pack is expected to be of type \ref t8_mesh_handle::competence_pack.
+ */
+template <typename... TPacks>
+using union_competence_packs_type = typename detail::union_competence_packs<TPacks...>::type;
+
+/** Compute the unique union of the competences of several \ref t8_mesh_handle::competence_pack 's.
+ *  This produces a new \ref t8_mesh_handle::competence_pack containing all competences of the competence packs 
+ *  with duplicates removed.
+ * \tparam TPacks The competence pack for which we should compute the unique union of the competences.
+ *         Each competence pack is expected to be of type \ref t8_mesh_handle::competence_pack.
+ */
+template <typename... TPacks>
+using union_competence_packs_type = typename detail::union_competence_packs<TPacks...>::type;
 
 }  // namespace t8_mesh_handle
diff --git a/mesh_handle/competences.hxx b/mesh_handle/competences.hxx
index 105ca08727..9782149022 100644
--- a/mesh_handle/competences.hxx
+++ b/mesh_handle/competences.hxx
@@ -25,15 +25,20 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
  * Especially, competences to cache functionalities of elements instead of calculating them each time a function
  * is called are provided.
  *
+ * \note for developers or users that want to provide their own competence:
  * All competences have the same inheritance pattern: 
  * 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 
+ * The \ref 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 \ref t8_mesh_handle::element.
+ *
+ * We use \ref t8_crtp_operator instead of \ref t8_crtp_basic to circumvent diamond shaped inheritance pattern in 
+ * the case that multiple competences are used together. 
+ * The distinction of the classes is made by the second template parameter of \ref t8_crtp_operator.
  */
 
 #pragma once
diff --git a/mesh_handle/data_handler.hxx b/mesh_handle/data_handler.hxx
new file mode 100644
index 0000000000..7c98c19164
--- /dev/null
+++ b/mesh_handle/data_handler.hxx
@@ -0,0 +1,171 @@
+/*
+  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) 2026 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 data_handler.hxx
+ * Handler for the element data of a \ref t8_mesh_handle::mesh.
+ * The file defines a mesh and an element competence for element data handling.
+ * Use both competences together if you want to manage element data for the elements of the mesh and access it directly for each element.
+ */
+#pragma once
+
+#include <t8.h>
+#include <t8_forest/t8_forest_general.h>
+#include <t8_types/t8_crtp.hxx>
+#include <type_traits>
+#include <vector>
+
+namespace t8_mesh_handle
+{
+// --- Mesh competence for element data management. ---
+/** Concept to ensure that a type is MPI safe. */
+template <typename TType>
+concept T8MPISafeType
+  = std::is_void_v<TType> || (std::is_trivially_copyable_v<TType> && std::is_standard_layout_v<TType>);
+
+/** Handler for the element data of a \ref mesh.
+ * Use this competence if you want to manage element data for the elements of the mesh.
+ * Use the helper \ref element_data_competence to get this competence with the correct template parameters form for the mesh. 
+ * If you want to access the data not only in vector form but also directly for each element, 
+ * you can combine this competence with the \ref access_element_data competence.
+ * In summary you can use the competences like this: 
+ *    mesh<element_competence_pack<access_element_data>,
+ *         mesh_competence_pack<element_data_competence<YourElementDataType>::template type>>;
+ *
+ * \tparam TUnderlying Use the \ref mesh class here.
+ * \tparam TElementDataType The element data type you want to use for each element of the mesh. 
+ *         The data type has to be MPI safe as the data for ghost elements will be exchanged via MPI.
+ */
+template <typename TUnderlying, T8MPISafeType TElementDataType>
+class handle_element_data: public t8_crtp_basic<TUnderlying> {
+ public:
+  using ElementDataType = TElementDataType; /**< Make Type of the element data publicly accessible. */
+
+  /** Set the element data vector. The vector should have the length of num_local_elements.
+   * \param [in] element_data The element data vector to set with one entry of class TElementDataType 
+   *            for each local mesh element (excluding ghosts).
+   */
+  void
+  set_element_data (std::vector<TElementDataType> element_data)
+  {
+    const auto num_local_elements = this->underlying ().get_num_local_elements ();
+    const auto num_ghosts = this->underlying ().get_num_ghosts ();
+    T8_ASSERT (element_data.size () == static_cast<size_t> (num_local_elements));
+    m_element_data = std::move (element_data);
+    m_element_data.reserve (num_local_elements + num_ghosts);
+    m_element_data.resize (num_local_elements);
+  }
+
+  /** Get the element data vector.
+   * The element data of the local mesh elements can be set using \ref set_element_data.
+   * If ghost entries should be filled, one should call \ref exchange_ghost_data on each process first.
+   * \return Element data vector with data of Type TElementDataType.
+   */
+  const std::vector<TElementDataType>&
+  get_element_data () const
+  {
+    return m_element_data;
+  }
+
+  /** Exchange the element data for ghost elements between processes.
+  * This routine has to be called on each process after setting the element data for all local elements.
+  */
+  void
+  exchange_ghost_data ()
+  {
+    // t8_forest_ghost_exchange_data expects an sc_array, so we need to wrap our data array to one.
+    sc_array* sc_array_wrapper;
+    const auto num_local_elements = this->underlying ().get_num_local_elements ();
+    const auto num_ghosts = this->underlying ().get_num_ghosts ();
+    m_element_data.resize (num_local_elements + num_ghosts);
+    sc_array_wrapper
+      = sc_array_new_data (m_element_data.data (), sizeof (ElementDataType), num_local_elements + num_ghosts);
+
+    // Data exchange: entries with indices > num_local_elements will get overwritten.
+    t8_forest_ghost_exchange_data (this->underlying ().get_forest (), sc_array_wrapper);
+
+    sc_array_destroy (sc_array_wrapper);
+  }
+
+ protected:
+  std::vector<TElementDataType> m_element_data; /**< Vector storing the (local) element data. */
+};
+
+/** Wrapper for \ref handle_element_data to hide TUnderlying and provide the form needed to pass it as a mesh competence.
+ * Use mesh_competence_pack<element_data_competence<YourElementDataType>::template type> 
+ * to get this competence with the correct template parameter form for the mesh.
+ * \tparam TElementDataType The element data type you want to use for each element of the mesh. 
+ *         The data type has to be MPI safe as the data for ghost elements will be exchanged via MPI.
+ */
+template <T8MPISafeType TElementDataType>
+struct element_data_competence
+{
+  /** Type to provide the form needed for the mesh competence pack. 
+  * \tparam TUnderlying Use the \ref mesh class here.
+  */
+  template <typename TUnderlying>
+  using type = handle_element_data<TUnderlying, TElementDataType>;
+};
+
+// --- Element competence for element data management. ---
+/** Element competence to enable that element data can be accessed directly for each element of the mesh.
+ * \note This competence requires that the mesh has the \ref handle_element_data competence to manage the
+ *   element data vector and exchange ghost data.
+ * \tparam TUnderlying Use the \ref element with specified competences as template parameter.
+ */
+template <typename TUnderlying>
+struct access_element_data: public t8_crtp_basic<TUnderlying>
+{
+ public:
+  // --- Getter and setter for element data. ---
+  /** Getter for the element data.
+   * For ghost elements ensure that \ref handle_element_data::exchange_ghost_data is called on each process first.
+   * Element data for non-ghost elements can be accessed (if set) directly.
+   * \return Element data with data of Type TMeshClass::ElementDataType.
+   */
+  const auto&
+  get_element_data () const
+  {
+    T8_ASSERT (this->underlying ().m_mesh->has_element_data_handler_competence ());
+    const t8_locidx_t handle_id = this->underlying ().get_element_handle_id ();
+    T8_ASSERTF (static_cast<size_t> (handle_id) < this->underlying ().m_mesh->m_element_data.size (),
+                "Element data not set.\n");
+    return this->underlying ().m_mesh->m_element_data[handle_id];
+  }
+
+  /** Set the element data for the element. 
+   * \note You can only set element data for non-ghost elements.
+   * \param [in] element_data The element data to be set of Type TMeshClass::ElementDataType.
+   */
+  void
+  set_element_data (auto element_data)
+  {
+    T8_ASSERT (this->underlying ().m_mesh->has_element_data_handler_competence ());
+    SC_CHECK_ABORT (!this->underlying ().is_ghost_element (), "Element data cannot be set for ghost elements.\n");
+    // Resize for the case that no data vector has been set previously.
+    this->underlying ().m_mesh->m_element_data.reserve (this->underlying ().m_mesh->get_num_local_elements ()
+                                                        + this->underlying ().m_mesh->get_num_ghosts ());
+    this->underlying ().m_mesh->m_element_data.resize (this->underlying ().m_mesh->get_num_local_elements ());
+    this->underlying ().m_mesh->m_element_data[this->underlying ().get_element_handle_id ()] = std::move (element_data);
+  }
+};
+
+}  // namespace t8_mesh_handle
diff --git a/mesh_handle/element.hxx b/mesh_handle/element.hxx
index 3be4da2ad7..fabcd017fd 100644
--- a/mesh_handle/element.hxx
+++ b/mesh_handle/element.hxx
@@ -21,62 +21,76 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 */
 
 /** \file element.hxx
- * Definition of an element of the \ref t8_mesh_handle::mesh handle (can be ghost or mesh elements).
+ * Definition of an element of the \ref t8_mesh_handle::mesh handle (can be
+ * ghost or mesh elements).
  */
 
 #pragma once
 
+#include "data_handler.hxx"
+#include <optional>
 #include <t8.h>
-#include <t8_element.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
+#include <t8_element/t8_element.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 <vector>
-#include <optional>
 
 namespace t8_mesh_handle
 {
-/** 
+/**
  * 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 
+ * 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
  * recalculation in every function call.
- * To add functionality to the element, you can also simply write your own competence 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.
+ * To add functionality to the element, you can also simply write your own
+ * competence 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 \ref T8Type (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 member variables of the default element to a minimum to save memory.
- * The choice between calculate and cache is a tradeoff between runtime and memory usage. 
+ * The inheritance pattern is inspired by \ref T8Type (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
+ * member variables of the default element to a minimum to save memory. The
+ * choice between calculate and cache is a tradeoff between runtime and memory
+ * usage.
  *
- * \tparam TCompetences The competences you want to add to the default functionality of the element.
+ * \tparam TCompetences The competences you want to add to the default
+ * functionality of the element. \tparam TMeshClass The class of the mesh the
+ * element belongs to.
  */
 
-template <typename mesh_class, template <typename> class... TCompetences>
-class element: public TCompetences<element<mesh_class, TCompetences...>>... {
+template <typename TMeshClass, template <typename> class... TCompetences>
+class element: public TCompetences<element<TMeshClass, TCompetences...>>... {
  private:
-  using SelfType
-    = element<mesh_class, TCompetences...>; /**< Type of the current class with all template parameters specified. */
-  friend mesh_class; /**< Define mesh_class as friend to be able to access e.g. the constructor. */
-
-  /** 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)
+  using SelfType = element<TMeshClass, TCompetences...>; /**< Type of the current class with all template
+                                   parameters specified. */
+  friend TMeshClass;                                     /**< Define TMeshClass as friend to be able to access e.g.
+                        the constructor. */
+  friend struct access_element_data<SelfType>;           /**< Define the competence to access element data as friend to
+                    be able to access e.g. the mesh. */
+
+  /** 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
+   * TMeshClass (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 (TMeshClass* 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)
   {
     // Cache the t8_element_t from the forest as it is often used.
     if (m_is_ghost_element) {
-      // The local ghost tree id is per definition the local tree id - number of local (non-ghost) trees.
+      // 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);
     }
@@ -84,7 +98,8 @@ class element: public TCompetences<element<mesh_class, TCompetences...>>... {
       m_element = t8_forest_get_leaf_element_in_tree (m_mesh->m_forest, m_tree_id, m_element_id);
     }
 
-    // Resize cache vectors for face properties to ensure clean access in case they may be only partially filled later.
+    // Resize cache vectors for face properties to ensure clean access in case
+    // they may be only partially filled later.
     if constexpr (has_face_neighbor_cache ()) {
       const int num_faces = get_num_faces ();
       this->m_num_neighbors.resize (num_faces);
@@ -113,7 +128,7 @@ class element: public TCompetences<element<mesh_class, TCompetences...>>... {
   static constexpr bool
   has_volume_cache ()
   {
-    return (false || ... || volume_cache_defined<TCompetences> ());
+    return requires (SelfType& element) { element.volume_cache_filled (); };
   }
 
   /** Function that checks if a cache for the element's diameter exists.
@@ -122,7 +137,7 @@ class element: public TCompetences<element<mesh_class, TCompetences...>>... {
   static constexpr bool
   has_diameter_cache ()
   {
-    return (false || ... || diameter_cache_defined<TCompetences> ());
+    return requires (SelfType& element) { element.diameter_cache_filled (); };
   }
 
   /** Function that checks if a cache for the vertex coordinates exists.
@@ -131,7 +146,7 @@ class element: public TCompetences<element<mesh_class, TCompetences...>>... {
   static constexpr bool
   has_vertex_cache ()
   {
-    return (false || ... || vertex_cache_defined<TCompetences> ());
+    return requires (SelfType& element) { element.vertex_cache_filled (); };
   }
 
   /** Function that checks if a cache for the centroid exists.
@@ -140,7 +155,7 @@ class element: public TCompetences<element<mesh_class, TCompetences...>>... {
   static constexpr bool
   has_centroid_cache ()
   {
-    return (false || ... || centroid_cache_defined<TCompetences> ());
+    return requires (SelfType& element) { element.centroid_cache_filled (); };
   }
 
   /** Function that checks if a cache for the face neighbors exists.
@@ -149,7 +164,7 @@ class element: public TCompetences<element<mesh_class, TCompetences...>>... {
   static constexpr bool
   has_face_neighbor_cache ()
   {
-    return (false || ... || neighbor_cache_defined<TCompetences> ());
+    return requires (SelfType& element) { element.neighbor_cache_filled (0); };
   }
   /** Function that checks if a cache for the element's face areas exists.
    * \return true if a cache exists, false otherwise.
@@ -157,7 +172,7 @@ class element: public TCompetences<element<mesh_class, TCompetences...>>... {
   static constexpr bool
   has_face_areas_cache ()
   {
-    return (false || ... || face_area_cache_defined<TCompetences> ());
+    return requires (SelfType& element) { element.face_area_cache_filled (0); };
   }
 
   /** Function that checks if a cache for the element's face centroids exists.
@@ -166,7 +181,7 @@ class element: public TCompetences<element<mesh_class, TCompetences...>>... {
   static constexpr bool
   has_face_centroids_cache ()
   {
-    return (false || ... || face_centroid_cache_defined<TCompetences> ());
+    return requires (SelfType& element) { element.face_centroid_cache_filled (0); };
   }
 
   /** Function that checks if a cache for the element's face normals exists.
@@ -175,13 +190,14 @@ class element: public TCompetences<element<mesh_class, TCompetences...>>... {
   static constexpr bool
   has_face_normals_cache ()
   {
-    return (false || ... || face_normal_cache_defined<TCompetences> ());
+    return requires (SelfType& element) { element.face_normal_cache_filled (0); };
   }
 
-  // --- Functionality of the element. In each function, it is checked if a cached version exists (and is used then). ---
+  // --- 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 element.
-   *  For this easily accessible variable, it makes no sense to provide a cached version.
-   * \return Refinement level of the element.
+   *  For this easily accessible variable, it makes no sense to provide a cached
+   * version. \return Refinement level of the element.
    */
   t8_element_level
   get_level () const
@@ -190,8 +206,8 @@ class element: public TCompetences<element<mesh_class, TCompetences...>>... {
   }
 
   /** 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.
+   *  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
@@ -200,8 +216,8 @@ class element: public TCompetences<element<mesh_class, TCompetences...>>... {
   }
 
   /** Getter for the number of vertices of the element.
-   *  For this easily accessible variable, it makes no sense to provide a cached version.
-   * \return Number of vertices of the element.
+   *  For this easily accessible variable, it makes no sense to provide a cached
+   * version. \return Number of vertices of the element.
    */
   int
   get_num_vertices () const
@@ -210,8 +226,8 @@ class element: public TCompetences<element<mesh_class, TCompetences...>>... {
   }
 
   /** 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.
+   *  For this easily accessible variable, it makes no sense to provide a cached
+   * version. \return The shape of the element.
    */
   t8_element_shape_t
   get_shape () const
@@ -221,8 +237,8 @@ class element: public TCompetences<element<mesh_class, TCompetences...>>... {
 
   /** Getter for the element's volume.
    *  This is only an approximation.
-   *  This function uses or sets the cached version defined in TCompetence if available and calculates if not.
-   * \return The volume of the element.
+   *  This function uses or sets the cached version defined in TCompetence if
+   * available and calculates if not. \return The volume of the element.
    */
   double
   get_volume () const
@@ -239,8 +255,8 @@ class element: public TCompetences<element<mesh_class, TCompetences...>>... {
 
   /** Getter for the element's diameter.
    *  This is only an approximation.
-   *  This function uses or sets the cached version defined in TCompetence if available and calculates if not.
-   * \return The diameter of the element.
+   *  This function uses or sets the cached version defined in TCompetence if
+   * available and calculates if not. \return The diameter of the element.
    */
   double
   get_diameter () const
@@ -256,8 +272,9 @@ class element: public TCompetences<element<mesh_class, TCompetences...>>... {
   }
 
   /** 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.
+   *  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_vec>
   get_vertex_coordinates () const
@@ -283,16 +300,17 @@ class element: public TCompetences<element<mesh_class, TCompetences...>>... {
   }
 
   /** Getter for the coordinates of one specific vertex of the element.
-   *  This function uses or sets the cached version defined in TCompetence if available and calculates if not.
-   *  The cache is filled for all vertices simultaneously.
-   * \param [in] vertex Index of the vertex.
-   * \return Coordinates of the vertex.
+   *  This function uses or sets the cached version defined in TCompetence if
+   * available and calculates if not. The cache is filled for all vertices
+   * simultaneously. \param [in] vertex Index of the vertex. \return Coordinates
+   * of the vertex.
    */
   t8_3D_vec
   get_vertex_coordinates (int vertex) const
   {
     T8_ASSERT (vertex < get_num_vertices ());
-    // Check if we have a cached version and if the cache has already been filled.
+    // Check if we have a cached version and if the cache has already been
+    // filled.
     if constexpr (has_vertex_cache ()) {
       if (!this->vertex_cache_filled ()) {
         get_vertex_coordinates ();
@@ -305,13 +323,14 @@ class element: public TCompetences<element<mesh_class, TCompetences...>>... {
   }
 
   /** 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.
+   * This function uses the cached version defined in TCompetence if available
+   * and calculates if not. \return Coordinates of the center.
    */
   t8_3D_vec
   get_centroid () const
   {
-    // Check if we have a cached version and if the cache has already been filled.
+    // Check if we have a cached version and if the cache has already been
+    // filled.
     if constexpr (has_centroid_cache ()) {
       if (this->centroid_cache_filled ()) {
         return this->m_centroid.value ();
@@ -327,10 +346,12 @@ class element: public TCompetences<element<mesh_class, TCompetences...>>... {
   }
 
   /** Getter for the face neighbors of the mesh element at a given face.
-   * This function uses the cached version defined in TCompetences 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.
+   * This function uses the cached version defined in TCompetences 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
@@ -362,7 +383,8 @@ class element: public TCompetences<element<mesh_class, TCompetences...>>... {
       neighbors_handle.push_back (&((*m_mesh)[neighids[ineighs]]));
     }
     if constexpr (has_face_neighbor_cache ()) {
-      // Also store num_neighbors in cache to indicate that the cache is filled if a face does not have any neighbor.
+      // 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);
@@ -380,7 +402,8 @@ class element: public TCompetences<element<mesh_class, TCompetences...>>... {
     return neighbors_handle;
   }
 
-  /** Function to fill the face neighbor cache for all faces of the mesh element.
+  /** Function to fill the face neighbor cache for all faces of the mesh
+   * element.
    */
   void
   fill_face_neighbor_cache () const
@@ -394,8 +417,8 @@ class element: public TCompetences<element<mesh_class, TCompetences...>>... {
   // --- Getter for face properties. ---
   /** The area of a face of the element.
    *  This is only an approximation.
-   *  This function uses the cached version defined in TCompetence if available and calculates if not.
-   * \param [in] face Index of a face of the element.
+   *  This function uses the cached version defined in TCompetence if available
+   * and calculates if not. \param [in] face Index of a face of the element.
    * \return The area of the face with id \a face.
    */
   double
@@ -412,8 +435,8 @@ class element: public TCompetences<element<mesh_class, TCompetences...>>... {
   }
 
   /** The centroid of a face of the element.
-   *  This function uses the cached version defined in TCompetence if available and calculates if not.
-   * \param [in] face Index of a face of the element.
+   *  This function uses the cached version defined in TCompetence if available
+   * and calculates if not. \param [in] face Index of a face of the element.
    * \return The centroid of the face with id \a face.
    */
   t8_3D_vec
@@ -434,8 +457,8 @@ class element: public TCompetences<element<mesh_class, TCompetences...>>... {
   }
 
   /** The normal vector of a face of the element.
-   *  This function uses the cached version defined in TCompetence if available and calculates if not.
-   * \param [in] face Index of a face of the element.
+   *  This function uses the cached version defined in TCompetence if available
+   * and calculates if not. \param [in] face Index of a face of the element.
    * \return The normal vector of the face with id \a face.
    */
   t8_3D_vec
@@ -456,9 +479,9 @@ class element: public TCompetences<element<mesh_class, TCompetences...>>... {
   }
 
   /** Getter for the element's face shape.
-   *  For this easily accessible variable, it makes no sense to provide a cached version.
-   * \param [in] face Index of a face of the element.
-   * \return The shape of the face with id \a face.
+   *  For this easily accessible variable, it makes no sense to provide a cached
+   * version. \param [in] face Index of a face of the element. \return The shape
+   * of the face with id \a face.
    */
   t8_element_shape_t
   get_face_shape (int face) const
@@ -469,8 +492,8 @@ class element: public TCompetences<element<mesh_class, TCompetences...>>... {
 
   // --- Print for the element for debugging purpose. ---
 #if T8_ENABLE_DEBUG
-  /** Print the element. 
-   *  For example, print the coordinates and level of a triangle.  
+  /** Print the element.
+   *  For example, print the coordinates and level of a triangle.
    *  This function is only available in the debugging configuration.
    */
   void
@@ -481,8 +504,8 @@ class element: public TCompetences<element<mesh_class, TCompetences...>>... {
 #endif
 
   // --- Function to access mesh specific id. ---
-  /** Getter for the index of the element in the mesh to which the element belongs.
-   * \return The local element id of the element in the mesh.
+  /** Getter for the index of the element in the mesh to which the element
+   * belongs. \return The local element id of the element in the mesh.
    */
   t8_locidx_t
   get_element_handle_id () const
@@ -498,8 +521,9 @@ class element: public TCompetences<element<mesh_class, TCompetences...>>... {
 
   //--- Getter for the member variables. ---
   /** Getter for the tree id of the element in the forest related to the mesh.
-   *  \warning This is related to t8code's tree structure and should not be confused with \ref mesh specific ids.
-   *  This function is mainly relevant for writing custom competences that need to access t8code functionality.
+   *  \warning This is related to t8code's tree structure and should not be
+   * confused with \ref mesh specific ids. This function is mainly relevant for
+   * writing custom competences that need to access t8code functionality.
    * \return The element's local tree id in the forest.
    */
   t8_locidx_t
@@ -508,10 +532,11 @@ class element: public TCompetences<element<mesh_class, TCompetences...>>... {
     return m_tree_id;
   }
 
-  /** Getter for the local element id in the tree of the element in the forest related to the mesh.
-   *  \warning This is related to t8code's tree structure and should not be confused with \ref mesh specific ids.
-   *  For mesh specific id use \ref get_element_handle_id. 
-   *  This function is mainly relevant for writing custom competences that need to access t8code functionality.
+  /** Getter for the local element id in the tree of the element in the forest
+   * related to the mesh. \warning This is related to t8code's tree structure
+   * and should not be confused with \ref mesh specific ids. For mesh specific
+   * id use \ref get_element_handle_id. This function is mainly relevant for
+   * writing custom competences that need to access t8code functionality.
    * \return The local element id in the tree of the element in the forest.
    */
   t8_locidx_t
@@ -523,7 +548,7 @@ class element: public TCompetences<element<mesh_class, TCompetences...>>... {
   /** Getter for the mesh to which the element belongs.
    * \return Reference to the mesh.
    */
-  const mesh_class*
+  const TMeshClass*
   get_mesh () const
   {
     return m_mesh;
@@ -538,45 +563,17 @@ class element: public TCompetences<element<mesh_class, TCompetences...>>... {
     return m_is_ghost_element;
   }
 
-  // --- Getter and setter for element data. ---
-  /** Getter for the element data.
-   * For ghost elements ensure that \ref mesh::exchange_ghost_data is called on each process first.
-   * Element data for non-ghost elements can be accessed (if set) directly.
-   * \return Element data with data of Type mesh_class::ElementDataType.
-   */
-  template <typename TElementDataType = typename mesh_class::ElementDataType,
-            typename = std::enable_if_t<!std::is_void<TElementDataType>::value>>
-  const TElementDataType&
-  get_element_data () const
-  {
-    const t8_locidx_t handle_id = get_element_handle_id ();
-    T8_ASSERTF (static_cast<size_t> (handle_id) < m_mesh->m_element_data.size (), "Element data not set.\n");
-    return m_mesh->m_element_data[handle_id];
-  }
-
-  /** Set the element data for the element. 
-   * \note You can only set element data for non-ghost elements.
-   * \param [in] element_data The element data to be set.
-   */
-  template <typename TElementDataType = typename mesh_class::ElementDataType,
-            typename = std::enable_if_t<!std::is_void<TElementDataType>::value>>
-  void
-  set_element_data (TElementDataType element_data)
-  {
-    SC_CHECK_ABORT (!m_is_ghost_element, "Element data cannot be set for ghost elements.\n");
-    // Resize for the case that no data vector has been set previously.
-    m_mesh->m_element_data.reserve (m_mesh->get_num_local_elements () + m_mesh->get_num_ghosts ());
-    m_mesh->m_element_data.resize (m_mesh->get_num_local_elements ());
-    m_mesh->m_element_data[get_element_handle_id ()] = std::move (element_data);
-  }
-
  private:
   // --- Private member variables. ---
-  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. */
+  TMeshClass* 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. */
 
   // --- Private helper function. ---
   /** Getter for the eclass of the tree of the element.
@@ -587,88 +584,6 @@ class element: public TCompetences<element<mesh_class, TCompetences...>>... {
   {
     return t8_forest_get_tree_class (m_mesh->m_forest, m_tree_id);
   }
-
-  // --- Private variables to check which functionality is defined in TCompetence. ---
-  /** Helper function to check if class T implements the function volume_cache_filled.
-   * \tparam T The competence to be checked.
-   * \return true if T implements the function, false if not.
-   */
-  template <template <typename> class T>
-  static constexpr bool
-  volume_cache_defined ()
-  {
-    return requires (T<SelfType>& competence) { competence.volume_cache_filled (); };
-  }
-  /** Helper function to check if class T implements the function diameter_cache_defined.
-   * \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
-  diameter_cache_defined ()
-  {
-    return requires (T<SelfType>& competence) { competence.diameter_cache_filled (); };
-  }
-  /** 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 (); };
-  }
-  /** 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 (); };
-  }
-  /** 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.
-   */
-  template <template <typename> class T>
-  static constexpr bool
-  neighbor_cache_defined ()
-  {
-    return requires (T<SelfType>& competence) { competence.neighbor_cache_filled (0); };
-  }
-  /** Helper function to check if class T implements the function face_area_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
-  face_area_cache_defined ()
-  {
-    return requires (T<SelfType>& competence) { competence.face_area_cache_filled (0); };
-  }
-  /** Helper function to check if class T implements the function face_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
-  face_centroid_cache_defined ()
-  {
-    return requires (T<SelfType>& competence) { competence.face_centroid_cache_filled (0); };
-  }
-  /** Helper function to check if class T implements the function face_normal_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
-  face_normal_cache_defined ()
-  {
-    return requires (T<SelfType>& competence) { competence.face_normal_cache_filled (0); };
-  }
 };
 
 }  // namespace t8_mesh_handle
diff --git a/mesh_handle/internal/competence_pack_union.hxx b/mesh_handle/internal/competence_pack_union.hxx
new file mode 100644
index 0000000000..6e0958f90e
--- /dev/null
+++ b/mesh_handle/internal/competence_pack_union.hxx
@@ -0,0 +1,164 @@
+/*
+  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) 2026 the developers
+
+  t8code is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2 of the License, or
+  (at your option) any later version.
+
+  t8code is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with t8code; if not, write to the Free Software Foundation, Inc.,
+  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+*/
+
+/** \file competence_pack_union.hxx 
+ * Define the implementation of the unique union of competences of several \ref t8_mesh_handle::competence_pack 's.
+ * Users should use \ref t8_mesh_handle::union_competence_packs_type in \ref competence_pack.hxx.
+ */
+
+#pragma once
+
+#include <type_traits>
+
+namespace t8_mesh_handle
+{
+
+/** Forward declaration of the competence pack class.
+ * \tparam TCompetence The competences to be packed.
+ */
+template <template <typename> class... TCompetence>
+struct element_competence_pack;
+
+/** Namespace to hide detail from user. */
+namespace detail
+{
+
+// --- Unique insertion of one competence into a competence pack. ---
+/** Helper: Wraps a template-template parameter into a type for comparison.
+ * Necessary because our competences are templated on the underlying type.
+ * This allows safe comparison of template templates using std::is_same_v.
+ * \tparam TType Template-template parameter to wrap.
+ */
+template <template <class> class TType>
+struct tag
+{
+};
+
+/** Insert competence TCompetence into a pack with competences TUnionCompetences
+ * if not already present. A new element_competence_pack is produced. \tparam
+ * TCompetence       Competence to insert. \tparam TUnionCompetences Existing
+ * competences in the pack.
+ */
+template <template <class> class TCompetence, template <class> class... TUnionCompetences>
+using insert_unique = std::conditional_t<(std::is_same_v<tag<TCompetence>, tag<TUnionCompetences>> || ...),
+                                         element_competence_pack<TUnionCompetences...>,
+                                         element_competence_pack<TUnionCompetences..., TCompetence>>;
+
+//--- Unique fold operation to fold competences into one competence pack without
+//duplication. ---
+/** Fold operation to accumulate unique competences.
+ * Recursively inserts all TCompetences into the competence pack.
+ * \tparam TCompetencePack Current accumulated element_competence_pack.
+ * \tparam TCompetences Competences to process.
+ */
+template <typename TCompetencePack, template <class> class... TCompetences>
+struct fold_unique;
+
+/** Termination case: no more competences to process.
+ * Specialization for the case when the competence pack is already fully
+ * processed and no more competences are left to insert. \tparam
+ * TUnionCompetences Existing competences in the pack.
+ */
+template <template <class> class... TUnionCompetences>
+struct fold_unique<element_competence_pack<TUnionCompetences...>>
+{
+  /** Final competence pack with all competences inserted. */
+  using type = element_competence_pack<TUnionCompetences...>;
+};
+
+/** Recursive case: insert the first competence uniquely, then process the rest
+ * recursively until termination (no competences left). Specialization for the
+ * case when there is still at least one competence left to process. \tparam
+ * TUnionCompetences Existing competences in the pack. \tparam TCompetence
+ * Competence to insert in this recursion cycle. \tparam TOtherCompetences
+ * Remaining competences to process in the next recursion cycles.
+ */
+template <template <class> class... TUnionCompetences, template <class> class TCompetence,
+          template <class> class... TOtherCompetences>
+struct fold_unique<element_competence_pack<TUnionCompetences...>, TCompetence, TOtherCompetences...>
+{
+  /** Competence pack after inserting the first competence TCompetence uniquely.
+   */
+  using type = typename fold_unique<insert_unique<TCompetence, TUnionCompetences...>, TOtherCompetences...>::type;
+};
+
+//--- Unique union of two competence packs. ---
+/** Compute the unique union of the competences of two \ref competence_pack 's.
+ * This produces a new \ref competence_pack containing all competences with
+ * duplicates removed. \tparam TPack1 First competence pack. \tparam TPack2
+ * Second competence pack.
+ */
+template <typename TPack1, typename TPack2>
+struct union_two_element_competence_packs;
+
+/** Specialization for two \ref element_competence_pack types.
+ * This is necessary because this way, we can access the competences directly.
+ * This specialization of the class above is used if both template parameters
+ * are of type \ref element_competence_pack. \tparam TCompetences1 Competences
+ * of the first competence pack. \tparam TCompetences2 Competences of the second
+ * competence pack.
+ */
+template <template <class> class... TCompetences1, template <class> class... TCompetences2>
+struct union_two_element_competence_packs<element_competence_pack<TCompetences1...>,
+                                          element_competence_pack<TCompetences2...>>
+{
+  /** The resulting element_competence_pack type with all competences from both
+   * packs, but without duplicates. The type is computed by folding the unique
+   * insertion of all competences from both packs into an initially empty pack.
+   */
+  using type = typename fold_unique<element_competence_pack<>, TCompetences1..., TCompetences2...>::type;
+};
+
+//--- Recursive union of multiple competence packs using the implementation for
+//two packs. ---
+/** Recursive case: Compute the unique union of the competences of more than one
+ * \ref element_competence_pack 's. Specialization for the case when there are
+ * still at least two competence packs left to process. Uses \ref
+ * union_two_element_competence_packs recursively for pairwise combination.
+ * \tparam TPack First competence pack to combine with the union of the rest of
+ * the competence packs in this recursion cycle. \tparam TPacks The competence
+ * pack for which we should compute the unique union of the competences. Each
+ * competence pack is expected to be of type \ref element_competence_pack.
+ */
+template <typename TPack, typename... TPacks>
+struct union_competence_packs
+{
+  /** This is the type of a new \ref element_competence_pack containing all
+   * competences of the competence packs with duplicates removed.
+   */
+  using type =
+    typename union_two_element_competence_packs<TPack, typename union_competence_packs<TPacks...>::type>::type;
+};
+
+/** Termination case: Only one pack left.
+ * Specialization for the case when there is only one competence pack left to
+ * process. \tparam TPack The only competence pack left.
+ */
+template <typename TPack>
+struct union_competence_packs<TPack>
+{
+  /** Type of the last remaining competence pack. */
+  using type = TPack;
+};
+
+}  // namespace detail
+}  // namespace t8_mesh_handle
diff --git a/mesh_handle/mesh.hxx b/mesh_handle/mesh.hxx
index bdd30ff9a3..463a0c9e24 100644
--- a/mesh_handle/mesh.hxx
+++ b/mesh_handle/mesh.hxx
@@ -30,45 +30,49 @@
 #include "element.hxx"
 #include "competence_pack.hxx"
 #include "adapt.hxx"
+#include "data_handler.hxx"
+#include <t8_forest/t8_forest_balance.h>
+#include <t8_forest/t8_forest_types.h>
 #include <t8_forest/t8_forest_general.h>
 #include <t8_forest/t8_forest_ghost.h>
 #include <vector>
-#include <type_traits>
 #include <functional>
 #include <memory>
 
 namespace t8_mesh_handle
 {
 
-/** Concept to ensure that a type is MPI safe.
+/** Concept to ensure that a type is an element competence pack.
  */
 template <typename TType>
-concept T8MPISafeType
-  = std::is_void_v<TType> || (std::is_trivially_copyable_v<TType> && std::is_standard_layout_v<TType>);
+concept ElementCompetencePack = requires { typename TType::is_element_competence_pack; };
+/** Concept to ensure that a type is a mesh competence pack.
+ */
+template <typename TType>
+concept MeshCompetencePack = requires { typename TType::is_mesh_competence_pack; };
 
 /**
  * Wrapper for a forest that enables it to be handled as a simple mesh object.
- * \tparam TCompetencePack The competences you want to add to the default functionality of the mesh.
+ * \tparam TElementCompetencePack The competences you want to add to the default functionality of the elements.
  *         \see element for more details on the choice of the template parameter.   
- *         \note Please pack your competences using the \ref competence_pack class.
- * \tparam TElementDataType The element data type you want to use for each element of the mesh. 
- *         The data type has to be MPI safe as the data for ghost elements will be exchanged via MPI.
- *         Use void (this is also the default) if you do not want to set element data.
+ *         \note Please pack your competences using the \ref element_competence_pack class.
+ * \tparam TMeshCompetences The competences you want to add to the default functionality of the mesh.  
+ *         \note Please pack your competences using the \ref t8_mesh_handle::mesh_competence_pack class.
+ *         One of the most important competences to add is \ref handle_element_data.
  */
-template <typename TCompetencePack = competence_pack<>, T8MPISafeType TElementDataType = void>
-class mesh {
+template <ElementCompetencePack TElementCompetencePack = element_competence_pack<>,
+          MeshCompetencePack TMeshCompetencePack = mesh_competence_pack<>>
+class mesh: public TMeshCompetencePack::template apply<mesh<TElementCompetencePack, TMeshCompetencePack>> {
  public:
-  using SelfType
-    = mesh<TCompetencePack, TElementDataType>; /**< Type of the current class with all template parameters specified. */
-  using ElementDataType = TElementDataType;    /**< Make Type of the element data accessible. */
-  using element_class =
-    typename TCompetencePack::template apply<SelfType,
-                                             element>; /**< The element class of the mesh with given competences. */
+  using SelfType = mesh<TElementCompetencePack, TMeshCompetencePack>; /**< Type of the current class. */
+  using element_class = typename TElementCompetencePack::template apply<
+    SelfType, element>; /**< 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<element_class>::const_iterator; /**< Constant iterator type for the mesh elements. */
   using mesh_iterator =
-    typename std::vector<element_class>::iterator; /**< Non-const iterator type for the mesh elements. */
+    typename std::vector<element_class>::iterator;  /**< Non-const iterator type for the mesh elements. */
+  friend struct access_element_data<element_class>; /**< Friend struct to access its element data vector. */
 
   /** Callback function prototype to decide for refining and coarsening of a family of elements
    * or one element in a mesh handle.
@@ -107,7 +111,6 @@ class mesh {
    */
   mesh (t8_forest_t forest): m_forest (forest)
   {
-    T8_ASSERT ((std::is_same<typename TCompetencePack::is_competence_pack, void>::value));
     T8_ASSERT (t8_forest_is_committed (m_forest));
     update_elements ();
   }
@@ -163,6 +166,17 @@ class mesh {
     return m_forest;
   }
 
+  /** Check if the local elements of the mesh are balanced. 
+  * The mesh is said to be balanced if each element has face neighbors of level
+  * at most +1 or -1 of the element's level.
+  * \return true if the local elements are balanced, false otherwise.
+  */
+  bool
+  is_balanced ()
+  {
+    return t8_forest_is_balanced (m_forest);
+  }
+
   // --- Methods to access elements. ---
   /**
    * Returns a constant iterator to the first (local) mesh element.
@@ -277,6 +291,50 @@ class mesh {
     t8_forest_set_adapt (m_uncommitted_forest.value (), m_forest, detail::mesh_adapt_callback_wrapper, recursive);
   }
 
+  /** If this function is called, the mesh will be partitioned on committing.
+   * The partitioning is done according to the SFC and each rank is assigned
+   * the same (maybe +1) number of elements.
+   * \note The partition is carried out only when \ref commit is called.
+   * \note This setting can be combined with \ref set_adapt and \ref set_balance. The order in which
+   * these operations are executed is always 1) Adapt 2) Partition 3) Balance.
+   * \param [in] set_for_coarsening If true, the partitions are choose such that coarsening 
+   *        an element once is a process local operation. Default is false.
+   */
+  void
+  set_partition (bool set_for_coarsening = false)
+  {
+    if (!m_uncommitted_forest.has_value ()) {
+      t8_forest_t new_forest;
+      t8_forest_init (&new_forest);
+      m_uncommitted_forest = new_forest;
+    }
+    t8_forest_set_partition (m_uncommitted_forest.value (), m_forest, set_for_coarsening);
+  }
+
+  /** If this function is called, the mesh will be balanced on committing.
+   * The mesh is said to be balanced if each element has face neighbors of level
+   * at most +1 or -1 of the element's level.
+   * \note The balance is carried out only when \ref commit is called.
+   * \param [in] no_repartition Balance constructs several intermediate steps that
+   *       are refined from each other. In order to maintain a balanced load, a repartitioning is performed in each 
+   *       round and the resulting mesh is load-balanced per default. 
+   *       Set \a no_repartition to true if this behaviour is not desired.
+   *       If \a no_repartition is false (default), an additional call of \ref set_partition is not necessary.
+   * \note This setting can be combined with \ref set_adapt and \ref set_partition. The order in which
+   * these operations are executed is always 1) Adapt 2) Partition 3) Balance.
+   */
+  void
+  set_balance (bool no_repartition = false)
+  {
+    if (!m_uncommitted_forest.has_value ()) {
+      t8_forest_t new_forest;
+      t8_forest_init (&new_forest);
+      m_uncommitted_forest = new_forest;
+    }
+    // Disable repartitioning and let the user call set_partition if desired.
+    t8_forest_set_balance (m_uncommitted_forest.value (), m_forest, no_repartition);
+  }
+
   /** Enable or disable the creation of a layer of ghost elements.
    * \param [in]      do_ghost  If true a ghost layer will be created.
    * \param [in]      ghost_type Controls which neighbors count as ghost elements,
@@ -318,7 +376,7 @@ class mesh {
     // Check if we adapted and unregister the adapt context if so.
     if (detail::AdaptRegistry::get (m_uncommitted_forest.value ()) != nullptr) {
       detail::AdaptRegistry::unregister_context (m_forest);
-      if (!std::is_void<TElementDataType>::value) {
+      if (has_element_data_handler_competence ()) {
         t8_global_infof (
           "Please note that the element data is not interpolated automatically during adaptation. Use the "
           "function set_element_data() to provide new adapted element data.\n");
@@ -331,56 +389,14 @@ class mesh {
     update_elements ();
   }
 
-  // --- Methods to set and get user and element data and exchange data between processes. ---
-  /** 
-   * Set the element data vector. The vector should have the length of num_local_elements.
-   * \param [in] element_data The element data vector to set with one entry of class TElementDataType 
-   *            for each local mesh element (excluding ghosts).
+  // --- Methods to check for mesh competences. ---
+  /** Function that checks if a competence for element data handling is given.
+   * \return true if mesh has a data handler, false otherwise.
    */
-  template <typename ElementDataType = TElementDataType,
-            typename = std::enable_if_t<!std::is_void<ElementDataType>::value>>
-  void
-  set_element_data (std::vector<ElementDataType> element_data)
+  static constexpr bool
+  has_element_data_handler_competence ()
   {
-    T8_ASSERT (element_data.size () == static_cast<size_t> (get_num_local_elements ()));
-    m_element_data = std::move (element_data);
-    m_element_data.reserve (get_num_local_elements () + get_num_ghosts ());
-    m_element_data.resize (get_num_local_elements ());
-  }
-
-  /** 
-   * Get the element data vector.
-   * The element data of the local mesh elements can be set using \ref set_element_data.
-   * If ghost entries should be filled, one should call \ref exchange_ghost_data on each process first.
-   * \return Element data vector with data of Type TElementDataType.
-   */
-  template <typename ElementDataType = TElementDataType,
-            typename = std::enable_if_t<!std::is_void<ElementDataType>::value>>
-  const std::vector<ElementDataType>&
-  get_element_data () const
-  {
-    return m_element_data;
-  }
-
-  /** 
-  * Exchange the element data for ghost elements between processes.
-  * This routine has to be called on each process after setting the element data for all local elements.
-  */
-  template <typename ElementDataType = TElementDataType,
-            typename = std::enable_if_t<!std::is_void<ElementDataType>::value>>
-  void
-  exchange_ghost_data ()
-  {
-    // t8_forest_ghost_exchange_data expects an sc_array, so we need to wrap our data array to one.
-    sc_array* sc_array_wrapper;
-    m_element_data.resize (get_num_local_elements () + get_num_ghosts ());
-    sc_array_wrapper = sc_array_new_data (m_element_data.data (), sizeof (ElementDataType),
-                                          get_num_local_elements () + get_num_ghosts ());
-
-    // Data exchange: entries with indices > num_local_elements will get overwritten.
-    t8_forest_ghost_exchange_data (m_forest, sc_array_wrapper);
-
-    sc_array_destroy (sc_array_wrapper);
+    return requires (SelfType& mesh) { mesh.get_element_data (); };
   }
 
  private:
@@ -427,8 +443,6 @@ class mesh {
   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. */
-  std::conditional_t<!std::is_void_v<TElementDataType>, std::vector<TElementDataType>, std::nullptr_t>
-    m_element_data; /**< Vector storing the (local) element data. */
   std::optional<t8_forest_t>
     m_uncommitted_forest; /**< Forest in which the set flags are set for a new forest before committing. */
 };
diff --git a/pull_request_template.md b/pull_request_template.md
index 9487fb68b8..1c8f3b26d0 100644
--- a/pull_request_template.md
+++ b/pull_request_template.md
@@ -25,7 +25,7 @@ If the Pull request introduces code that is not covered by the github action (fo
   - [ ] Should this use case be added to the github action?
   - [ ] If not, does the specific use case compile and all tests pass (check manually).
 #### Scripts and Wiki
-- [ ] If a new directory with source files is added, it must be covered by the `script/find_all_source_files.scp` to check the indentation of these files.
+- [ ] If a new directory with source files is added, it must be covered by the `scripts/internal/find_all_source_files.sh` to check the indentation of these files.
 - [ ] If this PR introduces a new feature, it must be covered in an example or tutorial and a Wiki article.
 #### License
 - [ ] The author added a BSD statement to `doc/` (or already has one).
\ No newline at end of file
diff --git a/scripts/README.md b/scripts/README.md
index c573496467..2a64333779 100644
--- a/scripts/README.md
+++ b/scripts/README.md
@@ -6,26 +6,21 @@ This folder contains several scripts that are useful for t8code users and develo
 
 The purpose of the indentation scripts is to help t8code developers to indent their code according to the t8code [indentation guidelines](https://github.com/DLR-AMR/t8code/wiki/Coding-Guideline#indentation). Please read these guidelines before using these scripts.
 
-#### t8indent.sh
+#### indent.sh
 
 Apply this script to a `.c`, `.cxx`, `.h` or `.hxx` file to indent it according to the guidelines.
 You can also provide a list of files and all will get indented.
 
 This script uses the `clang-format` program with t8code specific settings.
-Sometimes `t8indent.sh` does produce undesired results. Therefore, after indenting use `git add -p` or similar to check all changes before committing. You can protect code lines from being changed by the script by enclosing them in `/* clang-format off */` and `/* clang-format on */` comments.
+Sometimes `indent.sh` does produce undesired results. Therefore, after indenting use `git add -p` or similar to check all changes before committing. You can protect code lines from being changed by the script by enclosing them in `/* clang-format off */` and `/* clang-format on */` comments.
 
+#### internal/indent_ignore
 
-#### t8indent_ignore.sh
-
-A list of files that will be ignored by `t8indent.sh`.
-
-#### pre-commit
-
-This script should be copied to your `.git/hooks` folder. `git` then automatically checks the indentation of committed files and prevents you from committing wrongly indented files. See [Git indentation workflow](https://github.com/DLR-AMR/t8code/wiki/Coding-Guideline#git-indentation-workflow).
+A list of files that will be ignored by `indent.sh`.
 
 #### check_if_file_indented.sh
 
-Check for a single source file whether it is indented according to `t8indent.sh`.
+Check for a single source file whether it is indented according to `indent.sh`.
 
 #### check_if_all_files_indented.sh
 
@@ -35,30 +30,23 @@ Check whether all t8code source files are properly indented.
 
 This script indents all t8code source files at once. This script should only be used by the main developers of t8code. Handle with care.
 
-#### find_all_source_files.sh
-
-List all source files of t8code in the `src/`, `example/` and `test/` subfolders.
+## Software development
 
-#### check_valgrind.sh
+#### pre-commit
 
-This script runs Valgrind on a binary path provided as a parameter with specified memory leak detection flags. The Valgrind output is parsed. Using `--supp=[FILE]`, you can provide a path to a suppression file that is used by Valgrind to suppress certain errors (e.g. [valgrind_suppressions_file](valgrind_suppressions_file.supp)). With `--ntasks=[NUMBER]`, you can provide the number of processes to use with mpi (default is 1).
+This script should be copied to your `.git/hooks` folder. `git` then automatically checks the indentation of committed files and prevents you from committing wrongly indented files. See [Git indentation workflow](https://github.com/DLR-AMR/t8code/wiki/Coding-Guideline#git-indentation-workflow).
 
-#### find_all_test_binary_paths.sh
+#### check_valgrind.sh
 
-This file lists all paths to test binaries that exist in the build/test directory.
-The paths are relative paths assuming an execution from the test/ folder in the build directory.
+This script runs Valgrind on a binary path provided as a parameter with specified memory leak detection flags. The Valgrind output is parsed. Using `--supp=[FILE]`, you can provide a path to a suppression file that is used by Valgrind to suppress certain errors (e.g. [valgrind_suppressions_file](internal/valgrind_suppressions_file.supp)). With `--ntasks=[NUMBER]`, you can provide the number of processes to use with mpi (default is 1).
 
 #### check_all_test_binaries_valgrind.sh
 
-This script performs a valgrind check on each test binary found by [find_all_test_binary_paths.sh](find_all_test_binary_paths.sh).
+This script performs a valgrind check on each test binary found by [find_all_test_binary_paths.sh](internal/find_all_test_binary_paths.sh).
 The valgrind check is done by [check_valgrind.sh](check_valgrind.sh). It is assumed that the build folder ../build/test/ with the correct test binaries exists. With `--ntasks=[NUMBER]`, you can provide the number of processes to use with mpi for parallel tests (default is 1).
 
 ## Others
 
-#### su2_mesh_to_gmsh.py
-
-Used to convert coarse meshes from an su2 format into msh format.
-
 #### create_todo_list.sh
 
 Parses through the code and collects comments containing the `TODO` keyword.
diff --git a/scripts/check_all_test_binaries_valgrind.sh b/scripts/check_all_test_binaries_valgrind.sh
old mode 100644
new mode 100755
index c4f5796b30..f72497830f
--- a/scripts/check_all_test_binaries_valgrind.sh
+++ b/scripts/check_all_test_binaries_valgrind.sh
@@ -4,7 +4,7 @@
 #  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
+#  Copyright (C) 2026 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
@@ -23,16 +23,34 @@
 #
 # This script performs a valgrind check on each test binary given by find_all_test_binary_paths.sh.
 # The valgrind check is done by the check_valgrind.sh script.
-# The script returns 1 if an error is found and 0 otherwise. 
-# This script must be executed from the scripts/ folder.
-# It is assumed that the build folder ../build/test/ with the correct test binaries exists.
+# The script returns 1 if an error is found and 0 otherwise.
+# You need to provide the path to the test binaries. So the test folder inside the build directory.
 # With "--ntasks=[NUMBER]", you can provide the number of processes to use with MPI for parallel tests (default is 1).
 #
 
 USAGE="\nUSAGE: This script executes valgrind in parallel on each test binary available. Use the syntax \n
-$0 --ntasks=[NUM_TASKS]\n 
+$0 [TEST_BINARY_PATH] --ntasks=[NUM_TASKS]\n
 Providing the number of parallel processes to use with MPI for parallel tests is optional.\n"
 
+# Check directory exists
+if [ -z "$1" ]; then
+  echo "ERROR: Need to provide a directory as first argument."
+  echo -e "$USAGE"
+  exit 1
+fi
+
+# Check if it is a directory
+if [ -d "$1" ]; then
+  TEST_BINARY_PATH="$1"
+else
+  echo "ERROR: Directory does not exist: $1"
+  echo -e "$USAGE"
+  exit 1
+fi
+
+#convert to abspath
+TEST_BINARY_ABSPATH=$(realpath $TEST_BINARY_PATH)
+
 # Check if a number of processes is provided. If not, set to 1.
 num_procs=1
 for arg in "$@"; do
@@ -61,23 +79,25 @@ if [ `basename $PWD` != scripts ]; then
 fi
 
 # Find all test binary paths.
-test_bin_paths=`bash ./find_all_test_binary_paths.sh`
-num_paths=$(echo $test_bin_paths | wc -w)
+test_bin_paths=$(bash ./internal/find_all_test_binary_paths.sh "$TEST_BINARY_ABSPATH")
+status=$?
 
-# This is necessary because some tests use test files specified by relative paths. 
-# These tests only work when run from the build/test/ directory. 
-if [ -d ../build/test ]; then
-  # The directory stack is automatically reset on script exit.
-  pushd ../build/test/ > /dev/null
-else
-  echo "ERROR: Couldn't find a the directory ../build/test/."
-  echo -e "$USAGE"
-  exit 1
+if [ $status -ne 0 ]; then
+  echo "$test_bin_paths"
+  echo "Failed to collect test binaries."
+  exit $status
 fi
 
+num_paths=$(echo $test_bin_paths | wc -w)
+
+# This is necessary because some tests use test files specified by relative paths.
+# These tests only work when run from the test directory.
+# The directory stack is automatically reset on script exit.
+pushd $TEST_BINARY_ABSPATH > /dev/null
+
 status=0
 counter=0
-valgrind_suppressions_file=../../scripts/valgrind_suppressions_file.supp
+valgrind_suppressions_file=../../scripts/internal/valgrind_suppressions_file.supp
 
 # First run all serial tests in parallel.
 serial_count=$(echo $test_bin_paths | tr ' ' '\n' | grep -c '_serial')
diff --git a/scripts/check_if_all_files_indented.sh b/scripts/check_if_all_files_indented.sh
index dca7f1a81c..4c8208c3bf 100755
--- a/scripts/check_if_all_files_indented.sh
+++ b/scripts/check_if_all_files_indented.sh
@@ -44,7 +44,7 @@ fi
 
 # Find all files with the appropriate suffix.
 # Excluding the sc/ and p4est/ subfolders.
-files=`./find_all_source_files.sh`
+files=`./internal/find_all_source_files.sh`
 
 notallindented=0
 for file in $files
diff --git a/scripts/check_if_file_indented.sh b/scripts/check_if_file_indented.sh
index be7c55b3c5..ca23327d56 100755
--- a/scripts/check_if_file_indented.sh
+++ b/scripts/check_if_file_indented.sh
@@ -21,14 +21,14 @@
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 
 #
-# This script checks if a given file is correctly indented according to the t8indent.sh script.
-# 
+# This script checks if a given file is correctly indented according to the indent.sh script.
+#
 
 GIT_REPO_PATH=$(git rev-parse --show-toplevel)
 
-INDENT_SCRIPT=${GIT_REPO_PATH}/scripts/t8indent.sh
+INDENT_SCRIPT=${GIT_REPO_PATH}/scripts/indent.sh
 
-usage="USAGE:$0 [FILE_TO_CHECK]\n\nWill check if [FILE_TO_CHECK] is correctly indentend according to the script t8indent.sh."
+usage="USAGE:$0 [FILE_TO_CHECK]\n\nWill check if [FILE_TO_CHECK] is correctly indentend according to the script indent.sh."
 
 # Check if first argument given
 if [ ${1-x} = x ]
diff --git a/scripts/check_valgrind.sh b/scripts/check_valgrind.sh
old mode 100644
new mode 100755
index 635bdfd34b..c33c685413
--- a/scripts/check_valgrind.sh
+++ b/scripts/check_valgrind.sh
@@ -21,7 +21,7 @@
 #  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 
 #
-# This script runs Valgrind on an input binary paths with specified memory leak detection flags. 
+# This script runs Valgrind on an input binary paths with specified memory leak detection flags.
 # The Valgrind output is parsed. If any errors are found, they are printed and the script exits with a status of 1.
 # If errors are found, the Valgrind output is kept in the file valgrind-output.log for further inspection.
 # Using "--supp=[FILE]", you can provide a path to a suppression file that is used by Valgrind to suppress certain errors.
@@ -32,7 +32,7 @@ $0 [FILE] --supp=[SUPPRESSION_FILE] --ntasks=[NUM_TASKS]\n
 to run valgrind on FILE. Optionally you can provide a suppression file and the number of parallel processes to use with MPI.\n"
 
 # Check that an argument is given and that the argument is a file.
-if [ ${1-x} = x ]; then
+if [ -z "$1" ]; then
   echo "ERROR: Need to provide a file as first argument."
   echo -e "$USAGE"
   exit 1
diff --git a/scripts/configure_for_rtd.sh b/scripts/configure_for_rtd.sh
old mode 100644
new mode 100755
index dc44a436e7..c728d4ee62
--- a/scripts/configure_for_rtd.sh
+++ b/scripts/configure_for_rtd.sh
@@ -20,6 +20,8 @@
 #  along with t8code; if not, write to the Free Software Foundation, Inc.,
 #  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 
+pushd "$(git rev-parse --show-toplevel)" > /dev/null
+
 git submodule init
 git submodule update
 
diff --git a/scripts/find_disabled_tests.sh b/scripts/find_disabled_tests.sh
index efa3460aa3..0fa60081f5 100755
--- a/scripts/find_disabled_tests.sh
+++ b/scripts/find_disabled_tests.sh
@@ -1,25 +1,24 @@
 #!/bin/bash
 
-
-#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) 2024 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.
+#  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) 2024 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.
 
 
 
diff --git a/scripts/t8indent.sh b/scripts/indent.sh
similarity index 97%
rename from scripts/t8indent.sh
rename to scripts/indent.sh
index 750ecd6c51..e091533c8b 100755
--- a/scripts/t8indent.sh
+++ b/scripts/indent.sh
@@ -66,12 +66,12 @@ fi
 #
 #  Parsing of input files and throwing out files to be ignored
 #
-# Read all lines from the IGNORE_FILE 
+# Read all lines from the IGNORE_FILE
 # that are not empty and are not comments (i.e. start with '#').
 # Determine base directory of git repo
 GIT_REPO_PATH=$(git rev-parse --show-toplevel)
 
-IGNORE_FILE=${GIT_REPO_PATH}/scripts/t8indent_ignore.sh
+IGNORE_FILE=${GIT_REPO_PATH}/scripts/internal/indent_ignore
 files_to_ignore=()
 while read line; do
     if [[ ${line:0:1} != "#" ]] && [[ $line != "" ]]
@@ -112,7 +112,7 @@ do
     do
       echo Checking "$arg" against "${GIT_REPO_PATH}/$ignore_file"
     if [[ "$arg" -ef "${GIT_REPO_PATH}/$ignore_file" ]]
-    then 
+    then
       # arg matches and will be ignored
       echo The file \"$arg\" will be ignored by indentation as specified in \"$IGNORE_FILE\".
       ignore_arg=1
@@ -136,7 +136,7 @@ then
 else
   $FORMAT $FORMAT_OPTIONS ${newargs[@]}
   status=$?
-fi  
+fi
 
 # If the file content was not changed, the return
 # value determines whether or not the file was
diff --git a/scripts/indent_all_files.sh b/scripts/indent_all_files.sh
index 8d0559530f..4d7a7b4acf 100755
--- a/scripts/indent_all_files.sh
+++ b/scripts/indent_all_files.sh
@@ -43,13 +43,13 @@ fi
 
 # Find all files with the appropriate suffix.
 # Excluding the sc/ and p4est/ subfolders.
-files=`./find_all_source_files.sh`
+files=`./internal/find_all_source_files.sh`
 
 notallindented=0
 
-INDENT=./t8indent.sh
+INDENT=./indent.sh
 
-echo This script will change all source files found in 
+echo This script will change all source files found in
 echo	$PWD/../src/
 echo	$PWD/../example/
 echo	$PWD/../test/
@@ -72,14 +72,14 @@ then
     then
       $INDENT $file
       status=$?
-      if test $status -ne 0 
+      if test $status -ne 0
       then
         echo "File $file is not indented."
         notallindented=1
       fi
     fi
   done
-  
+
   if test $notallindented -eq 0
   then
     echo All files are indented.
diff --git a/scripts/check_macros.sh b/scripts/internal/check_macros.sh
similarity index 90%
rename from scripts/check_macros.sh
rename to scripts/internal/check_macros.sh
index 7e5e8645c1..7597ea9c11 100755
--- a/scripts/check_macros.sh
+++ b/scripts/internal/check_macros.sh
@@ -29,25 +29,25 @@ file_path=$1
 
 echo "$file_path"
 
-if [[ "$file_path" -ef "src/t8_with_macro_error.h" ]]
+if [[ "$file_path" -ef "src/t8_misc/t8_with_macro_error.h" ]]
 then
-  echo The file \"src/t8_with_macro_error.h\" will be ignored by the check_macros.sh script.
+  echo The file \"src/t8_misc/t8_with_macro_error.h\" will be ignored by the check_macros.sh script.
   exit 0
 fi
 
-# 
-# This script searches for lines containing a macro definition in the style of '#ifdef T8_ENABLE_' 
+#
+# This script searches for lines containing a macro definition in the style of '#ifdef T8_ENABLE_'
 # in the specified file and processes each matching line.
-# It uses 'grep' to find all occurrences of '#ifdef T8_ENABLE_' in the file located 
-# at the path stored in the variable 'file_path'. The '-n' option with 'grep' 
+# It uses 'grep' to find all occurrences of '#ifdef T8_ENABLE_' in the file located
+# at the path stored in the variable 'file_path'. The '-n' option with 'grep'
 # ensures that the line numbers of the matching lines are included in the output.
-# The output of 'grep' is then piped into a 'while' loop, which reads each line 
+# The output of 'grep' is then piped into a 'while' loop, which reads each line
 # and splits it into the line number and the line content using ':' as the delimiter.
 # Variables:
 # - file_path: The path to the file to be searched.
 # - line_number: The line number where the macro definition is found.
 # - line: The content of the line where the macro definition is found.
-# 
+#
 
 found_macros=FALSE
 
diff --git a/scripts/find_all_source_files.sh b/scripts/internal/find_all_source_files.sh
similarity index 100%
rename from scripts/find_all_source_files.sh
rename to scripts/internal/find_all_source_files.sh
diff --git a/scripts/find_all_test_binary_paths.sh b/scripts/internal/find_all_test_binary_paths.sh
old mode 100644
new mode 100755
similarity index 74%
rename from scripts/find_all_test_binary_paths.sh
rename to scripts/internal/find_all_test_binary_paths.sh
index 6abc889624..6984067bba
--- a/scripts/find_all_test_binary_paths.sh
+++ b/scripts/internal/find_all_test_binary_paths.sh
@@ -4,7 +4,7 @@
 #  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
+#  Copyright (C) 2026 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
@@ -26,16 +26,16 @@
 # The paths are relative paths assuming an execution from the test/ folder in the build directory.
 #
 
-build_test_directory="../build/test/"
+TEST_BINARY_PATH="$1"
 
 # Check that path to test folder in build directory is correct.
-if [ ! -d "$build_test_directory" ]; then
-  echo "Directory build/test/ not found!"
+if [ ! -d "$TEST_BINARY_PATH" ]; then
+  echo "Directory $TEST_BINARY_PATH not found!"
   exit 1
 fi
 
-# Find all executables in the build/test/ directory (that do not have a .so file ending) 
-# and store the relative paths to the build_test_directory with leading "./".
-test_bin_paths=$(find "$build_test_directory" -type f -executable -not -name "*.so" -exec realpath --relative-to="$build_test_directory" {} \; | sed 's|^|./|')
+# Find all executables in the build/test/ directory (that do not have a .so file ending)
+# and store the relative paths to the TEST_BINARY_PATH with leading "./".
+test_bin_paths=$(find "$TEST_BINARY_PATH" -type f -executable -not -name "*.so" -exec realpath --relative-to="$TEST_BINARY_PATH" {} \; | sed 's|^|./|')
 
-echo $test_bin_paths
+echo "$test_bin_paths"
diff --git a/scripts/t8indent_ignore.sh b/scripts/internal/indent_ignore
old mode 100755
new mode 100644
similarity index 88%
rename from scripts/t8indent_ignore.sh
rename to scripts/internal/indent_ignore
index 2aebf60489..2c33ee86fb
--- a/scripts/t8indent_ignore.sh
+++ b/scripts/internal/indent_ignore
@@ -19,11 +19,11 @@
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 
 # This is t8code's indentation ignore file.
-# All files listed here are ignored by out t8indent.sh script and thus not 
+# All files listed here are ignored by out indent.sh script and thus not
 # indented according to our indentation guidelines.
-# Since we rely on clang-format version 17 and clang-format.ignored files 
+# Since we rely on clang-format version 17 and clang-format.ignored files
 # have only been introduced in version 18, we need to manually parse
-# this list and throw out the matching files. This happens in t8indent.sh
+# this list and throw out the matching files. This happens in indent.sh
 
 # Each file that is listed here must have a comment describing why
 # it is necessary to ignore indentation for this file.
@@ -32,4 +32,4 @@
 # the usage of macros using the character '@'.
 # This causes clang to not recognize the file as a C++
 # file and will throw an error when trying to indent it.
-src/t8_with_macro_error.h
+src/t8_misc/t8_with_macro_error.h
diff --git a/scripts/valgrind_suppressions_file.supp b/scripts/internal/valgrind_suppressions_file.supp
similarity index 100%
rename from scripts/valgrind_suppressions_file.supp
rename to scripts/internal/valgrind_suppressions_file.supp
diff --git a/scripts/pre-commit b/scripts/pre-commit
index 0f04e17eba..cf062bdace 100755
--- a/scripts/pre-commit
+++ b/scripts/pre-commit
@@ -38,7 +38,7 @@ GIT_REPO_PATH=$(git rev-parse --show-toplevel)
 
 # Set paths to check scripts
 CHECK_INDENT=$GIT_REPO_PATH/scripts/check_if_file_indented.sh
-CHECK_MACROS=$GIT_REPO_PATH/scripts/check_macros.sh
+CHECK_MACROS=$GIT_REPO_PATH/scripts/internal/check_macros.sh
 
 TYPOS=`which typos 2> /dev/null`
 TYPOS_CONFIG_FILE=./.typos.toml
@@ -63,8 +63,17 @@ fi
 # Redirect output to stderr.
 exec 1>&2
 
+diff_size=$(git diff | wc -l)
+
+pre_stash_size=$(git stash list | wc -l)
+git stash push --quiet --keep-index --include-untracked --message "pre-commit-stash"
+post_stash_size=$(git stash list | wc -l)
+increased_stash_size=$((post_stash_size - pre_stash_size))
+
+# If the stash size has increased, it means a new stash entry was created.
 
 nocontinue=0
+
 for file in `git diff --cached --name-only`
 do
   # only indent existing files, this is necessary since if we rename or delete
@@ -83,7 +92,7 @@ do
   if ! [ -z "$status" ]; then
     echo "File $file contains typos."
     nocontinue=1
-  fi 
+  fi
 
   # We only indent .c, .cxx, .h and .hxx files
 #-a ${file: -2} != ".h" ]
@@ -93,7 +102,7 @@ do
     echo "Checking file $file"
     $CHECK_INDENT $file > /dev/null 2>&1
     status=$?
-    if test $status -ne 0 
+    if test $status -ne 0
     then
       echo "File $file is not indented."
       nocontinue=1
@@ -107,13 +116,21 @@ do
     # - nocontinue: Flag set to 1 if the incorrect macro usage is found.
     $CHECK_MACROS $file
     status=$?
-    if test $status -ne 0 
+    if test $status -ne 0
     then
       nocontinue=1
     fi
   fi
 done
 
+if [ $increased_stash_size -gt 0 ]; then
+  git stash pop --quiet --index
+fi
+
+if [ $nocontinue -ne 0 ]; then
+  printf '\033[38;5;208m%s\033[0m\n' "Pre-commit found errors. Did you add the latest changes?"
+fi
+
 # exit 1 if there was a nonindented file
 # this will abort the commit
 exit $nocontinue
diff --git a/scripts/t8spell_check_and_indent.sh b/scripts/spell_check_and_indent.sh
similarity index 97%
rename from scripts/t8spell_check_and_indent.sh
rename to scripts/spell_check_and_indent.sh
index 600b7bfb9e..f1ab9687a5 100755
--- a/scripts/t8spell_check_and_indent.sh
+++ b/scripts/spell_check_and_indent.sh
@@ -70,7 +70,7 @@ then
   if [[ $REPLY =~ ^[Yy]$ ]]
   then
     echo Indenting all files...
-    (cd $repo_main_dir && ./scripts/t8indent.sh $changed_files)
+    (cd $repo_main_dir && ./scripts/indent.sh $changed_files)
     echo done.
   else
     echo Aborted.
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 0d9d630b6d..a9a421db91 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -96,7 +96,7 @@ if( T8CODE_ENABLE_OCC )
     target_link_libraries( T8 PUBLIC ${OpenCASCADE_LIBRARIES} )
     target_sources(T8 PRIVATE
       t8_geometry/t8_geometry_implementations/t8_geometry_cad.cxx
-      t8_cad/t8_cad.cxx
+      t8_cad/t8_cad_handle.cxx
     )
     install( FILES
       t8_geometry/t8_geometry_implementations/t8_geometry_cad.hxx
@@ -104,7 +104,7 @@ if( T8CODE_ENABLE_OCC )
       DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/t8_geometry/t8_geometry_implementations
     )
     install( FILES
-      t8_cad/t8_cad.hxx
+      t8_cad/t8_cad_handle.hxx
       DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/t8_cad
     )
 endif()
@@ -136,36 +136,33 @@ endif()
 
 target_sources( T8 PRIVATE
     t8.c
-    t8_eclass.c
-    t8_element_shape.c
-    t8_element.cxx
-    t8_refcount.c 
-    t8_version.c 
-    t8_vtk.c 
-    t8_cmesh/t8_cmesh.cxx 
-    t8_cmesh/t8_cmesh_cad.cxx 
-    t8_cmesh/t8_cmesh_geometry.cxx 
+    t8_cmesh/t8_cmesh.cxx
+    t8_cmesh/t8_cmesh_cad.cxx
+    t8_cmesh/t8_cmesh_geometry.cxx
     t8_cmesh/t8_cmesh_examples.cxx
     t8_cmesh/t8_cmesh_helpers.cxx
-    t8_cmesh/t8_cmesh_internal/t8_cmesh_commit.cxx 
-    t8_cmesh/t8_cmesh_internal/t8_cmesh_copy.c 
-    t8_cmesh/t8_cmesh_internal/t8_cmesh_offset.c 
-    t8_cmesh/t8_cmesh_internal/t8_cmesh_partition.cxx 
-    t8_cmesh/t8_cmesh_internal/t8_cmesh_stash.c 
-    t8_cmesh/t8_cmesh_internal/t8_cmesh_trees.cxx 
-    t8_cmesh/t8_cmesh_vertex_connectivity/t8_cmesh_vertex_conn_tree_to_vertex.cxx 
-    t8_cmesh/t8_cmesh_vertex_connectivity/t8_cmesh_vertex_conn_vertex_to_tree.cxx 
-    t8_cmesh/t8_cmesh_vertex_connectivity/t8_cmesh_vertex_connectivity.cxx 
+    t8_cmesh/t8_cmesh_internal/t8_cmesh_commit.cxx
+    t8_cmesh/t8_cmesh_internal/t8_cmesh_copy.c
+    t8_cmesh/t8_cmesh_internal/t8_cmesh_offset.c
+    t8_cmesh/t8_cmesh_internal/t8_cmesh_partition.cxx
+    t8_cmesh/t8_cmesh_internal/t8_cmesh_stash.c
+    t8_cmesh/t8_cmesh_internal/t8_cmesh_trees.cxx
+    t8_cmesh/t8_cmesh_vertex_connectivity/t8_cmesh_vertex_conn_tree_to_vertex.cxx
+    t8_cmesh/t8_cmesh_vertex_connectivity/t8_cmesh_vertex_conn_vertex_to_tree.cxx
+    t8_cmesh/t8_cmesh_vertex_connectivity/t8_cmesh_vertex_connectivity.cxx
     t8_cmesh/t8_cmesh_io/t8_cmesh_readmshfile.cxx
-    t8_cmesh/t8_cmesh_io/t8_cmesh_save.cxx 
-    t8_cmesh/t8_cmesh_io/t8_cmesh_triangle.cxx 
-    t8_data/t8_shmem.c 
-    t8_data/t8_containers.cxx 
-    t8_forest/t8_forest_adapt.cxx 
-    t8_forest/t8_forest_partition.cxx 
+    t8_cmesh/t8_cmesh_io/t8_cmesh_save.cxx
+    t8_cmesh/t8_cmesh_io/t8_cmesh_triangle.cxx
+    t8_data/t8_shmem.c
+    t8_data/t8_containers.cxx
+    t8_eclass/t8_eclass.c
+    t8_element/t8_element_shape.c
+    t8_element/t8_element.cxx
+    t8_forest/t8_forest_adapt.cxx
+    t8_forest/t8_forest_partition.cxx
     t8_forest/t8_forest_partition_for_coarsening.cxx
-    t8_forest/t8_forest_pfc_helper.cxx 
-    t8_forest/t8_forest.cxx 
+    t8_forest/t8_forest_pfc_helper.cxx
+    t8_forest/t8_forest.cxx
     t8_forest/t8_forest_private.cxx
     t8_forest/t8_forest_ghost.cxx
     t8_forest/t8_forest_iterate.cxx
@@ -182,6 +179,8 @@ target_sources( T8 PRIVATE
     t8_geometry/t8_geometry_implementations/t8_geometry_lagrange.cxx
     t8_geometry/t8_geometry_implementations/t8_geometry_zero.cxx
     t8_geometry/t8_geometry_implementations/t8_geometry_examples.cxx
+    t8_helper_functions/t8_refcount.c
+    t8_misc/t8_version.c
     t8_schemes/t8_scheme.cxx
     t8_schemes/t8_default/t8_default.cxx
     t8_schemes/t8_default/t8_default_hex/t8_default_hex.cxx
@@ -204,6 +203,7 @@ target_sources( T8 PRIVATE
     t8_schemes/t8_default/t8_default_vertex/t8_default_vertex.cxx
     t8_types/t8_vec.cxx
     t8_schemes/t8_standalone/t8_standalone.cxx
+    t8_vtk/t8_vtk.c
     t8_vtk/t8_vtk_writer.cxx
     t8_vtk/t8_vtk_write_ASCII.cxx
     t8_vtk/t8_vtk_writer_helper.cxx
@@ -229,14 +229,6 @@ target_compile_definitions( T8 PUBLIC T8_LIBS="${T8_LIBS}" )
 
 install( FILES
     t8.h
-    t8_eclass.h
-    t8_element.h
-    t8_element_shape.h
-    t8_mat.h
-    t8_refcount.h
-    t8_version.h
-    t8_vtk.h 
-    t8_with_macro_error.h
     DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} 
 )
 
@@ -247,8 +239,9 @@ install( FILES
 # See https://gitlab.kitware.com/cmake/cmake/-/issues/19189
 
 install( DIRECTORY t8_helper_functions 
-  DESTINATION PRIVATE_HEADER 
+  DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} 
   FILES_MATCHING 
+    PATTERN "*.h" 
     PATTERN "*.hxx" 
 )
 install( DIRECTORY t8_cmesh
@@ -266,6 +259,18 @@ install( DIRECTORY t8_data
     PATTERN "*.h"
     PATTERN "*.hxx"
 )
+install( DIRECTORY t8_eclass 
+  DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} 
+  FILES_MATCHING 
+    PATTERN "*.h"
+    PATTERN "*.hxx"
+)
+install( DIRECTORY t8_element 
+  DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} 
+  FILES_MATCHING 
+    PATTERN "*.h"
+    PATTERN "*.hxx"
+)
 install( DIRECTORY t8_forest
   DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} 
   FILES_MATCHING 
@@ -283,12 +288,24 @@ install( DIRECTORY t8_geometry
     PATTERN "t8_geometry/t8_geometry_implementations/t8_geometry_cad.h" EXCLUDE
     PATTERN "t8_geometry/t8_geometry_implementations/t8_geometry_cad.hxx" EXCLUDE
 )
+install( DIRECTORY t8_misc
+  DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} 
+  FILES_MATCHING 
+    PATTERN "*.h"
+    PATTERN "*.hxx"
+)
 install( DIRECTORY t8_schemes 
   DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} 
   FILES_MATCHING 
     PATTERN "*.h"
     PATTERN "*.hxx" 
 )
+install( DIRECTORY t8_types 
+  DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} 
+  FILES_MATCHING 
+    PATTERN "*.hxx" 
+    PATTERN "*.h"
+)
 install( DIRECTORY t8_vtk 
   DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
   FILES_MATCHING 
@@ -300,12 +317,6 @@ install( DIRECTORY t8_vtk
     PATTERN "t8_vtk/t8_vtk_write_ASCII.hxx"   EXCLUDE
     PATTERN "t8_vtk/t8_vtk_writer_helper.hxx" EXCLUDE
 )
-install( DIRECTORY t8_types 
-  DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} 
-  FILES_MATCHING 
-    PATTERN "*.hxx" 
-    PATTERN "*.h"
-)
 
 install( TARGETS T8
   EXPORT ${PROJECT_NAME}-targets
diff --git a/src/t8.c b/src/t8.c
index f7c091ace7..b409ee974a 100644
--- a/src/t8.c
+++ b/src/t8.c
@@ -25,7 +25,7 @@
  */
 
 #include <t8.h>
-#include <t8_version.h>
+#include <t8_misc/t8_version.h>
 
 static int t8_package_id = -1;
 static void (*external_log_fcn) (int category, int priority, const char *msg) = NULL;
diff --git a/src/t8.h b/src/t8.h
index 80adbff415..6528ce6e13 100644
--- a/src/t8.h
+++ b/src/t8.h
@@ -29,7 +29,7 @@
 #ifndef T8_H
 #define T8_H
 
-#include <t8_with_macro_error.h>
+#include <t8_misc/t8_with_macro_error.h>
 #ifdef __cplusplus
 #include <cinttypes>
 #else
diff --git a/src/t8_cad/t8_cad.cxx b/src/t8_cad/t8_cad_handle.cxx
similarity index 72%
rename from src/t8_cad/t8_cad.cxx
rename to src/t8_cad/t8_cad_handle.cxx
index dc319f08c9..dafa849d7e 100644
--- a/src/t8_cad/t8_cad.cxx
+++ b/src/t8_cad/t8_cad_handle.cxx
@@ -21,7 +21,7 @@
 */
 
 #include <t8.h>
-#include <t8_cad/t8_cad.hxx>
+#include <t8_cad/t8_cad_handle.hxx>
 #include <t8_geometry/t8_geometry_implementations/t8_geometry_cad.hxx>
 #include <TopoDS.hxx>
 #include <BRep_Builder.hxx>
@@ -34,19 +34,23 @@
 #include <Standard_Version.hxx>
 #include <ShapeAnalysis_Edge.hxx>
 #include <TopExp_Explorer.hxx>
+#include <string_view>
 
 #if T8_ENABLE_DEBUG
 #include <Precision.hxx>
 #endif
 
-t8_cad::t8_cad (std::string fileprefix)
+void
+t8_cad_handle::load (const std::string_view fileprefix)
 {
-  BRep_Builder builder;
-  std::ifstream is (fileprefix + ".brep");
+  TopoDS_Shape loaded_cad_shape;
+  BRep_Builder bob;
+  const std::string filename = std::string (fileprefix) + ".brep";
+  std::ifstream is (filename);
   if (is.is_open () == false) {
-    SC_ABORTF ("Cannot find the file %s.brep.\n", fileprefix.c_str ());
+    SC_ABORTF ("Cannot find the file %s.\n", filename.c_str ());
   }
-  BRepTools::Read (cad_shape, is, builder);
+  BRepTools::Read (loaded_cad_shape, is, bob);
   is.close ();
   if (cad_shape.IsNull ()) {
     SC_ABORTF ("Could not read brep file or brep file contains no shape. "
@@ -54,107 +58,150 @@ t8_cad::t8_cad (std::string fileprefix)
                "Linked cad version: %s",
                OCC_VERSION_COMPLETE);
   }
-  TopExp::MapShapes (cad_shape, TopAbs_VERTEX, cad_shape_vertex_map);
-  TopExp::MapShapes (cad_shape, TopAbs_EDGE, cad_shape_edge_map);
-  TopExp::MapShapes (cad_shape, TopAbs_FACE, cad_shape_face_map);
-  TopExp::MapShapesAndUniqueAncestors (cad_shape, TopAbs_VERTEX, TopAbs_EDGE, cad_shape_vertex2edge_map);
-  TopExp::MapShapesAndUniqueAncestors (cad_shape, TopAbs_EDGE, TopAbs_FACE, cad_shape_edge2face_map);
-  TopExp::MapShapesAndUniqueAncestors (cad_shape, TopAbs_VERTEX, TopAbs_FACE, cad_shape_vertex2face_map);
+  this->cad_shape = std::move (loaded_cad_shape);
+  map ();
 }
 
-t8_cad::t8_cad (const TopoDS_Shape cad_shape)
+void
+t8_cad_handle::load (TopoDS_Shape cad_shape_in)
 {
-  if (cad_shape.IsNull ()) {
+  if (cad_shape_in.IsNull ()) {
+    SC_ABORTF ("Shape is null. \n");
+  }
+  this->cad_shape = std::move (cad_shape_in);
+  map ();
+}
+
+void
+t8_cad_handle::map ()
+{
+  if (this->cad_shape.IsNull ()) {
     SC_ABORTF ("Shape is null. \n");
   }
-  TopExp::MapShapes (cad_shape, TopAbs_VERTEX, cad_shape_vertex_map);
-  TopExp::MapShapes (cad_shape, TopAbs_EDGE, cad_shape_edge_map);
-  TopExp::MapShapes (cad_shape, TopAbs_FACE, cad_shape_face_map);
-  TopExp::MapShapesAndUniqueAncestors (cad_shape, TopAbs_VERTEX, TopAbs_EDGE, cad_shape_vertex2edge_map);
-  TopExp::MapShapesAndUniqueAncestors (cad_shape, TopAbs_EDGE, TopAbs_FACE, cad_shape_edge2face_map);
+  /* Clear maps before map the new data. */
+  cad_shape_vertex_map.Clear ();
+  cad_shape_edge_map.Clear ();
+  cad_shape_face_map.Clear ();
+  cad_shape_vertex2edge_map.Clear ();
+  cad_shape_edge2face_map.Clear ();
+  cad_shape_vertex2face_map.Clear ();
+
+  TopExp::MapShapes (this->cad_shape, TopAbs_VERTEX, cad_shape_vertex_map);
+  TopExp::MapShapes (this->cad_shape, TopAbs_EDGE, cad_shape_edge_map);
+  TopExp::MapShapes (this->cad_shape, TopAbs_FACE, cad_shape_face_map);
+  TopExp::MapShapesAndUniqueAncestors (this->cad_shape, TopAbs_VERTEX, TopAbs_EDGE, cad_shape_vertex2edge_map);
+  TopExp::MapShapesAndUniqueAncestors (this->cad_shape, TopAbs_EDGE, TopAbs_FACE, cad_shape_edge2face_map);
+  TopExp::MapShapesAndUniqueAncestors (this->cad_shape, TopAbs_VERTEX, TopAbs_FACE, cad_shape_vertex2face_map);
+}
+
+t8_cad_handle::t8_cad_handle (const std::string_view fileprefix)
+{
+  t8_refcount_init (&rc);
+  t8_debugf ("Constructed the cad_handle from file.\n");
+
+  load (fileprefix);
+}
+
+t8_cad_handle::t8_cad_handle (TopoDS_Shape cad_shape_in)
+{
+  t8_refcount_init (&rc);
+  t8_debugf ("Constructed the cad_handle from shape.\n");
+
+  load (std::move (cad_shape_in));
 }
 
-t8_cad::t8_cad ()
+t8_cad_handle::t8_cad_handle ()
 {
+  t8_refcount_init (&rc);
+  t8_debugf ("Constructed the empty cad_handle.\n");
   cad_shape.Nullify ();
 }
 
+t8_cad_handle::~t8_cad_handle ()
+{
+  if (sc_refcount_is_active (&rc)) {
+    T8_ASSERT (t8_refcount_is_last (&rc));
+    t8_refcount_unref (&rc);
+  }
+  t8_debugf ("Deleted the cad_handle.\n");
+}
+
 int
-t8_cad::t8_geom_is_line (const int curve_index) const
+t8_cad_handle::is_line (const int curve_index) const
 {
-  const Handle_Geom_Curve curve = t8_geom_get_cad_curve (curve_index);
+  const Handle_Geom_Curve curve = get_cad_curve (curve_index);
   const GeomAdaptor_Curve curve_adaptor (curve);
   return curve_adaptor.GetType () == GeomAbs_Line;
 }
 
 int
-t8_cad::t8_geom_is_plane (const int surface_index) const
+t8_cad_handle::is_plane (const int surface_index) const
 {
-  const Handle_Geom_Surface surface = t8_geom_get_cad_surface (surface_index);
+  const Handle_Geom_Surface surface = get_cad_surface (surface_index);
   const GeomAdaptor_Surface surface_adaptor (surface);
   return surface_adaptor.GetType () == GeomAbs_Plane;
 }
 
 const TopoDS_Vertex
-t8_cad::t8_geom_get_cad_vertex (const int index) const
+t8_cad_handle::get_cad_vertex (const int index) const
 {
   T8_ASSERT (index <= cad_shape_vertex_map.Size ());
   return TopoDS::Vertex (cad_shape_vertex_map.FindKey (index));
 }
 
 const TopoDS_Edge
-t8_cad::t8_geom_get_cad_edge (const int index) const
+t8_cad_handle::get_cad_edge (const int index) const
 {
   T8_ASSERT (index <= cad_shape_edge_map.Size ());
   return TopoDS::Edge (cad_shape_edge_map.FindKey (index));
 }
 
 const TopoDS_Face
-t8_cad::t8_geom_get_cad_face (const int index) const
+t8_cad_handle::get_cad_face (const int index) const
 {
   T8_ASSERT (index <= cad_shape_face_map.Size ());
   return TopoDS::Face (cad_shape_face_map.FindKey (index));
 }
 
 const gp_Pnt
-t8_cad::t8_geom_get_cad_point (const int index) const
+t8_cad_handle::get_cad_point (const int index) const
 {
-  return BRep_Tool::Pnt (t8_cad::t8_geom_get_cad_vertex (index));
+  return BRep_Tool::Pnt (get_cad_vertex (index));
 }
 
 const Handle_Geom_Curve
-t8_cad::t8_geom_get_cad_curve (const int index) const
+t8_cad_handle::get_cad_curve (const int index) const
 {
   Standard_Real first, last;
-  return BRep_Tool::Curve (t8_cad::t8_geom_get_cad_edge (index), first, last);
+  return BRep_Tool::Curve (get_cad_edge (index), first, last);
 }
 
 const Handle_Geom_Surface
-t8_cad::t8_geom_get_cad_surface (const int index) const
+t8_cad_handle::get_cad_surface (const int index) const
 {
-  return BRep_Tool::Surface (t8_cad::t8_geom_get_cad_face (index));
+  return BRep_Tool::Surface (get_cad_face (index));
 }
 
 const TopTools_IndexedMapOfShape
-t8_cad::t8_geom_get_cad_shape_vertex_map () const
+t8_cad_handle::get_cad_shape_vertex_map () const
 {
   return cad_shape_vertex_map;
 }
 
 const TopTools_IndexedMapOfShape
-t8_cad::t8_geom_get_cad_shape_edge_map () const
+t8_cad_handle::get_cad_shape_edge_map () const
 {
   return cad_shape_edge_map;
 }
 
 const TopTools_IndexedMapOfShape
-t8_cad::t8_geom_get_cad_shape_face_map () const
+t8_cad_handle::get_cad_shape_face_map () const
 {
   return cad_shape_face_map;
 }
 
 int
-t8_cad::t8_geom_get_common_edge_of_vertices (const int vertex1_index, const int vertex2_index) const
+t8_cad_handle::get_common_edge_of_vertices (const int vertex1_index, const int vertex2_index) const
 {
   T8_ASSERT (vertex1_index <= cad_shape_vertex2edge_map.Size ());
   T8_ASSERT (vertex2_index <= cad_shape_vertex2edge_map.Size ());
@@ -164,7 +211,7 @@ t8_cad::t8_geom_get_common_edge_of_vertices (const int vertex1_index, const int
   for (auto edge1 = collection1.begin (); edge1 != collection1.end (); ++edge1) {
     for (auto edge2 = collection2.begin (); edge2 != collection2.end (); ++edge2) {
       if (edge1->IsEqual (*edge2)) {
-        return cad_shape_edge2face_map.FindIndex (*edge1);
+        return cad_shape_edge_map.FindIndex (*edge1);
       }
     }
   }
@@ -172,7 +219,7 @@ t8_cad::t8_geom_get_common_edge_of_vertices (const int vertex1_index, const int
 }
 
 int
-t8_cad::t8_geom_get_common_face_of_edges (const int edge1_index, const int edge2_index) const
+t8_cad_handle::get_common_face_of_edges (const int edge1_index, const int edge2_index) const
 {
   T8_ASSERT (edge1_index <= cad_shape_edge2face_map.Size ());
   T8_ASSERT (edge2_index <= cad_shape_edge2face_map.Size ());
@@ -190,14 +237,14 @@ t8_cad::t8_geom_get_common_face_of_edges (const int edge1_index, const int edge2
 }
 
 int
-t8_cad::t8_geom_get_common_face_of_vertex_and_edge (const int vertex_index, const int edge_index) const
+t8_cad_handle::get_common_face_of_vertex_and_edge (const int vertex_index, const int edge_index) const
 {
   T8_ASSERT (vertex_index <= cad_shape_vertex_map.Size ());
   T8_ASSERT (edge_index <= cad_shape_edge2face_map.Size ());
   const TopTools_ListOfShape edge_collection = cad_shape_edge2face_map.FindFromIndex (edge_index);
   for (auto face = edge_collection.begin (); face != edge_collection.end (); ++face) {
     const size_t face_index = cad_shape_face_map.FindIndex (*face);
-    if (t8_geom_is_vertex_on_face (vertex_index, face_index)) {
+    if (is_vertex_on_face (vertex_index, face_index)) {
       return face_index;
     }
   }
@@ -205,7 +252,7 @@ t8_cad::t8_geom_get_common_face_of_vertex_and_edge (const int vertex_index, cons
 }
 
 int
-t8_cad::t8_geom_get_common_face_of_vertices (const int vertex1_index, const int vertex2_index) const
+t8_cad_handle::get_common_face_of_vertices (const int vertex1_index, const int vertex2_index) const
 {
   T8_ASSERT (vertex1_index <= cad_shape_vertex2face_map.Size ());
   T8_ASSERT (vertex2_index <= cad_shape_vertex2face_map.Size ());
@@ -221,9 +268,8 @@ t8_cad::t8_geom_get_common_face_of_vertices (const int vertex1_index, const int
   }
   return 0;
 }
-
 int
-t8_cad::t8_geom_is_vertex_on_edge (const int vertex_index, const int edge_index) const
+t8_cad_handle::is_vertex_on_edge (const int vertex_index, const int edge_index) const
 {
   T8_ASSERT (vertex_index <= cad_shape_vertex2edge_map.Size ());
   T8_ASSERT (edge_index <= cad_shape_edge_map.Size ());
@@ -232,7 +278,7 @@ t8_cad::t8_geom_is_vertex_on_edge (const int vertex_index, const int edge_index)
 }
 
 int
-t8_cad::t8_geom_is_edge_on_face (const int edge_index, const int face_index) const
+t8_cad_handle::is_edge_on_face (const int edge_index, const int face_index) const
 {
   T8_ASSERT (edge_index <= cad_shape_edge2face_map.Size ());
   T8_ASSERT (face_index <= cad_shape_face_map.Size ());
@@ -241,27 +287,21 @@ t8_cad::t8_geom_is_edge_on_face (const int edge_index, const int face_index) con
 }
 
 int
-t8_cad::t8_geom_is_vertex_on_face (const int vertex_index, const int face_index) const
+t8_cad_handle::is_vertex_on_face (const int vertex_index, const int face_index) const
 {
-  T8_ASSERT (vertex_index <= cad_shape_vertex2edge_map.Size ());
+  T8_ASSERT (vertex_index <= cad_shape_vertex2face_map.Size ());
   T8_ASSERT (face_index <= cad_shape_face_map.Size ());
-  const TopTools_ListOfShape edge_collection = cad_shape_vertex2edge_map.FindFromIndex (vertex_index);
-  for (auto edge = edge_collection.begin (); edge != edge_collection.end (); ++edge) {
-    const TopTools_ListOfShape face_collection = cad_shape_edge2face_map.FindFromKey (*edge);
-    if (face_collection.Contains (cad_shape_face_map.FindKey (face_index))) {
-      return 1;
-    }
-  }
-  return 0;
+  const TopTools_ListOfShape collection = cad_shape_vertex2face_map.FindFromIndex (vertex_index);
+  return collection.Contains (cad_shape_face_map.FindKey (face_index));
 }
 
 bool
-t8_cad::t8_geom_vertex_is_seam (const int vertex_index, const int edge_index) const
+t8_cad_handle::vertex_is_seam (const int vertex_index, const int edge_index) const
 {
   T8_ASSERT (vertex_index <= cad_shape_vertex_map.Size ());
   T8_ASSERT (edge_index <= cad_shape_edge_map.Size ());
-  const auto vertex = t8_cad::t8_geom_get_cad_vertex (vertex_index);
-  const auto edge = t8_cad::t8_geom_get_cad_edge (edge_index);
+  const auto vertex = get_cad_vertex (vertex_index);
+  const auto edge = get_cad_edge (edge_index);
   double u = BRep_Tool::Parameter (vertex, edge);
   double first = 0, last = 0;
   const auto curve = BRep_Tool::Curve (edge, first, last);
@@ -280,11 +320,11 @@ t8_cad::t8_geom_vertex_is_seam (const int vertex_index, const int edge_index) co
 }
 
 bool
-t8_cad::t8_geom_vertex_is_on_seam_edge (const int vertex_index, const int face_index) const
+t8_cad_handle::vertex_is_on_seam_edge (const int vertex_index, const int face_index) const
 {
   T8_ASSERT (vertex_index <= cad_shape_vertex2edge_map.Size ());
   T8_ASSERT (face_index <= cad_shape_face_map.Size ());
-  const auto face = t8_cad::t8_geom_get_cad_face (face_index);
+  const auto face = get_cad_face (face_index);
   const TopTools_ListOfShape edge_collection = cad_shape_vertex2edge_map.FindFromIndex (vertex_index);
   const ShapeAnalysis_Edge edge_analyzer;
   for (auto edge = edge_collection.begin (); edge != edge_collection.end (); ++edge) {
@@ -295,21 +335,21 @@ t8_cad::t8_geom_vertex_is_on_seam_edge (const int vertex_index, const int face_i
 }
 
 bool
-t8_cad::t8_geom_edge_is_seam (const int edge_index, const int face_index) const
+t8_cad_handle::edge_is_seam (const int edge_index, const int face_index) const
 {
   T8_ASSERT (edge_index <= cad_shape_edge_map.Size ());
   T8_ASSERT (face_index <= cad_shape_face_map.Size ());
-  const auto face = t8_cad::t8_geom_get_cad_face (face_index);
-  const auto edge = t8_cad::t8_geom_get_cad_edge (edge_index);
+  const auto face = get_cad_face (face_index);
+  const auto edge = get_cad_edge (edge_index);
   const ShapeAnalysis_Edge edge_analyzer;
   return edge_analyzer.IsSeam (edge, face);
 }
 
 void
-t8_cad::t8_geom_get_parameter_of_vertex_on_edge (const int vertex_index, const int edge_index, double *edge_param,
-                                                 std::optional<double> reference_edge_param) const
+t8_cad_handle::get_parameter_of_vertex_on_edge (const int vertex_index, const int edge_index, double *edge_param,
+                                                std::optional<double> reference_edge_param) const
 {
-  T8_ASSERT (t8_cad::t8_geom_is_vertex_on_edge (vertex_index, edge_index));
+  T8_ASSERT (is_vertex_on_edge (vertex_index, edge_index));
   TopoDS_Vertex vertex = TopoDS::Vertex (cad_shape_vertex_map.FindKey (vertex_index));
   TopoDS_Edge edge = TopoDS::Edge (cad_shape_edge_map.FindKey (edge_index));
 
@@ -317,8 +357,8 @@ t8_cad::t8_geom_get_parameter_of_vertex_on_edge (const int vertex_index, const i
   the parameter of the vertex on the edge. But if the edge is closed and the user provided
   said reference parameters it gets more sophisticated:*/
 
-  const bool edge_is_closed = t8_cad::t8_geom_edge_is_closed (edge_index);
-  if (reference_edge_param.has_value () && edge_is_closed) {
+  const bool is_closed = edge_is_closed (edge_index);
+  if (reference_edge_param.has_value () && is_closed) {
     /* Edge is closed and the user provided reference parameters. We iterate over all vertices of the edge.
     Since the edge is closed, the start and end vertex should be in the same physical location.
     We choose the point where the parameters are closer to the reference parameters. For debugging reasons
@@ -353,8 +393,8 @@ t8_cad::t8_geom_get_parameter_of_vertex_on_edge (const int vertex_index, const i
 }
 
 void
-t8_cad::t8_geom_get_parameters_of_vertex_on_face (const int vertex_index, const int face_index, double face_params[2],
-                                                  std::optional<std::span<const double, 2>> reference_face_params) const
+t8_cad_handle::get_parameters_of_vertex_on_face (const int vertex_index, const int face_index, double face_params[2],
+                                                 std::optional<std::span<const double, 2>> reference_face_params) const
 {
   /* DISCLAIMER: This function is overly complicated and I do not understand why the simpler versions do not work.
   The overly complicated part is only the edge case where the vertex lies on a seam and reference parameters are provided.
@@ -367,19 +407,19 @@ t8_cad::t8_geom_get_parameters_of_vertex_on_face (const int vertex_index, const
   And thats why this algorithm does not work. What you see here is the more complicated workaround:
   */
 
-  T8_ASSERT (t8_cad::t8_geom_is_vertex_on_face (vertex_index, face_index));
+  T8_ASSERT (is_vertex_on_face (vertex_index, face_index));
   std::optional<gp_Pnt2d> uv = std::nullopt; /** Final parameters on the surface */
   TopoDS_Vertex vertex = TopoDS::Vertex (cad_shape_vertex_map.FindKey (vertex_index));
   TopoDS_Face face = TopoDS::Face (cad_shape_face_map.FindKey (face_index));
 
   /* If the surface is not closed or the user did not provide any reference params we just query the parameters. */
-  if (!t8_cad::t8_geom_surface_is_closed (face_index) || !reference_face_params.has_value ()) {
+  if (!surface_is_closed (face_index) || !reference_face_params.has_value ()) {
     uv.emplace (BRep_Tool::Parameters (vertex, face));
   }
 
   /* If the vertex is not on the seam we can also just query the parameters. */
   else {
-    const bool is_on_seam = t8_cad::t8_geom_vertex_is_on_seam_edge (vertex_index, face_index);
+    const bool is_on_seam = vertex_is_on_seam_edge (vertex_index, face_index);
     if (!is_on_seam) {
       uv.emplace (BRep_Tool::Parameters (vertex, face));
     }
@@ -450,17 +490,17 @@ t8_cad::t8_geom_get_parameters_of_vertex_on_face (const int vertex_index, const
 }
 
 void
-t8_cad::t8_geom_edge_parameter_to_face_parameters (
-  const int edge_index, const int face_index, const double edge_param, double face_params_out[2],
-  std::optional<std::span<const double, 2>> reference_face_params) const
+t8_cad_handle::edge_parameter_to_face_parameters (const int edge_index, const int face_index, const double edge_param,
+                                                  double face_params_out[2],
+                                                  std::optional<std::span<const double, 2>> reference_face_params) const
 {
-  T8_ASSERT (t8_cad::t8_geom_is_edge_on_face (edge_index, face_index));
+  T8_ASSERT (is_edge_on_face (edge_index, face_index));
   Standard_Real first, last;
   std::optional<gp_Pnt2d> uv = std::nullopt;
   TopoDS_Face face = TopoDS::Face (cad_shape_face_map.FindKey (face_index));
   TopoDS_Edge edge = TopoDS::Edge (cad_shape_edge_map.FindKey (edge_index));
 
-  const bool is_seam = t8_cad::t8_geom_edge_is_seam (edge_index, face_index);
+  const bool is_seam = edge_is_seam (edge_index, face_index);
   if (is_seam && reference_face_params.has_value ()) {
     /* Convert reference parameters to OCCT point */
     gp_Pnt2d reference_point (reference_face_params.value ()[0], reference_face_params.value ()[1]);
@@ -504,38 +544,38 @@ t8_cad::t8_geom_edge_parameter_to_face_parameters (
 }
 
 void
-t8_cad::t8_geom_get_face_parametric_bounds (const int surface_index, double *bounds) const
+t8_cad_handle::get_face_parametric_bounds (const int surface_index, double *bounds) const
 {
-  const Handle_Geom_Surface cad_surface = t8_geom_get_cad_surface (surface_index);
+  const Handle_Geom_Surface cad_surface = get_cad_surface (surface_index);
   cad_surface->Bounds (bounds[0], bounds[1], bounds[2], bounds[3]);
 }
 
 void
-t8_cad::t8_geom_get_edge_parametric_bounds (const int edge_index, double *bounds) const
+t8_cad_handle::get_edge_parametric_bounds (const int edge_index, double *bounds) const
 {
-  const Handle_Geom_Curve cad_edge = t8_geom_get_cad_curve (edge_index);
+  const Handle_Geom_Curve cad_edge = get_cad_curve (edge_index);
   bounds[0] = cad_edge->FirstParameter ();
   bounds[1] = cad_edge->LastParameter ();
 }
 
-bool
-t8_cad::t8_geom_edge_is_closed (int edge_index) const
+int
+t8_cad_handle::edge_is_closed (int edge_index) const
 {
-  const Handle_Geom_Curve cad_edge = t8_geom_get_cad_curve (edge_index);
+  const Handle_Geom_Curve cad_edge = get_cad_curve (edge_index);
   return cad_edge->IsClosed ();
 }
 
 bool
-t8_cad::t8_geom_surface_is_closed (int geometry_index) const
+t8_cad_handle::surface_is_closed (int geometry_index) const
 {
-  const Handle_Geom_Surface cad_surface = t8_geom_get_cad_surface (geometry_index);
+  const Handle_Geom_Surface cad_surface = get_cad_surface (geometry_index);
   return cad_surface->IsUClosed () || cad_surface->IsVClosed ();
 }
 
 bool
-t8_cad::t8_geom_surface_is_closed (int geometry_index, int direction) const
+t8_cad_handle::surface_is_closed (int geometry_index, int direction) const
 {
-  const Handle_Geom_Surface cad_surface = t8_geom_get_cad_surface (geometry_index);
+  const Handle_Geom_Surface cad_surface = get_cad_surface (geometry_index);
   switch (direction) {
   case 0:
     return cad_surface->IsUClosed ();
diff --git a/src/t8_cad/t8_cad.hxx b/src/t8_cad/t8_cad_handle.hxx
similarity index 74%
rename from src/t8_cad/t8_cad.hxx
rename to src/t8_cad/t8_cad_handle.hxx
index 8dea025717..ec7c3c3809 100644
--- a/src/t8_cad/t8_cad.hxx
+++ b/src/t8_cad/t8_cad_handle.hxx
@@ -20,13 +20,13 @@
   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */
 
-/** \file t8_cad.hxx
- * This file implements the t8_cad class. It manages OpenCASCADE shapes and implements
+/** \file t8_cad_handle.hxx
+ * This file implements the t8_cad_handle class. It manages OpenCASCADE shapes and implements
  * helper functions for working with the shapes.
  */
 
-#ifndef T8_CAD_HXX
-#define T8_CAD_HXX
+#ifndef T8_CAD_HANDLE_HXX
+#define T8_CAD_HANDLE_HXX
 
 #include <gp_Pnt.hxx>
 #include <TopExp.hxx>
@@ -37,15 +37,15 @@
 #include <TopoDS_Vertex.hxx>
 #include <optional>
 #include <span>
-
+#include <string_view>
+#include <t8_cmesh/t8_cmesh.h>
 /**
  * This class manages OpenCASCADE shapes and implements helper functions for working with the shapes.
 */
-struct t8_cad
-{
+class t8_cad_handle {
  public:
   /**
-    * Constructor of the cad shape.
+    * Constructor of the cad shape handle.
     * The shape is initialized based on a .brep file with the given prefix.
     * The internal structure extracts and stores geometric information such as
     * vertices, edges, and faces from this file. The number and type of vertices
@@ -54,8 +54,7 @@ struct t8_cad
     *
     * \param [in] fileprefix  Prefix of a .brep file from which to extract cad geometry.
     */
-  t8_cad (std::string fileprefix);
-
+  t8_cad_handle (const std::string_view fileprefix);
   /**
     * Constructor of the cad shape.
     * The shape is initialized directly from an existing TopoDS_Shape.
@@ -63,88 +62,107 @@ struct t8_cad
     * or integration with mesh generators that already provide geometry in memory.
     * It avoids file I/O and allows full control over the CAD input.
     *
-    * \param [in] cad_shape  cad shape geometry object.
+    * \param [in] cad_shape_in  cad shape geometry object.
     */
-  t8_cad (const TopoDS_Shape cad_shape);
+  t8_cad_handle (TopoDS_Shape cad_shape_in);
 
   /**
    * Constructor of the cad shape for testing purposes. Sets an invalid cad_shape.
    */
-  t8_cad ();
+  t8_cad_handle ();
+
+  /**
+ * Destructor of the cad shape handle.
+ */
+  ~t8_cad_handle ();
+
+  /**
+   * Loads a cad shape from a .brep file with the given prefix and maps it.
+   * \param [in] fileprefix  Prefix of a .brep file from which to extract cad geometry.
+   */
+  void
+  load (const std::string_view fileprefix);
+
+  /**
+   * Loads a cad shape from an existing TopoDS_Shape and maps it.
+   * \param [in] cad_shape_in  The input cad shape.
+   */
+  void
+  load (TopoDS_Shape cad_shape_in);
 
   /** Check if a cad_curve is a line.
    * \param [in] curve_index      The index of the cad_curve.
    * \return                      1 if curve is a line, 0 if curve is not a line.
    */
   int
-  t8_geom_is_line (const int curve_index) const;
+  is_line (const int curve_index) const;
 
   /** Check if a cad_surface is a plane.
    * \param [in] surface_index      The index of the cad_surface.
    * \return                        1 if surface is a plane linear, 0 if surface is not a plane.
    */
   int
-  t8_geom_is_plane (const int surface_index) const;
+  is_plane (const int surface_index) const;
 
   /** Get a cad vertex from the cad_shape.
    * \param [in] index      The index of the vertex in the cad_shape.
    * \return                The cad vertex.
    */
   const TopoDS_Vertex
-  t8_geom_get_cad_vertex (const int index) const;
+  get_cad_vertex (const int index) const;
 
   /** Get a cad edge from the cad_shape.
    * \param [in] index      The index of the edge in the cad_shape.
    * \return                The cad edge.
    */
   const TopoDS_Edge
-  t8_geom_get_cad_edge (const int index) const;
+  get_cad_edge (const int index) const;
 
   /** Get a cad face from the cad_shape.
    * \param [in] index      The index of the face in the cad_shape.
    * \return                The cad face.
    */
   const TopoDS_Face
-  t8_geom_get_cad_face (const int index) const;
+  get_cad_face (const int index) const;
 
   /** Get a cad point from the cad_shape.
    * \param [in] index      The index of the point in the cad_shape.
    * \return                The cad point.
    */
   const gp_Pnt
-  t8_geom_get_cad_point (const int index) const;
+  get_cad_point (const int index) const;
 
   /** Get a cad curve from the cad_shape.
    * \param [in] index      The index of the curve in the cad_shape.
    * \return                The cad curve.
    */
   const Handle_Geom_Curve
-  t8_geom_get_cad_curve (const int index) const;
+  get_cad_curve (const int index) const;
 
   /** Get a cad surface from the cad_shape.
    * \param [in] index      The index of the surface in the cad_shape.
    * \return                The cad surface.
    */
   const Handle_Geom_Surface
-  t8_geom_get_cad_surface (const int index) const;
+  get_cad_surface (const int index) const;
 
   /** Get the cad_shape_vertex2edge_map.
    * \return                The cad_shape_vertex_map.
    */
   const TopTools_IndexedMapOfShape
-  t8_geom_get_cad_shape_vertex_map () const;
+  get_cad_shape_vertex_map () const;
 
   /** Get the cad_shape_edge2face_map.
    * \return                The cad_shape_edge_map.
    */
   const TopTools_IndexedMapOfShape
-  t8_geom_get_cad_shape_edge_map () const;
+  get_cad_shape_edge_map () const;
 
   /** Get the cad_shape_face_map.
    * \return                The cad_shape_face_map.
    */
   const TopTools_IndexedMapOfShape
-  t8_geom_get_cad_shape_face_map () const;
+  get_cad_shape_face_map () const;
 
   /** Check if two cad points share a common cad edge.
    * \param [in]  vertex1_index  The index of the first cad point.
@@ -152,7 +170,7 @@ struct t8_cad
    * \return                    Index of the shared edge. 0 if there is no shared edge.
    */
   int
-  t8_geom_get_common_edge_of_vertices (const int vertex1_index, const int vertex2_index) const;
+  get_common_edge_of_vertices (const int vertex1_index, const int vertex2_index) const;
 
   /** Check if two cad edges share a common cad face.
    * \param [in]  edge1_index    The index of the first cad edge.
@@ -160,7 +178,8 @@ struct t8_cad
    * \return                    Index of the shared face. 0 if there is no shared face.
    */
   int
-  t8_geom_get_common_face_of_edges (const int edge1_index, const int edge2_index) const;
+
+  get_common_face_of_edges (const int edge1_index, const int edge2_index) const;
 
   /** Check if a cad vertex and cad edge share a common face.
    * \param [in]  vertex_index   The index of the cad vertex.
@@ -168,7 +187,7 @@ struct t8_cad
    * \return                     Index of the shared face. 0 if there is no shared face.
    */
   int
-  t8_geom_get_common_face_of_vertex_and_edge (const int vertex_index, const int edge_index) const;
+  get_common_face_of_vertex_and_edge (const int vertex_index, const int edge_index) const;
 
   /** Check if two cad vertices share a common cad face.
    * \param [in]  vertex1_index The index of the first cad edge.
@@ -176,7 +195,7 @@ struct t8_cad
    * \return                    Index of the shared face. 0 if there is no shared face.
    */
   int
-  t8_geom_get_common_face_of_vertices (const int vertex1_index, const int vertex2_index) const;
+  get_common_face_of_vertices (const int vertex1_index, const int vertex2_index) const;
 
   /** Check if a cad vertex lies on an cad edge.
    * \param [in]  vertex_index   The index of the cad vertex.
@@ -184,7 +203,7 @@ struct t8_cad
    * \return                    1 if vertex lies on edge, otherwise 0.
    */
   int
-  t8_geom_is_vertex_on_edge (const int vertex_index, const int edge_index) const;
+  is_vertex_on_edge (const int vertex_index, const int edge_index) const;
 
   /** Check if a cad vertex lies on an cad edge.
    * \param [in]  edge_index     The index of the cad vertex.
@@ -192,7 +211,7 @@ struct t8_cad
    * \return                    1 if vertex lies on edge, otherwise 0.
    */
   int
-  t8_geom_is_edge_on_face (const int edge_index, const int face_index) const;
+  is_edge_on_face (const int edge_index, const int face_index) const;
 
   /** Check if a cad vertex lies on an cad face.
    * \param [in]  vertex_index   The index of the cad vertex.
@@ -200,7 +219,7 @@ struct t8_cad
    * \return                    1 if vertex lies on face, otherwise 0.
    */
   int
-  t8_geom_is_vertex_on_face (const int vertex_index, const int face_index) const;
+  is_vertex_on_face (const int vertex_index, const int face_index) const;
 
   /** Returns true if \a vertex_index is on a seam of \a edge_index.
    * A seam is a vertex which connects a curve to itself.
@@ -210,7 +229,7 @@ struct t8_cad
    * \return true if the vertex is a seam. false otherwise.
    */
   bool
-  t8_geom_vertex_is_seam (const int vertex_index, const int edge_index) const;
+  vertex_is_seam (const int vertex_index, const int edge_index) const;
 
   /** Returns true if \a vertex_index is on a seam of \a face_index.
    * A seam is an edge which connects a surface to itself.
@@ -220,7 +239,7 @@ struct t8_cad
    * \return true if the edge is a seam. false otherwise.
    */
   bool
-  t8_geom_vertex_is_on_seam_edge (const int vertex_index, const int face_index) const;
+  vertex_is_on_seam_edge (const int vertex_index, const int face_index) const;
 
   /** Returns true if \a edge_index is a seam of \a face_index.
    * A seam is an edge which connects a surface to itself.
@@ -230,7 +249,7 @@ struct t8_cad
    * \return true if the edge is a seam. false otherwise.
    */
   bool
-  t8_geom_edge_is_seam (const int edge_index, const int face_index) const;
+  edge_is_seam (const int edge_index, const int face_index) const;
 
   /** Retrieves the parameter of an cad vertex on an cad edge.
    * The vertex has to lie on the edge.
@@ -244,8 +263,8 @@ struct t8_cad
    * \param [in]  reference_edge_param    Reference parameters on the edge.
    */
   void
-  t8_geom_get_parameter_of_vertex_on_edge (const int vertex_index, const int edge_index, double *edge_param,
-                                           std::optional<double> reference_edge_param = std::nullopt) const;
+  get_parameter_of_vertex_on_edge (const int vertex_index, const int edge_index, double *edge_param,
+                                   std::optional<double> reference_edge_param = std::nullopt) const;
 
   /** Retrieves the parameters of an cad vertex on a cad face.
    * The vertex has to lie on the face.
@@ -260,9 +279,9 @@ struct t8_cad
    * \param [in]  reference_face_params     Reference parameters on the surface.
    */
   void
-  t8_geom_get_parameters_of_vertex_on_face (const int vertex_index, const int face_index, double face_params[2],
-                                            std::optional<std::span<const double, 2>> reference_face_params
-                                            = std::nullopt) const;
+  get_parameters_of_vertex_on_face (const int vertex_index, const int face_index, double face_params[2],
+                                    std::optional<std::span<const double, 2> > reference_face_params
+                                    = std::nullopt) const;
 
   /** Converts the parameters of a cad edge to the corresponding parameters on a cad face.
    * The edge has to lie on the face.
@@ -278,38 +297,61 @@ struct t8_cad
    * \param [in]  reference_face_params     Reference parameters on the surface.
    */
   void
-  t8_geom_edge_parameter_to_face_parameters (const int edge_index, const int face_index, const double edge_param,
-                                             double face_params_out[2],
-                                             std::optional<std::span<const double, 2>> reference_face_params
-                                             = std::nullopt) const;
+  edge_parameter_to_face_parameters (const int edge_index, const int face_index, const double edge_param,
+                                     double face_params_out[2],
+                                     std::optional<std::span<const double, 2> > reference_face_params
+                                     = std::nullopt) const;
 
   /** Finds the parametric bounds of an cad face.
    * \param [in]  surface_index   The index of the cad face.
    * \param [out] bounds          The parametric bounds of the cad face.
    */
   void
-  t8_geom_get_face_parametric_bounds (const int surface_index, double *bounds) const;
+  get_face_parametric_bounds (const int surface_index, double *bounds) const;
 
   /** Finds the parametric bounds of an cad edge.
    * \param [in]  edge_index   The index of the cad edge.
    * \param [out] bounds       The parametric bounds of the cad edge.
    */
   void
-  t8_geom_get_edge_parametric_bounds (const int edge_index, double *bounds) const;
+  get_edge_parametric_bounds (const int edge_index, double *bounds) const;
 
   /** Checks if an edge is closed.
    * \param [in]  edge_index   The index of the closed edge.
    * \return                   true if edge is closed
    */
-  bool
-  t8_geom_edge_is_closed (int edge_index) const;
+  int
+  edge_is_closed (int edge_index) const;
+
+  /**
+   * Increase the reference count of the cad handle.
+   */
+  inline void
+  ref ()
+  {
+    t8_refcount_ref (&rc);
+  }
+
+  /**
+   * Decrease the reference count of the cad handle.
+   * If the reference count reaches zero, the cad handle is deleted.
+   */
+  inline void
+  unref ()
+  {
+    if (t8_refcount_unref (&rc)) {
+      t8_debugf ("Deleting the cad_handle.\n");
+      delete this;
+    }
+  }
 
   /** Checks if a surface is closed in any direction.
    * \param [in]  geometry_index   The index of the closed geometry.
    * \return                       true if geometry is closed in any direction.
    */
+
   bool
-  t8_geom_surface_is_closed (int geometry_index) const;
+  surface_is_closed (int geometry_index) const;
 
   /** Checks if a surface is closed in its U direction or V direction.
    * \param [in]  geometry_index   The index of the closed geometry.
@@ -318,9 +360,15 @@ struct t8_cad
    * \return                       true if geometry is closed in the given direction.
    */
   bool
-  t8_geom_surface_is_closed (int geometry_index, int direction) const;
+  surface_is_closed (int geometry_index, int direction) const;
 
  private:
+  /**
+   * Map the cad shape to extract vertices, edges, faces, and their relationships.
+   */
+  void
+  map ();
+
   TopoDS_Shape cad_shape;                          /**< cad geometry */
   TopTools_IndexedMapOfShape cad_shape_vertex_map; /**< Map of all TopoDS_Vertex. */
   TopTools_IndexedMapOfShape cad_shape_edge_map;   /**< Map of all TopoDS_Edge. */
@@ -331,6 +379,8 @@ struct t8_cad
     cad_shape_edge2face_map; /**< Maps all TopoDS_Edge to all its connected TopoDS_Face */
   TopTools_IndexedDataMapOfShapeListOfShape
     cad_shape_vertex2face_map; /**< Maps all TopoDS_Vertex to all its connected TopoDS_Face */
+  /** The reference count of the cad handle. TODO: Replace by shared_ptr when cmesh becomes a class. */
+  t8_refcount_t rc;
 };
 
-#endif /* !T8_CAD_HXX */
+#endif /* !T8_CAD_HANDLE_HXX */
diff --git a/src/t8_cmesh/t8_cmesh.cxx b/src/t8_cmesh/t8_cmesh.cxx
index f81db4907a..2d55efd120 100644
--- a/src/t8_cmesh/t8_cmesh.cxx
+++ b/src/t8_cmesh/t8_cmesh.cxx
@@ -28,10 +28,10 @@
 #include <t8_geometry/t8_geometry_implementations/t8_geometry_linear.h>
 #include <t8_geometry/t8_geometry_implementations/t8_geometry_linear_axis_aligned.h>
 #include <t8_schemes/t8_scheme.hxx>
-#include <t8_refcount.h>
+#include <t8_helper_functions/t8_refcount.h>
 #include <t8_data/t8_shmem.h>
 #include <t8_types/t8_vec.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <t8_cmesh/t8_cmesh_internal/t8_cmesh_types.h>
 #include <t8_helper_functions/t8_vector_algorithms.hxx>
 #include <t8_cmesh/t8_cmesh.hxx>
@@ -41,7 +41,7 @@
 #endif
 #include <t8_cmesh/t8_cmesh_internal/t8_cmesh_trees.h>
 
-#include <t8_element.h>
+#include <t8_element/t8_element.h>
 
 /** \file t8_cmesh.cxx
  *  This file collects all general cmesh routines that need c++ compilation.
diff --git a/src/t8_cmesh/t8_cmesh.h b/src/t8_cmesh/t8_cmesh.h
index 6b5725010e..d012465056 100644
--- a/src/t8_cmesh/t8_cmesh.h
+++ b/src/t8_cmesh/t8_cmesh.h
@@ -30,7 +30,7 @@
 #include <t8.h>
 #include <t8_data/t8_shmem.h>
 #include <t8_cmesh/t8_cmesh_io/t8_cmesh_save.h>
-#include <t8_element.h>
+#include <t8_element/t8_element.h>
 #include <t8_schemes/t8_scheme.h>
 
 /** Forward pointer reference to hidden cmesh implementation.
@@ -47,7 +47,7 @@ typedef struct t8_cmesh *t8_cmesh_t;
  *       Actually, we need eclass in the type definition in cmesh.c.
  *       So we might as well use tree-related virtual functions there too.
  */
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 
 /* TODO: make it legal to call cmesh_set functions multiple times,
  *       just overwrite the previous setting if no inconsistency can occur.
diff --git a/src/t8_cmesh/t8_cmesh_examples.cxx b/src/t8_cmesh/t8_cmesh_examples.cxx
index 738ab04d0e..276fb6ff3a 100644
--- a/src/t8_cmesh/t8_cmesh_examples.cxx
+++ b/src/t8_cmesh/t8_cmesh_examples.cxx
@@ -31,8 +31,8 @@
 #include <t8_geometry/t8_geometry_implementations/t8_geometry_examples.hxx>
 #include <t8_geometry/t8_geometry_implementations/t8_geometry_zero.hxx>
 #include <t8_types/t8_vec.h>
-#include <t8_mat.h>
-#include <t8_eclass.h>
+#include <t8_helper_functions/t8_mat.h>
+#include <t8_eclass/t8_eclass.h>
 #include <t8_forest/t8_forest_general.h>
 #include <t8_forest/t8_forest_geometrical.h>
 #include <t8_schemes/t8_default/t8_default_c_interface.h> /* default refinement scheme. */
diff --git a/src/t8_cmesh/t8_cmesh_helpers.cxx b/src/t8_cmesh/t8_cmesh_helpers.cxx
index 17e7c2411c..495b740a65 100644
--- a/src/t8_cmesh/t8_cmesh_helpers.cxx
+++ b/src/t8_cmesh/t8_cmesh_helpers.cxx
@@ -27,7 +27,7 @@
 
 #include <t8.h>
 #include <t8_cmesh/t8_cmesh.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <t8_cmesh/t8_cmesh_internal/t8_cmesh_types.h>
 #include <t8_cmesh/t8_cmesh_internal/t8_cmesh_stash.h>
 #include <t8_cmesh/t8_cmesh_helpers.h>
diff --git a/src/t8_cmesh/t8_cmesh_helpers.h b/src/t8_cmesh/t8_cmesh_helpers.h
index 4e129c7f97..37dbc2783b 100644
--- a/src/t8_cmesh/t8_cmesh_helpers.h
+++ b/src/t8_cmesh/t8_cmesh_helpers.h
@@ -30,7 +30,7 @@
 
 #include <t8.h>
 #include <t8_cmesh/t8_cmesh.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 
 T8_EXTERN_C_BEGIN ();
 
diff --git a/src/t8_cmesh/t8_cmesh_internal/t8_cmesh_partition.cxx b/src/t8_cmesh/t8_cmesh_internal/t8_cmesh_partition.cxx
index 4c93390693..f7a272d98c 100644
--- a/src/t8_cmesh/t8_cmesh_internal/t8_cmesh_partition.cxx
+++ b/src/t8_cmesh/t8_cmesh_internal/t8_cmesh_partition.cxx
@@ -28,7 +28,7 @@
 
 #include <t8_data/t8_shmem.h>
 #include <t8_cmesh/t8_cmesh.h>
-#include <t8_element.h>
+#include <t8_element/t8_element.h>
 #include <t8_cmesh/t8_cmesh_internal/t8_cmesh_types.h>
 #include <t8_cmesh/t8_cmesh_internal/t8_cmesh_trees.h>
 #include <t8_cmesh/t8_cmesh_internal/t8_cmesh_partition.h>
diff --git a/src/t8_cmesh/t8_cmesh_internal/t8_cmesh_stash.c b/src/t8_cmesh/t8_cmesh_internal/t8_cmesh_stash.c
index 9f1275a18d..9cd9a8a535 100644
--- a/src/t8_cmesh/t8_cmesh_internal/t8_cmesh_stash.c
+++ b/src/t8_cmesh/t8_cmesh_internal/t8_cmesh_stash.c
@@ -25,7 +25,7 @@
  */
 
 #include <t8.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <t8_cmesh/t8_cmesh_internal/t8_cmesh_stash.h>
 
 void
diff --git a/src/t8_cmesh/t8_cmesh_internal/t8_cmesh_stash.h b/src/t8_cmesh/t8_cmesh_internal/t8_cmesh_stash.h
index 5838b246b7..f3883244c6 100644
--- a/src/t8_cmesh/t8_cmesh_internal/t8_cmesh_stash.h
+++ b/src/t8_cmesh/t8_cmesh_internal/t8_cmesh_stash.h
@@ -28,7 +28,7 @@
 #define T8_CMESH_STASH_H
 
 #include <t8.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 
 /**
  * Opaque pointer to a stash data structure.
diff --git a/src/t8_cmesh/t8_cmesh_internal/t8_cmesh_types.h b/src/t8_cmesh/t8_cmesh_internal/t8_cmesh_types.h
index 701cb9c5a3..b7e47b1c41 100644
--- a/src/t8_cmesh/t8_cmesh_internal/t8_cmesh_types.h
+++ b/src/t8_cmesh/t8_cmesh_internal/t8_cmesh_types.h
@@ -28,12 +28,12 @@
 #define T8_CMESH_TYPES_H
 
 #include <t8.h>
-#include <t8_refcount.h>
+#include <t8_helper_functions/t8_refcount.h>
 #include <t8_data/t8_shmem.h>
 #include <t8_geometry/t8_geometry.h>
 #include <t8_cmesh/t8_cmesh_vertex_connectivity/t8_cmesh_vertex_connectivity.h>
 #include <t8_cmesh/t8_cmesh_internal/t8_cmesh_stash.h>
-#include "t8_element.h"
+#include <t8_element/t8_element.h>
 
 /** Opaque pointer to a t8_part_tree */
 typedef struct t8_part_tree *t8_part_tree_t;
diff --git a/src/t8_cmesh/t8_cmesh_io/t8_cmesh_readmshfile.cxx b/src/t8_cmesh/t8_cmesh_io/t8_cmesh_readmshfile.cxx
index aaa39c5e92..a1cd883e9a 100644
--- a/src/t8_cmesh/t8_cmesh_io/t8_cmesh_readmshfile.cxx
+++ b/src/t8_cmesh/t8_cmesh_io/t8_cmesh_readmshfile.cxx
@@ -24,7 +24,7 @@
  * Implements functions declared in \ref t8_cmesh_readmshfile.h.
  */
 
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <t8_cmesh/t8_cmesh_io/t8_cmesh_readmshfile.h>
 #include <t8_cmesh/t8_cmesh.hxx>
 #include <t8_geometry/t8_geometry_implementations/t8_geometry_linear.hxx>
@@ -40,7 +40,7 @@
 #include <array>
 
 #ifdef _WIN32
-#include "t8_windows.h"
+#include <t8_misc/t8_windows.h>
 #endif
 
 /** The supported number of gmsh tree classes.
@@ -717,8 +717,8 @@ t8_cmesh_process_tree_geometry (const t8_cmesh_t cmesh, const t8_eclass_t eclass
 
           /* If both nodes are on a vertex we look if both vertices share an edge */
           if (node1.entity_dim == 0 && node2.entity_dim == 0) {
-            int common_edge = cad_geometry->get_cad_manager ()->t8_geom_get_common_edge_of_vertices (node1.entity_tag,
-                                                                                                     node2.entity_tag);
+            int common_edge
+              = cad_geometry->get_cad_handle ()->get_common_edge_of_vertices (node1.entity_tag, node2.entity_tag);
             if (common_edge > 0) {
               if (edge1_index == 0) {
                 edge1_index = common_edge;
@@ -733,7 +733,8 @@ t8_cmesh_process_tree_geometry (const t8_cmesh_t cmesh, const t8_eclass_t eclass
       }
       /* If the face is linked to a surface we should now have two curves and we can check if both share a surface. */
       if (edge2_index > 0) {
-        surface_index = cad_geometry->get_cad_manager ()->t8_geom_get_common_face_of_edges (edge1_index, edge2_index);
+
+        surface_index = cad_geometry->get_cad_handle ()->get_common_face_of_edges (edge1_index, edge2_index);
       }
       else {
         continue;
@@ -763,11 +764,11 @@ t8_cmesh_process_tree_geometry (const t8_cmesh_t cmesh, const t8_eclass_t eclass
           break;
         case 1:
           /* If the edge is on the face we can check if it is a seam and if not we can use its parameters as reference. */
-          if (cad_geometry->get_cad_manager ()->t8_geom_is_edge_on_face (face_node->entity_tag, surface_index)) {
+          if (cad_geometry->get_cad_handle ()->is_edge_on_face (face_node->entity_tag, surface_index)) {
             if (!reference_parameters_on_surface
-                && !cad_geometry->get_cad_manager ()->t8_geom_edge_is_seam (face_node->entity_tag, surface_index)) {
+                && !cad_geometry->get_cad_handle ()->edge_is_seam (face_node->entity_tag, surface_index)) {
               reference_parameters_on_surface.emplace ();
-              cad_geometry->get_cad_manager ()->t8_geom_edge_parameter_to_face_parameters (
+              cad_geometry->get_cad_handle ()->edge_parameter_to_face_parameters (
                 face_node->entity_tag, surface_index, face_node->parameters[0],
                 reference_parameters_on_surface.value ().data ());
             }
@@ -780,7 +781,7 @@ t8_cmesh_process_tree_geometry (const t8_cmesh_t cmesh, const t8_eclass_t eclass
         case 0:
           /* If the vertex is not on the face, we can stop the face linkage.
              We do not have to check for reference parameters since a closed face linked to four vertices makes no sense. */
-          if (!cad_geometry->get_cad_manager ()->t8_geom_is_vertex_on_face (face_node->entity_tag, surface_index))
+          if (!cad_geometry->get_cad_handle ()->is_vertex_on_face (face_node->entity_tag, surface_index))
             all_nodes_on_surface = 0;
           break;
         default:
@@ -788,7 +789,7 @@ t8_cmesh_process_tree_geometry (const t8_cmesh_t cmesh, const t8_eclass_t eclass
         }
       }
       /* Abort if not all nodes are on the surface or if the surface is a plane */
-      if (!all_nodes_on_surface || cad_geometry->get_cad_manager ()->t8_geom_is_plane (surface_index)) {
+      if (!all_nodes_on_surface || cad_geometry->get_cad_handle ()->is_plane (surface_index)) {
         continue;
       }
 
@@ -804,14 +805,14 @@ t8_cmesh_process_tree_geometry (const t8_cmesh_t cmesh, const t8_eclass_t eclass
           /* Nothing to do. */
           break;
         case 1:
-          cad_geometry->get_cad_manager ()->t8_geom_edge_parameter_to_face_parameters (
+          cad_geometry->get_cad_handle ()->edge_parameter_to_face_parameters (
             face_node.entity_tag, surface_index, face_node.parameters[0], face_node.parameters.data (),
             reference_parameters_on_surface);
           face_node.entity_dim = 2;
           face_node.entity_tag = surface_index;
           break;
         case 0:
-          cad_geometry->get_cad_manager ()->t8_geom_get_parameters_of_vertex_on_face (
+          cad_geometry->get_cad_handle ()->get_parameters_of_vertex_on_face (
             face_node.entity_tag, surface_index, face_node.parameters.data (), reference_parameters_on_surface);
           face_node.entity_dim = 2;
           face_node.entity_tag = surface_index;
@@ -898,22 +899,19 @@ t8_cmesh_process_tree_geometry (const t8_cmesh_t cmesh, const t8_eclass_t eclass
       int is_on_geom = 1;
       for (int i_edge = 0; i_edge < 2; ++i_edge) {
         if (edge_geometry_dim == 2 && edge_nodes[i_edge].entity_dim == 1) {
-          if (!cad_geometry->get_cad_manager ()->t8_geom_is_edge_on_face (edge_nodes[i_edge].entity_tag,
-                                                                          edge_geometry_tag)) {
+          if (!cad_geometry->get_cad_handle ()->is_edge_on_face (edge_nodes[i_edge].entity_tag, edge_geometry_tag)) {
             is_on_geom = 0;
             break;
           }
         }
         else if (edge_geometry_dim == 2 && edge_nodes[i_edge].entity_dim == 0) {
-          if (!cad_geometry->get_cad_manager ()->t8_geom_is_vertex_on_face (edge_nodes[i_edge].entity_tag,
-                                                                            edge_geometry_tag)) {
+          if (!cad_geometry->get_cad_handle ()->is_vertex_on_face (edge_nodes[i_edge].entity_tag, edge_geometry_tag)) {
             is_on_geom = 0;
             break;
           }
         }
         else if (edge_geometry_dim == 1 && edge_nodes[i_edge].entity_dim == 0) {
-          if (!cad_geometry->get_cad_manager ()->t8_geom_is_vertex_on_edge (edge_nodes[i_edge].entity_tag,
-                                                                            edge_geometry_tag)) {
+          if (!cad_geometry->get_cad_handle ()->is_vertex_on_edge (edge_nodes[i_edge].entity_tag, edge_geometry_tag)) {
             is_on_geom = 0;
             break;
           }
@@ -935,11 +933,11 @@ t8_cmesh_process_tree_geometry (const t8_cmesh_t cmesh, const t8_eclass_t eclass
       if (!is_on_geom) {
         int common_face = 0;
         if (edge_nodes[0].entity_dim == 1 && edge_nodes[1].entity_dim == 0)
-          common_face = cad_geometry->get_cad_manager ()->t8_geom_get_common_face_of_vertex_and_edge (
-            edge_nodes[1].entity_tag, edge_nodes[0].entity_tag);
+          common_face = cad_geometry->get_cad_handle ()->get_common_face_of_vertex_and_edge (edge_nodes[1].entity_tag,
+                                                                                             edge_nodes[0].entity_tag);
         if (edge_nodes[1].entity_dim == 1 && edge_nodes[0].entity_dim == 0)
-          common_face = cad_geometry->get_cad_manager ()->t8_geom_get_common_face_of_vertex_and_edge (
-            edge_nodes[0].entity_tag, edge_nodes[1].entity_tag);
+          common_face = cad_geometry->get_cad_handle ()->get_common_face_of_vertex_and_edge (edge_nodes[0].entity_tag,
+                                                                                             edge_nodes[1].entity_tag);
         /* If a common face exists we can save it. */
         if (common_face > 0) {
           edge_geometry_dim = 2;
@@ -955,15 +953,15 @@ t8_cmesh_process_tree_geometry (const t8_cmesh_t cmesh, const t8_eclass_t eclass
      * But we can look if both vertices share an edge/face and use this edge/face.
      * If not we can skip this edge. */
     if (edge_geometry_dim == 0 && edge_geometry_tag == 0) {
-      int common_edge = cad_geometry->get_cad_manager ()->t8_geom_get_common_edge_of_vertices (
-        edge_nodes[0].entity_tag, edge_nodes[1].entity_tag);
+      int common_edge = cad_geometry->get_cad_handle ()->get_common_edge_of_vertices (edge_nodes[0].entity_tag,
+                                                                                      edge_nodes[1].entity_tag);
       if (common_edge > 0) {
         edge_geometry_tag = common_edge;
         edge_geometry_dim = 1;
       }
       else {
-        int common_face = cad_geometry->get_cad_manager ()->t8_geom_get_common_face_of_vertices (
-          edge_nodes[0].entity_tag, edge_nodes[1].entity_tag);
+        int common_face = cad_geometry->get_cad_handle ()->get_common_face_of_vertices (edge_nodes[0].entity_tag,
+                                                                                        edge_nodes[1].entity_tag);
         if (common_face > 0) {
           edge_geometry_tag = common_face;
           edge_geometry_dim = 2;
@@ -977,8 +975,8 @@ t8_cmesh_process_tree_geometry (const t8_cmesh_t cmesh, const t8_eclass_t eclass
      * If not we can skip this edge */
     if (edge_nodes[0].entity_dim == 1 && edge_nodes[1].entity_dim == 1
         && edge_nodes[0].entity_tag != edge_nodes[1].entity_tag) {
-      int common_face = cad_geometry->get_cad_manager ()->t8_geom_get_common_face_of_edges (edge_nodes[0].entity_tag,
-                                                                                            edge_nodes[1].entity_tag);
+      int common_face = cad_geometry->get_cad_handle ()->get_common_face_of_edges (edge_nodes[0].entity_tag,
+                                                                                   edge_nodes[1].entity_tag);
       if (common_face > 0) {
         edge_geometry_tag = common_face;
         edge_geometry_dim = 2;
@@ -994,14 +992,14 @@ t8_cmesh_process_tree_geometry (const t8_cmesh_t cmesh, const t8_eclass_t eclass
 
       /* Abort if the edge is a line. If the edge is a line, the curved computation would
        * only result in more computational overhead. */
-      if (cad_geometry->get_cad_manager ()->t8_geom_is_line (edge_geometry_tag)) {
+      if (cad_geometry->get_cad_handle ()->is_line (edge_geometry_tag)) {
         continue;
       }
 
       /* Check if adjacent faces carry a surface and if this edge lies on the surface */
       for (int i_adjacent_face = 0; i_adjacent_face < 2; ++i_adjacent_face) {
         if (face_geometries[t8_edge_to_face[eclass][i_tree_edges][i_adjacent_face]] > 0) {
-          if (!cad_geometry->get_cad_manager ()->t8_geom_is_edge_on_face (
+          if (!cad_geometry->get_cad_handle ()->is_edge_on_face (
                 edge_geometry_tag, face_geometries[t8_edge_to_face[eclass][i_tree_edges][i_adjacent_face]])) {
             t8_global_errorf ("Error during mesh-cad recombination: Adjacent edge and face of a tree carry "
                               "incompatible geometries.\n");
@@ -1032,7 +1030,7 @@ t8_cmesh_process_tree_geometry (const t8_cmesh_t cmesh, const t8_eclass_t eclass
           return 0;
         }
         if (edge_node.entity_dim == 0) {
-          if (!cad_geometry->get_cad_manager ()->t8_geom_is_vertex_on_edge (edge_node.entity_tag, edge_geometry_tag)) {
+          if (!cad_geometry->get_cad_handle ()->is_vertex_on_edge (edge_node.entity_tag, edge_geometry_tag)) {
             t8_global_errorf (
               "Error during mesh-cad recombination: Node %li should lie on a vertex which lies on an edge, "
               "but the vertex does not lie on that edge.\n",
@@ -1049,10 +1047,10 @@ t8_cmesh_process_tree_geometry (const t8_cmesh_t cmesh, const t8_eclass_t eclass
             break;
           case 0:
             /* If the node is on a vertex we can convert the parameters safely if the vertex os not the seam of the edge. */
-            if (!cad_geometry->get_cad_manager ()->t8_geom_vertex_is_seam (edge_node.entity_tag, edge_geometry_tag)) {
+            if (!cad_geometry->get_cad_handle ()->vertex_is_seam (edge_node.entity_tag, edge_geometry_tag)) {
               reference_param.emplace ();
-              cad_geometry->get_cad_manager ()->t8_geom_get_parameter_of_vertex_on_edge (
-                edge_node.entity_tag, edge_geometry_tag, &reference_param.value ());
+              cad_geometry->get_cad_handle ()->get_parameter_of_vertex_on_edge (edge_node.entity_tag, edge_geometry_tag,
+                                                                                &reference_param.value ());
             }
             break;
           default:
@@ -1069,7 +1067,7 @@ t8_cmesh_process_tree_geometry (const t8_cmesh_t cmesh, const t8_eclass_t eclass
       for (auto &edge_node : edge_nodes) {
         /* If the node lies on a vertex we retrieve its parameter on the curve */
         if (edge_node.entity_dim == 0) {
-          cad_geometry->get_cad_manager ()->t8_geom_get_parameter_of_vertex_on_edge (
+          cad_geometry->get_cad_handle ()->get_parameter_of_vertex_on_edge (
             edge_node.entity_tag, edge_geometry_tag, edge_node.parameters.data (), reference_param);
           edge_node.entity_dim = 1;
         }
@@ -1093,7 +1091,7 @@ t8_cmesh_process_tree_geometry (const t8_cmesh_t cmesh, const t8_eclass_t eclass
 
       /* We also skip this edge if the edge is on a plane. Planes have no curvature and
        * therefore only result in computational overhead. */
-      if (cad_geometry->get_cad_manager ()->t8_geom_is_plane (edge_geometry_tag)) {
+      if (cad_geometry->get_cad_handle ()->is_plane (edge_geometry_tag)) {
         continue;
       }
 
@@ -1113,7 +1111,7 @@ t8_cmesh_process_tree_geometry (const t8_cmesh_t cmesh, const t8_eclass_t eclass
           return 0;
         }
         if (edge_node.entity_dim == 0) {
-          if (!cad_geometry->get_cad_manager ()->t8_geom_is_vertex_on_face (edge_node.entity_tag, edge_geometry_tag)) {
+          if (!cad_geometry->get_cad_handle ()->is_vertex_on_face (edge_node.entity_tag, edge_geometry_tag)) {
             t8_global_errorf (
               "Error during mesh-cad recombination: Node %li should lie on a vertex which lies on a face, "
               "but the vertex does not lie on that face.\n",
@@ -1122,7 +1120,7 @@ t8_cmesh_process_tree_geometry (const t8_cmesh_t cmesh, const t8_eclass_t eclass
           }
         }
         if (edge_node.entity_dim == 1) {
-          if (!cad_geometry->get_cad_manager ()->t8_geom_is_edge_on_face (edge_node.entity_tag, edge_geometry_tag)) {
+          if (!cad_geometry->get_cad_handle ()->is_edge_on_face (edge_node.entity_tag, edge_geometry_tag)) {
             t8_global_errorf (
               "Error during mesh-cad recombination: Node %li should lie on an edge which lies on a face, "
               "but the edge does not lie on that face.\n",
@@ -1138,18 +1136,17 @@ t8_cmesh_process_tree_geometry (const t8_cmesh_t cmesh, const t8_eclass_t eclass
             break;
           case 1:
             /* If the node is on a curve, we can use the parameters if the curve is not the seam of the surface. */
-            if (!cad_geometry->get_cad_manager ()->t8_geom_edge_is_seam (edge_node.entity_tag, edge_geometry_tag)) {
+            if (!cad_geometry->get_cad_handle ()->edge_is_seam (edge_node.entity_tag, edge_geometry_tag)) {
               reference_params.emplace ();
-              cad_geometry->get_cad_manager ()->t8_geom_edge_parameter_to_face_parameters (
+              cad_geometry->get_cad_handle ()->edge_parameter_to_face_parameters (
                 edge_node.entity_tag, edge_geometry_tag, edge_node.parameters[0], reference_params.value ().data ());
             }
             break;
           case 0:
             /* If the node is on a vertex we can convert the parameters safely if the vertex is not the seam of the edge. */
-            if (!cad_geometry->get_cad_manager ()->t8_geom_vertex_is_on_seam_edge (edge_node.entity_tag,
-                                                                                   edge_geometry_tag)) {
+            if (!cad_geometry->get_cad_handle ()->vertex_is_on_seam_edge (edge_node.entity_tag, edge_geometry_tag)) {
               reference_params.emplace ();
-              cad_geometry->get_cad_manager ()->t8_geom_get_parameters_of_vertex_on_face (
+              cad_geometry->get_cad_handle ()->get_parameters_of_vertex_on_face (
                 edge_node.entity_tag, edge_geometry_tag, reference_params.value ().data ());
             }
             break;
@@ -1167,13 +1164,13 @@ t8_cmesh_process_tree_geometry (const t8_cmesh_t cmesh, const t8_eclass_t eclass
       for (auto &edge_node : edge_nodes) {
         /* If the node lies on a vertex we retrieve its parameters on the surface */
         if (edge_node.entity_dim == 0) {
-          cad_geometry->get_cad_manager ()->t8_geom_get_parameters_of_vertex_on_face (
+          cad_geometry->get_cad_handle ()->get_parameters_of_vertex_on_face (
             edge_node.entity_tag, edge_geometry_tag, edge_node.parameters.data (), reference_params);
           edge_node.entity_dim = 2;
         }
         /* If the node lies on an edge we have to do the same */
         if (edge_node.entity_dim == 1) {
-          cad_geometry->get_cad_manager ()->t8_geom_edge_parameter_to_face_parameters (
+          cad_geometry->get_cad_handle ()->edge_parameter_to_face_parameters (
             edge_node.entity_tag, edge_geometry_tag, edge_node.parameters[0], edge_node.parameters.data (),
             reference_params);
           edge_node.entity_dim = 2;
diff --git a/src/t8_cmesh/t8_cmesh_io/t8_cmesh_readmshfile.h b/src/t8_cmesh/t8_cmesh_io/t8_cmesh_readmshfile.h
index 4153728ef9..639bb6a3ee 100644
--- a/src/t8_cmesh/t8_cmesh_io/t8_cmesh_readmshfile.h
+++ b/src/t8_cmesh/t8_cmesh_io/t8_cmesh_readmshfile.h
@@ -29,7 +29,7 @@
 #define T8_CMESH_READMSHFILE_H
 
 #include <t8.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <t8_cmesh/t8_cmesh.h>
 
 /** The supported .msh file versions.
diff --git a/src/t8_cmesh/t8_cmesh_io/t8_cmesh_save.cxx b/src/t8_cmesh/t8_cmesh_io/t8_cmesh_save.cxx
index a9d7aaa037..c4d14ebc53 100644
--- a/src/t8_cmesh/t8_cmesh_io/t8_cmesh_save.cxx
+++ b/src/t8_cmesh/t8_cmesh_io/t8_cmesh_save.cxx
@@ -24,8 +24,8 @@
  * We define routines to save and load a cmesh to/from the file system.
  */
 
-#include <t8_version.h>
-#include <t8_eclass.h>
+#include <t8_misc/t8_version.h>
+#include <t8_eclass/t8_eclass.h>
 #include <t8_cmesh/t8_cmesh_internal/t8_cmesh_types.h>
 #include <t8_cmesh/t8_cmesh_internal/t8_cmesh_trees.h>
 #include <t8_cmesh/t8_cmesh_io/t8_cmesh_save.h>
diff --git a/src/t8_cmesh/t8_cmesh_io/t8_cmesh_tetgen.h b/src/t8_cmesh/t8_cmesh_io/t8_cmesh_tetgen.h
index 93082ae012..a8310c0b1c 100644
--- a/src/t8_cmesh/t8_cmesh_io/t8_cmesh_tetgen.h
+++ b/src/t8_cmesh/t8_cmesh_io/t8_cmesh_tetgen.h
@@ -29,7 +29,7 @@
 #define T8_CMESH_TETGEN_H
 
 #include <t8.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <t8_cmesh/t8_cmesh.h>
 #include <sc_flops.h>
 #include <sc_statistics.h>
diff --git a/src/t8_cmesh/t8_cmesh_io/t8_cmesh_triangle.cxx b/src/t8_cmesh/t8_cmesh_io/t8_cmesh_triangle.cxx
index ae82acf419..916f6d4af3 100644
--- a/src/t8_cmesh/t8_cmesh_io/t8_cmesh_triangle.cxx
+++ b/src/t8_cmesh/t8_cmesh_io/t8_cmesh_triangle.cxx
@@ -28,7 +28,7 @@
 #include <t8_cmesh/t8_cmesh_internal/t8_cmesh_stash.h>
 
 #ifdef _WIN32
-#include "t8_windows.h"
+#include <t8_misc/t8_windows.h>
 #endif
 
 /* TODO: if partitioned then only add the needed face-connections to join faces
diff --git a/src/t8_cmesh/t8_cmesh_io/t8_cmesh_triangle.h b/src/t8_cmesh/t8_cmesh_io/t8_cmesh_triangle.h
index 277218214a..962cda6b0c 100644
--- a/src/t8_cmesh/t8_cmesh_io/t8_cmesh_triangle.h
+++ b/src/t8_cmesh/t8_cmesh_io/t8_cmesh_triangle.h
@@ -29,7 +29,7 @@
 #define T8_CMESH_TRIANGLE_H
 
 #include <t8.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <t8_cmesh/t8_cmesh.h>
 
 /* put typedefs here */
diff --git a/src/t8_data/t8_containers.cxx b/src/t8_data/t8_containers.cxx
index e025c9ed6b..fe20b2864c 100644
--- a/src/t8_data/t8_containers.cxx
+++ b/src/t8_data/t8_containers.cxx
@@ -27,6 +27,7 @@
 #include <sc_containers.h>
 #include <t8_data/t8_containers.h>
 #include <t8_schemes/t8_scheme.hxx>
+#include <t8_forest/t8_forest_private.h>
 
 T8_EXTERN_C_BEGIN ();
 
@@ -326,6 +327,39 @@ t8_element_array_get_array_mutable (t8_element_array_t *element_array)
   return &element_array->array;
 }
 
+t8_locidx_t
+t8_element_array_find (const t8_element_array_t *element_array, const t8_element_t *element)
+{
+  /* In order to find the element, we need to compute its linear id.
+   * To do so, we need the scheme and the level of the element. */
+  const t8_scheme *scheme = t8_element_array_get_scheme (element_array);
+  const t8_eclass_t tree_class = t8_element_array_get_tree_class (element_array);
+  const int element_level = scheme->element_get_level (tree_class, element);
+  /* Compute the linear id. */
+  const t8_linearidx_t element_id = scheme->element_get_linear_id (tree_class, element, element_level);
+  /* Search for the element.
+   * The search returns the largest index i,
+   * such that the element at position i has a smaller id than the given one.
+   * If no such i exists, it returns -1. */
+  const t8_locidx_t search_result = t8_forest_bin_search_lower (element_array, element_id, element_level);
+  if (search_result < 0) {
+    // The element was not found, we return -1. */
+    return -1;
+  }
+  /* An element was found but it may not be the candidate element. 
+   * To identify whether the element was found, we compare these two. */
+  const t8_element_t *check_element = t8_element_array_index_locidx (element_array, search_result);
+  T8_ASSERT (check_element != NULL);
+  if (scheme->element_is_equal (tree_class, element, check_element)) {
+    // The element was found at position search_result. We return it.
+    return search_result;
+  }
+  else {
+    // The element was not found, we return -1. */
+    return -1;
+  }
+}
+
 void
 t8_element_array_reset (t8_element_array_t *element_array)
 {
diff --git a/src/t8_data/t8_containers.h b/src/t8_data/t8_containers.h
index efa2ff6d6b..40a177b938 100644
--- a/src/t8_data/t8_containers.h
+++ b/src/t8_data/t8_containers.h
@@ -29,7 +29,7 @@
 #define T8_CONTAINERS_H
 
 #include <t8.h>
-#include <t8_element.h>
+#include <t8_element/t8_element.h>
 #include <t8_schemes/t8_scheme.h>
 
 /** The t8_element_array_t is an array to store t8_element_t * of a given
@@ -265,6 +265,16 @@ t8_element_array_get_array (const t8_element_array_t *element_array);
 sc_array_t *
 t8_element_array_get_array_mutable (t8_element_array_t *element_array);
 
+/** Search for an element in an array.
+ * \param [in] element_array Array structure.
+ * \param [in] element Element to be found in \a element_array. 
+ *                     The element must have been created with the scheme used in \a element_array.
+ * \return If \a element was found in \a element_array then the position in the array is returned.
+ *  If the element is not found, -1 is returned.
+*/
+t8_locidx_t
+t8_element_array_find (const t8_element_array_t *element_array, const t8_element_t *element);
+
 /** Sets the array count to zero and frees all elements.
  * \param [in,out]  element_array  Array structure to be reset.
  * \note Calling t8_element_array_init, then any array operations,
diff --git a/src/t8_data/t8_element_array_iterator.hxx b/src/t8_data/t8_element_array_iterator.hxx
index 069bfaa47e..e792d24b8d 100644
--- a/src/t8_data/t8_element_array_iterator.hxx
+++ b/src/t8_data/t8_element_array_iterator.hxx
@@ -29,7 +29,7 @@
 #define T8_ELEMENT_ARRAY_ITERATOR_HXX
 
 #include <t8.h>
-#include <t8_element.h>
+#include <t8_element/t8_element.h>
 #include <t8_data/t8_containers.h>
 
 #include <cstddef>
diff --git a/src/t8_eclass.c b/src/t8_eclass/t8_eclass.c
similarity index 99%
rename from src/t8_eclass.c
rename to src/t8_eclass/t8_eclass.c
index 160bbd8aa4..813d2c0494 100644
--- a/src/t8_eclass.c
+++ b/src/t8_eclass/t8_eclass.c
@@ -25,7 +25,7 @@
  */
 
 #define KEEP_ECLASS_VALUE_DEFINITIONS
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #undef KEEP_ECLASS_VALUE_DEFINITIONS
 
 const int t8_eclass_to_dimension[T8_ECLASS_COUNT] = T8_ECLASS_TO_DIMENSION_VALUES;
diff --git a/src/t8_eclass.h b/src/t8_eclass/t8_eclass.h
similarity index 100%
rename from src/t8_eclass.h
rename to src/t8_eclass/t8_eclass.h
diff --git a/src/t8_element.cxx b/src/t8_element/t8_element.cxx
similarity index 98%
rename from src/t8_element.cxx
rename to src/t8_element/t8_element.cxx
index 54e63589dc..58657dbaea 100644
--- a/src/t8_element.cxx
+++ b/src/t8_element/t8_element.cxx
@@ -20,7 +20,7 @@
   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */
 
-#include <t8_element.h>
+#include <t8_element/t8_element.h>
 
 /* We want to export the whole implementation to be callable from "C" */
 T8_EXTERN_C_BEGIN ();
diff --git a/src/t8_element.h b/src/t8_element/t8_element.h
similarity index 96%
rename from src/t8_element.h
rename to src/t8_element/t8_element.h
index 59e0870b5e..0995c74dec 100644
--- a/src/t8_element.h
+++ b/src/t8_element/t8_element.h
@@ -29,8 +29,8 @@
 #define T8_ELEMENT_H
 
 #include <t8.h>
-#include <t8_eclass.h>
-#include <t8_element_shape.h>
+#include <t8_eclass/t8_eclass.h>
+#include <t8_element/t8_element_shape.h>
 
 /** We want to export the whole implementation to be callable from "C". */
 T8_EXTERN_C_BEGIN ();
diff --git a/src/t8_element_shape.c b/src/t8_element/t8_element_shape.c
similarity index 98%
rename from src/t8_element_shape.c
rename to src/t8_element/t8_element_shape.c
index a9cf4f0a68..acc64a43aa 100644
--- a/src/t8_element_shape.c
+++ b/src/t8_element/t8_element_shape.c
@@ -20,7 +20,7 @@
   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */
 
-#include <t8_element_shape.h>
+#include <t8_element/t8_element_shape.h>
 
 const int t8_element_shape_max_num_corner[T8_ECLASS_MAX_DIM + 1] = { 0, 2, 4, 8 };
 
diff --git a/src/t8_element_shape.h b/src/t8_element/t8_element_shape.h
similarity index 99%
rename from src/t8_element_shape.h
rename to src/t8_element/t8_element_shape.h
index 59abca1c38..4486afd2df 100644
--- a/src/t8_element_shape.h
+++ b/src/t8_element/t8_element_shape.h
@@ -28,7 +28,7 @@
 #define T8_ELEMENT_SHAPE_H
 
 #include <t8.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 
 /** We want to export the whole implementation to be callable from "C". */
 T8_EXTERN_C_BEGIN ();
diff --git a/src/t8_forest/t8_forest.cxx b/src/t8_forest/t8_forest.cxx
index 16e43864e8..3e6993b74f 100644
--- a/src/t8_forest/t8_forest.cxx
+++ b/src/t8_forest/t8_forest.cxx
@@ -25,7 +25,7 @@
  */
 
 #include <sc_statistics.h>
-#include <t8_refcount.h>
+#include <t8_helper_functions/t8_refcount.h>
 #include <t8_types/t8_vec.h>
 #include <t8_forest/t8_forest_general.h>
 #include <t8_forest/t8_forest_geometrical.h>
@@ -1957,36 +1957,36 @@ t8_forest_tree_is_local (const t8_forest_t forest, const t8_locidx_t local_tree)
 int
 t8_forest_element_is_leaf (const t8_forest_t forest, const t8_element_t *element, const t8_locidx_t local_tree)
 {
-  T8_ASSERT (t8_forest_is_committed (forest));
+  bool check_ghost = false;
   T8_ASSERT (t8_forest_tree_is_local (forest, local_tree));
+  return t8_forest_element_is_leaf_or_ghost (forest, element, local_tree, check_ghost);
+}
+
+int
+t8_forest_element_is_leaf_or_ghost (const t8_forest_t forest, const t8_element_t *element, const t8_locidx_t local_tree,
+                                    const int check_ghost)
+{
+  T8_ASSERT (t8_forest_is_committed (forest));
+#if T8_ENABLE_DEBUG
+  if (!check_ghost) {
+    T8_ASSERT (t8_forest_tree_is_local (forest, local_tree));
+  }
+  else {
+    T8_ASSERT (0 <= local_tree && local_tree < t8_forest_get_num_ghost_trees (forest));
+  }
+#endif
 
   /* We get the array of the tree's elements and then search in the array of elements for our
    * element candidate. */
   /* Get the array */
-  const t8_element_array_t *elements = t8_forest_get_tree_leaf_element_array (forest, local_tree);
+  const t8_element_array_t *elements = check_ghost ? t8_forest_ghost_get_tree_leaf_elements (forest, local_tree)
+                                                   : t8_forest_tree_get_leaf_elements (forest, local_tree);
+
   T8_ASSERT (elements != NULL);
 
-  /* In order to find the element, we need to compute its linear id.
-   * To do so, we need the scheme and the level of the element. */
-  const t8_scheme *scheme = t8_element_array_get_scheme (elements);
-  const t8_eclass_t tree_class = t8_element_array_get_tree_class (elements);
-  const int element_level = scheme->element_get_level (tree_class, element);
-  /* Compute the linear id. */
-  const t8_linearidx_t element_id = scheme->element_get_linear_id (tree_class, element, element_level);
-  /* Search for the element.
-   * The search returns the largest index i,
-   * such that the element at position i has a smaller id than the given one.
-   * If no such i exists, it returns -1. */
-  const t8_locidx_t search_result = t8_forest_bin_search_lower (elements, element_id, element_level);
-  if (search_result < 0) {
-    /* The element was not found. */
-    return 0;
-  }
-  /* An element was found but it may not be the candidate element.
-   * To identify whether the element was found, we compare these two. */
-  const t8_element_t *check_element = t8_element_array_index_locidx (elements, search_result);
-  T8_ASSERT (check_element != NULL);
-  return (scheme->element_is_equal (tree_class, element, check_element));
+  // Search for the element in the array, return true if it was found,
+  // false if not.
+  return t8_element_array_find (elements, element) >= 0;
 }
 
 /* Check if an element is owned by a specific rank */
diff --git a/src/t8_forest/t8_forest_general.h b/src/t8_forest/t8_forest_general.h
index 0cfe5372f9..2add53783f 100644
--- a/src/t8_forest/t8_forest_general.h
+++ b/src/t8_forest/t8_forest_general.h
@@ -28,7 +28,7 @@
 #define T8_FOREST_GENERAL_H
 
 #include <t8_cmesh/t8_cmesh.h>
-#include <t8_element.h>
+#include <t8_element/t8_element.h>
 #include <t8_data/t8_containers.h>
 
 /** Opaque pointer to a forest implementation. */
@@ -550,6 +550,25 @@ t8_forest_get_coarse_tree (t8_forest_t forest, t8_locidx_t ltreeid);
 int
 t8_forest_element_is_leaf (const t8_forest_t forest, const t8_element_t *element, const t8_locidx_t local_tree);
 
+/**
+ * Query whether a given element or a ghost is a leaf of a local or ghost tree in a forest.
+ * 
+ * \param [in]  forest    The forest.
+ * \param [in]  element   An element of a local tree in \a forest.
+ * \param [in]  local_tree A local tree id of \a forest or a ghost tree id
+ * \param [in]  check_ghost If true \a element is interpreted as a ghost element and
+ *                         \a local_tree as the id of a ghost tree (0 <= \a local_tree < num_ghost_trees).
+ *                         If false \a element is interpreted as an element and \a local_tree as
+ *                         the id of a local tree (0 <= \a local_tree < num_local_trees).
+ * \return True (non-zero) if and only if \a element is a leaf (or ghost) in \a local_tree of \a forest.
+ * \note \a forest must be committed before calling this function.
+ * \ref t8_forest_element_is_leaf
+ * \ref t8_forest_element_is_ghost
+ */
+int
+t8_forest_element_is_leaf_or_ghost (const t8_forest_t forest, const t8_element_t *element, const t8_locidx_t local_tree,
+                                    const int check_ghost);
+
 /** Compute the leaf face orientation at given face in a forest.
  * \param [in]    forest  The forest. Must have a valid ghost layer.
  * \param [in]    ltreeid A local tree id.
diff --git a/src/t8_forest/t8_forest_ghost.cxx b/src/t8_forest/t8_forest_ghost.cxx
index bf65cfe9f9..8acfe43026 100644
--- a/src/t8_forest/t8_forest_ghost.cxx
+++ b/src/t8_forest/t8_forest_ghost.cxx
@@ -337,6 +337,16 @@ t8_forest_ghost_num_trees (const t8_forest_t forest)
   return forest->ghosts->ghost_trees->elem_count;
 }
 
+#if T8_ENABLE_DEBUG
+static bool
+t8_forest_tree_is_ghost (const t8_forest_t forest, const t8_locidx_t lghost_tree)
+{
+  T8_ASSERT (t8_forest_is_committed (forest));
+
+  return 0 <= lghost_tree && lghost_tree < t8_forest_get_num_ghost_trees (forest);
+}
+#endif
+
 /** 
  * Given an index into the ghost_trees array return the ghost tree 
  * 
@@ -355,7 +365,7 @@ t8_forest_ghost_get_tree (const t8_forest_t forest, const t8_locidx_t lghost_tre
   ghost = forest->ghosts;
   T8_ASSERT (ghost != NULL);
   T8_ASSERT (ghost->ghost_trees != NULL);
-  T8_ASSERT (0 <= lghost_tree && lghost_tree < t8_forest_ghost_num_trees (forest));
+  T8_ASSERT (t8_forest_tree_is_ghost (forest, lghost_tree));
 
   ghost_tree = (t8_ghost_tree_t *) t8_sc_array_index_locidx (ghost->ghost_trees, lghost_tree);
   return ghost_tree;
@@ -446,6 +456,14 @@ t8_forest_ghost_get_leaf_element (t8_forest_t forest, t8_locidx_t lghost_tree, t
   return t8_element_array_index_locidx_mutable (&ghost_tree->elements, lelement);
 }
 
+int
+t8_forest_element_is_ghost (const t8_forest_t forest, const t8_element_t *element, const t8_locidx_t lghost_tree)
+{
+  bool check_ghost = true;
+  T8_ASSERT (t8_forest_tree_is_ghost (forest, lghost_tree));
+  return t8_forest_element_is_leaf_or_ghost (forest, element, lghost_tree, check_ghost);
+}
+
 /** Initialize a t8_ghost_remote_tree_t.
  * 
  *  \param[in]  forest    The forest.
diff --git a/src/t8_forest/t8_forest_ghost.h b/src/t8_forest/t8_forest_ghost.h
index 42ffa3b90c..f6936bfbb3 100644
--- a/src/t8_forest/t8_forest_ghost.h
+++ b/src/t8_forest/t8_forest_ghost.h
@@ -116,7 +116,7 @@ t8_forest_ghost_get_tree_class (const t8_forest_t forest, const t8_locidx_t lgho
 
 /** Given a local ghost tree compute the global tree id of it.
  * \param [in]  forest    The forest. Ghost layer must exist.
- * \param [in]  lghost_tree The ghost tree id of a ghost tree.
+ * \param [in]  lghost_tree The ghost tree id of a ghost tree. (0 <= \a lghost_tree < num_ghost_trees)
  * \return                The global id of the local ghost tree \a lghost_tree.
  * \a forest must be committed before calling this function.
  * \see https://github.com/DLR-AMR/t8code/wiki/Tree-indexing for more details about tree indexing.
@@ -135,6 +135,18 @@ t8_forest_ghost_get_global_treeid (const t8_forest_t forest, const t8_locidx_t l
 t8_element_t *
 t8_forest_ghost_get_leaf_element (t8_forest_t forest, t8_locidx_t lghost_tree, t8_locidx_t lelement);
 
+/**
+ * Query whether a given element is a ghost of a certrain tree in a forest.
+ * 
+ * \param [in]  forest    The forest.
+ * \param [in]  element   An element of a ghost tree in \a forest.
+ * \param [in]  lghost_tree A local ghost tree id of \a forest. (0 <= \a lghost_tree < num_ghost_trees)
+ * \return True (non-zero) if and only if \a element is a ghost in \a lghost_tree of \a forest.
+ * \note \a forest must be committed before calling this function.
+ */
+int
+t8_forest_element_is_ghost (const t8_forest_t forest, const t8_element_t *element, const t8_locidx_t lghost_tree);
+
 /** Return the array of remote ranks.
  * \param [in] forest   A forest with constructed ghost layer.
  * \param [in,out] num_remotes On output the number of remote ranks is stored here.
diff --git a/src/t8_forest/t8_forest_io.h b/src/t8_forest/t8_forest_io.h
index ab0d1bd0ce..558bf8df9b 100644
--- a/src/t8_forest/t8_forest_io.h
+++ b/src/t8_forest/t8_forest_io.h
@@ -27,7 +27,7 @@
 #ifndef T8_FOREST_IO_H
 #define T8_FOREST_IO_H
 
-#include <t8_vtk.h>
+#include <t8_vtk/t8_vtk.h>
 T8_EXTERN_C_BEGIN ();
 
 /** TODO: implement */
diff --git a/src/t8_forest/t8_forest_partition_for_coarsening.cxx b/src/t8_forest/t8_forest_partition_for_coarsening.cxx
index 1708b9050b..986d81aaef 100644
--- a/src/t8_forest/t8_forest_partition_for_coarsening.cxx
+++ b/src/t8_forest/t8_forest_partition_for_coarsening.cxx
@@ -31,9 +31,9 @@
 #include <t8_forest/t8_forest_pfc_message.hxx>
 #include <t8_forest/t8_forest_pfc_helper.hxx>
 #include <t8_data/t8_shmem.h>
-#include <t8_element.h>
+#include <t8_element/t8_element.h>
 #include <t8_forest/t8_forest_partition_for_coarsening.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <vector>
 #include <algorithm>
 
diff --git a/src/t8_forest/t8_forest_pfc_helper.cxx b/src/t8_forest/t8_forest_pfc_helper.cxx
index 580cf9c5ee..93b62f4538 100644
--- a/src/t8_forest/t8_forest_pfc_helper.cxx
+++ b/src/t8_forest/t8_forest_pfc_helper.cxx
@@ -31,7 +31,7 @@
 #include <t8_forest/t8_forest_pfc_helper.hxx>
 #include <t8_schemes/t8_scheme.h>
 #include <t8_schemes/t8_scheme.hxx>
-#include <t8_element.h>
+#include <t8_element/t8_element.h>
 #include <algorithm>
 
 t8_locidx_t
diff --git a/src/t8_forest/t8_forest_pfc_helper.hxx b/src/t8_forest/t8_forest_pfc_helper.hxx
index 09ec4d2ca2..0c3ab21db2 100644
--- a/src/t8_forest/t8_forest_pfc_helper.hxx
+++ b/src/t8_forest/t8_forest_pfc_helper.hxx
@@ -29,7 +29,7 @@
 
 #include <t8.h>
 #include <t8_data/t8_shmem.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 
 /** Determine the sibling with the biggest difference in IDs (in the given direction).
  *
diff --git a/src/t8_forest/t8_forest_pfc_message.hxx b/src/t8_forest/t8_forest_pfc_message.hxx
index 46ab106521..868aae6d24 100644
--- a/src/t8_forest/t8_forest_pfc_message.hxx
+++ b/src/t8_forest/t8_forest_pfc_message.hxx
@@ -30,7 +30,7 @@
 #define T8_FOREST_PFC_MESSAGE_H
 
 #include <t8.h>
-#include <t8_element.h>
+#include <t8_element/t8_element.h>
 #include <t8_forest/t8_forest.h>
 #include <t8_forest/t8_forest_pfc_helper.hxx>
 #include <t8_schemes/t8_scheme.h>
diff --git a/src/t8_forest/t8_forest_private.cxx b/src/t8_forest/t8_forest_private.cxx
index ce3e91879d..49d3367eda 100644
--- a/src/t8_forest/t8_forest_private.cxx
+++ b/src/t8_forest/t8_forest_private.cxx
@@ -57,6 +57,14 @@ t8_forest_get_tree_leaf_element_array_mutable (const t8_forest_t forest, t8_loci
   return (t8_element_array_t *) t8_forest_get_tree_leaf_element_array (forest, ltreeid);
 }
 
+/* TODO: does the search fail when element_level is smaller then levels in the array?
+         For example entering the search with the root element or a level 1 element
+         and the array contains much finer elements.
+         Will it still return the largest index, or just any index? 
+ */
+/* TODO: This may be implementable with std::partition_point, which would yield an easier implementation.
+         Need to check.
+ */
 /** \brief Search for a linear element id (at level element_level) in a sorted array of
  * elements. If the element does not exist, return the largest index i
  * such that the element at position i has a smaller id than the given one.
@@ -93,4 +101,123 @@ t8_forest_bin_search_lower (const t8_element_array_t *elements, const t8_lineari
   return elem_iter.get_current_index () - 1;
 }
 
+/** \brief Search for a linear element id (at level element_level) in a sorted array of
+ * elements. If the element does not exist, return the smallest index i
+ * such that the element at position i has a larger id than the given one.
+ * If no such i exists, return -1.
+ */
+t8_locidx_t
+t8_forest_bin_search_upper (const t8_element_array_t *elements, const t8_linearidx_t element_id,
+                            const int element_level)
+{
+  const t8_scheme *scheme = t8_element_array_get_scheme (elements);
+  const t8_eclass_t tree_class = t8_element_array_get_tree_class (elements);
+  /* At first, we check whether any element has smaller id than the
+   * given one. */
+  const t8_locidx_t num_elements = t8_element_array_get_count (elements);
+  if (num_elements == 0) {
+    /* This array is empty. */
+    return -1;
+  }
+  const t8_element_t *query = t8_element_array_index_int (elements, num_elements - 1);
+  const t8_linearidx_t query_id = scheme->element_get_linear_id (tree_class, query, element_level);
+  if (query_id < element_id) {
+    /* No element has id larger than the given one. */
+    return -1;
+  }
+
+  /* We search for the first element E in the array, where element_id > ID(E) is false.
+     Thus, E is the first element with ID(E) >= element_id . */
+  auto elem_iter
+    = std::lower_bound (t8_element_array_begin (elements), t8_element_array_end (elements), element_id,
+                        [&element_level, &scheme, &tree_class] (const t8_element_array_iterator::value_type &elem_ptr,
+                                                                const t8_linearidx_t element_id_) {
+                          return (element_id_ > scheme->element_get_linear_id (tree_class, elem_ptr, element_level));
+                        });
+
+  /* In case we do not find an element that is greater than the given element_id, the binary search returns
+   * the end-iterator of the element array. */
+  if (elem_iter == t8_element_array_end (elements)) {
+    // No element was found.
+    return -1;
+  }
+  else {
+    return elem_iter.get_current_index ();
+  }
+}
+
+/** \brief Search for a linear element id (at level element_level) in a sorted array of
+ * elements. If the element does not exist, return the first index i such that
+ * the element at position i is an ancestor or descendant of the element corresponding to the element id.
+ * If no such i exists, return -1.
+ */
+t8_locidx_t
+t8_forest_bin_search_first_descendant_ancestor (const t8_element_array_t *elements, const t8_element_t *element,
+                                                const t8_element_t **element_found)
+{
+  /* This search works as follows:
+  
+  Let E denote the element with element_id at level L.
+  If an ancestor or descendant of E exists in the array then they are either:
+    A: The search result of t8_forest_bin_search_lower
+    B: The search result of t8_forest_bin_search_upper
+
+  Let ID(element,level) denote the linear id of an element at a given level.
+
+  Case A: There is an element F in the array that is E itself or an ancestor of E (i.e. level(F) <= level(E)).
+          In that case
+          ID(E,L) >= ID(F,L) and there can be no element with id in between (since it would also be an ancestor of E).
+          Then F will be the search result of t8_forest_bin_search_lower
+  Case B: There is an element F in the array that is a descendant of E and it has the smallest index in the array of all descendants.
+          Then
+          ID(E,L) = ID(F,L)
+          and also
+          ID(E,L) = ID(D,L) for all other descendants of E.
+          But since F is the first it will be the search result of t8_forest_bin_search_upper.
+  Case C: There is no descendant or ancestor of E in the array. In both cases t8_forest_bin_search_lower and
+          t8_forest_bin_search_upper may find elements but the results will not be ancestors/descendants of E.
+ 
+   From this, we determine the following algorithm:
+
+    1. Query t8_forest_bin_search_lower with N.
+    2. If no element was found, or the resulting element is not an ancestor of N.
+    3. Query t8_forest_bin_search_upper with N.
+    3. If an element was found and it is a descendant of N, we found our element.
+    4. If not, no element was found.
+  */
+
+  /* Compute the element's level and linear id. In order to do so,
+   * we first need the scheme and eclass. */
+  const t8_scheme *scheme = t8_element_array_get_scheme (elements);
+  const t8_eclass eclass = t8_element_array_get_tree_class (elements);
+  const int element_level = scheme->element_get_level (eclass, element);
+  const t8_linearidx_t element_id = scheme->element_get_linear_id (eclass, element, element_level);
+
+  const t8_locidx_t search_pos_lower = t8_forest_bin_search_lower (elements, element_id, element_level);
+
+  /* Get the element at the current position. */
+  if (search_pos_lower >= 0) {
+    *element_found = t8_element_array_index_locidx (elements, search_pos_lower);
+    const bool is_ancestor = scheme->element_is_ancestor (eclass, *element_found, element);
+    if (is_ancestor) {
+      /* The element at this position is an ancestor or descendant. */
+      return search_pos_lower;
+    }
+  }
+  /* t8_forest_bin_search_lower did not return a result or an ancestor. */
+
+  const t8_locidx_t search_pos_upper = t8_forest_bin_search_upper (elements, element_id, element_level);
+  if (search_pos_upper >= 0) {
+    *element_found = t8_element_array_index_locidx (elements, search_pos_upper);
+    const bool is_descendant = scheme->element_is_ancestor (eclass, element, *element_found);
+    if (is_descendant) {
+      /* The element at this position is an ancestor or descendant. */
+      return search_pos_upper;
+    }
+  }
+  // No ancestor or descendant was found
+  *element_found = nullptr;
+  return -1;
+}
+
 T8_EXTERN_C_END ();
diff --git a/src/t8_forest/t8_forest_private.h b/src/t8_forest/t8_forest_private.h
index e01f2a5162..0414a343e8 100644
--- a/src/t8_forest/t8_forest_private.h
+++ b/src/t8_forest/t8_forest_private.h
@@ -200,7 +200,7 @@ t8_forest_get_tree_leaf_element_array_mutable (const t8_forest_t forest, t8_loci
 
 /** Search for a linear element id in a sorted array of
  * elements. If the element does not exist, return the largest index i
- * such that the element at position i has a smaller id than the given one.
+ * such that the element at position i has a smaller or equal id than the given one.
  * If no such i exists, return -1.
  * \param [in]     elements    An array of elements. Must be sorted according to linear id at maximum level.
  *                             Must correspond to a valid refinement (i.e. contain no duplicate elements or elements and their descendants).
@@ -213,6 +213,35 @@ t8_locidx_t
 t8_forest_bin_search_lower (const t8_element_array_t *elements, const t8_linearidx_t element_id,
                             const int element_level);
 
+/** \brief Search for a linear element id (at level element_level) in a sorted array of
+ * elements. If the element does not exist, return the smallest index i
+ * such that the element at position i has a larger or equal id than the given one.
+ * If no such i exists, return -1.
+ * \param [in]     elements    An array of elements. Must be sorted according to linear id at maximum level.
+ *                             Must correspond to a valid refinement (i.e. contain no duplicate elements or elements and their descendants).
+ * \param [in]     element_id  The linear id of the element to search for.
+ * \param [in]     element_level The level of the element to search for. Thus, the level at which \a element_id was computed.
+ * \return                     The smallest index \a i of an element with linear_id larger than or equal to \a element_id in \a elements if it exists.
+ *                             -1 if no such element was found in \a elements.
+ */
+t8_locidx_t
+t8_forest_bin_search_upper (const t8_element_array_t *elements, const t8_linearidx_t element_id,
+                            const int element_level);
+
+/** \brief Search for the first descendant or ancestor of an element in a sorted array of elements.
+ * \param [in]     elements    An array of elements. Must be sorted according to linear id at maximum level.
+ *                             Must correspond to a valid refinement (i.e. contain no duplicate elements or elements and their descendants).
+ * \param [in]     element     The element to search for.
+ * \param [in]     element_found On return either a descendant or ancestor of \a element in \a elements if it exists. NULL if no
+ *                             such element exists in \a elements.
+ * \return                     The smallest index \a i such that elements[i] (= \a element_found) is an ancestor or a descendant of \a element.
+ *                             -1 if no such element was found in \a elements.
+ * \note \a element is ancestor and descendant of itself, so if \a element is contained in \a elements then it will be found by this function.
+ */
+t8_locidx_t
+t8_forest_bin_search_first_descendant_ancestor (const t8_element_array_t *elements, const t8_element_t *element,
+                                                const t8_element_t **element_found);
+
 /** Find the owner process of a given element, deprecated version.
  * Use t8_forest_element_find_owner instead.
  * \param [in]     forest  The forest.
diff --git a/src/t8_forest/t8_forest_types.h b/src/t8_forest/t8_forest_types.h
index 852a06db93..a6fbc712a6 100644
--- a/src/t8_forest/t8_forest_types.h
+++ b/src/t8_forest/t8_forest_types.h
@@ -29,9 +29,9 @@
 
 #include <t8.h>
 #include <sc_statistics.h>
-#include <t8_refcount.h>
+#include <t8_helper_functions/t8_refcount.h>
 #include <t8_cmesh/t8_cmesh.h>
-#include <t8_element.h>
+#include <t8_element/t8_element.h>
 #include <t8_data/t8_containers.h>
 #include <t8_forest/t8_forest_adapt.h>
 #include <t8_forest/t8_forest_general.h>
diff --git a/src/t8_geometry/t8_geometry.h b/src/t8_geometry/t8_geometry.h
index 9f4f6888b0..d0da4659c2 100644
--- a/src/t8_geometry/t8_geometry.h
+++ b/src/t8_geometry/t8_geometry.h
@@ -29,7 +29,7 @@
 #define T8_GEOMETRY_H
 
 #include <t8.h>
-#include <t8_refcount.h>
+#include <t8_helper_functions/t8_refcount.h>
 
 /** This enumeration contains all possible geometries. */
 typedef enum t8_geometry_type {
diff --git a/src/t8_geometry/t8_geometry_hash.hxx b/src/t8_geometry/t8_geometry_hash.hxx
index 68084d87d8..4fc3201f64 100644
--- a/src/t8_geometry/t8_geometry_hash.hxx
+++ b/src/t8_geometry/t8_geometry_hash.hxx
@@ -49,7 +49,7 @@ static const t8_geometry_hash t8_geometry_empty_hash (std::hash<std::string> {}(
 /**
  * Compute the hash value of a geometry's name.
  *  
- * \param [in] name The name of a geoemetry.
+ * \param [in] name The name of a geometry.
  * \return The hash value of \a name.
  * \note \a name being empty here is explicitly allowed and used as hash values for non-existing geometries.
  */
@@ -61,7 +61,7 @@ t8_geometry_compute_hash (const std::string &name)
 }
 
 /**
- * Query whether a given hash value corresponds to en empty string and hence
+ * Query whether a given hash value corresponds to an empty string and hence
  * a non-existing geometry.
  * 
  * \param [in] hash A hash value of a geometry.
diff --git a/src/t8_geometry/t8_geometry_helpers.c b/src/t8_geometry/t8_geometry_helpers.c
index 4fc1e59132..23235bbdf2 100644
--- a/src/t8_geometry/t8_geometry_helpers.c
+++ b/src/t8_geometry/t8_geometry_helpers.c
@@ -25,7 +25,7 @@
  */
 
 #include <t8_types/t8_vec.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <t8_geometry/t8_geometry_helpers.h>
 #include <t8_geometry/t8_geometry_implementations/t8_geometry_cad.h>
 
diff --git a/src/t8_geometry/t8_geometry_implementations/t8_geometry_cad.cxx b/src/t8_geometry/t8_geometry_implementations/t8_geometry_cad.cxx
index 502feb834c..b3fb118ae9 100644
--- a/src/t8_geometry/t8_geometry_implementations/t8_geometry_cad.cxx
+++ b/src/t8_geometry/t8_geometry_implementations/t8_geometry_cad.cxx
@@ -28,9 +28,10 @@
 #include <t8.h>
 #include <t8_geometry/t8_geometry_implementations/t8_geometry_cad.hxx>
 #include <t8_geometry/t8_geometry_implementations/t8_geometry_cad.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <t8_geometry/t8_geometry_helpers.h>
 #include <t8_schemes/t8_default/t8_default_prism/t8_dprism.h>
+#include <t8_cmesh/t8_cmesh_internal/t8_cmesh_types.h>
 
 #include <BRep_Builder.hxx>
 #include <BRep_Tool.hxx>
@@ -56,13 +57,13 @@ const int t8_face_ref_coords_tet[4][2] = { { 2, 1 }, { 0, 1 }, { 0, 1 }, { 0, 2
 
 t8_geometry_cad::t8_geometry_cad (std::string fileprefix, std::string name_in): t8_geometry_with_vertices (name_in)
 {
-  cad_manager = std::make_shared<t8_cad> (fileprefix);
+  cad_handle = std::make_shared<t8_cad_handle> (fileprefix);
 }
 
 t8_geometry_cad::t8_geometry_cad (const TopoDS_Shape cad_shape, std::string name_in)
   : t8_geometry_with_vertices (name_in)
 {
-  cad_manager = std::make_shared<t8_cad> (cad_shape);
+  cad_handle = std::make_shared<t8_cad_handle> (cad_shape);
 }
 
 t8_geometry_cad::t8_geometry_cad (): t8_geometry_with_vertices ("t8_geom_cad")
@@ -226,9 +227,9 @@ t8_geometry_cad::t8_geom_evaluate_cad_tri (t8_cmesh_t cmesh, t8_gloidx_t gtreeid
           t8_geom_linear_interpolation (&ref_intersection[(i_edge == 0) + offset_2d], edge_parameters, 1, 1,
                                         &interpolated_curve_parameter);
           /* Convert the interpolated edge parameter of each reference point to surface parameters */
-          cad_manager->t8_geom_edge_parameter_to_face_parameters (edges[i_edge], *faces, interpolated_curve_parameter,
-                                                                  converted_edge_surface_parameters + offset_2d,
-                                                                  std::span<const double, 2> (face_parameters, 2));
+          cad_handle->edge_parameter_to_face_parameters (edges[i_edge], *faces, interpolated_curve_parameter,
+                                                         converted_edge_surface_parameters + offset_2d,
+                                                         std::span<const double, 2> (face_parameters, 2));
         }
 
         double edge_surface_parameters[4];
@@ -397,9 +398,9 @@ t8_geometry_cad::t8_geom_evaluate_cad_quad (t8_cmesh_t cmesh, t8_gloidx_t gtreei
                                         temp_edge_parameters);
 
           /* Convert curve parameter to surface parameters */
-          cad_manager->t8_geom_edge_parameter_to_face_parameters (edges[i_edge], *faces, temp_edge_parameters[0],
-                                                                  temp_edge_parameters,
-                                                                  std::span<const double, 2> (face_parameters, 2));
+          cad_handle->edge_parameter_to_face_parameters (edges[i_edge], *faces, temp_edge_parameters[0],
+                                                         temp_edge_parameters,
+                                                         std::span<const double, 2> (face_parameters, 2));
 
           /* Interpolate between the surface parameters of the current edge */
           double edge_surface_parameters[4];
@@ -422,7 +423,7 @@ t8_geometry_cad::t8_geom_evaluate_cad_quad (t8_cmesh_t cmesh, t8_gloidx_t gtreei
     }
 
     /* Retrieve surface */
-    auto surface = cad_manager->t8_geom_get_cad_surface (*faces);
+    auto surface = cad_handle->get_cad_surface (*faces);
 
     /* Check if surface is valid */
     T8_ASSERT (!surface.IsNull ());
@@ -480,7 +481,7 @@ t8_geometry_cad::t8_geom_evaluate_cad_quad (t8_cmesh_t cmesh, t8_gloidx_t gtreei
         if (edges[i_edge] > 0) {
 
           /* Retrieve curve */
-          auto curve = cad_manager->t8_geom_get_cad_curve (edges[i_edge]);
+          auto curve = cad_handle->get_cad_curve (edges[i_edge]);
 
           /* Check if curve are valid */
           T8_ASSERT (!curve.IsNull ());
@@ -512,7 +513,7 @@ t8_geometry_cad::t8_geom_evaluate_cad_quad (t8_cmesh_t cmesh, t8_gloidx_t gtreei
         }
         else {
           /* Get surface */
-          auto surface = cad_manager->t8_geom_get_cad_surface (edges[i_edge + num_edges]);
+          auto surface = cad_handle->get_cad_surface (edges[i_edge + num_edges]);
 
           /* Check if surface is valid */
           T8_ASSERT (!surface.IsNull ());
@@ -966,7 +967,7 @@ t8_geometry_cad::t8_geom_evaluate_cad_hex (t8_cmesh_t cmesh, t8_gloidx_t gtreeid
               }
             }
             /* Convert the interpolated parameter of the curve into the corresponding parameters on the surface */
-            cad_manager->t8_geom_edge_parameter_to_face_parameters (
+            cad_handle->edge_parameter_to_face_parameters (
               edges[t8_face_edge_to_tree_edge[T8_ECLASS_HEX][i_faces][i_face_edge]], faces[i_faces],
               interpolated_curve_param, surface_parameters_from_curve,
               std::span<const double, 2> (surface_parameters, 2));
@@ -1278,7 +1279,7 @@ t8_geometry_cad::process_curve (const int curve_index, const double param) const
   gp_Pnt pnt;
 
   /* Retrieve the curve of the edge */
-  const auto curve = cad_manager->t8_geom_get_cad_curve (curve_index);
+  const auto curve = cad_handle->get_cad_curve (curve_index);
 
   /* Check if curve is valid */
   T8_ASSERT (!curve.IsNull ());
@@ -1294,7 +1295,7 @@ t8_geometry_cad::process_surface (const int surface_index, const double *params)
   gp_Pnt pnt;
 
   /* Retrieve the surface of the edge */
-  const auto surface = cad_manager->t8_geom_get_cad_surface (surface_index);
+  const auto surface = cad_handle->get_cad_surface (surface_index);
 
   /* Check if surface is valid */
   T8_ASSERT (!surface.IsNull ());
diff --git a/src/t8_geometry/t8_geometry_implementations/t8_geometry_cad.hxx b/src/t8_geometry/t8_geometry_implementations/t8_geometry_cad.hxx
index d81e1a0454..8e4d15d96a 100644
--- a/src/t8_geometry/t8_geometry_implementations/t8_geometry_cad.hxx
+++ b/src/t8_geometry/t8_geometry_implementations/t8_geometry_cad.hxx
@@ -31,9 +31,8 @@
 
 #include <t8.h>
 #include <t8_geometry/t8_geometry_with_vertices.hxx>
-#include <t8_cmesh/t8_cmesh_internal/t8_cmesh_types.h>
 #include <t8_geometry/t8_geometry_implementations/t8_geometry_cad.h>
-#include <t8_cad/t8_cad.hxx>
+#include <t8_cad/t8_cad_handle.hxx>
 #include <memory>
 #include <TopoDS_Shape.hxx>
 #include <TopExp.hxx>
@@ -147,10 +146,10 @@ struct t8_geometry_cad: public t8_geometry_with_vertices
    * 
    * \return The CAD manager of the geometry.
   */
-  std::shared_ptr<t8_cad>
-  get_cad_manager () const
+  std::shared_ptr<t8_cad_handle>
+  get_cad_handle () const
   {
-    return cad_manager;
+    return cad_handle;
   }
 
  private:
@@ -235,7 +234,7 @@ struct t8_geometry_cad: public t8_geometry_with_vertices
   const int *edges; /**< The linked edges of the currently active tree. */
   const int *faces; /**< The linked faces of the currently active tree. */
 
-  std::shared_ptr<t8_cad> cad_manager; /**< The CAD manager of the geometry. */
+  std::shared_ptr<t8_cad_handle> cad_handle; /**< The CAD handle of the geometry. */
 };
 
 #endif /* !T8_GEOMETRY_CAD_HXX */
diff --git a/src/t8_geometry/t8_geometry_implementations/t8_geometry_lagrange.cxx b/src/t8_geometry/t8_geometry_implementations/t8_geometry_lagrange.cxx
index d0a73b547e..1bc5be6d09 100644
--- a/src/t8_geometry/t8_geometry_implementations/t8_geometry_lagrange.cxx
+++ b/src/t8_geometry/t8_geometry_implementations/t8_geometry_lagrange.cxx
@@ -33,7 +33,7 @@
 #include <t8_cmesh/t8_cmesh_internal/t8_cmesh_types.h>
 #include <t8_geometry/t8_geometry_implementations/t8_geometry_lagrange.hxx>
 #include <t8_geometry/t8_geometry_implementations/t8_geometry_lagrange.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <t8_schemes/t8_default/t8_default.hxx>
 #include <t8_forest/t8_forest_general.h>
 #include <t8_forest/t8_forest_io.h>
diff --git a/src/t8_mat.h b/src/t8_helper_functions/t8_mat.h
similarity index 100%
rename from src/t8_mat.h
rename to src/t8_helper_functions/t8_mat.h
diff --git a/src/t8_refcount.c b/src/t8_helper_functions/t8_refcount.c
similarity index 96%
rename from src/t8_refcount.c
rename to src/t8_helper_functions/t8_refcount.c
index fb61f8171e..6f0deda235 100644
--- a/src/t8_refcount.c
+++ b/src/t8_helper_functions/t8_refcount.c
@@ -24,7 +24,7 @@
  * Implements reference counting functions declared in \ref t8_refcount.h.
  */
 
-#include <t8_refcount.h>
+#include <t8_helper_functions/t8_refcount.h>
 
 void
 t8_refcount_init (t8_refcount_t *rc)
diff --git a/src/t8_refcount.h b/src/t8_helper_functions/t8_refcount.h
similarity index 100%
rename from src/t8_refcount.h
rename to src/t8_helper_functions/t8_refcount.h
diff --git a/src/t8_version.c b/src/t8_misc/t8_version.c
similarity index 97%
rename from src/t8_version.c
rename to src/t8_misc/t8_version.c
index f35589f5a4..0c19db489e 100644
--- a/src/t8_version.c
+++ b/src/t8_misc/t8_version.c
@@ -24,7 +24,7 @@
  * Implements functions declared in \ref t8_version.h.
  */
 
-#include <t8_version.h>
+#include <t8_misc/t8_version.h>
 
 const char *
 t8_get_package_string ()
diff --git a/src/t8_version.h b/src/t8_misc/t8_version.h
similarity index 100%
rename from src/t8_version.h
rename to src/t8_misc/t8_version.h
diff --git a/src/t8_windows.h b/src/t8_misc/t8_windows.h
similarity index 100%
rename from src/t8_windows.h
rename to src/t8_misc/t8_windows.h
diff --git a/src/t8_with_macro_error.h b/src/t8_misc/t8_with_macro_error.h
similarity index 100%
rename from src/t8_with_macro_error.h
rename to src/t8_misc/t8_with_macro_error.h
diff --git a/src/t8_schemes/t8_default/t8_default_c_interface.h b/src/t8_schemes/t8_default/t8_default_c_interface.h
index 0de15119ae..701b830f05 100644
--- a/src/t8_schemes/t8_default/t8_default_c_interface.h
+++ b/src/t8_schemes/t8_default/t8_default_c_interface.h
@@ -27,7 +27,7 @@
 #ifndef T8_DEFAULT_C_INTERFACE_H
 #define T8_DEFAULT_C_INTERFACE_H
 
-#include <t8_element.h>
+#include <t8_element/t8_element.h>
 
 T8_EXTERN_C_BEGIN ();
 
diff --git a/src/t8_schemes/t8_default/t8_default_common/t8_default_common.hxx b/src/t8_schemes/t8_default/t8_default_common/t8_default_common.hxx
index f1f8146ff2..5e3b1a5bac 100644
--- a/src/t8_schemes/t8_default/t8_default_common/t8_default_common.hxx
+++ b/src/t8_schemes/t8_default/t8_default_common/t8_default_common.hxx
@@ -27,7 +27,7 @@
 #ifndef T8_DEFAULT_COMMON_HXX
 #define T8_DEFAULT_COMMON_HXX
 
-#include <t8_element.h>
+#include <t8_element/t8_element.h>
 #include <t8_types/t8_operators.hxx>
 #include <t8_schemes/t8_scheme_helpers.hxx>
 #include <sc_functions.h>
@@ -191,6 +191,40 @@ struct t8_default_scheme_common: public t8_scheme_helpers<TEclass, TUnderlyingEc
     return t8_eclass_max_num_children[TEclass];
   }
 
+  /** Query whether element A is an ancestor of the element B.
+   * An element A is ancestor of an element B if A == B or if B can 
+   * be obtained from A via successive refinement.
+   * \param [in] element_A An element of class \a eclass in scheme \a scheme.
+   * \param [in] element_B An element of class \a eclass in scheme \a scheme.
+   * \return     True if and only if \a element_A is an ancestor of \a element_B.
+  */
+  inline bool
+  element_is_ancestor (const t8_element_t *element_A, const t8_element_t *element_B) const
+  {
+    /* A is ancestor of B if and only if it has smaller or equal level and
+      restricted to A's level, B has the same id as A.
+
+        level(A) <= level(B) and ID(A,level(A)) == ID(B,level(B))
+    */
+    T8_ASSERT (this->underlying ().element_is_valid (element_A));
+    T8_ASSERT (this->underlying ().element_is_valid (element_B));
+
+    const int level_A = this->underlying ().element_get_level (element_A);
+    const int level_B = this->underlying ().element_get_level (element_B);
+
+    if (level_A > level_B) {
+      /* element A is finer than element B and thus cannot be 
+      * an ancestor of B. */
+      return false;
+    }
+
+    const t8_linearidx_t id_A = this->underlying ().element_get_linear_id (element_A, level_A);
+    const t8_linearidx_t id_B = this->underlying ().element_get_linear_id (element_B, level_A);
+
+    // If both elements have the same linear ID at level_A then A is an ancestor of B.
+    return id_A == id_B;
+  }
+
   /** Allocate space for a bunch of elements.
    * \param [in] length The number of elements to allocate.
    * \param [out] elem  The elements to allocate.
diff --git a/src/t8_schemes/t8_default/t8_default_hex/t8_default_hex.hxx b/src/t8_schemes/t8_default/t8_default_hex/t8_default_hex.hxx
index 9c6052012c..c24f60b53b 100644
--- a/src/t8_schemes/t8_default/t8_default_hex/t8_default_hex.hxx
+++ b/src/t8_schemes/t8_default/t8_default_hex/t8_default_hex.hxx
@@ -27,7 +27,7 @@
 #define T8_DEFAULT_HEX_HXX
 
 #include <p8est.h>
-#include <t8_element.h>
+#include <t8_element/t8_element.h>
 #include <t8_schemes/t8_default/t8_default_hex/t8_dhex.h>
 #include <t8_schemes/t8_default/t8_default_hex/t8_dhex_bits.h>
 #include <t8_schemes/t8_default/t8_default_quad/t8_default_quad.hxx>
diff --git a/src/t8_schemes/t8_default/t8_default_hex/t8_dhex_bits.h b/src/t8_schemes/t8_default/t8_default_hex/t8_dhex_bits.h
index 92c5ec8cec..476313f1c1 100644
--- a/src/t8_schemes/t8_default/t8_default_hex/t8_dhex_bits.h
+++ b/src/t8_schemes/t8_default/t8_default_hex/t8_dhex_bits.h
@@ -27,7 +27,7 @@
 #ifndef T8_DHEX_BITS_H
 #define T8_DHEX_BITS_H
 
-#include <t8_element.h>
+#include <t8_element/t8_element.h>
 #include <t8_schemes/t8_default/t8_default_hex/t8_dhex.h>
 
 T8_EXTERN_C_BEGIN ();
diff --git a/src/t8_schemes/t8_default/t8_default_line/t8_default_line.hxx b/src/t8_schemes/t8_default/t8_default_line/t8_default_line.hxx
index 8732d7e542..26122929e5 100644
--- a/src/t8_schemes/t8_default/t8_default_line/t8_default_line.hxx
+++ b/src/t8_schemes/t8_default/t8_default_line/t8_default_line.hxx
@@ -29,7 +29,7 @@
 #ifndef T8_DEFAULT_LINES_HXX
 #define T8_DEFAULT_LINES_HXX
 
-#include <t8_element.h>
+#include <t8_element/t8_element.h>
 #include <t8_schemes/t8_default/t8_default_common/t8_default_common.hxx>
 #include <t8_schemes/t8_default/t8_default_line/t8_dline_bits.h>
 
diff --git a/src/t8_schemes/t8_default/t8_default_line/t8_dline_bits.h b/src/t8_schemes/t8_default/t8_default_line/t8_dline_bits.h
index d2da50557d..f7dbeef411 100644
--- a/src/t8_schemes/t8_default/t8_default_line/t8_dline_bits.h
+++ b/src/t8_schemes/t8_default/t8_default_line/t8_dline_bits.h
@@ -27,7 +27,7 @@
 #ifndef T8_DLINE_BITS_H
 #define T8_DLINE_BITS_H
 
-#include <t8_element.h>
+#include <t8_element/t8_element.h>
 #include <t8_schemes/t8_default/t8_default_line/t8_dline.h>
 #include <t8_schemes/t8_default/t8_default_vertex/t8_dvertex.h>
 
diff --git a/src/t8_schemes/t8_default/t8_default_prism/t8_default_prism.hxx b/src/t8_schemes/t8_default/t8_default_prism/t8_default_prism.hxx
index f07417b7b8..e7079f3cb3 100644
--- a/src/t8_schemes/t8_default/t8_default_prism/t8_default_prism.hxx
+++ b/src/t8_schemes/t8_default/t8_default_prism/t8_default_prism.hxx
@@ -29,7 +29,7 @@
 #ifndef T8_DEFAULT_PRISM_HXX
 #define T8_DEFAULT_PRISM_HXX
 
-#include <t8_element.h>
+#include <t8_element/t8_element.h>
 #include <t8_schemes/t8_default/t8_default_line/t8_default_line.hxx>
 #include <t8_schemes/t8_default/t8_default_tri/t8_default_tri.hxx>
 #include <t8_schemes/t8_default/t8_default_common/t8_default_common.hxx>
diff --git a/src/t8_schemes/t8_default/t8_default_prism/t8_dprism_bits.h b/src/t8_schemes/t8_default/t8_default_prism/t8_dprism_bits.h
index 60726cf5d2..24a19f7e8d 100644
--- a/src/t8_schemes/t8_default/t8_default_prism/t8_dprism_bits.h
+++ b/src/t8_schemes/t8_default/t8_default_prism/t8_dprism_bits.h
@@ -27,7 +27,7 @@
 #ifndef T8_DPRISM_BITS_H
 #define T8_DPRISM_BITS_H
 
-#include <t8_element.h>
+#include <t8_element/t8_element.h>
 #include <t8_schemes/t8_default/t8_default_prism/t8_dprism.h>
 
 T8_EXTERN_C_BEGIN ();
diff --git a/src/t8_schemes/t8_default/t8_default_pyramid/t8_default_pyramid.hxx b/src/t8_schemes/t8_default/t8_default_pyramid/t8_default_pyramid.hxx
index b60b9015ec..f8d81486a8 100644
--- a/src/t8_schemes/t8_default/t8_default_pyramid/t8_default_pyramid.hxx
+++ b/src/t8_schemes/t8_default/t8_default_pyramid/t8_default_pyramid.hxx
@@ -29,7 +29,7 @@
 #ifndef T8_DEFAULT_PYRAMID_HXX
 #define T8_DEFAULT_PYRAMID_HXX
 
-#include <t8_element.h>
+#include <t8_element/t8_element.h>
 #include <t8_schemes/t8_default/t8_default_common/t8_default_common.hxx>
 #include <t8_schemes/t8_default/t8_default_pyramid/t8_dpyramid_bits.h>
 
diff --git a/src/t8_schemes/t8_default/t8_default_pyramid/t8_dpyramid_bits.h b/src/t8_schemes/t8_default/t8_default_pyramid/t8_dpyramid_bits.h
index 411355bbff..61251e1557 100644
--- a/src/t8_schemes/t8_default/t8_default_pyramid/t8_dpyramid_bits.h
+++ b/src/t8_schemes/t8_default/t8_default_pyramid/t8_dpyramid_bits.h
@@ -27,7 +27,7 @@
 #ifndef T8_DPYRAMID_BITS_H
 #define T8_DPYRAMID_BITS_H
 
-#include "t8_element.h"
+#include <t8_element/t8_element.h>
 #include "t8_dpyramid.h"
 
 T8_EXTERN_C_BEGIN ();
diff --git a/src/t8_schemes/t8_default/t8_default_quad/t8_default_quad.hxx b/src/t8_schemes/t8_default/t8_default_quad/t8_default_quad.hxx
index a9f199ee9f..a6e107417c 100644
--- a/src/t8_schemes/t8_default/t8_default_quad/t8_default_quad.hxx
+++ b/src/t8_schemes/t8_default/t8_default_quad/t8_default_quad.hxx
@@ -32,7 +32,7 @@
 #define T8_DEFAULT_QUAD_HXX
 
 #include <p4est.h>
-#include <t8_element.h>
+#include <t8_element/t8_element.h>
 #include <t8_schemes/t8_default/t8_default_line/t8_default_line.hxx>
 #include <t8_schemes/t8_default/t8_default_common/t8_default_common.hxx>
 
diff --git a/src/t8_schemes/t8_default/t8_default_quad/t8_default_quad_bits.hxx b/src/t8_schemes/t8_default/t8_default_quad/t8_default_quad_bits.hxx
index b51c4bebbf..7f63f0813e 100644
--- a/src/t8_schemes/t8_default/t8_default_quad/t8_default_quad_bits.hxx
+++ b/src/t8_schemes/t8_default/t8_default_quad/t8_default_quad_bits.hxx
@@ -27,7 +27,7 @@
 #ifndef T8_DQUAD_BITS_H
 #define T8_DQUAD_BITS_H
 
-#include <t8_element.h>
+#include <t8_element/t8_element.h>
 #include <t8_schemes/t8_default/t8_default_quad/t8_default_quad.hxx>
 
 T8_EXTERN_C_BEGIN ();
diff --git a/src/t8_schemes/t8_default/t8_default_tet/t8_default_tet.hxx b/src/t8_schemes/t8_default/t8_default_tet/t8_default_tet.hxx
index e5223e7261..cde4d5fdbd 100644
--- a/src/t8_schemes/t8_default/t8_default_tet/t8_default_tet.hxx
+++ b/src/t8_schemes/t8_default/t8_default_tet/t8_default_tet.hxx
@@ -29,7 +29,7 @@
 #ifndef T8_DEFAULT_TET_HXX
 #define T8_DEFAULT_TET_HXX
 
-#include <t8_element.h>
+#include <t8_element/t8_element.h>
 #include <t8_schemes/t8_default/t8_default_tri/t8_default_tri.hxx>
 #include <t8_schemes/t8_default/t8_default_common/t8_default_common.hxx>
 #include <t8_schemes/t8_default/t8_default_tet/t8_dtet_bits.h>
diff --git a/src/t8_schemes/t8_default/t8_default_tet/t8_dtet_bits.h b/src/t8_schemes/t8_default/t8_default_tet/t8_dtet_bits.h
index 6a707982ac..b5b8e84ecd 100644
--- a/src/t8_schemes/t8_default/t8_default_tet/t8_dtet_bits.h
+++ b/src/t8_schemes/t8_default/t8_default_tet/t8_dtet_bits.h
@@ -30,7 +30,7 @@
 #ifndef T8_DTET_BITS_H
 #define T8_DTET_BITS_H
 
-#include <t8_element.h>
+#include <t8_element/t8_element.h>
 #include <t8_schemes/t8_default/t8_default_tet/t8_dtet.h>
 
 T8_EXTERN_C_BEGIN ();
diff --git a/src/t8_schemes/t8_default/t8_default_tet/t8_dtet_connectivity.h b/src/t8_schemes/t8_default/t8_default_tet/t8_dtet_connectivity.h
index 9a203dc9b6..dfac92ba99 100644
--- a/src/t8_schemes/t8_default/t8_default_tet/t8_dtet_connectivity.h
+++ b/src/t8_schemes/t8_default/t8_default_tet/t8_dtet_connectivity.h
@@ -28,7 +28,7 @@
 #define T8_DTET_CONNECTIVITY_H
 
 #include <t8.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 
 T8_EXTERN_C_BEGIN ();
 
diff --git a/src/t8_schemes/t8_default/t8_default_tri/t8_default_tri.hxx b/src/t8_schemes/t8_default/t8_default_tri/t8_default_tri.hxx
index cb346c612f..5181ab6fe0 100644
--- a/src/t8_schemes/t8_default/t8_default_tri/t8_default_tri.hxx
+++ b/src/t8_schemes/t8_default/t8_default_tri/t8_default_tri.hxx
@@ -29,7 +29,7 @@
 #ifndef T8_DEFAULT_TRI_HXX
 #define T8_DEFAULT_TRI_HXX
 
-#include <t8_element.h>
+#include <t8_element/t8_element.h>
 #include <t8_schemes/t8_default/t8_default_line/t8_default_line.hxx>
 #include <t8_schemes/t8_default/t8_default_common/t8_default_common.hxx>
 #include <t8_schemes/t8_default/t8_default_tri/t8_dtri_bits.h>
diff --git a/src/t8_schemes/t8_default/t8_default_tri/t8_dtri_bits.h b/src/t8_schemes/t8_default/t8_default_tri/t8_dtri_bits.h
index da3296991c..fa6f5b2f0b 100644
--- a/src/t8_schemes/t8_default/t8_default_tri/t8_dtri_bits.h
+++ b/src/t8_schemes/t8_default/t8_default_tri/t8_dtri_bits.h
@@ -27,7 +27,7 @@
 #ifndef T8_DTRI_BITS_H
 #define T8_DTRI_BITS_H
 
-#include <t8_element.h>
+#include <t8_element/t8_element.h>
 #include <t8_schemes/t8_default/t8_default_tri/t8_dtri.h>
 
 T8_EXTERN_C_BEGIN ();
diff --git a/src/t8_schemes/t8_default/t8_default_tri/t8_dtri_connectivity.h b/src/t8_schemes/t8_default/t8_default_tri/t8_dtri_connectivity.h
index 06182dda1e..5961ce5194 100644
--- a/src/t8_schemes/t8_default/t8_default_tri/t8_dtri_connectivity.h
+++ b/src/t8_schemes/t8_default/t8_default_tri/t8_dtri_connectivity.h
@@ -27,7 +27,7 @@
 #define T8_DTRI_CONNECTIVITY_H
 
 #include <t8_schemes/t8_default/t8_default_tri/t8_dtri.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 
 T8_EXTERN_C_BEGIN ();
 
diff --git a/src/t8_schemes/t8_default/t8_default_vertex/t8_default_vertex.hxx b/src/t8_schemes/t8_default/t8_default_vertex/t8_default_vertex.hxx
index 987d993b40..894c7a5b66 100644
--- a/src/t8_schemes/t8_default/t8_default_vertex/t8_default_vertex.hxx
+++ b/src/t8_schemes/t8_default/t8_default_vertex/t8_default_vertex.hxx
@@ -27,7 +27,7 @@
 #ifndef T8_DEFAULT_VERTEX_HXX
 #define T8_DEFAULT_VERTEX_HXX
 
-#include <t8_element.h>
+#include <t8_element/t8_element.h>
 #include <t8_schemes/t8_default/t8_default_tri/t8_default_tri.hxx>
 #include <t8_schemes/t8_default/t8_default_common/t8_default_common.hxx>
 
diff --git a/src/t8_schemes/t8_scheme.cxx b/src/t8_schemes/t8_scheme.cxx
index 6f909ff635..d4a92da3c6 100644
--- a/src/t8_schemes/t8_scheme.cxx
+++ b/src/t8_schemes/t8_scheme.cxx
@@ -24,7 +24,7 @@
  * Implements functions declared in \ref t8_scheme.h.
  */
 
-#include <t8_element.h>
+#include <t8_element/t8_element.h>
 #include <t8_schemes/t8_scheme.hxx>
 #include <t8_schemes/t8_scheme.h>
 #include <t8_forest/t8_forest_types.h>
diff --git a/src/t8_schemes/t8_scheme.h b/src/t8_schemes/t8_scheme.h
index 3b36bc4f4a..0c3d16ef49 100644
--- a/src/t8_schemes/t8_scheme.h
+++ b/src/t8_schemes/t8_scheme.h
@@ -29,7 +29,7 @@
 #define T8_SCHEME_H
 
 #include <t8.h>
-#include <t8_element.h>
+#include <t8_element/t8_element.h>
 
 /** The scheme holds implementations for one or more element classes.
  *  Opaque pointer for C interface.
diff --git a/src/t8_schemes/t8_scheme.hxx b/src/t8_schemes/t8_scheme.hxx
index fd398584a7..fdaf9510c4 100644
--- a/src/t8_schemes/t8_scheme.hxx
+++ b/src/t8_schemes/t8_scheme.hxx
@@ -30,8 +30,8 @@
 
 #include <variant>
 #include <vector>
-#include <t8_refcount.h>
-#include <t8_eclass.h>
+#include <t8_helper_functions/t8_refcount.h>
+#include <t8_eclass/t8_eclass.h>
 #include <t8_schemes/t8_default/t8_default.hxx>
 #include <t8_schemes/t8_default/t8_default_vertex/t8_default_vertex.hxx>
 #include <t8_schemes/t8_default/t8_default_line/t8_default_line.hxx>
@@ -509,6 +509,21 @@ struct t8_scheme
                        eclass_schemes[tree_class]);
   };
 
+  /** Query whether element A is an ancestor of the element B.
+   * An element A is ancestor of an element B if A == B or if B can 
+   * be obtained from A via successive refinement.
+   * \param [in] tree_class The eclass of the current tree.
+   * \param [in] element_A An element of class \a eclass in scheme \a scheme.
+   * \param [in] element_B An element of class \a eclass in scheme \a scheme.
+   * \return     True if and only if \a element_A is an ancestor of \a element_B.
+  */
+  bool
+  element_is_ancestor (const t8_eclass_t tree_class, const t8_element_t *element_A, const t8_element_t *element_B) const
+  {
+    return std::visit ([&] (auto &&scheme) { return scheme.element_is_ancestor (element_A, element_B); },
+                       eclass_schemes[tree_class]);
+  }
+
   /** Query whether a given set of elements is a family or not.
    * \param [in] tree_class    The eclass of the current tree.
    * \param [in] fam      An array of as many elements as an element of class
@@ -537,8 +552,9 @@ struct t8_scheme
   element_get_nca (const t8_eclass_t tree_class, const t8_element_t *elem1, const t8_element_t *elem2,
                    t8_element_t *const nca) const
   {
-    return std::visit ([&] (auto &&scheme) { return scheme.element_get_nca (elem1, elem2, nca); },
-                       eclass_schemes[tree_class]);
+    std::visit ([&] (auto &&scheme) { return scheme.element_get_nca (elem1, elem2, nca); }, eclass_schemes[tree_class]);
+    T8_ASSERT (element_is_ancestor (tree_class, nca, elem1));
+    T8_ASSERT (element_is_ancestor (tree_class, nca, elem2));
   };
 
   /** Compute the shape of the face of an element.
diff --git a/src/t8_schemes/t8_scheme_helpers.hxx b/src/t8_schemes/t8_scheme_helpers.hxx
index 4bcfc652c6..87bbc6e56e 100644
--- a/src/t8_schemes/t8_scheme_helpers.hxx
+++ b/src/t8_schemes/t8_scheme_helpers.hxx
@@ -27,9 +27,9 @@
 #ifndef T8_SCHEME_HELPERS_HXX
 #define T8_SCHEME_HELPERS_HXX
 
-#include <t8_element.h>
+#include <t8_element/t8_element.h>
 #include <t8_types/t8_crtp.hxx>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 
 /**
   * Class which provides helper functions and default implementations for different schemes.
diff --git a/src/t8_schemes/t8_standalone/t8_standalone_implementation.hxx b/src/t8_schemes/t8_standalone/t8_standalone_implementation.hxx
index 5338e72625..c11e37cc3a 100644
--- a/src/t8_schemes/t8_standalone/t8_standalone_implementation.hxx
+++ b/src/t8_schemes/t8_standalone/t8_standalone_implementation.hxx
@@ -28,7 +28,7 @@
 #define T8_STANDALONE_IMPLEMENTATION_HXX
 
 #include <t8_schemes/t8_scheme.hxx>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <sc_functions.h>
 #include <t8_schemes/t8_standalone/t8_standalone_elements.hxx>
 #include <t8_schemes/t8_scheme_helpers.hxx>
@@ -608,6 +608,54 @@ struct t8_standalone_scheme: public t8_scheme_helpers<TEclass, t8_standalone_sch
     return 1;
   }
 
+  // Note to devs: element_is_ancestor currently cannot be static
+  //               since it uses the non-static function element_new
+  /** Query whether element A is an ancestor of the element B.
+   * An element A is ancestor of an element B if A == B or if B can 
+   * be obtained from A via successive refinement.
+   * \param [in] element_A An element of class \a eclass in scheme \a scheme.
+   * \param [in] element_B An element of class \a eclass in scheme \a scheme.
+   * \return     True if and only if \a element_A is an ancestor of \a element_B.
+  */
+  bool
+  element_is_ancestor (const t8_element_t *element_A, const t8_element_t *element_B) const noexcept
+  {
+    /* We compute whether A is an ancestor of B by
+    
+     - If level(A) > level(B) then A cannot be an ancestor.
+     - Otherwise compute the ancestor of B at level(A)
+     - Compare the computed ancestor with A.
+    */
+    T8_ASSERT (element_is_valid (element_A));
+    T8_ASSERT (element_is_valid (element_B));
+
+    const t8_standalone_element<TEclass> *el_B = (const t8_standalone_element<TEclass> *) element_B;
+
+    const int level_A = element_get_level (element_A);
+    const int level_B = element_get_level (element_B);
+
+    if (level_A > level_B) {
+      // A is finer than B and thus cannot be an ancestor.
+      return false;
+    }
+
+    // Compute the ancestor of B at level_A and compare it with A
+    t8_element_t *ancestor;
+    element_new (1, &ancestor);
+
+    t8_standalone_element<TEclass> *ancestor_casted = (t8_standalone_element<TEclass> *) ancestor;
+
+    element_get_ancestor (el_B, level_A, ancestor_casted);
+
+    const bool is_ancestor = element_is_equal (ancestor, element_A);
+
+    element_destroy (1, &ancestor);
+
+    // Return true if A == ancestor
+    // Return false if A != ancestor
+    return is_ancestor;
+  }
+
   /** Compute the nearest common ancestor of two elements. That is,
    * the element with highest level that still has both given elements as
    * descendants.
diff --git a/src/t8_vtk.c b/src/t8_vtk/t8_vtk.c
similarity index 99%
rename from src/t8_vtk.c
rename to src/t8_vtk/t8_vtk.c
index f4602932c7..3a9480b080 100644
--- a/src/t8_vtk.c
+++ b/src/t8_vtk/t8_vtk.c
@@ -20,7 +20,7 @@
   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */
 
-#include <t8_vtk.h>
+#include <t8_vtk/t8_vtk.h>
 
 /* Writes the pvtu header file that links to the processor local files.
  * This function should only be called by one process.
diff --git a/src/t8_vtk.h b/src/t8_vtk/t8_vtk.h
similarity index 100%
rename from src/t8_vtk.h
rename to src/t8_vtk/t8_vtk.h
diff --git a/src/t8_vtk/t8_vtk_types.h b/src/t8_vtk/t8_vtk_types.h
index 429f0af1bb..9e8ede013f 100644
--- a/src/t8_vtk/t8_vtk_types.h
+++ b/src/t8_vtk/t8_vtk_types.h
@@ -28,7 +28,7 @@
 #ifndef T8_VTK_TYPES
 #define T8_VTK_TYPES
 
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 
 /**
  * Translator between vtk-type of elements and t8code-elements. 
diff --git a/src/t8_vtk/t8_vtk_write_ASCII.cxx b/src/t8_vtk/t8_vtk_write_ASCII.cxx
index 14f02d8da5..c088904948 100644
--- a/src/t8_vtk/t8_vtk_write_ASCII.cxx
+++ b/src/t8_vtk/t8_vtk_write_ASCII.cxx
@@ -22,7 +22,7 @@
 
 #include "t8_vtk/t8_vtk_write_ASCII.hxx"
 #include "t8_vtk/t8_vtk_writer_helper.hxx"
-#include <t8_vtk.h>
+#include <t8_vtk/t8_vtk.h>
 #include <t8_forest/t8_forest_ghost.h>
 #include <t8_types/t8_vec.hxx>
 #include "t8_forest/t8_forest_types.h"
diff --git a/src/t8_vtk/t8_vtk_writer.h b/src/t8_vtk/t8_vtk_writer.h
index 0383c2fa6a..4a0ad19e3d 100644
--- a/src/t8_vtk/t8_vtk_writer.h
+++ b/src/t8_vtk/t8_vtk_writer.h
@@ -29,7 +29,7 @@
 #define T8_VTK_WRITER_C_INTERFACE_H
 
 #include <t8.h>
-#include <t8_vtk.h>
+#include <t8_vtk/t8_vtk.h>
 #include <t8_forest/t8_forest_types.h>
 
 #if T8_ENABLE_VTK
diff --git a/src/t8_vtk/t8_vtk_writer.hxx b/src/t8_vtk/t8_vtk_writer.hxx
index aae073b48a..d4c3355a4e 100644
--- a/src/t8_vtk/t8_vtk_writer.hxx
+++ b/src/t8_vtk/t8_vtk_writer.hxx
@@ -38,7 +38,7 @@
 #include "t8_vtk/t8_vtk_write_ASCII.hxx"
 
 #include <string>
-#include <t8_vtk.h>
+#include <t8_vtk/t8_vtk.h>
 #include <t8_types/t8_vec.hxx>
 
 #if T8_ENABLE_VTK
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 1684edd7b9..a8c6c3ac06 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -38,6 +38,8 @@ function( add_t8_test )
 
     # Link base libraries.
     target_include_directories( ${ADD_T8_TEST_NAME} PRIVATE ${CMAKE_SOURCE_DIR} )
+    # Include binary dir to find generated headers like t8_test_data_dir.h.
+    target_include_directories( ${ADD_T8_TEST_NAME} PRIVATE ${CMAKE_CURRENT_BINARY_DIR} )
 
     target_link_libraries( ${ADD_T8_TEST_NAME} PRIVATE GTest::gtest_main T8 pthread )
 
@@ -99,10 +101,16 @@ function ( add_t8_cpp_test)
     add_t8_test( NAME ${ADD_T8_CPP_TEST_NAME} SOURCES ${ADD_T8_CPP_TEST_SOURCES} )
 endfunction()
 
-# Copy test files to build folder so that the t8_test programs can find them.
-function( copy_test_file TEST_FILE_NAME )
-    configure_file(${CMAKE_CURRENT_LIST_DIR}/testfiles/${TEST_FILE_NAME} ${CMAKE_CURRENT_BINARY_DIR}/testfiles/${TEST_FILE_NAME} COPYONLY)
-endfunction()
+# Set absolute path to test data in the source tree
+file( TO_CMAKE_PATH
+  "${CMAKE_CURRENT_LIST_DIR}/testfiles"
+  T8_TEST_DATA_DIR
+)
+configure_file(
+  ${CMAKE_CURRENT_LIST_DIR}/t8_test_data_dir.h.in
+  ${CMAKE_CURRENT_BINARY_DIR}/t8_test_data_dir.h
+  @ONLY
+)
 
 add_t8_cpp_test( NAME t8_gtest_cmesh_bcast_parallel     SOURCES t8_cmesh/t8_gtest_bcast.cxx )
 add_t8_cpp_test( NAME t8_gtest_eclass_serial            SOURCES t8_gtest_eclass.cxx )
@@ -135,6 +143,7 @@ add_t8_cpp_test( NAME t8_gtest_cmesh_bounding_box_serial                    SOUR
 add_t8_cpp_test( NAME t8_gtest_shmem_parallel  SOURCES t8_data/t8_gtest_shmem.cxx )
 add_t8_cpp_test( NAME t8_gtest_data_pack_parallel       SOURCES t8_data/t8_gtest_data_handler.cxx t8_data/t8_data_handler_specs.cxx)
 
+add_t8_cpp_test( NAME t8_gtest_bin_search_parallel                SOURCES t8_forest/t8_gtest_bin_search.cxx t8_gtest_adapt_callbacks.cxx )
 add_t8_cpp_test( NAME t8_gtest_element_volume_serial              SOURCES t8_forest/t8_gtest_element_volume.cxx )
 add_t8_cpp_test( NAME t8_gtest_search_parallel                    SOURCES t8_forest/t8_gtest_search.cxx )
 add_t8_cpp_test( NAME t8_gtest_half_neighbors_parallel            SOURCES t8_forest/t8_gtest_half_neighbors.cxx )
@@ -147,12 +156,12 @@ add_t8_cpp_test( NAME t8_gtest_ghost_and_owner_parallel           SOURCES t8_for
 add_t8_cpp_test( NAME t8_gtest_balance_parallel                   SOURCES t8_forest/t8_gtest_balance.cxx )
 add_t8_cpp_test( NAME t8_gtest_forest_commit_parallel             SOURCES t8_forest/t8_gtest_forest_commit.cxx )
 add_t8_cpp_test( NAME t8_gtest_forest_face_normal_serial          SOURCES t8_forest/t8_gtest_forest_face_normal.cxx )
-add_t8_cpp_test( NAME t8_gtest_element_is_leaf_serial             SOURCES t8_forest/t8_gtest_element_is_leaf.cxx )
 add_t8_cpp_test( NAME t8_gtest_partition_data_parallel            SOURCES t8_forest/t8_gtest_partition_data.cxx )
 add_t8_cpp_test( NAME t8_gtest_set_partition_offset_parallel      SOURCES t8_forest/t8_gtest_set_partition_offset.cxx )
 add_t8_cpp_test( NAME t8_gtest_partition_for_coarsening_parallel  SOURCES t8_forest/t8_gtest_partition_for_coarsening.cxx )
 add_t8_cpp_test( NAME t8_gtest_weighted_partitioning_parallel     SOURCES t8_forest/t8_gtest_weighted_partitioning.cxx )
 
+add_t8_cpp_test( NAME t8_gtest_element_is_leaf_parallel     SOURCES t8_forest/t8_gtest_element_is_leaf.cxx t8_gtest_adapt_callbacks.cxx )
 add_t8_cpp_test( NAME t8_gtest_permute_hole_serial          SOURCES t8_forest_incomplete/t8_gtest_permute_hole.cxx )
 add_t8_cpp_test( NAME t8_gtest_recursive_serial             SOURCES t8_forest_incomplete/t8_gtest_recursive.cxx )
 add_t8_cpp_test( NAME t8_gtest_iterate_replace_parallel     SOURCES t8_forest_incomplete/t8_gtest_iterate_replace.cxx )
@@ -182,6 +191,7 @@ add_t8_cpp_test( NAME t8_gtest_pyra_connectivity_serial     SOURCES t8_schemes/t
 add_t8_cpp_test( NAME t8_gtest_face_neigh_serial            SOURCES t8_schemes/t8_gtest_face_neigh.cxx )
 add_t8_cpp_test( NAME t8_gtest_get_linear_id_serial         SOURCES t8_schemes/t8_gtest_get_linear_id.cxx )
 add_t8_cpp_test( NAME t8_gtest_ancestor_serial              SOURCES t8_schemes/t8_gtest_ancestor.cxx )
+add_t8_cpp_test( NAME t8_gtest_is_ancestor_serial              SOURCES t8_schemes/t8_gtest_is_ancestor.cxx )
 add_t8_cpp_test( NAME t8_gtest_ancestor_id_serial           SOURCES t8_schemes/t8_gtest_ancestor_id.cxx )
 add_t8_cpp_test( NAME t8_gtest_element_count_leaves_serial  SOURCES t8_schemes/t8_gtest_element_count_leaves.cxx )
 add_t8_cpp_test( NAME t8_gtest_element_ref_coords_serial    SOURCES t8_schemes/t8_gtest_element_ref_coords.cxx )
@@ -210,24 +220,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_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 )
-  add_t8_cpp_test( NAME t8_gtest_handle_data_parallel             SOURCES mesh_handle/t8_gtest_handle_data.cxx )
-  add_t8_cpp_test( NAME t8_gtest_handle_adapt_serial             SOURCES mesh_handle/t8_gtest_adapt.cxx )
+  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 )
+  add_t8_cpp_test( NAME t8_gtest_handle_data_parallel               SOURCES mesh_handle/t8_gtest_handle_data.cxx )
+  add_t8_cpp_test( NAME t8_gtest_adapt_partition_balance_parallel   SOURCES mesh_handle/t8_gtest_adapt_partition_balance.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 )
-copy_test_file( test_vtk_cube.vtp )
-copy_test_file( test_parallel_file.pvtu )
-copy_test_file( test_parallel_file_0.vtu )
-copy_test_file( test_parallel_file_1.vtu )
-copy_test_file( test_polydata.pvtp )
-copy_test_file( test_polydata_0.vtp )
-copy_test_file( test_polydata_1.vtp )
-copy_test_file( test_msh_file_vers4_ascii.msh )
-copy_test_file( test_msh_file_vers4_bin.msh )
diff --git a/test/mesh_handle/t8_gtest_adapt.cxx b/test/mesh_handle/t8_gtest_adapt_partition_balance.cxx
similarity index 72%
rename from test/mesh_handle/t8_gtest_adapt.cxx
rename to test/mesh_handle/t8_gtest_adapt_partition_balance.cxx
index d3ef723504..df460cd05a 100644
--- a/test/mesh_handle/t8_gtest_adapt.cxx
+++ b/test/mesh_handle/t8_gtest_adapt_partition_balance.cxx
@@ -21,11 +21,13 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 */
 
 /**
- * \file t8_gtest_adapt.cxx
- * Tests for the adapt routines of mesh handles. 
- * This tests uses the callback and user data of tutorial step 3 as example.
+ * \file t8_gtest_adapt_partition_balance.cxx
+ * Tests for the adapt, partition and balance routines of mesh handles. 
+ * For the adapt routine, we use the callback and user data of tutorial step 3 as example.
  * The adaptation criterion is to look at the midpoint coordinates of the current element and if
  * they are inside a sphere around a given midpoint we refine, if they are outside, we coarsen. 
+ * The test compares the results of the mesh handle to a forest adapted with the same criterion and balanced and partitioned similarly.
+ * Therefore, the check is based on the assumption that the forest functionality works as intended and is tested elsewhere.
  */
 #include <gtest/gtest.h>
 #include <t8.h>
@@ -33,6 +35,7 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 #include <mesh_handle/mesh.hxx>
 #include <mesh_handle/competence_pack.hxx>
 #include <mesh_handle/adapt.hxx>
+#include <mesh_handle/data_handler.hxx>
 #include <t8_cmesh/t8_cmesh.h>
 #include <t8_cmesh/t8_cmesh_examples.h>
 #include <t8_forest/t8_forest_general.h>
@@ -98,8 +101,9 @@ forest_adapt_callback_example (t8_forest_t forest, t8_forest_t forest_from, t8_l
   return 0;
 }
 
-/** Test the adapt routine of a mesh handle. 
- * We compare the result to a classically adapted forest with similar callback.
+/** Test the adapt partition and balance routine of a mesh handle. 
+ * The test compares the results of the mesh handle to a forest adapted with the same criterion and balanced and partitioned similarly.
+ * Therefore, the check is based on the assumption that the forest functionality works as intended and is tested elsewhere.
  */
 TEST (t8_gtest_handle_adapt, compare_adapt_with_forest)
 {
@@ -108,7 +112,9 @@ TEST (t8_gtest_handle_adapt, compare_adapt_with_forest)
   t8_cmesh_t cmesh = t8_cmesh_new_hypercube_hybrid (sc_MPI_COMM_WORLD, 0, 0);
   const t8_scheme *init_scheme = t8_scheme_new_default ();
   t8_forest_t forest = t8_forest_new_uniform (cmesh, init_scheme, level, 0, sc_MPI_COMM_WORLD);
-  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<>, dummy_user_data>;
+  using mesh_class = t8_mesh_handle::mesh<
+    t8_mesh_handle::element_competence_pack<t8_mesh_handle::access_element_data>,
+    t8_mesh_handle::mesh_competence_pack<t8_mesh_handle::element_data_competence<dummy_user_data>::template type>>;
   mesh_class mesh_handle = mesh_class (forest);
   struct dummy_user_data user_data = {
     t8_3D_vec ({ 0.5, 0.5, 1 }), /**< Midpoints of the sphere. */
@@ -124,11 +130,29 @@ TEST (t8_gtest_handle_adapt, compare_adapt_with_forest)
     mesh_class::mesh_adapt_callback_wrapper<dummy_user_data> (adapt_callback_test<mesh_class>, user_data), false);
   mesh_handle.commit ();
   // Adapt forest classically.
-  forest = t8_forest_new_adapt (forest, forest_adapt_callback_example, 0, 1, &user_data);
+  forest = t8_forest_new_adapt (forest, forest_adapt_callback_example, 0, 0, &user_data);
 
   // Compare results.
   EXPECT_TRUE (t8_forest_is_equal (mesh_handle.get_forest (), forest));
 
+  // Adapt the mesh handle again and apply partition and balance.
+  mesh_handle.set_balance ();
+  mesh_handle.set_partition ();
+  mesh_handle.set_adapt (
+    mesh_class::mesh_adapt_callback_wrapper<dummy_user_data> (adapt_callback_test<mesh_class>, user_data), false);
+  mesh_handle.commit ();
+  EXPECT_TRUE (mesh_handle.is_balanced ());
+
+  // Compare the results again to an appropriate forest.
+  t8_forest_t forest_compare;
+  t8_forest_init (&forest_compare);
+  t8_forest_set_user_data (forest_compare, &user_data);
+  t8_forest_set_adapt (forest_compare, forest, forest_adapt_callback_example, false);
+  t8_forest_set_partition (forest_compare, NULL, false);
+  t8_forest_set_balance (forest_compare, NULL, false);
+  t8_forest_commit (forest_compare);
+  EXPECT_TRUE (t8_forest_is_equal (mesh_handle.get_forest (), forest_compare));
+
   // Clean up.
-  t8_forest_unref (&forest);
+  t8_forest_unref (&forest_compare);
 }
diff --git a/test/mesh_handle/t8_gtest_cache_competence.cxx b/test/mesh_handle/t8_gtest_cache_competence.cxx
index 49d1338401..218e176728 100644
--- a/test/mesh_handle/t8_gtest_cache_competence.cxx
+++ b/test/mesh_handle/t8_gtest_cache_competence.cxx
@@ -145,7 +145,7 @@ struct cache_face_normals_overwrite: public t8_mesh_handle::cache_face_normals<T
 TEST (t8_gtest_cache_competence, cache_volume)
 {
   const int level = 1;
-  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_volume_overwrite>>;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::element_competence_pack<cache_volume_overwrite>>;
   using element_class = typename mesh_class::element_class;
   const auto mesh = t8_mesh_handle::handle_hypercube_hybrid_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
   EXPECT_TRUE (element_class::has_volume_cache ());
@@ -172,7 +172,7 @@ TEST (t8_gtest_cache_competence, cache_volume)
 TEST (t8_gtest_cache_competence, cache_diameter)
 {
   const int level = 1;
-  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_diameter_overwrite>>;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::element_competence_pack<cache_diameter_overwrite>>;
   using element_class = typename mesh_class::element_class;
   auto mesh = t8_mesh_handle::handle_hypercube_hybrid_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
   EXPECT_TRUE (element_class::has_diameter_cache ());
@@ -194,7 +194,7 @@ TEST (t8_gtest_cache_competence, cache_diameter)
 TEST (t8_gtest_cache_competence, cache_vertex_coordinates)
 {
   const int level = 1;
-  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_vertex_coordinates_overwrite>>;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::element_competence_pack<cache_vertex_coordinates_overwrite>>;
   using element_class = typename mesh_class::element_class;
   const auto mesh = t8_mesh_handle::handle_hypercube_hybrid_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
   EXPECT_TRUE (element_class::has_vertex_cache ());
@@ -220,7 +220,7 @@ TEST (t8_gtest_cache_competence, cache_vertex_coordinates)
 TEST (t8_gtest_cache_competence, cache_centroid)
 {
   const int level = 1;
-  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_centroid_overwrite>>;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::element_competence_pack<cache_centroid_overwrite>>;
   using element_class = typename mesh_class::element_class;
   const auto mesh = t8_mesh_handle::handle_hypercube_hybrid_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
   EXPECT_TRUE (element_class::has_centroid_cache ());
@@ -245,7 +245,7 @@ TEST (t8_gtest_cache_competence, cache_centroid)
 TEST (t8_gtest_cache_competence, cache_face_areas)
 {
   const int level = 1;
-  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_face_areas_overwrite>>;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::element_competence_pack<cache_face_areas_overwrite>>;
   using element_class = typename mesh_class::element_class;
   auto mesh = t8_mesh_handle::handle_hypercube_hybrid_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
   EXPECT_TRUE (element_class::has_face_areas_cache ());
@@ -270,7 +270,7 @@ TEST (t8_gtest_cache_competence, cache_face_areas)
 TEST (t8_gtest_cache_competence, cache_face_centroids)
 {
   const int level = 1;
-  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_face_centroids_overwrite>>;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::element_competence_pack<cache_face_centroids_overwrite>>;
   using element_class = typename mesh_class::element_class;
   auto mesh = t8_mesh_handle::handle_hypercube_hybrid_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
   EXPECT_TRUE (element_class::has_face_centroids_cache ());
@@ -296,7 +296,7 @@ TEST (t8_gtest_cache_competence, cache_face_centroids)
 TEST (t8_gtest_cache_competence, cache_face_normals)
 {
   const int level = 1;
-  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_face_normals_overwrite>>;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::element_competence_pack<cache_face_normals_overwrite>>;
   using element_class = typename mesh_class::element_class;
   auto mesh = t8_mesh_handle::handle_hypercube_hybrid_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
   EXPECT_TRUE (element_class::has_face_normals_cache ());
diff --git a/test/mesh_handle/t8_gtest_custom_competence.cxx b/test/mesh_handle/t8_gtest_custom_competence.cxx
index 5af812a3d7..4777eecb45 100644
--- a/test/mesh_handle/t8_gtest_custom_competence.cxx
+++ b/test/mesh_handle/t8_gtest_custom_competence.cxx
@@ -83,7 +83,7 @@ TEST (t8_gtest_custom_competence, custom_competence)
 {
   const int level = 1;
   // Check mesh with custom defined competence.
-  using mesh_class_custom = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<dummy_get_level>>;
+  using mesh_class_custom = t8_mesh_handle::mesh<t8_mesh_handle::element_competence_pack<dummy_get_level>>;
   const auto mesh
     = t8_mesh_handle::handle_hypercube_hybrid_uniform_default<mesh_class_custom> (level, sc_MPI_COMM_WORLD);
 
@@ -93,7 +93,8 @@ TEST (t8_gtest_custom_competence, custom_competence)
   }
 
   // Test with two custom competences and a predefined competence.
-  using competences = t8_mesh_handle::competence_pack<dummy_get_level, dummy_trivial, t8_mesh_handle::cache_centroid>;
+  using competences
+    = t8_mesh_handle::element_competence_pack<dummy_get_level, dummy_trivial, t8_mesh_handle::cache_centroid>;
   using mesh_class = t8_mesh_handle::mesh<competences>;
   auto mesh_more_competences
     = t8_mesh_handle::handle_hypercube_hybrid_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
diff --git a/test/mesh_handle/t8_gtest_ghost.cxx b/test/mesh_handle/t8_gtest_ghost.cxx
index 5b5bceb2b6..c26db84c42 100644
--- a/test/mesh_handle/t8_gtest_ghost.cxx
+++ b/test/mesh_handle/t8_gtest_ghost.cxx
@@ -59,7 +59,7 @@ struct t8_mesh_ghost_test: public testing::TestWithParam<std::tuple<t8_eclass_t,
 /** Check the implementation of ghosts and all functions accessible by ghosts. */
 TEST_P (t8_mesh_ghost_test, check_ghosts)
 {
-  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::all_cache_competences>;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::all_cache_element_competences>;
   auto mesh = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class> (eclass, level, sc_MPI_COMM_WORLD, true,
                                                                             false, false);
 
@@ -194,7 +194,7 @@ struct cache_neighbors_overwrite: public t8_mesh_handle::cache_neighbors<TUnderl
  */
 TEST_P (t8_mesh_ghost_test, cache_neighbors)
 {
-  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_neighbors_overwrite>>;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::element_competence_pack<cache_neighbors_overwrite>>;
   using element_class = typename mesh_class::element_class;
   const auto mesh = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class> (eclass, level, sc_MPI_COMM_WORLD,
                                                                                   true, true, false);
diff --git a/test/mesh_handle/t8_gtest_handle_data.cxx b/test/mesh_handle/t8_gtest_handle_data.cxx
index 3066e7b506..ba6c7abe9b 100644
--- a/test/mesh_handle/t8_gtest_handle_data.cxx
+++ b/test/mesh_handle/t8_gtest_handle_data.cxx
@@ -31,6 +31,7 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 #include <mesh_handle/mesh.hxx>
 #include <mesh_handle/competence_pack.hxx>
 #include <mesh_handle/constructor_wrappers.hxx>
+#include <mesh_handle/data_handler.hxx>
 #include <t8_forest/t8_forest_general.h>
 #include <t8_types/t8_vec.hxx>
 #include <vector>
@@ -46,7 +47,9 @@ struct data_per_element
 TEST (t8_gtest_handle_data, set_and_get_element_data)
 {
   const int level = 2;
-  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::all_cache_competences, data_per_element>;
+  using mesh_class = t8_mesh_handle::mesh<
+    t8_mesh_handle::element_competence_pack<t8_mesh_handle::access_element_data>,
+    t8_mesh_handle::mesh_competence_pack<t8_mesh_handle::element_data_competence<data_per_element>::template type>>;
   auto mesh
     = t8_mesh_handle::handle_hypercube_hybrid_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD, true, true, false);
 
@@ -70,13 +73,15 @@ TEST (t8_gtest_handle_data, set_and_get_element_data)
   }
 
   // Modify element data for elements that are in the first half of the global trees.
+  EXPECT_TRUE (mesh->has_element_data_handler_competence ());
   auto forest = mesh->get_forest ();
   t8_gloidx_t barrier = t8_forest_get_num_global_trees (forest) / 2.0;
   const int newlevel = 42;
   const double newvolume = 42.42;
   for (auto &elem : *mesh) {
     if (t8_forest_global_tree_id (forest, elem.get_local_tree_id ()) < barrier) {
-      elem.set_element_data ({ newlevel, newvolume });
+      data_per_element elem_data ({ newlevel, newvolume });
+      elem.set_element_data (elem_data);
     }
   }
   mesh->exchange_ghost_data ();
diff --git a/test/mesh_handle/t8_gtest_mesh_handle.cxx b/test/mesh_handle/t8_gtest_mesh_handle.cxx
index 1e9802b3b2..8129335a05 100644
--- a/test/mesh_handle/t8_gtest_mesh_handle.cxx
+++ b/test/mesh_handle/t8_gtest_mesh_handle.cxx
@@ -22,17 +22,18 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 
 /**
  * \file t8_gtest_mesh_handle.cxx
- * Tests if the \ref t8_mesh_handle::mesh class of the handle works as intended for different types of template parameter classes. 
+ * Tests if the \ref t8_mesh_handle::mesh class of the handle works as intended
+ * for different types of template parameter classes.
  */
 
 #include <gtest/gtest.h>
-#include <test/t8_gtest_macros.hxx>
 #include <t8.h>
+#include <test/t8_gtest_macros.hxx>
 
-#include <mesh_handle/mesh.hxx>
-#include <mesh_handle/competences.hxx>
 #include <mesh_handle/competence_pack.hxx>
+#include <mesh_handle/competences.hxx>
 #include <mesh_handle/constructor_wrappers.hxx>
+#include <mesh_handle/mesh.hxx>
 
 /** Parametrized test fixture for the mesh handle tests. */
 struct t8_mesh_handle_test: public testing::TestWithParam<std::tuple<t8_eclass_t, int>>
@@ -49,7 +50,8 @@ struct t8_mesh_handle_test: public testing::TestWithParam<std::tuple<t8_eclass_t
   int level;          /**< Refinement level used for testing.*/
 };
 
-/** Test default \ref t8_mesh_handle::mesh handle, the iterator and some exemplary functionality. */
+/** Test default \ref t8_mesh_handle::mesh handle, the iterator and some
+ * exemplary functionality. */
 TEST_P (t8_mesh_handle_test, test_default_mesh_handle)
 {
   using mesh_class = t8_mesh_handle::mesh<>;
@@ -59,17 +61,18 @@ TEST_P (t8_mesh_handle_test, test_default_mesh_handle)
   EXPECT_FALSE (element_class::has_vertex_cache ());
   EXPECT_FALSE (element_class::has_centroid_cache ());
 
-  // Iterate with the constant iterator over all mesh elements and check some functionality.
+  // Iterate with the constant iterator over all mesh elements and check some
+  // functionality.
   for (auto it = mesh->cbegin (); it != mesh->cend (); ++it) {
     EXPECT_FALSE (it->has_vertex_cache ());
     EXPECT_FALSE (it->has_centroid_cache ());
     auto centroid = it->get_centroid ();
-    for (const auto& coordinate : centroid) {
+    for (const auto &coordinate : centroid) {
       EXPECT_TRUE (coordinate >= 0.0 && coordinate <= 1.0);
     }
     auto vertex_coordinates = (*it).get_vertex_coordinates ();
     for (int ivertex = 0; ivertex < (int) vertex_coordinates.size (); ++ivertex) {
-      for (const auto& coordinate : vertex_coordinates[ivertex]) {
+      for (const auto &coordinate : vertex_coordinates[ivertex]) {
         EXPECT_TRUE (coordinate >= 0.0 && coordinate <= 1.0);
       }
     }
@@ -82,11 +85,13 @@ TEST_P (t8_mesh_handle_test, test_default_mesh_handle)
   }
 }
 
-/** Test mesh class with all competence available using some exemplary functionality. */
+/** Test mesh class with all competence available using some exemplary
+ * functionality. */
 TEST_P (t8_mesh_handle_test, test_all_cache_competence)
 {
-  // --- Use predefined competences to use all available caching competences. ---
-  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::all_cache_competences>;
+  // --- Use predefined competences to use all available caching competences.
+  // ---
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::all_cache_element_competences>;
   using element_class = typename mesh_class::element_class;
   auto mesh = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class> (eclass, level, sc_MPI_COMM_WORLD, true,
                                                                             true, false);
@@ -99,23 +104,25 @@ TEST_P (t8_mesh_handle_test, test_all_cache_competence)
   EXPECT_TRUE (element_class::has_face_normals_cache ());
   EXPECT_TRUE (element_class::has_face_neighbor_cache ());
 
-  // Iterate over all mesh elements and access some exemplary functionality which sets the caches.
+  // Iterate over all mesh elements and access some exemplary functionality
+  // which sets the caches.
   for (auto it = mesh->cbegin (); it != mesh->cend (); ++it) {
     EXPECT_FALSE (it->volume_cache_filled ());
     EXPECT_FALSE (it->centroid_cache_filled ());
     EXPECT_FALSE (it->vertex_cache_filled ());
     EXPECT_EQ (level, it->get_level ());
     EXPECT_GE (it->get_volume (), 0);
-    for (const auto& coordinate : it->get_centroid ()) {
+    for (const auto &coordinate : it->get_centroid ()) {
       EXPECT_TRUE (coordinate >= 0.0 && coordinate <= 1.0);
     }
     for (int ivertex = 0; ivertex < it->get_num_vertices (); ++ivertex) {
-      for (const auto& coordinate : it->get_vertex_coordinates (ivertex)) {
+      for (const auto &coordinate : it->get_vertex_coordinates (ivertex)) {
         EXPECT_TRUE (coordinate >= 0.0 && coordinate <= 1.0);
       }
     }
   }
-  // Check if caches are set. If caches are accessed correctly is checked in another test.
+  // Check if caches are set. If caches are accessed correctly is checked in
+  // another test.
   for (auto it = mesh->cbegin (); it != mesh->cend (); ++it) {
     EXPECT_TRUE (it->volume_cache_filled ());
     EXPECT_TRUE (it->centroid_cache_filled ());
@@ -130,11 +137,12 @@ TEST_P (t8_mesh_handle_test, test_all_cache_competence)
   }
 }
 
-/** Test mesh class with all predefined face competences using some exemplary functionality. */
-TEST_P (t8_mesh_handle_test, test_cache_face_competences)
+/** Test mesh class with all predefined face competences using some exemplary
+ * functionality. */
+TEST_P (t8_mesh_handle_test, test_cache_face_element_competences)
 {
   // --- Use all predefined competences. ---
-  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::cache_face_competences>;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::cache_face_element_competences>;
   using element_class = typename mesh_class::element_class;
   auto mesh = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class> (eclass, level, sc_MPI_COMM_WORLD, true,
                                                                             true, false);
@@ -147,7 +155,8 @@ TEST_P (t8_mesh_handle_test, test_cache_face_competences)
   EXPECT_TRUE (element_class::has_face_normals_cache ());
   EXPECT_TRUE (element_class::has_face_neighbor_cache ());
 
-  // Iterate over all mesh elements and access some exemplary functionality which sets the caches.
+  // Iterate over all mesh elements and access some exemplary functionality
+  // which sets the caches.
   for (auto it = mesh->cbegin (); it != mesh->cend (); ++it) {
     if (it->get_num_faces () == 0) {
       GTEST_SKIP () << "Skipping test as there are no faces to be tested.";
@@ -156,12 +165,13 @@ TEST_P (t8_mesh_handle_test, test_cache_face_competences)
       EXPECT_FALSE (it->face_area_cache_filled (iface));
       EXPECT_FALSE (it->face_normal_cache_filled (iface));
       EXPECT_GE (it->get_face_area (iface), 0);
-      for (const auto& coordinate : it->get_face_normal (iface)) {
+      for (const auto &coordinate : it->get_face_normal (iface)) {
         EXPECT_TRUE (coordinate >= -1 && coordinate <= 1);
       }
     }
   }
-  // Check if caches are set. If caches are accessed correctly is checked in another test.
+  // Check if caches are set. If caches are accessed correctly is checked in
+  // another test.
   for (auto it = mesh->cbegin (); it != mesh->cend (); ++it) {
     for (int iface = 0; iface < it->get_num_faces (); ++iface) {
       EXPECT_TRUE (it->face_area_cache_filled (iface));
@@ -172,4 +182,29 @@ TEST_P (t8_mesh_handle_test, test_cache_face_competences)
   }
 }
 
+/** Check that the unique union of multiple competence packs works as intended.
+ */
+TEST (t8_mesh_handle_test, test_union_competence_pack)
+{
+  using namespace t8_mesh_handle;
+  /* Combine multiple competence packs with some overlapping competences to
+   * check that the union works correctly and duplicates are removed. Duplicates
+   * would cause an error because we inherit multiple times from the same class.
+   */
+  using mesh_class = mesh<
+    union_competence_packs_type<element_competence_pack<cache_volume>,
+                                element_competence_pack<cache_volume, cache_diameter, cache_vertex_coordinates>,
+                                element_competence_pack<cache_centroid, cache_face_areas, cache_face_centroids>>>;
+  using element_class = typename mesh_class::element_class;
+
+  EXPECT_TRUE (element_class::has_volume_cache ());
+  EXPECT_TRUE (element_class::has_diameter_cache ());
+  EXPECT_TRUE (element_class::has_vertex_cache ());
+  EXPECT_TRUE (element_class::has_centroid_cache ());
+  EXPECT_TRUE (element_class::has_face_areas_cache ());
+  EXPECT_TRUE (element_class::has_face_centroids_cache ());
+  EXPECT_FALSE (element_class::has_face_normals_cache ());
+  EXPECT_FALSE (element_class::has_face_neighbor_cache ());
+}
+
 INSTANTIATE_TEST_SUITE_P (t8_gtest_mesh, t8_mesh_handle_test, testing::Combine (AllEclasses, testing::Range (2, 3)));
diff --git a/test/t8_IO/t8_gtest_vtk_reader.cxx b/test/t8_IO/t8_gtest_vtk_reader.cxx
index f0c067d46a..749f561e87 100644
--- a/test/t8_IO/t8_gtest_vtk_reader.cxx
+++ b/test/t8_IO/t8_gtest_vtk_reader.cxx
@@ -23,6 +23,8 @@
 #include <gtest/gtest.h>
 #include <test/t8_gtest_macros.hxx>
 #include <src/t8_vtk/t8_with_vtk/t8_vtk_reader.hxx>
+#include "t8_test_data_dir.h"
+#include <string>
 
 #define T8_VTK_TEST_NUM_PROCS 2
 
@@ -66,8 +68,8 @@ struct vtk_reader: public testing::TestWithParam<std::tuple<int, int, int>>
   int mpirank;
   const char* failing_files[5] = { "no_file", "non-existing-file.vtu", "non-existing-file.vtp",
                                    "non-existing-file.pvtu", "non-existing-file.pvtp" };
-  const char* test_files[5] = { "no_file", "test/testfiles/test_vtk_tri.vtu", "test/testfiles/test_vtk_cube.vtp",
-                                "test/testfiles/test_parallel_file.pvtu", "test/testfiles/test_polydata.pvtp" };
+  const char* test_files[5]
+    = { "no_file", "/test_vtk_tri.vtu", "/test_vtk_cube.vtp", "/test_parallel_file.pvtu", "/test_polydata.pvtp" };
   const int num_points[5] = { 0, 121, 24, 6144, 900 };
   const int num_trees[5] = { 0, 200, 12, 1024, 1680 };
 };
@@ -86,7 +88,8 @@ TEST_P (vtk_reader, vtk_to_cmesh_success)
   int mpirank;
   int mpiret = sc_MPI_Comm_rank (sc_MPI_COMM_WORLD, &mpirank);
   SC_CHECK_MPI (mpiret);
-  t8_cmesh_t cmesh = t8_vtk_reader_cmesh (test_files[file], partition, main_proc, sc_MPI_COMM_WORLD, file_type,
+  std::string testfile = std::string (T8_TEST_DATA_DIR) + test_files[file];
+  t8_cmesh_t cmesh = t8_vtk_reader_cmesh (testfile.c_str (), partition, main_proc, sc_MPI_COMM_WORLD, file_type,
                                           t8_testsuite_get_package_id (), 0);
   if (file_type != VTK_FILE_ERROR) {
     EXPECT_FALSE (cmesh == NULL);
@@ -116,8 +119,9 @@ TEST_P (vtk_reader, vtk_to_cmesh_success)
 TEST_P (vtk_reader, vtk_to_pointSet)
 {
   if (file_type != VTK_FILE_ERROR) {
+    std::string testfile = std::string (T8_TEST_DATA_DIR) + test_files[file];
     vtkSmartPointer<vtkPointSet> points
-      = t8_vtk_reader_pointSet (test_files[file], partition, main_proc, sc_MPI_COMM_WORLD, file_type);
+      = t8_vtk_reader_pointSet (testfile.c_str (), partition, main_proc, sc_MPI_COMM_WORLD, file_type);
     int test_points = points->GetNumberOfPoints ();
     if (distributed) {
       /* The points should be distributed equally in this case. */
diff --git a/test/t8_cmesh/t8_gtest_cmesh_partition.cxx b/test/t8_cmesh/t8_gtest_cmesh_partition.cxx
index 78519f3744..484d11d1db 100644
--- a/test/t8_cmesh/t8_gtest_cmesh_partition.cxx
+++ b/test/t8_cmesh/t8_gtest_cmesh_partition.cxx
@@ -69,8 +69,12 @@ test_cmesh_committed (t8_cmesh_t cmesh)
 
 TEST_P (t8_cmesh_partition_class, test_cmesh_partition_concentrate)
 {
+#if T8_TEST_LEVEL_INT >= 2
+  const int level = 6;  // Test level basic
+#else
+  const int level = 9;  // Test level medium and full
+#endif
 
-  const int level = 11;
   int mpisize;
   int mpiret;
   int mpirank;
diff --git a/test/t8_cmesh/t8_gtest_cmesh_readmshfile.cxx b/test/t8_cmesh/t8_gtest_cmesh_readmshfile.cxx
index 0d14982baa..4ec2444bf3 100644
--- a/test/t8_cmesh/t8_gtest_cmesh_readmshfile.cxx
+++ b/test/t8_cmesh/t8_gtest_cmesh_readmshfile.cxx
@@ -23,10 +23,12 @@
 #include <gtest/gtest.h>
 #include <unistd.h> /* Needed to check for file access */
 #include <t8.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <t8_cmesh/t8_cmesh.h>
 #include <t8_cmesh/t8_cmesh_io/t8_cmesh_readmshfile.h>
 #include <t8_cmesh/t8_cmesh_internal/t8_cmesh_trees.h>
+#include "t8_test_data_dir.h"
+#include <string>
 
 /* In this file we test the msh file (gmsh) reader of the cmesh.
  * Currently, we support version 2 and 4 ascii.
@@ -38,15 +40,15 @@
 TEST (t8_cmesh_readmshfile, test_msh_file_vers4_ascii)
 {
 
-  const char fileprefix[BUFSIZ - 4] = "testfiles/test_msh_file_vers4_ascii";
+  std::string fileprefix = std::string (T8_TEST_DATA_DIR) + "/test_msh_file_vers4_ascii";
   char filename[BUFSIZ];
 
-  snprintf (filename, BUFSIZ, "%s.msh", fileprefix);
+  snprintf (filename, BUFSIZ, "%s.msh", fileprefix.c_str ());
 
   t8_debugf ("Checking msh file version 4 ascii...\n");
 
   ASSERT_FALSE (access (filename, R_OK)) << "Could not open file " << filename;
-  t8_cmesh_t cmesh = t8_cmesh_from_msh_file (fileprefix, 1, sc_MPI_COMM_WORLD, 2, 0, 0);
+  t8_cmesh_t cmesh = t8_cmesh_from_msh_file (fileprefix.c_str (), 1, sc_MPI_COMM_WORLD, 2, 0, 0);
   ASSERT_TRUE (cmesh != NULL) << "Could not read cmesh from ascii version 4, but should be able to.";
 
   /* The cmesh was read successfully and we need to destroy it. */
@@ -56,15 +58,15 @@ TEST (t8_cmesh_readmshfile, test_msh_file_vers4_ascii)
 TEST (t8_cmesh_readmshfile, test_msh_file_vers4_bin)
 {
 
-  const char fileprefix[BUFSIZ - 4] = "testfiles/test_msh_file_vers4_bin";
+  std::string fileprefix = std::string (T8_TEST_DATA_DIR) + "/test_msh_file_vers4_bin";
   char filename[BUFSIZ];
 
-  snprintf (filename, BUFSIZ, "%s.msh", fileprefix);
+  snprintf (filename, BUFSIZ, "%s.msh", fileprefix.c_str ());
 
   t8_debugf ("Checking msh file version 4 binary...\n");
 
   ASSERT_FALSE (access (filename, R_OK)) << "Could not open file " << filename;
-  t8_cmesh_t cmesh = t8_cmesh_from_msh_file (fileprefix, 1, sc_MPI_COMM_WORLD, 2, 0, 0);
+  t8_cmesh_t cmesh = t8_cmesh_from_msh_file (fileprefix.c_str (), 1, sc_MPI_COMM_WORLD, 2, 0, 0);
   ASSERT_TRUE (cmesh == NULL) << "Expected fail of reading binary msh file v.4, but did not fail.";
 
   t8_debugf ("Error handling successful.\n");
diff --git a/test/t8_cmesh/t8_gtest_cmesh_set_join_by_vertices.cxx b/test/t8_cmesh/t8_gtest_cmesh_set_join_by_vertices.cxx
index eeeae6e902..a61abd4d89 100644
--- a/test/t8_cmesh/t8_gtest_cmesh_set_join_by_vertices.cxx
+++ b/test/t8_cmesh/t8_gtest_cmesh_set_join_by_vertices.cxx
@@ -22,7 +22,7 @@
 
 #include <gtest/gtest.h>
 #include <t8.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <t8_cmesh/t8_cmesh.h>
 #include <t8_cmesh/t8_cmesh_internal/t8_cmesh_types.h>
 #include <t8_cmesh/t8_cmesh_examples.h>
@@ -30,6 +30,8 @@
 #include "test/t8_cmesh_generator/t8_cmesh_example_sets.hxx"
 #include <t8_geometry/t8_geometry_implementations/t8_geometry_linear.hxx>
 #include <test/t8_gtest_macros.hxx>
+#include "t8_test_data_dir.h"
+#include <string>
 
 #include <p8est_geometry.h>
 
@@ -277,8 +279,8 @@ TEST (t8_cmesh_set_join_by_vertices, test_cmesh_set_join_by_vertices)
   }
 
   {
-    const char *filename = "testfiles/test_cube_unstructured_1.inp";
-    p8est_connectivity_t *p8_conn = p8est_connectivity_read_inp (filename);
+    std::string filename = std::string (T8_TEST_DATA_DIR) + "/test_cube_unstructured_1.inp";
+    p8est_connectivity_t *p8_conn = p8est_connectivity_read_inp (filename.c_str ());
     t8_cmesh_t cmesh = t8_cmesh_new_from_p8est (p8_conn, comm, do_partition);
     test_with_cmesh (cmesh);
     p8est_connectivity_destroy (p8_conn);
@@ -286,8 +288,8 @@ TEST (t8_cmesh_set_join_by_vertices, test_cmesh_set_join_by_vertices)
   }
 
   {
-    const char *filename = "testfiles/test_cube_unstructured_2.inp";
-    p8est_connectivity_t *p8_conn = p8est_connectivity_read_inp (filename);
+    std::string filename = std::string (T8_TEST_DATA_DIR) + "/test_cube_unstructured_2.inp";
+    p8est_connectivity_t *p8_conn = p8est_connectivity_read_inp (filename.c_str ());
     t8_cmesh_t cmesh = t8_cmesh_new_from_p8est (p8_conn, comm, do_partition);
     test_with_cmesh (cmesh);
     p8est_connectivity_destroy (p8_conn);
diff --git a/test/t8_cmesh_generator/t8_cmesh_parameterized_examples/t8_cmesh_new_bigmesh_param.hxx b/test/t8_cmesh_generator/t8_cmesh_parameterized_examples/t8_cmesh_new_bigmesh_param.hxx
index 981e5ff2e1..5d3f8d30ca 100644
--- a/test/t8_cmesh_generator/t8_cmesh_parameterized_examples/t8_cmesh_new_bigmesh_param.hxx
+++ b/test/t8_cmesh_generator/t8_cmesh_parameterized_examples/t8_cmesh_new_bigmesh_param.hxx
@@ -29,7 +29,7 @@
 #include "test/t8_cmesh_generator/t8_gtest_cmesh_cartesian_product.hxx"
 #include "test/t8_cmesh_generator/t8_cmesh_parameterized_examples/t8_cmesh_params.hxx"
 #include "t8_cmesh/t8_cmesh_examples.h"
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 
 namespace new_bigmesh
 {
diff --git a/test/t8_cmesh_generator/t8_cmesh_parameterized_examples/t8_cmesh_new_empty.hxx b/test/t8_cmesh_generator/t8_cmesh_parameterized_examples/t8_cmesh_new_empty.hxx
index 7c49d7025f..0a0f3bb891 100644
--- a/test/t8_cmesh_generator/t8_cmesh_parameterized_examples/t8_cmesh_new_empty.hxx
+++ b/test/t8_cmesh_generator/t8_cmesh_parameterized_examples/t8_cmesh_new_empty.hxx
@@ -29,7 +29,7 @@
 #include <test/t8_cmesh_generator/t8_gtest_cmesh_cartesian_product.hxx>
 #include <test/t8_cmesh_generator/t8_cmesh_parameterized_examples/t8_cmesh_params.hxx>
 #include <t8_cmesh/t8_cmesh_examples.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 
 namespace new_empty
 {
diff --git a/test/t8_cmesh_generator/t8_cmesh_parameterized_examples/t8_cmesh_new_from_class_param.hxx b/test/t8_cmesh_generator/t8_cmesh_parameterized_examples/t8_cmesh_new_from_class_param.hxx
index aa7a73ab62..b8188038a1 100644
--- a/test/t8_cmesh_generator/t8_cmesh_parameterized_examples/t8_cmesh_new_from_class_param.hxx
+++ b/test/t8_cmesh_generator/t8_cmesh_parameterized_examples/t8_cmesh_new_from_class_param.hxx
@@ -29,7 +29,7 @@
 #include "test/t8_cmesh_generator/t8_gtest_cmesh_cartesian_product.hxx"
 #include "test/t8_cmesh_generator/t8_cmesh_parameterized_examples/t8_cmesh_params.hxx"
 #include <t8_cmesh/t8_cmesh_examples.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 
 namespace new_from_class
 {
diff --git a/test/t8_cmesh_generator/t8_cmesh_parameterized_examples/t8_cmesh_new_hypercube_param.hxx b/test/t8_cmesh_generator/t8_cmesh_parameterized_examples/t8_cmesh_new_hypercube_param.hxx
index 933add099f..0ca61ed9f4 100644
--- a/test/t8_cmesh_generator/t8_cmesh_parameterized_examples/t8_cmesh_new_hypercube_param.hxx
+++ b/test/t8_cmesh_generator/t8_cmesh_parameterized_examples/t8_cmesh_new_hypercube_param.hxx
@@ -26,7 +26,7 @@
 #ifndef T8_CMESH_NEW_HYPERCUBE_PARAM_HXX
 #define T8_CMESH_NEW_HYPERCUBE_PARAM_HXX
 
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include "test/t8_cmesh_generator/t8_gtest_cmesh_cartesian_product.hxx"
 #include "test/t8_cmesh_generator/t8_cmesh_parameterized_examples/t8_cmesh_params.hxx"
 #include <t8_cmesh/t8_cmesh_examples.h>
diff --git a/test/t8_cmesh_generator/t8_cmesh_parameterized_examples/t8_cmesh_new_periodic.hxx b/test/t8_cmesh_generator/t8_cmesh_parameterized_examples/t8_cmesh_new_periodic.hxx
index 94ce719e1a..8520db32f2 100644
--- a/test/t8_cmesh_generator/t8_cmesh_parameterized_examples/t8_cmesh_new_periodic.hxx
+++ b/test/t8_cmesh_generator/t8_cmesh_parameterized_examples/t8_cmesh_new_periodic.hxx
@@ -29,7 +29,7 @@
 #include <test/t8_cmesh_generator/t8_gtest_cmesh_cartesian_product.hxx>
 #include <test/t8_cmesh_generator/t8_cmesh_parameterized_examples/t8_cmesh_params.hxx>
 #include <t8_cmesh/t8_cmesh_examples.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 
 namespace new_periodic
 {
diff --git a/test/t8_cmesh_generator/t8_cmesh_parameterized_examples/t8_cmesh_params.hxx b/test/t8_cmesh_generator/t8_cmesh_parameterized_examples/t8_cmesh_params.hxx
index 2a1680fef1..7d83054f6c 100644
--- a/test/t8_cmesh_generator/t8_cmesh_parameterized_examples/t8_cmesh_params.hxx
+++ b/test/t8_cmesh_generator/t8_cmesh_parameterized_examples/t8_cmesh_params.hxx
@@ -25,8 +25,7 @@
  */
 #ifndef T8_CMESH_PARAMS_HXX
 #define T8_CMESH_PARAMS_HXX
-
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <vector>
 #include <numeric>
 #include <algorithm>
diff --git a/test/t8_forest/t8_gtest_balance.cxx b/test/t8_forest/t8_gtest_balance.cxx
index 464ef97ff9..422abc87bc 100644
--- a/test/t8_forest/t8_gtest_balance.cxx
+++ b/test/t8_forest/t8_gtest_balance.cxx
@@ -29,7 +29,7 @@
 #include <test/t8_gtest_schemes.hxx>
 #include <test/t8_gtest_custom_assertion.hxx>
 
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <t8_cmesh/t8_cmesh.h>
 #include <t8_cmesh/t8_cmesh_examples.h>
 #include <t8_forest/t8_forest_general.h>
diff --git a/test/t8_forest/t8_gtest_bin_search.cxx b/test/t8_forest/t8_gtest_bin_search.cxx
new file mode 100644
index 0000000000..5d16be7424
--- /dev/null
+++ b/test/t8_forest/t8_gtest_bin_search.cxx
@@ -0,0 +1,345 @@
+/*
+  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) 2026 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.
+*/
+
+#include <gtest/gtest.h>
+#include <test/t8_gtest_schemes.hxx>
+#include <t8_eclass/t8_eclass.h>
+#include <t8_cmesh/t8_cmesh.h>
+#include <t8_forest/t8_forest_general.h>
+#include <t8_forest/t8_forest_private.h>
+#include <t8_schemes/t8_default/t8_default.hxx>
+#include "test/t8_cmesh_generator/t8_cmesh_example_sets.hxx"
+#include <test/t8_gtest_adapt_callbacks.hxx>
+#include <test/t8_gtest_macros.hxx>
+
+/* In these tests we check the t8_forest_bin_search_lower, t8_forest_bin_search_upper
+ * and t8_forest_bin_search_first_descendant_ancestor functions.
+ * Iterating over all cmesh test cases, we create a uniform and an adaptive forest.
+ * For each forest, we iterate over all elements and initialize searches.
+ * One search for the element E itself.
+ * One search for an element that is not in the array but for which element E will be found.
+ * Additionally, we issue one search per tree where no element at all will be found.
+ */
+
+/* Maximum uniform level for forest. */
+
+#if T8_TEST_LEVEL_INT >= 1
+#define T8_IS_LEAF_MAX_LVL 3
+#else
+#define T8_IS_LEAF_MAX_LVL 4
+#endif
+
+// TODO: ADd this class to common headers since it is reused
+class t8_bin_search_tester: public testing::TestWithParam<std::tuple<std::tuple<int, t8_eclass_t>, int>> {
+ protected:
+  void
+  SetUp () override
+  {
+    /* Construct a cmesh */
+    const int scheme_id = std::get<0> (std::get<0> (GetParam ()));
+    scheme = create_from_scheme_id (scheme_id);
+    const t8_eclass_t tree_class = std::get<1> (std::get<0> (GetParam ()));
+    const int level = std::get<1> (GetParam ());
+    t8_cmesh_t cmesh = t8_cmesh_new_from_class (tree_class, sc_MPI_COMM_WORLD);
+
+    // Construct a uniform forest
+    forest = t8_forest_new_uniform (cmesh, scheme, level, 0, sc_MPI_COMM_WORLD);
+    t8_forest_ref (forest);
+    int maxlevel = 7;
+    const int recursive_adapt = 1;
+    // Construct an adaptive forest
+    forest_adapt = t8_forest_new_adapt (forest, t8_test_adapt_first_child, recursive_adapt, 0, &maxlevel);
+  }
+
+  void
+  TearDown () override
+  {
+    if (forest != NULL) {
+      t8_forest_unref (&forest);
+    }
+    if (forest_adapt != NULL) {
+      t8_forest_unref (&forest_adapt);
+    }
+  }
+
+  t8_forest_t forest { NULL };
+  t8_forest_t forest_adapt { NULL };
+  const t8_scheme *scheme;
+};
+
+/** Test the t8_forest_bin_search_upper function.
+ * We iterate through all elements of a forest.
+ * For each element E of level L, we call t8_forest_bin_search_upper on the forest's element array and expect
+ * the element to be found.
+ * For each element we then build one case where we search for an element that is not contained but will
+ * match a different element in the element array:
+ *  We compute the linear Id of E at level L+1 (if it is >=0 ) and search for the L+1 element with this id.
+ *  We expect E to be found since it fulfills that its id is >= than the id we search for.
+ * We then build one case per tree where we search for an element that is not contained and will not match
+ * any other element:
+ *  We compute the linear Id of the last element in the tree and add 1 to it (if it is not zero).
+ *  We expect the search to not find anything.
+*/
+static void
+t8_test_forest_bin_search_upper (t8_forest_t forest)
+{
+  const t8_locidx_t num_local_trees = t8_forest_get_num_local_trees (forest);
+
+  const t8_scheme *scheme = t8_forest_get_scheme (forest);
+  for (t8_locidx_t itree = 0; itree < num_local_trees; ++itree) {
+    const t8_locidx_t num_elements_in_tree = t8_forest_get_tree_num_leaf_elements (forest, itree);
+    const t8_eclass_t tree_class = t8_forest_get_tree_class (forest, itree);
+    const t8_element_array_t *leaves = t8_forest_tree_get_leaf_elements (forest, itree);
+
+    // Iterate over all the tree's leaf elements.
+    for (t8_locidx_t ielement = 0; ielement < num_elements_in_tree; ++ielement) {
+      const t8_element_t *leaf_element = t8_forest_get_leaf_element_in_tree (forest, itree, ielement);
+      const int element_level = scheme->element_get_level (tree_class, leaf_element);
+      const t8_linearidx_t element_id = scheme->element_get_linear_id (tree_class, leaf_element, element_level);
+
+      /* Search for a linear element id in a sorted array of
+      * elements. If the element does not exist, return the smallest index i
+      * such that the element at position i has a larger id than the given one.
+      * If no such i exists, return -1. */
+      const t8_locidx_t search_index = t8_forest_bin_search_upper (leaves, element_id, element_level);
+      // We expect the leaf element to be found at position ielement
+      EXPECT_EQ (search_index, ielement) << "Found wrong position of leaf element. Expected: " << ielement
+                                         << " got: " << search_index;
+
+      // If we increase the level, we expect the element to not be found, but the search
+      // should return the index of the original element.
+      if (scheme->element_is_refinable (tree_class, leaf_element)) {
+        t8_debugf ("Computing element for level %i, Max is %i\n", element_level, T8_DLINE_MAXLEVEL);
+        const t8_linearidx_t element_id_at_next_level
+          = scheme->element_get_linear_id (tree_class, leaf_element, element_level + 1);
+
+        const t8_locidx_t search_index
+          = t8_forest_bin_search_upper (leaves, element_id_at_next_level, element_level + 1);
+        // We expect the leaf element to be found at position ielement
+        EXPECT_EQ (search_index, ielement)
+          << "Found wrong position of level " << element_level + 1 << " leaf element with id "
+          << element_id_at_next_level << ". Expected: " << ielement << " got: " << search_index;
+      }
+
+      // Construct an element that is definitely not in the array and
+      // does not have an element of smaller id in the array. We expect -1 as return.
+      // We take the first element of the forest and subtract 1 from its id.
+      if (ielement == num_elements_in_tree - 1) {
+        const t8_linearidx_t element_not_found_id = element_id + 1;
+        // Double check for possible conversion error, if element_id == MAX_POSSIBLE_VALUE. In that case, the
+        // test logic fails. Should we ever run into this case, we need to rewrite this test accordingly.
+        SC_CHECK_ABORTF (element_not_found_id > 0, "Invalid element id %li\n", element_not_found_id);
+        const t8_locidx_t search_index = t8_forest_bin_search_upper (leaves, element_not_found_id, element_level);
+        EXPECT_EQ (search_index, -1) << "Wrong return value for element that should not be in array. Expected -1.";
+      }
+    }
+  }
+}
+
+/** Test the t8_forest_bin_search_lower function.
+ * We iterate through all elements of a forest.
+ * For each element E of level L, we call t8_forest_bin_search_lower on the forest's element array and expect
+ * the element to be found.
+ * For each element we then build one case where we search for an element that is not contained but will
+ * match a different element in the element array:
+ *  We compute the linear Id of E at level L+1 (if not exceeding the maxlevel) and search for the L+1 element with this id.
+ *  We expect E to be found since it fulfills that its id is <= than the id we search for.
+ * We then build one case per tree where we search for an element that is not contained and will not match
+ * any other element:
+ *  We compute the linear Id of the first element in the tree and subtract 1 from it (if it is not zero).
+ *  We expect the search to not find anything.
+*/
+static void
+t8_test_forest_bin_search_lower (t8_forest_t forest)
+{
+  const t8_locidx_t num_local_trees = t8_forest_get_num_local_trees (forest);
+
+  const t8_scheme *scheme = t8_forest_get_scheme (forest);
+  for (t8_locidx_t itree = 0; itree < num_local_trees; ++itree) {
+    const t8_locidx_t num_elements_in_tree = t8_forest_get_tree_num_leaf_elements (forest, itree);
+    const t8_eclass_t tree_class = t8_forest_get_tree_class (forest, itree);
+    const t8_element_array_t *leaves = t8_forest_tree_get_leaf_elements (forest, itree);
+
+    /* Iterate over all the tree's leaf elements. */
+    for (t8_locidx_t ielement = 0; ielement < num_elements_in_tree; ++ielement) {
+      const t8_element_t *leaf_element = t8_forest_get_leaf_element_in_tree (forest, itree, ielement);
+      const int element_level = scheme->element_get_level (tree_class, leaf_element);
+      const t8_linearidx_t element_id = scheme->element_get_linear_id (tree_class, leaf_element, element_level);
+
+      /* Search for a linear element id in a sorted array of
+      * elements. If the element does not exist, return the largest index i
+      * such that the element at position i has a smaller id than the given one.
+      * If no such i exists, return -1. */
+      const t8_locidx_t search_index = t8_forest_bin_search_lower (leaves, element_id, element_level);
+      // We expect the leaf element to be found at position ielement
+      EXPECT_EQ (search_index, ielement) << "Found wrong position of leaf element. Expected: " << ielement
+                                         << " got: " << search_index;
+
+      // If we increase the level, we expect the element to not be found, but the search
+      // should return the index of the original element.
+      if (scheme->element_is_refinable (tree_class, leaf_element)) {
+        t8_debugf ("Computing element for level %i, Max is %i\n", element_level, T8_DLINE_MAXLEVEL);
+        const t8_linearidx_t element_id_at_next_level
+          = scheme->element_get_linear_id (tree_class, leaf_element, element_level + 1);
+
+        const t8_locidx_t search_index
+          = t8_forest_bin_search_lower (leaves, element_id_at_next_level, element_level + 1);
+        // We expect the leaf element to be found at position ielement
+        EXPECT_EQ (search_index, ielement)
+          << "Found wrong position of level " << element_level + 1 << " leaf element with id "
+          << element_id_at_next_level << ". Expected: " << ielement << " got: " << search_index;
+      }
+
+      // Construct an element that is definitely not in the array and
+      // does not have an element of smaller id in the array. We expect -1 as return.
+      // We take the first element of the forest and subtract 1 from its id.
+      if (ielement == 0 && element_id > 0) {
+        const t8_linearidx_t element_not_found_id = element_id - 1;
+        const t8_locidx_t search_index = t8_forest_bin_search_lower (leaves, element_not_found_id, element_level);
+        EXPECT_EQ (search_index, -1) << "Wrong return value for element that should not be in array. Expected -1.";
+      }
+    }
+  }
+}
+
+/** Test the t8_forest_bin_search_first_descendant_ancestor function.
+ * We iterate through all elements of a forest.
+ * For each element E of level L, we call t8_forest_bin_search_first_descendant_ancestor on the forest's element array and expect
+ * the element to be found.
+ * For each element we then build one case where we search for an element that is not contained but will
+ * match a different element in the element array:
+ *  We compute the first child C of E and search for C.
+ *  We expect E to be found since it is an ancestor of C.
+ * We then build one case per tree where we search for an element that is not contained and will not match
+ * any other element:
+ *  We compute the linear Id of the last element in the tree and add 1 to it.
+ *  Construct the corresponding element with that Id on level L (if such an element exists).
+ */
+static void
+t8_test_forest_bin_search_first_descendant_ancestor (t8_forest_t forest)
+{
+  const t8_locidx_t num_local_trees = t8_forest_get_num_local_trees (forest);
+
+  const t8_scheme *scheme = t8_forest_get_scheme (forest);
+  for (t8_locidx_t itree = 0; itree < num_local_trees; ++itree) {
+    const t8_locidx_t num_elements_in_tree = t8_forest_get_tree_num_leaf_elements (forest, itree);
+    const t8_eclass_t tree_class = t8_forest_get_tree_class (forest, itree);
+    const t8_element_array_t *leaves = t8_forest_tree_get_leaf_elements (forest, itree);
+    t8_element_t *search_element;
+    scheme->element_new (tree_class, 1, &search_element);
+
+    /* Iterate over all the tree's leaf elements */
+    for (t8_locidx_t ielement = 0; ielement < num_elements_in_tree; ++ielement) {
+      const t8_element_t *leaf_element = t8_forest_get_leaf_element_in_tree (forest, itree, ielement);
+      const int element_level = scheme->element_get_level (tree_class, leaf_element);
+      const t8_linearidx_t element_id = scheme->element_get_linear_id (tree_class, leaf_element, element_level);
+
+      // Search for the element or an ancestor or descendant in the leaves array.
+      const t8_element_t *element_found;
+      const t8_locidx_t search_index
+        = t8_forest_bin_search_first_descendant_ancestor (leaves, leaf_element, &element_found);
+      // We expect the leaf element to be found at position ielement
+      EXPECT_EQ (search_index, ielement) << "Found wrong position of leaf element. Expected: " << ielement
+                                         << " got: " << search_index;
+      EXPECT_TRUE (scheme->element_is_equal (tree_class, element_found, leaf_element));
+
+      // If we increase the level, we expect the element to not be found, but the search
+      // should return the index of the original element.
+      if (scheme->element_is_refinable (tree_class, leaf_element)) {
+        t8_debugf ("Computing element for level %i, Max is %i\n", element_level, T8_DLINE_MAXLEVEL);
+        scheme->element_get_child (tree_class, leaf_element, 0, search_element);
+        const t8_locidx_t search_index
+          = t8_forest_bin_search_first_descendant_ancestor (leaves, search_element, &element_found);
+        // We expect the leaf element to be found at position ielement
+        EXPECT_EQ (search_index, ielement) << "Found wrong position of level " << element_level + 1 << " leaf element "
+                                           << ". Expected: " << ielement << " got: " << search_index;
+        EXPECT_TRUE (scheme->element_is_equal (tree_class, element_found, leaf_element));
+      }
+
+      // Construct an element that is definitely not in the array and
+      // does not have an element of smaller id in the array. We expect -1 as return.
+      // We take the first element of the forest and subtract 1 from its id.
+      if (ielement == num_elements_in_tree - 1) {
+        const t8_linearidx_t element_not_found_id = element_id + 1;
+        // We need to check that this Id corresponds to a valid element id.
+        // To do so, we must compute the number of elements at the given refinement level,
+        // and check that element_not_found_id is smaller.
+        // We do this by building the root element and calling element_count_leaves.
+        // Note that we do not need to check this in the upper/lower tests, since we do not generate an actual element in them.
+        scheme->element_set_linear_id (tree_class, search_element, 0, 0);
+        const t8_linearidx_t max_valid_id
+          = (t8_linearidx_t) scheme->element_count_leaves (tree_class, search_element, element_level);
+        if (element_not_found_id < max_valid_id) {
+          // Double check for possible conversion error, if element_id == MAX_POSSIBLE_VALUE. In that case, the
+          // test logic fails. Should we ever run into this case, we need to rewrite this test accordingly.
+          SC_CHECK_ABORTF (element_not_found_id > 0, "Invalid element id %li\n", element_not_found_id);
+          scheme->element_set_linear_id (tree_class, search_element, element_level, element_not_found_id);
+          const t8_locidx_t search_index
+            = t8_forest_bin_search_first_descendant_ancestor (leaves, search_element, &element_found);
+          EXPECT_EQ (search_index, -1) << "Wrong return value for element that should not be in array. Expected -1.";
+          EXPECT_EQ (element_found, nullptr);
+        }
+      }
+    }
+    scheme->element_destroy (tree_class, 1, &search_element);
+  }
+}
+
+// bin_search_lower test for uniform forest
+TEST_P (t8_bin_search_tester, bin_search_lower_uniform)
+{
+  t8_test_forest_bin_search_lower (forest);
+}
+
+// bin_search_lower test for adaptive forest
+TEST_P (t8_bin_search_tester, bin_search_lower_adapt)
+{
+  t8_test_forest_bin_search_lower (forest_adapt);
+}
+
+// bin_search_upper test for uniform forest
+TEST_P (t8_bin_search_tester, bin_search_upper_uniform)
+{
+  t8_test_forest_bin_search_upper (forest);
+}
+
+// bin_search_upper test for adaptive forest
+TEST_P (t8_bin_search_tester, bin_search_upper_adapt)
+{
+  t8_test_forest_bin_search_upper (forest_adapt);
+}
+
+// bin_search_first_descendant_ancestor test for uniform forest
+TEST_P (t8_bin_search_tester, bin_search_first_descendant_ancestor_uniform)
+{
+  t8_test_forest_bin_search_first_descendant_ancestor (forest);
+}
+
+// bin_search_first_descendant_ancestor test for adaptive forest
+TEST_P (t8_bin_search_tester, bin_search_first_descendant_ancestor_adapt)
+{
+  t8_test_forest_bin_search_first_descendant_ancestor (forest_adapt);
+}
+
+INSTANTIATE_TEST_SUITE_P (t8_gtest_bin_search, t8_bin_search_tester,
+                          testing::Combine (AllSchemes, testing::Range (0, T8_IS_LEAF_MAX_LVL)),
+                          pretty_print_eclass_scheme_and_level);
diff --git a/test/t8_forest/t8_gtest_element_is_leaf.cxx b/test/t8_forest/t8_gtest_element_is_leaf.cxx
index f19af2371c..d162707a42 100644
--- a/test/t8_forest/t8_gtest_element_is_leaf.cxx
+++ b/test/t8_forest/t8_gtest_element_is_leaf.cxx
@@ -22,11 +22,13 @@
 
 #include <gtest/gtest.h>
 #include <test/t8_gtest_schemes.hxx>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <t8_cmesh/t8_cmesh.h>
 #include <t8_forest/t8_forest_general.h>
+#include <t8_forest/t8_forest_ghost.h>
 #include <t8_schemes/t8_default/t8_default.hxx>
 #include "test/t8_cmesh_generator/t8_cmesh_example_sets.hxx"
+#include <test/t8_gtest_adapt_callbacks.hxx>
 #include <test/t8_gtest_macros.hxx>
 
 /* In this test we check the t8_forest_element_is_leaf function.
@@ -38,88 +40,32 @@
 /* Maximum uniform level for forest. */
 
 #if T8_TEST_LEVEL_INT >= 1
-#define T8_IS_LEAF_MAX_LVL 3
+#define T8_IS_LEAF_MAX_LVL 2
 #else
-#define T8_IS_LEAF_MAX_LVL 4
+#define T8_IS_LEAF_MAX_LVL 3
 #endif
-/* Adapt a forest such that always the first child of a
- * family is refined and no other elements. This results in a highly
- * imbalanced forest. */
-static int
-t8_test_adapt_first_child (t8_forest_t forest, [[maybe_unused]] t8_forest_t forest_from,
-                           [[maybe_unused]] t8_locidx_t which_tree, const t8_eclass_t tree_class,
-                           [[maybe_unused]] t8_locidx_t lelement_id, const t8_scheme *scheme,
-                           [[maybe_unused]] const int is_family, [[maybe_unused]] const int num_elements,
-                           t8_element_t *elements[])
-{
-  T8_ASSERT (!is_family || (is_family && num_elements == scheme->element_get_num_children (tree_class, elements[0])));
-
-  const int level = scheme->element_get_level (tree_class, elements[0]);
-
-  /* we set a maximum refinement level as forest user data */
-  int maxlevel = *(int *) t8_forest_get_user_data (forest);
-  if (level >= maxlevel) {
-    /* Do not refine after the maxlevel */
-    return 0;
-  }
-  const int child_id = scheme->element_get_child_id (tree_class, elements[0]);
-  if (child_id == 1) {
-    return 1;
-  }
-  return 0;
-}
 
-struct element_is_leaf: public testing::TestWithParam<std::tuple<std::tuple<int, t8_eclass_t>, int>>
-{
+class element_is_leaf_or_ghost: public testing::TestWithParam<std::tuple<int, int, cmesh_example_base *>> {
  protected:
   void
   SetUp () override
   {
     /* Construct a cmesh */
-    const int scheme_id = std::get<0> (std::get<0> (GetParam ()));
+    const int scheme_id = std::get<0> (GetParam ());
     scheme = create_from_scheme_id (scheme_id);
-    const t8_eclass_t tree_class = std::get<1> (std::get<0> (GetParam ()));
     const int level = std::get<1> (GetParam ());
-    t8_cmesh_t cmesh = t8_cmesh_new_from_class (tree_class, sc_MPI_COMM_WORLD);
-
-    forest = t8_forest_new_uniform (cmesh, scheme, level, 0, sc_MPI_COMM_WORLD);
-    t8_forest_ref (forest);
-    //const int maxlevel = t8_forest_get_maxlevel (forest);
-    int maxlevel = 7;
-    const int recursive_adapt = 1;
-    forest_adapt = t8_forest_new_adapt (forest, t8_test_adapt_first_child, recursive_adapt, 0, &maxlevel);
-  }
-
-  void
-  TearDown () override
-  {
-    if (forest != NULL) {
-      t8_forest_unref (&forest);
+    t8_cmesh_t cmesh = std::get<2> (GetParam ())->cmesh_create ();
+    if (t8_cmesh_is_empty (cmesh)) {
+      /* forest_commit does not support empty cmeshes, we skip this case */
+      scheme->unref ();
+      t8_cmesh_unref (&cmesh);
+      GTEST_SKIP ();
     }
-    if (forest_adapt != NULL) {
-      t8_forest_unref (&forest_adapt);
-    }
-  }
 
-  t8_forest_t forest { NULL };
-  t8_forest_t forest_adapt { NULL };
-  const t8_scheme *scheme;
-};
-
-struct element_is_leaf_hybrid: public testing::TestWithParam<int>
-{
- protected:
-  void
-  SetUp () override
-  {
-    /* Construct a cmesh */
-    const int scheme_id = GetParam ();
-    scheme = create_from_scheme_id (scheme_id);
-    t8_cmesh_t cmesh = t8_cmesh_new_full_hybrid (sc_MPI_COMM_WORLD);
-    const int level = 0;
-    forest = t8_forest_new_uniform (cmesh, scheme, level, 0, sc_MPI_COMM_WORLD);
+    forest = t8_forest_new_uniform (cmesh, scheme, level, 1, sc_MPI_COMM_WORLD);
     t8_forest_ref (forest);
-    int maxlevel = 7;
+    //const int maxlevel = t8_forest_get_maxlevel (forest);
+    int maxlevel = level + 2;
     const int recursive_adapt = 1;
     forest_adapt = t8_forest_new_adapt (forest, t8_test_adapt_first_child, recursive_adapt, 0, &maxlevel);
   }
@@ -153,59 +99,101 @@ t8_test_element_is_leaf_for_forest (t8_forest_t forest)
     t8_element_t *not_leaf;
     scheme->element_new (tree_class, 1, &not_leaf);
     /* Iterate over all the tree's leaf elements, check whether the leaf
-     * is correctly identified by t8_forest_element_is_leaf,
+     * is correctly identified by t8_forest_element_is_leaf and t8_forest_element_is_leaf_or_ghost,
      * build its parent and its first child (if they exist), and verify
-     * that t8_forest_element_is_leaf returns false. */
+     * that t8_forest_element_is_leaf and t8_forest_element_is_leaf_or_ghost returns false. */
     for (t8_locidx_t ielement = 0; ielement < num_elements_in_tree; ++ielement) {
       const t8_element_t *leaf_element = t8_forest_get_leaf_element_in_tree (forest, itree, ielement);
       EXPECT_TRUE (t8_forest_element_is_leaf (forest, leaf_element, itree));
+      EXPECT_TRUE (t8_forest_element_is_leaf_or_ghost (forest, leaf_element, itree, 0));
       /* Compute parent and first child of element and check that they are not in the tree */
       const int element_level = scheme->element_get_level (tree_class, leaf_element);
       if (element_level > 0) {
         scheme->element_get_parent (tree_class, leaf_element, not_leaf);
         EXPECT_FALSE (t8_forest_element_is_leaf (forest, not_leaf, itree));
+        EXPECT_FALSE (t8_forest_element_is_leaf_or_ghost (forest, not_leaf, itree, 0));
       }
-      if (element_level < scheme->get_maxlevel (tree_class)) {
+      if (scheme->element_is_refinable (tree_class, leaf_element)) {
         scheme->element_get_child (tree_class, leaf_element, 0, not_leaf);
         EXPECT_FALSE (t8_forest_element_is_leaf (forest, not_leaf, itree));
+        EXPECT_FALSE (t8_forest_element_is_leaf_or_ghost (forest, not_leaf, itree, 0));
       }
     }
     scheme->element_destroy (tree_class, 1, &not_leaf);
   }
 }
 
-TEST_P (element_is_leaf, element_is_leaf)
+TEST_P (element_is_leaf_or_ghost, element_is_leaf)
 {
   t8_test_element_is_leaf_for_forest (forest);
 }
 
-TEST_P (element_is_leaf, element_is_leaf_adapt)
+TEST_P (element_is_leaf_or_ghost, element_is_leaf_adapt)
 {
   t8_test_element_is_leaf_for_forest (forest_adapt);
 }
 
-TEST_P (element_is_leaf_hybrid, element_is_leaf)
+void
+t8_test_element_is_ghost_for_forest (t8_forest_t forest)
 {
-  t8_test_element_is_leaf_for_forest (forest);
+  const t8_locidx_t num_ghost_trees = t8_forest_get_num_ghost_trees (forest);
+  const t8_locidx_t num_local_trees = t8_forest_get_num_local_trees (forest);
+  const t8_scheme *scheme = t8_forest_get_scheme (forest);
+  for (t8_locidx_t ighost_tree = 0; ighost_tree < num_ghost_trees; ++ighost_tree) {
+    const t8_locidx_t num_elements_in_tree = t8_forest_ghost_tree_num_leaf_elements (forest, ighost_tree);
+    const t8_eclass_t tree_class = t8_forest_get_tree_class (forest, ighost_tree + num_local_trees);
+    /* Allocate memory to build a non-ghost element. */
+    t8_element_t *not_ghost;
+    scheme->element_new (tree_class, 1, &not_ghost);
+    /* Iterate over all the tree's ghost elements, check whether the ghost
+     * is correctly identified by t8_forest_element_is_ghost and t8_forest_element_is_leaf_or_ghost,
+     * build its parent and its first child (if they exist), and verify
+     * that t8_forest_element_is_leaf and t8_forest_element_is_leaf_or_ghost returns false. */
+    for (t8_locidx_t ielement = 0; ielement < num_elements_in_tree; ++ielement) {
+      const t8_element_t *ghost_element = t8_forest_ghost_get_leaf_element (forest, ighost_tree, ielement);
+      EXPECT_TRUE (t8_forest_element_is_ghost (forest, ghost_element, ighost_tree));
+      EXPECT_TRUE (t8_forest_element_is_leaf_or_ghost (forest, ghost_element, ighost_tree, 1));
+      /* Compute parent and first child of element and check that they are not in the tree */
+      const int element_level = scheme->element_get_level (tree_class, ghost_element);
+      if (element_level > 0) {
+        scheme->element_get_parent (tree_class, ghost_element, not_ghost);
+        EXPECT_FALSE (t8_forest_element_is_ghost (forest, not_ghost, ighost_tree));
+        EXPECT_FALSE (t8_forest_element_is_leaf_or_ghost (forest, not_ghost, ighost_tree, 1));
+      }
+      if (scheme->element_is_refinable (tree_class, ghost_element)) {
+        scheme->element_get_child (tree_class, ghost_element, 0, not_ghost);
+        EXPECT_FALSE (t8_forest_element_is_ghost (forest, not_ghost, ighost_tree));
+        EXPECT_FALSE (t8_forest_element_is_leaf_or_ghost (forest, not_ghost, ighost_tree, 1));
+      }
+    }
+    scheme->element_destroy (tree_class, 1, &not_ghost);
+  }
+}
+
+TEST_P (element_is_leaf_or_ghost, element_is_ghost)
+{
+  t8_test_element_is_ghost_for_forest (forest);
 }
 
-TEST_P (element_is_leaf_hybrid, element_is_leaf_adapt)
+TEST_P (element_is_leaf_or_ghost, element_is_ghost_adapt)
 {
   t8_test_element_is_leaf_for_forest (forest_adapt);
 }
 
-/* Define a lambda to beatify gtest output for tuples <level, cmesh>.
- * This will set the correct level and cmesh name as part of the test case name. */
-auto pretty_print_eclass_scheme_and_level
-  = [] (const testing::TestParamInfo<std::tuple<std::tuple<int, t8_eclass_t>, int>> &info) {
-      std::string scheme = t8_scheme_to_string[std::get<0> (std::get<0> (info.param))];
-      std::string eclass = t8_eclass_to_string[std::get<1> (std::get<0> (info.param))];
-      std::string level = std::string ("_level_") + std::to_string (std::get<1> (info.param));
-      return scheme + "_" + eclass + level;
+/* Define a lambda to beautify gtest output for tuples <scheme, level, cmesh>.
+ * This will set the correct scheme, level and cmesh name as part of the test case name. */
+auto pretty_print_level_and_cmesh_params
+  = [] (const testing::TestParamInfo<std::tuple<int, int, cmesh_example_base *>> &info) {
+      std::string name = std::string ("Level_") + std::to_string (std::get<1> (info.param));
+      std::string cmesh_name;
+      std::get<2> (info.param)->param_to_string (cmesh_name);
+      name += std::string ("_") + cmesh_name;
+      name += std::string ("scheme_") + std::to_string (std::get<0> (info.param));
+      name += std::string ("_") + std::to_string (info.index);
+      return name;
     };
 
-INSTANTIATE_TEST_SUITE_P (t8_gtest_element_is_leaf, element_is_leaf,
-                          testing::Combine (AllSchemes, testing::Range (0, T8_IS_LEAF_MAX_LVL)),
-                          pretty_print_eclass_scheme_and_level);
-
-INSTANTIATE_TEST_SUITE_P (t8_gtest_element_is_leaf_hybrid, element_is_leaf_hybrid, AllSchemeCollections, print_scheme);
+INSTANTIATE_TEST_SUITE_P (t8_gtest_element_is_leaf_or_ghost, element_is_leaf_or_ghost,
+                          testing::Combine (AllSchemeCollections, testing::Range (0, T8_IS_LEAF_MAX_LVL),
+                                            AllCmeshsParam),
+                          pretty_print_level_and_cmesh_params);
diff --git a/test/t8_forest/t8_gtest_element_volume.cxx b/test/t8_forest/t8_gtest_element_volume.cxx
index 43efbf5b01..e93eb0d6e2 100644
--- a/test/t8_forest/t8_gtest_element_volume.cxx
+++ b/test/t8_forest/t8_gtest_element_volume.cxx
@@ -22,7 +22,7 @@
 
 #include <sc_functions.h>
 #include <gtest/gtest.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <test/t8_gtest_schemes.hxx>
 #include <t8_schemes/t8_default/t8_default.hxx>
 #include <t8_schemes/t8_default/t8_default_pyramid/t8_dpyramid_bits.h>
diff --git a/test/t8_forest/t8_gtest_find_owner.cxx b/test/t8_forest/t8_gtest_find_owner.cxx
index e748ae35a9..50f4876bb2 100644
--- a/test/t8_forest/t8_gtest_find_owner.cxx
+++ b/test/t8_forest/t8_gtest_find_owner.cxx
@@ -21,7 +21,7 @@
 */
 
 #include <gtest/gtest.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <test/t8_gtest_schemes.hxx>
 #include <t8_cmesh/t8_cmesh.h>
 #include <t8_forest/t8_forest_general.h>
diff --git a/test/t8_forest/t8_gtest_forest_commit.cxx b/test/t8_forest/t8_gtest_forest_commit.cxx
index 7234ecc6db..1ccaedd34f 100644
--- a/test/t8_forest/t8_gtest_forest_commit.cxx
+++ b/test/t8_forest/t8_gtest_forest_commit.cxx
@@ -21,7 +21,7 @@
 */
 
 #include <gtest/gtest.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <t8_cmesh/t8_cmesh.h>
 #include <t8_forest/t8_forest_general.h>
 #include <t8_schemes/t8_default/t8_default.hxx>
@@ -149,7 +149,7 @@ TEST_P (forest_commit, test_forest_commit)
   t8_forest_t forest_ada_bal_part;
   t8_forest_t forest_abp_3part;
 
-  const int level_step = 2;
+  const int level_step = 1;
 
   /* Compute the first level, such that no process is empty */
   int min_level = t8_forest_min_nonempty_level (cmesh, scheme);
@@ -157,7 +157,7 @@ TEST_P (forest_commit, test_forest_commit)
   min_level = SC_MAX (min_level - 1, 0);
   for (int level = min_level; level < min_level + level_step; level++) {
     t8_debugf ("Testing forest commit level %i\n", level);
-    int maxlevel = level + level_step;
+    int maxlevel = level + 2;
     /* ref the cmesh since we reuse it */
     t8_cmesh_ref (cmesh);
     /* Create a uniformly refined forest */
diff --git a/test/t8_forest/t8_gtest_forest_face_normal.cxx b/test/t8_forest/t8_gtest_forest_face_normal.cxx
index 13f6d1a4a8..e48c7d8efe 100644
--- a/test/t8_forest/t8_gtest_forest_face_normal.cxx
+++ b/test/t8_forest/t8_gtest_forest_face_normal.cxx
@@ -22,7 +22,7 @@
 
 #include <sc_functions.h>
 #include <gtest/gtest.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <t8_schemes/t8_scheme.hxx>
 #include <t8_cmesh/t8_cmesh_examples.h>
 #include <t8_forest/t8_forest_general.h>
diff --git a/test/t8_forest/t8_gtest_ghost_and_owner.cxx b/test/t8_forest/t8_gtest_ghost_and_owner.cxx
index 69dd9eae61..ac705b832b 100644
--- a/test/t8_forest/t8_gtest_ghost_and_owner.cxx
+++ b/test/t8_forest/t8_gtest_ghost_and_owner.cxx
@@ -21,7 +21,7 @@
 */
 
 #include <gtest/gtest.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <t8_schemes/t8_default/t8_default.hxx>
 #include <t8_forest/t8_forest_general.h>
 #include <t8_forest/t8_forest_ghost.h>
@@ -130,9 +130,9 @@ TEST_P (forest_ghost_owner, test_ghost_owner)
   min_level = SC_MAX (0, min_level - 1);
   t8_debugf ("Testing ghost exchange with start level %i\n", min_level);
 #if T8_TEST_LEVEL_INT >= 2
-  const int max_level = min_level + 2;
+  const int max_level = min_level + 1;
 #else
-  const int max_level = min_level + 3;
+  const int max_level = min_level + 2;
 #endif
   for (int level = min_level; level < max_level; level++) {
     /* ref the scheme since we reuse it */
@@ -144,8 +144,8 @@ TEST_P (forest_ghost_owner, test_ghost_owner)
     /* Check the owners of the ghost elements */
     t8_test_gao_check (forest);
     /* Adapt the forest and exchange data again */
-    int maxlevel = level + 2;
-    t8_forest_t forest_adapt = t8_forest_new_adapt (forest, t8_test_gao_adapt, 1, 1, &maxlevel);
+    int adapt_maxlevel = level + 2;
+    t8_forest_t forest_adapt = t8_forest_new_adapt (forest, t8_test_gao_adapt, 1, 1, &adapt_maxlevel);
     /* Check the owners of the ghost elements */
     t8_test_gao_check (forest_adapt);
     t8_forest_unref (&forest_adapt);
diff --git a/test/t8_forest/t8_gtest_ghost_delete.cxx b/test/t8_forest/t8_gtest_ghost_delete.cxx
index ea7e37ce71..65a8e01e75 100644
--- a/test/t8_forest/t8_gtest_ghost_delete.cxx
+++ b/test/t8_forest/t8_gtest_ghost_delete.cxx
@@ -21,7 +21,7 @@
 */
 
 #include <gtest/gtest.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <t8_schemes/t8_default/t8_default.hxx>
 #include <t8_forest/t8_forest_general.h>
 #include <t8_forest/t8_forest_geometrical.h>
diff --git a/test/t8_forest/t8_gtest_ghost_exchange.cxx b/test/t8_forest/t8_gtest_ghost_exchange.cxx
index 4c05fe6db8..e90514a04f 100644
--- a/test/t8_forest/t8_gtest_ghost_exchange.cxx
+++ b/test/t8_forest/t8_gtest_ghost_exchange.cxx
@@ -21,7 +21,7 @@
 */
 
 #include <gtest/gtest.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <t8_schemes/t8_default/t8_default.hxx>
 #include <t8_forest/t8_forest_general.h>
 #include <t8_forest/t8_forest_ghost.h>
@@ -180,9 +180,9 @@ TEST_P (forest_ghost_exchange, test_ghost_exchange)
   /* we start with an empty level */
   min_level = SC_MAX (min_level - 1, 0);
 #if T8_TEST_LEVEL_INT >= 2
-  const int max_level = min_level + 2;
+  const int max_level = min_level + 1;
 #else
-  const int max_level = min_level + 3;
+  const int max_level = min_level + 2;
 #endif
   for (int level = min_level; level < max_level; level++) {
     /* ref the scheme since we reuse it */
@@ -195,8 +195,8 @@ TEST_P (forest_ghost_exchange, test_ghost_exchange)
     t8_test_ghost_exchange_data_int (forest);
     t8_test_ghost_exchange_data_id (forest);
     /* Adapt the forest and exchange data again */
-    int maxlevel = level + 2;
-    t8_forest_t forest_adapt = t8_forest_new_adapt (forest, t8_test_exchange_adapt, 1, 1, &maxlevel);
+    int adapt_maxlevel = level + 2;
+    t8_forest_t forest_adapt = t8_forest_new_adapt (forest, t8_test_exchange_adapt, 1, 1, &adapt_maxlevel);
     t8_test_ghost_exchange_data_int (forest_adapt);
     t8_test_ghost_exchange_data_id (forest_adapt);
     t8_forest_unref (&forest_adapt);
diff --git a/test/t8_forest/t8_gtest_half_neighbors.cxx b/test/t8_forest/t8_gtest_half_neighbors.cxx
index 918b642f21..b40fe34212 100644
--- a/test/t8_forest/t8_gtest_half_neighbors.cxx
+++ b/test/t8_forest/t8_gtest_half_neighbors.cxx
@@ -24,7 +24,7 @@
 #include <test/t8_gtest_custom_assertion.hxx>
 #include <test/t8_gtest_memory_macros.hxx>
 
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <t8_cmesh/t8_cmesh.h>
 #include <t8_forest/t8_forest_general.h>
 #include <t8_forest/t8_forest_types.h>
diff --git a/test/t8_forest/t8_gtest_search.cxx b/test/t8_forest/t8_gtest_search.cxx
index 214021dec6..1a454d21d4 100644
--- a/test/t8_forest/t8_gtest_search.cxx
+++ b/test/t8_forest/t8_gtest_search.cxx
@@ -22,7 +22,7 @@
 
 #include <gtest/gtest.h>
 #include <test/t8_gtest_custom_assertion.hxx>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <t8_cmesh/t8_cmesh.h>
 #include <t8_cmesh/t8_cmesh_examples.h>
 #include <t8_forest/t8_forest_general.h>
diff --git a/test/t8_forest/t8_gtest_transform.cxx b/test/t8_forest/t8_gtest_transform.cxx
index 66593080a7..e949869782 100644
--- a/test/t8_forest/t8_gtest_transform.cxx
+++ b/test/t8_forest/t8_gtest_transform.cxx
@@ -30,7 +30,7 @@
 #include <gtest/gtest.h>
 #include <test/t8_gtest_custom_assertion.hxx>
 
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <t8_cmesh/t8_cmesh.h>
 #include <t8_cmesh/t8_cmesh_examples.h>
 #include <t8_forest/t8_forest_general.h>
diff --git a/test/t8_geometry/t8_geometry_implementations/t8_gtest_geometry_cad.cxx b/test/t8_geometry/t8_geometry_implementations/t8_gtest_geometry_cad.cxx
index c3f8584e57..e920c36ceb 100644
--- a/test/t8_geometry/t8_geometry_implementations/t8_gtest_geometry_cad.cxx
+++ b/test/t8_geometry/t8_geometry_implementations/t8_gtest_geometry_cad.cxx
@@ -23,13 +23,13 @@
 #include <gtest/gtest.h>
 #include <t8_cmesh/t8_cmesh.hxx>
 #include <t8_forest/t8_forest_general.h>
-#include <t8_vtk.h>
+#include <t8_vtk/t8_vtk.h>
 #include <t8_schemes/t8_default/t8_default.hxx>
 #include <t8_geometry/t8_geometry_implementations/t8_geometry_cad.hxx>
 #include <t8_cmesh/t8_cmesh_examples.h>
 #include <test/t8_gtest_macros.hxx>
 #include <test/t8_gtest_custom_assertion.hxx>
-#include <t8_element.h>
+#include <t8_element/t8_element.h>
 #include <t8_vtk/t8_vtk_writer.h>
 #include <t8_types/t8_vec.hxx>
 
@@ -48,7 +48,7 @@
 #include <Geom_BSplineSurface.hxx>
 #include <TopoDS_Face.hxx>
 #include <TopoDS_Edge.hxx>
-#include <t8_element.h>
+#include <t8_element/t8_element.h>
 
 #include <test/t8_gtest_custom_assertion.hxx>
 
diff --git a/test/t8_geometry/t8_geometry_implementations/t8_gtest_geometry_lagrange.cxx b/test/t8_geometry/t8_geometry_implementations/t8_gtest_geometry_lagrange.cxx
index 778df8c415..a0ada582c8 100644
--- a/test/t8_geometry/t8_geometry_implementations/t8_gtest_geometry_lagrange.cxx
+++ b/test/t8_geometry/t8_geometry_implementations/t8_gtest_geometry_lagrange.cxx
@@ -32,7 +32,7 @@
 
 #include <gtest/gtest.h>
 #include <test/t8_gtest_macros.hxx>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <t8_types/t8_vec.hxx>
 #include <t8_cmesh/t8_cmesh.hxx>
 #include <t8_vtk/t8_vtk_writer.h>
diff --git a/test/t8_geometry/t8_geometry_implementations/t8_gtest_geometry_linear.cxx b/test/t8_geometry/t8_geometry_implementations/t8_gtest_geometry_linear.cxx
index 6c117c9227..0b6d84c007 100644
--- a/test/t8_geometry/t8_geometry_implementations/t8_gtest_geometry_linear.cxx
+++ b/test/t8_geometry/t8_geometry_implementations/t8_gtest_geometry_linear.cxx
@@ -27,13 +27,13 @@
 #include <test/t8_gtest_macros.hxx>
 #include <test/t8_gtest_custom_assertion.hxx>
 #include <gtest/gtest.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <t8_cmesh/t8_cmesh.hxx>
 #include <t8_cmesh/t8_cmesh_examples.h>
 #include <t8_geometry/t8_geometry.h>
 #include <t8_geometry/t8_geometry_implementations/t8_geometry_linear.hxx>
 #include <t8_geometry/t8_geometry_implementations/t8_geometry_linear_axis_aligned.hxx>
-#include <t8_element.h>
+#include <t8_element/t8_element.h>
 #include <t8_types/t8_vec.hxx>
 
 struct geometry_test: public testing::TestWithParam<std::tuple<int, t8_eclass>>
diff --git a/test/t8_geometry/t8_gtest_geometry_handling.cxx b/test/t8_geometry/t8_gtest_geometry_handling.cxx
index 42bd429659..0617cc049f 100644
--- a/test/t8_geometry/t8_gtest_geometry_handling.cxx
+++ b/test/t8_geometry/t8_gtest_geometry_handling.cxx
@@ -25,7 +25,7 @@
  */
 
 #include <gtest/gtest.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <t8_cmesh/t8_cmesh.hxx>
 #include <t8_vtk/t8_vtk_writer.h>
 #include <t8_cmesh/t8_cmesh_examples.h>
diff --git a/test/t8_geometry/t8_gtest_geometry_negative_volume.cxx b/test/t8_geometry/t8_gtest_geometry_negative_volume.cxx
index 1b218bff12..bc8a09b109 100644
--- a/test/t8_geometry/t8_gtest_geometry_negative_volume.cxx
+++ b/test/t8_geometry/t8_gtest_geometry_negative_volume.cxx
@@ -26,7 +26,7 @@
 */
 
 #include <gtest/gtest.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <t8_cmesh/t8_cmesh.hxx>
 #include <t8_geometry/t8_geometry_implementations/t8_geometry_linear.hxx>
 #include <test/t8_gtest_memory_macros.hxx>
diff --git a/test/t8_geometry/t8_gtest_point_inside.cxx b/test/t8_geometry/t8_gtest_point_inside.cxx
index d7f80d64b3..40e05ea735 100644
--- a/test/t8_geometry/t8_gtest_point_inside.cxx
+++ b/test/t8_geometry/t8_gtest_point_inside.cxx
@@ -23,7 +23,7 @@
 #include <gtest/gtest.h>
 #include <test/t8_gtest_memory_macros.hxx>
 #include <sc_functions.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <t8_cmesh/t8_cmesh.hxx>
 #include <t8_cmesh/t8_cmesh_examples.h>
 #include <t8_forest/t8_forest_general.h>
diff --git a/test/t8_gtest_adapt_callbacks.cxx b/test/t8_gtest_adapt_callbacks.cxx
new file mode 100644
index 0000000000..bab9f26a08
--- /dev/null
+++ b/test/t8_gtest_adapt_callbacks.cxx
@@ -0,0 +1,58 @@
+/*
+  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_adapt_callbacks.cxx
+* Provide forest adapt callback functions that we use in our tests.
+*/
+
+#include <test/t8_gtest_adapt_callbacks.hxx>
+
+/* Adapt a forest such that always the first child of a
+ * family is refined and no other elements. This results in a highly
+ * imbalanced forest.
+ * 
+ * This adapt callbacks requires an integer as forest user data.
+ * This integer is the maximum refinement level.
+ */
+int
+t8_test_adapt_first_child (t8_forest_t forest, [[maybe_unused]] t8_forest_t forest_from,
+                           [[maybe_unused]] t8_locidx_t which_tree, const t8_eclass_t eclass,
+                           [[maybe_unused]] t8_locidx_t lelement_id, const t8_scheme *scheme,
+                           [[maybe_unused]] const int is_family, [[maybe_unused]] const int num_elements,
+                           t8_element_t *elements[])
+{
+  T8_ASSERT (!is_family || (is_family && num_elements == scheme->element_get_num_children (eclass, elements[0])));
+
+  int level = scheme->element_get_level (eclass, elements[0]);
+
+  /* we set a maximum refinement level as forest user data */
+  int maxlevel = *(int *) t8_forest_get_user_data (forest);
+  if (level >= maxlevel) {
+    /* Do not refine after the maxlevel */
+    return 0;
+  }
+  int child_id = scheme->element_get_child_id (eclass, elements[0]);
+  if (child_id == 1) {
+    return 1;
+  }
+  return 0;
+}
diff --git a/test/t8_gtest_adapt_callbacks.hxx b/test/t8_gtest_adapt_callbacks.hxx
new file mode 100644
index 0000000000..6198d0ab5e
--- /dev/null
+++ b/test/t8_gtest_adapt_callbacks.hxx
@@ -0,0 +1,56 @@
+/*
+  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_adapt_callbacks.hxx
+* Provide forest adapt callback functions that we use in our tests.
+*/
+
+#ifndef T8_GTEST_ADAPT_CALLBACKS
+#define T8_GTEST_ADAPT_CALLBACKS
+
+#include <src/t8_forest/t8_forest_general.h>
+#include <t8_schemes/t8_scheme.hxx>
+
+/** Adapt a forest such that always the first child of a
+ * family is refined and no other elements. This results in a highly
+ * imbalanced forest.
+ * 
+ * This adapt callbacks requires an integer as forest user data.
+ * This integer is the maximum refinement level.
+ * 
+ * \param [in] forest       The forest to which the new elements belong.
+ * \param [in] forest_from  The forest that is adapted.
+ * \param [in] which_tree   The local tree containing \a elements.
+ * \param [in] eclass   The eclass of \a which_tree.
+ * \param [in] lelement_id  The local element id in \a forest_from in the tree of the current element.
+ * \param [in] scheme       The scheme of the forest.
+ * \param [in] is_family    If 1, the first \a num_elements entries in \a elements form a family. If 0, they do not.
+ * \param [in] num_elements The number of entries in \a elements that are defined
+ * \param [in] elements     Pointers to a family or, if \a is_family is zero,
+ *                          pointer to one element.
+ */
+int
+t8_test_adapt_first_child (t8_forest_t forest, t8_forest_t forest_from, t8_locidx_t which_tree,
+                           const t8_eclass_t eclass, t8_locidx_t lelement_id, const t8_scheme *scheme,
+                           const int is_family, const int num_elements, t8_element_t *elements[]);
+
+#endif /* T8_GTEST_ADAPT_CALLBACKS */
diff --git a/test/t8_gtest_eclass.cxx b/test/t8_gtest_eclass.cxx
index 31f112cf55..2e2703bf61 100644
--- a/test/t8_gtest_eclass.cxx
+++ b/test/t8_gtest_eclass.cxx
@@ -21,7 +21,7 @@
 */
 
 #include <gtest/gtest.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <t8_cmesh/t8_cmesh.h>
 #include <t8_cmesh/t8_cmesh_examples.h>
 #include <t8_types/t8_vec.h>
diff --git a/test/t8_gtest_macros.hxx b/test/t8_gtest_macros.hxx
index 8074015463..3dc651674b 100644
--- a/test/t8_gtest_macros.hxx
+++ b/test/t8_gtest_macros.hxx
@@ -28,11 +28,12 @@
 #define T8_GTEST_MACROS_HXX
 
 #include <gtest/gtest.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <t8_schemes/t8_default/t8_default.hxx>
 #include <iostream>
 #include <t8_schemes/t8_scheme.hxx>
 #include <test/t8_gtest_memory_macros.hxx>
+#include <test/t8_gtest_schemes.hxx>
 
 /**
  * lambda to pass to an INSTANTIATE_TEST_SUITE_P to print the current cmesh_example_base
@@ -41,6 +42,16 @@
 inline auto print_eclass
   = [] (const testing::TestParamInfo<t8_eclass> &info) { return t8_eclass_to_string[info.param]; };
 
+/** Define a lambda to beautify gtest output for tuples <<scheme, eclass>, level>.
+ * This will set the correct level and cmesh name as part of the test case name. */
+auto pretty_print_eclass_scheme_and_level
+  = [] (const testing::TestParamInfo<std::tuple<std::tuple<int, t8_eclass_t>, int>> &info) {
+      std::string scheme = t8_scheme_to_string[std::get<0> (std::get<0> (info.param))];
+      std::string eclass = t8_eclass_to_string[std::get<1> (std::get<0> (info.param))];
+      std::string level = std::string ("_level_") + std::to_string (std::get<1> (info.param));
+      return scheme + "_" + eclass + level;
+    };
+
 /**
  * Initializes everything needed for the t8code testsuite.
  * MPI is initialized with MPI_COMM_WORLD and SC with loglevel SC_LP_PRODUCTION.
diff --git a/test/t8_gtest_mat.cxx b/test/t8_gtest_mat.cxx
index fa6b3c5654..895cae3c5d 100644
--- a/test/t8_gtest_mat.cxx
+++ b/test/t8_gtest_mat.cxx
@@ -23,7 +23,7 @@
 /* In this file we collect tests for the routines in `t8_mat.h`. */
 
 #include <t8.h>
-#include <t8_mat.h>
+#include <t8_helper_functions/t8_mat.h>
 #include <gtest/gtest.h>
 
 /* Test the `t8_mat_mult_vec` function. Here we also test the rotation matrices
diff --git a/test/t8_gtest_memory_macros.hxx b/test/t8_gtest_memory_macros.hxx
index 2eccf9acb5..99ccc7ccb1 100644
--- a/test/t8_gtest_memory_macros.hxx
+++ b/test/t8_gtest_memory_macros.hxx
@@ -27,7 +27,7 @@
 #ifndef T8_GTEST_MEMORY_MACROS_HXX
 #define T8_GTEST_MEMORY_MACROS_HXX
 
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <t8_schemes/t8_default/t8_default.hxx>
 #include <iostream>
 #include <t8_schemes/t8_scheme.hxx>
diff --git a/test/t8_gtest_refcount.cxx b/test/t8_gtest_refcount.cxx
index 09ef36559d..e0d3f0d31e 100644
--- a/test/t8_gtest_refcount.cxx
+++ b/test/t8_gtest_refcount.cxx
@@ -21,7 +21,7 @@
 */
 
 #include <gtest/gtest.h>
-#include <t8_refcount.h>
+#include <t8_helper_functions/t8_refcount.h>
 
 TEST (t8_gtest_refcount, Init)
 {
diff --git a/test/t8_gtest_version.cxx b/test/t8_gtest_version.cxx
index 5331f76b99..462fd9d200 100644
--- a/test/t8_gtest_version.cxx
+++ b/test/t8_gtest_version.cxx
@@ -21,7 +21,7 @@
 */
 
 #include <gtest/gtest.h>
-#include <t8_version.h>
+#include <t8_misc/t8_version.h>
 
 /* The following three tests check whether t8code computes the correct
  * version.
diff --git a/test/t8_schemes/t8_gtest_ancestor.cxx b/test/t8_schemes/t8_gtest_ancestor.cxx
index 5b48eb596d..4d45a8a817 100644
--- a/test/t8_schemes/t8_gtest_ancestor.cxx
+++ b/test/t8_schemes/t8_gtest_ancestor.cxx
@@ -28,7 +28,7 @@
 #include <gtest/gtest.h>
 #include <test/t8_gtest_custom_assertion.hxx>
 #include <test/t8_gtest_macros.hxx>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <t8_schemes/t8_default/t8_default_pyramid/t8_dpyramid_bits.h>
 #include <test/t8_gtest_schemes.hxx>
 
diff --git a/test/t8_schemes/t8_gtest_ancestor_id.cxx b/test/t8_schemes/t8_gtest_ancestor_id.cxx
index 7a0c01a92a..9e36fc13fa 100644
--- a/test/t8_schemes/t8_gtest_ancestor_id.cxx
+++ b/test/t8_schemes/t8_gtest_ancestor_id.cxx
@@ -27,7 +27,7 @@
  */
 
 #include <gtest/gtest.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <t8_schemes/t8_default/t8_default.hxx>
 #include <test/t8_gtest_custom_assertion.hxx>
 #include "t8_gtest_dfs_base.hxx"
diff --git a/test/t8_schemes/t8_gtest_bfs_base.hxx b/test/t8_schemes/t8_gtest_bfs_base.hxx
index 2fc03bcd21..22fa02f72c 100644
--- a/test/t8_schemes/t8_gtest_bfs_base.hxx
+++ b/test/t8_schemes/t8_gtest_bfs_base.hxx
@@ -29,7 +29,7 @@
 #define T8_GTEST_BFS_BASE_HXX
 
 #include <gtest/gtest.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <test/t8_gtest_schemes.hxx>
 #include <queue>
 
diff --git a/test/t8_schemes/t8_gtest_boundary_extrude.cxx b/test/t8_schemes/t8_gtest_boundary_extrude.cxx
index eacd6bff2e..4b6abe640b 100644
--- a/test/t8_schemes/t8_gtest_boundary_extrude.cxx
+++ b/test/t8_schemes/t8_gtest_boundary_extrude.cxx
@@ -21,7 +21,7 @@
 */
 
 #include <gtest/gtest.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <t8_schemes/t8_default/t8_default.hxx>
 #include <test/t8_gtest_custom_assertion.hxx>
 #include <test/t8_gtest_macros.hxx>
diff --git a/test/t8_schemes/t8_gtest_child_parent_face.cxx b/test/t8_schemes/t8_gtest_child_parent_face.cxx
index ad5785e30e..1f6805f435 100644
--- a/test/t8_schemes/t8_gtest_child_parent_face.cxx
+++ b/test/t8_schemes/t8_gtest_child_parent_face.cxx
@@ -21,7 +21,7 @@
 */
 
 #include <gtest/gtest.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <t8_schemes/t8_default/t8_default.hxx>
 #include <test/t8_gtest_custom_assertion.hxx>
 #include "t8_gtest_dfs_base.hxx"
diff --git a/test/t8_schemes/t8_gtest_descendant.cxx b/test/t8_schemes/t8_gtest_descendant.cxx
index 8fb0604c77..5c5a611825 100644
--- a/test/t8_schemes/t8_gtest_descendant.cxx
+++ b/test/t8_schemes/t8_gtest_descendant.cxx
@@ -21,7 +21,7 @@
 */
 
 #include <gtest/gtest.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <test/t8_gtest_schemes.hxx>
 #include <test/t8_gtest_custom_assertion.hxx>
 #include <test/t8_gtest_macros.hxx>
diff --git a/test/t8_schemes/t8_gtest_dfs_base.hxx b/test/t8_schemes/t8_gtest_dfs_base.hxx
index 2f9d395423..f51bb1e3c6 100644
--- a/test/t8_schemes/t8_gtest_dfs_base.hxx
+++ b/test/t8_schemes/t8_gtest_dfs_base.hxx
@@ -29,7 +29,7 @@
 #define T8_GTEST_DFS_BASE_HXX
 
 #include <gtest/gtest.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <test/t8_gtest_schemes.hxx>
 
 /** A base class for depth first search tests. */
diff --git a/test/t8_schemes/t8_gtest_element_ref_coords.cxx b/test/t8_schemes/t8_gtest_element_ref_coords.cxx
index 97ee0f62d4..deecc3894d 100644
--- a/test/t8_schemes/t8_gtest_element_ref_coords.cxx
+++ b/test/t8_schemes/t8_gtest_element_ref_coords.cxx
@@ -26,7 +26,7 @@
 */
 
 #include <gtest/gtest.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <t8_types/t8_vec.h>
 #include <t8_schemes/t8_default/t8_default.hxx>
 #include <t8_forest/t8_forest.h>
diff --git a/test/t8_schemes/t8_gtest_elements_are_family.cxx b/test/t8_schemes/t8_gtest_elements_are_family.cxx
index 365b645edd..e0d3a5f876 100644
--- a/test/t8_schemes/t8_gtest_elements_are_family.cxx
+++ b/test/t8_schemes/t8_gtest_elements_are_family.cxx
@@ -21,7 +21,7 @@
 */
 
 #include <gtest/gtest.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <test/t8_gtest_schemes.hxx>
 #include <test/t8_gtest_macros.hxx>
 #include "t8_gtest_dfs_base.hxx"
diff --git a/test/t8_schemes/t8_gtest_equal.cxx b/test/t8_schemes/t8_gtest_equal.cxx
index fdf98b39ba..731f32b447 100644
--- a/test/t8_schemes/t8_gtest_equal.cxx
+++ b/test/t8_schemes/t8_gtest_equal.cxx
@@ -21,7 +21,7 @@
 */
 
 #include <gtest/gtest.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <test/t8_gtest_schemes.hxx>
 #include <test/t8_gtest_custom_assertion.hxx>
 #include <test/t8_gtest_macros.hxx>
diff --git a/test/t8_schemes/t8_gtest_face_corner.cxx b/test/t8_schemes/t8_gtest_face_corner.cxx
index 3d17d6ba01..bb6cfc36fb 100644
--- a/test/t8_schemes/t8_gtest_face_corner.cxx
+++ b/test/t8_schemes/t8_gtest_face_corner.cxx
@@ -21,7 +21,7 @@
 */
 
 #include <gtest/gtest.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <test/t8_gtest_schemes.hxx>
 #include <test/t8_gtest_custom_assertion.hxx>
 #include <test/t8_gtest_macros.hxx>
diff --git a/test/t8_schemes/t8_gtest_face_descendant.cxx b/test/t8_schemes/t8_gtest_face_descendant.cxx
index 32c3db6f20..b3d7d1aa94 100644
--- a/test/t8_schemes/t8_gtest_face_descendant.cxx
+++ b/test/t8_schemes/t8_gtest_face_descendant.cxx
@@ -21,7 +21,7 @@
 */
 
 #include <gtest/gtest.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <test/t8_gtest_schemes.hxx>
 #include <test/t8_gtest_custom_assertion.hxx>
 #include <test/t8_gtest_macros.hxx>
diff --git a/test/t8_schemes/t8_gtest_face_neigh.cxx b/test/t8_schemes/t8_gtest_face_neigh.cxx
index 875b9e536a..e1f3c81b6e 100644
--- a/test/t8_schemes/t8_gtest_face_neigh.cxx
+++ b/test/t8_schemes/t8_gtest_face_neigh.cxx
@@ -22,7 +22,7 @@
 
 #include <gtest/gtest.h>
 #include <test/t8_gtest_custom_assertion.hxx>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <test/t8_gtest_schemes.hxx>
 #include <test/t8_gtest_macros.hxx>
 
diff --git a/test/t8_schemes/t8_gtest_find_parent.cxx b/test/t8_schemes/t8_gtest_find_parent.cxx
index 6f58b165e5..d92c163170 100644
--- a/test/t8_schemes/t8_gtest_find_parent.cxx
+++ b/test/t8_schemes/t8_gtest_find_parent.cxx
@@ -21,7 +21,7 @@
 */
 
 #include <gtest/gtest.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <test/t8_gtest_schemes.hxx>
 #include <test/t8_gtest_custom_assertion.hxx>
 #include "t8_gtest_dfs_base.hxx"
diff --git a/test/t8_schemes/t8_gtest_get_linear_id.cxx b/test/t8_schemes/t8_gtest_get_linear_id.cxx
index 62764c3924..5bd386daf0 100644
--- a/test/t8_schemes/t8_gtest_get_linear_id.cxx
+++ b/test/t8_schemes/t8_gtest_get_linear_id.cxx
@@ -21,7 +21,7 @@
 */
 
 #include <gtest/gtest.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <t8_forest/t8_forest_general.h>
 #include <test/t8_gtest_schemes.hxx>
 #include <sc_functions.h>
diff --git a/test/t8_schemes/t8_gtest_input_equal_output.cxx b/test/t8_schemes/t8_gtest_input_equal_output.cxx
index 7738482073..7bf52f04d5 100644
--- a/test/t8_schemes/t8_gtest_input_equal_output.cxx
+++ b/test/t8_schemes/t8_gtest_input_equal_output.cxx
@@ -21,7 +21,7 @@
 */
 
 #include <gtest/gtest.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <test/t8_gtest_schemes.hxx>
 #include <test/t8_gtest_custom_assertion.hxx>
 #include <test/t8_gtest_macros.hxx>
diff --git a/test/t8_schemes/t8_gtest_is_ancestor.cxx b/test/t8_schemes/t8_gtest_is_ancestor.cxx
new file mode 100644
index 0000000000..e626534558
--- /dev/null
+++ b/test/t8_schemes/t8_gtest_is_ancestor.cxx
@@ -0,0 +1,94 @@
+/*
+  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_is_ancestor.cxx
+ * This test checks the element_is_ancestor function of the scheme interface.
+ * Starting from an element we build up all its ancestor up to root level and 
+ * test whether the element_is_ancestor function returns true.
+ * We also test sone cases where the function returns false, namely when putting
+ * in an element and an ancestor in reverse order.
+ * 
+ * This test is modified from the ancestor_id test.
+ */
+
+#include <gtest/gtest.h>
+#include <t8_eclass/t8_eclass.h>
+#include <t8_schemes/t8_default/t8_default.hxx>
+#include <test/t8_gtest_custom_assertion.hxx>
+#include "t8_gtest_dfs_base.hxx"
+#include <test/t8_gtest_macros.hxx>
+
+class class_is_ancestor: public TestDFS {
+  void
+  check_element () override
+  {
+    t8_element_t *ancestor;
+    scheme->element_new (eclass, 1, &ancestor);
+    /* Get level of current element */
+    const int level = scheme->element_get_level (eclass, element);
+
+    /* Iterate over all levels above the current element and check
+    if ancestor id corresponds with the child id of elem, parent, grandparent, ... */
+    for (int levels_above_elem = 0; levels_above_elem < level; levels_above_elem++) {
+      const int ancestor_level = level - levels_above_elem;
+      /* Compute the ancestor by iteratively computing the parent */
+      scheme->element_copy (eclass, element, ancestor);
+      for (int level_diff = 0; level_diff < levels_above_elem; level_diff++) {
+        scheme->element_get_parent (eclass, ancestor, ancestor);
+      }
+      // Check whether element_is_ancestor correctly identifies our candidate as an ancestor
+      EXPECT_TRUE (scheme->element_is_ancestor (eclass, ancestor, element));
+      // We check that element_is_ancestor properly returns false by
+      // checking that element is not an ancestor of our candidate if their levels do not agree.
+      if (ancestor_level != level) {
+        EXPECT_FALSE (scheme->element_is_ancestor (eclass, element, ancestor));
+      }
+    }
+    scheme->element_destroy (eclass, 1, &ancestor);
+  }
+
+ protected:
+  void
+  SetUp () override
+  {
+    /* Setup DFS test */
+    dfs_test_setup ();
+  }
+  void
+  TearDown () override
+  {
+    /* Destroy DFS test */
+    dfs_test_teardown ();
+  }
+};
+
+TEST_P (class_is_ancestor, t8_recursive_dfs_is_ancestor)
+{
+#if T8_TEST_LEVEL_INT >= 1  // test level medium or lower
+  const int maxlvl = 4;
+#else
+  const int maxlvl = 6;  // test level full
+#endif
+  check_recursive_dfs_to_max_lvl (maxlvl);
+}
+
+INSTANTIATE_TEST_SUITE_P (t8_gtest_is_ancestor, class_is_ancestor, AllSchemes, print_all_schemes);
diff --git a/test/t8_schemes/t8_gtest_nca.cxx b/test/t8_schemes/t8_gtest_nca.cxx
index 252911581a..a8521d31a0 100644
--- a/test/t8_schemes/t8_gtest_nca.cxx
+++ b/test/t8_schemes/t8_gtest_nca.cxx
@@ -27,7 +27,7 @@
 
 #include <gtest/gtest.h>
 #include <test/t8_gtest_custom_assertion.hxx>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <test/t8_gtest_schemes.hxx>
 #include <test/t8_gtest_macros.hxx>
 
@@ -81,6 +81,10 @@ TEST_P (nca, nca_check_shallow)
       scheme->element_get_nca (tree_class, desc_a, desc_b, check);
       /*expect equality */
       EXPECT_ELEM_EQ (scheme, tree_class, check, correct_nca);
+      // Check against element_is_ancestor. This adds another test layer
+      // to both element_get_nca and element_is_ancestor.
+      EXPECT_TRUE (scheme->element_is_ancestor (tree_class, check, desc_a));
+      EXPECT_TRUE (scheme->element_is_ancestor (tree_class, check, desc_b));
     }
   }
 }
@@ -125,6 +129,10 @@ TEST_P (nca, nca_check_deep)
             /* Expect equality of correct_nca and check for every other class */
             EXPECT_ELEM_EQ (scheme, tree_class, correct_nca, check);
           }
+          // Check against element_is_ancestor. This adds another test layer
+          // to both element_get_nca and element_is_ancestor.
+          EXPECT_TRUE (scheme->element_is_ancestor (tree_class, check, desc_a));
+          EXPECT_TRUE (scheme->element_is_ancestor (tree_class, check, desc_b));
         }
       }
     }
@@ -179,6 +187,10 @@ t8_recursive_nca_check (t8_element_t *check_nca, t8_element_t *desc_a, t8_elemen
     for (j = 0; j < num_children_b; j++) {
       scheme->element_get_child (tree_class, parent_b, j, desc_b);
       scheme->element_get_nca (tree_class, desc_a, desc_b, check);
+      // Check against element_is_ancestor. This adds another test layer
+      // to both element_get_nca and element_is_ancestor.
+      EXPECT_TRUE (scheme->element_is_ancestor (tree_class, check, desc_a));
+      EXPECT_TRUE (scheme->element_is_ancestor (tree_class, check, desc_b));
 
       if (!scheme->element_is_equal (tree_class, check_nca, check)) {
         level_a = scheme->element_get_level (tree_class, desc_a);
@@ -307,6 +319,10 @@ TEST_P (nca, recursive_check_higher_level)
             scheme->element_get_nca (tree_class, parent_a, parent_b, check);
             EXPECT_ELEM_EQ (scheme, tree_class, parent_a, check);
             EXPECT_ELEM_EQ (scheme, tree_class, parent_b, check);
+            // Check against element_is_ancestor. This adds another test layer
+            // to both element_get_nca and element_is_ancestor.
+            EXPECT_TRUE (scheme->element_is_ancestor (tree_class, check, parent_a));
+            EXPECT_TRUE (scheme->element_is_ancestor (tree_class, check, parent_b));
           }
         }
       }
diff --git a/test/t8_schemes/t8_gtest_pack_unpack.cxx b/test/t8_schemes/t8_gtest_pack_unpack.cxx
index 0a70d5b383..33fcbdde1c 100644
--- a/test/t8_schemes/t8_gtest_pack_unpack.cxx
+++ b/test/t8_schemes/t8_gtest_pack_unpack.cxx
@@ -21,7 +21,7 @@
 */
 
 #include <gtest/gtest.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <test/t8_gtest_custom_assertion.hxx>
 #include <test/t8_gtest_macros.hxx>
 #include <test/t8_gtest_schemes.hxx>
diff --git a/test/t8_schemes/t8_gtest_root.cxx b/test/t8_schemes/t8_gtest_root.cxx
index 41711c24bd..bbc04b12c0 100644
--- a/test/t8_schemes/t8_gtest_root.cxx
+++ b/test/t8_schemes/t8_gtest_root.cxx
@@ -27,7 +27,7 @@
 #include <test/t8_gtest_custom_assertion.hxx>
 #include <test/t8_gtest_macros.hxx>
 #include <test/t8_gtest_schemes.hxx>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <t8_schemes/t8_default/t8_default.hxx>
 #include <test/t8_gtest_macros.hxx>
 
diff --git a/test/t8_schemes/t8_gtest_set_linear_id.cxx b/test/t8_schemes/t8_gtest_set_linear_id.cxx
index 38fb7bd583..c0b61b09b9 100644
--- a/test/t8_schemes/t8_gtest_set_linear_id.cxx
+++ b/test/t8_schemes/t8_gtest_set_linear_id.cxx
@@ -21,7 +21,7 @@
 */
 
 #include <gtest/gtest.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <test/t8_gtest_schemes.hxx>
 #include <test/t8_gtest_custom_assertion.hxx>
 #include <test/t8_gtest_macros.hxx>
diff --git a/test/t8_schemes/t8_gtest_successor.cxx b/test/t8_schemes/t8_gtest_successor.cxx
index 34a6e7eb33..b184a4019b 100644
--- a/test/t8_schemes/t8_gtest_successor.cxx
+++ b/test/t8_schemes/t8_gtest_successor.cxx
@@ -21,7 +21,7 @@
 */
 
 #include <gtest/gtest.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <test/t8_gtest_schemes.hxx>
 #include <test/t8_gtest_custom_assertion.hxx>
 #include <test/t8_gtest_macros.hxx>
diff --git a/test/t8_test_data_dir.h.in b/test/t8_test_data_dir.h.in
new file mode 100644
index 0000000000..a36f8e909f
--- /dev/null
+++ b/test/t8_test_data_dir.h.in
@@ -0,0 +1,36 @@
+/*
+  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) 2026 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_test_data_dir.h.in 
+ * This header defines the macro T8_TEST_DATA_DIR, which specifies the path to the test data directory.
+ * The value is substituted by CMake during the build configuration process. 
+ * This creates the file t8_test_data_dir.h in the build directory,
+ * which can be included in test source files to access the test data directory path.
+ *
+ * Usage:
+ * #include "t8_test_data_dir.h"
+ * std::string data_dir = T8_TEST_DATA_DIR;
+ */
+
+#pragma once
+
+#define T8_TEST_DATA_DIR "@T8_TEST_DATA_DIR@"
\ No newline at end of file
diff --git a/tutorials/general/t8_step7_interpolation.cxx b/tutorials/general/t8_step7_interpolation.cxx
index 0e283e61ef..0b4a155d7d 100644
--- a/tutorials/general/t8_step7_interpolation.cxx
+++ b/tutorials/general/t8_step7_interpolation.cxx
@@ -28,7 +28,7 @@
 
 #include <iostream>
 #include <t8.h>
-#include <t8_eclass.h>
+#include <t8_eclass/t8_eclass.h>
 #include <t8_cmesh/t8_cmesh.h>
 #include <t8_cmesh/t8_cmesh_examples.h>
 #include <t8_forest/t8_forest_general.h>