diff --git a/common/include/algebra/concepts.hpp b/common/include/algebra/concepts.hpp
index b66948ec..374b7bc0 100644
--- a/common/include/algebra/concepts.hpp
+++ b/common/include/algebra/concepts.hpp
@@ -15,23 +15,23 @@
 
 namespace algebra::concepts {
 
+/// Arithmetic types
+template <typename T>
+concept arithmetic = std::is_arithmetic_v<T>;
+
 // Value concept: Single entry
 template <typename T>
-concept value = std::is_arithmetic_v<std::decay_t<T>>;
+concept value = algebra::concepts::arithmetic<std::decay_t<T>>;
 
 /// Scalar concept: Elements of vectors/matrices (can be simd vectors)
 template <typename T>
 concept scalar = !algebra::traits::is_matrix<T> &&
                  !algebra::traits::is_vector<T> && requires(T a, T b) {
-  { a + b }
-  ->std::convertible_to<T>;
-  { a - b }
-  ->std::convertible_to<T>;
-  { a* b }
-  ->std::convertible_to<T>;
-  { a / b }
-  ->std::convertible_to<T>;
-};
+                   { a + b } -> std::convertible_to<T>;
+                   { a - b } -> std::convertible_to<T>;
+                   { a* b } -> std::convertible_to<T>;
+                   { a / b } -> std::convertible_to<T>;
+                 };
 
 /// Check if a scalar is simd
 template <typename T>
@@ -71,7 +71,7 @@ template <typename M>
 concept matrix = algebra::traits::is_matrix<M>;
 
 template <typename M>
-concept square_matrix = matrix<M>&& algebra::traits::is_square<M>;
+concept square_matrix = matrix<M> && algebra::traits::is_square<M>;
 
 template <typename M>
 concept row_matrix = matrix<M> && (algebra::traits::rows<M> == 1);
@@ -104,4 +104,25 @@ concept transform3D = requires(T trf) {
   trf.vector_to_local(typename T::vector3());
 };
 
+/// Algebra plugin concept
+template <typename A>
+concept algebra = (concepts::value<typename A::value_type> &&
+                   concepts::scalar<typename A::scalar> &&
+                   concepts::index<typename A::size_type> &&
+                   concepts::simd_scalar<typename A::template simd<float>> &&
+                   concepts::vector3D<typename A::vector3D> &&
+                   concepts::point2D<typename A::point2D> &&
+                   concepts::point3D<typename A::point3D> &&
+                   concepts::transform3D<typename A::transform3D> &&
+                   concepts::matrix<typename A::template matrix<3, 3>>);
+
+/// Check if an algebra has soa layout
+/// @{
+template <typename A>
+concept soa = (!concepts::arithmetic<algebra::get_scalar_t<A>>);
+
+template <typename A>
+concept aos = (!concepts::soa<A>);
+/// @}
+
 }  // namespace algebra::concepts
diff --git a/common/include/algebra/type_traits.hpp b/common/include/algebra/type_traits.hpp
index 3b338aad..7fb7c4b5 100644
--- a/common/include/algebra/type_traits.hpp
+++ b/common/include/algebra/type_traits.hpp
@@ -12,7 +12,9 @@
 #include <cmath>
 #include <type_traits>
 
