diff --git a/CMakeLists.txt b/CMakeLists.txt
index 27fcd9c3..ab55e202 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,6 +1,6 @@
 # Algebra plugins library, part of the ACTS project (R&D line)
 #
-# (c) 2021-2024 CERN for the benefit of the ACTS project
+# (c) 2021-2026 CERN for the benefit of the ACTS project
 #
 # Mozilla Public License Version 2.0
 
@@ -243,9 +243,8 @@ endif()
 
 # Set up the Algebra Plugin libraries.
 add_subdirectory(common)
-add_subdirectory(frontend)
-add_subdirectory(math)
-add_subdirectory(storage)
+add_subdirectory(plugins)
+add_subdirectory(generic)
 add_subdirectory(utils)
 
 # Set up the test(s).
diff --git a/benchmarks/CMakeLists.txt b/benchmarks/CMakeLists.txt
index 73dfff21..def496b2 100644
--- a/benchmarks/CMakeLists.txt
+++ b/benchmarks/CMakeLists.txt
@@ -29,7 +29,7 @@ target_include_directories(
 )
 target_link_libraries(
     algebra_bench_array
-    INTERFACE algebra::array algebra::common_storage
+    INTERFACE algebra::array algebra::common
 )
 algebra_add_benchmark( array_getter
    "array/array_getter.cpp"
@@ -60,7 +60,7 @@ if(ALGEBRA_PLUGINS_INCLUDE_EIGEN)
     )
     target_link_libraries(
         algebra_bench_eigen
-        INTERFACE algebra::eigen algebra::common_storage
+        INTERFACE algebra::eigen algebra::common
     )
     algebra_add_benchmark(eigen_getter
       "eigen/eigen_getter.cpp"
@@ -93,7 +93,7 @@ if(ALGEBRA_PLUGINS_INCLUDE_VC)
     )
     target_link_libraries(
         algebra_bench_vc_aos
-        INTERFACE algebra::vc_aos algebra::common_storage
+        INTERFACE algebra::vc_aos algebra::common
     )
     algebra_add_benchmark(vc_aos_getter
       "vc_aos/vc_aos_getter.cpp"
@@ -124,7 +124,7 @@ if(ALGEBRA_PLUGINS_INCLUDE_VC)
     )
     target_link_libraries(
         algebra_bench_vc_soa
-        INTERFACE algebra::vc_soa algebra::common_storage
+        INTERFACE algebra::vc_soa algebra::common
     )
     algebra_add_benchmark(vc_soa_getter
       "vc_soa/vc_soa_getter.cpp"
@@ -161,7 +161,7 @@ if(ALGEBRA_PLUGINS_INCLUDE_FASTOR)
     )
     target_link_libraries(
         algebra_bench_fastor
-        INTERFACE algebra::fastor algebra::common_storage
+        INTERFACE algebra::fastor algebra::common
     )
     algebra_add_benchmark(fastor_getter
       "fastor/fastor_getter.cpp"
diff --git a/common/CMakeLists.txt b/common/CMakeLists.txt
index 53722aeb..09337212 100644
--- a/common/CMakeLists.txt
+++ b/common/CMakeLists.txt
@@ -4,17 +4,29 @@
 #
 # Mozilla Public License Version 2.0
 
-# Set up the library.
+# Set up the common library.
 algebra_add_library( algebra_common common
+   "include/algebra/array_operators.hpp"
    "include/algebra/assert.hpp"
+   "include/algebra/boolean.hpp"
    "include/algebra/concepts.hpp"
+   "include/algebra/math.hpp"
+   "include/algebra/matrix_getter.hpp"
+   "include/algebra/matrix.hpp"
    "include/algebra/qualifiers.hpp"
    "include/algebra/type_traits.hpp"
+   "include/algebra/vector.hpp"
 )
 
 algebra_test_public_headers( algebra_common
+   "algebra/array_operators.hpp"
    "algebra/assert.hpp"
+   "algebra/boolean.hpp"
    "algebra/concepts.hpp"
+   "algebra/math.hpp"
+   "algebra/matrix_getter.hpp"
+   "algebra/matrix.hpp"
    "algebra/qualifiers.hpp"
    "algebra/type_traits.hpp"
+   "algebra/vector.hpp"
 )
diff --git a/storage/common/include/algebra/storage/array_operators.hpp b/common/include/algebra/array_operators.hpp
similarity index 97%
rename from storage/common/include/algebra/storage/array_operators.hpp
rename to common/include/algebra/array_operators.hpp
index f9f8a59d..51b04c24 100644
--- a/storage/common/include/algebra/storage/array_operators.hpp
+++ b/common/include/algebra/array_operators.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins, part of the ACTS project
  *
- * (c) 2023 CERN for the benefit of the ACTS project
+ * (c) 2023-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
diff --git a/common/include/algebra/assert.hpp b/common/include/algebra/assert.hpp
index eddbd30b..8af9b8b9 100644
--- a/common/include/algebra/assert.hpp
+++ b/common/include/algebra/assert.hpp
@@ -1,7 +1,7 @@
 /**
  * ALGEBRA PLUGIN library, part of the ACTS project (R&D line)
  *
- * (c) 2025 CERN for the benefit of the ACTS project
+ * (c) 2025-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
diff --git a/math/common/include/algebra/math/boolean.hpp b/common/include/algebra/boolean.hpp
similarity index 86%
rename from math/common/include/algebra/math/boolean.hpp
rename to common/include/algebra/boolean.hpp
index ba8e9792..d2e0eac2 100644
--- a/math/common/include/algebra/math/boolean.hpp
+++ b/common/include/algebra/boolean.hpp
@@ -1,6 +1,6 @@
 /** Detray library, part of the ACTS project (R&D line)
  *
- * (c) 2024 CERN for the benefit of the ACTS project
+ * (c) 2024-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
diff --git a/common/include/algebra/concepts.hpp b/common/include/algebra/concepts.hpp
index d212dec4..8ed0a33c 100644
--- a/common/include/algebra/concepts.hpp
+++ b/common/include/algebra/concepts.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins library, part of the ACTS project
  *
- * (c) 2024 CERN for the benefit of the ACTS project
+ * (c) 2024-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -144,7 +144,7 @@ concept transform3D = requires(T trf) {
 template <typename A>
 concept algebra = (concepts::value<typename A::value_type> &&
                    concepts::scalar<typename A::scalar> &&
-                   concepts::index<typename A::size_type> &&
+                   concepts::index<typename A::index_type> &&
                    concepts::vector3D<typename A::vector3D> &&
                    concepts::point2D<typename A::point2D> &&
                    concepts::point3D<typename A::point3D> &&
diff --git a/math/common/include/algebra/math/common.hpp b/common/include/algebra/math.hpp
similarity index 90%
rename from math/common/include/algebra/math/common.hpp
rename to common/include/algebra/math.hpp
index 8109318c..488c887e 100644
--- a/math/common/include/algebra/math/common.hpp
+++ b/common/include/algebra/math.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins library, part of the ACTS project
  *
- * (c) 2022-2024 CERN for the benefit of the ACTS project
+ * (c) 2022-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
diff --git a/storage/common/include/algebra/storage/matrix.hpp b/common/include/algebra/matrix.hpp
similarity index 97%
rename from storage/common/include/algebra/storage/matrix.hpp
rename to common/include/algebra/matrix.hpp
index 02046a7f..65af3016 100644
--- a/storage/common/include/algebra/storage/matrix.hpp
+++ b/common/include/algebra/matrix.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins, part of the ACTS project
  *
- * (c) 2024 CERN for the benefit of the ACTS project
+ * (c) 2024-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -8,8 +8,8 @@
 
 // Project include(s).
 #include "algebra/concepts.hpp"
-#include "algebra/storage/vector.hpp"
 #include "algebra/type_traits.hpp"
+#include "algebra/vector.hpp"
 
 // System include(s).
 #include <array>
@@ -20,10 +20,11 @@ namespace algebra::storage {
 /// Generic matrix type that can take vectors as columns
 template <template <typename, std::size_t> class array_t,
           concepts::scalar scalar_t, std::size_t ROW, std::size_t COL>
-struct ALGEBRA_ALIGN(alignof(storage::vector<ROW, scalar_t, array_t>)) matrix {
+struct ALGEBRA_ALIGN(
+    alignof(algebra::storage::vector<ROW, scalar_t, array_t>)) matrix {
 
   // The matrix consists of column vectors
-  using vector_type = storage::vector<ROW, scalar_t, array_t>;
+  using vector_type = algebra::storage::vector<ROW, scalar_t, array_t>;
   // Value type: Can be simd types
   using scalar_type = scalar_t;
 
diff --git a/storage/common/include/algebra/storage/matrix_getter.hpp b/common/include/algebra/matrix_getter.hpp
similarity index 98%
rename from storage/common/include/algebra/storage/matrix_getter.hpp
rename to common/include/algebra/matrix_getter.hpp
index d53e8e1d..649e98d0 100644
--- a/storage/common/include/algebra/storage/matrix_getter.hpp
+++ b/common/include/algebra/matrix_getter.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins, part of the ACTS project
  *
- * (c) 2024 CERN for the benefit of the ACTS project
+ * (c) 2024-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -8,8 +8,8 @@
 
 // Project include(s).
 #include "algebra/concepts.hpp"
-#include "algebra/storage/matrix.hpp"
-#include "algebra/storage/vector.hpp"
+#include "algebra/matrix.hpp"
+#include "algebra/vector.hpp"
 
 // System include(s).
 #include <cassert>
diff --git a/common/include/algebra/qualifiers.hpp b/common/include/algebra/qualifiers.hpp
index 5ebb8e11..6991519a 100644
--- a/common/include/algebra/qualifiers.hpp
+++ b/common/include/algebra/qualifiers.hpp
@@ -1,7 +1,7 @@
 /**
  * ALGEBRA PLUGIN library, part of the ACTS project (R&D line)
  *
- * (c) 2021-2022 CERN for the benefit of the ACTS project
+ * (c) 2021-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
diff --git a/common/include/algebra/type_traits.hpp b/common/include/algebra/type_traits.hpp
index 5cd4864e..a81aee43 100644
--- a/common/include/algebra/type_traits.hpp
+++ b/common/include/algebra/type_traits.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins library, part of the ACTS project
  *
- * (c) 2024 CERN for the benefit of the ACTS project
+ * (c) 2024-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -77,12 +77,12 @@ using get_matrix_t = typename matrix<M>::template other_type<T, ROWS, COLS>;
 template <typename M>
 struct dimensions {
 
-  using size_type = int;
+  using index_type = int;
 
   // Error case
-  static constexpr size_type dim{-1};
-  static constexpr size_type rows{-1};
-  static constexpr size_type columns{-1};
+  static constexpr index_type _dim{-1};
+  static constexpr index_type _rows{-1};
+  static constexpr index_type _columns{-1};
 };
 
 /// Specilization for scalar types
@@ -90,22 +90,22 @@ template <typename M>
   requires std::is_fundamental_v<M>
 struct dimensions<M> {
 
-  using size_type = std::size_t;
+  using index_type = std::size_t;
 
-  static constexpr size_type dim{0};
-  static constexpr size_type rows{1};
-  static constexpr size_type columns{1};
+  static constexpr index_type _dim{0};
+  static constexpr index_type _rows{1};
+  static constexpr index_type _columns{1};
 };
 
 template <class M>
-inline constexpr index_t<M> dim{dimensions<std::remove_cvref_t<M>>::sim};
+inline constexpr index_t<M> dim{dimensions<std::remove_cvref_t<M>>::_dim};
 
 template <class M>
-inline constexpr index_t<M> rows{dimensions<std::remove_cvref_t<M>>::rows};
+inline constexpr index_t<M> rows{dimensions<std::remove_cvref_t<M>>::_rows};
 
 template <class M>
 inline constexpr index_t<M> columns{
-    dimensions<std::remove_cvref_t<M>>::columns};
+    dimensions<std::remove_cvref_t<M>>::_columns};
 
 template <class M>
 inline constexpr index_t<M> rank{std::min(rows<M>, columns<M>)};
@@ -114,10 +114,10 @@ template <class M>
 inline constexpr index_t<M> size{rows<M> * columns<M>};
 
 template <class V>
-inline constexpr bool is_vector{dimensions<std::remove_cvref_t<V>>::dim == 1};
+inline constexpr bool is_vector{dimensions<std::remove_cvref_t<V>>::_dim == 1};
 
 template <class M>
-inline constexpr bool is_matrix{dimensions<std::remove_cvref_t<M>>::dim == 2};
+inline constexpr bool is_matrix{dimensions<std::remove_cvref_t<M>>::_dim == 2};
 
 template <class M>
 inline constexpr bool is_square{(rows<M> == columns<M>)};
@@ -148,7 +148,7 @@ template <typename T>
 struct get_algebra<T> {
   template <typename U>
   using simd = typename T::template simd<U>;
-  using size_type = typename T::size_type;
+  using index_type = typename T::index_type;
   using boolean = typename T::boolean;
   using value = typename T::value_type;
   using scalar = typename T::scalar;
@@ -173,7 +173,7 @@ template <typename A, typename T>
 using get_simd_t = typename traits::get_algebra<A>::template simd<T>;
 
 template <typename A>
-using get_size_t = typename traits::get_algebra<A>::size_type;
+using get_size_t = typename traits::get_algebra<A>::index_type;
 
 template <typename A>
 using get_scalar_t = typename traits::get_algebra<A>::scalar;
@@ -207,32 +207,32 @@ using get_matrix_t = typename traits::get_algebra<A>::template matrix<R, C>;
                                                                         \
   template <typename T, auto N>                                         \
   struct index<A::vector_type<T, N>> {                                  \
-    using type = algebra::A::size_type;                                 \
+    using type = algebra::A::index_type;                                \
   };                                                                    \
                                                                         \
   template <typename T, auto ROWS, auto COLS>                           \
   struct index<A::matrix_type<T, ROWS, COLS>> {                         \
-    using type = algebra::A::size_type;                                 \
+    using type = algebra::A::index_type;                                \
   };                                                                    \
                                                                         \
   template <typename T, auto N>                                         \
   struct dimensions<A::vector_type<T, N>> {                             \
                                                                         \
-    using size_type = index_t<A::vector_type<T, N>>;                    \
+    using index_type = index_t<A::vector_type<T, N>>;                   \
                                                                         \
-    static constexpr size_type dim{1};                                  \
-    static constexpr size_type rows{N};                                 \
-    static constexpr size_type columns{1};                              \
+    static constexpr index_type _dim{1};                                \
+    static constexpr index_type _rows{N};                               \
+    static constexpr index_type _columns{1};                            \
   };                                                                    \
                                                                         \
   template <typename T, auto ROWS, auto COLS>                           \
   struct dimensions<A::matrix_type<T, ROWS, COLS>> {                    \
                                                                         \
-    using size_type = index_t<A::matrix_type<T, ROWS, COLS>>;           \
+    using index_type = index_t<A::matrix_type<T, ROWS, COLS>>;          \
                                                                         \
-    static constexpr size_type dim{2};                                  \
-    static constexpr size_type rows{ROWS};                              \
-    static constexpr size_type columns{COLS};                           \
+    static constexpr index_type _dim{2};                                \
+    static constexpr index_type _rows{ROWS};                            \
+    static constexpr index_type _columns{COLS};                         \
   };                                                                    \
                                                                         \
   template <typename T, auto N>                                         \
diff --git a/storage/common/include/algebra/storage/vector.hpp b/common/include/algebra/vector.hpp
similarity index 98%
rename from storage/common/include/algebra/storage/vector.hpp
rename to common/include/algebra/vector.hpp
index 7db15bdf..ab1a5b9b 100644
--- a/storage/common/include/algebra/storage/vector.hpp
+++ b/common/include/algebra/vector.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins, part of the ACTS project
  *
- * (c) 2023-2024 CERN for the benefit of the ACTS project
+ * (c) 2023-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -12,9 +12,9 @@
 #endif
 
 // Project include(s)
+#include "algebra/array_operators.hpp"
 #include "algebra/concepts.hpp"
 #include "algebra/qualifiers.hpp"
-#include "algebra/storage/array_operators.hpp"
 
 // System include(s).
 #include <array>
@@ -287,7 +287,7 @@ struct is_storage_vector : public std::false_type {};
 
 template <std::size_t N, concepts::scalar scalar_t,
           template <typename, std::size_t> class array_t>
-struct is_storage_vector<storage::vector<N, scalar_t, array_t>>
+struct is_storage_vector<algebra::storage::vector<N, scalar_t, array_t>>
     : public std::true_type {};
 
 template <typename T>
diff --git a/generic/CMakeLists.txt b/generic/CMakeLists.txt
new file mode 100644
index 00000000..e7cf20b3
--- /dev/null
+++ b/generic/CMakeLists.txt
@@ -0,0 +1,27 @@
+# Algebra plugins library, part of the ACTS project (R&D line)
+#
+# (c) 2021-2026 CERN for the benefit of the ACTS project
+#
+# Mozilla Public License Version 2.0
+
+# Set up the generic algebra library.
+algebra_add_library(algebra_generic generic
+   "include/algebra/generic.hpp"
+   # impl include
+   "include/algebra/impl/generic_matrix.hpp"
+   "include/algebra/impl/generic_transform3.hpp"
+   "include/algebra/impl/generic_vector.hpp"
+   # algorithms include
+   "include/algebra/algorithms/matrix/decomposition/partial_pivot_lud.hpp"
+   "include/algebra/algorithms/matrix/determinant/cofactor.hpp"
+   "include/algebra/algorithms/matrix/determinant/hard_coded.hpp"
+   "include/algebra/algorithms/matrix/determinant/partial_pivot_lud.hpp"
+   "include/algebra/algorithms/matrix/inverse/cofactor.hpp"
+   "include/algebra/algorithms/matrix/inverse/hard_coded.hpp"
+   "include/algebra/algorithms/matrix/inverse/partial_pivot_lud.hpp"
+   "include/algebra/algorithms/utils/algorithm_selector.hpp"
+)
+target_link_libraries(algebra_generic INTERFACE algebra::common algebra::utils)
+algebra_test_public_headers( algebra_generic
+   "algebra/generic.hpp"
+)
diff --git a/math/generic/include/algebra/math/algorithms/matrix/decomposition/partial_pivot_lud.hpp b/generic/include/algebra/algorithms/matrix/decomposition/partial_pivot_lud.hpp
similarity index 51%
rename from math/generic/include/algebra/math/algorithms/matrix/decomposition/partial_pivot_lud.hpp
rename to generic/include/algebra/algorithms/matrix/decomposition/partial_pivot_lud.hpp
index b67ddcd7..14878c0a 100644
--- a/math/generic/include/algebra/math/algorithms/matrix/decomposition/partial_pivot_lud.hpp
+++ b/generic/include/algebra/algorithms/matrix/decomposition/partial_pivot_lud.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins library, part of the ACTS project
  *
- * (c) 2022-2024 CERN for the benefit of the ACTS project
+ * (c) 2022-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -9,7 +9,7 @@
 
 // Project include(s).
 #include "algebra/concepts.hpp"
-#include "algebra/math/common.hpp"
+#include "algebra/math.hpp"
 #include "algebra/qualifiers.hpp"
 
 // System include(s).
@@ -18,24 +18,21 @@
 namespace algebra::generic::matrix::decomposition {
 
 /// "Partial Pivot LU Decomposition", assuming a N X N matrix
-template <concepts::matrix matrix_t, class element_getter_t>
+template <concepts::matrix matrix_t>
 struct partial_pivot_lud {
 
-  using scalar_type = algebra::traits::value_t<matrix_t>;
-  using size_type = algebra::traits::index_t<matrix_t>;
-  using vector_type = algebra::traits::vector_t<matrix_t>;
+  using scalar_t = algebra::traits::value_t<matrix_t>;
+  using index_t = algebra::traits::index_t<matrix_t>;
+  using vector_t = algebra::traits::vector_t<matrix_t>;
 
-  /// Function (object) used for accessing a matrix element
-  using element_getter = element_getter_t;
-
-  template <size_type N>
+  template <index_t N>
   struct lud {
     // LU decomposition matrix, equal to (L - I) + U, where the diagonal
     // components of L is always 1
     matrix_t lu;
 
     // Permutation vector
-    vector_type P;
+    vector_t P;
 
     // Number of pivots
     int n_pivot = 0;
@@ -44,37 +41,41 @@ struct partial_pivot_lud {
   ALGEBRA_HOST_DEVICE constexpr lud<algebra::traits::rank<matrix_t>> operator()(
       const matrix_t& m) const {
 
-    constexpr size_type N{algebra::traits::rank<matrix_t>};
+    // Function (object) used for accessing a matrix element
+    using element_getter_t = algebra::traits::element_getter_t<matrix_t>;
+
+    constexpr element_getter_t elem{};
+    constexpr index_t N{algebra::traits::rank<matrix_t>};
 
     // LU decomposition matrix
     matrix_t lu = m;
 
     // Permutation
-    vector_type P;
+    vector_t P;
 
     // Max index and value
-    size_type max_idx;
-    scalar_type max_val;
-    scalar_type abs_val;
+    index_t max_idx;
+    scalar_t max_val;
+    scalar_t abs_val;
 
     // Number of pivoting
     int n_pivot = N;
 
     // Rows for swapping
-    vector_type row_0;
-    vector_type row_1;
+    vector_t row_0;
+    vector_t row_1;
 
     // Unit permutation matrix, P[N] initialized with N
-    for (size_type i = 0; i < N; i++) {
-      P[i] = static_cast<scalar_type>(i);
+    for (index_t i = 0; i < N; i++) {
+      P[i] = static_cast<scalar_t>(i);
     }
 
-    for (size_type i = 0; i < N; i++) {
+    for (index_t i = 0; i < N; i++) {
       max_val = 0;
       max_idx = i;
 
-      for (size_type k = i; k < N; k++) {
-        abs_val = algebra::math::fabs(element_getter()(lu, k, i));
+      for (index_t k = i; k < N; k++) {
+        abs_val = algebra::math::fabs(elem(lu, k, i));
 
         if (abs_val > max_val) {
 
@@ -91,27 +92,26 @@ struct partial_pivot_lud {
         P[max_idx] = j;
 
         // Pivoting rows of A
-        for (size_type q = 0; q < N; q++) {
-          row_0[q] = element_getter_t()(lu, i, q);
-          row_1[q] = element_getter_t()(lu, max_idx, q);
+        for (index_t q = 0; q < N; q++) {
+          row_0[q] = elem(lu, i, q);
+          row_1[q] = elem(lu, max_idx, q);
         }
-        for (size_type q = 0; q < N; q++) {
-          element_getter_t()(lu, i, q) = row_1[q];
-          element_getter_t()(lu, max_idx, q) = row_0[q];
+        for (index_t q = 0; q < N; q++) {
+          elem(lu, i, q) = row_1[q];
+          elem(lu, max_idx, q) = row_0[q];
         }
 
         // counting pivots starting from N (for determinant)
         n_pivot++;
       }
 
-      for (size_type j = i + 1; j < N; j++) {
+      for (index_t j = i + 1; j < N; j++) {
         // m[j][i] /= m[i][i];
-        element_getter_t()(lu, j, i) /= element_getter_t()(lu, i, i);
+        elem(lu, j, i) /= elem(lu, i, i);
 
-        for (size_type k = i + 1; k < N; k++) {
+        for (index_t k = i + 1; k < N; k++) {
           // m[j][k] -= m[j][i] * m[i][k];
-          element_getter_t()(lu, j, k) -=
-              element_getter_t()(lu, j, i) * element_getter_t()(lu, i, k);
+          elem(lu, j, k) -= elem(lu, j, i) * elem(lu, i, k);
         }
       }
     }
diff --git a/math/generic/include/algebra/math/algorithms/matrix/determinant/cofactor.hpp b/generic/include/algebra/algorithms/matrix/determinant/cofactor.hpp
similarity index 52%
rename from math/generic/include/algebra/math/algorithms/matrix/determinant/cofactor.hpp
rename to generic/include/algebra/algorithms/matrix/determinant/cofactor.hpp
index 8d1942f4..3a068f91 100644
--- a/math/generic/include/algebra/math/algorithms/matrix/determinant/cofactor.hpp
+++ b/generic/include/algebra/algorithms/matrix/determinant/cofactor.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins library, part of the ACTS project
  *
- * (c) 2022-2024 CERN for the benefit of the ACTS project
+ * (c) 2022-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -18,53 +18,64 @@
 namespace algebra::generic::matrix::determinant {
 
 /// "Determinant getter", assuming a N X N matrix
-template <concepts::square_matrix matrix_t, class element_getter_t>
+template <concepts::square_matrix matrix_t>
 struct cofactor {
 
   using scalar_type = algebra::traits::value_t<matrix_t>;
-  using size_type = algebra::traits::index_t<matrix_t>;
-
-  /// Function (object) used for accessing a matrix element
-  using element_getter = element_getter_t;
+  using index_type = algebra::traits::index_t<matrix_t>;
 
   ALGEBRA_HOST_DEVICE constexpr scalar_type operator()(
       const matrix_t &m) const {
     return determinant_getter_helper<algebra::traits::rank<matrix_t>>()(m);
   }
 
-  template <size_type N, typename Enable = void>
+  template <index_type N>
   struct determinant_getter_helper;
 
-  template <size_type N>
-  struct determinant_getter_helper<N, typename std::enable_if_t<N == 1>> {
+  template <index_type N>
+    requires(N == 1)
+  struct determinant_getter_helper<N> {
     template <class input_matrix_type>
     ALGEBRA_HOST_DEVICE constexpr scalar_type operator()(
         const input_matrix_type &m) const {
-      return element_getter()(m, 0, 0);
+
+      using element_getter_t =
+          algebra::traits::element_getter_t<input_matrix_type>;
+
+      constexpr element_getter_t elem{};
+
+      return elem(m, 0, 0);
     }
   };
 
-  template <size_type N>
-  struct determinant_getter_helper<N, typename std::enable_if_t<N != 1>> {
+  template <index_type N>
+    requires(N != 1)
+  struct determinant_getter_helper<N> {
 
     template <class input_matrix_type>
     ALGEBRA_HOST_DEVICE constexpr scalar_type operator()(
         const input_matrix_type &m) const {
 
-      scalar_type D = 0;
+      using scalar_t = algebra::traits::value_t<input_matrix_type>;
+      using index_t = algebra::traits::index_t<input_matrix_type>;
+      using element_getter_t =
+          algebra::traits::element_getter_t<input_matrix_type>;
+
+      constexpr element_getter_t elem{};
+
+      scalar_t D = 0;
 
       // To store cofactors
-      matrix_t temp;
+      input_matrix_type temp;
 
       // To store sign multiplier
       int sign = 1;
 
       // Iterate for each element of first row
-      for (size_type col = 0; col < N; col++) {
+      for (index_t col = 0; col < N; col++) {
         // Getting Cofactor of A[0][f]
-        this->get_cofactor(m, temp, size_type(0), col);
-        D += sign * element_getter()(m, 0, col) *
-             determinant_getter_helper<N - 1>()(temp);
+        this->get_cofactor(m, temp, index_t(0), col);
+        D += sign * elem(m, 0, col) * determinant_getter_helper<N - 1>()(temp);
 
         // terms are to be added with alternate sign
         sign = -sign;
@@ -75,19 +86,26 @@ struct cofactor {
 
     template <class input_matrix_type>
     ALGEBRA_HOST_DEVICE constexpr void get_cofactor(const input_matrix_type &m,
-                                                    matrix_t &temp, size_type p,
-                                                    size_type q) const {
+                                                    input_matrix_type &temp,
+                                                    index_type p,
+                                                    index_type q) const {
+
+      using index_t = algebra::traits::index_t<input_matrix_type>;
+      using element_getter_t =
+          algebra::traits::element_getter_t<input_matrix_type>;
+
+      constexpr element_getter_t elem{};
 
-      size_type i = 0;
-      size_type j = 0;
+      index_t i = 0;
+      index_t j = 0;
 
       // Looping for each element of the matrix
-      for (size_type row = 0; row < N; row++) {
-        for (size_type col = 0; col < N; col++) {
+      for (index_t row = 0; row < N; row++) {
+        for (index_t col = 0; col < N; col++) {
           //  Copying into temporary matrix only those element
           //  which are not in given row and column
           if (row != p && col != q) {
-            element_getter()(temp, i, j++) = element_getter()(m, row, col);
+            elem(temp, i, j++) = elem(m, row, col);
 
             // Row is filled, so increase row index and
             // reset col index
diff --git a/generic/include/algebra/algorithms/matrix/determinant/hard_coded.hpp b/generic/include/algebra/algorithms/matrix/determinant/hard_coded.hpp
new file mode 100644
index 00000000..173e8324
--- /dev/null
+++ b/generic/include/algebra/algorithms/matrix/determinant/hard_coded.hpp
@@ -0,0 +1,74 @@
+/** Algebra plugins library, part of the ACTS project
+ *
+ * (c) 2022-2026 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s).
+#include "algebra/concepts.hpp"
+#include "algebra/qualifiers.hpp"
+#include "algebra/type_traits.hpp"
+
+// System include(s)
+#include <type_traits>
+
+namespace algebra::generic::matrix::determinant {
+
+/// "Determinant getter", assuming a N X N matrix
+template <concepts::square_matrix matrix_t>
+struct hard_coded {
+
+  using scalar_t = algebra::traits::value_t<matrix_t>;
+  using index_t = algebra::traits::index_t<matrix_t>;
+
+  /// Function (object) used for accessing a matrix element
+  using element_getter_t = algebra::traits::element_getter_t<matrix_t>;
+
+  // 2 X 2 matrix determinant
+  template <typename M = matrix_t>
+    requires(algebra::traits::rank<M> == 2)
+  ALGEBRA_HOST_DEVICE constexpr scalar_t operator()(const matrix_t &m) const {
+
+    constexpr element_getter_t elem{};
+
+    return elem(m, 0, 0) * elem(m, 1, 1) - elem(m, 0, 1) * elem(m, 1, 0);
+  }
+
+  // 4 X 4 matrix determinant
+  template <typename M = matrix_t>
+    requires(algebra::traits::rank<M> == 4)
+  ALGEBRA_HOST_DEVICE constexpr scalar_t operator()(const matrix_t &m) const {
+
+    constexpr element_getter_t elem{};
+
+    return elem(m, 0, 3) * elem(m, 1, 2) * elem(m, 2, 1) * elem(m, 3, 0) -
+           elem(m, 0, 2) * elem(m, 1, 3) * elem(m, 2, 1) * elem(m, 3, 0) -
+           elem(m, 0, 3) * elem(m, 1, 1) * elem(m, 2, 2) * elem(m, 3, 0) +
+           elem(m, 0, 1) * elem(m, 1, 3) * elem(m, 2, 2) * elem(m, 3, 0) +
+           elem(m, 0, 2) * elem(m, 1, 1) * elem(m, 2, 3) * elem(m, 3, 0) -
+           elem(m, 0, 1) * elem(m, 1, 2) * elem(m, 2, 3) * elem(m, 3, 0) -
+           elem(m, 0, 3) * elem(m, 1, 2) * elem(m, 2, 0) * elem(m, 3, 1) +
+           elem(m, 0, 2) * elem(m, 1, 3) * elem(m, 2, 0) * elem(m, 3, 1) +
+           elem(m, 0, 3) * elem(m, 1, 0) * elem(m, 2, 2) * elem(m, 3, 1) -
+           elem(m, 0, 0) * elem(m, 1, 3) * elem(m, 2, 2) * elem(m, 3, 1) -
+           elem(m, 0, 2) * elem(m, 1, 0) * elem(m, 2, 3) * elem(m, 3, 1) +
+           elem(m, 0, 0) * elem(m, 1, 2) * elem(m, 2, 3) * elem(m, 3, 1) +
+           elem(m, 0, 3) * elem(m, 1, 1) * elem(m, 2, 0) * elem(m, 3, 2) -
+           elem(m, 0, 1) * elem(m, 1, 3) * elem(m, 2, 0) * elem(m, 3, 2) -
+           elem(m, 0, 3) * elem(m, 1, 0) * elem(m, 2, 1) * elem(m, 3, 2) +
+           elem(m, 0, 0) * elem(m, 1, 3) * elem(m, 2, 1) * elem(m, 3, 2) +
+           elem(m, 0, 1) * elem(m, 1, 0) * elem(m, 2, 3) * elem(m, 3, 2) -
+           elem(m, 0, 0) * elem(m, 1, 1) * elem(m, 2, 3) * elem(m, 3, 2) -
+           elem(m, 0, 2) * elem(m, 1, 1) * elem(m, 2, 0) * elem(m, 3, 3) +
+           elem(m, 0, 1) * elem(m, 1, 2) * elem(m, 2, 0) * elem(m, 3, 3) +
+           elem(m, 0, 2) * elem(m, 1, 0) * elem(m, 2, 1) * elem(m, 3, 3) -
+           elem(m, 0, 0) * elem(m, 1, 2) * elem(m, 2, 1) * elem(m, 3, 3) -
+           elem(m, 0, 1) * elem(m, 1, 0) * elem(m, 2, 2) * elem(m, 3, 3) +
+           elem(m, 0, 0) * elem(m, 1, 1) * elem(m, 2, 2) * elem(m, 3, 3);
+  }
+};
+
+}  // namespace algebra::generic::matrix::determinant
diff --git a/math/generic/include/algebra/math/algorithms/matrix/determinant/partial_pivot_lud.hpp b/generic/include/algebra/algorithms/matrix/determinant/partial_pivot_lud.hpp
similarity index 54%
rename from math/generic/include/algebra/math/algorithms/matrix/determinant/partial_pivot_lud.hpp
rename to generic/include/algebra/algorithms/matrix/determinant/partial_pivot_lud.hpp
index 53213951..aa8a9e3e 100644
--- a/math/generic/include/algebra/math/algorithms/matrix/determinant/partial_pivot_lud.hpp
+++ b/generic/include/algebra/algorithms/matrix/determinant/partial_pivot_lud.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins library, part of the ACTS project
  *
- * (c) 2022-2024 CERN for the benefit of the ACTS project
+ * (c) 2022-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -8,31 +8,31 @@
 #pragma once
 
 // Project include(s).
+#include "algebra/algorithms/matrix/decomposition/partial_pivot_lud.hpp"
 #include "algebra/concepts.hpp"
-#include "algebra/math/algorithms/matrix/decomposition/partial_pivot_lud.hpp"
 #include "algebra/qualifiers.hpp"
 #include "algebra/type_traits.hpp"
 
 namespace algebra::generic::matrix::determinant {
 
 /// "Partial Pivot LU Decomposition", assuming a N X N matrix
-template <concepts::square_matrix matrix_t, class element_getter_t>
+template <concepts::square_matrix matrix_t>
 struct partial_pivot_lud {
 
-  using scalar_type = algebra::traits::value_t<matrix_t>;
-  using size_type = algebra::traits::index_t<matrix_t>;
+  using scalar_t = algebra::traits::value_t<matrix_t>;
+  using index_t = algebra::traits::index_t<matrix_t>;
 
   /// Function (object) used for accessing a matrix element
-  using element_getter = element_getter_t;
+  using element_getter_t = algebra::traits::element_getter_t<matrix_t>;
 
   using decomposition_t =
       typename algebra::generic::matrix::decomposition::partial_pivot_lud<
-          matrix_t, element_getter_t>;
+          matrix_t>;
 
-  ALGEBRA_HOST_DEVICE constexpr scalar_type operator()(
-      const matrix_t& m) const {
+  ALGEBRA_HOST_DEVICE constexpr scalar_t operator()(const matrix_t& m) const {
 
-    constexpr size_type N{algebra::traits::rank<matrix_t>};
+    constexpr element_getter_t elem{};
+    constexpr index_t N{algebra::traits::rank<matrix_t>};
 
     const typename decomposition_t::template lud<
         algebra::traits::rank<matrix_t>>
@@ -40,12 +40,12 @@ struct partial_pivot_lud {
 
     // Get the LU decomposition matrix equal to (L - I) + U
     const auto& lu = decomp_res.lu;
-    const auto n_pivot = static_cast<size_type>(decomp_res.n_pivot);
+    const auto n_pivot = static_cast<index_t>(decomp_res.n_pivot);
 
-    scalar_type det = element_getter()(lu, 0, 0);
+    scalar_t det = elem(lu, 0, 0);
 
-    for (size_type i = 1; i < N; i++) {
-      det *= element_getter()(lu, i, i);
+    for (index_t i = 1; i < N; i++) {
+      det *= elem(lu, i, i);
     }
 
     return (n_pivot - N) % 2 == 0 ? det : -det;
diff --git a/math/generic/include/algebra/math/algorithms/matrix/inverse/cofactor.hpp b/generic/include/algebra/algorithms/matrix/inverse/cofactor.hpp
similarity index 57%
rename from math/generic/include/algebra/math/algorithms/matrix/inverse/cofactor.hpp
rename to generic/include/algebra/algorithms/matrix/inverse/cofactor.hpp
index cc0835b1..26ee6226 100644
--- a/math/generic/include/algebra/math/algorithms/matrix/inverse/cofactor.hpp
+++ b/generic/include/algebra/algorithms/matrix/inverse/cofactor.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins library, part of the ACTS project
  *
- * (c) 2022-2024 CERN for the benefit of the ACTS project
+ * (c) 2022-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -8,8 +8,8 @@
 #pragma once
 
 // Project include(s).
+#include "algebra/algorithms/matrix/determinant/cofactor.hpp"
 #include "algebra/concepts.hpp"
-#include "algebra/math/algorithms/matrix/determinant/cofactor.hpp"
 #include "algebra/qualifiers.hpp"
 #include "algebra/type_traits.hpp"
 
@@ -21,50 +21,54 @@ namespace algebra::generic::matrix {
 namespace adjoint {
 
 /// "Adjoint getter", assuming a N X N matrix
-template <concepts::square_matrix matrix_t, class element_getter_t>
+template <concepts::square_matrix matrix_t>
 struct cofactor {
 
-  using scalar_type = algebra::traits::value_t<matrix_t>;
-  using size_type = algebra::traits::index_t<matrix_t>;
-
-  /// Function (object) used for accessing a matrix element
-  using element_getter = element_getter_t;
+  using index_type = algebra::traits::index_t<matrix_t>;
 
   ALGEBRA_HOST_DEVICE constexpr matrix_t operator()(const matrix_t &m) const {
     return adjoint_getter_helper<algebra::traits::rank<matrix_t>>()(m);
   }
 
-  template <size_type N, typename Enable = void>
+  template <index_type N>
   struct adjoint_getter_helper;
 
-  template <size_type N>
-  struct adjoint_getter_helper<N, typename std::enable_if_t<N == 1>> {
+  template <index_type N>
+    requires(N == 1)
+  struct adjoint_getter_helper<N> {
     ALGEBRA_HOST_DEVICE constexpr matrix_t operator()(
         const matrix_t & /*m*/) const {
+
+      using element_getter_t = algebra::traits::element_getter_t<matrix_t>;
+      constexpr element_getter_t elem{};
+
       matrix_t ret;
-      element_getter()(ret, 0, 0) = 1;
+      elem(ret, 0, 0) = 1;
+
       return ret;
     }
   };
 
