diff --git a/CMakeLists.txt b/CMakeLists.txt
index 61d880508..872154c3d 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -38,7 +38,7 @@ ${XSIMD_INCLUDE_DIR}/xsimd/arch/xsimd_fma3_avx.hpp
 ${XSIMD_INCLUDE_DIR}/xsimd/arch/xsimd_fma3_avx2.hpp
 ${XSIMD_INCLUDE_DIR}/xsimd/arch/xsimd_fma3_sse.hpp
 ${XSIMD_INCLUDE_DIR}/xsimd/arch/xsimd_fma4.hpp
-${XSIMD_INCLUDE_DIR}/xsimd/arch/xsimd_generic.hpp
+${XSIMD_INCLUDE_DIR}/xsimd/arch/xsimd_common.hpp
 ${XSIMD_INCLUDE_DIR}/xsimd/arch/xsimd_isa.hpp
 ${XSIMD_INCLUDE_DIR}/xsimd/arch/xsimd_neon.hpp
 ${XSIMD_INCLUDE_DIR}/xsimd/arch/xsimd_neon64.hpp
@@ -68,7 +68,7 @@ ${XSIMD_INCLUDE_DIR}/xsimd/types/xsimd_fma3_avx_register.hpp
 ${XSIMD_INCLUDE_DIR}/xsimd/types/xsimd_fma3_avx2_register.hpp
 ${XSIMD_INCLUDE_DIR}/xsimd/types/xsimd_fma3_sse_register.hpp
 ${XSIMD_INCLUDE_DIR}/xsimd/types/xsimd_fma4_register.hpp
-${XSIMD_INCLUDE_DIR}/xsimd/types/xsimd_generic_arch.hpp
+${XSIMD_INCLUDE_DIR}/xsimd/types/xsimd_common_arch.hpp
 ${XSIMD_INCLUDE_DIR}/xsimd/types/xsimd_register.hpp
 ${XSIMD_INCLUDE_DIR}/xsimd/types/xsimd_rvv_register.hpp
 ${XSIMD_INCLUDE_DIR}/xsimd/types/xsimd_sse2_register.hpp
diff --git a/docs/Doxyfile b/docs/Doxyfile
index b95ae599b..390baf223 100644
--- a/docs/Doxyfile
+++ b/docs/Doxyfile
@@ -7,7 +7,7 @@ INPUT             = ../include/xsimd/types/xsimd_api.hpp \
                     ../include/xsimd/config/xsimd_config.hpp \
                     ../include/xsimd/memory/xsimd_alignment.hpp \
                     ../include/xsimd/memory/xsimd_aligned_allocator.hpp \
-                    ../include/xsimd/types/xsimd_generic_arch.hpp \
+                    ../include/xsimd/types/xsimd_common_arch.hpp \
                     ../include/xsimd/types/xsimd_traits.hpp \
                     ../include/xsimd/types/xsimd_avx2_register.hpp \
                     ../include/xsimd/types/xsimd_avx512bw_register.hpp \
diff --git a/include/xsimd/arch/generic/xsimd_generic_arithmetic.hpp b/include/xsimd/arch/common/xsimd_common_arithmetic.hpp
similarity index 84%
rename from include/xsimd/arch/generic/xsimd_generic_arithmetic.hpp
rename to include/xsimd/arch/common/xsimd_common_arithmetic.hpp
index e7916b0d4..dba8c38ca 100644
--- a/include/xsimd/arch/generic/xsimd_generic_arithmetic.hpp
+++ b/include/xsimd/arch/common/xsimd_common_arithmetic.hpp
@@ -9,14 +9,14 @@
  * The full license is in the file LICENSE, distributed with this software. *
  ****************************************************************************/
 
-#ifndef XSIMD_GENERIC_ARITHMETIC_HPP
-#define XSIMD_GENERIC_ARITHMETIC_HPP
+#ifndef XSIMD_COMMON_ARITHMETIC_HPP
+#define XSIMD_COMMON_ARITHMETIC_HPP
 
 #include <complex>
 #include <limits>
 #include <type_traits>
 