-namespace algebra::traits {
+namespace algebra {
+
+namespace traits {
 
 /// Matrix traits
 /// @{
@@ -79,7 +81,8 @@ struct dimensions {
 
 /// Specilization for scalar types
 template <typename M>
-requires std::is_fundamental_v<M> struct dimensions<M> {
+  requires std::is_fundamental_v<M>
+struct dimensions<M> {
 
   using size_type = std::size_t;
 
@@ -129,7 +132,55 @@ template <class M>
 using block_getter_t = typename block_getter<M>::type;
 /// @}
 
-}  // namespace algebra::traits
+/// The algebra types
+/// @{
+template <typename T>
+struct get_algebra {};
+
+template <typename T>
+  requires(!std::is_same_v<typename T::point3D, void>)
+struct get_algebra<T> {
+  template <typename U>
+  using simd = typename T::template simd<U>;
+  using size_type = typename T::size_type;
+  using value = typename T::value_type;
+  using scalar = typename T::scalar;
+  using point2D = typename T::point2D;
+  using point3D = typename T::point3D;
+  using vector3D = typename T::vector3D;
+  using transform3D = typename T::transform3D;
+  template <std::size_t ROWS, std::size_t COLS>
+  using matrix = typename T::template matrix<ROWS, COLS>;
+};
+
+}  // namespace traits
+
+template <typename A>
+using get_scalar_t = typename traits::get_algebra<A>::scalar;
+
+template <typename A, typename T>
+using get_simd_t = typename traits::get_algebra<A>::template simd<T>;
+
+template <typename A>
+using get_point2D_t = typename traits::get_algebra<A>::point2D;
+
+template <typename A>
+using get_point3D_t = typename traits::get_algebra<A>::point3D;
+
+template <typename A>
+using get_vector3D_t = typename traits::get_algebra<A>::vector3D;
+
+template <typename A>
+using get_transform3D_t = typename traits::get_algebra<A>::transform3D;
+
+template <typename A>
+using get_size_t = typename traits::get_algebra<A>::size_type;
+
+template <typename A, std::size_t R, std::size_t C>
+using get_matrix_t = typename traits::get_algebra<A>::template matrix<R, C>;
+/// @}
+
+}  // namespace algebra
 
 /// Default type trait specializations
 /// @{
diff --git a/frontend/array_cmath/include/algebra/array_cmath.hpp b/frontend/array_cmath/include/algebra/array_cmath.hpp
index acb19a3d..7bde32d3 100644
--- a/frontend/array_cmath/include/algebra/array_cmath.hpp
+++ b/frontend/array_cmath/include/algebra/array_cmath.hpp
@@ -115,4 +115,31 @@ using transform3 =
 
 }  // namespace array
 
+namespace plugin {
+
+/// Define the plugin types
+/// @{
+template <typename V>
+struct cmath {
+    /// Define scalar type
+    using value_type = V;
+
+    template <typename T>
+    using simd = T;
+
+    using boolean = bool;
+    using scalar = value_type;
+    using size_type = algebra::array::size_type;
+    using transform3D = algebra::array::transform3<value_type>;
+    using point2D = algebra::array::point2<value_type>;
+    using point3D = algebra::array::point3<value_type>;
+    using vector3D = algebra::array::vector3<value_type>;
+
+    template <std::size_t ROWS, std::size_t COLS>
+    using matrix = algebra::array::matrix_type<value_type, ROWS, COLS>;
+};
+/// @}
+
+} // namespace plugin
+
 }  // namespace algebra
diff --git a/frontend/eigen_eigen/include/algebra/eigen_eigen.hpp b/frontend/eigen_eigen/include/algebra/eigen_eigen.hpp
index fc9c52a1..fbdf31c7 100644
--- a/frontend/eigen_eigen/include/algebra/eigen_eigen.hpp
+++ b/frontend/eigen_eigen/include/algebra/eigen_eigen.hpp
@@ -80,4 +80,31 @@ using transform3 = math::transform3<T>;
 
 }  // namespace eigen
 
+namespace plugin {
+
+/// Define the plugin types
+/// @{
+template <typename V>
+struct eigen {
+    /// Define scalar type
+    using value_type = V;
+
+    template <typename T>
+    using simd = T;
+
+    using boolean = bool;
+    using scalar = value_type;
+    using size_type = algebra::eigen::size_type;
+    using transform3D = algebra::eigen::transform3<value_type>;
+    using point2D = algebra::eigen::point2<value_type>;
+    using point3D = algebra::eigen::point3<value_type>;
+    using vector3D = algebra::eigen::vector3<value_type>;
+
+    template <std::size_t ROWS, std::size_t COLS>
+    using matrix = algebra::eigen::matrix_type<value_type, ROWS, COLS>;
+};
+/// @}
+
+} // namespace plugin
+
 }  // namespace algebra
diff --git a/frontend/eigen_generic/include/algebra/eigen_generic.hpp b/frontend/eigen_generic/include/algebra/eigen_generic.hpp
index b7f37321..4eb0eb7f 100644
--- a/frontend/eigen_generic/include/algebra/eigen_generic.hpp
+++ b/frontend/eigen_generic/include/algebra/eigen_generic.hpp
@@ -93,4 +93,31 @@ using transform3 =
 
 }  // namespace eigen
 