-  template <size_type N>
-  struct adjoint_getter_helper<N, typename std::enable_if_t<N != 1>> {
+  template <index_type N>
+    requires(N != 1)
+  struct adjoint_getter_helper<N> {
 
-    using determinant_getter =
-        determinant::cofactor<matrix_t, element_getter_t>;
+    using determinant_getter = determinant::cofactor<matrix_t>;
 
     ALGEBRA_HOST_DEVICE constexpr matrix_t operator()(const matrix_t &m) const {
 
-      matrix_t adj;
+      using index_t = algebra::traits::index_t<matrix_t>;
+      using element_getter_t = algebra::traits::element_getter_t<matrix_t>;
+      constexpr element_getter_t elem{};
 
       // temp is used to store cofactors of m
       int sign = 1;
 
-      // To store cofactors
-      matrix_t temp;
+      matrix_t temp;  //< To store cofactors
+      matrix_t adj;
 
-      for (size_type i = 0; i < N; i++) {
-        for (size_type j = 0; j < N; j++) {
+      for (index_t i = 0; i < N; i++) {
+        for (index_t j = 0; j < N; j++) {
           // Get cofactor of m[i][j]
           typename determinant_getter::template determinant_getter_helper<N>()
               .get_cofactor(m, temp, i, j);
@@ -75,7 +79,7 @@ struct cofactor {
 
           // Interchanging rows and columns to get the
           // transpose of the cofactor matrix
-          element_getter()(adj, j, i) =
+          elem(adj, j, i) =
               sign *
               typename determinant_getter::template determinant_getter_helper<
                   N - 1>()(temp);
@@ -92,27 +96,26 @@ struct cofactor {
 namespace inverse {
 
 /// "inverse getter", assuming a N X N matrix
-template <class matrix_t, class element_getter_t>
+template <class matrix_t>
 struct cofactor {
 
-  using scalar_type = algebra::traits::value_t<matrix_t>;
-  using size_type = algebra::traits::index_t<matrix_t>;
+  using scalar_t = algebra::traits::value_t<matrix_t>;
+  using index_t = algebra::traits::index_t<matrix_t>;
 
   /// Function (object) used for accessing a matrix element
-  using element_getter = element_getter_t;
-
-  using determinant_getter = determinant::cofactor<matrix_t, element_getter_t>;
-
-  using adjoint_getter = adjoint::cofactor<matrix_t, element_getter_t>;
+  using element_getter_t = algebra::traits::element_getter_t<matrix_t>;
+  using determinant_getter = determinant::cofactor<matrix_t>;
+  using adjoint_getter = adjoint::cofactor<matrix_t>;
 
   ALGEBRA_HOST_DEVICE constexpr matrix_t operator()(const matrix_t &m) const {
 
-    constexpr size_type N{algebra::traits::rank<matrix_t>};
+    constexpr element_getter_t elem{};
+    constexpr index_t N{algebra::traits::rank<matrix_t>};
 
     matrix_t ret;
 
     // Find determinant of A
-    scalar_type det = determinant_getter()(m);
+    scalar_t det = determinant_getter()(m);
 
     // TODO: handle singular matrix error
     // if (det == 0) {
@@ -122,9 +125,9 @@ struct cofactor {
     auto adj = adjoint_getter()(m);
 
     // Find Inverse using formula "inverse(A) = adj(A)/det(A)"
-    for (size_type i = 0; i < N; i++) {
-      for (size_type j = 0; j < N; j++) {
-        element_getter()(ret, j, i) = element_getter()(adj, j, i) / det;
+    for (index_t i = 0; i < N; i++) {
+      for (index_t j = 0; j < N; j++) {
+        elem(ret, j, i) = elem(adj, j, i) / det;
       }
     }
 
diff --git a/generic/include/algebra/algorithms/matrix/inverse/hard_coded.hpp b/generic/include/algebra/algorithms/matrix/inverse/hard_coded.hpp
new file mode 100644
index 00000000..f83bbfd3
--- /dev/null
+++ b/generic/include/algebra/algorithms/matrix/inverse/hard_coded.hpp
@@ -0,0 +1,166 @@
+/** Algebra plugins library, part of the ACTS project
+ *
+ * (c) 2022-2026 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s).
+#include "algebra/algorithms/matrix/determinant/hard_coded.hpp"
+#include "algebra/concepts.hpp"
+#include "algebra/qualifiers.hpp"
+#include "algebra/type_traits.hpp"
+
+// System include(s)
+#include <type_traits>
+
+namespace algebra::generic::matrix::inverse {
+
+/// "inverse getter", assuming a N X N matrix
+template <concepts::square_matrix matrix_t>
+struct hard_coded {
+
+  using scalar_t = algebra::traits::value_t<matrix_t>;
+  using index_t = algebra::traits::index_t<matrix_t>;
+
+  /// Function (object) used for accessing a matrix element
+  using element_getter_t = algebra::traits::element_getter_t<matrix_t>;
+  using determinant_getter = determinant::hard_coded<matrix_t>;
+
+  // 2 X 2 matrix inverse
+  template <typename M = matrix_t>
+    requires(algebra::traits::rank<M> == 2)
+  ALGEBRA_HOST_DEVICE constexpr matrix_t operator()(const matrix_t &m) const {
+
+    constexpr element_getter_t elem{};
+
+    const scalar_t det = determinant_getter()(m);
+
+    matrix_t ret;
+    elem(ret, 0, 0) = elem(m, 1, 1) / det;
+    elem(ret, 0, 1) = -elem(m, 0, 1) / det;
+    elem(ret, 1, 0) = -elem(m, 1, 0) / det;
+    elem(ret, 1, 1) = elem(m, 0, 0) / det;
+
+    return ret;
+  }
+
+  // 4 X 4 matrix inverse
+  template <typename M = matrix_t>
+    requires(algebra::traits::rank<M> == 4)
+  ALGEBRA_HOST_DEVICE constexpr matrix_t operator()(const matrix_t &m) const {
+
+    constexpr element_getter_t elem{};
+
+    matrix_t ret;
+    elem(ret, 0, 0) = elem(m, 1, 2) * elem(m, 2, 3) * elem(m, 3, 1) -
+                      elem(m, 1, 3) * elem(m, 2, 2) * elem(m, 3, 1) +
+                      elem(m, 1, 3) * elem(m, 2, 1) * elem(m, 3, 2) -
+                      elem(m, 1, 1) * elem(m, 2, 3) * elem(m, 3, 2) -
+                      elem(m, 1, 2) * elem(m, 2, 1) * elem(m, 3, 3) +
+                      elem(m, 1, 1) * elem(m, 2, 2) * elem(m, 3, 3);
+    elem(ret, 0, 1) = elem(m, 0, 3) * elem(m, 2, 2) * elem(m, 3, 1) -
+                      elem(m, 0, 2) * elem(m, 2, 3) * elem(m, 3, 1) -
+                      elem(m, 0, 3) * elem(m, 2, 1) * elem(m, 3, 2) +
+                      elem(m, 0, 1) * elem(m, 2, 3) * elem(m, 3, 2) +
+                      elem(m, 0, 2) * elem(m, 2, 1) * elem(m, 3, 3) -
+                      elem(m, 0, 1) * elem(m, 2, 2) * elem(m, 3, 3);
+    elem(ret, 0, 2) = elem(m, 0, 2) * elem(m, 1, 3) * elem(m, 3, 1) -
+                      elem(m, 0, 3) * elem(m, 1, 2) * elem(m, 3, 1) +
+                      elem(m, 0, 3) * elem(m, 1, 1) * elem(m, 3, 2) -
+                      elem(m, 0, 1) * elem(m, 1, 3) * elem(m, 3, 2) -
+                      elem(m, 0, 2) * elem(m, 1, 1) * elem(m, 3, 3) +
+                      elem(m, 0, 1) * elem(m, 1, 2) * elem(m, 3, 3);
+    elem(ret, 0, 3) = elem(m, 0, 3) * elem(m, 1, 2) * elem(m, 2, 1) -
+                      elem(m, 0, 2) * elem(m, 1, 3) * elem(m, 2, 1) -
+                      elem(m, 0, 3) * elem(m, 1, 1) * elem(m, 2, 2) +
+                      elem(m, 0, 1) * elem(m, 1, 3) * elem(m, 2, 2) +
+                      elem(m, 0, 2) * elem(m, 1, 1) * elem(m, 2, 3) -
+                      elem(m, 0, 1) * elem(m, 1, 2) * elem(m, 2, 3);
+    elem(ret, 1, 0) = elem(m, 1, 3) * elem(m, 2, 2) * elem(m, 3, 0) -
+                      elem(m, 1, 2) * elem(m, 2, 3) * elem(m, 3, 0) -
+                      elem(m, 1, 3) * elem(m, 2, 0) * elem(m, 3, 2) +
+                      elem(m, 1, 0) * elem(m, 2, 3) * elem(m, 3, 2) +
+                      elem(m, 1, 2) * elem(m, 2, 0) * elem(m, 3, 3) -
+                      elem(m, 1, 0) * elem(m, 2, 2) * elem(m, 3, 3);
+    elem(ret, 1, 1) = elem(m, 0, 2) * elem(m, 2, 3) * elem(m, 3, 0) -
+                      elem(m, 0, 3) * elem(m, 2, 2) * elem(m, 3, 0) +
+                      elem(m, 0, 3) * elem(m, 2, 0) * elem(m, 3, 2) -
+                      elem(m, 0, 0) * elem(m, 2, 3) * elem(m, 3, 2) -
+                      elem(m, 0, 2) * elem(m, 2, 0) * elem(m, 3, 3) +
+                      elem(m, 0, 0) * elem(m, 2, 2) * elem(m, 3, 3);
+    elem(ret, 1, 2) = elem(m, 0, 3) * elem(m, 1, 2) * elem(m, 3, 0) -
+                      elem(m, 0, 2) * elem(m, 1, 3) * elem(m, 3, 0) -
+                      elem(m, 0, 3) * elem(m, 1, 0) * elem(m, 3, 2) +
+                      elem(m, 0, 0) * elem(m, 1, 3) * elem(m, 3, 2) +
+                      elem(m, 0, 2) * elem(m, 1, 0) * elem(m, 3, 3) -
+                      elem(m, 0, 0) * elem(m, 1, 2) * elem(m, 3, 3);
+    elem(ret, 1, 3) = elem(m, 0, 2) * elem(m, 1, 3) * elem(m, 2, 0) -
+                      elem(m, 0, 3) * elem(m, 1, 2) * elem(m, 2, 0) +
+                      elem(m, 0, 3) * elem(m, 1, 0) * elem(m, 2, 2) -
+                      elem(m, 0, 0) * elem(m, 1, 3) * elem(m, 2, 2) -
+                      elem(m, 0, 2) * elem(m, 1, 0) * elem(m, 2, 3) +
+                      elem(m, 0, 0) * elem(m, 1, 2) * elem(m, 2, 3);
+    elem(ret, 2, 0) = elem(m, 1, 1) * elem(m, 2, 3) * elem(m, 3, 0) -
+                      elem(m, 1, 3) * elem(m, 2, 1) * elem(m, 3, 0) +
+                      elem(m, 1, 3) * elem(m, 2, 0) * elem(m, 3, 1) -
+                      elem(m, 1, 0) * elem(m, 2, 3) * elem(m, 3, 1) -
+                      elem(m, 1, 1) * elem(m, 2, 0) * elem(m, 3, 3) +
+                      elem(m, 1, 0) * elem(m, 2, 1) * elem(m, 3, 3);
+    elem(ret, 2, 1) = elem(m, 0, 3) * elem(m, 2, 1) * elem(m, 3, 0) -
+                      elem(m, 0, 1) * elem(m, 2, 3) * elem(m, 3, 0) -
+                      elem(m, 0, 3) * elem(m, 2, 0) * elem(m, 3, 1) +
+                      elem(m, 0, 0) * elem(m, 2, 3) * elem(m, 3, 1) +
+                      elem(m, 0, 1) * elem(m, 2, 0) * elem(m, 3, 3) -
+                      elem(m, 0, 0) * elem(m, 2, 1) * elem(m, 3, 3);
+    elem(ret, 2, 2) = elem(m, 0, 1) * elem(m, 1, 3) * elem(m, 3, 0) -
+                      elem(m, 0, 3) * elem(m, 1, 1) * elem(m, 3, 0) +
+                      elem(m, 0, 3) * elem(m, 1, 0) * elem(m, 3, 1) -
+                      elem(m, 0, 0) * elem(m, 1, 3) * elem(m, 3, 1) -
+                      elem(m, 0, 1) * elem(m, 1, 0) * elem(m, 3, 3) +
+                      elem(m, 0, 0) * elem(m, 1, 1) * elem(m, 3, 3);
+    elem(ret, 2, 3) = elem(m, 0, 3) * elem(m, 1, 1) * elem(m, 2, 0) -
+                      elem(m, 0, 1) * elem(m, 1, 3) * elem(m, 2, 0) -
+                      elem(m, 0, 3) * elem(m, 1, 0) * elem(m, 2, 1) +
+                      elem(m, 0, 0) * elem(m, 1, 3) * elem(m, 2, 1) +
+                      elem(m, 0, 1) * elem(m, 1, 0) * elem(m, 2, 3) -
+                      elem(m, 0, 0) * elem(m, 1, 1) * elem(m, 2, 3);
+    elem(ret, 3, 0) = elem(m, 1, 2) * elem(m, 2, 1) * elem(m, 3, 0) -
+                      elem(m, 1, 1) * elem(m, 2, 2) * elem(m, 3, 0) -
+                      elem(m, 1, 2) * elem(m, 2, 0) * elem(m, 3, 1) +
+                      elem(m, 1, 0) * elem(m, 2, 2) * elem(m, 3, 1) +
+                      elem(m, 1, 1) * elem(m, 2, 0) * elem(m, 3, 2) -
+                      elem(m, 1, 0) * elem(m, 2, 1) * elem(m, 3, 2);
+    elem(ret, 3, 1) = elem(m, 0, 1) * elem(m, 2, 2) * elem(m, 3, 0) -
+                      elem(m, 0, 2) * elem(m, 2, 1) * elem(m, 3, 0) +
+                      elem(m, 0, 2) * elem(m, 2, 0) * elem(m, 3, 1) -
+                      elem(m, 0, 0) * elem(m, 2, 2) * elem(m, 3, 1) -
+                      elem(m, 0, 1) * elem(m, 2, 0) * elem(m, 3, 2) +
+                      elem(m, 0, 0) * elem(m, 2, 1) * elem(m, 3, 2);
+    elem(ret, 3, 2) = elem(m, 0, 2) * elem(m, 1, 1) * elem(m, 3, 0) -
+                      elem(m, 0, 1) * elem(m, 1, 2) * elem(m, 3, 0) -
+                      elem(m, 0, 2) * elem(m, 1, 0) * elem(m, 3, 1) +
+                      elem(m, 0, 0) * elem(m, 1, 2) * elem(m, 3, 1) +
+                      elem(m, 0, 1) * elem(m, 1, 0) * elem(m, 3, 2) -
+                      elem(m, 0, 0) * elem(m, 1, 1) * elem(m, 3, 2);
+    elem(ret, 3, 3) = elem(m, 0, 1) * elem(m, 1, 2) * elem(m, 2, 0) -
+                      elem(m, 0, 2) * elem(m, 1, 1) * elem(m, 2, 0) +
+                      elem(m, 0, 2) * elem(m, 1, 0) * elem(m, 2, 1) -
+                      elem(m, 0, 0) * elem(m, 1, 2) * elem(m, 2, 1) -
+                      elem(m, 0, 1) * elem(m, 1, 0) * elem(m, 2, 2) +
+                      elem(m, 0, 0) * elem(m, 1, 1) * elem(m, 2, 2);
+
+    const scalar_t idet = static_cast<scalar_t>(1.) / determinant_getter()(ret);
+    for (unsigned int c = 0; c < 4; ++c) {
+      for (unsigned int r = 0; r < 4; ++r) {
+        elem(ret, c, r) *= idet;
+      }
+    }
+
+    return ret;
+  }
+};
+
+}  // namespace algebra::generic::matrix::inverse
diff --git a/generic/include/algebra/algorithms/matrix/inverse/partial_pivot_lud.hpp b/generic/include/algebra/algorithms/matrix/inverse/partial_pivot_lud.hpp
new file mode 100644
index 00000000..0e00ccae
--- /dev/null
+++ b/generic/include/algebra/algorithms/matrix/inverse/partial_pivot_lud.hpp
@@ -0,0 +1,73 @@
+/** Algebra plugins library, part of the ACTS project
+ *
+ * (c) 2022-2026 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s).
+#include "algebra/algorithms/matrix/decomposition/partial_pivot_lud.hpp"
+#include "algebra/concepts.hpp"
+#include "algebra/qualifiers.hpp"
+#include "algebra/type_traits.hpp"
+
+namespace algebra::generic::matrix::inverse {
+
+/// "Partial Pivot LU Decomposition", assuming a N X N matrix
+template <concepts::square_matrix matrix_t>
+struct partial_pivot_lud {
+
+  using scalar_t = algebra::traits::value_t<matrix_t>;
+  using index_t = algebra::traits::index_t<matrix_t>;
+
+  /// Function (object) used for accessing a matrix element
+  using element_getter_t = algebra::traits::element_getter_t<matrix_t>;
+
+  using decomposition_t =
+      typename algebra::generic::matrix::decomposition::partial_pivot_lud<
+          matrix_t>;
+
+  ALGEBRA_HOST_DEVICE constexpr matrix_t operator()(const matrix_t& m) const {
+
+    constexpr element_getter_t elem{};
+    constexpr index_t N{algebra::traits::rank<matrix_t>};
+
+    const typename decomposition_t::template lud<N> decomp_res =
+        decomposition_t()(m);
+
+    // Get the LU decomposition matrix equal to (L - I) + U
+    const auto& lu = decomp_res.lu;
+
+    // Permutation vector
+    const auto& P = decomp_res.P;
+
+    // Inverse matrix
+    matrix_t inv;
+
+    // Calculate inv(A) = inv(U) * inv(L) * P;
+    for (index_t j = 0; j < N; j++) {
+      for (index_t i = 0; i < N; i++) {
+        elem(inv, i, j) = static_cast<index_t>(P[i]) == j
+                              ? static_cast<scalar_t>(1.0)
+                              : static_cast<scalar_t>(0.0);
+
+        for (index_t k = 0; k < i; k++) {
+          elem(inv, i, j) -= elem(lu, i, k) * elem(inv, k, j);
+        }
+      }
+
+      for (index_t i = N - 1; int(i) >= 0; i--) {
+        for (index_t k = i + 1; k < N; k++) {
+          elem(inv, i, j) -= elem(lu, i, k) * elem(inv, k, j);
+        }
+        elem(inv, i, j) /= elem(lu, i, i);
+      }
+    }
+
+    return inv;
+  }
+};
+
+}  // namespace algebra::generic::matrix::inverse
diff --git a/math/generic/include/algebra/math/algorithms/utils/algorithm_finder.hpp b/generic/include/algebra/algorithms/utils/algorithm_selector.hpp
similarity index 58%
rename from math/generic/include/algebra/math/algorithms/utils/algorithm_finder.hpp
rename to generic/include/algebra/algorithms/utils/algorithm_selector.hpp
index 43bb450e..73dcc8ea 100644
--- a/math/generic/include/algebra/math/algorithms/utils/algorithm_finder.hpp
+++ b/generic/include/algebra/algorithms/utils/algorithm_selector.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins library, part of the ACTS project
  *
- * (c) 2022-2024 CERN for the benefit of the ACTS project
+ * (c) 2022-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -8,14 +8,14 @@
 #pragma once
 
 // Project include(s).
-#include "algebra/math/algorithms/matrix/determinant/hard_coded.hpp"
-#include "algebra/math/algorithms/matrix/determinant/partial_pivot_lud.hpp"
-#include "algebra/math/algorithms/matrix/inverse/hard_coded.hpp"
-#include "algebra/math/algorithms/matrix/inverse/partial_pivot_lud.hpp"
+#include "algebra/algorithms/matrix/determinant/hard_coded.hpp"
+#include "algebra/algorithms/matrix/determinant/partial_pivot_lud.hpp"
+#include "algebra/algorithms/matrix/inverse/hard_coded.hpp"
+#include "algebra/algorithms/matrix/inverse/partial_pivot_lud.hpp"
 
 namespace algebra::generic {
 
-/// Get the type of determinant algorithm acording to matrix dimension
+/// Get the type of determinant algorithm according to matrix dimension
 /// @{
 
 // Default algorithm
@@ -33,11 +33,10 @@ struct determinant_selector<2, Args...> {
 /// @tparam M matrix type
 template <concepts::square_matrix M>
 using determinant_t =
-    typename determinant_selector<algebra::traits::rank<M>, M,
-                                  algebra::traits::element_getter_t<M>>::type;
+    typename determinant_selector<algebra::traits::rank<M>, M>::type;
 /// @}
 
-/// Get the type of inversion algorithm acording to matrix dimension
+/// Get the type of inversion algorithm according to matrix dimension
 /// @{
 template <std::size_t N, typename... Args>
 struct inversion_selector {
@@ -53,8 +52,7 @@ struct inversion_selector<2, Args...> {
 /// @tparam M matrix type
 template <concepts::square_matrix M>
 using inversion_t =
-    typename inversion_selector<algebra::traits::rank<M>, M,
-                                algebra::traits::element_getter_t<M>>::type;
-/// @}generic
+    typename inversion_selector<algebra::traits::rank<M>, M>::type;
+/// @}
 
 }  // namespace algebra::generic
diff --git a/generic/include/algebra/generic.hpp b/generic/include/algebra/generic.hpp
new file mode 100644
index 00000000..d91e868b
--- /dev/null
+++ b/generic/include/algebra/generic.hpp
@@ -0,0 +1,25 @@
+/** Algebra plugins library, part of the ACTS project
+ *
+ * (c) 2020-2024 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Impl include(s).
+#include "algebra/boolean.hpp"
+#include "algebra/impl/generic_matrix.hpp"
+#include "algebra/impl/generic_transform3.hpp"
+#include "algebra/impl/generic_vector.hpp"
+#include "algebra/math.hpp"
+
+// Algorithms include(s).
+#include "algebra/algorithms/matrix/decomposition/partial_pivot_lud.hpp"
+#include "algebra/algorithms/matrix/determinant/cofactor.hpp"
+#include "algebra/algorithms/matrix/determinant/hard_coded.hpp"
+#include "algebra/algorithms/matrix/determinant/partial_pivot_lud.hpp"
+#include "algebra/algorithms/matrix/inverse/cofactor.hpp"
+#include "algebra/algorithms/matrix/inverse/hard_coded.hpp"
+#include "algebra/algorithms/matrix/inverse/partial_pivot_lud.hpp"
+#include "algebra/algorithms/utils/algorithm_selector.hpp"
diff --git a/math/generic/include/algebra/math/impl/generic_matrix.hpp b/generic/include/algebra/impl/generic_matrix.hpp
similarity index 99%
rename from math/generic/include/algebra/math/impl/generic_matrix.hpp
rename to generic/include/algebra/impl/generic_matrix.hpp
index 8ebd6516..77bd0744 100644
--- a/math/generic/include/algebra/math/impl/generic_matrix.hpp
+++ b/generic/include/algebra/impl/generic_matrix.hpp
@@ -8,9 +8,9 @@
 #pragma once
 
 // Project include(s).
+#include "algebra/algorithms/utils/algorithm_selector.hpp"
 #include "algebra/concepts.hpp"
-#include "algebra/math/algorithms/utils/algorithm_finder.hpp"
-#include "algebra/math/common.hpp"
+#include "algebra/math.hpp"
 #include "algebra/qualifiers.hpp"
 
 namespace algebra::generic::math {
diff --git a/math/generic/include/algebra/math/impl/generic_transform3.hpp b/generic/include/algebra/impl/generic_transform3.hpp
similarity index 96%
rename from math/generic/include/algebra/math/impl/generic_transform3.hpp
rename to generic/include/algebra/impl/generic_transform3.hpp
index d98f2657..e44d3f12 100644
--- a/math/generic/include/algebra/math/impl/generic_transform3.hpp
+++ b/generic/include/algebra/impl/generic_transform3.hpp
@@ -8,9 +8,9 @@
 #pragma once
 
 // Project include(s).
-#include "algebra/math/algorithms/matrix/inverse/hard_coded.hpp"
-#include "algebra/math/impl/generic_matrix.hpp"
-#include "algebra/math/impl/generic_vector.hpp"
+#include "algebra/algorithms/matrix/inverse/hard_coded.hpp"
+#include "algebra/impl/generic_matrix.hpp"
+#include "algebra/impl/generic_vector.hpp"
 #include "algebra/qualifiers.hpp"
 #include "algebra/type_traits.hpp"
 #include "algebra/utils/approximately_equal.hpp"
@@ -42,22 +42,16 @@ struct transform3 {
   using matrix44 = matrix_t<scalar_t, 4, 4>;
   static_assert(concepts::square_matrix<matrix44>);
 
-  /// 3-element "vector" type
   using vector3 = algebra::traits::get_vector_t<matrix44, 3, scalar_t>;
-  /// Point in 3D space
   using point3 = vector3;
-  /// Point in 2D space
   using point2 = algebra::traits::get_vector_t<matrix44, 2, scalar_t>;
 
-  /// Function (object) used for accessing a matrix element
+  /// Function (object) used for accessing a matrix element/block
   using element_getter = algebra::traits::element_getter_t<matrix44>;
-
-  /// Function (object) used for accessing a matrix element
   using block_getter = algebra::traits::block_getter_t<matrix44>;
 
   /// Matrix inversion algorithm
-  using matrix_inversion =
-      generic::matrix::inverse::hard_coded<matrix44, element_getter>;
+  using matrix_inversion = generic::matrix::inverse::hard_coded<matrix44>;
 
   /// Helper type to cast this to another floating point precision
   template <concepts::scalar o_scalar_t>
diff --git a/math/generic/include/algebra/math/impl/generic_vector.hpp b/generic/include/algebra/impl/generic_vector.hpp
similarity index 99%
rename from math/generic/include/algebra/math/impl/generic_vector.hpp
rename to generic/include/algebra/impl/generic_vector.hpp
index f1f49ff0..01099c7e 100644
--- a/math/generic/include/algebra/math/impl/generic_vector.hpp
+++ b/generic/include/algebra/impl/generic_vector.hpp
@@ -9,7 +9,7 @@
 
 // Project include(s).
 #include "algebra/concepts.hpp"
-#include "algebra/math/common.hpp"
+#include "algebra/math.hpp"
 #include "algebra/qualifiers.hpp"
 #include "algebra/type_traits.hpp"
 
diff --git a/math/CMakeLists.txt b/math/CMakeLists.txt
deleted file mode 100644
index 3a7e3604..00000000
--- a/math/CMakeLists.txt
+++ /dev/null
@@ -1,27 +0,0 @@
-# Algebra plugins library, part of the ACTS project (R&D line)
-#
-# (c) 2021-2026 CERN for the benefit of the ACTS project
-#
-# Mozilla Public License Version 2.0
-
-# Set up all enabled libraries.
-add_subdirectory(common)
-add_subdirectory(cmath)
-add_subdirectory(generic)
-
-if(ALGEBRA_PLUGINS_INCLUDE_EIGEN)
-    add_subdirectory(eigen)
-endif()
-
-if(ALGEBRA_PLUGINS_INCLUDE_FASTOR)
-    add_subdirectory(fastor)
-endif()
-
-if(ALGEBRA_PLUGINS_INCLUDE_SMATRIX)
-    add_subdirectory(smatrix)
-endif()
-
-if(ALGEBRA_PLUGINS_INCLUDE_VC)
-    add_subdirectory(vc_aos)
-    add_subdirectory(vc_soa)
-endif()
diff --git a/math/cmath/CMakeLists.txt b/math/cmath/CMakeLists.txt
deleted file mode 100644
index b1066bda..00000000
--- a/math/cmath/CMakeLists.txt
+++ /dev/null
@@ -1,21 +0,0 @@
-# Algebra plugins library, part of the ACTS project (R&D line)
-#
-# (c) 2021-2024 CERN for the benefit of the ACTS project
-#
-# Mozilla Public License Version 2.0
-
-# Set up the library.
-algebra_add_library(algebra_cmath_math cmath_math
-   # impl include
-   "include/algebra/math/cmath.hpp"
-   "include/algebra/math/impl/cmath_matrix.hpp"
-   "include/algebra/math/impl/cmath_operators.hpp"
-   "include/algebra/math/impl/cmath_vector.hpp"
-)
-target_link_libraries(
-    algebra_cmath_math
-    INTERFACE algebra::common algebra::common_math algebra::generic_math
-)
-algebra_test_public_headers( algebra_cmath_math
-   "algebra/math/cmath.hpp"
-)
diff --git a/math/cmath/include/algebra/math/cmath.hpp b/math/cmath/include/algebra/math/cmath.hpp
deleted file mode 100644
index 5423775d..00000000
--- a/math/cmath/include/algebra/math/cmath.hpp
+++ /dev/null
@@ -1,15 +0,0 @@
-/** Algebra plugins library, part of the ACTS project
- *
- * (c) 2020-2024 CERN for the benefit of the ACTS project
- *
- * Mozilla Public License Version 2.0
- */
-
-#pragma once
-
-// Impl include(s).
-#include "algebra/math/boolean.hpp"
-#include "algebra/math/common.hpp"
-#include "algebra/math/impl/cmath_matrix.hpp"
-#include "algebra/math/impl/cmath_operators.hpp"
-#include "algebra/math/impl/cmath_vector.hpp"
diff --git a/math/common/CMakeLists.txt b/math/common/CMakeLists.txt
deleted file mode 100644
index 31d13beb..00000000
--- a/math/common/CMakeLists.txt
+++ /dev/null
@@ -1,17 +0,0 @@
-# Algebra plugins library, part of the ACTS project (R&D line)
-#
-# (c) 2022-2023 CERN for the benefit of the ACTS project
-#
-# Mozilla Public License Version 2.0
-
-# Set up the library.
-algebra_add_library(algebra_common_math common_math
-   # Math
-   "include/algebra/math/boolean.hpp"
-   "include/algebra/math/common.hpp"
-)
-target_link_libraries(algebra_common_math INTERFACE algebra::common)
-algebra_test_public_headers( algebra_common_math
-   "algebra/math/boolean.hpp"
-   "algebra/math/common.hpp"
-)
diff --git a/math/eigen/CMakeLists.txt b/math/eigen/CMakeLists.txt
deleted file mode 100644
index 90fb706c..00000000
--- a/math/eigen/CMakeLists.txt
+++ /dev/null
@@ -1,25 +0,0 @@
-# Algebra plugins library, part of the ACTS project (R&D line)
-#
-# (c) 2021-2024 CERN for the benefit of the ACTS project
-#
-# Mozilla Public License Version 2.0
-
-# Set up the library.
-algebra_add_library(algebra_eigen_math eigen_math
-   "include/algebra/math/eigen.hpp"
-   "include/algebra/math/impl/eigen_matrix.hpp"
-   "include/algebra/math/impl/eigen_transform3.hpp"
-   "include/algebra/math/impl/eigen_vector.hpp"
-)
-target_link_libraries(
-    algebra_eigen_math
-    INTERFACE
-        Eigen3::Eigen
-        algebra::common
-        algebra::utils
-        algebra::common_math
-        algebra::eigen_storage
-)
-algebra_test_public_headers( algebra_eigen_math
-   "algebra/math/eigen.hpp"
-)
diff --git a/math/eigen/include/algebra/math/eigen.hpp b/math/eigen/include/algebra/math/eigen.hpp
deleted file mode 100644
index eb9250e3..00000000
--- a/math/eigen/include/algebra/math/eigen.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-/** Algebra plugins library, part of the ACTS project
- *
- * (c) 2020-2022 CERN for the benefit of the ACTS project
- *
- * Mozilla Public License Version 2.0
- */
-
-#pragma once
-
-// Project include(s).
-#include "algebra/math/boolean.hpp"
-#include "algebra/math/common.hpp"
-#include "algebra/math/impl/eigen_matrix.hpp"
-#include "algebra/math/impl/eigen_transform3.hpp"
-#include "algebra/math/impl/eigen_vector.hpp"
-#include "algebra/storage/impl/eigen_getter.hpp"
diff --git a/math/fastor/CMakeLists.txt b/math/fastor/CMakeLists.txt
deleted file mode 100644
index d54f8797..00000000
--- a/math/fastor/CMakeLists.txt
+++ /dev/null
@@ -1,25 +0,0 @@
-# Algebra plugins library, part of the ACTS project (R&D line)
-#
-# (c) 2022-2024 CERN for the benefit of the ACTS project
-#
-# Mozilla Public License Version 2.0
-
-# Set up the library.
-algebra_add_library(algebra_fastor_math fastor_math
-   "include/algebra/math/fastor.hpp"
-   "include/algebra/math/impl/fastor_matrix.hpp"
-   "include/algebra/math/impl/fastor_transform3.hpp"
-   "include/algebra/math/impl/fastor_vector.hpp"
-)
-target_link_libraries(
-    algebra_fastor_math
-    INTERFACE
-        Fastor::Fastor
-        algebra::common
-        algebra::utils
-        algebra::common_math
-        algebra::fastor_storage
-)
-algebra_test_public_headers( algebra_fastor_math
-   "algebra/math/fastor.hpp"
-)
diff --git a/math/fastor/include/algebra/math/fastor.hpp b/math/fastor/include/algebra/math/fastor.hpp
deleted file mode 100644
index 84e6587a..00000000
--- a/math/fastor/include/algebra/math/fastor.hpp
+++ /dev/null
@@ -1,15 +0,0 @@
-/** Algebra plugins library, part of the ACTS project
- *
- * (c) 2020-2022 CERN for the benefit of the ACTS project
- *
- * Mozilla Public License Version 2.0
- */
-
-#pragma once
-
-// Project include(s).
-#include "algebra/math/boolean.hpp"
-#include "algebra/math/common.hpp"
-#include "algebra/math/impl/fastor_matrix.hpp"
-#include "algebra/math/impl/fastor_transform3.hpp"
-#include "algebra/math/impl/fastor_vector.hpp"
diff --git a/math/generic/CMakeLists.txt b/math/generic/CMakeLists.txt
deleted file mode 100644
index e27afce7..00000000
--- a/math/generic/CMakeLists.txt
+++ /dev/null
@@ -1,30 +0,0 @@
-# Algebra plugins library, part of the ACTS project (R&D line)
-#
-# (c) 2021-2024 CERN for the benefit of the ACTS project
-#
-# Mozilla Public License Version 2.0
-
-# Set up the library.
-algebra_add_library(algebra_generic_math generic_math
-   # impl include
-   "include/algebra/math/generic.hpp"
-   "include/algebra/math/impl/generic_matrix.hpp"
-   "include/algebra/math/impl/generic_transform3.hpp"
-   "include/algebra/math/impl/generic_vector.hpp"
-   # algorithms include
-   "include/algebra/math/algorithms/matrix/decomposition/partial_pivot_lud.hpp"
-   "include/algebra/math/algorithms/matrix/determinant/cofactor.hpp"
-   "include/algebra/math/algorithms/matrix/determinant/hard_coded.hpp"
-   "include/algebra/math/algorithms/matrix/determinant/partial_pivot_lud.hpp"
-   "include/algebra/math/algorithms/matrix/inverse/cofactor.hpp"
-   "include/algebra/math/algorithms/matrix/inverse/hard_coded.hpp"
-   "include/algebra/math/algorithms/matrix/inverse/partial_pivot_lud.hpp"
-   "include/algebra/math/algorithms/utils/algorithm_finder.hpp"
-)
-target_link_libraries(
-    algebra_generic_math
-    INTERFACE algebra::common algebra::utils algebra::common_math
-)
-algebra_test_public_headers( algebra_generic_math
-   "algebra/math/generic.hpp"
-)
diff --git a/math/generic/include/algebra/math/algorithms/matrix/determinant/hard_coded.hpp b/math/generic/include/algebra/math/algorithms/matrix/determinant/hard_coded.hpp
deleted file mode 100644
index f73225ee..00000000
--- a/math/generic/include/algebra/math/algorithms/matrix/determinant/hard_coded.hpp
+++ /dev/null
@@ -1,97 +0,0 @@
-/** Algebra plugins library, part of the ACTS project
- *
- * (c) 2022-2024 CERN for the benefit of the ACTS project
- *
- * Mozilla Public License Version 2.0
- */
-
-#pragma once
-
-// Project include(s).
-#include "algebra/concepts.hpp"
-#include "algebra/qualifiers.hpp"
-#include "algebra/type_traits.hpp"
-
-// System include(s)
-#include <type_traits>
-
-namespace algebra::generic::matrix::determinant {
-
-/// "Determinant getter", assuming a N X N matrix
-template <concepts::square_matrix matrix_t, class element_getter_t>
-struct hard_coded {
-
-  using scalar_type = algebra::traits::value_t<matrix_t>;
-  using size_type = algebra::traits::index_t<matrix_t>;
-
-  /// Function (object) used for accessing a matrix element
-  using element_getter = element_getter_t;
-
-  // 2 X 2 matrix determinant
-  template <typename M = matrix_t>
-    requires(algebra::traits::rank<M> == 2)
-  ALGEBRA_HOST_DEVICE constexpr scalar_type operator()(
-      const matrix_t &m) const {
-
-    return element_getter()(m, 0, 0) * element_getter()(m, 1, 1) -
-           element_getter()(m, 0, 1) * element_getter()(m, 1, 0);
-  }
-
-  // 4 X 4 matrix determinant
-  template <typename M = matrix_t>
-    requires(algebra::traits::rank<M> == 4)
-  ALGEBRA_HOST_DEVICE constexpr scalar_type operator()(
-      const matrix_t &m) const {
-
-    return element_getter()(m, 0, 3) * element_getter()(m, 1, 2) *
-               element_getter()(m, 2, 1) * element_getter()(m, 3, 0) -
-           element_getter()(m, 0, 2) * element_getter()(m, 1, 3) *
-               element_getter()(m, 2, 1) * element_getter()(m, 3, 0) -
-           element_getter()(m, 0, 3) * element_getter()(m, 1, 1) *
-               element_getter()(m, 2, 2) * element_getter()(m, 3, 0) +
-           element_getter()(m, 0, 1) * element_getter()(m, 1, 3) *
-               element_getter()(m, 2, 2) * element_getter()(m, 3, 0) +
-           element_getter()(m, 0, 2) * element_getter()(m, 1, 1) *
-               element_getter()(m, 2, 3) * element_getter()(m, 3, 0) -
-           element_getter()(m, 0, 1) * element_getter()(m, 1, 2) *
-               element_getter()(m, 2, 3) * element_getter()(m, 3, 0) -
-           element_getter()(m, 0, 3) * element_getter()(m, 1, 2) *
-               element_getter()(m, 2, 0) * element_getter()(m, 3, 1) +
-           element_getter()(m, 0, 2) * element_getter()(m, 1, 3) *
-               element_getter()(m, 2, 0) * element_getter()(m, 3, 1) +
-           element_getter()(m, 0, 3) * element_getter()(m, 1, 0) *
-               element_getter()(m, 2, 2) * element_getter()(m, 3, 1) -
-           element_getter()(m, 0, 0) * element_getter()(m, 1, 3) *
-               element_getter()(m, 2, 2) * element_getter()(m, 3, 1) -
-           element_getter()(m, 0, 2) * element_getter()(m, 1, 0) *
-               element_getter()(m, 2, 3) * element_getter()(m, 3, 1) +
-           element_getter()(m, 0, 0) * element_getter()(m, 1, 2) *
-               element_getter()(m, 2, 3) * element_getter()(m, 3, 1) +
-           element_getter()(m, 0, 3) * element_getter()(m, 1, 1) *
-               element_getter()(m, 2, 0) * element_getter()(m, 3, 2) -
-           element_getter()(m, 0, 1) * element_getter()(m, 1, 3) *
-               element_getter()(m, 2, 0) * element_getter()(m, 3, 2) -
-           element_getter()(m, 0, 3) * element_getter()(m, 1, 0) *
-               element_getter()(m, 2, 1) * element_getter()(m, 3, 2) +
-           element_getter()(m, 0, 0) * element_getter()(m, 1, 3) *
-               element_getter()(m, 2, 1) * element_getter()(m, 3, 2) +
-           element_getter()(m, 0, 1) * element_getter()(m, 1, 0) *
-               element_getter()(m, 2, 3) * element_getter()(m, 3, 2) -
-           element_getter()(m, 0, 0) * element_getter()(m, 1, 1) *
-               element_getter()(m, 2, 3) * element_getter()(m, 3, 2) -
-           element_getter()(m, 0, 2) * element_getter()(m, 1, 1) *
-               element_getter()(m, 2, 0) * element_getter()(m, 3, 3) +
-           element_getter()(m, 0, 1) * element_getter()(m, 1, 2) *
-               element_getter()(m, 2, 0) * element_getter()(m, 3, 3) +
-           element_getter()(m, 0, 2) * element_getter()(m, 1, 0) *
-               element_getter()(m, 2, 1) * element_getter()(m, 3, 3) -
-           element_getter()(m, 0, 0) * element_getter()(m, 1, 2) *
-               element_getter()(m, 2, 1) * element_getter()(m, 3, 3) -
-           element_getter()(m, 0, 1) * element_getter()(m, 1, 0) *
-               element_getter()(m, 2, 2) * element_getter()(m, 3, 3) +
-           element_getter()(m, 0, 0) * element_getter()(m, 1, 1) *
-               element_getter()(m, 2, 2) * element_getter()(m, 3, 3);
-  }
-};
-
-}  // namespace algebra::generic::matrix::determinant
diff --git a/math/generic/include/algebra/math/algorithms/matrix/inverse/hard_coded.hpp b/math/generic/include/algebra/math/algorithms/matrix/inverse/hard_coded.hpp
deleted file mode 100644
index c5bc01eb..00000000
--- a/math/generic/include/algebra/math/algorithms/matrix/inverse/hard_coded.hpp
+++ /dev/null
@@ -1,276 +0,0 @@
-/** Algebra plugins library, part of the ACTS project
- *
- * (c) 2022-2024 CERN for the benefit of the ACTS project
- *
- * Mozilla Public License Version 2.0
- */
-
-#pragma once
-
-// Project include(s).
-#include "algebra/concepts.hpp"
-#include "algebra/math/algorithms/matrix/determinant/hard_coded.hpp"
-#include "algebra/qualifiers.hpp"
-#include "algebra/type_traits.hpp"
-
-// System include(s)
-#include <type_traits>
-
-namespace algebra::generic::matrix::inverse {
-
-/// "inverse getter", assuming a N X N matrix
-template <concepts::square_matrix matrix_t, class element_getter_t>
-struct hard_coded {
-
-  using scalar_type = algebra::traits::value_t<matrix_t>;
-  using size_type = algebra::traits::index_t<matrix_t>;
-
-  /// Function (object) used for accessing a matrix element
-  using element_getter = element_getter_t;
-
-  using determinant_getter =
-      determinant::hard_coded<matrix_t, element_getter_t>;
-
-  // 2 X 2 matrix inverse
-  template <typename M = matrix_t>
-    requires(algebra::traits::rank<M> == 2)
-  ALGEBRA_HOST_DEVICE constexpr matrix_t operator()(const matrix_t &m) const {
-
-    matrix_t ret;
-
-    scalar_type det = determinant_getter()(m);
-
-    element_getter()(ret, 0, 0) = element_getter()(m, 1, 1) / det;
-    element_getter()(ret, 0, 1) = -1 * element_getter()(m, 0, 1) / det;
-    element_getter()(ret, 1, 0) = -1 * element_getter()(m, 1, 0) / det;
-    element_getter()(ret, 1, 1) = element_getter()(m, 0, 0) / det;
-
-    return ret;
-  }
-
-  // 4 X 4 matrix inverse
-  template <typename M = matrix_t>
-    requires(algebra::traits::rank<M> == 4)
-  ALGEBRA_HOST_DEVICE constexpr matrix_t operator()(const matrix_t &m) const {
-
-    matrix_t ret;
-    element_getter()(ret, 0, 0) =
-        element_getter()(m, 1, 2) * element_getter()(m, 2, 3) *
-            element_getter()(m, 3, 1) -
-        element_getter()(m, 1, 3) * element_getter()(m, 2, 2) *
-            element_getter()(m, 3, 1) +
-        element_getter()(m, 1, 3) * element_getter()(m, 2, 1) *
-            element_getter()(m, 3, 2) -
-        element_getter()(m, 1, 1) * element_getter()(m, 2, 3) *
-            element_getter()(m, 3, 2) -
-        element_getter()(m, 1, 2) * element_getter()(m, 2, 1) *
-            element_getter()(m, 3, 3) +
-        element_getter()(m, 1, 1) * element_getter()(m, 2, 2) *
-            element_getter()(m, 3, 3);
-    element_getter()(ret, 0, 1) =
-        element_getter()(m, 0, 3) * element_getter()(m, 2, 2) *
-            element_getter()(m, 3, 1) -
-        element_getter()(m, 0, 2) * element_getter()(m, 2, 3) *
-            element_getter()(m, 3, 1) -
-        element_getter()(m, 0, 3) * element_getter()(m, 2, 1) *
-            element_getter()(m, 3, 2) +
-        element_getter()(m, 0, 1) * element_getter()(m, 2, 3) *
-            element_getter()(m, 3, 2) +
-        element_getter()(m, 0, 2) * element_getter()(m, 2, 1) *
-            element_getter()(m, 3, 3) -
-        element_getter()(m, 0, 1) * element_getter()(m, 2, 2) *
-            element_getter()(m, 3, 3);
-    element_getter()(ret, 0, 2) =
-        element_getter()(m, 0, 2) * element_getter()(m, 1, 3) *
-            element_getter()(m, 3, 1) -
-        element_getter()(m, 0, 3) * element_getter()(m, 1, 2) *
-            element_getter()(m, 3, 1) +
-        element_getter()(m, 0, 3) * element_getter()(m, 1, 1) *
-            element_getter()(m, 3, 2) -
-        element_getter()(m, 0, 1) * element_getter()(m, 1, 3) *
-            element_getter()(m, 3, 2) -
-        element_getter()(m, 0, 2) * element_getter()(m, 1, 1) *
-            element_getter()(m, 3, 3) +
-        element_getter()(m, 0, 1) * element_getter()(m, 1, 2) *
-            element_getter()(m, 3, 3);
-    element_getter()(ret, 0, 3) =
-        element_getter()(m, 0, 3) * element_getter()(m, 1, 2) *
-            element_getter()(m, 2, 1) -
-        element_getter()(m, 0, 2) * element_getter()(m, 1, 3) *
-            element_getter()(m, 2, 1) -
-        element_getter()(m, 0, 3) * element_getter()(m, 1, 1) *
-            element_getter()(m, 2, 2) +
-        element_getter()(m, 0, 1) * element_getter()(m, 1, 3) *
-            element_getter()(m, 2, 2) +
-        element_getter()(m, 0, 2) * element_getter()(m, 1, 1) *
-            element_getter()(m, 2, 3) -
-        element_getter()(m, 0, 1) * element_getter()(m, 1, 2) *
-            element_getter()(m, 2, 3);
-    element_getter()(ret, 1, 0) =
-        element_getter()(m, 1, 3) * element_getter()(m, 2, 2) *
-            element_getter()(m, 3, 0) -
-        element_getter()(m, 1, 2) * element_getter()(m, 2, 3) *
-            element_getter()(m, 3, 0) -
-        element_getter()(m, 1, 3) * element_getter()(m, 2, 0) *
-            element_getter()(m, 3, 2) +
-        element_getter()(m, 1, 0) * element_getter()(m, 2, 3) *
-            element_getter()(m, 3, 2) +
-        element_getter()(m, 1, 2) * element_getter()(m, 2, 0) *
-            element_getter()(m, 3, 3) -
-        element_getter()(m, 1, 0) * element_getter()(m, 2, 2) *
-            element_getter()(m, 3, 3);
-    element_getter()(ret, 1, 1) =
-        element_getter()(m, 0, 2) * element_getter()(m, 2, 3) *
-            element_getter()(m, 3, 0) -
-        element_getter()(m, 0, 3) * element_getter()(m, 2, 2) *
-            element_getter()(m, 3, 0) +
-        element_getter()(m, 0, 3) * element_getter()(m, 2, 0) *
-            element_getter()(m, 3, 2) -
-        element_getter()(m, 0, 0) * element_getter()(m, 2, 3) *
-            element_getter()(m, 3, 2) -
-        element_getter()(m, 0, 2) * element_getter()(m, 2, 0) *
-            element_getter()(m, 3, 3) +
-        element_getter()(m, 0, 0) * element_getter()(m, 2, 2) *
-            element_getter()(m, 3, 3);
-    element_getter()(ret, 1, 2) =
-        element_getter()(m, 0, 3) * element_getter()(m, 1, 2) *
-            element_getter()(m, 3, 0) -
-        element_getter()(m, 0, 2) * element_getter()(m, 1, 3) *
-            element_getter()(m, 3, 0) -
-        element_getter()(m, 0, 3) * element_getter()(m, 1, 0) *
-            element_getter()(m, 3, 2) +
-        element_getter()(m, 0, 0) * element_getter()(m, 1, 3) *
-            element_getter()(m, 3, 2) +
-        element_getter()(m, 0, 2) * element_getter()(m, 1, 0) *
-            element_getter()(m, 3, 3) -
-        element_getter()(m, 0, 0) * element_getter()(m, 1, 2) *
-            element_getter()(m, 3, 3);
-    element_getter()(ret, 1, 3) =
-        element_getter()(m, 0, 2) * element_getter()(m, 1, 3) *
-            element_getter()(m, 2, 0) -
-        element_getter()(m, 0, 3) * element_getter()(m, 1, 2) *
-            element_getter()(m, 2, 0) +
-        element_getter()(m, 0, 3) * element_getter()(m, 1, 0) *
-            element_getter()(m, 2, 2) -
-        element_getter()(m, 0, 0) * element_getter()(m, 1, 3) *
-            element_getter()(m, 2, 2) -
-        element_getter()(m, 0, 2) * element_getter()(m, 1, 0) *
-            element_getter()(m, 2, 3) +
-        element_getter()(m, 0, 0) * element_getter()(m, 1, 2) *
-            element_getter()(m, 2, 3);
-    element_getter()(ret, 2, 0) =
-        element_getter()(m, 1, 1) * element_getter()(m, 2, 3) *
-            element_getter()(m, 3, 0) -
-        element_getter()(m, 1, 3) * element_getter()(m, 2, 1) *
-            element_getter()(m, 3, 0) +
-        element_getter()(m, 1, 3) * element_getter()(m, 2, 0) *
-            element_getter()(m, 3, 1) -
-        element_getter()(m, 1, 0) * element_getter()(m, 2, 3) *
-            element_getter()(m, 3, 1) -
-        element_getter()(m, 1, 1) * element_getter()(m, 2, 0) *
-            element_getter()(m, 3, 3) +
-        element_getter()(m, 1, 0) * element_getter()(m, 2, 1) *
-            element_getter()(m, 3, 3);
-    element_getter()(ret, 2, 1) =
-        element_getter()(m, 0, 3) * element_getter()(m, 2, 1) *
-            element_getter()(m, 3, 0) -
-        element_getter()(m, 0, 1) * element_getter()(m, 2, 3) *
-            element_getter()(m, 3, 0) -
-        element_getter()(m, 0, 3) * element_getter()(m, 2, 0) *
-            element_getter()(m, 3, 1) +
-        element_getter()(m, 0, 0) * element_getter()(m, 2, 3) *
-            element_getter()(m, 3, 1) +
-        element_getter()(m, 0, 1) * element_getter()(m, 2, 0) *
-            element_getter()(m, 3, 3) -
-        element_getter()(m, 0, 0) * element_getter()(m, 2, 1) *
-            element_getter()(m, 3, 3);
-    element_getter()(ret, 2, 2) =
-        element_getter()(m, 0, 1) * element_getter()(m, 1, 3) *
-            element_getter()(m, 3, 0) -
-        element_getter()(m, 0, 3) * element_getter()(m, 1, 1) *
-            element_getter()(m, 3, 0) +
-        element_getter()(m, 0, 3) * element_getter()(m, 1, 0) *
-            element_getter()(m, 3, 1) -
-        element_getter()(m, 0, 0) * element_getter()(m, 1, 3) *
-            element_getter()(m, 3, 1) -
-        element_getter()(m, 0, 1) * element_getter()(m, 1, 0) *
-            element_getter()(m, 3, 3) +
-        element_getter()(m, 0, 0) * element_getter()(m, 1, 1) *
-            element_getter()(m, 3, 3);
-    element_getter()(ret, 2, 3) =
-        element_getter()(m, 0, 3) * element_getter()(m, 1, 1) *
-            element_getter()(m, 2, 0) -
-        element_getter()(m, 0, 1) * element_getter()(m, 1, 3) *
-            element_getter()(m, 2, 0) -
-        element_getter()(m, 0, 3) * element_getter()(m, 1, 0) *
-            element_getter()(m, 2, 1) +
-        element_getter()(m, 0, 0) * element_getter()(m, 1, 3) *
-            element_getter()(m, 2, 1) +
-        element_getter()(m, 0, 1) * element_getter()(m, 1, 0) *
-            element_getter()(m, 2, 3) -
-        element_getter()(m, 0, 0) * element_getter()(m, 1, 1) *
-            element_getter()(m, 2, 3);
-    element_getter()(ret, 3, 0) =
-        element_getter()(m, 1, 2) * element_getter()(m, 2, 1) *
-            element_getter()(m, 3, 0) -
-        element_getter()(m, 1, 1) * element_getter()(m, 2, 2) *
-            element_getter()(m, 3, 0) -
-        element_getter()(m, 1, 2) * element_getter()(m, 2, 0) *
-            element_getter()(m, 3, 1) +
-        element_getter()(m, 1, 0) * element_getter()(m, 2, 2) *
-            element_getter()(m, 3, 1) +
-        element_getter()(m, 1, 1) * element_getter()(m, 2, 0) *
-            element_getter()(m, 3, 2) -
-        element_getter()(m, 1, 0) * element_getter()(m, 2, 1) *
-            element_getter()(m, 3, 2);
-    element_getter()(ret, 3, 1) =
-        element_getter()(m, 0, 1) * element_getter()(m, 2, 2) *
-            element_getter()(m, 3, 0) -
-        element_getter()(m, 0, 2) * element_getter()(m, 2, 1) *
-            element_getter()(m, 3, 0) +
-        element_getter()(m, 0, 2) * element_getter()(m, 2, 0) *
-            element_getter()(m, 3, 1) -
-        element_getter()(m, 0, 0) * element_getter()(m, 2, 2) *
-            element_getter()(m, 3, 1) -
-        element_getter()(m, 0, 1) * element_getter()(m, 2, 0) *
-            element_getter()(m, 3, 2) +
-        element_getter()(m, 0, 0) * element_getter()(m, 2, 1) *
-            element_getter()(m, 3, 2);
-    element_getter()(ret, 3, 2) =
-        element_getter()(m, 0, 2) * element_getter()(m, 1, 1) *
-            element_getter()(m, 3, 0) -
-        element_getter()(m, 0, 1) * element_getter()(m, 1, 2) *
-            element_getter()(m, 3, 0) -
-        element_getter()(m, 0, 2) * element_getter()(m, 1, 0) *
-            element_getter()(m, 3, 1) +
-        element_getter()(m, 0, 0) * element_getter()(m, 1, 2) *
-            element_getter()(m, 3, 1) +
-        element_getter()(m, 0, 1) * element_getter()(m, 1, 0) *
-            element_getter()(m, 3, 2) -
-        element_getter()(m, 0, 0) * element_getter()(m, 1, 1) *
-            element_getter()(m, 3, 2);
-    element_getter()(ret, 3, 3) =
-        element_getter()(m, 0, 1) * element_getter()(m, 1, 2) *
-            element_getter()(m, 2, 0) -
-        element_getter()(m, 0, 2) * element_getter()(m, 1, 1) *
-            element_getter()(m, 2, 0) +
-        element_getter()(m, 0, 2) * element_getter()(m, 1, 0) *
-            element_getter()(m, 2, 1) -
-        element_getter()(m, 0, 0) * element_getter()(m, 1, 2) *
-            element_getter()(m, 2, 1) -
-        element_getter()(m, 0, 1) * element_getter()(m, 1, 0) *
-            element_getter()(m, 2, 2) +
-        element_getter()(m, 0, 0) * element_getter()(m, 1, 1) *
-            element_getter()(m, 2, 2);
-
-    scalar_type idet = static_cast<scalar_type>(1.) / determinant_getter()(ret);
-    for (unsigned int c = 0; c < 4; ++c) {
-      for (unsigned int r = 0; r < 4; ++r) {
-        element_getter()(ret, c, r) *= idet;
-      }
-    }
-    return ret;
-  }
-};
-
-}  // namespace algebra::generic::matrix::inverse
diff --git a/math/generic/include/algebra/math/algorithms/matrix/inverse/partial_pivot_lud.hpp b/math/generic/include/algebra/math/algorithms/matrix/inverse/partial_pivot_lud.hpp
deleted file mode 100644
index 248cecac..00000000
--- a/math/generic/include/algebra/math/algorithms/matrix/inverse/partial_pivot_lud.hpp
+++ /dev/null
@@ -1,74 +0,0 @@
-/** Algebra plugins library, part of the ACTS project
- *
- * (c) 2022-2024 CERN for the benefit of the ACTS project
- *
- * Mozilla Public License Version 2.0
- */
-
-#pragma once
-
-// Project include(s).
-#include "algebra/concepts.hpp"
-#include "algebra/math/algorithms/matrix/decomposition/partial_pivot_lud.hpp"
-#include "algebra/qualifiers.hpp"
-#include "algebra/type_traits.hpp"
-
-namespace algebra::generic::matrix::inverse {
-
-/// "Partial Pivot LU Decomposition", assuming a N X N matrix
-template <concepts::square_matrix matrix_t, class element_getter_t>
-struct partial_pivot_lud {
-
-  using scalar_type = algebra::traits::value_t<matrix_t>;
-  using size_type = algebra::traits::index_t<matrix_t>;
-
-  /// Function (object) used for accessing a matrix element
-  using element_getter = element_getter_t;
-
-  using decomposition_t =
-      typename algebra::generic::matrix::decomposition::partial_pivot_lud<
-          matrix_t, element_getter_t>;
-
-  ALGEBRA_HOST_DEVICE constexpr matrix_t operator()(const matrix_t& m) const {
-
-    constexpr size_type N{algebra::traits::rank<matrix_t>};
-
-    const typename decomposition_t::template lud<N> decomp_res =
-        decomposition_t()(m);
-
-    // Get the LU decomposition matrix equal to (L - I) + U
-    const auto& lu = decomp_res.lu;
-
-    // Permutation vector
-    const auto& P = decomp_res.P;
-
-    // Inverse matrix
-    matrix_t inv;
-
-    // Calculate inv(A) = inv(U) * inv(L) * P;
-    for (size_type j = 0; j < N; j++) {
-      for (size_type i = 0; i < N; i++) {
-        element_getter_t()(inv, i, j) = static_cast<size_type>(P[i]) == j
-                                            ? static_cast<scalar_type>(1.0)
-                                            : static_cast<scalar_type>(0.0);
-
-        for (size_type k = 0; k < i; k++) {
-          element_getter_t()(inv, i, j) -=
-              element_getter_t()(lu, i, k) * element_getter_t()(inv, k, j);
-        }
-      }
-
-      for (size_type i = N - 1; int(i) >= 0; i--) {
-        for (size_type k = i + 1; k < N; k++) {
-          element_getter_t()(inv, i, j) -=
-              element_getter_t()(lu, i, k) * element_getter_t()(inv, k, j);
-        }
-        element_getter_t()(inv, i, j) /= element_getter_t()(lu, i, i);
-      }
-    }
-
-    return inv;
-  }
-};
-
-}  // namespace algebra::generic::matrix::inverse
diff --git a/math/generic/include/algebra/math/generic.hpp b/math/generic/include/algebra/math/generic.hpp
deleted file mode 100644
index bab33912..00000000
--- a/math/generic/include/algebra/math/generic.hpp
+++ /dev/null
@@ -1,25 +0,0 @@
-/** Algebra plugins library, part of the ACTS project
- *
- * (c) 2020-2024 CERN for the benefit of the ACTS project
- *
- * Mozilla Public License Version 2.0
- */
-
-#pragma once
-
-// Impl include(s).
-#include "algebra/math/boolean.hpp"
-#include "algebra/math/common.hpp"
-#include "algebra/math/impl/generic_matrix.hpp"
-#include "algebra/math/impl/generic_transform3.hpp"
-#include "algebra/math/impl/generic_vector.hpp"
-
-// Algorithms include(s).
-#include "algebra/math/algorithms/matrix/decomposition/partial_pivot_lud.hpp"
-#include "algebra/math/algorithms/matrix/determinant/cofactor.hpp"
-#include "algebra/math/algorithms/matrix/determinant/hard_coded.hpp"
-#include "algebra/math/algorithms/matrix/determinant/partial_pivot_lud.hpp"
-#include "algebra/math/algorithms/matrix/inverse/cofactor.hpp"
-#include "algebra/math/algorithms/matrix/inverse/hard_coded.hpp"
-#include "algebra/math/algorithms/matrix/inverse/partial_pivot_lud.hpp"
-#include "algebra/math/algorithms/utils/algorithm_finder.hpp"
diff --git a/math/smatrix/CMakeLists.txt b/math/smatrix/CMakeLists.txt
deleted file mode 100644
index c63ca4e5..00000000
--- a/math/smatrix/CMakeLists.txt
+++ /dev/null
@@ -1,30 +0,0 @@
-# Algebra plugins library, part of the ACTS project (R&D line)
-#
-# (c) 2021-2024 CERN for the benefit of the ACTS project
-#
-# Mozilla Public License Version 2.0
-
-# Find Smatrix.
-find_package(ROOT COMPONENTS Core MathCore Smatrix REQUIRED)
-
-# Set up the library.
-algebra_add_library(algebra_smatrix_math smatrix_math
-   "include/algebra/math/smatrix.hpp"
-   "include/algebra/math/impl/smatrix_errorcheck.hpp"
-   "include/algebra/math/impl/smatrix_matrix.hpp"
-   "include/algebra/math/impl/smatrix_transform3.hpp"
-   "include/algebra/math/impl/smatrix_vector.hpp"
-)
-target_link_libraries(
-    algebra_smatrix_math
-    INTERFACE
-        algebra::common
-        algebra::utils
-        algebra::smatrix_storage
-        ROOT::Core
-        ROOT::MathCore
-        ROOT::Smatrix
-)
-algebra_test_public_headers( algebra_smatrix_math
-   "algebra/math/smatrix.hpp"
-)
diff --git a/math/smatrix/include/algebra/math/smatrix.hpp b/math/smatrix/include/algebra/math/smatrix.hpp
deleted file mode 100644
index 5f4d86fb..00000000
--- a/math/smatrix/include/algebra/math/smatrix.hpp
+++ /dev/null
@@ -1,15 +0,0 @@
-/** Algebra plugins library, part of the ACTS project
- *
- * (c) 2020-2022 CERN for the benefit of the ACTS project
- *
- * Mozilla Public License Version 2.0
- */
-
-#pragma once
-
-// Project include(s).
-#include "algebra/math/boolean.hpp"
-#include "algebra/math/common.hpp"
-#include "algebra/math/impl/smatrix_matrix.hpp"
-#include "algebra/math/impl/smatrix_transform3.hpp"
-#include "algebra/math/impl/smatrix_vector.hpp"
diff --git a/math/vc_aos/CMakeLists.txt b/math/vc_aos/CMakeLists.txt
deleted file mode 100644
index 3d9b6f77..00000000
--- a/math/vc_aos/CMakeLists.txt
+++ /dev/null
@@ -1,26 +0,0 @@
-# Algebra plugins library, part of the ACTS project (R&D line)
-#
-# (c) 2021-2023 CERN for the benefit of the ACTS project
-#
-# Mozilla Public License Version 2.0
-
-# Set up the library.
-algebra_add_library( algebra_vc_aos_math vc_aos_math
-   "include/algebra/math/vc_aos.hpp"
-   "include/algebra/math/impl/vc_aos_matrix.hpp"
-   "include/algebra/math/impl/vc_aos_transform3.hpp"
-   "include/algebra/math/impl/vc_aos_vector.hpp"
-)
-target_link_libraries(
-    algebra_vc_aos_math
-    INTERFACE
-        Vc::Vc
-        algebra::common
-        algebra::utils
-        algebra::common_math
-        algebra::generic_math
-        algebra::vc_aos_storage
-)
-algebra_test_public_headers( algebra_vc_aos_math
-   "algebra/math/vc_aos.hpp"
-)
diff --git a/math/vc_aos/include/algebra/math/vc_aos.hpp b/math/vc_aos/include/algebra/math/vc_aos.hpp
deleted file mode 100644
index 38fa17d5..00000000
--- a/math/vc_aos/include/algebra/math/vc_aos.hpp
+++ /dev/null
@@ -1,15 +0,0 @@
-/** Algebra plugins library, part of the ACTS project
- *
- * (c) 2020-2024 CERN for the benefit of the ACTS project
- *
- * Mozilla Public License Version 2.0
- */
-
-#pragma once
-
-// Project include(s).
-#include "algebra/math/boolean.hpp"
-#include "algebra/math/common.hpp"
-#include "algebra/math/impl/vc_aos_matrix.hpp"
-#include "algebra/math/impl/vc_aos_transform3.hpp"
-#include "algebra/math/impl/vc_aos_vector.hpp"
diff --git a/math/vc_soa/CMakeLists.txt b/math/vc_soa/CMakeLists.txt
deleted file mode 100644
index bf35a24d..00000000
--- a/math/vc_soa/CMakeLists.txt
+++ /dev/null
@@ -1,26 +0,0 @@
-# Algebra plugins library, part of the ACTS project (R&D line)
-#
-# (c) 2021-2024 CERN for the benefit of the ACTS project
-#
-# Mozilla Public License Version 2.0
-
-# Set up the library.
-algebra_add_library( algebra_vc_soa_math vc_soa_math
-   "include/algebra/math/vc_soa.hpp"
-   "include/algebra/math/impl/vc_soa_boolean.hpp"
-   "include/algebra/math/impl/vc_soa_math.hpp"
-   "include/algebra/math/impl/vc_soa_matrix.hpp"
-   "include/algebra/math/impl/vc_soa_vector.hpp"
-)
-target_link_libraries(
-    algebra_vc_soa_math
-    INTERFACE
-        algebra::common
-        algebra::common_math
-        algebra::common_storage
-        algebra::vc_soa_storage
-        Vc::Vc
-)
-algebra_test_public_headers( algebra_vc_soa_math
-   "algebra/math/vc_soa.hpp"
-)
diff --git a/math/vc_soa/include/algebra/math/vc_soa.hpp b/math/vc_soa/include/algebra/math/vc_soa.hpp
deleted file mode 100644
index 70d7777b..00000000
--- a/math/vc_soa/include/algebra/math/vc_soa.hpp
+++ /dev/null
@@ -1,14 +0,0 @@
-/** Algebra plugins library, part of the ACTS project
- *
- * (c) 2023-2024 CERN for the benefit of the ACTS project
- *
- * Mozilla Public License Version 2.0
- */
-
-#pragma once
-
-// Project include(s).
-#include "algebra/math/impl/vc_soa_boolean.hpp"
-#include "algebra/math/impl/vc_soa_math.hpp"
-#include "algebra/math/impl/vc_soa_matrix.hpp"
-#include "algebra/math/impl/vc_soa_vector.hpp"
diff --git a/frontend/CMakeLists.txt b/plugins/CMakeLists.txt
similarity index 87%
rename from frontend/CMakeLists.txt
rename to plugins/CMakeLists.txt
index 3bda3efd..db18406b 100644
--- a/frontend/CMakeLists.txt
+++ b/plugins/CMakeLists.txt
@@ -5,7 +5,9 @@
 # Mozilla Public License Version 2.0
 
 # Set up all enabled libraries.
-add_subdirectory(array)
+if(ALGEBRA_PLUGINS_INCLUDE_ARRAY)
+    add_subdirectory(array)
+endif()
 
 if(ALGEBRA_PLUGINS_INCLUDE_EIGEN)
     add_subdirectory(eigen)
diff --git a/frontend/array/CMakeLists.txt b/plugins/array/CMakeLists.txt
similarity index 69%
rename from frontend/array/CMakeLists.txt
rename to plugins/array/CMakeLists.txt
index b75bd456..9aa0c778 100644
--- a/frontend/array/CMakeLists.txt
+++ b/plugins/array/CMakeLists.txt
@@ -9,16 +9,10 @@ message(STATUS "Building the std::array algebra plugin")
 # Set up the library.
 algebra_add_library( algebra_array array
    "include/algebra/array.hpp"
+   "include/algebra/impl/*.hpp"
 )
 
-target_link_libraries(
-    algebra_array
-    INTERFACE
-        algebra::common
-        algebra::array_storage
-        algebra::cmath_math
-        algebra::generic_math
-)
+target_link_libraries(algebra_array INTERFACE algebra::common algebra::generic)
 
 algebra_test_public_headers( algebra_array
    "algebra/array.hpp"
diff --git a/frontend/array/include/algebra/array.hpp b/plugins/array/include/algebra/array.hpp
similarity index 70%
rename from frontend/array/include/algebra/array.hpp
rename to plugins/array/include/algebra/array.hpp
index 3eb68a44..037503ab 100644
--- a/frontend/array/include/algebra/array.hpp
+++ b/plugins/array/include/algebra/array.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins library, part of the ACTS project
  *
- * (c) 2020-2024 CERN for the benefit of the ACTS project
+ * (c) 2020-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -8,19 +8,22 @@
 #pragma once
 
 // Project include(s).
-#include "algebra/math/cmath.hpp"
-#include "algebra/math/generic.hpp"
-#include "algebra/math/impl/generic_matrix.hpp"
-#include "algebra/storage/array.hpp"
+#include "algebra/generic.hpp"
+#include "algebra/impl/array_getter.hpp"
+#include "algebra/impl/array_matrix.hpp"
+#include "algebra/impl/array_operators.hpp"
+#include "algebra/impl/array_types.hpp"
+#include "algebra/impl/array_vector.hpp"
+#include "algebra/impl/generic_matrix.hpp"
 
 namespace algebra {
 
 /// @name Operators on @c algebra::array::storage_type
 /// @{
 
-using algebra::cmath::operator*;
-using algebra::cmath::operator-;
-using algebra::cmath::operator+;
+using algebra::array::operator*;
+using algebra::array::operator-;
+using algebra::array::operator+;
 
 /// @}
 
@@ -29,10 +32,10 @@ namespace getter {
 /// @name Getter functions on @c algebra::array::storage_type
 /// @{
 
-using cmath::storage::block;
-using cmath::storage::element;
-using cmath::storage::set_block;
-using cmath::storage::vector;
+using array::storage::block;
+using array::storage::element;
+using array::storage::set_block;
+using array::storage::vector;
 
 /// @}
 
@@ -44,16 +47,16 @@ namespace vector {
 /// @{
 
 // array specific implementations
-using cmath::dot;
-using cmath::normalize;
+using array::dot;
+using array::normalize;
 
 // generic implementations
-using cmath::cross;
-using cmath::eta;
-using cmath::norm;
-using cmath::perp;
-using cmath::phi;
-using cmath::theta;
+using array::cross;
+using array::eta;
+using array::norm;
+using array::perp;
+using array::phi;
+using array::theta;
 
 /// @}
 
@@ -67,16 +70,14 @@ template <concepts::scalar T, auto ROWS, auto COLS>
 struct determinant_selector<4, array::matrix_type<T, ROWS, COLS>,
                             array::element_getter> {
   using type =
-      matrix::determinant::hard_coded<array::matrix_type<T, ROWS, COLS>,
-                                      array::element_getter>;
+      matrix::determinant::hard_coded<array::matrix_type<T, ROWS, COLS>>;
 };
 
 // Inversion algorithms
 template <concepts::scalar T, auto ROWS, auto COLS>
 struct inversion_selector<4, array::matrix_type<T, ROWS, COLS>,
                           array::element_getter> {
-  using type = matrix::inverse::hard_coded<array::matrix_type<T, ROWS, COLS>,
-                                           array::element_getter>;
+  using type = matrix::inverse::hard_coded<array::matrix_type<T, ROWS, COLS>>;
 };
 
 }  // namespace generic
@@ -86,15 +87,15 @@ namespace matrix {
 /// @name Matrix functions on @c algebra::array::storage_type
 /// @{
 
-using cmath::identity;
-using cmath::set_identity;
-using cmath::set_zero;
-using cmath::zero;
+using array::identity;
+using array::set_identity;
+using array::set_zero;
+using array::zero;
 
 // Uses generic implementation in the background
-using cmath::determinant;
-using cmath::inverse;
-using cmath::transpose;
+using array::determinant;
+using array::inverse;
+using array::transpose;
 
 using generic::math::set_inplace_product_left;
 using generic::math::set_inplace_product_left_transpose;
@@ -111,12 +112,12 @@ using generic::math::transposed_product;
 
 namespace array {
 
-/// @name cmath based transforms on @c algebra::array
+/// @name array based transforms on @c algebra::array
 /// @{
 
 template <concepts::scalar T>
 using transform3 =
-    generic::math::transform3<array::size_type, T, array::matrix_type,
+    generic::math::transform3<array::index_type, T, array::matrix_type,
                               array::storage_type>;
 
 /// @}
@@ -137,7 +138,7 @@ struct array {
 
   using boolean = bool;
   using scalar = value_type;
-  using size_type = algebra::array::size_type;
+  using index_type = algebra::array::index_type;
   using transform3D = algebra::array::transform3<value_type>;
   using point2D = algebra::array::point2<value_type>;
   using point3D = algebra::array::point3<value_type>;
diff --git a/storage/cmath/include/algebra/storage/impl/cmath_getter.hpp b/plugins/array/include/algebra/impl/array_getter.hpp
similarity index 98%
rename from storage/cmath/include/algebra/storage/impl/cmath_getter.hpp
rename to plugins/array/include/algebra/impl/array_getter.hpp
index 1dc504e7..d36134b5 100644
--- a/storage/cmath/include/algebra/storage/impl/cmath_getter.hpp
+++ b/plugins/array/include/algebra/impl/array_getter.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins library, part of the ACTS project
  *
- * (c) 2020-2024 CERN for the benefit of the ACTS project
+ * (c) 2020-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -10,14 +10,14 @@
 // Project include(s).
 #include "algebra/assert.hpp"
 #include "algebra/concepts.hpp"
-#include "algebra/math/common.hpp"
+#include "algebra/math.hpp"
 #include "algebra/qualifiers.hpp"
 
 // System include(s).
 #include <cstddef>
 #include <type_traits>
 
-namespace algebra::cmath::storage {
+namespace algebra::array::storage {
 
 /// "Element getter", assuming a simple 2D array access
 struct element_getter {
@@ -236,4 +236,4 @@ ALGEBRA_HOST_DEVICE constexpr void set_block(input_matrix_type &m,
   }
 }
 
-}  // namespace algebra::cmath::storage
+}  // namespace algebra::array::storage
diff --git a/math/cmath/include/algebra/math/impl/cmath_matrix.hpp b/plugins/array/include/algebra/impl/array_matrix.hpp
similarity index 93%
rename from math/cmath/include/algebra/math/impl/cmath_matrix.hpp
rename to plugins/array/include/algebra/impl/array_matrix.hpp
index 4029500e..d0473661 100644
--- a/math/cmath/include/algebra/math/impl/cmath_matrix.hpp
+++ b/plugins/array/include/algebra/impl/array_matrix.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins library, part of the ACTS project
  *
- * (c) 2022-2024 CERN for the benefit of the ACTS project
+ * (c) 2022-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -9,11 +9,11 @@
 
 // Project include(s).
 #include "algebra/concepts.hpp"
-#include "algebra/math/common.hpp"
-#include "algebra/math/generic.hpp"
+#include "algebra/generic.hpp"
+#include "algebra/math.hpp"
 #include "algebra/qualifiers.hpp"
 
-namespace algebra::cmath {
+namespace algebra::array {
 
 /// @returns zero matrix of type @tparam matrix_t
 template <concepts::matrix matrix_t>
@@ -83,4 +83,4 @@ ALGEBRA_HOST_DEVICE constexpr auto inverse(
   return algebra::generic::math::inverse(m);
 }
 
-}  // namespace algebra::cmath
+}  // namespace algebra::array
diff --git a/math/cmath/include/algebra/math/impl/cmath_operators.hpp b/plugins/array/include/algebra/impl/array_operators.hpp
similarity index 75%
rename from math/cmath/include/algebra/math/impl/cmath_operators.hpp
rename to plugins/array/include/algebra/impl/array_operators.hpp
index 6bc926b6..7e9206a0 100644
--- a/math/cmath/include/algebra/math/impl/cmath_operators.hpp
+++ b/plugins/array/include/algebra/impl/array_operators.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins library, part of the ACTS project
  *
- * (c) 2020-2024 CERN for the benefit of the ACTS project
+ * (c) 2020-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -8,13 +8,14 @@
 #pragma once
 
 // Project include(s).
+#include "algebra/concepts.hpp"
 #include "algebra/qualifiers.hpp"
 
 // System include(s).
 #include <cstddef>
 #include <type_traits>
 
-namespace algebra::cmath {
+namespace algebra::array {
 
 /// @name Operators on 2-element arrays
 /// @{
@@ -95,16 +96,16 @@ ALGEBRA_HOST_DEVICE constexpr array_t<scalar_t, 3> operator+(
 /// @name Operators on matrix
 /// @{
 
-template <typename size_type, template <typename, size_type> class array_t,
-          concepts::scalar scalar1_t, concepts::scalar scalar2_t,
-          size_type ROWS, size_type COLS>
+template <typename index_t, template <typename, index_t> class array_t,
+          concepts::scalar scalar1_t, concepts::scalar scalar2_t, index_t ROWS,
+          index_t COLS>
 ALGEBRA_HOST_DEVICE constexpr array_t<array_t<scalar1_t, ROWS>, COLS> operator*(
     const array_t<array_t<scalar1_t, ROWS>, COLS> &a, scalar2_t s) {
 
   array_t<array_t<scalar1_t, ROWS>, COLS> ret;
 
-  for (size_type j = 0; j < COLS; ++j) {
-    for (size_type i = 0; i < ROWS; ++i) {
+  for (index_t j = 0; j < COLS; ++j) {
+    for (index_t i = 0; i < ROWS; ++i) {
       ret[j][i] = a[j][i] * static_cast<scalar1_t>(s);
     }
   }
@@ -112,16 +113,16 @@ ALGEBRA_HOST_DEVICE constexpr array_t<array_t<scalar1_t, ROWS>, COLS> operator*(
   return ret;
 }
 
-template <typename size_type, template <typename, size_type> class array_t,
-          concepts::scalar scalar1_t, concepts::scalar scalar2_t,
-          size_type ROWS, size_type COLS>
+template <typename index_t, template <typename, index_t> class array_t,
+          concepts::scalar scalar1_t, concepts::scalar scalar2_t, index_t ROWS,
+          index_t COLS>
 ALGEBRA_HOST_DEVICE constexpr array_t<array_t<scalar1_t, ROWS>, COLS> operator*(
     scalar2_t s, const array_t<array_t<scalar1_t, ROWS>, COLS> &a) {
 
   array_t<array_t<scalar1_t, ROWS>, COLS> ret;
 
-  for (size_type j = 0; j < COLS; ++j) {
-    for (size_type i = 0; i < ROWS; ++i) {
+  for (index_t j = 0; j < COLS; ++j) {
+    for (index_t i = 0; i < ROWS; ++i) {
       ret[j][i] = a[j][i] * static_cast<scalar1_t>(s);
     }
   }
@@ -129,23 +130,23 @@ ALGEBRA_HOST_DEVICE constexpr array_t<array_t<scalar1_t, ROWS>, COLS> operator*(
   return ret;
 }
 
-template <typename size_type, template <typename, size_type> class array_t,
-          concepts::scalar scalar_t, size_type M, size_type N, size_type O>
+template <typename index_t, template <typename, index_t> class array_t,
+          concepts::scalar scalar_t, index_t M, index_t N, index_t O>
 ALGEBRA_HOST_DEVICE constexpr array_t<array_t<scalar_t, M>, O> operator*(
     const array_t<array_t<scalar_t, M>, N> &A,
     const array_t<array_t<scalar_t, N>, O> &B) {
 
   array_t<array_t<scalar_t, M>, O> C;
 
-  for (size_type j = 0; j < O; ++j) {
-    for (size_type i = 0; i < M; ++i) {
+  for (index_t j = 0; j < O; ++j) {
+    for (index_t i = 0; i < M; ++i) {
       C[j][i] = 0.f;
     }
   }
 
-  for (size_type i = 0; i < N; ++i) {
-    for (size_type j = 0; j < O; ++j) {
-      for (size_type k = 0; k < M; ++k) {
+  for (index_t i = 0; i < N; ++i) {
+    for (index_t j = 0; j < O; ++j) {
+      for (index_t k = 0; k < M; ++k) {
         C[j][k] += A[i][k] * B[j][i];
       }
     }
@@ -154,16 +155,16 @@ ALGEBRA_HOST_DEVICE constexpr array_t<array_t<scalar_t, M>, O> operator*(
   return C;
 }
 
-template <typename size_type, template <typename, size_type> class array_t,
-          concepts::scalar scalar_t, size_type ROWS, size_type COLS>
+template <typename index_t, template <typename, index_t> class array_t,
+          concepts::scalar scalar_t, index_t ROWS, index_t COLS>
 ALGEBRA_HOST_DEVICE constexpr array_t<array_t<scalar_t, ROWS>, COLS> operator+(
     const array_t<array_t<scalar_t, ROWS>, COLS> &A,
     const array_t<array_t<scalar_t, ROWS>, COLS> &B) {
 
   array_t<array_t<scalar_t, ROWS>, COLS> C;
 
-  for (size_type j = 0; j < COLS; ++j) {
-    for (size_type i = 0; i < ROWS; ++i) {
+  for (index_t j = 0; j < COLS; ++j) {
+    for (index_t i = 0; i < ROWS; ++i) {
       C[j][i] = A[j][i] + B[j][i];
     }
   }
@@ -171,16 +172,16 @@ ALGEBRA_HOST_DEVICE constexpr array_t<array_t<scalar_t, ROWS>, COLS> operator+(
   return C;
 }
 
-template <typename size_type, template <typename, size_type> class array_t,
-          concepts::scalar scalar_t, size_type ROWS, size_type COLS>
+template <typename index_t, template <typename, index_t> class array_t,
+          concepts::scalar scalar_t, index_t ROWS, index_t COLS>
 ALGEBRA_HOST_DEVICE constexpr array_t<array_t<scalar_t, ROWS>, COLS> operator-(
     const array_t<array_t<scalar_t, ROWS>, COLS> &A,
     const array_t<array_t<scalar_t, ROWS>, COLS> &B) {
 
   array_t<array_t<scalar_t, ROWS>, COLS> C;
 
-  for (size_type j = 0; j < COLS; ++j) {
-    for (size_type i = 0; i < ROWS; ++i) {
+  for (index_t j = 0; j < COLS; ++j) {
+    for (index_t i = 0; i < ROWS; ++i) {
       C[j][i] = A[j][i] - B[j][i];
     }
   }
@@ -193,16 +194,16 @@ ALGEBRA_HOST_DEVICE constexpr array_t<array_t<scalar_t, ROWS>, COLS> operator-(
 /// @name Operators on matrix * vector
 /// @{
 
-template <typename size_type, template <typename, size_type> class array_t,
-          concepts::scalar scalar_t, size_type ROWS, size_type COLS>
+template <typename index_t, template <typename, index_t> class array_t,
+          concepts::scalar scalar_t, index_t ROWS, index_t COLS>
 ALGEBRA_HOST_DEVICE constexpr array_t<scalar_t, ROWS> operator*(
     const array_t<array_t<scalar_t, ROWS>, COLS> &a,
     const array_t<scalar_t, COLS> &b) {
 
   array_t<scalar_t, ROWS> ret{0};
 
-  for (size_type j = 0; j < COLS; ++j) {
-    for (size_type i = 0; i < ROWS; ++i) {
+  for (index_t j = 0; j < COLS; ++j) {
+    for (index_t i = 0; i < ROWS; ++i) {
       ret[i] += a[j][i] * b[j];
     }
   }
@@ -212,4 +213,4 @@ ALGEBRA_HOST_DEVICE constexpr array_t<scalar_t, ROWS> operator*(
 
 /// @}
 
-}  // namespace algebra::cmath
+}  // namespace algebra::array
diff --git a/storage/array/include/algebra/storage/array.hpp b/plugins/array/include/algebra/impl/array_types.hpp
similarity index 80%
rename from storage/array/include/algebra/storage/array.hpp
rename to plugins/array/include/algebra/impl/array_types.hpp
index 9b2f9d81..74d1f408 100644
--- a/storage/array/include/algebra/storage/array.hpp
+++ b/plugins/array/include/algebra/impl/array_types.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins library, part of the ACTS project
  *
- * (c) 2020-2024 CERN for the benefit of the ACTS project
+ * (c) 2020-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -9,7 +9,7 @@
 
 // Project include(s)
 #include "algebra/concepts.hpp"
-#include "algebra/storage/impl/cmath_getter.hpp"
+#include "algebra/impl/array_getter.hpp"
 #include "algebra/type_traits.hpp"
 
 // System include(s).
@@ -21,7 +21,7 @@ namespace algebra {
 namespace array {
 
 /// size type for Array storage model
-using size_type = std::size_t;
+using index_type = std::size_t;
 /// Value type for Array storage model
 template <concepts::value T>
 using value_type = T;
@@ -29,13 +29,13 @@ using value_type = T;
 template <concepts::value T>
 using scalar_type = T;
 /// Array type used in the Array storage model
-template <typename T, size_type N>
+template <typename T, index_type N>
 using storage_type = std::array<T, N>;
 /// Vector type used in the Array storage model
 template <concepts::scalar T, std::size_t N>
 using vector_type = storage_type<T, N>;
 /// Matrix type used in the Array storage model
-template <concepts::scalar T, size_type ROWS, size_type COLS>
+template <concepts::scalar T, index_type ROWS, index_type COLS>
 using matrix_type = storage_type<storage_type<T, ROWS>, COLS>;
 
 /// 3-element "vector" type, using @c std::array
@@ -52,9 +52,9 @@ template <concepts::scalar T>
 using point2 = vector2<T>;
 
 /// Element Getter
-using element_getter = cmath::storage::element_getter;
+using element_getter = array::storage::element_getter;
 /// Block Getter
-using block_getter = cmath::storage::block_getter;
+using block_getter = array::storage::block_getter;
 
 }  // namespace array
 
diff --git a/math/cmath/include/algebra/math/impl/cmath_vector.hpp b/plugins/array/include/algebra/impl/array_vector.hpp
similarity index 61%
rename from math/cmath/include/algebra/math/impl/cmath_vector.hpp
rename to plugins/array/include/algebra/impl/array_vector.hpp
index 9ccbf579..c31b803f 100644
--- a/math/cmath/include/algebra/math/impl/cmath_vector.hpp
+++ b/plugins/array/include/algebra/impl/array_vector.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins library, part of the ACTS project
  *
- * (c) 2020-2024 CERN for the benefit of the ACTS project
+ * (c) 2020-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -9,18 +9,18 @@
 
 // Project include(s).
 #include "algebra/concepts.hpp"
-#include "algebra/math/common.hpp"
-#include "algebra/math/generic.hpp"
+#include "algebra/generic.hpp"
+#include "algebra/impl/array_operators.hpp"
+#include "algebra/math.hpp"
 #include "algebra/qualifiers.hpp"
 
-namespace algebra::cmath {
+namespace algebra::array {
 
 /// This method retrieves phi from a vector with rows >= 2
 ///
 /// @param v the input vector
-template <concepts::index size_type,
-          template <typename, size_type> class array_t,
-          concepts::scalar scalar_t, size_type N>
+template <concepts::index index_t, template <typename, index_t> class array_t,
+          concepts::scalar scalar_t, index_t N>
   requires(N >= 2)
 ALGEBRA_HOST_DEVICE constexpr scalar_t phi(const array_t<scalar_t, N> &v) {
   return algebra::generic::math::phi(v);
@@ -29,9 +29,8 @@ ALGEBRA_HOST_DEVICE constexpr scalar_t phi(const array_t<scalar_t, N> &v) {
 /// This method retrieves the perpendicular magnitude of a vector with rows >= 2
 ///
 /// @param v the input vector
-template <concepts::index size_type,
-          template <typename, size_type> class array_t,
-          concepts::scalar scalar_t, size_type N>
+template <concepts::index index_t, template <typename, index_t> class array_t,
+          concepts::scalar scalar_t, index_t N>
   requires(N >= 2)
 ALGEBRA_HOST_DEVICE constexpr scalar_t perp(const array_t<scalar_t, N> &v) {
   return algebra::generic::math::perp(v);
@@ -40,9 +39,8 @@ ALGEBRA_HOST_DEVICE constexpr scalar_t perp(const array_t<scalar_t, N> &v) {
 /// This method retrieves theta from a vector with rows >= 3
 ///
 /// @param v the input vector
-template <concepts::index size_type,
-          template <typename, size_type> class array_t,
-          concepts::scalar scalar_t, size_type N>
+template <concepts::index index_t, template <typename, index_t> class array_t,
+          concepts::scalar scalar_t, index_t N>
   requires(N >= 2)
 ALGEBRA_HOST_DEVICE constexpr scalar_t theta(const array_t<scalar_t, N> &v) {
   return algebra::generic::math::theta(v);
@@ -50,7 +48,7 @@ ALGEBRA_HOST_DEVICE constexpr scalar_t theta(const array_t<scalar_t, N> &v) {
 
 /// Cross product between two input vectors - 3 Dim
 ///
-/// @tparam size_type the index type for this plugin
+/// @tparam index_t the index type for this plugin
 /// @tparam array_t the array type the plugin is based on
 /// @tparam scalar_t the scalar type
 /// @tparam N the dimension of the vectors (minimum 3)
@@ -60,36 +58,32 @@ ALGEBRA_HOST_DEVICE constexpr scalar_t theta(const array_t<scalar_t, N> &v) {
 ///
 /// @return a vector representing the cross product
 /// @{
-template <concepts::index size_type,
-          template <typename, size_type> class array_t,
-          concepts::scalar scalar_t, size_type N>
+template <concepts::index index_t, template <typename, index_t> class array_t,
+          concepts::scalar scalar_t, index_t N>
   requires(N >= 3)
 ALGEBRA_HOST_DEVICE constexpr array_t<scalar_t, N> cross(
     const array_t<scalar_t, N> &a, const array_t<scalar_t, N> &b) {
   return algebra::generic::math::cross(a, b);
 }
 
-template <concepts::index size_type,
-          template <typename, size_type> class array_t,
-          concepts::scalar scalar_t, size_type N>
+template <concepts::index index_t, template <typename, index_t> class array_t,
+          concepts::scalar scalar_t, index_t N>
   requires(N >= 3)
 ALGEBRA_HOST_DEVICE constexpr array_t<scalar_t, N> cross(
     const array_t<scalar_t, N> &a, const array_t<array_t<scalar_t, N>, 1> &b) {
   return algebra::generic::math::cross(a, b);
 }
 
-template <concepts::index size_type,
-          template <typename, size_type> class array_t,
-          concepts::scalar scalar_t, size_type N>
+template <concepts::index index_t, template <typename, index_t> class array_t,
+          concepts::scalar scalar_t, index_t N>
   requires(N >= 3)
 ALGEBRA_HOST_DEVICE constexpr array_t<scalar_t, N> cross(
     const array_t<array_t<scalar_t, N>, 1> &a, const array_t<scalar_t, N> &b) {
   return algebra::generic::math::cross(a, b);
 }
 
-template <concepts::index size_type,
-          template <typename, size_type> class array_t,
-          concepts::scalar scalar_t, size_type N>
+template <concepts::index index_t, template <typename, index_t> class array_t,
+          concepts::scalar scalar_t, index_t N>
   requires(N >= 3)
 ALGEBRA_HOST_DEVICE constexpr array_t<scalar_t, N> cross(
     const array_t<array_t<scalar_t, N>, 1> &a,
@@ -105,66 +99,62 @@ ALGEBRA_HOST_DEVICE constexpr array_t<scalar_t, N> cross(
 ///
 /// @return the scalar dot product value
 /// @{
-template <concepts::index size_type,
-          template <typename, size_type> class array_t,
-          concepts::scalar scalar_t, size_type N>
+template <concepts::index index_t, template <typename, index_t> class array_t,
+          concepts::scalar scalar_t, index_t N>
 ALGEBRA_HOST_DEVICE constexpr scalar_t dot(const array_t<scalar_t, N> &a,
                                            const array_t<scalar_t, N> &b) {
   array_t<scalar_t, N> tmp;
-  for (size_type i = 0; i < N; i++) {
+  for (index_t i = 0; i < N; i++) {
     tmp[i] = a[i] * b[i];
   }
   scalar_t ret{0.f};
-  for (size_type i = 0; i < N; i++) {
+  for (index_t i = 0; i < N; i++) {
     ret += tmp[i];
   }
   return ret;
 }
 
-template <concepts::index size_type,
-          template <typename, size_type> class array_t,
-          concepts::scalar scalar_t, size_type N>
+template <concepts::index index_t, template <typename, index_t> class array_t,
+          concepts::scalar scalar_t, index_t N>
 ALGEBRA_HOST_DEVICE constexpr scalar_t dot(
     const array_t<scalar_t, N> &a, const array_t<array_t<scalar_t, N>, 1> &b) {
   array_t<scalar_t, N> tmp;
-  for (size_type i = 0; i < N; i++) {
+  for (index_t i = 0; i < N; i++) {
     tmp[i] = a[i] * b[0][i];
   }
   scalar_t ret{0.f};
-  for (size_type i = 0; i < N; i++) {
+  for (index_t i = 0; i < N; i++) {
     ret += tmp[i];
   }
   return ret;
 }
 
-template <concepts::index size_type,
-          template <typename, size_type> class array_t,
-          concepts::scalar scalar_t, size_type N>
+template <concepts::index index_t, template <typename, index_t> class array_t,
+          concepts::scalar scalar_t, index_t N>
 ALGEBRA_HOST_DEVICE constexpr scalar_t dot(
     const array_t<array_t<scalar_t, N>, 1> &a, const array_t<scalar_t, N> &b) {
   array_t<scalar_t, N> tmp;
-  for (size_type i = 0; i < N; i++) {
+  for (index_t i = 0; i < N; i++) {
     tmp[i] = a[0][i] * b[i];
   }
   scalar_t ret{0.f};
-  for (size_type i = 0; i < N; i++) {
+  for (index_t i = 0; i < N; i++) {
     ret += tmp[i];
   }
   return ret;
 }
 
-template <concepts::index size_type,
-          template <typename, size_type> class array_t,
-          concepts::scalar scalar_t, size_type N>
+template <concepts::index index_t, template <typename, index_t> class array_t,
+          concepts::scalar scalar_t, index_t N>
 ALGEBRA_HOST_DEVICE constexpr scalar_t dot(
     const array_t<array_t<scalar_t, N>, 1> &a,
     const array_t<array_t<scalar_t, N>, 1> &b) {
   array_t<scalar_t, N> tmp;
-  for (size_type i = 0; i < N; i++) {
+  for (index_t i = 0; i < N; i++) {
     tmp[i] = a[0][i] * b[0][i];
   }
   scalar_t ret{0.f};
-  for (size_type i = 0; i < N; i++) {
+  for (index_t i = 0; i < N; i++) {
     ret += tmp[i];
   }
   return ret;
@@ -174,9 +164,8 @@ ALGEBRA_HOST_DEVICE constexpr scalar_t dot(
 /// This method retrieves the norm of a vector, no dimension restriction
 ///
 /// @param v the input vector
-template <concepts::index size_type,
-          template <typename, size_type> class array_t,
-          concepts::scalar scalar_t, size_type N>
+template <concepts::index index_t, template <typename, index_t> class array_t,
+          concepts::scalar scalar_t, index_t N>
   requires(N >= 2)
 ALGEBRA_HOST_DEVICE constexpr scalar_t norm(const array_t<scalar_t, N> &v) {
 
@@ -187,9 +176,8 @@ ALGEBRA_HOST_DEVICE constexpr scalar_t norm(const array_t<scalar_t, N> &v) {
 /// rows >= 3
 ///
 /// @param v the input vector
-template <concepts::index size_type,
-          template <typename, size_type> class array_t,
-          concepts::scalar scalar_t, size_type N>
+template <concepts::index index_t, template <typename, index_t> class array_t,
+          concepts::scalar scalar_t, index_t N>
   requires(N >= 3)
 ALGEBRA_HOST_DEVICE constexpr scalar_t eta(
     const array_t<scalar_t, N> &v) noexcept {
@@ -200,13 +188,12 @@ ALGEBRA_HOST_DEVICE constexpr scalar_t eta(
 /// Get a normalized version of the input vector
 ///
 /// @param v the input vector
-template <concepts::index size_type,
-          template <typename, size_type> class array_t,
-          concepts::scalar scalar_t, size_type N>
+template <concepts::index index_t, template <typename, index_t> class array_t,
+          concepts::scalar scalar_t, index_t N>
 ALGEBRA_HOST_DEVICE constexpr array_t<scalar_t, N> normalize(
     const array_t<scalar_t, N> &v) {
 
   return (static_cast<scalar_t>(1.) / norm(v)) * v;
 }
 
-}  // namespace algebra::cmath
+}  // namespace algebra::array
diff --git a/frontend/eigen/CMakeLists.txt b/plugins/eigen/CMakeLists.txt
similarity index 74%
rename from frontend/eigen/CMakeLists.txt
rename to plugins/eigen/CMakeLists.txt
index 3af35d48..28bf013b 100644
--- a/frontend/eigen/CMakeLists.txt
+++ b/plugins/eigen/CMakeLists.txt
@@ -9,16 +9,13 @@ message(STATUS "Building the Eigen3 algebra plugin")
 # Set up the library.
 algebra_add_library( algebra_eigen eigen
    "include/algebra/eigen.hpp"
+   "include/algebra/impl/*.hpp"
+   "include/algebra/impl/detail/*.hpp"
 )
 
 target_link_libraries(
     algebra_eigen
-    INTERFACE
-        algebra::common
-        algebra::eigen_storage
-        algebra::eigen_math
-        algebra::generic_math
-        Eigen3::Eigen
+    INTERFACE algebra::common algebra::generic Eigen3::Eigen
 )
 
 algebra_test_public_headers( algebra_eigen
diff --git a/frontend/eigen/include/algebra/eigen.hpp b/plugins/eigen/include/algebra/eigen.hpp
similarity index 85%
rename from frontend/eigen/include/algebra/eigen.hpp
rename to plugins/eigen/include/algebra/eigen.hpp
index 9a753492..5de06a0d 100644
--- a/frontend/eigen/include/algebra/eigen.hpp
+++ b/plugins/eigen/include/algebra/eigen.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins library, part of the ACTS project
  *
- * (c) 2020-2024 CERN for the benefit of the ACTS project
+ * (c) 2020-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -8,9 +8,14 @@
 #pragma once
 
 // Project include(s).
-#include "algebra/math/eigen.hpp"
-#include "algebra/math/generic.hpp"
-#include "algebra/storage/eigen.hpp"
+#include "algebra/boolean.hpp"
+#include "algebra/generic.hpp"
+#include "algebra/impl/eigen_getter.hpp"
+#include "algebra/impl/eigen_matrix.hpp"
+#include "algebra/impl/eigen_transform3.hpp"
+#include "algebra/impl/eigen_types.hpp"
+#include "algebra/impl/eigen_vector.hpp"
+#include "algebra/math.hpp"
 
 // Eigen include(s).
 #ifdef _MSC_VER
@@ -100,7 +105,7 @@ struct eigen {
 
   using boolean = bool;
   using scalar = value_type;
-  using size_type = algebra::eigen::size_type;
+  using index_type = algebra::eigen::index_type;
   using transform3D = algebra::eigen::transform3<value_type>;
   using point2D = algebra::eigen::point2<value_type>;
   using point3D = algebra::eigen::point3<value_type>;
diff --git a/storage/eigen/include/algebra/storage/impl/eigen_array.hpp b/plugins/eigen/include/algebra/impl/detail/eigen_array.hpp
similarity index 93%
rename from storage/eigen/include/algebra/storage/impl/eigen_array.hpp
rename to plugins/eigen/include/algebra/impl/detail/eigen_array.hpp
index d86f100d..4db308a9 100644
--- a/storage/eigen/include/algebra/storage/impl/eigen_array.hpp
+++ b/plugins/eigen/include/algebra/impl/detail/eigen_array.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins library, part of the ACTS project
  *
- * (c) 2020-2024 CERN for the benefit of the ACTS project
+ * (c) 2020-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
diff --git a/storage/eigen/include/algebra/storage/impl/eigen_getter.hpp b/plugins/eigen/include/algebra/impl/eigen_getter.hpp
similarity index 78%
rename from storage/eigen/include/algebra/storage/impl/eigen_getter.hpp
rename to plugins/eigen/include/algebra/impl/eigen_getter.hpp
index 7a5b841c..5fe1c3c5 100644
--- a/storage/eigen/include/algebra/storage/impl/eigen_getter.hpp
+++ b/plugins/eigen/include/algebra/impl/eigen_getter.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins, part of the ACTS project
  *
- * (c) 2020-2024 CERN for the benefit of the ACTS project
+ * (c) 2020-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -9,7 +9,7 @@
 
 // Project include(s).
 #include "algebra/concepts.hpp"
-#include "algebra/math/common.hpp"
+#include "algebra/math.hpp"
 #include "algebra/qualifiers.hpp"
 
 // Eigen include(s).
@@ -36,40 +36,39 @@ namespace algebra::eigen::storage {
 /// Functor used to access elements of Eigen matrices
 struct element_getter {
   /// Get non-const access to a matrix element
-  template <typename derived_type, concepts::index size_type_1,
-            concepts::index size_type_2>
+  template <typename derived_type, concepts::index index_t_1,
+            concepts::index index_t_2>
     requires std::is_base_of_v<
         Eigen::DenseCoeffsBase<derived_type, Eigen::WriteAccessors>,
         Eigen::MatrixBase<derived_type> >
   ALGEBRA_HOST_DEVICE constexpr auto &operator()(
-      Eigen::MatrixBase<derived_type> &m, size_type_1 row,
-      size_type_2 col) const {
+      Eigen::MatrixBase<derived_type> &m, index_t_1 row, index_t_2 col) const {
 
     return m(static_cast<Eigen::Index>(row), static_cast<Eigen::Index>(col));
   }
   /// Get const access to a matrix element
-  template <typename derived_type, concepts::index size_type_1,
-            concepts::index size_type_2>
+  template <typename derived_type, concepts::index index_t_1,
+            concepts::index index_t_2>
   ALGEBRA_HOST_DEVICE constexpr auto operator()(
-      const Eigen::MatrixBase<derived_type> &m, size_type_1 row,
-      size_type_2 col) const {
+      const Eigen::MatrixBase<derived_type> &m, index_t_1 row,
+      index_t_2 col) const {
 
     return m(static_cast<Eigen::Index>(row), static_cast<Eigen::Index>(col));
   }
   /// Get non-const access to a matrix element
-  template <typename derived_type, concepts::index size_type>
+  template <typename derived_type, concepts::index index_t>
     requires std::is_base_of_v<
         Eigen::DenseCoeffsBase<derived_type, Eigen::WriteAccessors>,
         Eigen::MatrixBase<derived_type> >
   ALGEBRA_HOST_DEVICE constexpr auto &operator()(
-      Eigen::MatrixBase<derived_type> &m, size_type row) const {
+      Eigen::MatrixBase<derived_type> &m, index_t row) const {
 
     return m(static_cast<Eigen::Index>(row));
   }
   /// Get const access to a matrix element
-  template <typename derived_type, concepts::index size_type>
+  template <typename derived_type, concepts::index index_t>
   ALGEBRA_HOST_DEVICE constexpr auto operator()(
-      const Eigen::MatrixBase<derived_type> &m, size_type row) const {
+      const Eigen::MatrixBase<derived_type> &m, index_t row) const {
 
     return m(static_cast<Eigen::Index>(row));
   }
@@ -120,37 +119,36 @@ ALGEBRA_HOST_DEVICE constexpr decltype(auto) element(
 struct block_getter {
 
   template <int kROWS, int kCOLS, typename derived_type,
-            concepts::index size_type_1, concepts::index size_type_2>
+            concepts::index index_t_1, concepts::index index_t_2>
   ALGEBRA_HOST_DEVICE decltype(auto) operator()(
-      const Eigen::MatrixBase<derived_type> &m, size_type_1 row,
-      size_type_2 col) const {
+      const Eigen::MatrixBase<derived_type> &m, index_t_1 row,
+      index_t_2 col) const {
 
     return m.template block<kROWS, kCOLS>(row, col);
   }
 
   template <int kROWS, int kCOLS, typename derived_type,
-            concepts::index size_type_1, concepts::index size_type_2>
+            concepts::index index_t_1, concepts::index index_t_2>
   ALGEBRA_HOST_DEVICE decltype(auto) operator()(
-      Eigen::MatrixBase<derived_type> &m, size_type_1 row,
-      size_type_2 col) const {
+      Eigen::MatrixBase<derived_type> &m, index_t_1 row, index_t_2 col) const {
 
     return m.template block<kROWS, kCOLS>(row, col);
   }
 
-  template <int SIZE, typename derived_type, concepts::index size_type_1,
-            concepts::index size_type_2>
+  template <int SIZE, typename derived_type, concepts::index index_t_1,
+            concepts::index index_t_2>
   ALGEBRA_HOST_DEVICE decltype(auto) vector(Eigen::MatrixBase<derived_type> &m,
-                                            size_type_1 row,
-                                            size_type_2 col) const {
+                                            index_t_1 row,
+                                            index_t_2 col) const {
 
     return m.template block<SIZE, 1>(row, col);
   }
 
-  template <int SIZE, typename derived_type, concepts::index size_type_1,
-            concepts::index size_type_2>
+  template <int SIZE, typename derived_type, concepts::index index_t_1,
+            concepts::index index_t_2>
   ALGEBRA_HOST_DEVICE decltype(auto) vector(
-      const Eigen::MatrixBase<derived_type> &m, size_type_1 row,
-      size_type_2 col) const {
+      const Eigen::MatrixBase<derived_type> &m, index_t_1 row,
+      index_t_2 col) const {
 
     return m.template block<SIZE, 1>(row, col);
   }
diff --git a/math/eigen/include/algebra/math/impl/eigen_matrix.hpp b/plugins/eigen/include/algebra/impl/eigen_matrix.hpp
similarity index 94%
rename from math/eigen/include/algebra/math/impl/eigen_matrix.hpp
rename to plugins/eigen/include/algebra/impl/eigen_matrix.hpp
index bd22e2f0..c8347d95 100644
--- a/math/eigen/include/algebra/math/impl/eigen_matrix.hpp
+++ b/plugins/eigen/include/algebra/impl/eigen_matrix.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins library, part of the ACTS project
  *
- * (c) 2022-2024 CERN for the benefit of the ACTS project
+ * (c) 2022-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -8,8 +8,9 @@
 #pragma once
 
 // Project include(s).
+#include "algebra/concepts.hpp"
+#include "algebra/impl/eigen_types.hpp"
 #include "algebra/qualifiers.hpp"
-#include "algebra/storage/eigen.hpp"
 
 // Eigen include(s).
 #ifdef _MSC_VER
diff --git a/math/eigen/include/algebra/math/impl/eigen_transform3.hpp b/plugins/eigen/include/algebra/impl/eigen_transform3.hpp
similarity index 98%
rename from math/eigen/include/algebra/math/impl/eigen_transform3.hpp
rename to plugins/eigen/include/algebra/impl/eigen_transform3.hpp
index 64f5f00c..a6314e56 100644
--- a/math/eigen/include/algebra/math/impl/eigen_transform3.hpp
+++ b/plugins/eigen/include/algebra/impl/eigen_transform3.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins library, part of the ACTS project
  *
- * (c) 2020-2024 CERN for the benefit of the ACTS project
+ * (c) 2020-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -8,8 +8,8 @@
 #pragma once
 
 // Project include(s).
+#include "algebra/impl/detail/eigen_array.hpp"
 #include "algebra/qualifiers.hpp"
-#include "algebra/storage/impl/eigen_array.hpp"
 #include "algebra/utils/approximately_equal.hpp"
 
 // Eigen include(s).
diff --git a/storage/eigen/include/algebra/storage/eigen.hpp b/plugins/eigen/include/algebra/impl/eigen_types.hpp
similarity index 86%
rename from storage/eigen/include/algebra/storage/eigen.hpp
rename to plugins/eigen/include/algebra/impl/eigen_types.hpp
index 707d95e2..74e27cc5 100644
--- a/storage/eigen/include/algebra/storage/eigen.hpp
+++ b/plugins/eigen/include/algebra/impl/eigen_types.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins library, part of the ACTS project
  *
- * (c) 2020-2024 CERN for the benefit of the ACTS project
+ * (c) 2020-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -9,8 +9,8 @@
 
 // Project include(s).
 #include "algebra/concepts.hpp"
-#include "algebra/storage/impl/eigen_array.hpp"
-#include "algebra/storage/impl/eigen_getter.hpp"
+#include "algebra/impl/detail/eigen_array.hpp"
+#include "algebra/impl/eigen_getter.hpp"
 #include "algebra/type_traits.hpp"
 
 // System include(s).
@@ -21,7 +21,7 @@ namespace algebra {
 namespace eigen {
 
 /// size type for Eigen storage model
-using size_type = int;
+using index_type = int;
 /// Value type for Eigen storage model
 template <concepts::value T>
 using value_type = T;
@@ -29,14 +29,14 @@ using value_type = T;
 template <concepts::value T>
 using scalar_type = T;
 /// Array type used in the Eigen storage model
-template <concepts::scalar T, size_type N>
+template <concepts::scalar T, index_type N>
 using storage_type = array<T, N>;
 /// Vector type used in the Eigen storage model
-template <concepts::scalar T, size_type N>
+template <concepts::scalar T, index_type N>
 using vector_type = storage_type<T, N>;
 /// Matrix type used in the Eigen storage model
 /// If the number of rows is 1, make it RowMajor
-template <concepts::scalar T, size_type ROWS, size_type COLS>
+template <concepts::scalar T, index_type ROWS, index_type COLS>
 using matrix_type = Eigen::Matrix<T, ROWS, COLS, (ROWS == 1), ROWS, COLS>;
 
 /// 3-element "vector" type, using @c eigen::vector_type
@@ -68,13 +68,13 @@ namespace traits {
 /// @{
 template <typename derived_t>
 struct index<Eigen::MatrixBase<derived_t>> {
-  using type = algebra::eigen::size_type;
+  using type = algebra::eigen::index_type;
 };
 
 template <typename T, int ROWS, int COLS, int OPT, int bROWS, int bCOLS>
 struct index<Eigen::Block<Eigen::Matrix<T, ROWS, COLS, OPT, ROWS, COLS>, bROWS,
                           bCOLS, false>> {
-  using type = algebra::eigen::size_type;
+  using type = algebra::eigen::index_type;
 };
 /// @}
 
@@ -83,12 +83,12 @@ struct index<Eigen::Block<Eigen::Matrix<T, ROWS, COLS, OPT, ROWS, COLS>, bROWS,
 template <typename derived_t>
 struct dimensions<Eigen::MatrixBase<derived_t>> {
 
-  using size_type = index_t<Eigen::MatrixBase<derived_t>>;
+  using index_type = index_t<Eigen::MatrixBase<derived_t>>;
 
-  static constexpr size_type dim{2};
-  static constexpr size_type rows{
+  static constexpr index_type _dim{2};
+  static constexpr index_type _rows{
       Eigen::MatrixBase<derived_t>::RowsAtCompileTime};
-  static constexpr size_type columns{
+  static constexpr index_type _columns{
       Eigen::MatrixBase<derived_t>::ColsAtCompileTime};
 };
 
@@ -96,13 +96,13 @@ template <typename T, int ROWS, int COLS, int OPT, int bROWS, int bCOLS>
 struct dimensions<Eigen::Block<Eigen::Matrix<T, ROWS, COLS, OPT, ROWS, COLS>,
                                bROWS, bCOLS, false>> {
 
-  using size_type =
+  using index_type =
       index_t<Eigen::Block<Eigen::Matrix<T, ROWS, COLS, OPT, ROWS, COLS>, bROWS,
                            bCOLS, false>>;
 
-  static constexpr size_type dim{2};
-  static constexpr size_type rows{bROWS};
-  static constexpr size_type columns{bCOLS};
+  static constexpr index_type _dim{2};
+  static constexpr index_type _rows{bROWS};
+  static constexpr index_type _columns{bCOLS};
 };
 /// @}
 
diff --git a/math/eigen/include/algebra/math/impl/eigen_vector.hpp b/plugins/eigen/include/algebra/impl/eigen_vector.hpp
similarity index 98%
rename from math/eigen/include/algebra/math/impl/eigen_vector.hpp
rename to plugins/eigen/include/algebra/impl/eigen_vector.hpp
index 928fda0c..297f94ec 100644
--- a/math/eigen/include/algebra/math/impl/eigen_vector.hpp
+++ b/plugins/eigen/include/algebra/impl/eigen_vector.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins library, part of the ACTS project
  *
- * (c) 2020-2024 CERN for the benefit of the ACTS project
+ * (c) 2020-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
diff --git a/frontend/fastor/CMakeLists.txt b/plugins/fastor/CMakeLists.txt
similarity index 76%
rename from frontend/fastor/CMakeLists.txt
rename to plugins/fastor/CMakeLists.txt
index a7226796..1ef00ca7 100644
--- a/frontend/fastor/CMakeLists.txt
+++ b/plugins/fastor/CMakeLists.txt
@@ -9,15 +9,13 @@ message(STATUS "Building the Fastor algebra plugin")
 # Set up the library.
 algebra_add_library( algebra_fastor fastor
    "include/algebra/fastor.hpp"
+   "include/algebra/impl/*.hpp"
+   "include/algebra/impl/detail/*.hpp"
 )
 
 target_link_libraries(
     algebra_fastor
-    INTERFACE
-        algebra::common
-        algebra::fastor_storage
-        algebra::fastor_math
-        algebra::generic_math
+    INTERFACE Fastor::Fastor algebra::common algebra::generic
 )
 
 algebra_test_public_headers( algebra_fastor
diff --git a/frontend/fastor/include/algebra/fastor.hpp b/plugins/fastor/include/algebra/fastor.hpp
similarity index 87%
rename from frontend/fastor/include/algebra/fastor.hpp
rename to plugins/fastor/include/algebra/fastor.hpp
index e2ec281e..6a5a6940 100644
--- a/frontend/fastor/include/algebra/fastor.hpp
+++ b/plugins/fastor/include/algebra/fastor.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins library, part of the ACTS project
  *
- * (c) 2022-2024 CERN for the benefit of the ACTS project
+ * (c) 2022-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -8,9 +8,13 @@
 #pragma once
 
 // Project include(s).
-#include "algebra/math/fastor.hpp"
-#include "algebra/math/generic.hpp"
-#include "algebra/storage/fastor.hpp"
+#include "algebra/boolean.hpp"
+#include "algebra/generic.hpp"
+#include "algebra/impl/fastor_getter.hpp"
+#include "algebra/impl/fastor_matrix.hpp"
+#include "algebra/impl/fastor_transform3.hpp"
+#include "algebra/impl/fastor_types.hpp"
+#include "algebra/impl/fastor_vector.hpp"
 
 // Fastor include(s).
 #ifdef _MSC_VER
@@ -107,7 +111,7 @@ struct fastor {
 
   using boolean = bool;
   using scalar = value_type;
-  using size_type = algebra::fastor::size_type;
+  using index_type = algebra::fastor::index_type;
   using transform3D = algebra::fastor::transform3<value_type>;
   using point2D = algebra::fastor::point2<value_type>;
   using point3D = algebra::fastor::point3<value_type>;
diff --git a/storage/fastor/include/algebra/storage/impl/fastor_matrix.hpp b/plugins/fastor/include/algebra/impl/detail/fastor_matrix_wrapper.hpp
similarity index 61%
rename from storage/fastor/include/algebra/storage/impl/fastor_matrix.hpp
rename to plugins/fastor/include/algebra/impl/detail/fastor_matrix_wrapper.hpp
index 4b84409b..1b0ef273 100644
--- a/storage/fastor/include/algebra/storage/impl/fastor_matrix.hpp
+++ b/plugins/fastor/include/algebra/impl/detail/fastor_matrix_wrapper.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins library, part of the ACTS project
  *
- * (c) 2023-2024 CERN for the benefit of the ACTS project
+ * (c) 2023-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -24,7 +24,7 @@
 
 namespace algebra::fastor {
 
-/// Fastor Matrix type
+/// @brief Fastor Matrix type
 ///
 /// This class is needed because Fastor differentiates between normal
 /// matrix-matrix multiplication and element-wise matrix-matrix multiplication.
@@ -46,6 +46,7 @@ class Matrix : public Fastor::Tensor<T, M1, N> {
   /// Inherit all constructors from the base class
   using Fastor::Tensor<T, M1, N>::Tensor;
 
+ private:
   /// When we encounter an `operator*` function call between Matrix objects, we
   /// will catch it and handle it correctly by invoking `Fastor::matmul()`.
   ///
@@ -56,30 +57,30 @@ class Matrix : public Fastor::Tensor<T, M1, N> {
   ///
   /// The `static_cast` is there to signal both to the compiler and the reader
   /// that we wish to interpret the `Matrix` object as a `Fastor::Tensor` here.
-  template <concepts::scalar U, std::size_t M2>
-  constexpr Matrix<T, M1, M2> operator*(const Matrix<U, N, M2>& other) const {
-    return Fastor::matmul(static_cast<Fastor::Tensor<T, M1, N>>(*this),
-                          static_cast<Fastor::Tensor<T, N, M2>>(other));
-  }
+  /// @{
+  template <std::size_t LR, std::size_t C, std::size_t RC, concepts::scalar S>
+  constexpr friend Matrix<S, LR, RC> operator*(const Matrix<S, LR, C>& lhs,
+                                               const Matrix<S, C, RC>& rhs);
 
-  /// When we encounter an `operator*` function call between a Matrix object and
-  /// a `Fastor::Tensor` with one dimensional parameter (i.e. a vector), we will
-  /// catch it and handle it correctly by invoking `Fastor::matmul()`.
-  ///
-  /// The data type contained in the `other` has a separate template parameter
-  /// dedicated to it because in certain cases, we might want to multiply say, a
-  /// float matrix with a double vector and not have it produce a compilation
-  /// error.
-  ///
-  /// The `static_cast` is there to signal both to the compiler and the reader
-  /// that we wish to interpret the `Matrix` object as a `Fastor::Tensor` here.
-  template <concepts::scalar U>
-  constexpr Fastor::Tensor<T, M1> operator*(
-      const Fastor::Tensor<U, N>& other) const {
-    return Fastor::matmul(static_cast<Fastor::Tensor<T, M1, N>>(*this),
-                          static_cast<Fastor::Tensor<T, N>>(other));
-  }
+  template <std::size_t R, std::size_t C, concepts::scalar S>
+  constexpr friend Fastor::Tensor<S, R> operator*(
+      const Matrix<S, R, C>& lhs, const Fastor::Tensor<S, C>& vector);
+  /// @}
 
 };  // class Matrix
 
+template <std::size_t LR, std::size_t C, std::size_t RC, concepts::scalar S>
+constexpr Matrix<S, LR, RC> operator*(const Matrix<S, LR, C>& lhs,
+                                      const Matrix<S, C, RC>& rhs) {
+  return Fastor::matmul(static_cast<Fastor::Tensor<S, LR, C>>(lhs),
+                        static_cast<Fastor::Tensor<S, C, RC>>(rhs));
+}
+
+template <std::size_t R, std::size_t C, concepts::scalar S>
+constexpr Fastor::Tensor<S, R> operator*(const Matrix<S, R, C>& lhs,
+                                         const Fastor::Tensor<S, C>& vector) {
+  return Fastor::matmul(static_cast<Fastor::Tensor<S, R, C>>(lhs),
+                        static_cast<Fastor::Tensor<S, C>>(vector));
+}
+
 }  // namespace algebra::fastor
diff --git a/storage/fastor/include/algebra/storage/impl/fastor_getter.hpp b/plugins/fastor/include/algebra/impl/fastor_getter.hpp
similarity index 97%
rename from storage/fastor/include/algebra/storage/impl/fastor_getter.hpp
rename to plugins/fastor/include/algebra/impl/fastor_getter.hpp
index 250273d3..e7f99a6f 100644
--- a/storage/fastor/include/algebra/storage/impl/fastor_getter.hpp
+++ b/plugins/fastor/include/algebra/impl/fastor_getter.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins, part of the ACTS project
  *
- * (c) 2022-2024 CERN for the benefit of the ACTS project
+ * (c) 2022-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -9,9 +9,9 @@
 
 // Project include(s).
 #include "algebra/concepts.hpp"
-#include "algebra/math/common.hpp"
+#include "algebra/impl/detail/fastor_matrix_wrapper.hpp"
+#include "algebra/math.hpp"
 #include "algebra/qualifiers.hpp"
-#include "algebra/storage/impl/fastor_matrix.hpp"
 
 // Fastor include(s).
 #ifdef _MSC_VER
diff --git a/math/fastor/include/algebra/math/impl/fastor_matrix.hpp b/plugins/fastor/include/algebra/impl/fastor_matrix.hpp
similarity index 96%
rename from math/fastor/include/algebra/math/impl/fastor_matrix.hpp
rename to plugins/fastor/include/algebra/impl/fastor_matrix.hpp
index 0e165192..ada27726 100644
--- a/math/fastor/include/algebra/math/impl/fastor_matrix.hpp
+++ b/plugins/fastor/include/algebra/impl/fastor_matrix.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins, part of the ACTS project
  *
- * (c) 2022-2024 CERN for the benefit of the ACTS project
+ * (c) 2022-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -8,8 +8,8 @@
 #pragma once
 
 // Project include(s).
+#include "algebra/impl/fastor_types.hpp"
 #include "algebra/qualifiers.hpp"
-#include "algebra/storage/fastor.hpp"
 
 // Fastor include(s).
 #ifdef _MSC_VER
diff --git a/math/fastor/include/algebra/math/impl/fastor_transform3.hpp b/plugins/fastor/include/algebra/impl/fastor_transform3.hpp
similarity index 98%
rename from math/fastor/include/algebra/math/impl/fastor_transform3.hpp
rename to plugins/fastor/include/algebra/impl/fastor_transform3.hpp
index e6c321c0..28c9b407 100644
--- a/math/fastor/include/algebra/math/impl/fastor_transform3.hpp
+++ b/plugins/fastor/include/algebra/impl/fastor_transform3.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins, part of the ACTS project
  *
- * (c) 2022-2024 CERN for the benefit of the ACTS project
+ * (c) 2022-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -8,7 +8,7 @@
 #pragma once
 
 // Project include(s).
-#include "algebra/math/impl/fastor_matrix.hpp"
+#include "algebra/impl/fastor_matrix.hpp"
 #include "algebra/qualifiers.hpp"
 #include "algebra/utils/approximately_equal.hpp"
 
diff --git a/storage/fastor/include/algebra/storage/fastor.hpp b/plugins/fastor/include/algebra/impl/fastor_types.hpp
similarity index 81%
rename from storage/fastor/include/algebra/storage/fastor.hpp
rename to plugins/fastor/include/algebra/impl/fastor_types.hpp
index 7cce3b8d..b5856d9d 100644
--- a/storage/fastor/include/algebra/storage/fastor.hpp
+++ b/plugins/fastor/include/algebra/impl/fastor_types.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins library, part of the ACTS project
  *
- * (c) 2022-2024 CERN for the benefit of the ACTS project
+ * (c) 2022-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -9,8 +9,8 @@
 
 // Project include(s).
 #include "algebra/concepts.hpp"
-#include "algebra/storage/impl/fastor_getter.hpp"
-#include "algebra/storage/impl/fastor_matrix.hpp"
+#include "algebra/impl/detail/fastor_matrix_wrapper.hpp"
+#include "algebra/impl/fastor_getter.hpp"
 #include "algebra/type_traits.hpp"
 
 // System include(s).
@@ -21,7 +21,7 @@ namespace algebra {
 namespace fastor {
 
 /// size type for Fastor storage model
-using size_type = std::size_t;
+using index_type = std::size_t;
 /// Value type for Fastor storage model
 template <concepts::value T>
 using value_type = T;
@@ -29,13 +29,13 @@ using value_type = T;
 template <concepts::value T>
 using scalar_type = T;
 /// Array type used in the Fastor storage model
-template <concepts::scalar T, size_type N>
+template <concepts::scalar T, index_type N>
 using storage_type = Fastor::Tensor<T, N>;
 /// Vector type used in the Fastor storage model
-template <concepts::scalar T, size_type N>
+template <concepts::scalar T, index_type N>
 using vector_type = storage_type<T, N>;
 /// Matrix type used in the Fastor storage model
-template <concepts::scalar T, size_type ROWS, size_type COLS>
+template <concepts::scalar T, index_type ROWS, index_type COLS>
 using matrix_type = algebra::fastor::Matrix<T, ROWS, COLS>;
 
 /// 3-element "vector" type, using @c Fastor::Tensor
diff --git a/math/fastor/include/algebra/math/impl/fastor_vector.hpp b/plugins/fastor/include/algebra/impl/fastor_vector.hpp
similarity index 99%
rename from math/fastor/include/algebra/math/impl/fastor_vector.hpp
rename to plugins/fastor/include/algebra/impl/fastor_vector.hpp
index 7cc68cec..a7a7a8bc 100644
--- a/math/fastor/include/algebra/math/impl/fastor_vector.hpp
+++ b/plugins/fastor/include/algebra/impl/fastor_vector.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins, part of the ACTS project
  *
- * (c) 2022-2024 CERN for the benefit of the ACTS project
+ * (c) 2022-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
diff --git a/frontend/smatrix/CMakeLists.txt b/plugins/smatrix/CMakeLists.txt
similarity index 68%
rename from frontend/smatrix/CMakeLists.txt
rename to plugins/smatrix/CMakeLists.txt
index ef334f3e..65efa240 100644
--- a/frontend/smatrix/CMakeLists.txt
+++ b/plugins/smatrix/CMakeLists.txt
@@ -6,18 +6,23 @@
 
 message(STATUS "Building the SMatrix algebra plugin")
 
+find_package(ROOT COMPONENTS Core MathCore Smatrix REQUIRED)
+
 # Set up the library.
 algebra_add_library( algebra_smatrix smatrix
    "include/algebra/smatrix.hpp"
+   "include/algebra/impl/*.hpp"
+   "include/algebra/impl/detail/*.hpp"
 )
 
 target_link_libraries(
     algebra_smatrix
     INTERFACE
+        ROOT::Core
+        ROOT::MathCore
+        ROOT::Smatrix
         algebra::common
-        algebra::smatrix_storage
-        algebra::smatrix_math
-        algebra::generic_math
+        algebra::generic
 )
 
 algebra_test_public_headers( algebra_smatrix
diff --git a/math/smatrix/include/algebra/math/impl/smatrix_errorcheck.hpp b/plugins/smatrix/include/algebra/impl/detail/smatrix_errorcheck.hpp
similarity index 93%
rename from math/smatrix/include/algebra/math/impl/smatrix_errorcheck.hpp
rename to plugins/smatrix/include/algebra/impl/detail/smatrix_errorcheck.hpp
index 4cf7042d..d2f65921 100644
--- a/math/smatrix/include/algebra/math/impl/smatrix_errorcheck.hpp
+++ b/plugins/smatrix/include/algebra/impl/detail/smatrix_errorcheck.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins library, part of the ACTS project
  *
- * (c) 2020-2022 CERN for the benefit of the ACTS project
+ * (c) 2020-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
diff --git a/storage/smatrix/include/algebra/storage/impl/smatrix_getter.hpp b/plugins/smatrix/include/algebra/impl/smatrix_getter.hpp
similarity index 99%
rename from storage/smatrix/include/algebra/storage/impl/smatrix_getter.hpp
rename to plugins/smatrix/include/algebra/impl/smatrix_getter.hpp
index 1dac384c..22f9cebb 100644
--- a/storage/smatrix/include/algebra/storage/impl/smatrix_getter.hpp
+++ b/plugins/smatrix/include/algebra/impl/smatrix_getter.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins library, part of the ACTS project
  *
- * (c) 2020-2024 CERN for the benefit of the ACTS project
+ * (c) 2020-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
diff --git a/math/smatrix/include/algebra/math/impl/smatrix_matrix.hpp b/plugins/smatrix/include/algebra/impl/smatrix_matrix.hpp
similarity index 95%
rename from math/smatrix/include/algebra/math/impl/smatrix_matrix.hpp
rename to plugins/smatrix/include/algebra/impl/smatrix_matrix.hpp
index ded7eba4..e3565f34 100644
--- a/math/smatrix/include/algebra/math/impl/smatrix_matrix.hpp
+++ b/plugins/smatrix/include/algebra/impl/smatrix_matrix.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins library, part of the ACTS project
  *
- * (c) 2020-2024 CERN for the benefit of the ACTS project
+ * (c) 2020-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -9,8 +9,8 @@
 
 // Project include(s).
 #include "algebra/concepts.hpp"
+#include "algebra/impl/smatrix_types.hpp"
 #include "algebra/qualifiers.hpp"
-#include "algebra/storage/smatrix.hpp"
 
 // ROOT/Smatrix include(s).
 #include <Math/SMatrix.h>
diff --git a/math/smatrix/include/algebra/math/impl/smatrix_transform3.hpp b/plugins/smatrix/include/algebra/impl/smatrix_transform3.hpp
similarity index 98%
rename from math/smatrix/include/algebra/math/impl/smatrix_transform3.hpp
rename to plugins/smatrix/include/algebra/impl/smatrix_transform3.hpp
index 13d36130..65a77405 100644
--- a/math/smatrix/include/algebra/math/impl/smatrix_transform3.hpp
+++ b/plugins/smatrix/include/algebra/impl/smatrix_transform3.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins library, part of the ACTS project
  *
- * (c) 2020-2024 CERN for the benefit of the ACTS project
+ * (c) 2020-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -8,7 +8,7 @@
 #pragma once
 
 // Project include(s).
-#include "algebra/math/impl/smatrix_errorcheck.hpp"
+#include "algebra/impl/detail/smatrix_errorcheck.hpp"
 #include "algebra/qualifiers.hpp"
 #include "algebra/utils/approximately_equal.hpp"
 
diff --git a/storage/smatrix/include/algebra/storage/smatrix.hpp b/plugins/smatrix/include/algebra/impl/smatrix_types.hpp
similarity index 84%
rename from storage/smatrix/include/algebra/storage/smatrix.hpp
rename to plugins/smatrix/include/algebra/impl/smatrix_types.hpp
index 26703ee4..d0f245b7 100644
--- a/storage/smatrix/include/algebra/storage/smatrix.hpp
+++ b/plugins/smatrix/include/algebra/impl/smatrix_types.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins library, part of the ACTS project
  *
- * (c) 2020-2024 CERN for the benefit of the ACTS project
+ * (c) 2020-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -9,7 +9,7 @@
 
 // Project include(s)
 #include "algebra/concepts.hpp"
-#include "algebra/storage/impl/smatrix_getter.hpp"
+#include "algebra/impl/smatrix_getter.hpp"
 #include "algebra/type_traits.hpp"
 
 // ROOT/Smatrix include(s).
@@ -24,7 +24,7 @@ namespace algebra {
 namespace smatrix {
 
 /// size type for SMatrix storage model
-using size_type = unsigned int;
+using index_type = unsigned int;
 /// Value type for SMatrix storage model
 template <concepts::value T>
 using value_type = T;
@@ -32,13 +32,13 @@ using value_type = T;
 template <concepts::value T>
 using scalar_type = T;
 /// Array type used in the SMatrix storage model
-template <concepts::scalar T, size_type N>
+template <concepts::scalar T, index_type N>
 using storage_type = ROOT::Math::SVector<T, N>;
 /// Vector type used in the SMatrix storage model
-template <concepts::scalar T, size_type N>
+template <concepts::scalar T, index_type N>
 using vector_type = storage_type<T, N>;
 /// Matrix type used in the SMatrix storage model
-template <concepts::scalar T, size_type ROWS, size_type COLS>
+template <concepts::scalar T, index_type ROWS, index_type COLS>
 using matrix_type = ROOT::Math::SMatrix<T, ROWS, COLS>;
 
 /// 3-element "vector" type, using @c ROOT::Math::SVector
diff --git a/math/smatrix/include/algebra/math/impl/smatrix_vector.hpp b/plugins/smatrix/include/algebra/impl/smatrix_vector.hpp
similarity index 99%
rename from math/smatrix/include/algebra/math/impl/smatrix_vector.hpp
rename to plugins/smatrix/include/algebra/impl/smatrix_vector.hpp
index be5fbfe8..14aa9d44 100644
--- a/math/smatrix/include/algebra/math/impl/smatrix_vector.hpp
+++ b/plugins/smatrix/include/algebra/impl/smatrix_vector.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins library, part of the ACTS project
  *
- * (c) 2020-2024 CERN for the benefit of the ACTS project
+ * (c) 2020-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
diff --git a/frontend/smatrix/include/algebra/smatrix.hpp b/plugins/smatrix/include/algebra/smatrix.hpp
similarity index 86%
rename from frontend/smatrix/include/algebra/smatrix.hpp
rename to plugins/smatrix/include/algebra/smatrix.hpp
index 9c1794d7..d5fd1c2e 100644
--- a/frontend/smatrix/include/algebra/smatrix.hpp
+++ b/plugins/smatrix/include/algebra/smatrix.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins library, part of the ACTS project
  *
- * (c) 2020-2024 CERN for the benefit of the ACTS project
+ * (c) 2020-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -8,9 +8,13 @@
 #pragma once
 
 // Project include(s).
-#include "algebra/math/generic.hpp"
-#include "algebra/math/smatrix.hpp"
-#include "algebra/storage/smatrix.hpp"
+#include "algebra/boolean.hpp"
+#include "algebra/generic.hpp"
+#include "algebra/impl/smatrix_getter.hpp"
+#include "algebra/impl/smatrix_matrix.hpp"
+#include "algebra/impl/smatrix_transform3.hpp"
+#include "algebra/impl/smatrix_types.hpp"
+#include "algebra/impl/smatrix_vector.hpp"
 
 namespace algebra {
 
@@ -98,7 +102,7 @@ struct smatrix {
 
   using boolean = bool;
   using scalar = value_type;
-  using size_type = algebra::smatrix::size_type;
+  using index_type = algebra::smatrix::index_type;
   using transform3D = algebra::smatrix::transform3<value_type>;
   using point2D = algebra::smatrix::point2<value_type>;
   using point3D = algebra::smatrix::point3<value_type>;
diff --git a/frontend/vc_aos/CMakeLists.txt b/plugins/vc_aos/CMakeLists.txt
similarity index 76%
rename from frontend/vc_aos/CMakeLists.txt
rename to plugins/vc_aos/CMakeLists.txt
index b13732db..07656352 100644
--- a/frontend/vc_aos/CMakeLists.txt
+++ b/plugins/vc_aos/CMakeLists.txt
@@ -9,15 +9,12 @@ message(STATUS "Building the Vc AoS algebra plugin")
 # Set up the library.
 algebra_add_library( algebra_vc_aos vc_aos
    "include/algebra/vc_aos.hpp"
+   "include/algebra/impl/*.hpp"
 )
 
 target_link_libraries(
     algebra_vc_aos
-    INTERFACE
-        algebra::common
-        algebra::vc_aos_storage
-        algebra::vc_aos_math
-        algebra::generic_math
+    INTERFACE Vc::Vc algebra::common algebra::utils algebra::generic
 )
 
 algebra_test_public_headers( algebra_vc_aos
diff --git a/storage/vc_aos/include/algebra/storage/impl/vc_aos_approximately_equal.hpp b/plugins/vc_aos/include/algebra/impl/vc_aos_approximately_equal.hpp
similarity index 97%
rename from storage/vc_aos/include/algebra/storage/impl/vc_aos_approximately_equal.hpp
rename to plugins/vc_aos/include/algebra/impl/vc_aos_approximately_equal.hpp
index dbee4af0..2235ca5b 100644
--- a/storage/vc_aos/include/algebra/storage/impl/vc_aos_approximately_equal.hpp
+++ b/plugins/vc_aos/include/algebra/impl/vc_aos_approximately_equal.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins, part of the ACTS project
  *
- * (c) 2025 CERN for the benefit of the ACTS project
+ * (c) 2025-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
diff --git a/storage/vc_aos/include/algebra/storage/impl/vc_aos_concepts.hpp b/plugins/vc_aos/include/algebra/impl/vc_aos_concepts.hpp
similarity index 88%
rename from storage/vc_aos/include/algebra/storage/impl/vc_aos_concepts.hpp
rename to plugins/vc_aos/include/algebra/impl/vc_aos_concepts.hpp
index 7ae9490d..07fbf0c9 100644
--- a/storage/vc_aos/include/algebra/storage/impl/vc_aos_concepts.hpp
+++ b/plugins/vc_aos/include/algebra/impl/vc_aos_concepts.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins library, part of the ACTS project
  *
- * (c) 2024 CERN for the benefit of the ACTS project
+ * (c) 2024-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -8,7 +8,7 @@
 #pragma once
 
 // Project include(s).
-#include "algebra/storage/vector.hpp"
+#include "algebra/vector.hpp"
 
 // Vc include(s).
 #ifdef _MSC_VER
diff --git a/storage/vc_aos/include/algebra/storage/impl/vc_aos_getter.hpp b/plugins/vc_aos/include/algebra/impl/vc_aos_getter.hpp
similarity index 89%
rename from storage/vc_aos/include/algebra/storage/impl/vc_aos_getter.hpp
rename to plugins/vc_aos/include/algebra/impl/vc_aos_getter.hpp
index 3bc7bbb2..2417b1ef 100644
--- a/storage/vc_aos/include/algebra/storage/impl/vc_aos_getter.hpp
+++ b/plugins/vc_aos/include/algebra/impl/vc_aos_getter.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins library, part of the ACTS project
  *
- * (c) 2020-2024 CERN for the benefit of the ACTS project
+ * (c) 2020-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -9,8 +9,8 @@
 
 // Project include(s).
 #include "algebra/concepts.hpp"
+#include "algebra/matrix_getter.hpp"
 #include "algebra/qualifiers.hpp"
-#include "algebra/storage/matrix_getter.hpp"
 
 namespace algebra::vc_aos::storage {
 
diff --git a/math/vc_aos/include/algebra/math/impl/vc_aos_matrix.hpp b/plugins/vc_aos/include/algebra/impl/vc_aos_matrix.hpp
similarity index 53%
rename from math/vc_aos/include/algebra/math/impl/vc_aos_matrix.hpp
rename to plugins/vc_aos/include/algebra/impl/vc_aos_matrix.hpp
index 381f77c3..a4b5ec02 100644
--- a/math/vc_aos/include/algebra/math/impl/vc_aos_matrix.hpp
+++ b/plugins/vc_aos/include/algebra/impl/vc_aos_matrix.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins library, part of the ACTS project
  *
- * (c) 2024 CERN for the benefit of the ACTS project
+ * (c) 2024-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -9,39 +9,43 @@
 
 // Project include(s).
 #include "algebra/concepts.hpp"
-#include "algebra/math/generic.hpp"
+#include "algebra/generic.hpp"
+#include "algebra/matrix.hpp"
 #include "algebra/qualifiers.hpp"
-#include "algebra/storage/matrix.hpp"
 
 namespace algebra::vc_aos::math {
 
-using storage::identity;
-using storage::set_identity;
-using storage::set_zero;
-using storage::transpose;
-using storage::zero;
+using algebra::storage::identity;
+using algebra::storage::set_identity;
+using algebra::storage::set_zero;
+using algebra::storage::transpose;
+using algebra::storage::zero;
 
 /// @returns the determinant
 template <std::size_t N, concepts::value value_t,
           template <typename, std::size_t> class array_t>
 ALGEBRA_HOST_DEVICE constexpr value_t determinant(
-    const storage::matrix<array_t, value_t, N, N> &m) noexcept {
+    const algebra::storage::matrix<array_t, value_t, N, N> &m) noexcept {
   return algebra::generic::math::determinant(m);
 }
 
 /// @returns the inverse
 template <std::size_t ROW, std::size_t COL, concepts::value value_t,
           template <typename, std::size_t> class array_t>
-ALGEBRA_HOST_DEVICE constexpr storage::matrix<array_t, value_t, COL, ROW>
-inverse(const storage::matrix<array_t, value_t, ROW, COL> &m) noexcept {
+ALGEBRA_HOST_DEVICE constexpr algebra::storage::matrix<array_t, value_t, COL,
+                                                       ROW>
+inverse(
+    const algebra::storage::matrix<array_t, value_t, ROW, COL> &m) noexcept {
   return algebra::generic::math::inverse(m);
 }
 
 /// @returns the transpose
 template <std::size_t ROW, std::size_t COL, concepts::value value_t,
           template <typename, std::size_t> class array_t>
-ALGEBRA_HOST_DEVICE constexpr storage::matrix<array_t, value_t, COL, ROW>
-transpose(const storage::matrix<array_t, value_t, ROW, COL> &m) noexcept {
+ALGEBRA_HOST_DEVICE constexpr algebra::storage::matrix<array_t, value_t, COL,
+                                                       ROW>
+transpose(
+    const algebra::storage::matrix<array_t, value_t, ROW, COL> &m) noexcept {
   return algebra::generic::math::transpose(m);
 }
 
diff --git a/math/vc_aos/include/algebra/math/impl/vc_aos_transform3.hpp b/plugins/vc_aos/include/algebra/impl/vc_aos_transform3.hpp
similarity index 93%
rename from math/vc_aos/include/algebra/math/impl/vc_aos_transform3.hpp
rename to plugins/vc_aos/include/algebra/impl/vc_aos_transform3.hpp
index 77b00db1..77591e1f 100644
--- a/math/vc_aos/include/algebra/math/impl/vc_aos_transform3.hpp
+++ b/plugins/vc_aos/include/algebra/impl/vc_aos_transform3.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins library, part of the ACTS project
  *
- * (c) 2020-2024 CERN for the benefit of the ACTS project
+ * (c) 2020-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -9,13 +9,13 @@
 
 // Project include(s).
 #include "algebra/concepts.hpp"
-#include "algebra/math/common.hpp"
+#include "algebra/impl/vc_aos_approximately_equal.hpp"
+#include "algebra/math.hpp"
+#include "algebra/matrix.hpp"
+#include "algebra/matrix_getter.hpp"
 #include "algebra/qualifiers.hpp"
-#include "algebra/storage/impl/vc_aos_approximately_equal.hpp"
-#include "algebra/storage/matrix.hpp"
-#include "algebra/storage/matrix_getter.hpp"
-#include "algebra/storage/vector.hpp"
 #include "algebra/utils/approximately_equal.hpp"
+#include "algebra/vector.hpp"
 
 // Vc include(s).
 #ifdef _MSC_VER
@@ -63,18 +63,18 @@ struct transform3 {
   using array_type = array_t<scalar_type, N>;
 
   /// 3-element "vector" type (does not observe translations)
-  using vector3 = storage::vector<3u, scalar_type, array_t>;
+  using vector3 = algebra::storage::vector<3u, scalar_type, array_t>;
   /// Point in 3D space (does observe translations)
   using point3 = vector3;
   /// Point in 2D space
-  using point2 = storage::vector<2u, scalar_type, array_t>;
+  using point2 = algebra::storage::vector<2u, scalar_type, array_t>;
 
   /// 4x4 matrix type (Last row is {0, 0, 0, 1} and can be omitted)
-  using matrix44 = storage::matrix<array_t, scalar_type, 3u, 4u>;
+  using matrix44 = algebra::storage::matrix<array_t, scalar_type, 3u, 4u>;
   using column_t = typename matrix44::vector_type;
 
   /// Function (object) used for accessing a matrix element
-  using element_getter = storage::element_getter;
+  using element_getter = algebra::storage::element_getter;
 
   /// Helper type to cast this to another floating point precision
   template <concepts::scalar o_scalar_t>
@@ -92,8 +92,8 @@ struct transform3 {
   /// Default constructor: identity
   ALGEBRA_HOST_DEVICE
   constexpr transform3()
-      : _data{storage::identity<matrix44>()},
-        _data_inv{storage::identity<matrix44>()} {}
+      : _data{algebra::storage::identity<matrix44>()},
+        _data_inv{algebra::storage::identity<matrix44>()} {}
 
   /// Contructor with arguments: t, x, y, z
   ///
@@ -261,7 +261,7 @@ struct transform3 {
   ALGEBRA_HOST_DEVICE
   constexpr auto rotation() const {
 
-    using matrix_t = storage::matrix<array_t, scalar_type, 3u, 3u>;
+    using matrix_t = algebra::storage::matrix<array_t, scalar_type, 3u, 3u>;
 
     matrix_t submatrix;
     for (unsigned int icol = 0; icol < 3; ++icol) {
diff --git a/storage/vc_aos/include/algebra/storage/vc_aos.hpp b/plugins/vc_aos/include/algebra/impl/vc_aos_types.hpp
similarity index 77%
rename from storage/vc_aos/include/algebra/storage/vc_aos.hpp
rename to plugins/vc_aos/include/algebra/impl/vc_aos_types.hpp
index c45e853d..85114a7b 100644
--- a/storage/vc_aos/include/algebra/storage/vc_aos.hpp
+++ b/plugins/vc_aos/include/algebra/impl/vc_aos_types.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins library, part of the ACTS project
  *
- * (c) 2020-2024 CERN for the benefit of the ACTS project
+ * (c) 2020-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -9,12 +9,12 @@
 
 // Project include(s).
 #include "algebra/concepts.hpp"
-#include "algebra/storage/impl/vc_aos_approximately_equal.hpp"
-#include "algebra/storage/impl/vc_aos_concepts.hpp"
-#include "algebra/storage/impl/vc_aos_getter.hpp"
-#include "algebra/storage/matrix.hpp"
-#include "algebra/storage/vector.hpp"
+#include "algebra/impl/vc_aos_approximately_equal.hpp"
+#include "algebra/impl/vc_aos_concepts.hpp"
+#include "algebra/impl/vc_aos_getter.hpp"
+#include "algebra/matrix.hpp"
 #include "algebra/type_traits.hpp"
+#include "algebra/vector.hpp"
 
 // System include(s).
 #include <array>
@@ -34,7 +34,7 @@ namespace algebra {
 namespace vc_aos {
 
 /// Size type for Vc storage model
-using size_type = std::size_t;
+using index_type = std::size_t;
 /// Value type for Vc storage model
 template <concepts::value T>
 using value_type = T;
@@ -42,7 +42,7 @@ using value_type = T;
 template <concepts::value T>
 using scalar_type = T;
 /// Array type used to store Vc::Vectors
-template <concepts::value T, size_type N>
+template <concepts::value T, index_type N>
 using storage_type = Vc::SimdArray<T, N>;
 /// Value type in a linear algebra vector: AoS layout
 template <concepts::value T>
@@ -54,7 +54,7 @@ using scalar_type = T;
 template <concepts::value T, std::size_t N>
 using vector_type = algebra::storage::vector<N, T, storage_type>;
 /// Matrix type used in the Vc AoS storage model
-template <concepts::value T, size_type ROWS, size_type COLS>
+template <concepts::value T, index_type ROWS, index_type COLS>
 using matrix_type = algebra::storage::matrix<storage_type, T, ROWS, COLS>;
 
 /// 2-element "vector" type, using @c Vc::SimdArray
@@ -89,12 +89,12 @@ namespace traits {
 
 template <typename T, auto N>
 struct index<vc_aos::storage_type<T, N>> {
-  using size_type = vc_aos::size_type;
+  using index_type = vc_aos::index_type;
 };
 
 template <typename T, auto N>
 struct index<Vc_1::Vector<T, Vc_1::simd_abi::fixed_size<N>>> {
-  using size_type = vc_aos::size_type;
+  using index_type = vc_aos::index_type;
 };
 
 template <typename T, auto N>
@@ -111,22 +111,22 @@ struct value<Vc_1::Vector<T, Vc_1::simd_abi::fixed_size<N>>> {
 template <typename T, auto N>
 struct dimensions<vc_aos::storage_type<T, N>> {
 
-  using size_type = vc_aos::size_type;
+  using index_type = vc_aos::index_type;
 
-  static constexpr size_type dim{1};
-  static constexpr size_type rows{N};
-  static constexpr size_type columns{1};
+  static constexpr index_type _dim{1};
+  static constexpr index_type _rows{N};
+  static constexpr index_type _columns{1};
 };
 
 // Vector and storage types are different
 template <typename T, auto N>
 struct dimensions<Vc_1::Vector<T, Vc_1::simd_abi::fixed_size<N>>> {
 
-  using size_type = vc_aos::size_type;
+  using index_type = vc_aos::index_type;
 
-  static constexpr size_type dim{1};
-  static constexpr size_type rows{N};
-  static constexpr size_type columns{1};
+  static constexpr index_type _dim{1};
+  static constexpr index_type _rows{N};
+  static constexpr index_type _columns{1};
 };
 
 }  // namespace traits
diff --git a/math/vc_aos/include/algebra/math/impl/vc_aos_vector.hpp b/plugins/vc_aos/include/algebra/impl/vc_aos_vector.hpp
similarity index 96%
rename from math/vc_aos/include/algebra/math/impl/vc_aos_vector.hpp
rename to plugins/vc_aos/include/algebra/impl/vc_aos_vector.hpp
index 0b53acb9..33741a92 100644
--- a/math/vc_aos/include/algebra/math/impl/vc_aos_vector.hpp
+++ b/plugins/vc_aos/include/algebra/impl/vc_aos_vector.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins library, part of the ACTS project
  *
- * (c) 2020-2025 CERN for the benefit of the ACTS project
+ * (c) 2020-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -9,10 +9,10 @@
 
 // Project include(s).
 #include "algebra/concepts.hpp"
-#include "algebra/math/common.hpp"
+#include "algebra/impl/vc_aos_types.hpp"
+#include "algebra/math.hpp"
 #include "algebra/qualifiers.hpp"
-#include "algebra/storage/vc_aos.hpp"
-#include "algebra/storage/vector.hpp"
+#include "algebra/vector.hpp"
 
 // Vc include(s).
 #ifdef _MSC_VER
diff --git a/frontend/vc_aos/include/algebra/vc_aos.hpp b/plugins/vc_aos/include/algebra/vc_aos.hpp
similarity index 88%
rename from frontend/vc_aos/include/algebra/vc_aos.hpp
rename to plugins/vc_aos/include/algebra/vc_aos.hpp
index 80705b82..e2a1067e 100644
--- a/frontend/vc_aos/include/algebra/vc_aos.hpp
+++ b/plugins/vc_aos/include/algebra/vc_aos.hpp
@@ -1,6 +1,6 @@
 /** Algebra plugins library, part of the ACTS project
  *
- * (c) 2020-2024 CERN for the benefit of the ACTS project
+ * (c) 2020-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -8,9 +8,13 @@
 #pragma once
 
 // Project include(s).
-#include "algebra/math/generic.hpp"
-#include "algebra/math/vc_aos.hpp"
-#include "algebra/storage/vc_aos.hpp"
+#include "algebra/boolean.hpp"
+#include "algebra/generic.hpp"
+#include "algebra/impl/vc_aos_getter.hpp"
+#include "algebra/impl/vc_aos_matrix.hpp"
+#include "algebra/impl/vc_aos_transform3.hpp"
+#include "algebra/impl/vc_aos_types.hpp"
+#include "algebra/impl/vc_aos_vector.hpp"
 
 // System include(s).
 #include <cassert>
@@ -59,16 +63,14 @@ template <concepts::scalar T, auto ROWS, auto COLS>
 struct determinant_selector<4, vc_aos::matrix_type<T, ROWS, COLS>,
                             vc_aos::element_getter> {
   using type =
-      matrix::determinant::hard_coded<vc_aos::matrix_type<T, ROWS, COLS>,
-                                      vc_aos::element_getter>;
+      matrix::determinant::hard_coded<vc_aos::matrix_type<T, ROWS, COLS>>;
 };
 
 // Inversion algorithms
 template <concepts::scalar T, auto ROWS, auto COLS>
 struct inversion_selector<4, vc_aos::matrix_type<T, ROWS, COLS>,
                           vc_aos::element_getter> {
-  using type = matrix::inverse::hard_coded<vc_aos::matrix_type<T, ROWS, COLS>,
-                                           vc_aos::element_getter>;
+  using type = matrix::inverse::hard_coded<vc_aos::matrix_type<T, ROWS, COLS>>;
 };
 
 }  // namespace generic
@@ -125,7 +127,7 @@ struct vc_aos {
 
   using boolean = bool;
   using scalar = value_type;
-  using size_type = algebra::vc_aos::size_type;
+  using index_type = algebra::vc_aos::index_type;
   using transform3D = algebra::vc_aos::transform3<value_type>;
   using point2D = algebra::vc_aos::point2<value_type>;
   using point3D = algebra::vc_aos::point3<value_type>;
diff --git a/frontend/vc_soa/CMakeLists.txt b/plugins/vc_soa/CMakeLists.txt
similarity index 73%
rename from frontend/vc_soa/CMakeLists.txt
rename to plugins/vc_soa/CMakeLists.txt
index 3570bd54..05a6e0a8 100644
--- a/frontend/vc_soa/CMakeLists.txt
+++ b/plugins/vc_soa/CMakeLists.txt
@@ -9,16 +9,12 @@ message(STATUS "Building the Vc SoA algebra plugin")
 # Set up the library.
 algebra_add_library( algebra_vc_soa vc_soa
    "include/algebra/vc_soa.hpp"
+   "include/algebra/impl/*.hpp"
 )
 
 target_link_libraries(
     algebra_vc_soa
-    INTERFACE
-        algebra::common
-        algebra::vc_soa_storage
-        algebra::vc_soa_math
-        algebra::generic_math
-        algebra::vc_aos_math
+    INTERFACE Vc::Vc algebra::common algebra::generic algebra::vc_aos
 )
 
 algebra_test_public_headers( algebra_vc_soa
diff --git a/math/vc_soa/include/algebra/math/impl/vc_soa_boolean.hpp b/plugins/vc_soa/include/algebra/impl/vc_soa_boolean.hpp
similarity index 96%
rename from math/vc_soa/include/algebra/math/impl/vc_soa_boolean.hpp
rename to plugins/vc_soa/include/algebra/impl/vc_soa_boolean.hpp
index 1e108b94..0de16585 100644
--- a/math/vc_soa/include/algebra/math/impl/vc_soa_boolean.hpp
+++ b/plugins/vc_soa/include/algebra/impl/vc_soa_boolean.hpp
@@ -8,7 +8,7 @@
 #pragma once
 
 // Project include(s).
-#include "algebra/math/boolean.hpp"
+#include "algebra/boolean.hpp"
 
 // Vc include(s).
 #ifdef _MSC_VER
diff --git a/storage/vc_soa/include/algebra/storage/impl/vc_soa_casts.hpp b/plugins/vc_soa/include/algebra/impl/vc_soa_casts.hpp
similarity index 100%
rename from storage/vc_soa/include/algebra/storage/impl/vc_soa_casts.hpp
rename to plugins/vc_soa/include/algebra/impl/vc_soa_casts.hpp
diff --git a/storage/vc_soa/include/algebra/storage/impl/vc_soa_concepts.hpp b/plugins/vc_soa/include/algebra/impl/vc_soa_concepts.hpp
similarity index 89%
rename from storage/vc_soa/include/algebra/storage/impl/vc_soa_concepts.hpp
rename to plugins/vc_soa/include/algebra/impl/vc_soa_concepts.hpp
index 626b29aa..9d64ccf1 100644
--- a/storage/vc_soa/include/algebra/storage/impl/vc_soa_concepts.hpp
+++ b/plugins/vc_soa/include/algebra/impl/vc_soa_concepts.hpp
@@ -8,7 +8,7 @@
 #pragma once
 
 // Project include(s).
-#include "algebra/storage/impl/vc_aos_concepts.hpp"
+#include "algebra/impl/vc_aos_concepts.hpp"
 
 // System include(s).
 #include <concepts>
diff --git a/storage/vc_soa/include/algebra/storage/impl/vc_soa_getter.hpp b/plugins/vc_soa/include/algebra/impl/vc_soa_getter.hpp
similarity index 95%
rename from storage/vc_soa/include/algebra/storage/impl/vc_soa_getter.hpp
rename to plugins/vc_soa/include/algebra/impl/vc_soa_getter.hpp
index 98cf14ee..712fc400 100644
--- a/storage/vc_soa/include/algebra/storage/impl/vc_soa_getter.hpp
+++ b/plugins/vc_soa/include/algebra/impl/vc_soa_getter.hpp
@@ -9,8 +9,8 @@
 
 // Project include(s).
 #include "algebra/concepts.hpp"
+#include "algebra/matrix_getter.hpp"
 #include "algebra/qualifiers.hpp"
-#include "algebra/storage/matrix_getter.hpp"
 
 namespace algebra::vc_soa::storage {
 
diff --git a/math/vc_soa/include/algebra/math/impl/vc_soa_math.hpp b/plugins/vc_soa/include/algebra/impl/vc_soa_math.hpp
similarity index 98%
rename from math/vc_soa/include/algebra/math/impl/vc_soa_math.hpp
rename to plugins/vc_soa/include/algebra/impl/vc_soa_math.hpp
index 691c63d4..e6987ad5 100644
--- a/math/vc_soa/include/algebra/math/impl/vc_soa_math.hpp
+++ b/plugins/vc_soa/include/algebra/impl/vc_soa_math.hpp
@@ -8,7 +8,7 @@
 #pragma once
 
 // Project include(s)
-#include "algebra/storage/impl/vc_soa_concepts.hpp"
+#include "algebra/impl/vc_soa_concepts.hpp"
 
 // Vc include(s).
 #ifdef _MSC_VER
diff --git a/math/vc_soa/include/algebra/math/impl/vc_soa_matrix.hpp b/plugins/vc_soa/include/algebra/impl/vc_soa_matrix.hpp
similarity index 57%
rename from math/vc_soa/include/algebra/math/impl/vc_soa_matrix.hpp
rename to plugins/vc_soa/include/algebra/impl/vc_soa_matrix.hpp
index 278f3b03..81519bbd 100644
--- a/math/vc_soa/include/algebra/math/impl/vc_soa_matrix.hpp
+++ b/plugins/vc_soa/include/algebra/impl/vc_soa_matrix.hpp
@@ -9,30 +9,32 @@
 
 // Project include(s).
 #include "algebra/concepts.hpp"
-#include "algebra/math/impl/vc_soa_vector.hpp"
+#include "algebra/impl/vc_soa_vector.hpp"
+#include "algebra/matrix.hpp"
 #include "algebra/qualifiers.hpp"
-#include "algebra/storage/matrix.hpp"
 
 namespace algebra::vc_soa::math {
 
-using storage::identity;
-using storage::set_identity;
-using storage::set_zero;
-using storage::transpose;
-using storage::zero;
+using algebra::storage::identity;
+using algebra::storage::set_identity;
+using algebra::storage::set_zero;
+using algebra::storage::transpose;
+using algebra::storage::zero;
 
 template <std::size_t ROW, std::size_t COL, concepts::simd_scalar scalar_t,
           template <typename, std::size_t> class array_t>
 ALGEBRA_HOST_DEVICE constexpr scalar_t determinant(
-    const storage::matrix<array_t, scalar_t, ROW, COL> &) noexcept {
+    const algebra::storage::matrix<array_t, scalar_t, ROW, COL> &) noexcept {
   // @TODO: Implement
   return scalar_t(0);
 }
 
 template <std::size_t ROW, std::size_t COL, concepts::simd_scalar scalar_t,
           template <typename, std::size_t> class array_t>
-ALGEBRA_HOST_DEVICE constexpr storage::matrix<array_t, scalar_t, ROW, COL>
-inverse(const storage::matrix<array_t, scalar_t, ROW, COL> &m) noexcept {
+ALGEBRA_HOST_DEVICE constexpr algebra::storage::matrix<array_t, scalar_t, ROW,
+                                                       COL>
+inverse(
+    const algebra::storage::matrix<array_t, scalar_t, ROW, COL> &m) noexcept {
   // @TODO: Implement
   return m;
 }
diff --git a/storage/vc_soa/include/algebra/storage/vc_soa.hpp b/plugins/vc_soa/include/algebra/impl/vc_soa_types.hpp
similarity index 84%
rename from storage/vc_soa/include/algebra/storage/vc_soa.hpp
rename to plugins/vc_soa/include/algebra/impl/vc_soa_types.hpp
index 6053bd26..73148362 100644
--- a/storage/vc_soa/include/algebra/storage/vc_soa.hpp
+++ b/plugins/vc_soa/include/algebra/impl/vc_soa_types.hpp
@@ -9,12 +9,12 @@
 
 // Project include(s).
 #include "algebra/concepts.hpp"
-#include "algebra/storage/impl/vc_aos_approximately_equal.hpp"
-#include "algebra/storage/impl/vc_soa_casts.hpp"
-#include "algebra/storage/impl/vc_soa_getter.hpp"
-#include "algebra/storage/matrix.hpp"
-#include "algebra/storage/vector.hpp"
+#include "algebra/impl/vc_aos_approximately_equal.hpp"
+#include "algebra/impl/vc_soa_casts.hpp"
+#include "algebra/impl/vc_soa_getter.hpp"
+#include "algebra/matrix.hpp"
 #include "algebra/type_traits.hpp"
+#include "algebra/vector.hpp"
 
 // System include(s).
 #include <array>
@@ -34,7 +34,7 @@ namespace algebra {
 namespace vc_soa {
 
 /// Size type for Vc storage model
-using size_type = std::size_t;
+using index_type = std::size_t;
 /// Value type in a linear algebra vector: SoA layout
 template <concepts::value T>
 using value_type = T;
@@ -42,13 +42,13 @@ using value_type = T;
 template <concepts::value T>
 using scalar_type = Vc::Vector<T>;
 /// Array type used to store Vc::Vectors or matrix columns
-template <concepts::simd_scalar T, size_type N>
+template <concepts::simd_scalar T, index_type N>
 using storage_type = std::array<T, N>;
 /// Vector type used in the Vc SoA storage model
 template <concepts::value T, std::size_t N>
 using vector_type = algebra::storage::vector<N, Vc::Vector<T>, storage_type>;
 /// Matrix type used in the Vc SoA storage model
-template <concepts::value T, size_type ROWS, size_type COLS>
+template <concepts::value T, index_type ROWS, index_type COLS>
 using matrix_type =
     algebra::storage::matrix<storage_type, Vc::Vector<T>, ROWS, COLS>;
 
@@ -109,11 +109,11 @@ struct value<Vc::Vector<T>> {
 template <concepts::simd_scalar T, auto N>
 struct dimensions<vc_soa::storage_type<T, N>> {
 
-  using size_type = vc_soa::size_type;
+  using index_type = vc_soa::index_type;
 
-  static constexpr size_type dim{1};
-  static constexpr size_type rows{N};
-  static constexpr size_type columns{1};
+  static constexpr index_type _dim{1};
+  static constexpr index_type _rows{N};
+  static constexpr index_type _columns{1};
 };
 
 }  // namespace traits
diff --git a/math/vc_soa/include/algebra/math/impl/vc_soa_vector.hpp b/plugins/vc_soa/include/algebra/impl/vc_soa_vector.hpp
similarity index 82%
rename from math/vc_soa/include/algebra/math/impl/vc_soa_vector.hpp
rename to plugins/vc_soa/include/algebra/impl/vc_soa_vector.hpp
index c032f587..ac81372e 100644
--- a/math/vc_soa/include/algebra/math/impl/vc_soa_vector.hpp
+++ b/plugins/vc_soa/include/algebra/impl/vc_soa_vector.hpp
@@ -9,9 +9,9 @@
 
 // Project include(s).
 #include "algebra/concepts.hpp"
-#include "algebra/math/impl/vc_soa_math.hpp"
+#include "algebra/impl/vc_soa_math.hpp"
 #include "algebra/qualifiers.hpp"
-#include "algebra/storage/vector.hpp"
+#include "algebra/vector.hpp"
 
 // Vc include(s).
 #ifdef _MSC_VER
@@ -35,7 +35,7 @@ template <std::size_t N, concepts::value value_t,
           template <typename, std::size_t> class array_t>
   requires(N >= 2)
 ALGEBRA_HOST_DEVICE constexpr auto phi(
-    const storage::vector<N, Vc::Vector<value_t>, array_t> &v) {
+    const algebra::storage::vector<N, Vc::Vector<value_t>, array_t> &v) {
 
   return Vc::atan2(v[1], v[0]);
 }
@@ -51,7 +51,7 @@ template <std::size_t N, concepts::value value_t,
           template <typename, std::size_t> class array_t>
   requires(N >= 2)
 ALGEBRA_HOST_DEVICE constexpr auto perp(
-    const storage::vector<N, Vc::Vector<value_t>, array_t> &v) {
+    const algebra::storage::vector<N, Vc::Vector<value_t>, array_t> &v) {
 
   return Vc::sqrt(Vc::fma(v[0], v[0], v[1] * v[1]));
 }
@@ -67,7 +67,7 @@ template <std::size_t N, concepts::value value_t,
           template <typename, std::size_t> class array_t>
   requires(N >= 3)
 ALGEBRA_HOST_DEVICE constexpr auto theta(
-    const storage::vector<N, Vc::Vector<value_t>, array_t> &v) {
+    const algebra::storage::vector<N, Vc::Vector<value_t>, array_t> &v) {
 
   return Vc::atan2(perp(v), v[2]);
 }
@@ -85,9 +85,10 @@ ALGEBRA_HOST_DEVICE constexpr auto theta(
 template <std::size_t N, concepts::value value_t,
           template <typename, std::size_t> class array_t>
   requires(N == 3)
-ALGEBRA_HOST_DEVICE constexpr storage::vector<N, Vc::Vector<value_t>, array_t>
-cross(const storage::vector<N, Vc::Vector<value_t>, array_t> &a,
-      const storage::vector<N, Vc::Vector<value_t>, array_t> &b) {
+ALGEBRA_HOST_DEVICE constexpr algebra::storage::vector<N, Vc::Vector<value_t>,
+                                                       array_t>
+cross(const algebra::storage::vector<N, Vc::Vector<value_t>, array_t> &a,
+      const algebra::storage::vector<N, Vc::Vector<value_t>, array_t> &b) {
 
   return {Vc::fma(a[1], b[2], -b[1] * a[2]), Vc::fma(a[2], b[0], -b[2] * a[0]),
           Vc::fma(a[0], b[1], -b[0] * a[1])};
@@ -106,8 +107,8 @@ cross(const storage::vector<N, Vc::Vector<value_t>, array_t> &a,
 template <std::size_t N, concepts::value value_t,
           template <typename, std::size_t> class array_t>
 ALGEBRA_HOST_DEVICE constexpr Vc::Vector<value_t> dot(
-    const storage::vector<N, Vc::Vector<value_t>, array_t> &a,
-    const storage::vector<N, Vc::Vector<value_t>, array_t> &b) {
+    const algebra::storage::vector<N, Vc::Vector<value_t>, array_t> &a,
+    const algebra::storage::vector<N, Vc::Vector<value_t>, array_t> &b) {
 
   auto ret = a[0] * b[0];
 
@@ -128,7 +129,7 @@ ALGEBRA_HOST_DEVICE constexpr Vc::Vector<value_t> dot(
 template <std::size_t N, concepts::value value_t,
           template <typename, std::size_t> class array_t>
 ALGEBRA_HOST_DEVICE constexpr auto norm(
-    const storage::vector<N, Vc::Vector<value_t>, array_t> &v) {
+    const algebra::storage::vector<N, Vc::Vector<value_t>, array_t> &v) {
 
   return Vc::sqrt(dot(v, v));
 }
@@ -142,8 +143,9 @@ ALGEBRA_HOST_DEVICE constexpr auto norm(
 /// @param v the input vector
 template <std::size_t N, concepts::value value_t,
           template <typename, std::size_t> class array_t>
-ALGEBRA_HOST_DEVICE constexpr storage::vector<N, Vc::Vector<value_t>, array_t>
-normalize(const storage::vector<N, Vc::Vector<value_t>, array_t> &v) {
+ALGEBRA_HOST_DEVICE constexpr algebra::storage::vector<N, Vc::Vector<value_t>,
+                                                       array_t>
+normalize(const algebra::storage::vector<N, Vc::Vector<value_t>, array_t> &v) {
 
   return (Vc::Vector<value_t>::One() / norm(v)) * v;
 
@@ -166,7 +168,7 @@ template <std::size_t N, concepts::value value_t,
           template <typename, std::size_t> class array_t>
   requires(N >= 3)
 ALGEBRA_HOST_DEVICE constexpr auto eta(
-    const storage::vector<N, Vc::Vector<value_t>, array_t> &v) {
+    const algebra::storage::vector<N, Vc::Vector<value_t>, array_t> &v) {
 
   // atanh does not exist in Vc
   auto atanh_func = [](value_t e) { return std::atanh(e); };
@@ -192,7 +194,7 @@ ALGEBRA_HOST_DEVICE constexpr auto eta(
 template <std::size_t N, concepts::value value_t,
           template <typename, std::size_t> class array_t>
 ALGEBRA_HOST_DEVICE constexpr Vc::Vector<value_t> sum(
-    const storage::vector<N, Vc::Vector<value_t>, array_t> &v) {
+    const algebra::storage::vector<N, Vc::Vector<value_t>, array_t> &v) {
 
   Vc::Vector<value_t> res{v[0]};
 
diff --git a/frontend/vc_soa/include/algebra/vc_soa.hpp b/plugins/vc_soa/include/algebra/vc_soa.hpp
similarity index 86%
rename from frontend/vc_soa/include/algebra/vc_soa.hpp
rename to plugins/vc_soa/include/algebra/vc_soa.hpp
index 4935c39d..2dba4f9f 100644
--- a/frontend/vc_soa/include/algebra/vc_soa.hpp
+++ b/plugins/vc_soa/include/algebra/vc_soa.hpp
@@ -8,10 +8,15 @@
 #pragma once
 
 // Project include(s).
-#include "algebra/math/impl/generic_matrix.hpp"
-#include "algebra/math/impl/vc_aos_transform3.hpp"
-#include "algebra/math/vc_soa.hpp"
-#include "algebra/storage/vc_soa.hpp"
+#include "algebra/impl/generic_matrix.hpp"
+#include "algebra/impl/vc_aos_transform3.hpp"
+#include "algebra/impl/vc_soa_boolean.hpp"
+#include "algebra/impl/vc_soa_casts.hpp"
+#include "algebra/impl/vc_soa_getter.hpp"
+#include "algebra/impl/vc_soa_math.hpp"
+#include "algebra/impl/vc_soa_matrix.hpp"
+#include "algebra/impl/vc_soa_types.hpp"
+#include "algebra/impl/vc_soa_vector.hpp"
 
 // System include(s).
 #include <cassert>
@@ -114,7 +119,7 @@ struct vc_soa {
   /// Linear Algebra type definitions
   /// @{
   using scalar = simd<value_type>;
-  using size_type = algebra::vc_soa::size_type;
+  using index_type = algebra::vc_soa::index_type;
   using transform3D = algebra::vc_soa::transform3<value_type>;
   using point2D = algebra::vc_soa::point2<value_type>;
   using point3D = algebra::vc_soa::point3<value_type>;
diff --git a/storage/CMakeLists.txt b/storage/CMakeLists.txt
deleted file mode 100644
index f11121c8..00000000
--- a/storage/CMakeLists.txt
+++ /dev/null
@@ -1,27 +0,0 @@
-# Algebra plugins library, part of the ACTS project (R&D line)
-#
-# (c) 2021-2026 CERN for the benefit of the ACTS project
-#
-# Mozilla Public License Version 2.0
-
-# Set up all enabled libraries.
-add_subdirectory(array)
-add_subdirectory(cmath)
-add_subdirectory(common)
-
-if(ALGEBRA_PLUGINS_INCLUDE_EIGEN)
-    add_subdirectory(eigen)
-endif()
-
-if(ALGEBRA_PLUGINS_INCLUDE_SMATRIX)
-    add_subdirectory(smatrix)
-endif()
-
-if(ALGEBRA_PLUGINS_INCLUDE_VC)
-    add_subdirectory(vc_aos)
-    add_subdirectory(vc_soa)
-endif()
-
-if(ALGEBRA_PLUGINS_INCLUDE_FASTOR)
-    add_subdirectory(fastor)
-endif()
diff --git a/storage/array/CMakeLists.txt b/storage/array/CMakeLists.txt
deleted file mode 100644
index 4975d876..00000000
--- a/storage/array/CMakeLists.txt
+++ /dev/null
@@ -1,17 +0,0 @@
-# Algebra plugins library, part of the ACTS project (R&D line)
-#
-# (c) 2021-2023 CERN for the benefit of the ACTS project
-#
-# Mozilla Public License Version 2.0
-
-# Set up the library.
-algebra_add_library( algebra_array_storage array_storage
-   "include/algebra/storage/array.hpp"
-)
-target_link_libraries(
-    algebra_array_storage
-    INTERFACE algebra::common algebra::common_math algebra::cmath_storage
-)
-algebra_test_public_headers( algebra_array_storage
-   "algebra/storage/array.hpp"
-)
diff --git a/storage/cmath/CMakeLists.txt b/storage/cmath/CMakeLists.txt
deleted file mode 100644
index 0f87e895..00000000
--- a/storage/cmath/CMakeLists.txt
+++ /dev/null
@@ -1,17 +0,0 @@
-# Algebra plugins library, part of the ACTS project (R&D line)
-#
-# (c) 2024 CERN for the benefit of the ACTS project
-#
-# Mozilla Public License Version 2.0
-
-# Set up the library.
-algebra_add_library( algebra_cmath_storage cmath_storage
-   "include/algebra/storage/impl/cmath_getter.hpp"
-)
-target_link_libraries(
-    algebra_cmath_storage
-    INTERFACE algebra::common algebra::common_math
-)
-algebra_test_public_headers( algebra_cmath_storage
-   "algebra/storage/impl/cmath_getter.hpp"
-)
diff --git a/storage/common/CMakeLists.txt b/storage/common/CMakeLists.txt
deleted file mode 100644
index cf3dd934..00000000
--- a/storage/common/CMakeLists.txt
+++ /dev/null
@@ -1,14 +0,0 @@
-# Algebra plugins library, part of the ACTS project (R&D line)
-#
-# (c) 2023-2024 CERN for the benefit of the ACTS project
-#
-# Mozilla Public License Version 2.0
-
-# Set up the library.
-algebra_add_library(algebra_common_storage common_storage
-   "include/algebra/storage/array_operators.hpp"
-   "include/algebra/storage/matrix_getter.hpp"
-   "include/algebra/storage/matrix.hpp"
-   "include/algebra/storage/vector.hpp"
-)
-target_link_libraries(algebra_common_storage INTERFACE algebra::common)
diff --git a/storage/eigen/CMakeLists.txt b/storage/eigen/CMakeLists.txt
deleted file mode 100644
index cb818a93..00000000
--- a/storage/eigen/CMakeLists.txt
+++ /dev/null
@@ -1,19 +0,0 @@
-# Algebra plugins library, part of the ACTS project (R&D line)
-#
-# (c) 2021-2024 CERN for the benefit of the ACTS project
-#
-# Mozilla Public License Version 2.0
-
-# Set up the library.
-algebra_add_library( algebra_eigen_storage eigen_storage
-   "include/algebra/storage/eigen.hpp"
-   "include/algebra/storage/impl/eigen_array.hpp"
-   "include/algebra/storage/impl/eigen_getter.hpp"
-)
-target_link_libraries(
-    algebra_eigen_storage
-    INTERFACE algebra::common Eigen3::Eigen algebra::common_math
-)
-algebra_test_public_headers( algebra_eigen_storage
-   "algebra/storage/eigen.hpp"
-)
diff --git a/storage/fastor/CMakeLists.txt b/storage/fastor/CMakeLists.txt
deleted file mode 100644
index f81d30b5..00000000
--- a/storage/fastor/CMakeLists.txt
+++ /dev/null
@@ -1,19 +0,0 @@
-# Algebra plugins library, part of the ACTS project (R&D line)
-#
-# (c) 2022-2024 CERN for the benefit of the ACTS project
-#
-# Mozilla Public License Version 2.0
-
-# Set up the library.
-algebra_add_library( algebra_fastor_storage fastor_storage
-   "include/algebra/storage/fastor.hpp"
-   "include/algebra/storage/impl/fastor_getter.hpp"
-   "include/algebra/storage/impl/fastor_matrix.hpp"
-)
-target_link_libraries(
-    algebra_fastor_storage
-    INTERFACE Fastor::Fastor algebra::common algebra::common_math
-)
-algebra_test_public_headers( algebra_fastor_storage
-   "algebra/storage/fastor.hpp"
-)
diff --git a/storage/smatrix/CMakeLists.txt b/storage/smatrix/CMakeLists.txt
deleted file mode 100644
index e7a12d81..00000000
--- a/storage/smatrix/CMakeLists.txt
+++ /dev/null
@@ -1,21 +0,0 @@
-# Algebra plugins library, part of the ACTS project (R&D line)
-#
-# (c) 2021-2024 CERN for the benefit of the ACTS project
-#
-# Mozilla Public License Version 2.0
-
-# Find Smatrix.
-find_package(ROOT COMPONENTS Smatrix REQUIRED)
-
-# Set up the library.
-algebra_add_library( algebra_smatrix_storage smatrix_storage
-   "include/algebra/storage/smatrix.hpp"
-   "include/algebra/storage/impl/smatrix_getter.hpp"
-)
-target_link_libraries(
-    algebra_smatrix_storage
-    INTERFACE algebra::common ROOT::Smatrix algebra::common_math
-)
-algebra_test_public_headers( algebra_smatrix_storage
-   "algebra/storage/smatrix.hpp"
-)
diff --git a/storage/vc_aos/CMakeLists.txt b/storage/vc_aos/CMakeLists.txt
deleted file mode 100644
index 66a7b8c7..00000000
--- a/storage/vc_aos/CMakeLists.txt
+++ /dev/null
@@ -1,24 +0,0 @@
-# Algebra plugins library, part of the ACTS project (R&D line)
-#
-# (c) 2021-2024 CERN for the benefit of the ACTS project
-#
-# Mozilla Public License Version 2.0
-
-# Set up the library.
-algebra_add_library( algebra_vc_aos_storage vc_aos_storage
-   "include/algebra/storage/vc_aos.hpp"
-   "include/algebra/storage/impl/vc_aos_approximately_equal.hpp"
-   "include/algebra/storage/impl/vc_aos_concepts.hpp"
-   "include/algebra/storage/impl/vc_aos_getter.hpp"
-)
-target_link_libraries(
-    algebra_vc_aos_storage
-    INTERFACE
-        algebra::common
-        algebra::common_storage
-        Vc::Vc
-        algebra::common_math
-)
-algebra_test_public_headers( algebra_vc_aos_storage
-   "algebra/storage/vc_aos.hpp"
-)
diff --git a/storage/vc_soa/CMakeLists.txt b/storage/vc_soa/CMakeLists.txt
deleted file mode 100644
index 1836158d..00000000
--- a/storage/vc_soa/CMakeLists.txt
+++ /dev/null
@@ -1,24 +0,0 @@
-# Algebra plugins library, part of the ACTS project (R&D line)
-#
-# (c) 2024 CERN for the benefit of the ACTS project
-#
-# Mozilla Public License Version 2.0
-
-# Set up the library.
-algebra_add_library( algebra_vc_soa_storage vc_soa_storage
-   "include/algebra/storage/vc_soa.hpp"
-   "include/algebra/storage/impl/vc_soa_casts.hpp"
-   "include/algebra/storage/impl/vc_soa_concepts.hpp"
-   "include/algebra/storage/impl/vc_soa_getter.hpp"
-)
-target_link_libraries(
-    algebra_vc_soa_storage
-    INTERFACE
-        algebra::common
-        algebra::common_storage
-        Vc::Vc
-        algebra::vc_aos_storage
-)
-algebra_test_public_headers( algebra_vc_soa_storage
-   "algebra/storage/vc_soa.hpp"
-)
diff --git a/tests/include/algebra/test/device/matrix_fixture.hpp b/tests/include/algebra/test/device/matrix_fixture.hpp
index f7ee987b..9fc1636e 100644
--- a/tests/include/algebra/test/device/matrix_fixture.hpp
+++ b/tests/include/algebra/test/device/matrix_fixture.hpp
@@ -80,6 +80,7 @@ class matrix_fixture : public device_fixture<A, algebra::get_scalar_t<A>> {
     // Delete the matrices.
     m_m1.reset();
     m_m2.reset();
+
     // Tear down the base class.
     base_fixture::TearDown();
   }
diff --git a/tests/include/algebra/test/device/transform_fixture.hpp b/tests/include/algebra/test/device/transform_fixture.hpp
index 940768b4..370c5b08 100644
--- a/tests/include/algebra/test/device/transform_fixture.hpp
+++ b/tests/include/algebra/test/device/transform_fixture.hpp
@@ -89,6 +89,7 @@ class transform_fixture : public device_fixture<A, algebra::get_scalar_t<A>> {
     m_t3.reset();
     m_v1.reset();
     m_v2.reset();
+
     // Tear down the base class.
     base_fixture::TearDown();
   }
diff --git a/tests/include/algebra/test/device/vector_fixture.hpp b/tests/include/algebra/test/device/vector_fixture.hpp
index 08621965..802e19ab 100644
--- a/tests/include/algebra/test/device/vector_fixture.hpp
+++ b/tests/include/algebra/test/device/vector_fixture.hpp
@@ -86,6 +86,7 @@ class vector_fixture : public device_fixture<A, algebra::get_scalar_t<A>> {
     m_p2.reset();
     m_v1.reset();
     m_v2.reset();
+
     // Tear down the base class.
     base_fixture::TearDown();
   }
diff --git a/tests/unit_tests/device/sycl/CMakeLists.txt b/tests/unit_tests/device/sycl/CMakeLists.txt
index fd98fc16..e0c31955 100644
--- a/tests/unit_tests/device/sycl/CMakeLists.txt
+++ b/tests/unit_tests/device/sycl/CMakeLists.txt
@@ -12,6 +12,13 @@ enable_language(SYCL)
 # Set the default SYCL compiler flags.
 include(algebra-plugins-compiler-options-sycl)
 
+if(${CMAKE_SYCL_STANDARD} LESS 20)
+    message(
+        SEND_ERROR
+        "CMAKE_SYCL_STANDARD=${CMAKE_SYCL_STANDARD}, but algebra-plugins requires C++>=20"
+    )
+endif()
+
 # Macro setting up the SYCL tests for a specific algebra plugin.
 macro(algebra_add_test_suite plugin)
     string(TOUPPER ${plugin} PLUGIN)
diff --git a/utils/CMakeLists.txt b/utils/CMakeLists.txt
index 4e042e22..bdaba136 100644
--- a/utils/CMakeLists.txt
+++ b/utils/CMakeLists.txt
@@ -11,10 +11,7 @@ algebra_add_library( algebra_utils utils
    "include/algebra/utils/print.hpp"
 )
 
-target_link_libraries(
-    algebra_utils
-    INTERFACE algebra::common algebra_common_math
-)
+target_link_libraries(algebra_utils INTERFACE algebra::common)
 
 algebra_test_public_headers( algebra_utils
    "algebra/utils/approximately_equal.hpp"
diff --git a/utils/include/algebra/utils/approximately_equal.hpp b/utils/include/algebra/utils/approximately_equal.hpp
index fa64147e..31099146 100644
--- a/utils/include/algebra/utils/approximately_equal.hpp
+++ b/utils/include/algebra/utils/approximately_equal.hpp
@@ -9,7 +9,7 @@
 
 // Project include(s)
 #include "algebra/concepts.hpp"
-#include "algebra/math/common.hpp"
+#include "algebra/math.hpp"
 #include "algebra/qualifiers.hpp"
 
 // System include(s)