-#include "./xsimd_generic_details.hpp"
+#include "./xsimd_common_details.hpp"
 
 namespace xsimd
 {
@@ -28,7 +28,7 @@ namespace xsimd
 
         // bitwise_lshift
         template <class A, class T, class /*=typename std::enable_if<std::is_integral<T>::value, void>::type*/>
-        XSIMD_INLINE batch<T, A> bitwise_lshift(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> bitwise_lshift(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept
         {
             return detail::apply([](T x, T y) noexcept
                                  { return x << y; },
@@ -37,7 +37,7 @@ namespace xsimd
 
         // bitwise_rshift
         template <class A, class T, class /*=typename std::enable_if<std::is_integral<T>::value, void>::type*/>
-        XSIMD_INLINE batch<T, A> bitwise_rshift(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> bitwise_rshift(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept
         {
             return detail::apply([](T x, T y) noexcept
                                  { return x >> y; },
@@ -46,21 +46,21 @@ namespace xsimd
 
         // decr
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> decr(batch<T, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> decr(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             return self - T(1);
         }
 
         // decr_if
         template <class A, class T, class Mask>
-        XSIMD_INLINE batch<T, A> decr_if(batch<T, A> const& self, Mask const& mask, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> decr_if(batch<T, A> const& self, Mask const& mask, requires_arch<common>) noexcept
         {
             return select(mask, decr(self), self);
         }
 
         // div
         template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
-        XSIMD_INLINE batch<T, A> div(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> div(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept
         {
             return detail::apply([](T x, T y) noexcept -> T
                                  { return x / y; },
@@ -69,13 +69,13 @@ namespace xsimd
 
         // fma
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> fma(batch<T, A> const& x, batch<T, A> const& y, batch<T, A> const& z, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> fma(batch<T, A> const& x, batch<T, A> const& y, batch<T, A> const& z, requires_arch<common>) noexcept
         {
             return x * y + z;
         }
 
         template <class A, class T>
-        XSIMD_INLINE batch<std::complex<T>, A> fma(batch<std::complex<T>, A> const& x, batch<std::complex<T>, A> const& y, batch<std::complex<T>, A> const& z, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<std::complex<T>, A> fma(batch<std::complex<T>, A> const& x, batch<std::complex<T>, A> const& y, batch<std::complex<T>, A> const& z, requires_arch<common>) noexcept
         {
             auto res_r = fms(x.real(), y.real(), fms(x.imag(), y.imag(), z.real()));
             auto res_i = fma(x.real(), y.imag(), fma(x.imag(), y.real(), z.imag()));
@@ -84,13 +84,13 @@ namespace xsimd
 
         // fms
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> fms(batch<T, A> const& x, batch<T, A> const& y, batch<T, A> const& z, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> fms(batch<T, A> const& x, batch<T, A> const& y, batch<T, A> const& z, requires_arch<common>) noexcept
         {
             return x * y - z;
         }
 
         template <class A, class T>
-        XSIMD_INLINE batch<std::complex<T>, A> fms(batch<std::complex<T>, A> const& x, batch<std::complex<T>, A> const& y, batch<std::complex<T>, A> const& z, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<std::complex<T>, A> fms(batch<std::complex<T>, A> const& x, batch<std::complex<T>, A> const& y, batch<std::complex<T>, A> const& z, requires_arch<common>) noexcept
         {
             auto res_r = fms(x.real(), y.real(), fma(x.imag(), y.imag(), z.real()));
             auto res_i = fma(x.real(), y.imag(), fms(x.imag(), y.real(), z.imag()));
@@ -99,13 +99,13 @@ namespace xsimd
 
         // fnma
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> fnma(batch<T, A> const& x, batch<T, A> const& y, batch<T, A> const& z, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> fnma(batch<T, A> const& x, batch<T, A> const& y, batch<T, A> const& z, requires_arch<common>) noexcept
         {
             return -x * y + z;
         }
 
         template <class A, class T>
-        XSIMD_INLINE batch<std::complex<T>, A> fnma(batch<std::complex<T>, A> const& x, batch<std::complex<T>, A> const& y, batch<std::complex<T>, A> const& z, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<std::complex<T>, A> fnma(batch<std::complex<T>, A> const& x, batch<std::complex<T>, A> const& y, batch<std::complex<T>, A> const& z, requires_arch<common>) noexcept
         {
             auto res_r = -fms(x.real(), y.real(), fma(x.imag(), y.imag(), z.real()));
             auto res_i = -fma(x.real(), y.imag(), fms(x.imag(), y.real(), z.imag()));
@@ -114,13 +114,13 @@ namespace xsimd
 
         // fnms
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> fnms(batch<T, A> const& x, batch<T, A> const& y, batch<T, A> const& z, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> fnms(batch<T, A> const& x, batch<T, A> const& y, batch<T, A> const& z, requires_arch<common>) noexcept
         {
             return -x * y - z;
         }
 
         template <class A, class T>
-        XSIMD_INLINE batch<std::complex<T>, A> fnms(batch<std::complex<T>, A> const& x, batch<std::complex<T>, A> const& y, batch<std::complex<T>, A> const& z, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<std::complex<T>, A> fnms(batch<std::complex<T>, A> const& x, batch<std::complex<T>, A> const& y, batch<std::complex<T>, A> const& z, requires_arch<common>) noexcept
         {
             auto res_r = -fms(x.real(), y.real(), fms(x.imag(), y.imag(), z.real()));
             auto res_i = -fma(x.real(), y.imag(), fma(x.imag(), y.real(), z.imag()));
@@ -129,7 +129,7 @@ namespace xsimd
 
         // hadd
         template <class A, class T, class /*=typename std::enable_if<std::is_integral<T>::value, void>::type*/>
-        XSIMD_INLINE T hadd(batch<T, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE T hadd(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             alignas(A::alignment()) T buffer[batch<T, A>::size];
             self.store_aligned(buffer);
@@ -143,21 +143,21 @@ namespace xsimd
 
         // incr
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> incr(batch<T, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> incr(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             return self + T(1);
         }
 
         // incr_if
         template <class A, class T, class Mask>
-        XSIMD_INLINE batch<T, A> incr_if(batch<T, A> const& self, Mask const& mask, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> incr_if(batch<T, A> const& self, Mask const& mask, requires_arch<common>) noexcept
         {
             return select(mask, incr(self), self);
         }
 
         // mul
         template <class A, class T, class /*=typename std::enable_if<std::is_integral<T>::value, void>::type*/>
-        XSIMD_INLINE batch<T, A> mul(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> mul(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept
         {
             return detail::apply([](T x, T y) noexcept -> T
                                  { return x * y; },
@@ -166,7 +166,7 @@ namespace xsimd
 
         // rotl
         template <class A, class T, class STy>
-        XSIMD_INLINE batch<T, A> rotl(batch<T, A> const& self, STy other, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> rotl(batch<T, A> const& self, STy other, requires_arch<common>) noexcept
         {
             constexpr auto N = std::numeric_limits<T>::digits;
             return (self << other) | (self >> (N - other));
@@ -174,7 +174,7 @@ namespace xsimd
 
         // rotr
         template <class A, class T, class STy>
-        XSIMD_INLINE batch<T, A> rotr(batch<T, A> const& self, STy other, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> rotr(batch<T, A> const& self, STy other, requires_arch<common>) noexcept
         {
             constexpr auto N = std::numeric_limits<T>::digits;
             return (self >> other) | (self << (N - other));
@@ -182,12 +182,12 @@ namespace xsimd
 
         // sadd
         template <class A>
-        XSIMD_INLINE batch<float, A> sadd(batch<float, A> const& self, batch<float, A> const& other, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<float, A> sadd(batch<float, A> const& self, batch<float, A> const& other, requires_arch<common>) noexcept
         {
             return add(self, other); // no saturated arithmetic on floating point numbers
         }
         template <class A, class T, class /*=typename std::enable_if<std::is_integral<T>::value, void>::type*/>
-        XSIMD_INLINE batch<T, A> sadd(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> sadd(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept
         {
             if (std::is_signed<T>::value)
             {
@@ -204,19 +204,19 @@ namespace xsimd
             }
         }
         template <class A>
-        XSIMD_INLINE batch<double, A> sadd(batch<double, A> const& self, batch<double, A> const& other, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<double, A> sadd(batch<double, A> const& self, batch<double, A> const& other, requires_arch<common>) noexcept
         {
             return add(self, other); // no saturated arithmetic on floating point numbers
         }
 
         // ssub
         template <class A>
-        XSIMD_INLINE batch<float, A> ssub(batch<float, A> const& self, batch<float, A> const& other, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<float, A> ssub(batch<float, A> const& self, batch<float, A> const& other, requires_arch<common>) noexcept
         {
             return sub(self, other); // no saturated arithmetic on floating point numbers
         }
         template <class A, class T, class /*=typename std::enable_if<std::is_integral<T>::value, void>::type*/>
-        XSIMD_INLINE batch<T, A> ssub(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> ssub(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept
         {
             if (std::is_signed<T>::value)
             {
@@ -229,7 +229,7 @@ namespace xsimd
             }
         }
         template <class A>
-        XSIMD_INLINE batch<double, A> ssub(batch<double, A> const& self, batch<double, A> const& other, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<double, A> ssub(batch<double, A> const& self, batch<double, A> const& other, requires_arch<common>) noexcept
         {
             return sub(self, other); // no saturated arithmetic on floating point numbers
         }
diff --git a/include/xsimd/arch/generic/xsimd_generic_complex.hpp b/include/xsimd/arch/common/xsimd_common_complex.hpp
similarity index 84%
rename from include/xsimd/arch/generic/xsimd_generic_complex.hpp
rename to include/xsimd/arch/common/xsimd_common_complex.hpp
index 812c592ae..1283aecca 100644
--- a/include/xsimd/arch/generic/xsimd_generic_complex.hpp
+++ b/include/xsimd/arch/common/xsimd_common_complex.hpp
@@ -9,12 +9,12 @@
  * The full license is in the file LICENSE, distributed with this software. *
  ****************************************************************************/
 
-#ifndef XSIMD_GENERIC_COMPLEX_HPP
-#define XSIMD_GENERIC_COMPLEX_HPP
+#ifndef XSIMD_COMMON_COMPLEX_HPP
+#define XSIMD_COMMON_COMPLEX_HPP
 
 #include <complex>
 
-#include "./xsimd_generic_details.hpp"
+#include "./xsimd_common_details.hpp"
 
 namespace xsimd
 {
@@ -26,54 +26,54 @@ namespace xsimd
 
         // real
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> real(batch<T, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> real(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             return self;
         }
 
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> real(batch<std::complex<T>, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> real(batch<std::complex<T>, A> const& self, requires_arch<common>) noexcept
         {
             return self.real();
         }
 
         // imag
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> imag(batch<T, A> const& /*self*/, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> imag(batch<T, A> const& /*self*/, requires_arch<common>) noexcept
         {
             return batch<T, A>(T(0));
         }
 
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> imag(batch<std::complex<T>, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> imag(batch<std::complex<T>, A> const& self, requires_arch<common>) noexcept
         {
             return self.imag();
         }
 
         // arg
         template <class A, class T>
-        XSIMD_INLINE real_batch_type_t<batch<T, A>> arg(batch<T, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE real_batch_type_t<batch<T, A>> arg(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             return atan2(imag(self), real(self));
         }
 
         // conj
         template <class A, class T>
-        XSIMD_INLINE complex_batch_type_t<batch<T, A>> conj(batch<T, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE complex_batch_type_t<batch<T, A>> conj(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             return { real(self), -imag(self) };
         }
 
         // norm
         template <class A, class T>
-        XSIMD_INLINE real_batch_type_t<batch<T, A>> norm(batch<T, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE real_batch_type_t<batch<T, A>> norm(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             return { fma(real(self), real(self), imag(self) * imag(self)) };
         }
 
         // proj
         template <class A, class T>
-        XSIMD_INLINE complex_batch_type_t<batch<T, A>> proj(batch<T, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE complex_batch_type_t<batch<T, A>> proj(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             using batch_type = complex_batch_type_t<batch<T, A>>;
             using real_batch = typename batch_type::real_batch;
@@ -86,19 +86,19 @@ namespace xsimd
         }
 
         template <class A, class T>
-        XSIMD_INLINE batch_bool<T, A> isnan(batch<std::complex<T>, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch_bool<T, A> isnan(batch<std::complex<T>, A> const& self, requires_arch<common>) noexcept
         {
             return batch_bool<T, A>(isnan(self.real()) || isnan(self.imag()));
         }
 
         template <class A, class T>
-        XSIMD_INLINE batch_bool<T, A> isinf(batch<std::complex<T>, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch_bool<T, A> isinf(batch<std::complex<T>, A> const& self, requires_arch<common>) noexcept
         {
             return batch_bool<T, A>(isinf(self.real()) || isinf(self.imag()));
         }
 
         template <class A, class T>
-        XSIMD_INLINE batch_bool<T, A> isfinite(batch<std::complex<T>, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch_bool<T, A> isfinite(batch<std::complex<T>, A> const& self, requires_arch<common>) noexcept
         {
             return batch_bool<T, A>(isfinite(self.real()) && isfinite(self.imag()));
         }
diff --git a/include/xsimd/arch/generic/xsimd_generic_details.hpp b/include/xsimd/arch/common/xsimd_common_details.hpp
similarity index 92%
rename from include/xsimd/arch/generic/xsimd_generic_details.hpp
rename to include/xsimd/arch/common/xsimd_common_details.hpp
index a9af608c8..0a8abc419 100644
--- a/include/xsimd/arch/generic/xsimd_generic_details.hpp
+++ b/include/xsimd/arch/common/xsimd_common_details.hpp
@@ -9,13 +9,13 @@
  * The full license is in the file LICENSE, distributed with this software. *
  ****************************************************************************/
 
-#ifndef XSIMD_GENERIC_DETAILS_HPP
-#define XSIMD_GENERIC_DETAILS_HPP
+#ifndef XSIMD_COMMON_DETAILS_HPP
+#define XSIMD_COMMON_DETAILS_HPP
 
 #include <complex>
 
 #include "../../math/xsimd_rem_pio2.hpp"
-#include "../../types/xsimd_generic_arch.hpp"
+#include "../../types/xsimd_common_arch.hpp"
 #include "../../types/xsimd_utils.hpp"
 #include "../xsimd_constants.hpp"
 
@@ -137,54 +137,54 @@ namespace xsimd
             }
         }
 
-        // some generic fast_cast conversion
+        // some common fast_cast conversion
         namespace detail
         {
             template <class A>
-            XSIMD_INLINE batch<uint8_t, A> fast_cast(batch<int8_t, A> const& self, batch<uint8_t, A> const&, requires_arch<generic>) noexcept
+            XSIMD_INLINE batch<uint8_t, A> fast_cast(batch<int8_t, A> const& self, batch<uint8_t, A> const&, requires_arch<common>) noexcept
             {
                 return bitwise_cast<uint8_t>(self);
             }
             template <class A>
-            XSIMD_INLINE batch<uint16_t, A> fast_cast(batch<int16_t, A> const& self, batch<uint16_t, A> const&, requires_arch<generic>) noexcept
+            XSIMD_INLINE batch<uint16_t, A> fast_cast(batch<int16_t, A> const& self, batch<uint16_t, A> const&, requires_arch<common>) noexcept
             {
                 return bitwise_cast<uint16_t>(self);
             }
             template <class A>
-            XSIMD_INLINE batch<uint32_t, A> fast_cast(batch<int32_t, A> const& self, batch<uint32_t, A> const&, requires_arch<generic>) noexcept
+            XSIMD_INLINE batch<uint32_t, A> fast_cast(batch<int32_t, A> const& self, batch<uint32_t, A> const&, requires_arch<common>) noexcept
             {
                 return bitwise_cast<uint32_t>(self);
             }
             template <class A>
-            XSIMD_INLINE batch<uint64_t, A> fast_cast(batch<int64_t, A> const& self, batch<uint64_t, A> const&, requires_arch<generic>) noexcept
+            XSIMD_INLINE batch<uint64_t, A> fast_cast(batch<int64_t, A> const& self, batch<uint64_t, A> const&, requires_arch<common>) noexcept
             {
                 return bitwise_cast<uint64_t>(self);
             }
             template <class A>
-            XSIMD_INLINE batch<int8_t, A> fast_cast(batch<uint8_t, A> const& self, batch<int8_t, A> const&, requires_arch<generic>) noexcept
+            XSIMD_INLINE batch<int8_t, A> fast_cast(batch<uint8_t, A> const& self, batch<int8_t, A> const&, requires_arch<common>) noexcept
             {
                 return bitwise_cast<int8_t>(self);
             }
             template <class A>
-            XSIMD_INLINE batch<int16_t, A> fast_cast(batch<uint16_t, A> const& self, batch<int16_t, A> const&, requires_arch<generic>) noexcept
+            XSIMD_INLINE batch<int16_t, A> fast_cast(batch<uint16_t, A> const& self, batch<int16_t, A> const&, requires_arch<common>) noexcept
             {
                 return bitwise_cast<int16_t>(self);
             }
             template <class A>
-            XSIMD_INLINE batch<int32_t, A> fast_cast(batch<uint32_t, A> const& self, batch<int32_t, A> const&, requires_arch<generic>) noexcept
+            XSIMD_INLINE batch<int32_t, A> fast_cast(batch<uint32_t, A> const& self, batch<int32_t, A> const&, requires_arch<common>) noexcept
             {
                 return bitwise_cast<int32_t>(self);
             }
             template <class A>
-            XSIMD_INLINE batch<int64_t, A> fast_cast(batch<uint64_t, A> const& self, batch<int64_t, A> const&, requires_arch<generic>) noexcept
+            XSIMD_INLINE batch<int64_t, A> fast_cast(batch<uint64_t, A> const& self, batch<int64_t, A> const&, requires_arch<common>) noexcept
             {
                 return bitwise_cast<int64_t>(self);
             }
 
-            // Provide a generic uint32_t -> float cast only if we have a
-            // non-generic int32_t -> float fast_cast
+            // Provide a common uint32_t -> float cast only if we have a
+            // non-common int32_t -> float fast_cast
             template <class A, class _ = decltype(fast_cast(std::declval<batch<int32_t, A> const&>(), std::declval<batch<float, A> const&>(), A {}))>
-            XSIMD_INLINE batch<float, A> fast_cast(batch<uint32_t, A> const& v, batch<float, A> const&, requires_arch<generic>) noexcept
+            XSIMD_INLINE batch<float, A> fast_cast(batch<uint32_t, A> const& v, batch<float, A> const&, requires_arch<common>) noexcept
             {
                 // see https://stackoverflow.com/questions/34066228/how-to-perform-uint32-float-conversion-with-sse
                 batch<uint32_t, A> msk_lo(0xFFFF);
@@ -198,10 +198,10 @@ namespace xsimd
                 return v_hi_flt + v_lo_flt; /* Rounding may occur here, mul and add may fuse to fma for haswell and newer   */
             }
 
-            // Provide a generic float -> uint32_t cast only if we have a
-            // non-generic float -> int32_t fast_cast
+            // Provide a common float -> uint32_t cast only if we have a
+            // non-common float -> int32_t fast_cast
             template <class A, class _ = decltype(fast_cast(std::declval<batch<float, A> const&>(), std::declval<batch<int32_t, A> const&>(), A {}))>
-            XSIMD_INLINE batch<uint32_t, A> fast_cast(batch<float, A> const& v, batch<uint32_t, A> const&, requires_arch<generic>) noexcept
+            XSIMD_INLINE batch<uint32_t, A> fast_cast(batch<float, A> const& v, batch<uint32_t, A> const&, requires_arch<common>) noexcept
             {
                 auto is_large = v >= batch<float, A>(1u << 31);
                 auto small_v = bitwise_cast<float>(batch_cast<int32_t>(v));
diff --git a/include/xsimd/arch/generic/xsimd_generic_logical.hpp b/include/xsimd/arch/common/xsimd_common_logical.hpp
similarity index 87%
rename from include/xsimd/arch/generic/xsimd_generic_logical.hpp
rename to include/xsimd/arch/common/xsimd_common_logical.hpp
index 4f5dd8e4b..7640c2841 100644
--- a/include/xsimd/arch/generic/xsimd_generic_logical.hpp
+++ b/include/xsimd/arch/common/xsimd_common_logical.hpp
@@ -9,10 +9,10 @@
  * The full license is in the file LICENSE, distributed with this software. *
  ****************************************************************************/
 
-#ifndef XSIMD_GENERIC_LOGICAL_HPP
-#define XSIMD_GENERIC_LOGICAL_HPP
+#ifndef XSIMD_COMMON_LOGICAL_HPP
+#define XSIMD_COMMON_LOGICAL_HPP
 
-#include "./xsimd_generic_details.hpp"
+#include "./xsimd_common_details.hpp"
 
 #include <climits>
 
@@ -26,7 +26,7 @@ namespace xsimd
 
         // count
         template <class A, class T>
-        XSIMD_INLINE size_t count(batch_bool<T, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE size_t count(batch_bool<T, A> const& self, requires_arch<common>) noexcept
         {
             uint64_t m = self.mask();
             XSIMD_IF_CONSTEXPR(batch_bool<T, A>::size < 14)
@@ -69,7 +69,7 @@ namespace xsimd
 
         // from  mask
         template <class A, class T>
-        XSIMD_INLINE batch_bool<T, A> from_mask(batch_bool<T, A> const&, uint64_t mask, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch_bool<T, A> from_mask(batch_bool<T, A> const&, uint64_t mask, requires_arch<common>) noexcept
         {
             alignas(A::alignment()) bool buffer[batch_bool<T, A>::size];
             // This is inefficient but should never be called. It's just a
@@ -81,28 +81,28 @@ namespace xsimd
 
         // ge
         template <class A, class T>
-        XSIMD_INLINE batch_bool<T, A> ge(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch_bool<T, A> ge(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept
         {
             return other <= self;
         }
 
         // gt
         template <class A, class T>
-        XSIMD_INLINE batch_bool<T, A> gt(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch_bool<T, A> gt(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept
         {
             return other < self;
         }
 
         // is_even
         template <class A, class T>
-        XSIMD_INLINE batch_bool<T, A> is_even(batch<T, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch_bool<T, A> is_even(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             return is_flint(self * T(0.5));
         }
 
         // is_flint
         template <class A, class T>
-        XSIMD_INLINE batch_bool<T, A> is_flint(batch<T, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch_bool<T, A> is_flint(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             auto frac = select(isnan(self - self), constants::nan<batch<T, A>>(), self - trunc(self));
             return frac == T(0.);
@@ -110,69 +110,69 @@ namespace xsimd
 
         // is_odd
         template <class A, class T>
-        XSIMD_INLINE batch_bool<T, A> is_odd(batch<T, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch_bool<T, A> is_odd(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             return is_even(self - T(1.));
         }
 
         // isinf
         template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
-        XSIMD_INLINE batch_bool<T, A> isinf(batch<T, A> const&, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch_bool<T, A> isinf(batch<T, A> const&, requires_arch<common>) noexcept
         {
             return batch_bool<T, A>(false);
         }
         template <class A>
-        XSIMD_INLINE batch_bool<float, A> isinf(batch<float, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch_bool<float, A> isinf(batch<float, A> const& self, requires_arch<common>) noexcept
         {
             return abs(self) == std::numeric_limits<float>::infinity();
         }
         template <class A>
-        XSIMD_INLINE batch_bool<double, A> isinf(batch<double, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch_bool<double, A> isinf(batch<double, A> const& self, requires_arch<common>) noexcept
         {
             return abs(self) == std::numeric_limits<double>::infinity();
         }
 
         // isfinite
         template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
-        XSIMD_INLINE batch_bool<T, A> isfinite(batch<T, A> const&, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch_bool<T, A> isfinite(batch<T, A> const&, requires_arch<common>) noexcept
         {
             return batch_bool<T, A>(true);
         }
         template <class A>
-        XSIMD_INLINE batch_bool<float, A> isfinite(batch<float, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch_bool<float, A> isfinite(batch<float, A> const& self, requires_arch<common>) noexcept
         {
             return (self - self) == 0.f;
         }
         template <class A>
-        XSIMD_INLINE batch_bool<double, A> isfinite(batch<double, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch_bool<double, A> isfinite(batch<double, A> const& self, requires_arch<common>) noexcept
         {
             return (self - self) == 0.;
         }
 
         // isnan
         template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
-        XSIMD_INLINE batch_bool<T, A> isnan(batch<T, A> const&, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch_bool<T, A> isnan(batch<T, A> const&, requires_arch<common>) noexcept
         {
             return batch_bool<T, A>(false);
         }
 
         // le
         template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
-        XSIMD_INLINE batch_bool<T, A> le(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch_bool<T, A> le(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept
         {
             return (self < other) || (self == other);
         }
 
         // neq
         template <class A, class T>
-        XSIMD_INLINE batch_bool<T, A> neq(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch_bool<T, A> neq(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept
         {
             return !(other == self);
         }
 
         // logical_and
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> logical_and(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> logical_and(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept
         {
             return detail::apply([](T x, T y) noexcept
                                  { return x && y; },
@@ -181,7 +181,7 @@ namespace xsimd
 
         // logical_or
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> logical_or(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> logical_or(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept
         {
             return detail::apply([](T x, T y) noexcept
                                  { return x || y; },
@@ -190,7 +190,7 @@ namespace xsimd
 
         // mask
         template <class A, class T>
-        XSIMD_INLINE uint64_t mask(batch_bool<T, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE uint64_t mask(batch_bool<T, A> const& self, requires_arch<common>) noexcept
         {
             alignas(A::alignment()) bool buffer[batch_bool<T, A>::size];
             self.store_aligned(buffer);
diff --git a/include/xsimd/arch/generic/xsimd_generic_math.hpp b/include/xsimd/arch/common/xsimd_common_math.hpp
similarity index 96%
rename from include/xsimd/arch/generic/xsimd_generic_math.hpp
rename to include/xsimd/arch/common/xsimd_common_math.hpp
index 4dc9c3878..71dc75787 100644
--- a/include/xsimd/arch/generic/xsimd_generic_math.hpp
+++ b/include/xsimd/arch/common/xsimd_common_math.hpp
@@ -9,12 +9,12 @@
  * The full license is in the file LICENSE, distributed with this software. *
  ****************************************************************************/
 
-#ifndef XSIMD_GENERIC_MATH_HPP
-#define XSIMD_GENERIC_MATH_HPP
+#ifndef XSIMD_COMMON_MATH_HPP
+#define XSIMD_COMMON_MATH_HPP
 
 #include "../xsimd_scalar.hpp"
-#include "./xsimd_generic_details.hpp"
-#include "./xsimd_generic_trigo.hpp"
+#include "./xsimd_common_details.hpp"
+#include "./xsimd_common_trigo.hpp"
 
 #include <type_traits>
 
@@ -27,7 +27,7 @@ namespace xsimd
         using namespace types;
         // abs
         template <class A, class T, class>
-        XSIMD_INLINE batch<T, A> abs(batch<T, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> abs(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             if (std::is_unsigned<T>::value)
                 return self;
@@ -40,7 +40,7 @@ namespace xsimd
         }
 
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> abs(batch<std::complex<T>, A> const& z, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> abs(batch<std::complex<T>, A> const& z, requires_arch<common>) noexcept
         {
             return hypot(z.real(), z.imag());
         }
@@ -73,7 +73,7 @@ namespace xsimd
         }
 
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> avg(batch<T, A> const& x, batch<T, A> const& y, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> avg(batch<T, A> const& x, batch<T, A> const& y, requires_arch<common>) noexcept
         {
             return detail::avg(x, y, typename std::is_integral<T>::type {}, typename std::is_signed<T>::type {});
         }
@@ -97,14 +97,14 @@ namespace xsimd
         }
 
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> avgr(batch<T, A> const& x, batch<T, A> const& y, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> avgr(batch<T, A> const& x, batch<T, A> const& y, requires_arch<common>) noexcept
         {
             return detail::avgr(x, y, typename std::is_integral<T>::type {});
         }
 
         // batch_cast
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> batch_cast(batch<T, A> const& self, batch<T, A> const&, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> batch_cast(batch<T, A> const& self, batch<T, A> const&, requires_arch<common>) noexcept
         {
             return self;
         }
@@ -112,12 +112,12 @@ namespace xsimd
         namespace detail
         {
             template <class A, class T_out, class T_in>
-            XSIMD_INLINE batch<T_out, A> batch_cast(batch<T_in, A> const& self, batch<T_out, A> const& out, requires_arch<generic>, with_fast_conversion) noexcept
+            XSIMD_INLINE batch<T_out, A> batch_cast(batch<T_in, A> const& self, batch<T_out, A> const& out, requires_arch<common>, with_fast_conversion) noexcept
             {
                 return fast_cast(self, out, A {});
             }
             template <class A, class T_out, class T_in>
-            XSIMD_INLINE batch<T_out, A> batch_cast(batch<T_in, A> const& self, batch<T_out, A> const&, requires_arch<generic>, with_slow_conversion) noexcept
+            XSIMD_INLINE batch<T_out, A> batch_cast(batch<T_in, A> const& self, batch<T_out, A> const&, requires_arch<common>, with_slow_conversion) noexcept
             {
                 static_assert(!std::is_same<T_in, T_out>::value, "there should be no conversion for this type combination");
                 using batch_type_in = batch<T_in, A>;
@@ -133,14 +133,14 @@ namespace xsimd
         }
 
         template <class A, class T_out, class T_in>
-        XSIMD_INLINE batch<T_out, A> batch_cast(batch<T_in, A> const& self, batch<T_out, A> const& out, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T_out, A> batch_cast(batch<T_in, A> const& self, batch<T_out, A> const& out, requires_arch<common>) noexcept
         {
             return detail::batch_cast(self, out, A {}, detail::conversion_type<A, T_in, T_out> {});
         }
 
         // bitofsign
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> bitofsign(batch<T, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> bitofsign(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             static_assert(std::is_integral<T>::value, "int type implementation");
             if (std::is_unsigned<T>::value)
@@ -150,19 +150,19 @@ namespace xsimd
         }
 
         template <class A>
-        XSIMD_INLINE batch<float, A> bitofsign(batch<float, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<float, A> bitofsign(batch<float, A> const& self, requires_arch<common>) noexcept
         {
             return self & constants::signmask<batch<float, A>>();
         }
         template <class A>
-        XSIMD_INLINE batch<double, A> bitofsign(batch<double, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<double, A> bitofsign(batch<double, A> const& self, requires_arch<common>) noexcept
         {
             return self & constants::signmask<batch<double, A>>();
         }
 
         // bitwise_cast
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> bitwise_cast(batch<T, A> const& self, batch<T, A> const&, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> bitwise_cast(batch<T, A> const& self, batch<T, A> const&, requires_arch<common>) noexcept
         {
             return self;
         }
@@ -178,7 +178,7 @@ namespace xsimd
          * ====================================================
          */
         template <class A>
-        XSIMD_INLINE batch<float, A> cbrt(batch<float, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<float, A> cbrt(batch<float, A> const& self, requires_arch<common>) noexcept
         {
             using batch_type = batch<float, A>;
             batch_type z = abs(self);
@@ -225,7 +225,7 @@ namespace xsimd
         }
 
         template <class A>
-        XSIMD_INLINE batch<double, A> cbrt(batch<double, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<double, A> cbrt(batch<double, A> const& self, requires_arch<common>) noexcept
         {
             using batch_type = batch<double, A>;
             batch_type z = abs(self);
@@ -274,14 +274,14 @@ namespace xsimd
 
         // clip
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> clip(batch<T, A> const& self, batch<T, A> const& lo, batch<T, A> const& hi, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> clip(batch<T, A> const& self, batch<T, A> const& lo, batch<T, A> const& hi, requires_arch<common>) noexcept
         {
             return min(hi, max(self, lo));
         }
 
         // copysign
         template <class A, class T, class _ = typename std::enable_if<std::is_floating_point<T>::value, void>::type>
-        XSIMD_INLINE batch<T, A> copysign(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> copysign(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept
         {
             return abs(self) | bitofsign(other);
         }
@@ -290,7 +290,7 @@ namespace xsimd
 
         namespace detail
         {
-            /* origin: boost/simd/arch/common/detail/generic/erf_kernel.hpp */
+            /* origin: boost/simd/arch/common/detail/common/erf_kernel.hpp */
             /*
              * ====================================================
              * copyright 2016 NumScale SAS
@@ -461,7 +461,7 @@ namespace xsimd
          */
 
         template <class A>
-        XSIMD_INLINE batch<float, A> erf(batch<float, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<float, A> erf(batch<float, A> const& self, requires_arch<common>) noexcept
         {
             using batch_type = batch<float, A>;
             batch_type x = abs(self);
@@ -485,7 +485,7 @@ namespace xsimd
         }
 
         template <class A>
-        XSIMD_INLINE batch<double, A> erf(batch<double, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<double, A> erf(batch<double, A> const& self, requires_arch<common>) noexcept
         {
             using batch_type = batch<double, A>;
             batch_type x = abs(self);
@@ -521,7 +521,7 @@ namespace xsimd
 
         // erfc
         template <class A>
-        XSIMD_INLINE batch<float, A> erfc(batch<float, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<float, A> erfc(batch<float, A> const& self, requires_arch<common>) noexcept
         {
             using batch_type = batch<float, A>;
             batch_type x = abs(self);
@@ -546,7 +546,7 @@ namespace xsimd
         }
 
         template <class A>
-        XSIMD_INLINE batch<double, A> erfc(batch<double, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<double, A> erfc(batch<double, A> const& self, requires_arch<common>) noexcept
         {
             using batch_type = batch<double, A>;
             batch_type x = abs(self);
@@ -910,13 +910,13 @@ namespace xsimd
         }
 
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> exp(batch<T, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> exp(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             return detail::exp<detail::exp_tag>(self);
         }
 
         template <class A, class T>
-        XSIMD_INLINE batch<std::complex<T>, A> exp(batch<std::complex<T>, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<std::complex<T>, A> exp(batch<std::complex<T>, A> const& self, requires_arch<common>) noexcept
         {
             using batch_type = batch<std::complex<T>, A>;
             auto isincos = sincos(self.imag());
@@ -925,14 +925,14 @@ namespace xsimd
 
         // exp10
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> exp10(batch<T, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> exp10(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             return detail::exp<detail::exp10_tag>(self);
         }
 
         // exp2
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> exp2(batch<T, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> exp2(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             return detail::exp<detail::exp2_tag>(self);
         }
@@ -940,7 +940,7 @@ namespace xsimd
         // expm1
         namespace detail
         {
-            /* origin: boost/simd/arch/common/detail/generic/expm1_kernel.hpp */
+            /* origin: boost/simd/arch/common/detail/common/expm1_kernel.hpp */
             /*
              * ====================================================
              * copyright 2016 NumScale SAS
@@ -1005,7 +1005,7 @@ namespace xsimd
         }
 
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> expm1(batch<T, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> expm1(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             using batch_type = batch<T, A>;
             return select(self < constants::logeps<batch_type>(),
@@ -1016,7 +1016,7 @@ namespace xsimd
         }
 
         template <class A, class T>
-        XSIMD_INLINE batch<std::complex<T>, A> expm1(const batch<std::complex<T>, A>& z, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<std::complex<T>, A> expm1(const batch<std::complex<T>, A>& z, requires_arch<common>) noexcept
         {
             using batch_type = batch<std::complex<T>, A>;
             using real_batch = typename batch_type::real_batch;
@@ -1029,7 +1029,7 @@ namespace xsimd
 
         // polar
         template <class A, class T>
-        XSIMD_INLINE batch<std::complex<T>, A> polar(const batch<T, A>& r, const batch<T, A>& theta, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<std::complex<T>, A> polar(const batch<T, A>& r, const batch<T, A>& theta, requires_arch<common>) noexcept
         {
             auto sincosTheta = sincos(theta);
             return { r * sincosTheta.second, r * sincosTheta.first };
@@ -1037,14 +1037,14 @@ namespace xsimd
 
         // fdim
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> fdim(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> fdim(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept
         {
             return fmax(batch<T, A>(0), self - other);
         }
 
         // fmod
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> fmod(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> fmod(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept
         {
             return fnma(trunc(self / other), other, self);
         }
@@ -1060,7 +1060,7 @@ namespace xsimd
          * ====================================================
          */
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> frexp(const batch<T, A>& self, batch<as_integer_t<T>, A>& exp, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> frexp(const batch<T, A>& self, batch<as_integer_t<T>, A>& exp, requires_arch<common>) noexcept
         {
             using batch_type = batch<T, A>;
             using int_type = as_integer_t<T>;
@@ -1075,7 +1075,7 @@ namespace xsimd
 
         // from bool
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> from_bool(batch_bool<T, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> from_bool(batch_bool<T, A> const& self, requires_arch<common>) noexcept
         {
             return batch<T, A>(self.data) & batch<T, A>(1);
         }
@@ -1089,14 +1089,14 @@ namespace xsimd
 
         // hypot
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> hypot(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> hypot(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept
         {
             return sqrt(fma(self, self, other * other));
         }
 
         // ipow
         template <class A, class T, class ITy>
-        XSIMD_INLINE batch<T, A> ipow(batch<T, A> const& self, ITy other, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> ipow(batch<T, A> const& self, ITy other, requires_arch<common>) noexcept
         {
             return ::xsimd::detail::ipow(self, other);
         }
@@ -1112,7 +1112,7 @@ namespace xsimd
          * ====================================================
          */
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> ldexp(const batch<T, A>& self, const batch<as_integer_t<T>, A>& other, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> ldexp(const batch<T, A>& self, const batch<as_integer_t<T>, A>& other, requires_arch<common>) noexcept
         {
             using batch_type = batch<T, A>;
             using itype = as_integer_t<batch_type>;
@@ -1123,11 +1123,11 @@ namespace xsimd
 
         // lgamma
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> lgamma(batch<T, A> const& self, requires_arch<generic>) noexcept;
+        XSIMD_INLINE batch<T, A> lgamma(batch<T, A> const& self, requires_arch<common>) noexcept;
 
         namespace detail
         {
-            /* origin: boost/simd/arch/common/detail/generic/gammaln_kernel.hpp */
+            /* origin: boost/simd/arch/common/detail/common/gammaln_kernel.hpp */
             /*
              * ====================================================
              * copyright 2016 NumScale SAS
@@ -1426,7 +1426,7 @@ namespace xsimd
         }
 
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> lgamma(batch<T, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> lgamma(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             return detail::lgamma_impl<batch<T, A>>::compute(self);
         }
@@ -1442,7 +1442,7 @@ namespace xsimd
          * ====================================================
          */
         template <class A>
-        XSIMD_INLINE batch<float, A> log(batch<float, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<float, A> log(batch<float, A> const& self, requires_arch<common>) noexcept
         {
             using batch_type = batch<float, A>;
             using int_type = as_integer_t<float>;
@@ -1482,7 +1482,7 @@ namespace xsimd
         }
 
         template <class A>
-        XSIMD_INLINE batch<double, A> log(batch<double, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<double, A> log(batch<double, A> const& self, requires_arch<common>) noexcept
         {
             using batch_type = batch<double, A>;
             using int_type = as_integer_t<double>;
@@ -1525,14 +1525,14 @@ namespace xsimd
         }
 
         template <class A, class T>
-        XSIMD_INLINE batch<std::complex<T>, A> log(const batch<std::complex<T>, A>& z, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<std::complex<T>, A> log(const batch<std::complex<T>, A>& z, requires_arch<common>) noexcept
         {
             return batch<std::complex<T>, A>(log(abs(z)), atan2(z.imag(), z.real()));
         }
 
         // log2
         template <class A>
-        XSIMD_INLINE batch<float, A> log2(batch<float, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<float, A> log2(batch<float, A> const& self, requires_arch<common>) noexcept
         {
             using batch_type = batch<float, A>;
             using int_type = as_integer_t<float>;
@@ -1572,7 +1572,7 @@ namespace xsimd
         }
 
         template <class A>
-        XSIMD_INLINE batch<double, A> log2(batch<double, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<double, A> log2(batch<double, A> const& self, requires_arch<common>) noexcept
         {
             using batch_type = batch<double, A>;
             using int_type = as_integer_t<double>;
@@ -1631,7 +1631,7 @@ namespace xsimd
         }
 
         template <class A, class T>
-        XSIMD_INLINE batch<std::complex<T>, A> log2(batch<std::complex<T>, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<std::complex<T>, A> log2(batch<std::complex<T>, A> const& self, requires_arch<common>) noexcept
         {
             return detail::logN_complex_impl(self, std::log(2));
         }
@@ -1649,7 +1649,7 @@ namespace xsimd
          * ====================================================
          */
         template <class A>
-        XSIMD_INLINE batch<float, A> log10(batch<float, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<float, A> log10(batch<float, A> const& self, requires_arch<common>) noexcept
         {
             using batch_type = batch<float, A>;
             const batch_type
@@ -1700,7 +1700,7 @@ namespace xsimd
         }
 
         template <class A>
-        XSIMD_INLINE batch<double, A> log10(batch<double, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<double, A> log10(batch<double, A> const& self, requires_arch<common>) noexcept
         {
             using batch_type = batch<double, A>;
             const batch_type
@@ -1754,7 +1754,7 @@ namespace xsimd
         }
 
         template <class A, class T>
-        XSIMD_INLINE batch<std::complex<T>, A> log10(const batch<std::complex<T>, A>& z, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<std::complex<T>, A> log10(const batch<std::complex<T>, A>& z, requires_arch<common>) noexcept
         {
             return detail::logN_complex_impl(z, std::log(10));
         }
@@ -1770,7 +1770,7 @@ namespace xsimd
          * ====================================================
          */
         template <class A>
-        XSIMD_INLINE batch<float, A> log1p(batch<float, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<float, A> log1p(batch<float, A> const& self, requires_arch<common>) noexcept
         {
             using batch_type = batch<float, A>;
             using int_type = as_integer_t<float>;
@@ -1802,7 +1802,7 @@ namespace xsimd
         }
 
         template <class A>
-        XSIMD_INLINE batch<double, A> log1p(batch<double, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<double, A> log1p(batch<double, A> const& self, requires_arch<common>) noexcept
         {
             using batch_type = batch<double, A>;
             using int_type = as_integer_t<double>;
@@ -1835,7 +1835,7 @@ namespace xsimd
         }
 
         template <class A, class T>
-        XSIMD_INLINE batch<std::complex<T>, A> log1p(batch<std::complex<T>, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<std::complex<T>, A> log1p(batch<std::complex<T>, A> const& self, requires_arch<common>) noexcept
         {
             using batch_type = batch<std::complex<T>, A>;
             using real_batch = typename batch_type::real_batch;
@@ -1850,7 +1850,7 @@ namespace xsimd
 
         // mod
         template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
-        XSIMD_INLINE batch<T, A> mod(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> mod(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept
         {
             return detail::apply([](T x, T y) noexcept -> T
                                  { return x % y; },
@@ -1859,7 +1859,7 @@ namespace xsimd
 
         // nearbyint
         template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
-        XSIMD_INLINE batch<T, A> nearbyint(batch<T, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> nearbyint(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             return self;
         }
@@ -1886,19 +1886,19 @@ namespace xsimd
             }
         }
         template <class A>
-        XSIMD_INLINE batch<float, A> nearbyint(batch<float, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<float, A> nearbyint(batch<float, A> const& self, requires_arch<common>) noexcept
         {
             return detail::nearbyintf(self);
         }
         template <class A>
-        XSIMD_INLINE batch<double, A> nearbyint(batch<double, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<double, A> nearbyint(batch<double, A> const& self, requires_arch<common>) noexcept
         {
             return detail::nearbyintf(self);
         }
 
         // nearbyint_as_int
         template <class T, class A, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
-        XSIMD_INLINE batch<T, A> nearbyint_as_int(batch<T, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> nearbyint_as_int(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             return self;
         }
@@ -1906,7 +1906,7 @@ namespace xsimd
         // nearbyint_as_int
         template <class A>
         XSIMD_INLINE batch<as_integer_t<float>, A>
-        nearbyint_as_int(batch<float, A> const& self, requires_arch<generic>) noexcept
+        nearbyint_as_int(batch<float, A> const& self, requires_arch<common>) noexcept
         {
             using U = as_integer_t<float>;
             return kernel::detail::apply_transform<U>([](float x) noexcept -> U
@@ -1916,7 +1916,7 @@ namespace xsimd
 
         template <class A>
         XSIMD_INLINE batch<as_integer_t<double>, A>
-        nearbyint_as_int(batch<double, A> const& self, requires_arch<generic>) noexcept
+        nearbyint_as_int(batch<double, A> const& self, requires_arch<common>) noexcept
         {
             using U = as_integer_t<double>;
             return kernel::detail::apply_transform<U>([](double x) noexcept -> U
@@ -1979,7 +1979,7 @@ namespace xsimd
             };
         }
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> nextafter(batch<T, A> const& from, batch<T, A> const& to, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> nextafter(batch<T, A> const& from, batch<T, A> const& to, requires_arch<common>) noexcept
         {
             using kernel = detail::nextafter_kernel<T, A>;
             return select(from == to, from,
@@ -1997,7 +1997,7 @@ namespace xsimd
          * ====================================================
          */
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> pow(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> pow(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept
         {
             using batch_type = batch<T, A>;
             const auto zero = batch_type(0.);
@@ -2012,7 +2012,7 @@ namespace xsimd
         }
 
         template <class A, class T>
-        XSIMD_INLINE batch<std::complex<T>, A> pow(const batch<std::complex<T>, A>& a, const batch<std::complex<T>, A>& z, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<std::complex<T>, A> pow(const batch<std::complex<T>, A>& a, const batch<std::complex<T>, A>& z, requires_arch<common>) noexcept
         {
             using cplx_batch = batch<std::complex<T>, A>;
             using real_batch = typename cplx_batch::real_batch;
@@ -2031,7 +2031,7 @@ namespace xsimd
         }
 
         template <class A, class T>
-        inline batch<std::complex<T>, A> pow(const batch<std::complex<T>, A>& a, const batch<T, A>& z, requires_arch<generic>) noexcept
+        inline batch<std::complex<T>, A> pow(const batch<std::complex<T>, A>& a, const batch<T, A>& z, requires_arch<common>) noexcept
         {
             using cplx_batch = batch<std::complex<T>, A>;
 
@@ -2045,7 +2045,7 @@ namespace xsimd
         }
 
         template <class A, class T>
-        inline batch<std::complex<T>, A> pow(const batch<T, A>& a, const batch<std::complex<T>, A>& z, requires_arch<generic>) noexcept
+        inline batch<std::complex<T>, A> pow(const batch<T, A>& a, const batch<std::complex<T>, A>& z, requires_arch<common>) noexcept
         {
             return pow(batch<std::complex<T>, A> { a, batch<T, A> {} }, z);
         }
@@ -2053,7 +2053,7 @@ namespace xsimd
         // reciprocal
         template <class T, class A, class = typename std::enable_if<std::is_floating_point<T>::value, void>::type>
         XSIMD_INLINE batch<T, A> reciprocal(batch<T, A> const& self,
-                                            requires_arch<generic>) noexcept
+                                            requires_arch<common>) noexcept
         {
             using batch_type = batch<T, A>;
             return div(batch_type(1), self);
@@ -2061,7 +2061,7 @@ namespace xsimd
 
         // reduce_add
         template <class A, class T>
-        XSIMD_INLINE std::complex<T> reduce_add(batch<std::complex<T>, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE std::complex<T> reduce_add(batch<std::complex<T>, A> const& self, requires_arch<common>) noexcept
         {
             return { reduce_add(self.real()), reduce_add(self.imag()) };
         }
@@ -2094,7 +2094,7 @@ namespace xsimd
 
         // reduce_max
         template <class A, class T>
-        XSIMD_INLINE T reduce_max(batch<T, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE T reduce_max(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             return detail::reduce([](batch<T, A> const& x, batch<T, A> const& y)
                                   { return max(x, y); },
@@ -2103,7 +2103,7 @@ namespace xsimd
 
         // reduce_min
         template <class A, class T>
-        XSIMD_INLINE T reduce_min(batch<T, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE T reduce_min(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             return detail::reduce([](batch<T, A> const& x, batch<T, A> const& y)
                                   { return min(x, y); },
@@ -2112,17 +2112,17 @@ namespace xsimd
 
         // remainder
         template <class A>
-        XSIMD_INLINE batch<float, A> remainder(batch<float, A> const& self, batch<float, A> const& other, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<float, A> remainder(batch<float, A> const& self, batch<float, A> const& other, requires_arch<common>) noexcept
         {
             return fnma(nearbyint(self / other), other, self);
         }
         template <class A>
-        XSIMD_INLINE batch<double, A> remainder(batch<double, A> const& self, batch<double, A> const& other, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<double, A> remainder(batch<double, A> const& self, batch<double, A> const& other, requires_arch<common>) noexcept
         {
             return fnma(nearbyint(self / other), other, self);
         }
         template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
-        XSIMD_INLINE batch<T, A> remainder(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> remainder(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept
         {
             auto mod = self % other;
             return select(mod <= other / 2, mod, mod - other);
@@ -2130,14 +2130,14 @@ namespace xsimd
 
         // select
         template <class A, class T>
-        XSIMD_INLINE batch<std::complex<T>, A> select(batch_bool<T, A> const& cond, batch<std::complex<T>, A> const& true_br, batch<std::complex<T>, A> const& false_br, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<std::complex<T>, A> select(batch_bool<T, A> const& cond, batch<std::complex<T>, A> const& true_br, batch<std::complex<T>, A> const& false_br, requires_arch<common>) noexcept
         {
             return { select(cond, true_br.real(), false_br.real()), select(cond, true_br.imag(), false_br.imag()) };
         }
 
         // sign
         template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
-        XSIMD_INLINE batch<T, A> sign(batch<T, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> sign(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             using batch_type = batch<T, A>;
             batch_type res = select(self > batch_type(0), batch_type(1), batch_type(0)) - select(self < batch_type(0), batch_type(1), batch_type(0));
@@ -2160,17 +2160,17 @@ namespace xsimd
         }
 
         template <class A>
-        XSIMD_INLINE batch<float, A> sign(batch<float, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<float, A> sign(batch<float, A> const& self, requires_arch<common>) noexcept
         {
             return detail::signf(self);
         }
         template <class A>
-        XSIMD_INLINE batch<double, A> sign(batch<double, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<double, A> sign(batch<double, A> const& self, requires_arch<common>) noexcept
         {
             return detail::signf(self);
         }
         template <class A, class T>
-        XSIMD_INLINE batch<std::complex<T>, A> sign(const batch<std::complex<T>, A>& z, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<std::complex<T>, A> sign(const batch<std::complex<T>, A>& z, requires_arch<common>) noexcept
         {
             using batch_type = batch<std::complex<T>, A>;
             using real_batch = typename batch_type::real_batch;
@@ -2183,7 +2183,7 @@ namespace xsimd
 
         // signnz
         template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
-        XSIMD_INLINE batch<T, A> signnz(batch<T, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> signnz(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             using batch_type = batch<T, A>;
             return (self >> (sizeof(T) * 8 - 1)) | batch_type(1.);
@@ -2204,19 +2204,19 @@ namespace xsimd
         }
 
         template <class A>
-        XSIMD_INLINE batch<float, A> signnz(batch<float, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<float, A> signnz(batch<float, A> const& self, requires_arch<common>) noexcept
         {
             return detail::signnzf(self);
         }
         template <class A>
-        XSIMD_INLINE batch<double, A> signnz(batch<double, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<double, A> signnz(batch<double, A> const& self, requires_arch<common>) noexcept
         {
             return detail::signnzf(self);
         }
 
         // sqrt
         template <class A, class T>
-        XSIMD_INLINE batch<std::complex<T>, A> sqrt(batch<std::complex<T>, A> const& z, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<std::complex<T>, A> sqrt(batch<std::complex<T>, A> const& z, requires_arch<common>) noexcept
         {
 
             constexpr T csqrt_scale_factor = std::is_same<T, float>::value ? 6.7108864e7f : 1.8014398509481984e16;
@@ -2255,7 +2255,7 @@ namespace xsimd
 
         namespace detail
         {
-            /* origin: boost/simd/arch/common/detail/generic/stirling_kernel.hpp */
+            /* origin: boost/simd/arch/common/detail/common/stirling_kernel.hpp */
             /*
              * ====================================================
              * copyright 2016 NumScale SAS
@@ -2349,7 +2349,7 @@ namespace xsimd
                 return select(x > stirlinglargelim, constants::infinity<batch_type>(), y);
             }
 
-            /* origin: boost/simd/arch/common/detail/generic/gamma_kernel.hpp */
+            /* origin: boost/simd/arch/common/detail/common/gamma_kernel.hpp */
             /*
              * ====================================================
              * copyright 2016 NumScale SAS
@@ -2471,7 +2471,7 @@ namespace xsimd
         }
 
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> tgamma(batch<T, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> tgamma(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             using batch_type = batch<T, A>;
             auto nan_result = (self < batch_type(0.) && is_flint(self));
diff --git a/include/xsimd/arch/generic/xsimd_generic_memory.hpp b/include/xsimd/arch/common/xsimd_common_memory.hpp
similarity index 92%
rename from include/xsimd/arch/generic/xsimd_generic_memory.hpp
rename to include/xsimd/arch/common/xsimd_common_memory.hpp
index af884c185..812ad0bca 100644
--- a/include/xsimd/arch/generic/xsimd_generic_memory.hpp
+++ b/include/xsimd/arch/common/xsimd_common_memory.hpp
@@ -9,15 +9,15 @@
  * The full license is in the file LICENSE, distributed with this software. *
  ****************************************************************************/
 
-#ifndef XSIMD_GENERIC_MEMORY_HPP
-#define XSIMD_GENERIC_MEMORY_HPP
+#ifndef XSIMD_COMMON_MEMORY_HPP
+#define XSIMD_COMMON_MEMORY_HPP
 
 #include <algorithm>
 #include <complex>
 #include <stdexcept>
 
 #include "../../types/xsimd_batch_constant.hpp"
-#include "./xsimd_generic_details.hpp"
+#include "./xsimd_common_details.hpp"
 
 namespace xsimd
 {
@@ -77,7 +77,7 @@ namespace xsimd
         template <typename A, typename T>
         XSIMD_INLINE batch<T, A>
         compress(batch<T, A> const& x, batch_bool<T, A> const& mask,
-                 kernel::requires_arch<generic>) noexcept
+                 kernel::requires_arch<common>) noexcept
         {
             using IT = as_unsigned_integer_t<T>;
             constexpr std::size_t size = batch_bool<T, A>::size;
@@ -103,7 +103,7 @@ namespace xsimd
         template <typename A, typename T>
         XSIMD_INLINE batch<T, A>
         expand(batch<T, A> const& x, batch_bool<T, A> const& mask,
-               kernel::requires_arch<generic>) noexcept
+               kernel::requires_arch<common>) noexcept
         {
             constexpr std::size_t size = batch_bool<T, A>::size;
             auto bitmask = mask.mask();
@@ -114,7 +114,7 @@ namespace xsimd
 
         // extract_pair
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const& self, batch<T, A> const& other, std::size_t i, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const& self, batch<T, A> const& other, std::size_t i, requires_arch<common>) noexcept
         {
             constexpr std::size_t size = batch<T, A>::size;
             assert(i < size && "index in bounds");
@@ -163,7 +163,7 @@ namespace xsimd
         template <typename T, typename A, typename V>
         XSIMD_INLINE batch<T, A>
         gather(batch<T, A> const&, T const* src, batch<V, A> const& index,
-               kernel::requires_arch<generic>) noexcept
+               kernel::requires_arch<common>) noexcept
         {
             static_assert(batch<T, A>::size == batch<V, A>::size,
                           "Index and destination sizes must match");
@@ -175,7 +175,7 @@ namespace xsimd
         template <typename T, typename A, typename U, typename V>
         XSIMD_INLINE detail::sizes_mismatch_t<T, U, batch<T, A>>
         gather(batch<T, A> const&, U const* src, batch<V, A> const& index,
-               kernel::requires_arch<generic>) noexcept
+               kernel::requires_arch<common>) noexcept
         {
             static_assert(batch<T, A>::size == batch<V, A>::size,
                           "Index and destination sizes must match");
@@ -187,7 +187,7 @@ namespace xsimd
         template <typename T, typename A, typename U, typename V>
         XSIMD_INLINE detail::stride_match_t<T, U, batch<T, A>>
         gather(batch<T, A> const&, U const* src, batch<V, A> const& index,
-               kernel::requires_arch<generic>) noexcept
+               kernel::requires_arch<common>) noexcept
         {
             static_assert(batch<T, A>::size == batch<V, A>::size,
                           "Index and destination sizes must match");
@@ -197,7 +197,7 @@ namespace xsimd
 
         // insert
         template <class A, class T, size_t I>
-        XSIMD_INLINE batch<T, A> insert(batch<T, A> const& self, T val, index<I>, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> insert(batch<T, A> const& self, T val, index<I>, requires_arch<common>) noexcept
         {
             struct index_mask
             {
@@ -212,7 +212,7 @@ namespace xsimd
 
         // get
         template <class A, size_t I, class T>
-        XSIMD_INLINE T get(batch<T, A> const& self, ::xsimd::index<I>, requires_arch<generic>) noexcept
+        XSIMD_INLINE T get(batch<T, A> const& self, ::xsimd::index<I>, requires_arch<common>) noexcept
         {
             alignas(A::alignment()) T buffer[batch<T, A>::size];
             self.store_aligned(&buffer[0]);
@@ -220,7 +220,7 @@ namespace xsimd
         }
 
         template <class A, size_t I, class T>
-        XSIMD_INLINE T get(batch_bool<T, A> const& self, ::xsimd::index<I>, requires_arch<generic>) noexcept
+        XSIMD_INLINE T get(batch_bool<T, A> const& self, ::xsimd::index<I>, requires_arch<common>) noexcept
         {
             alignas(A::alignment()) T buffer[batch_bool<T, A>::size];
             self.store_aligned(&buffer[0]);
@@ -228,7 +228,7 @@ namespace xsimd
         }
 
         template <class A, size_t I, class T>
-        XSIMD_INLINE auto get(batch<std::complex<T>, A> const& self, ::xsimd::index<I>, requires_arch<generic>) noexcept -> typename batch<std::complex<T>, A>::value_type
+        XSIMD_INLINE auto get(batch<std::complex<T>, A> const& self, ::xsimd::index<I>, requires_arch<common>) noexcept -> typename batch<std::complex<T>, A>::value_type
         {
             alignas(A::alignment()) T buffer[batch<std::complex<T>, A>::size];
             self.store_aligned(&buffer[0]);
@@ -236,7 +236,7 @@ namespace xsimd
         }
 
         template <class A, class T>
-        XSIMD_INLINE T get(batch<T, A> const& self, std::size_t i, requires_arch<generic>) noexcept
+        XSIMD_INLINE T get(batch<T, A> const& self, std::size_t i, requires_arch<common>) noexcept
         {
             alignas(A::alignment()) T buffer[batch<T, A>::size];
             self.store_aligned(&buffer[0]);
@@ -244,7 +244,7 @@ namespace xsimd
         }
 
         template <class A, class T>
-        XSIMD_INLINE T get(batch_bool<T, A> const& self, std::size_t i, requires_arch<generic>) noexcept
+        XSIMD_INLINE T get(batch_bool<T, A> const& self, std::size_t i, requires_arch<common>) noexcept
         {
             alignas(A::alignment()) bool buffer[batch_bool<T, A>::size];
             self.store_aligned(&buffer[0]);
@@ -252,7 +252,7 @@ namespace xsimd
         }
 
         template <class A, class T>
-        XSIMD_INLINE auto get(batch<std::complex<T>, A> const& self, std::size_t i, requires_arch<generic>) noexcept -> typename batch<std::complex<T>, A>::value_type
+        XSIMD_INLINE auto get(batch<std::complex<T>, A> const& self, std::size_t i, requires_arch<common>) noexcept -> typename batch<std::complex<T>, A>::value_type
         {
             using T2 = typename batch<std::complex<T>, A>::value_type;
             alignas(A::alignment()) T2 buffer[batch<std::complex<T>, A>::size];
@@ -262,7 +262,7 @@ namespace xsimd
 
         // load
         template <class A, class T>
-        XSIMD_INLINE batch_bool<T, A> load_unaligned(bool const* mem, batch_bool<T, A>, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch_bool<T, A> load_unaligned(bool const* mem, batch_bool<T, A>, requires_arch<common>) noexcept
         {
             using batch_type = batch<T, A>;
             batch_type ref(0);
@@ -274,7 +274,7 @@ namespace xsimd
         }
 
         template <class A, class T>
-        XSIMD_INLINE batch_bool<T, A> load_aligned(bool const* mem, batch_bool<T, A> b, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch_bool<T, A> load_aligned(bool const* mem, batch_bool<T, A> b, requires_arch<common>) noexcept
         {
             return load_unaligned(mem, b, A {});
         }
@@ -283,14 +283,14 @@ namespace xsimd
         namespace detail
         {
             template <class A, class T_in, class T_out>
-            XSIMD_INLINE batch<T_out, A> load_aligned(T_in const* mem, convert<T_out>, requires_arch<generic>, with_fast_conversion) noexcept
+            XSIMD_INLINE batch<T_out, A> load_aligned(T_in const* mem, convert<T_out>, requires_arch<common>, with_fast_conversion) noexcept
             {
                 using batch_type_in = batch<T_in, A>;
                 using batch_type_out = batch<T_out, A>;
                 return fast_cast(batch_type_in::load_aligned(mem), batch_type_out(), A {});
             }
             template <class A, class T_in, class T_out>
-            XSIMD_INLINE batch<T_out, A> load_aligned(T_in const* mem, convert<T_out>, requires_arch<generic>, with_slow_conversion) noexcept
+            XSIMD_INLINE batch<T_out, A> load_aligned(T_in const* mem, convert<T_out>, requires_arch<common>, with_slow_conversion) noexcept
             {
                 static_assert(!std::is_same<T_in, T_out>::value, "there should be a direct load for this type combination");
                 using batch_type_out = batch<T_out, A>;
@@ -300,7 +300,7 @@ namespace xsimd
             }
         }
         template <class A, class T_in, class T_out>
-        XSIMD_INLINE batch<T_out, A> load_aligned(T_in const* mem, convert<T_out> cvt, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T_out, A> load_aligned(T_in const* mem, convert<T_out> cvt, requires_arch<common>) noexcept
         {
             return detail::load_aligned<A>(mem, cvt, A {}, detail::conversion_type<A, T_in, T_out> {});
         }
@@ -309,7 +309,7 @@ namespace xsimd
         namespace detail
         {
             template <class A, class T_in, class T_out>
-            XSIMD_INLINE batch<T_out, A> load_unaligned(T_in const* mem, convert<T_out>, requires_arch<generic>, with_fast_conversion) noexcept
+            XSIMD_INLINE batch<T_out, A> load_unaligned(T_in const* mem, convert<T_out>, requires_arch<common>, with_fast_conversion) noexcept
             {
                 using batch_type_in = batch<T_in, A>;
                 using batch_type_out = batch<T_out, A>;
@@ -317,21 +317,21 @@ namespace xsimd
             }
 
             template <class A, class T_in, class T_out>
-            XSIMD_INLINE batch<T_out, A> load_unaligned(T_in const* mem, convert<T_out> cvt, requires_arch<generic>, with_slow_conversion) noexcept
+            XSIMD_INLINE batch<T_out, A> load_unaligned(T_in const* mem, convert<T_out> cvt, requires_arch<common>, with_slow_conversion) noexcept
             {
                 static_assert(!std::is_same<T_in, T_out>::value, "there should be a direct load for this type combination");
-                return load_aligned<A>(mem, cvt, generic {}, with_slow_conversion {});
+                return load_aligned<A>(mem, cvt, common {}, with_slow_conversion {});
             }
         }
         template <class A, class T_in, class T_out>
-        XSIMD_INLINE batch<T_out, A> load_unaligned(T_in const* mem, convert<T_out> cvt, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T_out, A> load_unaligned(T_in const* mem, convert<T_out> cvt, requires_arch<common>) noexcept
         {
-            return detail::load_unaligned<A>(mem, cvt, generic {}, detail::conversion_type<A, T_in, T_out> {});
+            return detail::load_unaligned<A>(mem, cvt, common {}, detail::conversion_type<A, T_in, T_out> {});
         }
 
         // rotate_right
         template <size_t N, class A, class T>
-        XSIMD_INLINE batch<T, A> rotate_right(batch<T, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> rotate_right(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             struct rotate_generator
             {
@@ -345,14 +345,14 @@ namespace xsimd
         }
 
         template <size_t N, class A, class T>
-        XSIMD_INLINE batch<std::complex<T>, A> rotate_right(batch<std::complex<T>, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<std::complex<T>, A> rotate_right(batch<std::complex<T>, A> const& self, requires_arch<common>) noexcept
         {
             return { rotate_right<N>(self.real()), rotate_right<N>(self.imag()) };
         }
 
         // rotate_left
         template <size_t N, class A, class T>
-        XSIMD_INLINE batch<T, A> rotate_left(batch<T, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> rotate_left(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             struct rotate_generator
             {
@@ -366,7 +366,7 @@ namespace xsimd
         }
 
         template <size_t N, class A, class T>
-        XSIMD_INLINE batch<std::complex<T>, A> rotate_left(batch<std::complex<T>, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<std::complex<T>, A> rotate_left(batch<std::complex<T>, A> const& self, requires_arch<common>) noexcept
         {
             return { rotate_left<N>(self.real()), rotate_left<N>(self.imag()) };
         }
@@ -399,7 +399,7 @@ namespace xsimd
         XSIMD_INLINE void
         scatter(batch<T, A> const& src, T* dst,
                 batch<V, A> const& index,
-                kernel::requires_arch<generic>) noexcept
+                kernel::requires_arch<common>) noexcept
         {
             static_assert(batch<T, A>::size == batch<V, A>::size,
                           "Source and index sizes must match");
@@ -411,7 +411,7 @@ namespace xsimd
         XSIMD_INLINE detail::sizes_mismatch_t<T, U, void>
         scatter(batch<T, A> const& src, U* dst,
                 batch<V, A> const& index,
-                kernel::requires_arch<generic>) noexcept
+                kernel::requires_arch<common>) noexcept
         {
             static_assert(batch<T, A>::size == batch<V, A>::size,
                           "Source and index sizes must match");
@@ -423,7 +423,7 @@ namespace xsimd
         XSIMD_INLINE detail::stride_match_t<T, U, void>
         scatter(batch<T, A> const& src, U* dst,
                 batch<V, A> const& index,
-                kernel::requires_arch<generic>) noexcept
+                kernel::requires_arch<common>) noexcept
         {
             static_assert(batch<T, A>::size == batch<V, A>::size,
                           "Source and index sizes must match");
@@ -501,7 +501,7 @@ namespace xsimd
         }
 
         template <class A, typename T, typename ITy, ITy... Indices>
-        XSIMD_INLINE batch<T, A> shuffle(batch<T, A> const& x, batch<T, A> const& y, batch_constant<ITy, A, Indices...>, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> shuffle(batch<T, A> const& x, batch<T, A> const& y, batch_constant<ITy, A, Indices...>, requires_arch<common>) noexcept
         {
             constexpr size_t bsize = sizeof...(Indices);
             static_assert(bsize == batch<T, A>::size, "valid shuffle");
@@ -549,7 +549,7 @@ namespace xsimd
 //            typedef ITy integer_vector_type __attribute__((vector_size(sizeof(batch<ITy, A>))));
 //            return __builtin_shuffle(x.data, y.data, integer_vector_type{Indices...});
 #else
-            // Use a generic_pattern. It is suboptimal but clang optimizes this
+            // Use a common_pattern. It is suboptimal but clang optimizes this
             // pretty well.
             batch<T, A> x_lane = swizzle(x, batch_constant<ITy, A, ((Indices >= bsize) ? (Indices - bsize) : Indices)...>());
             batch<T, A> y_lane = swizzle(y, batch_constant<ITy, A, ((Indices >= bsize) ? (Indices - bsize) : Indices)...>());
@@ -560,7 +560,7 @@ namespace xsimd
 
         // store
         template <class A, class T>
-        XSIMD_INLINE void store(batch_bool<T, A> const& self, bool* mem, requires_arch<generic>) noexcept
+        XSIMD_INLINE void store(batch_bool<T, A> const& self, bool* mem, requires_arch<common>) noexcept
         {
             using batch_type = batch<T, A>;
             constexpr auto size = batch_bool<T, A>::size;
@@ -572,7 +572,7 @@ namespace xsimd
 
         // store_aligned
         template <class A, class T_in, class T_out>
-        XSIMD_INLINE void store_aligned(T_out* mem, batch<T_in, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE void store_aligned(T_out* mem, batch<T_in, A> const& self, requires_arch<common>) noexcept
         {
             static_assert(!std::is_same<T_in, T_out>::value, "there should be a direct store for this type combination");
             alignas(A::alignment()) T_in buffer[batch<T_in, A>::size];
@@ -582,21 +582,21 @@ namespace xsimd
 
         // store_unaligned
         template <class A, class T_in, class T_out>
-        XSIMD_INLINE void store_unaligned(T_out* mem, batch<T_in, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE void store_unaligned(T_out* mem, batch<T_in, A> const& self, requires_arch<common>) noexcept
         {
             static_assert(!std::is_same<T_in, T_out>::value, "there should be a direct store for this type combination");
-            return store_aligned<A>(mem, self, generic {});
+            return store_aligned<A>(mem, self, common {});
         }
 
         // swizzle
         template <class A, class T, class ITy, ITy... Vs>
-        XSIMD_INLINE batch<std::complex<T>, A> swizzle(batch<std::complex<T>, A> const& self, batch_constant<ITy, A, Vs...> mask, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<std::complex<T>, A> swizzle(batch<std::complex<T>, A> const& self, batch_constant<ITy, A, Vs...> mask, requires_arch<common>) noexcept
         {
             return { swizzle(self.real(), mask), swizzle(self.imag(), mask) };
         }
 
         template <class A, class T, class ITy>
-        XSIMD_INLINE batch<T, A> swizzle(batch<T, A> const& self, batch<ITy, A> mask, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> swizzle(batch<T, A> const& self, batch<ITy, A> mask, requires_arch<common>) noexcept
         {
             constexpr size_t size = batch<T, A>::size;
             alignas(A::alignment()) T self_buffer[size];
@@ -612,7 +612,7 @@ namespace xsimd
         }
 
         template <class A, class T, class ITy>
-        XSIMD_INLINE batch<std::complex<T>, A> swizzle(batch<std::complex<T>, A> const& self, batch<ITy, A> mask, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<std::complex<T>, A> swizzle(batch<std::complex<T>, A> const& self, batch<ITy, A> mask, requires_arch<common>) noexcept
         {
             return { swizzle(self.real(), mask), swizzle(self.imag(), mask) };
         }
@@ -621,26 +621,26 @@ namespace xsimd
         namespace detail
         {
             template <class A, class T>
-            XSIMD_INLINE batch<std::complex<T>, A> load_complex(batch<T, A> const& /*hi*/, batch<T, A> const& /*lo*/, requires_arch<generic>) noexcept
+            XSIMD_INLINE batch<std::complex<T>, A> load_complex(batch<T, A> const& /*hi*/, batch<T, A> const& /*lo*/, requires_arch<common>) noexcept
             {
                 static_assert(std::is_same<T, void>::value, "load_complex not implemented for the required architecture");
             }
 
             template <class A, class T>
-            XSIMD_INLINE batch<T, A> complex_high(batch<std::complex<T>, A> const& /*src*/, requires_arch<generic>) noexcept
+            XSIMD_INLINE batch<T, A> complex_high(batch<std::complex<T>, A> const& /*src*/, requires_arch<common>) noexcept
             {
                 static_assert(std::is_same<T, void>::value, "complex_high not implemented for the required architecture");
             }
 
             template <class A, class T>
-            XSIMD_INLINE batch<T, A> complex_low(batch<std::complex<T>, A> const& /*src*/, requires_arch<generic>) noexcept
+            XSIMD_INLINE batch<T, A> complex_low(batch<std::complex<T>, A> const& /*src*/, requires_arch<common>) noexcept
             {
                 static_assert(std::is_same<T, void>::value, "complex_low not implemented for the required architecture");
             }
         }
 
         template <class A, class T_out, class T_in>
-        XSIMD_INLINE batch<std::complex<T_out>, A> load_complex_aligned(std::complex<T_in> const* mem, convert<std::complex<T_out>>, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<std::complex<T_out>, A> load_complex_aligned(std::complex<T_in> const* mem, convert<std::complex<T_out>>, requires_arch<common>) noexcept
         {
             using real_batch = batch<T_out, A>;
             T_in const* buffer = reinterpret_cast<T_in const*>(mem);
@@ -651,7 +651,7 @@ namespace xsimd
 
         // load_complex_unaligned
         template <class A, class T_out, class T_in>
-        XSIMD_INLINE batch<std::complex<T_out>, A> load_complex_unaligned(std::complex<T_in> const* mem, convert<std::complex<T_out>>, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<std::complex<T_out>, A> load_complex_unaligned(std::complex<T_in> const* mem, convert<std::complex<T_out>>, requires_arch<common>) noexcept
         {
             using real_batch = batch<T_out, A>;
             T_in const* buffer = reinterpret_cast<T_in const*>(mem);
@@ -662,7 +662,7 @@ namespace xsimd
 
         // store_complex_aligned
         template <class A, class T_out, class T_in>
-        XSIMD_INLINE void store_complex_aligned(std::complex<T_out>* dst, batch<std::complex<T_in>, A> const& src, requires_arch<generic>) noexcept
+        XSIMD_INLINE void store_complex_aligned(std::complex<T_out>* dst, batch<std::complex<T_in>, A> const& src, requires_arch<common>) noexcept
         {
             using real_batch = batch<T_in, A>;
             real_batch hi = detail::complex_high(src, A {});
@@ -674,7 +674,7 @@ namespace xsimd
 
         // store_complex_unaligned
         template <class A, class T_out, class T_in>
-        XSIMD_INLINE void store_complex_unaligned(std::complex<T_out>* dst, batch<std::complex<T_in>, A> const& src, requires_arch<generic>) noexcept
+        XSIMD_INLINE void store_complex_unaligned(std::complex<T_out>* dst, batch<std::complex<T_in>, A> const& src, requires_arch<common>) noexcept
         {
             using real_batch = batch<T_in, A>;
             real_batch hi = detail::complex_high(src, A {});
@@ -686,7 +686,7 @@ namespace xsimd
 
         // transpose
         template <class A, class T>
-        XSIMD_INLINE void transpose(batch<T, A>* matrix_begin, batch<T, A>* matrix_end, requires_arch<generic>) noexcept
+        XSIMD_INLINE void transpose(batch<T, A>* matrix_begin, batch<T, A>* matrix_end, requires_arch<common>) noexcept
         {
             assert((matrix_end - matrix_begin == batch<T, A>::size) && "correctly sized matrix");
             (void)matrix_end;
@@ -712,7 +712,7 @@ namespace xsimd
 
         // transpose
         template <class A, class = typename std::enable_if<batch<int16_t, A>::size == 8, void>::type>
-        XSIMD_INLINE void transpose(batch<int16_t, A>* matrix_begin, batch<int16_t, A>* matrix_end, requires_arch<generic>) noexcept
+        XSIMD_INLINE void transpose(batch<int16_t, A>* matrix_begin, batch<int16_t, A>* matrix_end, requires_arch<common>) noexcept
         {
             assert((matrix_end - matrix_begin == batch<int16_t, A>::size) && "correctly sized matrix");
             (void)matrix_end;
@@ -750,13 +750,13 @@ namespace xsimd
         }
 
         template <class A>
-        XSIMD_INLINE void transpose(batch<uint16_t, A>* matrix_begin, batch<uint16_t, A>* matrix_end, requires_arch<generic>) noexcept
+        XSIMD_INLINE void transpose(batch<uint16_t, A>* matrix_begin, batch<uint16_t, A>* matrix_end, requires_arch<common>) noexcept
         {
             transpose(reinterpret_cast<batch<int16_t, A>*>(matrix_begin), reinterpret_cast<batch<int16_t, A>*>(matrix_end), A {});
         }
 
         template <class A, class = typename std::enable_if<batch<int8_t, A>::size == 16, void>::type>
-        XSIMD_INLINE void transpose(batch<int8_t, A>* matrix_begin, batch<int8_t, A>* matrix_end, requires_arch<generic>) noexcept
+        XSIMD_INLINE void transpose(batch<int8_t, A>* matrix_begin, batch<int8_t, A>* matrix_end, requires_arch<common>) noexcept
         {
             assert((matrix_end - matrix_begin == batch<int8_t, A>::size) && "correctly sized matrix");
             (void)matrix_end;
@@ -840,7 +840,7 @@ namespace xsimd
         }
 
         template <class A>
-        XSIMD_INLINE void transpose(batch<uint8_t, A>* matrix_begin, batch<uint8_t, A>* matrix_end, requires_arch<generic>) noexcept
+        XSIMD_INLINE void transpose(batch<uint8_t, A>* matrix_begin, batch<uint8_t, A>* matrix_end, requires_arch<common>) noexcept
         {
             transpose(reinterpret_cast<batch<int8_t, A>*>(matrix_begin), reinterpret_cast<batch<int8_t, A>*>(matrix_end), A {});
         }
diff --git a/include/xsimd/arch/generic/xsimd_generic_rounding.hpp b/include/xsimd/arch/common/xsimd_common_rounding.hpp
similarity index 88%
rename from include/xsimd/arch/generic/xsimd_generic_rounding.hpp
rename to include/xsimd/arch/common/xsimd_common_rounding.hpp
index daf7b58ea..a46c263d0 100644
--- a/include/xsimd/arch/generic/xsimd_generic_rounding.hpp
+++ b/include/xsimd/arch/common/xsimd_common_rounding.hpp
@@ -9,10 +9,10 @@
  * The full license is in the file LICENSE, distributed with this software. *
  ****************************************************************************/
 
-#ifndef XSIMD_GENERIC_ROUNDING_HPP
-#define XSIMD_GENERIC_ROUNDING_HPP
+#ifndef XSIMD_COMMON_ROUNDING_HPP
+#define XSIMD_COMMON_ROUNDING_HPP
 
-#include "./xsimd_generic_details.hpp"
+#include "./xsimd_common_details.hpp"
 
 namespace xsimd
 {
@@ -24,7 +24,7 @@ namespace xsimd
 
         // ceil
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> ceil(batch<T, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> ceil(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             batch<T, A> truncated_self = trunc(self);
             return select(truncated_self < self, truncated_self + 1, truncated_self);
@@ -32,7 +32,7 @@ namespace xsimd
 
         // floor
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> floor(batch<T, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> floor(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             batch<T, A> truncated_self = trunc(self);
             return select(truncated_self > self, truncated_self - 1, truncated_self);
@@ -40,7 +40,7 @@ namespace xsimd
 
         // round
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> round(batch<T, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> round(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             auto v = abs(self);
             auto c = ceil(v);
@@ -50,17 +50,17 @@ namespace xsimd
 
         // trunc
         template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
-        XSIMD_INLINE batch<T, A> trunc(batch<T, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> trunc(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             return self;
         }
         template <class A>
-        XSIMD_INLINE batch<float, A> trunc(batch<float, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<float, A> trunc(batch<float, A> const& self, requires_arch<common>) noexcept
         {
             return select(abs(self) < constants::maxflint<batch<float, A>>(), to_float(to_int(self)), self);
         }
         template <class A>
-        XSIMD_INLINE batch<double, A> trunc(batch<double, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<double, A> trunc(batch<double, A> const& self, requires_arch<common>) noexcept
         {
             return select(abs(self) < constants::maxflint<batch<double, A>>(), to_float(to_int(self)), self);
         }
diff --git a/include/xsimd/arch/generic/xsimd_generic_trigo.hpp b/include/xsimd/arch/common/xsimd_common_trigo.hpp
similarity index 96%
rename from include/xsimd/arch/generic/xsimd_generic_trigo.hpp
rename to include/xsimd/arch/common/xsimd_common_trigo.hpp
index b1bb68f25..235bbc14b 100644
--- a/include/xsimd/arch/generic/xsimd_generic_trigo.hpp
+++ b/include/xsimd/arch/common/xsimd_common_trigo.hpp
@@ -9,10 +9,10 @@
  * The full license is in the file LICENSE, distributed with this software. *
  ****************************************************************************/
 
-#ifndef XSIMD_GENERIC_TRIGO_HPP
-#define XSIMD_GENERIC_TRIGO_HPP
+#ifndef XSIMD_COMMON_TRIGO_HPP
+#define XSIMD_COMMON_TRIGO_HPP
 
-#include "./xsimd_generic_details.hpp"
+#include "./xsimd_common_details.hpp"
 
 #include <array>
 
@@ -35,7 +35,7 @@ namespace xsimd
 
         // acos
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> acos(batch<T, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> acos(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             using batch_type = batch<T, A>;
             batch_type x = abs(self);
@@ -47,7 +47,7 @@ namespace xsimd
             return select(x_larger_05, x, constants::pio2<batch_type>() - x);
         }
         template <class A, class T>
-        XSIMD_INLINE batch<std::complex<T>, A> acos(const batch<std::complex<T>, A>& z, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<std::complex<T>, A> acos(const batch<std::complex<T>, A>& z, requires_arch<common>) noexcept
         {
             using batch_type = batch<std::complex<T>, A>;
             using real_batch = typename batch_type::real_batch;
@@ -66,7 +66,7 @@ namespace xsimd
          * ====================================================
          */
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> acosh(batch<T, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> acosh(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             using batch_type = batch<T, A>;
             batch_type x = self - batch_type(1.);
@@ -76,7 +76,7 @@ namespace xsimd
             return select(test, l1pz + constants::log_2<batch_type>(), l1pz);
         }
         template <class A, class T>
-        XSIMD_INLINE batch<std::complex<T>, A> acosh(const batch<std::complex<T>, A>& z, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<std::complex<T>, A> acosh(const batch<std::complex<T>, A>& z, requires_arch<common>) noexcept
         {
             using batch_type = batch<std::complex<T>, A>;
             batch_type w = acos(z);
@@ -86,7 +86,7 @@ namespace xsimd
 
         // asin
         template <class A>
-        XSIMD_INLINE batch<float, A> asin(batch<float, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<float, A> asin(batch<float, A> const& self, requires_arch<common>) noexcept
         {
             using batch_type = batch<float, A>;
             batch_type x = abs(self);
@@ -105,7 +105,7 @@ namespace xsimd
             return z ^ sign;
         }
         template <class A>
-        XSIMD_INLINE batch<double, A> asin(batch<double, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<double, A> asin(batch<double, A> const& self, requires_arch<common>) noexcept
         {
             using batch_type = batch<double, A>;
             batch_type x = abs(self);
@@ -127,7 +127,7 @@ namespace xsimd
                               ^ bitofsign(self));
         }
         template <class A, class T>
-        XSIMD_INLINE batch<std::complex<T>, A> asin(const batch<std::complex<T>, A>& z, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<std::complex<T>, A> asin(const batch<std::complex<T>, A>& z, requires_arch<common>) noexcept
         {
             using batch_type = batch<std::complex<T>, A>;
             using real_batch = typename batch_type::real_batch;
@@ -184,7 +184,7 @@ namespace xsimd
             }
         }
         template <class A>
-        XSIMD_INLINE batch<float, A> asinh(batch<float, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<float, A> asinh(batch<float, A> const& self, requires_arch<common>) noexcept
         {
             using batch_type = batch<float, A>;
             batch_type x = abs(self);
@@ -212,7 +212,7 @@ namespace xsimd
 #endif
         }
         template <class A>
-        XSIMD_INLINE batch<double, A> asinh(batch<double, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<double, A> asinh(batch<double, A> const& self, requires_arch<common>) noexcept
         {
             using batch_type = batch<double, A>;
             batch_type x = abs(self);
@@ -226,7 +226,7 @@ namespace xsimd
             return bitofsign(self) ^ z;
         }
         template <class A, class T>
-        XSIMD_INLINE batch<std::complex<T>, A> asinh(const batch<std::complex<T>, A>& z, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<std::complex<T>, A> asinh(const batch<std::complex<T>, A>& z, requires_arch<common>) noexcept
         {
             using batch_type = batch<std::complex<T>, A>;
             batch_type w = asin(batch_type(-z.imag(), z.real()));
@@ -288,7 +288,7 @@ namespace xsimd
             }
         }
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> atan(batch<T, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> atan(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             using batch_type = batch<T, A>;
             const batch_type absa = abs(self);
@@ -296,7 +296,7 @@ namespace xsimd
             return x ^ bitofsign(self);
         }
         template <class A, class T>
-        XSIMD_INLINE batch<std::complex<T>, A> atan(const batch<std::complex<T>, A>& z, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<std::complex<T>, A> atan(const batch<std::complex<T>, A>& z, requires_arch<common>) noexcept
         {
             using batch_type = batch<std::complex<T>, A>;
             using real_batch = typename batch_type::real_batch;
@@ -327,7 +327,7 @@ namespace xsimd
          * ====================================================
          */
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> atanh(batch<T, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> atanh(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             using batch_type = batch<T, A>;
             batch_type x = abs(self);
@@ -338,7 +338,7 @@ namespace xsimd
             return bitofsign(self) ^ (batch_type(0.5) * log1p(select(test, fma(t, tmp, t), tmp)));
         }
         template <class A, class T>
-        XSIMD_INLINE batch<std::complex<T>, A> atanh(const batch<std::complex<T>, A>& z, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<std::complex<T>, A> atanh(const batch<std::complex<T>, A>& z, requires_arch<common>) noexcept
         {
             using batch_type = batch<std::complex<T>, A>;
             batch_type w = atan(batch_type(-z.imag(), z.real()));
@@ -348,7 +348,7 @@ namespace xsimd
 
         // atan2
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> atan2(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> atan2(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept
         {
             using batch_type = batch<T, A>;
             const batch_type q = abs(self / other);
@@ -617,7 +617,7 @@ namespace xsimd
 
         }
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> cos(batch<T, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> cos(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             using batch_type = batch<T, A>;
             const batch_type x = abs(self);
@@ -634,7 +634,7 @@ namespace xsimd
         }
 
         template <class A, class T>
-        XSIMD_INLINE batch<std::complex<T>, A> cos(batch<std::complex<T>, A> const& z, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<std::complex<T>, A> cos(batch<std::complex<T>, A> const& z, requires_arch<common>) noexcept
         {
             return { cos(z.real()) * cosh(z.imag()), -sin(z.real()) * sinh(z.imag()) };
         }
@@ -652,7 +652,7 @@ namespace xsimd
          */
 
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> cosh(batch<T, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> cosh(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             using batch_type = batch<T, A>;
             batch_type x = abs(self);
@@ -663,7 +663,7 @@ namespace xsimd
             return select(test1, tmp1 * tmp, detail::average(tmp, batch_type(1.) / tmp));
         }
         template <class A, class T>
-        XSIMD_INLINE batch<std::complex<T>, A> cosh(const batch<std::complex<T>, A>& z, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<std::complex<T>, A> cosh(const batch<std::complex<T>, A>& z, requires_arch<common>) noexcept
         {
             auto x = z.real();
             auto y = z.imag();
@@ -692,20 +692,20 @@ namespace xsimd
         }
 
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> sin(batch<T, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> sin(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             return detail::sin(self);
         }
 
         template <class A, class T>
-        XSIMD_INLINE batch<std::complex<T>, A> sin(batch<std::complex<T>, A> const& z, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<std::complex<T>, A> sin(batch<std::complex<T>, A> const& z, requires_arch<common>) noexcept
         {
             return { sin(z.real()) * cosh(z.imag()), cos(z.real()) * sinh(z.imag()) };
         }
 
         // sincos
         template <class A, class T>
-        XSIMD_INLINE std::pair<batch<T, A>, batch<T, A>> sincos(batch<T, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE std::pair<batch<T, A>, batch<T, A>> sincos(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             using batch_type = batch<T, A>;
             const batch_type x = abs(self);
@@ -725,7 +725,7 @@ namespace xsimd
 
         template <class A, class T>
         XSIMD_INLINE std::pair<batch<std::complex<T>, A>, batch<std::complex<T>, A>>
-        sincos(batch<std::complex<T>, A> const& z, requires_arch<generic>) noexcept
+        sincos(batch<std::complex<T>, A> const& z, requires_arch<common>) noexcept
         {
             using batch_type = batch<std::complex<T>, A>;
             using real_batch = typename batch_type::real_batch;
@@ -739,7 +739,7 @@ namespace xsimd
         // sinh
         namespace detail
         {
-            /* origin: boost/simd/arch/common/detail/generic/sinh_kernel.hpp */
+            /* origin: boost/simd/arch/common/detail/common/sinh_kernel.hpp */
             /*
              * ====================================================
              * copyright 2016 NumScale SAS
@@ -792,7 +792,7 @@ namespace xsimd
          * ====================================================
          */
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> sinh(batch<T, A> const& a, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> sinh(batch<T, A> const& a, requires_arch<common>) noexcept
         {
             using batch_type = batch<T, A>;
             batch_type half(0.5);
@@ -814,7 +814,7 @@ namespace xsimd
             return select(lt1, z, r) ^ bts;
         }
         template <class A, class T>
-        XSIMD_INLINE batch<std::complex<T>, A> sinh(const batch<std::complex<T>, A>& z, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<std::complex<T>, A> sinh(const batch<std::complex<T>, A>& z, requires_arch<common>) noexcept
         {
             auto x = z.real();
             auto y = z.imag();
@@ -823,7 +823,7 @@ namespace xsimd
 
         // tan
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> tan(batch<T, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> tan(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             using batch_type = batch<T, A>;
             const batch_type x = abs(self);
@@ -836,7 +836,7 @@ namespace xsimd
             return y ^ bitofsign(self);
         }
         template <class A, class T>
-        XSIMD_INLINE batch<std::complex<T>, A> tan(batch<std::complex<T>, A> const& z, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<std::complex<T>, A> tan(batch<std::complex<T>, A> const& z, requires_arch<common>) noexcept
         {
             using batch_type = batch<std::complex<T>, A>;
             using real_batch = typename batch_type::real_batch;
@@ -851,7 +851,7 @@ namespace xsimd
         // tanh
         namespace detail
         {
-            /* origin: boost/simd/arch/common/detail/generic/tanh_kernel.hpp */
+            /* origin: boost/simd/arch/common/detail/common/tanh_kernel.hpp */
             /*
              * ====================================================
              * copyright 2016 NumScale SAS
@@ -934,7 +934,7 @@ namespace xsimd
          * ====================================================
          */
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> tanh(batch<T, A> const& self, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<T, A> tanh(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             using batch_type = batch<T, A>;
             batch_type one(1.);
@@ -952,7 +952,7 @@ namespace xsimd
             return select(test, z, r) ^ bts;
         }
         template <class A, class T>
-        XSIMD_INLINE batch<std::complex<T>, A> tanh(const batch<std::complex<T>, A>& z, requires_arch<generic>) noexcept
+        XSIMD_INLINE batch<std::complex<T>, A> tanh(const batch<std::complex<T>, A>& z, requires_arch<common>) noexcept
         {
             using real_batch = typename batch<std::complex<T>, A>::real_batch;
             auto x = z.real();
diff --git a/include/xsimd/arch/xsimd_avx.hpp b/include/xsimd/arch/xsimd_avx.hpp
index 3292aaaaf..883f055be 100644
--- a/include/xsimd/arch/xsimd_avx.hpp
+++ b/include/xsimd/arch/xsimd_avx.hpp
@@ -27,12 +27,12 @@ namespace xsimd
 
         // fwd
         template <class A, class T, size_t I>
-        XSIMD_INLINE batch<T, A> insert(batch<T, A> const& self, T val, index<I>, requires_arch<generic>) noexcept;
+        XSIMD_INLINE batch<T, A> insert(batch<T, A> const& self, T val, index<I>, requires_arch<common>) noexcept;
 
         template <class A>
-        XSIMD_INLINE void transpose(batch<uint16_t, A>* matrix_begin, batch<uint16_t, A>* matrix_end, requires_arch<generic>) noexcept;
+        XSIMD_INLINE void transpose(batch<uint16_t, A>* matrix_begin, batch<uint16_t, A>* matrix_end, requires_arch<common>) noexcept;
         template <class A>
-        XSIMD_INLINE void transpose(batch<uint8_t, A>* matrix_begin, batch<uint8_t, A>* matrix_end, requires_arch<generic>) noexcept;
+        XSIMD_INLINE void transpose(batch<uint8_t, A>* matrix_begin, batch<uint8_t, A>* matrix_end, requires_arch<common>) noexcept;
 
         namespace detail
         {
@@ -760,10 +760,10 @@ namespace xsimd
             }
             else
             {
-                return insert(self, val, pos, generic {});
+                return insert(self, val, pos, common {});
             }
 #endif
-            return insert(self, val, pos, generic {});
+            return insert(self, val, pos, common {});
         }
 
         // isnan
@@ -1224,7 +1224,7 @@ namespace xsimd
             if (I4 == (I0 + 4) && I5 == (I1 + 4) && I6 == (I2 + 4) && I7 == (I3 + 4) && I2 < 4 && I3 < 4 && I0 >= 8 && I0 < 12 && I1 >= 8 && I1 < 12)
                 return _mm256_shuffle_ps(y, x, smask);
 
-            return shuffle(x, y, mask, generic {});
+            return shuffle(x, y, mask, common {});
         }
 
         template <class A, class ITy, ITy I0, ITy I1, ITy I2, ITy I3>
@@ -1239,7 +1239,7 @@ namespace xsimd
             if (I1 < 2 && I0 >= 4 && I0 < 6 && I3 >= 2 && I3 < 4 && I2 >= 6)
                 return _mm256_shuffle_pd(y, x, smask);
 
-            return shuffle(x, y, mask, generic {});
+            return shuffle(x, y, mask, common {});
         }
 
         // slide_left
diff --git a/include/xsimd/arch/xsimd_avx2.hpp b/include/xsimd/arch/xsimd_avx2.hpp
index d1f89d223..3ab8517a9 100644
--- a/include/xsimd/arch/xsimd_avx2.hpp
+++ b/include/xsimd/arch/xsimd_avx2.hpp
@@ -90,7 +90,7 @@ namespace xsimd
             }
             else
             {
-                return avgr(self, other, generic {});
+                return avgr(self, other, common {});
             }
         }
 
@@ -110,7 +110,7 @@ namespace xsimd
             }
             else
             {
-                return avg(self, other, generic {});
+                return avg(self, other, common {});
             }
         }
 
diff --git a/include/xsimd/arch/xsimd_avx512bw.hpp b/include/xsimd/arch/xsimd_avx512bw.hpp
index 136adf1fe..832cba6a1 100644
--- a/include/xsimd/arch/xsimd_avx512bw.hpp
+++ b/include/xsimd/arch/xsimd_avx512bw.hpp
@@ -126,7 +126,7 @@ namespace xsimd
             }
             else
             {
-                return avgr(self, other, generic {});
+                return avgr(self, other, common {});
             }
         }
 
@@ -146,7 +146,7 @@ namespace xsimd
             }
             else
             {
-                return avg(self, other, generic {});
+                return avg(self, other, common {});
             }
         }
 
diff --git a/include/xsimd/arch/xsimd_avx512f.hpp b/include/xsimd/arch/xsimd_avx512f.hpp
index d58724a61..dc46cd867 100644
--- a/include/xsimd/arch/xsimd_avx512f.hpp
+++ b/include/xsimd/arch/xsimd_avx512f.hpp
@@ -27,15 +27,15 @@ namespace xsimd
 
         // fwd
         template <class A, class T, class Mask>
-        XSIMD_INLINE batch<T, A> decr_if(batch<T, A> const& self, Mask const& mask, requires_arch<generic>) noexcept;
+        XSIMD_INLINE batch<T, A> decr_if(batch<T, A> const& self, Mask const& mask, requires_arch<common>) noexcept;
         template <class A, class T, class Mask>
-        XSIMD_INLINE batch<T, A> incr_if(batch<T, A> const& self, Mask const& mask, requires_arch<generic>) noexcept;
+        XSIMD_INLINE batch<T, A> incr_if(batch<T, A> const& self, Mask const& mask, requires_arch<common>) noexcept;
         template <class A, class T, size_t I>
-        XSIMD_INLINE batch<T, A> insert(batch<T, A> const& self, T val, index<I>, requires_arch<generic>) noexcept;
+        XSIMD_INLINE batch<T, A> insert(batch<T, A> const& self, T val, index<I>, requires_arch<common>) noexcept;
         template <class A>
-        XSIMD_INLINE void transpose(batch<uint16_t, A>* matrix_begin, batch<uint16_t, A>* matrix_end, requires_arch<generic>) noexcept;
+        XSIMD_INLINE void transpose(batch<uint16_t, A>* matrix_begin, batch<uint16_t, A>* matrix_end, requires_arch<common>) noexcept;
         template <class A>
-        XSIMD_INLINE void transpose(batch<uint8_t, A>* matrix_begin, batch<uint8_t, A>* matrix_end, requires_arch<generic>) noexcept;
+        XSIMD_INLINE void transpose(batch<uint8_t, A>* matrix_begin, batch<uint8_t, A>* matrix_end, requires_arch<common>) noexcept;
 
         namespace detail
         {
@@ -778,7 +778,7 @@ namespace xsimd
             }
             else
             {
-                return decr_if(self, mask, generic {});
+                return decr_if(self, mask, common {});
             }
         }
 
@@ -1112,7 +1112,7 @@ namespace xsimd
             }
             else
             {
-                return incr_if(self, mask, generic {});
+                return incr_if(self, mask, common {});
             }
         }
 
@@ -1144,7 +1144,7 @@ namespace xsimd
             }
             else
             {
-                return insert(self, val, pos, generic {});
+                return insert(self, val, pos, common {});
             }
         }
 
@@ -1826,7 +1826,7 @@ namespace xsimd
             if ((I4 == I0 + 4) && (I5 == I1 + 4) && (I6 == I2 + 4) && (I7 == I3 + 4) && (I8 == I0 + 8) && (I9 == I1 + 8) && (I10 == I2 + 8) && (I11 == I3 + 8) && (I12 == I0 + 12) && (I13 == I1 + 12) && (I14 == I2 + 12) && (I15 == I3 + 12) && I2 < 4 && I3 < 4 && I0 >= 16 && I0 < 20 && I1 >= 16 && I1 < 20)
                 return _mm512_shuffle_ps(y, x, smask);
 
-            return shuffle(x, y, mask, generic {});
+            return shuffle(x, y, mask, common {});
         }
 
         template <class A, class ITy, ITy I0, ITy I1, ITy I2, ITy I3, ITy I4, ITy I5, ITy I6, ITy I7>
@@ -1841,7 +1841,7 @@ namespace xsimd
             if (I1 < 2 && I0 >= 8 && I0 < 10 && I3 >= 2 && I3 < 4 && I2 >= 10 && I2 < 12 && I5 >= 4 && I5 < 6 && I4 >= 12 && I4 < 14 && I7 >= 6 && I7 < 8 && I6 >= 14)
                 return _mm512_shuffle_pd(y, x, smask);
 
-            return shuffle(x, y, mask, generic {});
+            return shuffle(x, y, mask, common {});
         }
 
         // slide_left
@@ -2095,7 +2095,7 @@ namespace xsimd
         swizzle(batch<uint16_t, A> const& self, batch_constant<uint16_t, A, (uint16_t)1, (uint16_t)1, (uint16_t)0, (uint16_t)1, (uint16_t)0, (uint16_t)1, (uint16_t)0, (uint16_t)1, (uint16_t)0, (uint16_t)1, (uint16_t)0, (uint16_t)1, (uint16_t)0, (uint16_t)1, (uint16_t)0, (uint16_t)1, (uint16_t)0, (uint16_t)1, (uint16_t)0, (uint16_t)1, (uint16_t)0, (uint16_t)1, (uint16_t)0, (uint16_t)1, (uint16_t)0, (uint16_t)1, (uint16_t)0, (uint16_t)1, (uint16_t)0, (uint16_t)1, (uint16_t)0, (uint16_t)1>, requires_arch<avx512f>) noexcept
         {
             // FIXME: this sequence is very inefficient, but it's here to catch
-            // a pattern generated by detail::reduce from xsimd_generic_math.hpp.
+            // a pattern generated by detail::reduce from xsimd_common_math.hpp.
             // The whole pattern is actually decently folded by GCC and Clang,
             // so bare with it.
             constexpr batch_constant<uint32_t, A, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0> mask32;
diff --git a/include/xsimd/arch/xsimd_generic.hpp b/include/xsimd/arch/xsimd_common.hpp
similarity index 67%
rename from include/xsimd/arch/xsimd_generic.hpp
rename to include/xsimd/arch/xsimd_common.hpp
index 6403cfb0f..4f8c09f37 100644
--- a/include/xsimd/arch/xsimd_generic.hpp
+++ b/include/xsimd/arch/xsimd_common.hpp
@@ -9,15 +9,15 @@
  * The full license is in the file LICENSE, distributed with this software. *
  ****************************************************************************/
 
-#ifndef XSIMD_GENERIC_HPP
-#define XSIMD_GENERIC_HPP
+#ifndef XSIMD_COMMON_HPP
+#define XSIMD_COMMON_HPP
 
-#include "./generic/xsimd_generic_arithmetic.hpp"
-#include "./generic/xsimd_generic_complex.hpp"
-#include "./generic/xsimd_generic_logical.hpp"
-#include "./generic/xsimd_generic_math.hpp"
-#include "./generic/xsimd_generic_memory.hpp"
-#include "./generic/xsimd_generic_rounding.hpp"
-#include "./generic/xsimd_generic_trigo.hpp"
+#include "./common/xsimd_common_arithmetic.hpp"
+#include "./common/xsimd_common_complex.hpp"
+#include "./common/xsimd_common_logical.hpp"
+#include "./common/xsimd_common_math.hpp"
+#include "./common/xsimd_common_memory.hpp"
+#include "./common/xsimd_common_rounding.hpp"
+#include "./common/xsimd_common_trigo.hpp"
 
 #endif
diff --git a/include/xsimd/arch/xsimd_generic_fwd.hpp b/include/xsimd/arch/xsimd_common_fwd.hpp
similarity index 82%
rename from include/xsimd/arch/xsimd_generic_fwd.hpp
rename to include/xsimd/arch/xsimd_common_fwd.hpp
index 02708d60f..26a9bdbdb 100644
--- a/include/xsimd/arch/xsimd_generic_fwd.hpp
+++ b/include/xsimd/arch/xsimd_common_fwd.hpp
@@ -9,8 +9,8 @@
  * The full license is in the file LICENSE, distributed with this software. *
  ****************************************************************************/
 
-#ifndef XSIMD_GENERIC_FWD_HPP
-#define XSIMD_GENERIC_FWD_HPP
+#ifndef XSIMD_COMMON_FWD_HPP
+#define XSIMD_COMMON_FWD_HPP
 
 #include "../types/xsimd_batch_constant.hpp"
 
@@ -22,21 +22,21 @@ namespace xsimd
     {
         // forward declaration
         template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
-        XSIMD_INLINE batch<T, A> abs(batch<T, A> const& self, requires_arch<generic>) noexcept;
+        XSIMD_INLINE batch<T, A> abs(batch<T, A> const& self, requires_arch<common>) noexcept;
         template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
-        XSIMD_INLINE batch<T, A> bitwise_lshift(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept;
+        XSIMD_INLINE batch<T, A> bitwise_lshift(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept;
         template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
-        XSIMD_INLINE batch<T, A> bitwise_rshift(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept;
+        XSIMD_INLINE batch<T, A> bitwise_rshift(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept;
         template <class A, class T>
-        XSIMD_INLINE batch_bool<T, A> gt(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept;
+        XSIMD_INLINE batch_bool<T, A> gt(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept;
         template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
-        XSIMD_INLINE batch<T, A> mul(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept;
+        XSIMD_INLINE batch<T, A> mul(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept;
         template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
-        XSIMD_INLINE batch<T, A> sadd(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept;
+        XSIMD_INLINE batch<T, A> sadd(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept;
         template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
-        XSIMD_INLINE batch<T, A> ssub(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept;
+        XSIMD_INLINE batch<T, A> ssub(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept;
         template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
-        XSIMD_INLINE T hadd(batch<T, A> const& self, requires_arch<generic>) noexcept;
+        XSIMD_INLINE T hadd(batch<T, A> const& self, requires_arch<common>) noexcept;
 
     }
 }
diff --git a/include/xsimd/arch/xsimd_emulated.hpp b/include/xsimd/arch/xsimd_emulated.hpp
index 2f4585bbb..11e607479 100644
--- a/include/xsimd/arch/xsimd_emulated.hpp
+++ b/include/xsimd/arch/xsimd_emulated.hpp
@@ -39,9 +39,9 @@ namespace xsimd
 
         // fwd
         template <class A, class T, size_t I>
-        XSIMD_INLINE batch<T, A> insert(batch<T, A> const& self, T val, index<I>, requires_arch<generic>) noexcept;
+        XSIMD_INLINE batch<T, A> insert(batch<T, A> const& self, T val, index<I>, requires_arch<common>) noexcept;
         template <class A, typename T, typename ITy, ITy... Indices>
-        XSIMD_INLINE batch<T, A> shuffle(batch<T, A> const& x, batch<T, A> const& y, batch_constant<ITy, A, Indices...>, requires_arch<generic>) noexcept;
+        XSIMD_INLINE batch<T, A> shuffle(batch<T, A> const& x, batch<T, A> const& y, batch_constant<ITy, A, Indices...>, requires_arch<common>) noexcept;
 
         namespace detail
         {
diff --git a/include/xsimd/arch/xsimd_isa.hpp b/include/xsimd/arch/xsimd_isa.hpp
index a617f836d..f88d94f93 100644
--- a/include/xsimd/arch/xsimd_isa.hpp
+++ b/include/xsimd/arch/xsimd_isa.hpp
@@ -14,7 +14,7 @@
 
 #include "../config/xsimd_arch.hpp"
 
-#include "./xsimd_generic_fwd.hpp"
+#include "./xsimd_common_fwd.hpp"
 
 #if XSIMD_WITH_EMULATED
 #include "./xsimd_emulated.hpp"
@@ -129,6 +129,6 @@
 #endif
 
 // Must come last to have access to all conversion specializations.
-#include "./xsimd_generic.hpp"
+#include "./xsimd_common.hpp"
 
 #endif
diff --git a/include/xsimd/arch/xsimd_neon.hpp b/include/xsimd/arch/xsimd_neon.hpp
index 2d0a24452..ac3cdacd0 100644
--- a/include/xsimd/arch/xsimd_neon.hpp
+++ b/include/xsimd/arch/xsimd_neon.hpp
@@ -1678,14 +1678,14 @@ namespace xsimd
          * reduce_max *
          **************/
 
-        // Using generic implementation because ARM doe snot provide intrinsics
+        // Using common implementation because ARM doe snot provide intrinsics
         // for this operation
 
         /**************
          * reduce_min *
          **************/
 
-        // Using generic implementation because ARM doe snot provide intrinsics
+        // Using common implementation because ARM doe snot provide intrinsics
         // for this operation
 
         /**********
diff --git a/include/xsimd/arch/xsimd_scalar.hpp b/include/xsimd/arch/xsimd_scalar.hpp
index f72dc76a7..82f284958 100644
--- a/include/xsimd/arch/xsimd_scalar.hpp
+++ b/include/xsimd/arch/xsimd_scalar.hpp
@@ -1123,7 +1123,7 @@ namespace xsimd
         XSIMD_HASSINCOS_TRAIT(__sincos);
         XSIMD_HASSINCOS_TRAIT(__sincosf);
 
-        struct generic_sincosf
+        struct common_sincosf
         {
             template <class T>
             XSIMD_INLINE typename std::enable_if<XSIMD_HASSINCOS(sincosf, T), void>::type
@@ -1148,7 +1148,7 @@ namespace xsimd
             }
         };
 
-        struct generic_sincos
+        struct common_sincos
         {
             template <class T>
             XSIMD_INLINE typename std::enable_if<XSIMD_HASSINCOS(sincos, T), void>::type
@@ -1180,14 +1180,14 @@ namespace xsimd
     XSIMD_INLINE std::pair<float, float> sincos(float val) noexcept
     {
         float s, c;
-        detail::generic_sincosf {}(val, s, c);
+        detail::common_sincosf {}(val, s, c);
         return std::make_pair(s, c);
     }
 
     XSIMD_INLINE std::pair<double, double> sincos(double val) noexcept
     {
         double s, c;
-        detail::generic_sincos {}(val, s, c);
+        detail::common_sincos {}(val, s, c);
         return std::make_pair(s, c);
     }
 
diff --git a/include/xsimd/arch/xsimd_sse2.hpp b/include/xsimd/arch/xsimd_sse2.hpp
index fed786576..94d7af5d4 100644
--- a/include/xsimd/arch/xsimd_sse2.hpp
+++ b/include/xsimd/arch/xsimd_sse2.hpp
@@ -57,13 +57,13 @@ namespace xsimd
 
         // fwd
         template <class A, class T, size_t I>
-        XSIMD_INLINE batch<T, A> insert(batch<T, A> const& self, T val, index<I>, requires_arch<generic>) noexcept;
+        XSIMD_INLINE batch<T, A> insert(batch<T, A> const& self, T val, index<I>, requires_arch<common>) noexcept;
         template <class A, typename T, typename ITy, ITy... Indices>
-        XSIMD_INLINE batch<T, A> shuffle(batch<T, A> const& x, batch<T, A> const& y, batch_constant<ITy, A, Indices...>, requires_arch<generic>) noexcept;
+        XSIMD_INLINE batch<T, A> shuffle(batch<T, A> const& x, batch<T, A> const& y, batch_constant<ITy, A, Indices...>, requires_arch<common>) noexcept;
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> avg(batch<T, A> const&, batch<T, A> const&, requires_arch<generic>) noexcept;
+        XSIMD_INLINE batch<T, A> avg(batch<T, A> const&, batch<T, A> const&, requires_arch<common>) noexcept;
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> avgr(batch<T, A> const&, batch<T, A> const&, requires_arch<generic>) noexcept;
+        XSIMD_INLINE batch<T, A> avgr(batch<T, A> const&, batch<T, A> const&, requires_arch<common>) noexcept;
 
         // abs
         template <class A>
@@ -166,7 +166,7 @@ namespace xsimd
             }
             else
             {
-                return avgr(self, other, generic {});
+                return avgr(self, other, common {});
             }
         }
 
@@ -186,7 +186,7 @@ namespace xsimd
             }
             else
             {
-                return avg(self, other, generic {});
+                return avg(self, other, common {});
             }
         }
 
@@ -806,12 +806,12 @@ namespace xsimd
                 }
                 else
                 {
-                    return gt(self, other, generic {});
+                    return gt(self, other, common {});
                 }
             }
             else
             {
-                return gt(self, other, generic {});
+                return gt(self, other, common {});
             }
         }
 
@@ -859,7 +859,7 @@ namespace xsimd
             }
             else
             {
-                return insert(self, val, pos, generic {});
+                return insert(self, val, pos, common {});
             }
         }
 
@@ -1243,7 +1243,7 @@ namespace xsimd
             }
             else
             {
-                return hadd(self, generic {});
+                return hadd(self, common {});
             }
         }
 
@@ -1344,7 +1344,7 @@ namespace xsimd
             // shuffle within opposite lane
             if (I0 >= 4 && I1 >= 4 && I2 < 4 && I3 < 4)
                 return _mm_shuffle_ps(y, x, smask);
-            return shuffle(x, y, mask, generic {});
+            return shuffle(x, y, mask, common {});
         }
 
         template <class A, class ITy, ITy I0, ITy I1>
@@ -1358,7 +1358,7 @@ namespace xsimd
             // shuffle within opposite lane
             if (I0 >= 2 && I1 < 2)
                 return _mm_shuffle_pd(y, x, smask);
-            return shuffle(x, y, mask, generic {});
+            return shuffle(x, y, mask, common {});
         }
 
         // sqrt
@@ -1404,7 +1404,7 @@ namespace xsimd
                 }
                 else
                 {
-                    return sadd(self, other, generic {});
+                    return sadd(self, other, common {});
                 }
             }
             else
@@ -1419,7 +1419,7 @@ namespace xsimd
                 }
                 else
                 {
-                    return sadd(self, other, generic {});
+                    return sadd(self, other, common {});
                 }
             }
         }
@@ -1497,7 +1497,7 @@ namespace xsimd
                 }
                 else
                 {
-                    return ssub(self, other, generic {});
+                    return ssub(self, other, common {});
                 }
             }
             else
@@ -1512,7 +1512,7 @@ namespace xsimd
                 }
                 else
                 {
-                    return ssub(self, other, generic {});
+                    return ssub(self, other, common {});
                 }
             }
         }
diff --git a/include/xsimd/arch/xsimd_wasm.hpp b/include/xsimd/arch/xsimd_wasm.hpp
index 9d2983992..f4721aedd 100644
--- a/include/xsimd/arch/xsimd_wasm.hpp
+++ b/include/xsimd/arch/xsimd_wasm.hpp
@@ -34,13 +34,13 @@ namespace xsimd
 
         // fwd
         template <class A, class T, size_t I>
-        XSIMD_INLINE batch<T, A> insert(batch<T, A> const& self, T val, index<I>, requires_arch<generic>) noexcept;
+        XSIMD_INLINE batch<T, A> insert(batch<T, A> const& self, T val, index<I>, requires_arch<common>) noexcept;
         template <class A, typename T, typename ITy, ITy... Indices>
-        XSIMD_INLINE batch<T, A> shuffle(batch<T, A> const& x, batch<T, A> const& y, batch_constant<ITy, A, Indices...>, requires_arch<generic>) noexcept;
+        XSIMD_INLINE batch<T, A> shuffle(batch<T, A> const& x, batch<T, A> const& y, batch_constant<ITy, A, Indices...>, requires_arch<common>) noexcept;
         template <class A, class T>
-        XSIMD_INLINE batch<T, A> avg(batch<T, A> const&, batch<T, A> const&, requires_arch<generic>) noexcept;
+        XSIMD_INLINE batch<T, A> avg(batch<T, A> const&, batch<T, A> const&, requires_arch<common>) noexcept;
         template <class A, class T>
-        XSIMD_INLINE void transpose(batch<T, A>* matrix_begin, batch<T, A>* matrix_end, requires_arch<generic>) noexcept;
+        XSIMD_INLINE void transpose(batch<T, A>* matrix_begin, batch<T, A>* matrix_end, requires_arch<common>) noexcept;
 
         // abs
         template <class A, class T, typename std::enable_if<std::is_integral<T>::value && std::is_signed<T>::value, void>::type>
@@ -134,7 +134,7 @@ namespace xsimd
             }
             else
             {
-                return avgr(self, other, generic {});
+                return avgr(self, other, common {});
             }
         }
 
@@ -154,7 +154,7 @@ namespace xsimd
             }
             else
             {
-                return avg(self, other, generic {});
+                return avg(self, other, common {});
             }
         }
 
@@ -728,7 +728,7 @@ namespace xsimd
                 }
                 else
                 {
-                    return gt(self, other, generic {});
+                    return gt(self, other, common {});
                 }
             }
         }
@@ -1170,7 +1170,7 @@ namespace xsimd
             }
             else
             {
-                return hadd(self, generic {});
+                return hadd(self, common {});
             }
         }
         template <class A>
@@ -1244,7 +1244,7 @@ namespace xsimd
                 }
                 else
                 {
-                    return sadd(self, other, generic {});
+                    return sadd(self, other, common {});
                 }
             }
             else
@@ -1259,7 +1259,7 @@ namespace xsimd
                 }
                 else
                 {
-                    return sadd(self, other, generic {});
+                    return sadd(self, other, common {});
                 }
             }
         }
@@ -1375,7 +1375,7 @@ namespace xsimd
                 }
                 else
                 {
-                    return ssub(self, other, generic {});
+                    return ssub(self, other, common {});
                 }
             }
             else
@@ -1390,7 +1390,7 @@ namespace xsimd
                 }
                 else
                 {
-                    return ssub(self, other, generic {});
+                    return ssub(self, other, common {});
                 }
             }
         }
@@ -1608,7 +1608,7 @@ namespace xsimd
             }
             else
             {
-                transpose(matrix_begin, matrix_end, generic {});
+                transpose(matrix_begin, matrix_end, common {});
             }
         }
 
diff --git a/include/xsimd/memory/xsimd_aligned_allocator.hpp b/include/xsimd/memory/xsimd_aligned_allocator.hpp
index f6e9c9d12..6d4431f13 100644
--- a/include/xsimd/memory/xsimd_aligned_allocator.hpp
+++ b/include/xsimd/memory/xsimd_aligned_allocator.hpp
@@ -39,7 +39,7 @@ namespace xsimd
      * @tparam T type of objects to allocate.
      * @tparam Align alignment in bytes.
      */
-    template <class T, size_t Align = std::conditional<std::is_same<unsupported, default_arch>::value, generic, default_arch>::type::alignment()>
+    template <class T, size_t Align = std::conditional<std::is_same<unsupported, default_arch>::value, common, default_arch>::type::alignment()>
     class aligned_allocator
     {
     public:
diff --git a/include/xsimd/types/xsimd_avx512f_register.hpp b/include/xsimd/types/xsimd_avx512f_register.hpp
index 7f4bda929..c7af6d9f7 100644
--- a/include/xsimd/types/xsimd_avx512f_register.hpp
+++ b/include/xsimd/types/xsimd_avx512f_register.hpp
@@ -12,7 +12,7 @@
 #ifndef XSIMD_AVX512F_REGISTER_HPP
 #define XSIMD_AVX512F_REGISTER_HPP
 
-#include "./xsimd_generic_arch.hpp"
+#include "./xsimd_common_arch.hpp"
 
 namespace xsimd
 {
@@ -22,7 +22,7 @@ namespace xsimd
      *
      * AVX512F instructions
      */
-    struct avx512f : generic
+    struct avx512f : common
     {
         static constexpr bool supported() noexcept { return XSIMD_WITH_AVX512F; }
         static constexpr bool available() noexcept { return true; }
diff --git a/include/xsimd/types/xsimd_avx_register.hpp b/include/xsimd/types/xsimd_avx_register.hpp
index 0cd423473..47997ee76 100644
--- a/include/xsimd/types/xsimd_avx_register.hpp
+++ b/include/xsimd/types/xsimd_avx_register.hpp
@@ -12,7 +12,7 @@
 #ifndef XSIMD_AVX_REGISTER_HPP
 #define XSIMD_AVX_REGISTER_HPP
 
-#include "./xsimd_generic_arch.hpp"
+#include "./xsimd_common_arch.hpp"
 
 namespace xsimd
 {
@@ -22,7 +22,7 @@ namespace xsimd
      *
      * AVX instructions
      */
-    struct avx : generic
+    struct avx : common
     {
         static constexpr bool supported() noexcept { return XSIMD_WITH_AVX; }
         static constexpr bool available() noexcept { return true; }
diff --git a/include/xsimd/types/xsimd_generic_arch.hpp b/include/xsimd/types/xsimd_common_arch.hpp
similarity index 91%
rename from include/xsimd/types/xsimd_generic_arch.hpp
rename to include/xsimd/types/xsimd_common_arch.hpp
index d16a37fea..28491aeda 100644
--- a/include/xsimd/types/xsimd_generic_arch.hpp
+++ b/include/xsimd/types/xsimd_common_arch.hpp
@@ -9,8 +9,8 @@
  * The full license is in the file LICENSE, distributed with this software. *
  ****************************************************************************/
 
-#ifndef XSIMD_GENERIC_ARCH_HPP
-#define XSIMD_GENERIC_ARCH_HPP
+#ifndef XSIMD_COMMON_ARCH_HPP
+#define XSIMD_COMMON_ARCH_HPP
 
 #include "../config/xsimd_config.hpp"
 
@@ -24,7 +24,7 @@ namespace xsimd
      *
      * Base class for all architectures.
      */
-    struct generic
+    struct common
     {
         /// Whether this architecture is supported at compile-time.
         static constexpr bool supported() noexcept { return true; }
@@ -36,7 +36,7 @@ namespace xsimd
         /// Whether this architecture requires aligned memory access.
         static constexpr bool requires_alignment() noexcept { return false; }
         /// Name of the architecture.
-        static constexpr char const* name() noexcept { return "generic"; }
+        static constexpr char const* name() noexcept { return "common"; }
     };
 
     struct unsupported
diff --git a/include/xsimd/types/xsimd_emulated_register.hpp b/include/xsimd/types/xsimd_emulated_register.hpp
index 6e0d659bd..306ca0cf4 100644
--- a/include/xsimd/types/xsimd_emulated_register.hpp
+++ b/include/xsimd/types/xsimd_emulated_register.hpp
@@ -12,7 +12,7 @@
 #ifndef XSIMD_EMULATED_REGISTER_HPP
 #define XSIMD_EMULATED_REGISTER_HPP
 
-#include "./xsimd_generic_arch.hpp"
+#include "./xsimd_common_arch.hpp"
 #include "./xsimd_register.hpp"
 
 namespace xsimd
@@ -23,7 +23,7 @@ namespace xsimd
      * emulated instructions
      */
     template <size_t N>
-    struct emulated : generic
+    struct emulated : common
     {
         static constexpr bool supported() noexcept { return true; }
         static constexpr bool available() noexcept { return true; }
diff --git a/include/xsimd/types/xsimd_neon_register.hpp b/include/xsimd/types/xsimd_neon_register.hpp
index a9f4a46c8..4f40a4287 100644
--- a/include/xsimd/types/xsimd_neon_register.hpp
+++ b/include/xsimd/types/xsimd_neon_register.hpp
@@ -12,7 +12,7 @@
 #ifndef XSIMD_NEON_REGISTER_HPP
 #define XSIMD_NEON_REGISTER_HPP
 
-#include "xsimd_generic_arch.hpp"
+#include "xsimd_common_arch.hpp"
 #include "xsimd_register.hpp"
 
 #if XSIMD_WITH_NEON
@@ -26,7 +26,7 @@ namespace xsimd
      *
      * NEON instructions for arm32
      */
-    struct neon : generic
+    struct neon : common
     {
         static constexpr bool supported() noexcept { return XSIMD_WITH_NEON; }
         static constexpr bool available() noexcept { return true; }
diff --git a/include/xsimd/types/xsimd_rvv_register.hpp b/include/xsimd/types/xsimd_rvv_register.hpp
index 4d5258d30..feadc00f9 100644
--- a/include/xsimd/types/xsimd_rvv_register.hpp
+++ b/include/xsimd/types/xsimd_rvv_register.hpp
@@ -13,7 +13,7 @@
 #ifndef XSIMD_RVV_REGISTER_HPP
 #define XSIMD_RVV_REGISTER_HPP
 
-#include "xsimd_generic_arch.hpp"
+#include "xsimd_common_arch.hpp"
 #include "xsimd_register.hpp"
 
 #if XSIMD_WITH_RVV
@@ -30,7 +30,7 @@ namespace xsimd
          * RVV instructions (fixed vector size) for riscv
          */
         template <size_t Width>
-        struct rvv : xsimd::generic
+        struct rvv : xsimd::common
         {
             static constexpr size_t width = Width;
             static constexpr bool supported() noexcept { return Width == XSIMD_RVV_BITS; }
diff --git a/include/xsimd/types/xsimd_sse2_register.hpp b/include/xsimd/types/xsimd_sse2_register.hpp
index e6eabec7a..48c1fd53f 100644
--- a/include/xsimd/types/xsimd_sse2_register.hpp
+++ b/include/xsimd/types/xsimd_sse2_register.hpp
@@ -12,7 +12,7 @@
 #ifndef XSIMD_SSE2_REGISTER_HPP
 #define XSIMD_SSE2_REGISTER_HPP
 
-#include "./xsimd_generic_arch.hpp"
+#include "./xsimd_common_arch.hpp"
 #include "./xsimd_register.hpp"
 
 #if XSIMD_WITH_SSE2
@@ -27,7 +27,7 @@ namespace xsimd
      *
      * SSE2 instructions
      */
-    struct sse2 : generic
+    struct sse2 : common
     {
         static constexpr bool supported() noexcept { return XSIMD_WITH_SSE2; }
         static constexpr bool available() noexcept { return true; }
diff --git a/include/xsimd/types/xsimd_sve_register.hpp b/include/xsimd/types/xsimd_sve_register.hpp
index 29564d023..9d33fc484 100644
--- a/include/xsimd/types/xsimd_sve_register.hpp
+++ b/include/xsimd/types/xsimd_sve_register.hpp
@@ -13,7 +13,7 @@
 #ifndef XSIMD_SVE_REGISTER_HPP
 #define XSIMD_SVE_REGISTER_HPP
 
-#include "xsimd_generic_arch.hpp"
+#include "xsimd_common_arch.hpp"
 #include "xsimd_register.hpp"
 
 #if XSIMD_WITH_SVE
@@ -30,7 +30,7 @@ namespace xsimd
          * SVE instructions (fixed vector size) for arm64
          */
         template <size_t Width>
-        struct sve : xsimd::generic
+        struct sve : xsimd::common
         {
             static constexpr bool supported() noexcept { return Width == XSIMD_SVE_BITS; }
             static constexpr bool available() noexcept { return true; }
diff --git a/include/xsimd/types/xsimd_wasm_register.hpp b/include/xsimd/types/xsimd_wasm_register.hpp
index a1b840360..70b6ff9ad 100644
--- a/include/xsimd/types/xsimd_wasm_register.hpp
+++ b/include/xsimd/types/xsimd_wasm_register.hpp
@@ -13,7 +13,7 @@
 #ifndef XSIMD_WASM_REGISTER_HPP
 #define XSIMD_WASM_REGISTER_HPP
 
-#include "xsimd_generic_arch.hpp"
+#include "xsimd_common_arch.hpp"
 #include "xsimd_register.hpp"
 
 #if XSIMD_WITH_WASM
@@ -27,7 +27,7 @@ namespace xsimd
      *
      * WASM instructions
      */
-    struct wasm : generic
+    struct wasm : common
     {
         static constexpr bool supported() noexcept { return XSIMD_WITH_WASM; }
         static constexpr bool available() noexcept { return true; }
diff --git a/test/test_arch.cpp b/test/test_arch.cpp
index 4a5c3154e..9bb19291f 100644
--- a/test/test_arch.cpp
+++ b/test/test_arch.cpp
@@ -99,8 +99,8 @@ TEST_CASE("[multi arch support]")
 
     SUBCASE("xsimd::arch_list<...>::alignment()")
     {
-        static_assert(xsimd::arch_list<xsimd::generic>::alignment() == 0,
-                      "generic");
+        static_assert(xsimd::arch_list<xsimd::common>::alignment() == 0,
+                      "common");
         static_assert(xsimd::arch_list<xsimd::sse2>::alignment()
                           == xsimd::sse2::alignment(),
                       "one architecture");
diff --git a/test/test_batch.cpp b/test/test_batch.cpp
index 49559b25d..dc6b1940d 100644
--- a/test/test_batch.cpp
+++ b/test/test_batch.cpp
@@ -803,17 +803,17 @@ struct batch_test
     }
 
     template <size_t N>
-    typename std::enable_if<4 <= N, void>::type test_generic_horizontal_operations(std::integral_constant<size_t, N>) const
+    typename std::enable_if<4 <= N, void>::type test_common_horizontal_operations(std::integral_constant<size_t, N>) const
     {
-        // reduce generic
+        // reduce common
         {
             value_type expected = std::accumulate(lhs.cbegin(), lhs.cend(), value_type(1), std::multiplies<value_type>());
             value_type res = reduce(xsimd::mul<typename B::value_type, typename B::arch_type>, batch_lhs());
-            INFO("generic reduce");
+            INFO("common reduce");
             CHECK_SCALAR_EQ(res, expected);
         }
     }
-    void test_generic_horizontal_operations(...) const { }
+    void test_common_horizontal_operations(...) const { }
 
     void test_boolean_conversions() const
     {
@@ -986,7 +986,7 @@ TEST_CASE_TEMPLATE("[batch]", B, BATCH_TYPES)
     SUBCASE("horizontal_operations")
     {
         Test.test_horizontal_operations();
-        Test.test_generic_horizontal_operations(std::integral_constant<size_t, sizeof(typename B::value_type)>());
+        Test.test_common_horizontal_operations(std::integral_constant<size_t, sizeof(typename B::value_type)>());
     }
 
     SUBCASE("boolean_conversions")
diff --git a/test/test_shuffle.cpp b/test/test_shuffle.cpp
index a2f66157d..1c7c9884b 100644
--- a/test/test_shuffle.cpp
+++ b/test/test_shuffle.cpp
@@ -332,7 +332,7 @@ struct compress_test
         CHECK_BATCH_EQ(b, expected);
     }
 
-    void generic()
+    void common()
     {
         for (size_t i = 0; i < size; ++i)
             mask[i] = i % 3 == 0;
@@ -362,9 +362,9 @@ TEST_CASE_TEMPLATE("[compress]", B, BATCH_FLOAT_TYPES, xsimd::batch<uint8_t>, xs
     //{
     //      Test.interleave();
     // }
-    // SUBCASE("generic")
+    // SUBCASE("common")
     //{
-    //      Test.generic();
+    //      Test.common();
     // }
 }
 
@@ -428,7 +428,7 @@ struct expand_test
         CHECK_BATCH_EQ(b, expected);
     }
 
-    void generic()
+    void common()
     {
         for (size_t i = 0; i < size; ++i)
             mask[i] = i % 3 == 0;
@@ -458,9 +458,9 @@ TEST_CASE_TEMPLATE("[expand]", B, BATCH_FLOAT_TYPES, xsimd::batch<uint8_t>, xsim
     {
         Test.interleave();
     }
-    SUBCASE("generic")
+    SUBCASE("common")
     {
-        Test.generic();
+        Test.common();
     }
 }
 
@@ -514,12 +514,12 @@ struct shuffle_test
         CHECK_BATCH_EQ(b_res_rhs, b_rhs);
     }
 
-    void generic()
+    void common()
     {
         B b_lhs = B::load_unaligned(lhs.data());
         B b_rhs = B::load_unaligned(rhs.data());
 
-        struct generic_generator
+        struct common_generator
         {
             static constexpr size_t get(size_t index, size_t size)
             {
@@ -535,7 +535,7 @@ struct shuffle_test
         }
         B b_ref = B::load_unaligned(ref.data());
 
-        B b_res = xsimd::shuffle(b_lhs, b_rhs, xsimd::make_batch_constant<mask_type, generic_generator, arch_type>());
+        B b_res = xsimd::shuffle(b_lhs, b_rhs, xsimd::make_batch_constant<mask_type, common_generator, arch_type>());
         CHECK_BATCH_EQ(b_res, b_ref);
     }
 
@@ -697,9 +697,9 @@ TEST_CASE_TEMPLATE("[shuffle]", B, BATCH_FLOAT_TYPES, xsimd::batch<uint32_t>, xs
     {
         Test.no_op();
     }
-    SUBCASE("generic")
+    SUBCASE("common")
     {
-        Test.generic();
+        Test.common();
     }
     SUBCASE("pick")
     {