+namespace plugin {
+
+/// Define the plugin types
+/// @{
+template <typename V>
+struct eigen_generic {
+    /// Define scalar type
+    using value_type = V;
+
+    template <typename T>
+    using simd = T;
+
+    using boolean = bool;
+    using scalar = value_type;
+    using size_type = algebra::eigen::size_type;
+    using transform3D = algebra::eigen::transform3<value_type>;
+    using point2D = algebra::eigen::point2<value_type>;
+    using point3D = algebra::eigen::point3<value_type>;
+    using vector3D = algebra::eigen::vector3<value_type>;
+
+    template <std::size_t ROWS, std::size_t COLS>
+    using matrix = algebra::eigen::matrix_type<value_type, ROWS, COLS>;
+};
+/// @}
+
+} // namespace plugin
+
 }  // namespace algebra
diff --git a/frontend/fastor_fastor/include/algebra/fastor_fastor.hpp b/frontend/fastor_fastor/include/algebra/fastor_fastor.hpp
index 122430da..088189a3 100644
--- a/frontend/fastor_fastor/include/algebra/fastor_fastor.hpp
+++ b/frontend/fastor_fastor/include/algebra/fastor_fastor.hpp
@@ -87,4 +87,31 @@ using transform3 = math::transform3<T>;
 
 }  // namespace fastor
 
+namespace plugin {
+
+/// Define the plugin types
+/// @{
+template <typename V>
+struct fastor {
+    /// Define scalar type
+    using value_type = V;
+
+    template <typename T>
+    using simd = T;
+
+    using boolean = bool;
+    using scalar = value_type;
+    using size_type = algebra::fastor::size_type;
+    using transform3D = algebra::fastor::transform3<value_type>;
+    using point2D = algebra::fastor::point2<value_type>;
+    using point3D = algebra::fastor::point3<value_type>;
+    using vector3D = algebra::fastor::vector3<value_type>;
+
+    template <std::size_t ROWS, std::size_t COLS>
+    using matrix = algebra::fastor::matrix_type<value_type, ROWS, COLS>;
+};
+/// @}
+
+} // namespace plugin
+
 }  // namespace algebra
diff --git a/frontend/smatrix_generic/include/algebra/smatrix_generic.hpp b/frontend/smatrix_generic/include/algebra/smatrix_generic.hpp
index 65436f3d..162b0579 100644
--- a/frontend/smatrix_generic/include/algebra/smatrix_generic.hpp
+++ b/frontend/smatrix_generic/include/algebra/smatrix_generic.hpp
@@ -84,4 +84,31 @@ using transform3 =
 
 }  // namespace smatrix
 
+namespace plugin {
+
+/// Define the plugin types
+/// @{
+template <typename V>
+struct smatrix_generic {
+    /// Define scalar type
+    using value_type = V;
+
+    template <typename T>
+    using simd = T;
+
+    using boolean = bool;
+    using scalar = value_type;
+    using size_type = algebra::smatrix::size_type;
+    using transform3D = algebra::smatrix::transform3<value_type>;
+    using point2D = algebra::smatrix::point2<value_type>;
+    using point3D = algebra::smatrix::point3<value_type>;
+    using vector3D = algebra::smatrix::vector3<value_type>;
+
+    template <std::size_t ROWS, std::size_t COLS>
+    using matrix = algebra::smatrix::matrix_type<value_type, ROWS, COLS>;
+};
+/// @}
+
+} // namespace plugin
+
 }  // namespace algebra
diff --git a/frontend/smatrix_smatrix/include/algebra/smatrix_smatrix.hpp b/frontend/smatrix_smatrix/include/algebra/smatrix_smatrix.hpp
index c1c243c4..456a4bf1 100644
--- a/frontend/smatrix_smatrix/include/algebra/smatrix_smatrix.hpp
+++ b/frontend/smatrix_smatrix/include/algebra/smatrix_smatrix.hpp
@@ -78,4 +78,31 @@ using transform3 = math::transform3<T>;
 
 }  // namespace smatrix
 
+namespace plugin {
+
+/// Define the plugin types
+/// @{
+template <typename V>
+struct smatrix {
+    /// Define scalar type
+    using value_type = V;
+
+    template <typename T>
+    using simd = T;
+
+    using boolean = bool;
+    using scalar = value_type;
+    using size_type = algebra::smatrix::size_type;
+    using transform3D = algebra::smatrix::transform3<value_type>;
+    using point2D = algebra::smatrix::point2<value_type>;
+    using point3D = algebra::smatrix::point3<value_type>;
+    using vector3D = algebra::smatrix::vector3<value_type>;
+
+    template <std::size_t ROWS, std::size_t COLS>
+    using matrix = algebra::smatrix::matrix_type<value_type, ROWS, COLS>;
+};
+/// @}
+
+} // namespace plugin
+
 }  // namespace algebra
diff --git a/frontend/vc_aos/include/algebra/vc_aos.hpp b/frontend/vc_aos/include/algebra/vc_aos.hpp
index 473b58e1..da7112cf 100644
--- a/frontend/vc_aos/include/algebra/vc_aos.hpp
+++ b/frontend/vc_aos/include/algebra/vc_aos.hpp
@@ -83,4 +83,31 @@ using transform3 = math::transform3<vc_aos::storage_type, T>;
 
 }  // namespace vc_aos
 
+namespace plugin {
+
+/// Define the plugin types
+/// @{
+template <typename V>
+struct vc_aos {
+    /// Define scalar type
+    using value_type = V;
+
+    template <typename T>
+    using simd = T;
+
+    using boolean = bool;
+    using scalar = value_type;
+    using size_type = algebra::vc_aos::size_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>;
+    using vector3D = algebra::vc_aos::vector3<value_type>;
+
+    template <std::size_t ROWS, std::size_t COLS>
+    using matrix = algebra::vc_aos::matrix_type<value_type, ROWS, COLS>;
+};
+/// @}
+
+} // namespace plugin
+
 }  // namespace algebra
diff --git a/frontend/vc_aos_generic/include/algebra/vc_aos_generic.hpp b/frontend/vc_aos_generic/include/algebra/vc_aos_generic.hpp
index 3f8811e3..6e320848 100644
--- a/frontend/vc_aos_generic/include/algebra/vc_aos_generic.hpp
+++ b/frontend/vc_aos_generic/include/algebra/vc_aos_generic.hpp
@@ -92,4 +92,31 @@ using transform3 =
 
 }  // namespace vc_aos
 
+namespace plugin {
+
+/// Define the plugin types
+/// @{
+template <typename V>
+struct vc_aos_generic {
+    /// Define scalar type
+    using value_type = V;
+
+    template <typename T>
+    using simd = T;
+
+    using boolean = bool;
+    using scalar = value_type;
+    using size_type = algebra::vc_aos::size_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>;
+    using vector3D = algebra::vc_aos::vector3<value_type>;
+
+    template <std::size_t ROWS, std::size_t COLS>
+    using matrix = algebra::vc_aos::matrix_type<value_type, ROWS, COLS>;
+};
+/// @}
+
+} // namespace plugin
+
 }  // namespace algebra
diff --git a/frontend/vc_soa/include/algebra/vc_soa.hpp b/frontend/vc_soa/include/algebra/vc_soa.hpp
index aed5e83c..da218d24 100644
--- a/frontend/vc_soa/include/algebra/vc_soa.hpp
+++ b/frontend/vc_soa/include/algebra/vc_soa.hpp
@@ -84,10 +84,42 @@ namespace vc_soa {
 
 template <concepts::value T>
 using transform3 =
-    algebra::vc_aos::math::transform3<algebra::vc_soa::storage_type, T>;
+    algebra::vc_aos::math::transform3<algebra::vc_soa::storage_type,
+                                      Vc::Vector<T>>;
 
 /// @}
 
 }  // namespace vc_soa
 
+namespace plugin {
+
+/// Define the plugin types
+/// @{
+template <typename V>
+struct vc_soa {
+  /// Define scalar precision
+  using value_type = V;
+
+  template <typename T>
+  using simd = Vc::Vector<T>;
+
+  using boolean = Vc::Mask<V>;
+
+  /// Linear Algebra type definitions
+  /// @{
+  using scalar = simd<value_type>;
+  using size_type = algebra::vc_soa::size_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>;
+  using vector3D = algebra::vc_soa::vector3<value_type>;
+
+  template <std::size_t ROWS, std::size_t COLS>
+  using matrix = algebra::vc_soa::matrix_type<value_type, ROWS, COLS>;
+  /// @}
+};
+/// @}
+
+}  // namespace plugin
+
 }  // namespace algebra
diff --git a/frontend/vecmem_cmath/include/algebra/vecmem_cmath.hpp b/frontend/vecmem_cmath/include/algebra/vecmem_cmath.hpp
index 5cf46599..a8c6e9ee 100644
--- a/frontend/vecmem_cmath/include/algebra/vecmem_cmath.hpp
+++ b/frontend/vecmem_cmath/include/algebra/vecmem_cmath.hpp
@@ -114,4 +114,31 @@ using transform3 =
 
 }  // namespace vecmem
 
+namespace plugin {
+
+/// Define the plugin types
+/// @{
+template <typename V>
+struct vecmem {
+    /// Define scalar type
+    using value_type = V;
+
+    template <typename T>
+    using simd = T;
+
+    using boolean = bool;
+    using scalar = value_type;
+    using size_type = algebra::vecmem::size_type;
+    using transform3D = algebra::vecmem::transform3<value_type>;
+    using point2D = algebra::vecmem::point2<value_type>;
+    using point3D = algebra::vecmem::point3<value_type>;
+    using vector3D = algebra::vecmem::vector3<value_type>;
+
+    template <std::size_t ROWS, std::size_t COLS>
+    using matrix = algebra::vecmem::matrix_type<value_type, ROWS, COLS>;
+};
+/// @}
+
+} // namespace plugin
+
 }  // namespace algebra
diff --git a/math/vc_aos/include/algebra/math/impl/vc_aos_transform3.hpp b/math/vc_aos/include/algebra/math/impl/vc_aos_transform3.hpp
index 170fd41b..24baa9a6 100644
--- a/math/vc_aos/include/algebra/math/impl/vc_aos_transform3.hpp
+++ b/math/vc_aos/include/algebra/math/impl/vc_aos_transform3.hpp
@@ -36,7 +36,7 @@ using algebra::storage::operator+;
 
 /// Transform wrapper class to ensure standard API within differnt plugins
 template <template <typename, std::size_t> class array_t,
-          concepts::value value_t>
+          concepts::scalar scalar_t>
 struct transform3 {
 
  private:
@@ -53,11 +53,7 @@ struct transform3 {
   /// @{
 
   /// Scalar type used by the transform
-  using value_type = value_t;
-  /// The type of the matrix elements (scalar for AoS, Vc::Vector for SoA)
-  using scalar_type =
-      std::conditional_t<Vc::is_simd_vector<array_t<value_t, 4>>::value,
-                         value_t, Vc::Vector<value_t>>;
+  using scalar_type = scalar_t;
 
   template <std::size_t N>
   using array_type = array_t<scalar_type, N>;
diff --git a/storage/vc_aos/include/algebra/storage/impl/vc_aos_getter.hpp b/storage/vc_aos/include/algebra/storage/impl/vc_aos_getter.hpp
index 6076ae81..3bc7bbb2 100644
--- a/storage/vc_aos/include/algebra/storage/impl/vc_aos_getter.hpp
+++ b/storage/vc_aos/include/algebra/storage/impl/vc_aos_getter.hpp
@@ -22,7 +22,7 @@ using algebra::storage::set_block;
 template <std::size_t SIZE, std::size_t ROW, std::size_t COL,
           concepts::scalar scalar_t,
           template <typename, std::size_t> class array_t>
-ALGEBRA_HOST_DEVICE constexpr auto vector(
+ALGEBRA_HOST_DEVICE constexpr decltype(auto) vector(
     const algebra::storage::matrix<array_t, scalar_t, ROW, COL> &m,
     const std::size_t row, const std::size_t col) noexcept {
   return algebra::storage::block_getter{}.template vector<SIZE>(m, row, col);
diff --git a/storage/vc_soa/include/algebra/storage/vc_soa.hpp b/storage/vc_soa/include/algebra/storage/vc_soa.hpp
index 4612226d..bd648d1a 100644
--- a/storage/vc_soa/include/algebra/storage/vc_soa.hpp
+++ b/storage/vc_soa/include/algebra/storage/vc_soa.hpp
@@ -34,7 +34,7 @@ namespace vc_soa {
 /// Size type for Vc storage model
 using size_type = std::size_t;
 /// Array type used to store Vc::Vectors or matrix columns
-template <concepts::scalar T, size_type N>
+template <concepts::simd_scalar T, size_type N>
 using storage_type = std::array<T, N>;
 /// Value type in a linear algebra vector: SoA layout
 template <concepts::value T>
@@ -90,7 +90,7 @@ struct scalar<
 /// @}
 
 // Vector and storage types are different
-template <typename T, auto N>
+template <concepts::simd_scalar T, auto N>
 struct dimensions<vc_soa::storage_type<T, N>> {
 
   using size_type = vc_soa::size_type;