diff --git a/include/xsimd/arch/xsimd_rvv.hpp b/include/xsimd/arch/xsimd_rvv.hpp
index 12ae39280..42b7e2f51 100644
--- a/include/xsimd/arch/xsimd_rvv.hpp
+++ b/include/xsimd/arch/xsimd_rvv.hpp
@@ -287,7 +287,7 @@ namespace xsimd
 
     namespace kernel
     {
-        namespace detail
+        namespace detail_rvv
         {
             template <class T, size_t Width = XSIMD_RVV_BITS>
             using rvv_reg_t = types::detail::rvv_reg_t<T, Width>;
@@ -380,17 +380,17 @@ namespace xsimd
          * Scalar to vector *
          ********************/
 
-        namespace detail
+        namespace detail_rvv
         {
             template <class T, size_t Width>
-            XSIMD_INLINE detail::rvv_reg_t<T, Width> broadcast(T arg) noexcept
+            XSIMD_INLINE rvv_reg_t<T, Width> broadcast(T arg) noexcept
             {
                 // A bit of a dance, here, because rvvmv_splat has no other
                 // argument from which to deduce type, and T=char is not
                 // supported.
                 project_num_t<T> arg_not_char(arg);
-                const auto splat = detail::rvvmv_splat(arg_not_char);
-                return detail::rvv_reg_t<T, Width>(splat.get_bytes(), types::detail::XSIMD_RVV_BITCAST);
+                const auto splat = rvvmv_splat(arg_not_char);
+                return rvv_reg_t<T, Width>(splat.get_bytes(), types::detail::XSIMD_RVV_BITCAST);
             }
         }
 
@@ -398,14 +398,14 @@ namespace xsimd
         template <class A, class T>
         XSIMD_INLINE batch<T, A> broadcast(T arg, requires_arch<rvv>) noexcept
         {
-            return detail::broadcast<T, A::width>(arg);
+            return detail_rvv::broadcast<T, A::width>(arg);
         }
 
         /*********
          * Load *
          *********/
 
-        namespace detail
+        namespace detail_rvv
         {
             XSIMD_RVV_OVERLOAD(rvvle, (__riscv_vle XSIMD_RVV_S _v_ XSIMD_RVV_TSM), , vec(T const*))
             XSIMD_RVV_OVERLOAD(rvvse, (__riscv_vse XSIMD_RVV_S _v_ XSIMD_RVV_TSM), , void(T*, vec))
@@ -414,7 +414,7 @@ namespace xsimd
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> load_aligned(T const* src, convert<T>, requires_arch<rvv>) noexcept
         {
-            return detail::rvvle(reinterpret_cast<project_num_t<T> const*>(src));
+            return detail_rvv::rvvle(reinterpret_cast<project_num_t<T> const*>(src));
         }
 
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
@@ -424,7 +424,7 @@ namespace xsimd
         }
 
         // load_complex
-        namespace detail
+        namespace detail_rvv
         {
             template <class T, size_t W, std::enable_if_t<W >= types::detail::rvv_width_m1, int> = 0>
             XSIMD_INLINE rvv_reg_t<T, W * 2> rvvabut(rvv_reg_t<T, W> const& lo, rvv_reg_t<T, W> const& hi) noexcept
@@ -464,16 +464,23 @@ namespace xsimd
                 return __riscv_vslidedown(vv, vv.vl / 2, vv.vl);
             }
 
+        }
+
+        // Must be in detail::load_complex for use by common memory.
+        // ODR violation are prevented because the size of the register is encoded
+        // in batch.
+        namespace detail
+        {
             template <class A, class T, detail::enable_floating_point_t<T> = 0>
             XSIMD_INLINE batch<std::complex<T>, A> load_complex(batch<T, A> const& lo, batch<T, A> const& hi, requires_arch<rvv>) noexcept
             {
-                const auto real_index = vindex<A, as_unsigned_integer_t<T>, 0, 1>();
-                const auto imag_index = vindex<A, as_unsigned_integer_t<T>, 1, 1>();
-                const auto index = rvvabut<as_unsigned_integer_t<T>, A::width>(real_index, imag_index);
-                const auto input = rvvabut<T, A::width>(lo.data, hi.data);
-                const rvv_reg_t<T, A::width * 2> result = __riscv_vrgather(input, index, index.vl);
+                const auto real_index = detail_rvv::vindex<A, as_unsigned_integer_t<T>, 0, 1>();
+                const auto imag_index = detail_rvv::vindex<A, as_unsigned_integer_t<T>, 1, 1>();
+                const auto index = detail_rvv::rvvabut<as_unsigned_integer_t<T>, A::width>(real_index, imag_index);
+                const auto input = detail_rvv::rvvabut<T, A::width>(lo.data, hi.data);
+                const detail_rvv::rvv_reg_t<T, A::width * 2> result = __riscv_vrgather(input, index, index.vl);
 
-                return { rvvget_lo<T, A::width>(result), rvvget_hi<T, A::width>(result) };
+                return { detail_rvv::rvvget_lo<T, A::width>(result), detail_rvv::rvvget_hi<T, A::width>(result) };
             }
         }
 
@@ -484,7 +491,7 @@ namespace xsimd
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE void store_aligned(T* dst, batch<T, A> const& src, requires_arch<rvv>) noexcept
         {
-            detail::rvvse(reinterpret_cast<project_num_t<T>*>(dst), src);
+            detail_rvv::rvvse(reinterpret_cast<project_num_t<T>*>(dst), src);
         }
 
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
@@ -497,7 +504,7 @@ namespace xsimd
          * scatter/gather *
          ******************/
 
-        namespace detail
+        namespace detail_rvv
         {
             template <class T, class U>
             using rvv_enable_sg_t = std::enable_if_t<(sizeof(T) == sizeof(U) && (sizeof(T) == 4 || sizeof(T) == 8)), int>;
@@ -510,34 +517,34 @@ namespace xsimd
         }
 
         // scatter
-        template <class A, class T, class U, detail::rvv_enable_sg_t<T, U> = 0>
+        template <class A, class T, class U, detail_rvv::rvv_enable_sg_t<T, U> = 0>
         XSIMD_INLINE void scatter(batch<T, A> const& vals, T* dst, batch<U, A> const& index, kernel::requires_arch<rvv>) noexcept
         {
             using UU = as_unsigned_integer_t<U>;
-            const auto uindex = detail::rvv_to_unsigned_batch(index);
+            const auto uindex = detail_rvv::rvv_to_unsigned_batch(index);
             auto* base = reinterpret_cast<project_num_t<T>*>(dst);
             // or rvvsuxei
-            const auto bi = detail::rvvmul_splat(uindex, sizeof(T));
-            detail::rvvsoxei(base, bi, vals);
+            const auto bi = detail_rvv::rvvmul_splat(uindex, sizeof(T));
+            detail_rvv::rvvsoxei(base, bi, vals);
         }
 
         // gather
-        template <class A, class T, class U, detail::rvv_enable_sg_t<T, U> = 0>
+        template <class A, class T, class U, detail_rvv::rvv_enable_sg_t<T, U> = 0>
         XSIMD_INLINE batch<T, A> gather(batch<T, A> const&, T const* src, batch<U, A> const& index, kernel::requires_arch<rvv>) noexcept
         {
             using UU = as_unsigned_integer_t<U>;
-            const auto uindex = detail::rvv_to_unsigned_batch(index);
+            const auto uindex = detail_rvv::rvv_to_unsigned_batch(index);
             auto const* base = reinterpret_cast<project_num_t<T> const*>(src);
             // or rvvluxei
-            const auto bi = detail::rvvmul_splat(uindex, sizeof(T));
-            return detail::rvvloxei(base, bi);
+            const auto bi = detail_rvv::rvvmul_splat(uindex, sizeof(T));
+            return detail_rvv::rvvloxei(base, bi);
         }
 
         /**************
          * Arithmetic *
          **************/
 
-        namespace detail
+        namespace detail_rvv
         {
             XSIMD_RVV_OVERLOAD3(rvvadd,
                                 (__riscv_vadd),
@@ -621,56 +628,56 @@ namespace xsimd
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> add(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
-            return detail::rvvadd(lhs, rhs);
+            return detail_rvv::rvvadd(lhs, rhs);
         }
 
         // sadd
         template <class A, class T, detail::enable_integral_t<T> = 0>
         XSIMD_INLINE batch<T, A> sadd(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
-            return detail::rvvsadd(lhs, rhs);
+            return detail_rvv::rvvsadd(lhs, rhs);
         }
 
         // sub
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> sub(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
-            return detail::rvvsub(lhs, rhs);
+            return detail_rvv::rvvsub(lhs, rhs);
         }
 
         // ssub
         template <class A, class T, detail::enable_integral_t<T> = 0>
         XSIMD_INLINE batch<T, A> ssub(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
-            return detail::rvvssub(lhs, rhs);
+            return detail_rvv::rvvssub(lhs, rhs);
         }
 
         // mul
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> mul(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
-            return detail::rvvmul(lhs, rhs);
+            return detail_rvv::rvvmul(lhs, rhs);
         }
 
         // div
         template <class A, class T, typename detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> div(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
-            return detail::rvvdiv(lhs, rhs);
+            return detail_rvv::rvvdiv(lhs, rhs);
         }
 
         // max
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> max(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
-            return detail::rvvmax(lhs, rhs);
+            return detail_rvv::rvvmax(lhs, rhs);
         }
 
         // min
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> min(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
-            return detail::rvvmin(lhs, rhs);
+            return detail_rvv::rvvmin(lhs, rhs);
         }
 
         // neg
@@ -678,15 +685,15 @@ namespace xsimd
         XSIMD_INLINE batch<T, A> neg(batch<T, A> const& arg, requires_arch<rvv>) noexcept
         {
             using S = as_signed_integer_t<T>;
-            const auto as_signed = detail::rvvreinterpret<S>(arg);
-            const auto result = detail::rvvneg(as_signed);
-            return detail::rvvreinterpret<T>(result);
+            const auto as_signed = detail_rvv::rvvreinterpret<S>(arg);
+            const auto result = detail_rvv::rvvneg(as_signed);
+            return detail_rvv::rvvreinterpret<T>(result);
         }
 
         template <class A, class T, detail::enable_signed_numeral_t<T> = 0>
         XSIMD_INLINE batch<T, A> neg(batch<T, A> const& arg, requires_arch<rvv>) noexcept
         {
-            return detail::rvvneg(arg);
+            return detail_rvv::rvvneg(arg);
         }
 
         // abs
@@ -699,23 +706,23 @@ namespace xsimd
         template <class A, class T, detail::enable_floating_point_t<T> = 0>
         XSIMD_INLINE batch<T, A> abs(batch<T, A> const& arg, requires_arch<rvv>) noexcept
         {
-            return detail::rvvabs(arg);
+            return detail_rvv::rvvabs(arg);
         }
 
         // fma: x * y + z
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> fma(batch<T, A> const& x, batch<T, A> const& y, batch<T, A> const& z, requires_arch<rvv>) noexcept
         {
-            // also detail::rvvmadd(x, y, z);
-            return detail::rvvmacc(z, x, y);
+            // also detail_rvv::rvvmadd(x, y, z);
+            return detail_rvv::rvvmacc(z, x, y);
         }
 
         // fnma: z - x * y
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> fnma(batch<T, A> const& x, batch<T, A> const& y, batch<T, A> const& z, requires_arch<rvv>) noexcept
         {
-            // also detail::rvvnmsub(x, y, z);
-            return detail::rvvnmsac(z, x, y);
+            // also detail_rvv::rvvnmsub(x, y, z);
+            return detail_rvv::rvvnmsac(z, x, y);
         }
 
         // fms: x * y - z
@@ -740,7 +747,7 @@ namespace xsimd
          * Logical operations *
          **********************/
 
-        namespace detail
+        namespace detail_rvv
         {
             XSIMD_RVV_OVERLOAD_INTS(rvvand, (__riscv_vand), , vec(vec, vec))
             XSIMD_RVV_OVERLOAD_INTS(rvvor, (__riscv_vor), , vec(vec, vec))
@@ -758,118 +765,118 @@ namespace xsimd
         template <class A, class T, detail::enable_integral_t<T> = 0>
         XSIMD_INLINE batch<T, A> bitwise_and(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
-            return detail::rvvand(lhs, rhs);
+            return detail_rvv::rvvand(lhs, rhs);
         }
 
         template <class A, class T, detail::enable_floating_point_t<T> = 0>
         XSIMD_INLINE batch<T, A> bitwise_and(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
-            const auto lhs_bits = detail::rvv_to_unsigned_batch(lhs);
-            const auto rhs_bits = detail::rvv_to_unsigned_batch(rhs);
-            const auto result_bits = detail::rvvand(lhs_bits, rhs_bits);
-            return detail::rvvreinterpret<T>(result_bits);
+            const auto lhs_bits = detail_rvv::rvv_to_unsigned_batch(lhs);
+            const auto rhs_bits = detail_rvv::rvv_to_unsigned_batch(rhs);
+            const auto result_bits = detail_rvv::rvvand(lhs_bits, rhs_bits);
+            return detail_rvv::rvvreinterpret<T>(result_bits);
         }
 
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> bitwise_and(batch_bool<T, A> const& lhs, batch_bool<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
-            return detail::rvvmand(lhs, rhs);
+            return detail_rvv::rvvmand(lhs, rhs);
         }
 
         // bitwise_andnot
         template <class A, class T, detail::enable_integral_t<T> = 0>
         XSIMD_INLINE batch<T, A> bitwise_andnot(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
-            const auto not_rhs = detail::rvvnot(rhs);
-            return detail::rvvand(lhs, not_rhs);
+            const auto not_rhs = detail_rvv::rvvnot(rhs);
+            return detail_rvv::rvvand(lhs, not_rhs);
         }
 
         template <class A, class T, detail::enable_floating_point_t<T> = 0>
         XSIMD_INLINE batch<T, A> bitwise_andnot(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
-            const auto lhs_bits = detail::rvv_to_unsigned_batch(lhs);
-            const auto rhs_bits = detail::rvv_to_unsigned_batch(rhs);
-            const auto not_rhs = detail::rvvnot(rhs_bits);
-            const auto result_bits = detail::rvvand(lhs_bits, not_rhs);
-            return detail::rvvreinterpret<T>(result_bits);
+            const auto lhs_bits = detail_rvv::rvv_to_unsigned_batch(lhs);
+            const auto rhs_bits = detail_rvv::rvv_to_unsigned_batch(rhs);
+            const auto not_rhs = detail_rvv::rvvnot(rhs_bits);
+            const auto result_bits = detail_rvv::rvvand(lhs_bits, not_rhs);
+            return detail_rvv::rvvreinterpret<T>(result_bits);
         }
 
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> bitwise_andnot(batch_bool<T, A> const& lhs, batch_bool<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
-            return detail::rvvmandn(lhs, rhs);
+            return detail_rvv::rvvmandn(lhs, rhs);
         }
 
         // bitwise_or
         template <class A, class T, detail::enable_integral_t<T> = 0>
         XSIMD_INLINE batch<T, A> bitwise_or(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
-            return detail::rvvor(lhs, rhs);
+            return detail_rvv::rvvor(lhs, rhs);
         }
 
         template <class A, class T, detail::enable_floating_point_t<T> = 0>
         XSIMD_INLINE batch<T, A> bitwise_or(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
-            const auto lhs_bits = detail::rvv_to_unsigned_batch(lhs);
-            const auto rhs_bits = detail::rvv_to_unsigned_batch(rhs);
-            const auto result_bits = detail::rvvor(lhs_bits, rhs_bits);
-            return detail::rvvreinterpret<T>(result_bits);
+            const auto lhs_bits = detail_rvv::rvv_to_unsigned_batch(lhs);
+            const auto rhs_bits = detail_rvv::rvv_to_unsigned_batch(rhs);
+            const auto result_bits = detail_rvv::rvvor(lhs_bits, rhs_bits);
+            return detail_rvv::rvvreinterpret<T>(result_bits);
         }
 
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> bitwise_or(batch_bool<T, A> const& lhs, batch_bool<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
-            return detail::rvvmor(lhs, rhs);
+            return detail_rvv::rvvmor(lhs, rhs);
         }
 
         // bitwise_xor
         template <class A, class T, detail::enable_integral_t<T> = 0>
         XSIMD_INLINE batch<T, A> bitwise_xor(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
-            return detail::rvvxor(lhs, rhs);
+            return detail_rvv::rvvxor(lhs, rhs);
         }
 
         template <class A, class T, detail::enable_floating_point_t<T> = 0>
         XSIMD_INLINE batch<T, A> bitwise_xor(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
-            const auto lhs_bits = detail::rvv_to_unsigned_batch(lhs);
-            const auto rhs_bits = detail::rvv_to_unsigned_batch(rhs);
-            const auto result_bits = detail::rvvxor(lhs_bits, rhs_bits);
-            return detail::rvvreinterpret<T>(result_bits);
+            const auto lhs_bits = detail_rvv::rvv_to_unsigned_batch(lhs);
+            const auto rhs_bits = detail_rvv::rvv_to_unsigned_batch(rhs);
+            const auto result_bits = detail_rvv::rvvxor(lhs_bits, rhs_bits);
+            return detail_rvv::rvvreinterpret<T>(result_bits);
         }
 
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> bitwise_xor(batch_bool<T, A> const& lhs, batch_bool<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
-            return detail::rvvmxor(lhs, rhs);
+            return detail_rvv::rvvmxor(lhs, rhs);
         }
 
         // bitwise_not
         template <class A, class T, detail::enable_integral_t<T> = 0>
         XSIMD_INLINE batch<T, A> bitwise_not(batch<T, A> const& arg, requires_arch<rvv>) noexcept
         {
-            return detail::rvvnot(arg);
+            return detail_rvv::rvvnot(arg);
         }
 
         template <class A, class T, detail::enable_floating_point_t<T> = 0>
         XSIMD_INLINE batch<T, A> bitwise_not(batch<T, A> const& arg, requires_arch<rvv>) noexcept
         {
-            const auto arg_bits = detail::rvv_to_unsigned_batch(arg);
-            const auto result_bits = detail::rvvnot(arg_bits);
-            return detail::rvvreinterpret<T>(result_bits);
+            const auto arg_bits = detail_rvv::rvv_to_unsigned_batch(arg);
+            const auto result_bits = detail_rvv::rvvnot(arg_bits);
+            return detail_rvv::rvvreinterpret<T>(result_bits);
         }
 
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> bitwise_not(batch_bool<T, A> const& arg, requires_arch<rvv>) noexcept
         {
-            return detail::rvvmnot(arg);
+            return detail_rvv::rvvmnot(arg);
         }
 
         /**********
          * Shifts *
          **********/
 
-        namespace detail
+        namespace detail_rvv
         {
             XSIMD_RVV_OVERLOAD_INTS(rvvsll_splat, (__riscv_vsll), , vec(vec, size_t))
             XSIMD_RVV_OVERLOAD_INTS(rvvsll, (__riscv_vsll), , vec(vec, uvec))
@@ -887,13 +894,13 @@ namespace xsimd
         {
             constexpr size_t size = sizeof(typename batch<T, A>::value_type) * 8;
             assert(0 <= n && static_cast<size_t>(n) < size && "index in bounds");
-            return detail::rvvsll_splat(arg, n);
+            return detail_rvv::rvvsll_splat(arg, n);
         }
 
         template <class A, class T, detail::enable_integral_t<T> = 0>
         XSIMD_INLINE batch<T, A> bitwise_lshift(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
-            return detail::rvvsll(lhs, detail::rvv_to_unsigned_batch<A, T>(rhs));
+            return detail_rvv::rvvsll(lhs, detail_rvv::rvv_to_unsigned_batch<A, T>(rhs));
         }
 
         // bitwise_rshift
@@ -902,20 +909,20 @@ namespace xsimd
         {
             constexpr size_t size = sizeof(typename batch<T, A>::value_type) * 8;
             assert(0 <= n && static_cast<size_t>(n) < size && "index in bounds");
-            return detail::rvvsr_splat(arg, n);
+            return detail_rvv::rvvsr_splat(arg, n);
         }
 
         template <class A, class T, detail::enable_integral_t<T> = 0>
         XSIMD_INLINE batch<T, A> bitwise_rshift(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
-            return detail::rvvsr(lhs, detail::rvv_to_unsigned_batch<A, T>(rhs));
+            return detail_rvv::rvvsr(lhs, detail_rvv::rvv_to_unsigned_batch<A, T>(rhs));
         }
 
         /**************
          * Reductions *
          **************/
 
-        namespace detail
+        namespace detail_rvv
         {
             XSIMD_RVV_OVERLOAD3(rvvredsum,
                                 (__riscv_vredsum),
@@ -942,34 +949,34 @@ namespace xsimd
             template <class A, class T>
             XSIMD_INLINE T reduce_scalar(rvv_reg_t<T, types::detail::rvv_width_m1> const& arg)
             {
-                return detail::rvvmv_lane0(rvv_reg_t<T, A::width>(arg.get_bytes(), types::detail::XSIMD_RVV_BITCAST));
+                return detail_rvv::rvvmv_lane0(rvv_reg_t<T, A::width>(arg.get_bytes(), types::detail::XSIMD_RVV_BITCAST));
             }
         }
         // reduce_add
         template <class A, class T, class V = typename batch<T, A>::value_type, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE V reduce_add(batch<T, A> const& arg, requires_arch<rvv>) noexcept
         {
-            const auto zero = detail::broadcast<T, types::detail::rvv_width_m1>(T(0));
-            const auto r = detail::rvvredsum(arg, zero);
-            return detail::reduce_scalar<A, T>(r);
+            const auto zero = detail_rvv::broadcast<T, types::detail::rvv_width_m1>(T(0));
+            const auto r = detail_rvv::rvvredsum(arg, zero);
+            return detail_rvv::reduce_scalar<A, T>(r);
         }
 
         // reduce_max
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE T reduce_max(batch<T, A> const& arg, requires_arch<rvv>) noexcept
         {
-            const auto lowest = detail::broadcast<T, types::detail::rvv_width_m1>(std::numeric_limits<T>::lowest());
-            const auto r = detail::rvvredmax(arg, lowest);
-            return detail::reduce_scalar<A, T>(r);
+            const auto lowest = detail_rvv::broadcast<T, types::detail::rvv_width_m1>(std::numeric_limits<T>::lowest());
+            const auto r = detail_rvv::rvvredmax(arg, lowest);
+            return detail_rvv::reduce_scalar<A, T>(r);
         }
 
         // reduce_min
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE T reduce_min(batch<T, A> const& arg, requires_arch<rvv>) noexcept
         {
-            const auto max = detail::broadcast<T, types::detail::rvv_width_m1>(std::numeric_limits<T>::max());
-            const auto r = detail::rvvredmin(arg, max);
-            return detail::reduce_scalar<A, T>(r);
+            const auto max = detail_rvv::broadcast<T, types::detail::rvv_width_m1>(std::numeric_limits<T>::max());
+            const auto r = detail_rvv::rvvredmin(arg, max);
+            return detail_rvv::reduce_scalar<A, T>(r);
         }
 
         // haddp
@@ -994,61 +1001,61 @@ namespace xsimd
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> eq(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
-            return detail::rvvmseq(lhs, rhs);
+            return detail_rvv::rvvmseq(lhs, rhs);
         }
 
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> eq(batch_bool<T, A> const& lhs, batch_bool<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
-            const auto neq_result = detail::rvvmxor(lhs, rhs);
-            return detail::rvvmnot(neq_result);
+            const auto neq_result = detail_rvv::rvvmxor(lhs, rhs);
+            return detail_rvv::rvvmnot(neq_result);
         }
 
         // neq
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> neq(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
-            return detail::rvvmsne(lhs, rhs);
+            return detail_rvv::rvvmsne(lhs, rhs);
         }
 
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> neq(batch_bool<T, A> const& lhs, batch_bool<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
-            return detail::rvvmxor(lhs, rhs);
+            return detail_rvv::rvvmxor(lhs, rhs);
         }
 
         // lt
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> lt(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
-            return detail::rvvmslt(lhs, rhs);
+            return detail_rvv::rvvmslt(lhs, rhs);
         }
 
         // le
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> le(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
-            return detail::rvvmsle(lhs, rhs);
+            return detail_rvv::rvvmsle(lhs, rhs);
         }
 
         // gt
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> gt(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
-            return detail::rvvmsgt(lhs, rhs);
+            return detail_rvv::rvvmsgt(lhs, rhs);
         }
 
         // ge
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> ge(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
-            return detail::rvvmsge(lhs, rhs);
+            return detail_rvv::rvvmsge(lhs, rhs);
         }
 
         /*************
          * Selection *
          *************/
-        namespace detail
+        namespace detail_rvv
         {
             XSIMD_RVV_OVERLOAD(rvvcompress, (__riscv_vcompress_tu), , vec(vec, vec, bvec))
         }
@@ -1057,13 +1064,13 @@ namespace xsimd
         XSIMD_INLINE batch<T, A> compress(batch<T, A> const& x, batch_bool<T, A> const& mask, requires_arch<rvv>) noexcept
         {
             auto zero = broadcast<A>(T(0), rvv {});
-            return detail::rvvcompress(zero, x, mask);
+            return detail_rvv::rvvcompress(zero, x, mask);
         }
 
         /***************
          * Permutation *
          ***************/
-        namespace detail
+        namespace detail_rvv
         {
             XSIMD_RVV_OVERLOAD(rvvrgather, (__riscv_vrgather), , vec(vec, uvec))
             XSIMD_RVV_OVERLOAD(rvvslideup, (__riscv_vslideup), , vec(vec, vec, size_t))
@@ -1076,7 +1083,7 @@ namespace xsimd
         {
             static_assert(batch<T, A>::size == sizeof...(idx), "invalid swizzle indices");
             const batch<I, A> indices { idx... };
-            return detail::rvvrgather(arg, indices);
+            return detail_rvv::rvvrgather(arg, indices);
         }
 
         template <class A, class T, class I, I... idx>
@@ -1098,15 +1105,15 @@ namespace xsimd
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, size_t n, requires_arch<rvv>) noexcept
         {
-            const auto tmp = detail::rvvslidedown(rhs, n);
-            return detail::rvvslideup(tmp, lhs, lhs.size - n);
+            const auto tmp = detail_rvv::rvvslidedown(rhs, n);
+            return detail_rvv::rvvslideup(tmp, lhs, lhs.size - n);
         }
 
         // select
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> select(batch_bool<T, A> const& cond, batch<T, A> const& a, batch<T, A> const& b, requires_arch<rvv>) noexcept
         {
-            return detail::rvvmerge(b, a, cond);
+            return detail_rvv::rvvmerge(b, a, cond);
         }
 
         template <class A, class T, bool... b>
@@ -1119,22 +1126,22 @@ namespace xsimd
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> zip_lo(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
-            const auto index = detail::vindex<A, as_unsigned_integer_t<T>, 0, -1>();
-            const auto mask = detail::pmask8<T, A::width>(0xaa);
-            return detail::rvvmerge(detail::rvvrgather(lhs, index),
-                                    detail::rvvrgather(rhs, index),
-                                    mask);
+            const auto index = detail_rvv::vindex<A, as_unsigned_integer_t<T>, 0, -1>();
+            const auto mask = detail_rvv::pmask8<T, A::width>(0xaa);
+            return detail_rvv::rvvmerge(detail_rvv::rvvrgather(lhs, index),
+                                        detail_rvv::rvvrgather(rhs, index),
+                                        mask);
         }
 
         // zip_hi
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> zip_hi(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
-            const auto index = detail::vindex<A, as_unsigned_integer_t<T>, batch<T, A>::size / 2, -1>();
-            const auto mask = detail::pmask8<T, A::width>(0xaa);
-            return detail::rvvmerge(detail::rvvrgather(lhs, index),
-                                    detail::rvvrgather(rhs, index),
-                                    mask);
+            const auto index = detail_rvv::vindex<A, as_unsigned_integer_t<T>, batch<T, A>::size / 2, -1>();
+            const auto mask = detail_rvv::pmask8<T, A::width>(0xaa);
+            return detail_rvv::rvvmerge(detail_rvv::rvvrgather(lhs, index),
+                                        detail_rvv::rvvrgather(rhs, index),
+                                        mask);
         }
 
         // store_complex
@@ -1158,7 +1165,7 @@ namespace xsimd
          * Floating-point arithmetic *
          *****************************/
 
-        namespace detail
+        namespace detail_rvv
         {
             XSIMD_RVV_OVERLOAD_FLOATS(rvvfsqrt, (__riscv_vfsqrt), , vec(vec))
             XSIMD_RVV_OVERLOAD_FLOATS(rvvfrec7, (__riscv_vfrec7), , vec(vec))
@@ -1169,7 +1176,7 @@ namespace xsimd
         template <class A, class T, detail::enable_floating_point_t<T> = 0>
         XSIMD_INLINE batch<T, A> rsqrt(batch<T, A> const& arg, requires_arch<rvv>) noexcept
         {
-            auto approx = detail::rvvfrsqrt7(arg);
+            auto approx = detail_rvv::rvvfrsqrt7(arg);
             approx = approx * (1.5 - (0.5 * arg * approx * approx));
             return approx;
         }
@@ -1178,14 +1185,14 @@ namespace xsimd
         template <class A, class T, detail::enable_floating_point_t<T> = 0>
         XSIMD_INLINE batch<T, A> sqrt(batch<T, A> const& arg, requires_arch<rvv>) noexcept
         {
-            return detail::rvvfsqrt(arg);
+            return detail_rvv::rvvfsqrt(arg);
         }
 
         // reciprocal
         template <class A, class T, detail::enable_floating_point_t<T> = 0>
         XSIMD_INLINE batch<T, A> reciprocal(const batch<T, A>& arg, requires_arch<rvv>) noexcept
         {
-            return detail::rvvfrec7(arg);
+            return detail_rvv::rvvfrec7(arg);
         }
 
         /******************************
@@ -1193,7 +1200,7 @@ namespace xsimd
          ******************************/
 
         // fast_cast
-        namespace detail
+        namespace detail_rvv
         {
             XSIMD_RVV_OVERLOAD2(rvvfcvt_rtz, // truncating conversion, like C.
                                 (__riscv_vfcvt_rtz_x),
@@ -1252,7 +1259,7 @@ namespace xsimd
             using U = as_unsigned_integer_t<T>;
             const auto values = set(batch<U, rvv> {}, rvv {}, static_cast<U>(args)...);
             const auto zero = broadcast<A>(U(0), rvv {});
-            detail::rvv_bool_t<T> result = detail::rvvmsne(values, zero);
+            detail_rvv::rvv_bool_t<T> result = detail_rvv::rvvmsne(values, zero);
             return result;
         }
 
@@ -1260,65 +1267,65 @@ namespace xsimd
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE T first(batch<T, A> const& arg, requires_arch<rvv>) noexcept
         {
-            return detail::rvvmv_lane0(arg);
+            return detail_rvv::rvvmv_lane0(arg);
         }
 
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE std::complex<T> first(batch<std::complex<T>, A> const& arg, requires_arch<rvv>) noexcept
         {
-            return std::complex<T> { detail::rvvmv_lane0(arg.real()), detail::rvvmv_lane0(arg.imag()) };
+            return std::complex<T> { detail_rvv::rvvmv_lane0(arg.real()), detail_rvv::rvvmv_lane0(arg.imag()) };
         }
 
         // insert
         template <class A, class T, size_t I, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> insert(batch<T, A> const& arg, T val, index<I>, requires_arch<rvv>) noexcept
         {
-            const auto mask = detail::pmask<T, A::width>(uint64_t(1) << I);
-            return detail::rvvmerge_splat(arg, val, mask);
+            const auto mask = detail_rvv::pmask<T, A::width>(uint64_t(1) << I);
+            return detail_rvv::rvvmerge_splat(arg, val, mask);
         }
 
         // get
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE T get(batch<T, A> const& arg, size_t i, requires_arch<rvv>) noexcept
         {
-            const auto tmp = detail::rvvslidedown(arg, i);
-            return detail::rvvmv_lane0(tmp);
+            const auto tmp = detail_rvv::rvvslidedown(arg, i);
+            return detail_rvv::rvvmv_lane0(tmp);
         }
 
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE std::complex<T> get(batch<std::complex<T>, A> const& arg, size_t i, requires_arch<rvv>) noexcept
         {
-            const auto tmpr = detail::rvvslidedown(arg.real(), i);
-            const auto tmpi = detail::rvvslidedown(arg.imag(), i);
-            return std::complex<T> { detail::rvvmv_lane0(tmpr), detail::rvvmv_lane0(tmpi) };
+            const auto tmpr = detail_rvv::rvvslidedown(arg.real(), i);
+            const auto tmpi = detail_rvv::rvvslidedown(arg.imag(), i);
+            return std::complex<T> { detail_rvv::rvvmv_lane0(tmpr), detail_rvv::rvvmv_lane0(tmpi) };
         }
 
         // all
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE bool all(batch_bool<T, A> const& arg, requires_arch<rvv>) noexcept
         {
-            return detail::rvvcpop(arg) == batch_bool<T, A>::size;
+            return detail_rvv::rvvcpop(arg) == batch_bool<T, A>::size;
         }
 
         // any
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE bool any(batch_bool<T, A> const& arg, requires_arch<rvv>) noexcept
         {
-            return detail::rvvcpop(arg) > 0;
+            return detail_rvv::rvvcpop(arg) > 0;
         }
 
         // bitwise_cast
         template <class A, class T, class R, detail::enable_arithmetic_t<T> = 0, detail::enable_arithmetic_t<R> = 0>
         XSIMD_INLINE batch<R, A> bitwise_cast(batch<T, A> const& arg, batch<R, A> const&, requires_arch<rvv>) noexcept
         {
-            return detail::rvv_reg_t<R, A::width>(arg.data.get_bytes(), types::detail::XSIMD_RVV_BITCAST);
+            return detail_rvv::rvv_reg_t<R, A::width>(arg.data.get_bytes(), types::detail::XSIMD_RVV_BITCAST);
         }
 
         // batch_bool_cast
         template <class A, class T_out, class T_in, detail::enable_arithmetic_t<T_in> = 0>
         XSIMD_INLINE batch_bool<T_out, A> batch_bool_cast(batch_bool<T_in, A> const& arg, batch_bool<T_out, A> const&, requires_arch<rvv>) noexcept
         {
-            using intermediate_t = typename detail::rvv_bool_t<T_out>;
+            using intermediate_t = typename detail_rvv::rvv_bool_t<T_out>;
             return intermediate_t(arg.data);
         }
 
@@ -1327,10 +1334,10 @@ namespace xsimd
         XSIMD_INLINE batch<T, A> from_bool(batch_bool<T, A> const& arg, requires_arch<rvv>) noexcept
         {
             const auto zero = broadcast<A>(T(0), rvv {});
-            return detail::rvvmerge_splat(zero, T(1), arg);
+            return detail_rvv::rvvmerge_splat(zero, T(1), arg);
         }
 
-        namespace detail
+        namespace detail_rvv
         {
             template <size_t Width>
             XSIMD_INLINE vuint8m1_t rvvslidedownbytes(vuint8m1_t arg, size_t i)
@@ -1366,16 +1373,16 @@ namespace xsimd
         {
             const auto zero = broadcast<A>(uint8_t(0), rvv {});
             const auto bytes = arg.data.get_bytes();
-            return detail::rvvreinterpret<T>(detail::rvvslideup(zero, bytes, N));
+            return detail_rvv::rvvreinterpret<T>(detail_rvv::rvvslideup(zero, bytes, N));
         }
 
         // slide_right
         template <size_t N, class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> slide_right(batch<T, A> const& arg, requires_arch<rvv>) noexcept
         {
-            using reg_t = detail::rvv_reg_t<T, A::width>;
+            using reg_t = detail_rvv::rvv_reg_t<T, A::width>;
             const auto bytes = arg.data.get_bytes();
-            return reg_t(detail::rvvslidedownbytes<A::width>(bytes, N), types::detail::XSIMD_RVV_BITCAST);
+            return reg_t(detail_rvv::rvvslidedownbytes<A::width>(bytes, N), types::detail::XSIMD_RVV_BITCAST);
         }
 
         // isnan
@@ -1385,7 +1392,7 @@ namespace xsimd
             return !(arg == arg);
         }
 
-        namespace detail
+        namespace detail_rvv
         {
             template <class T>
             using rvv_as_signed_integer_t = as_signed_integer_t<as_unsigned_integer_t<T>>;
@@ -1404,11 +1411,11 @@ namespace xsimd
         }
 
         // nearbyint_as_int
-        template <class A, class T, class U = detail::rvv_as_signed_integer_t<T>>
+        template <class A, class T, class U = detail_rvv::rvv_as_signed_integer_t<T>>
         XSIMD_INLINE batch<U, A> nearbyint_as_int(batch<T, A> const& arg, requires_arch<rvv>) noexcept
         {
             // Reference rounds ties to nearest even
-            return detail::rvvfcvt_default(arg);
+            return detail_rvv::rvvfcvt_default(arg);
         }
 
         // round
@@ -1417,7 +1424,7 @@ namespace xsimd
         {
             // Round ties away from zero.
             const auto mask = abs(arg) < constants::maxflint<batch<T, A>>();
-            return select(mask, to_float(detail::rvvfcvt_afz(arg)), arg, rvv {});
+            return select(mask, to_float(detail_rvv::rvvfcvt_afz(arg)), arg, rvv {});
         }
 
         // nearbyint
@@ -1426,7 +1433,7 @@ namespace xsimd
         {
             // Round according to current rounding mode.
             const auto mask = abs(arg) < constants::maxflint<batch<T, A>>();
-            return select(mask, to_float(detail::rvvfcvt_default(arg)), arg, rvv {});
+            return select(mask, to_float(detail_rvv::rvvfcvt_default(arg)), arg, rvv {});
         }
 
         // mask
@@ -1439,12 +1446,12 @@ namespace xsimd
             XSIMD_IF_CONSTEXPR((8 * sizeof(T)) >= batch_bool<T, A>::size)
             {
                 // (A) Easy case: the number of slots fits in T.
-                const auto zero = detail::broadcast<as_unsigned_integer_t<T>, types::detail::rvv_width_m1>(T(0));
-                auto ones = detail::broadcast<as_unsigned_integer_t<T>, A::width>(1);
-                auto iota = detail::rvvid(as_unsigned_integer_t<T> {});
-                auto upowers = detail::rvvsll(ones, iota);
+                const auto zero = detail_rvv::broadcast<as_unsigned_integer_t<T>, types::detail::rvv_width_m1>(T(0));
+                auto ones = detail_rvv::broadcast<as_unsigned_integer_t<T>, A::width>(1);
+                auto iota = detail_rvv::rvvid(as_unsigned_integer_t<T> {});
+                auto upowers = detail_rvv::rvvsll(ones, iota);
                 auto r = __riscv_vredor(self.data.as_mask(), upowers, (typename decltype(zero)::register_type)zero, batch_bool<T, A>::size);
-                return detail::reduce_scalar<A, as_unsigned_integer_t<T>>(r);
+                return detail_rvv::reduce_scalar<A, as_unsigned_integer_t<T>>(r);
             }
             else XSIMD_IF_CONSTEXPR((2 * 8 * sizeof(T)) == batch_bool<T, A>::size)
             {
@@ -1460,20 +1467,20 @@ namespace xsimd
                 };
 
                 // The low part is similar to the approach in (A).
-                const auto zero = detail::broadcast<as_unsigned_integer_t<T>, types::detail::rvv_width_m1>(T(0));
-                auto ones = detail::broadcast<as_unsigned_integer_t<T>, A::width>(1);
-                auto iota = detail::rvvid(as_unsigned_integer_t<T> {});
-                auto upowers = detail::rvvsll(ones, iota);
+                const auto zero = detail_rvv::broadcast<as_unsigned_integer_t<T>, types::detail::rvv_width_m1>(T(0));
+                auto ones = detail_rvv::broadcast<as_unsigned_integer_t<T>, A::width>(1);
+                auto iota = detail_rvv::rvvid(as_unsigned_integer_t<T> {});
+                auto upowers = detail_rvv::rvvsll(ones, iota);
                 auto low_mask = self & make_batch_bool_constant<T, LowerHalf, A>();
                 auto r_low = __riscv_vredor(low_mask.data.as_mask(), upowers, (typename decltype(zero)::register_type)zero, batch_bool<T, A>::size);
 
                 // The high part requires to slide the upower filter to match the high mask.
-                upowers = detail::rvvslideup(upowers, upowers, 8 * sizeof(T));
+                upowers = detail_rvv::rvvslideup(upowers, upowers, 8 * sizeof(T));
                 auto high_mask = self & make_batch_bool_constant<T, UpperHalf, A>();
                 auto r_high = __riscv_vredor(high_mask.data.as_mask(), upowers, (typename decltype(zero)::register_type)zero, batch_bool<T, A>::size);
 
                 // Concatenate the two parts.
-                return (uint64_t)detail::reduce_scalar<A, as_unsigned_integer_t<T>>(r_low) | ((uint64_t)detail::reduce_scalar<A, as_unsigned_integer_t<T>>(r_high) << (8 * sizeof(T)));
+                return (uint64_t)detail_rvv::reduce_scalar<A, as_unsigned_integer_t<T>>(r_low) | ((uint64_t)detail_rvv::reduce_scalar<A, as_unsigned_integer_t<T>>(r_high) << (8 * sizeof(T)));
             }
             else
             {
diff --git a/include/xsimd/arch/xsimd_sve.hpp b/include/xsimd/arch/xsimd_sve.hpp
index 05109dfd1..841ed35f6 100644
--- a/include/xsimd/arch/xsimd_sve.hpp
+++ b/include/xsimd/arch/xsimd_sve.hpp
@@ -16,8 +16,16 @@
 #include <complex>
 #include <type_traits>
 
+#include "../config/xsimd_config.hpp"
+#include "../config/xsimd_macros.hpp"
 #include "../types/xsimd_sve_register.hpp"
 
+// Define a inline namespace with the explicit SVE vector size to avoid ODR violation
+// When dynamically dispatching between different SVE sizes.
+// While most code is safe from ODR violation as the size is already encoded in the
+// register (and hence batch) types, utilities can quickly fall prone to this issue.
+#define XSIMD_SVE_NAMESPACE XSIMD_CONCAT(sve, XSIMD_SVE_BITS)
+
 namespace xsimd
 {
     template <typename T, class A, T... Values>
@@ -25,54 +33,57 @@ namespace xsimd
 
     namespace kernel
     {
-        namespace detail
-        {
-            using xsimd::index;
-            using xsimd::types::detail::sve_vector_type;
-
-            // predicate creation
-            XSIMD_INLINE svbool_t sve_ptrue_impl(index<1>) noexcept { return svptrue_b8(); }
-            XSIMD_INLINE svbool_t sve_ptrue_impl(index<2>) noexcept { return svptrue_b16(); }
-            XSIMD_INLINE svbool_t sve_ptrue_impl(index<4>) noexcept { return svptrue_b32(); }
-            XSIMD_INLINE svbool_t sve_ptrue_impl(index<8>) noexcept { return svptrue_b64(); }
-
-            template <class T>
-            svbool_t sve_ptrue() noexcept { return sve_ptrue_impl(index<sizeof(T)> {}); }
-
-            // predicate loading
-            template <bool M0, bool M1>
-            svbool_t sve_pmask() noexcept { return svdupq_b64(M0, M1); }
-            template <bool M0, bool M1, bool M2, bool M3>
-            svbool_t sve_pmask() noexcept { return svdupq_b32(M0, M1, M2, M3); }
-            template <bool M0, bool M1, bool M2, bool M3, bool M4, bool M5, bool M6, bool M7>
-            svbool_t sve_pmask() noexcept { return svdupq_b16(M0, M1, M2, M3, M4, M5, M6, M7); }
-            template <bool M0, bool M1, bool M2, bool M3, bool M4, bool M5, bool M6, bool M7,
-                      bool M8, bool M9, bool M10, bool M11, bool M12, bool M13, bool M14, bool M15>
-            svbool_t sve_pmask() noexcept { return svdupq_b8(M0, M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15); }
-
-            // count active lanes in a predicate
-            XSIMD_INLINE uint64_t sve_pcount_impl(svbool_t p, index<1>) noexcept { return svcntp_b8(p, p); }
-            XSIMD_INLINE uint64_t sve_pcount_impl(svbool_t p, index<2>) noexcept { return svcntp_b16(p, p); }
-            XSIMD_INLINE uint64_t sve_pcount_impl(svbool_t p, index<4>) noexcept { return svcntp_b32(p, p); }
-            XSIMD_INLINE uint64_t sve_pcount_impl(svbool_t p, index<8>) noexcept { return svcntp_b64(p, p); }
-
-            template <class T>
-            XSIMD_INLINE uint64_t sve_pcount(svbool_t p) noexcept { return sve_pcount_impl(p, index<sizeof(T)> {}); }
-
-            // enable for signed integers or floating points
-            template <class T>
-            using sve_enable_signed_int_or_floating_point_t = std::enable_if_t<std::is_signed<T>::value, int>;
-
-            // `sizeless` is the matching sizeless SVE type. xsimd stores SVE
-            // vectors as fixed-size attributed types (arm_sve_vector_bits),
-            // which clang treats as implicitly convertible to every sizeless
-            // SVE type — including multi-vector tuples — making the overloaded
-            // svreinterpret_*/svsel/etc. intrinsics ambiguous. Static-casting
-            // to `sizeless` first collapses the overload set to the single
-            // 1-vector candidate.
-            template <class T>
-            using sve_sizeless_t = xsimd::types::detail::sizeless_sve_vector_type<T>;
-        } // namespace detail
+        namespace detail_sve
+        {
+            inline namespace XSIMD_SVE_NAMESPACE
+            {
+                using xsimd::index;
+                using xsimd::types::detail::sve_vector_type;
+
+                // predicate creation
+                XSIMD_INLINE svbool_t ptrue_impl(index<1>) noexcept { return svptrue_b8(); }
+                XSIMD_INLINE svbool_t ptrue_impl(index<2>) noexcept { return svptrue_b16(); }
+                XSIMD_INLINE svbool_t ptrue_impl(index<4>) noexcept { return svptrue_b32(); }
+                XSIMD_INLINE svbool_t ptrue_impl(index<8>) noexcept { return svptrue_b64(); }
+
+                template <class T>
+                XSIMD_INLINE svbool_t ptrue() noexcept { return ptrue_impl(index<sizeof(T)> {}); }
+
+                // predicate loading
+                template <bool M0, bool M1>
+                XSIMD_INLINE svbool_t pmask() noexcept { return svdupq_b64(M0, M1); }
+                template <bool M0, bool M1, bool M2, bool M3>
+                XSIMD_INLINE svbool_t pmask() noexcept { return svdupq_b32(M0, M1, M2, M3); }
+                template <bool M0, bool M1, bool M2, bool M3, bool M4, bool M5, bool M6, bool M7>
+                XSIMD_INLINE svbool_t pmask() noexcept { return svdupq_b16(M0, M1, M2, M3, M4, M5, M6, M7); }
+                template <bool M0, bool M1, bool M2, bool M3, bool M4, bool M5, bool M6, bool M7,
+                          bool M8, bool M9, bool M10, bool M11, bool M12, bool M13, bool M14, bool M15>
+                XSIMD_INLINE svbool_t pmask() noexcept { return svdupq_b8(M0, M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15); }
+
+                // count active lanes in a predicate
+                XSIMD_INLINE uint64_t pcount_impl(svbool_t p, index<1>) noexcept { return svcntp_b8(p, p); }
+                XSIMD_INLINE uint64_t pcount_impl(svbool_t p, index<2>) noexcept { return svcntp_b16(p, p); }
+                XSIMD_INLINE uint64_t pcount_impl(svbool_t p, index<4>) noexcept { return svcntp_b32(p, p); }
+                XSIMD_INLINE uint64_t pcount_impl(svbool_t p, index<8>) noexcept { return svcntp_b64(p, p); }
+
+                template <class T>
+                XSIMD_INLINE uint64_t pcount(svbool_t p) noexcept { return pcount_impl(p, index<sizeof(T)> {}); }
+
+                // enable for signed integers or floating points
+                template <class T>
+                using enable_signed_int_or_floating_point_t = std::enable_if_t<std::is_signed<T>::value, int>;
+
+                // `sizeless` is the matching sizeless SVE type. xsimd stores SVE
+                // vectors as fixed-size attributed types (arm_sve_vector_bits),
+                // which clang treats as implicitly convertible to every sizeless
+                // SVE type — including multi-vector tuples — making the overloaded
+                // svreinterpret_*/svsel/etc. intrinsics ambiguous. Static-casting
+                // to `sizeless` first collapses the overload set to the single
+                // 1-vector candidate.
+                template <class T>
+                using sizeless_t = xsimd::types::detail::sizeless_sve_vector_type<T>;
+            } // namespace XSIMD_SVE_NAMESPACE
+        } // namespace detail_sve
 
         /*********
          * Load *
@@ -81,7 +92,7 @@ namespace xsimd
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> load_aligned(T const* src, convert<T>, requires_arch<sve>) noexcept
         {
-            return svld1(detail::sve_ptrue<T>(), reinterpret_cast<project_num_t<T> const*>(src));
+            return svld1(detail_sve::ptrue<T>(), reinterpret_cast<project_num_t<T> const*>(src));
         }
 
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
@@ -94,7 +105,7 @@ namespace xsimd
         template <class A, class T, bool... Values, class Mode, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> load_masked(T const* mem, batch_bool_constant<float, A, Values...>, Mode, requires_arch<sve>) noexcept
         {
-            return svld1(detail::sve_pmask<Values...>(), reinterpret_cast<project_num_t<T> const*>(mem));
+            return svld1(detail_sve::pmask<Values...>(), reinterpret_cast<project_num_t<T> const*>(mem));
         }
 
         // load_complex
@@ -102,7 +113,7 @@ namespace xsimd
         XSIMD_INLINE batch<std::complex<T>, A> load_complex_aligned(std::complex<T> const* mem, convert<std::complex<T>>, requires_arch<sve>) noexcept
         {
             const T* buf = reinterpret_cast<const T*>(mem);
-            const auto tmp = svld2(detail::sve_ptrue<T>(), buf);
+            const auto tmp = svld2(detail_sve::ptrue<T>(), buf);
             const auto real = svget2(tmp, 0);
             const auto imag = svget2(tmp, 1);
             return batch<std::complex<T>, A> { real, imag };
@@ -121,7 +132,7 @@ namespace xsimd
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE void store_aligned(T* dst, batch<T, A> const& src, requires_arch<sve>) noexcept
         {
-            svst1(detail::sve_ptrue<T>(), reinterpret_cast<project_num_t<T>*>(dst), src);
+            svst1(detail_sve::ptrue<T>(), reinterpret_cast<project_num_t<T>*>(dst), src);
         }
 
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
@@ -139,7 +150,7 @@ namespace xsimd
             tmp = svset2(tmp, 0, src.real());
             tmp = svset2(tmp, 1, src.imag());
             T* buf = reinterpret_cast<T*>(dst);
-            svst2(detail::sve_ptrue<T>(), buf, tmp);
+            svst2(detail_sve::ptrue<T>(), buf, tmp);
         }
 
         template <class A, class T, detail::enable_floating_point_t<T> = 0>
@@ -152,24 +163,24 @@ namespace xsimd
          * scatter/gather *
          ******************/
 
-        namespace detail
+        namespace detail_sve
         {
             template <class T, class U>
-            using sve_enable_sg_t = std::enable_if_t<(sizeof(T) == sizeof(U) && (sizeof(T) == 4 || sizeof(T) == 8)), int>;
+            using enable_sg_t = std::enable_if_t<(sizeof(T) == sizeof(U) && (sizeof(T) == 4 || sizeof(T) == 8)), int>;
         }
 
         // scatter
-        template <class A, class T, class U, detail::sve_enable_sg_t<T, U> = 0>
+        template <class A, class T, class U, detail_sve::enable_sg_t<T, U> = 0>
         XSIMD_INLINE void scatter(batch<T, A> const& src, T* dst, batch<U, A> const& index, kernel::requires_arch<sve>) noexcept
         {
-            svst1_scatter_index(detail::sve_ptrue<T>(), dst, index.data, src.data);
+            svst1_scatter_index(detail_sve::ptrue<T>(), dst, index.data, src.data);
         }
 
         // gather
-        template <class A, class T, class U, detail::sve_enable_sg_t<T, U> = 0>
+        template <class A, class T, class U, detail_sve::enable_sg_t<T, U> = 0>
         XSIMD_INLINE batch<T, A> gather(batch<T, A> const&, T const* src, batch<U, A> const& index, kernel::requires_arch<sve>) noexcept
         {
-            return svld1_gather_index(detail::sve_ptrue<T>(), src, index.data);
+            return svld1_gather_index(detail_sve::ptrue<T>(), src, index.data);
         }
 
         /********************
@@ -251,7 +262,7 @@ namespace xsimd
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> add(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<sve>) noexcept
         {
-            return svadd_x(detail::sve_ptrue<T>(), lhs, rhs);
+            return svadd_x(detail_sve::ptrue<T>(), lhs, rhs);
         }
 
         // sadd
@@ -265,7 +276,7 @@ namespace xsimd
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> sub(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<sve>) noexcept
         {
-            return svsub_x(detail::sve_ptrue<T>(), lhs, rhs);
+            return svsub_x(detail_sve::ptrue<T>(), lhs, rhs);
         }
 
         // ssub
@@ -279,59 +290,59 @@ namespace xsimd
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> mul(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<sve>) noexcept
         {
-            return svmul_x(detail::sve_ptrue<T>(), lhs, rhs);
+            return svmul_x(detail_sve::ptrue<T>(), lhs, rhs);
         }
 
         // div
         template <class A, class T, std::enable_if_t<sizeof(T) >= 4, int> = 0>
         XSIMD_INLINE batch<T, A> div(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<sve>) noexcept
         {
-            return svdiv_x(detail::sve_ptrue<T>(), lhs, rhs);
+            return svdiv_x(detail_sve::ptrue<T>(), lhs, rhs);
         }
 
         // max
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> max(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<sve>) noexcept
         {
-            return svmax_x(detail::sve_ptrue<T>(), lhs, rhs);
+            return svmax_x(detail_sve::ptrue<T>(), lhs, rhs);
         }
 
         // min
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> min(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<sve>) noexcept
         {
-            return svmin_x(detail::sve_ptrue<T>(), lhs, rhs);
+            return svmin_x(detail_sve::ptrue<T>(), lhs, rhs);
         }
 
         // neg
         template <class A, class T, detail::enable_sized_unsigned_t<T, 1> = 0>
         XSIMD_INLINE batch<T, A> neg(batch<T, A> const& arg, requires_arch<sve>) noexcept
         {
-            return svreinterpret_u8(svneg_x(detail::sve_ptrue<T>(), svreinterpret_s8(static_cast<detail::sve_sizeless_t<T>>(arg))));
+            return svreinterpret_u8(svneg_x(detail_sve::ptrue<T>(), svreinterpret_s8(static_cast<detail_sve::sizeless_t<T>>(arg))));
         }
 
         template <class A, class T, detail::enable_sized_unsigned_t<T, 2> = 0>
         XSIMD_INLINE batch<T, A> neg(batch<T, A> const& arg, requires_arch<sve>) noexcept
         {
-            return svreinterpret_u16(svneg_x(detail::sve_ptrue<T>(), svreinterpret_s16(static_cast<detail::sve_sizeless_t<T>>(arg))));
+            return svreinterpret_u16(svneg_x(detail_sve::ptrue<T>(), svreinterpret_s16(static_cast<detail_sve::sizeless_t<T>>(arg))));
         }
 
         template <class A, class T, detail::enable_sized_unsigned_t<T, 4> = 0>
         XSIMD_INLINE batch<T, A> neg(batch<T, A> const& arg, requires_arch<sve>) noexcept
         {
-            return svreinterpret_u32(svneg_x(detail::sve_ptrue<T>(), svreinterpret_s32(static_cast<detail::sve_sizeless_t<T>>(arg))));
+            return svreinterpret_u32(svneg_x(detail_sve::ptrue<T>(), svreinterpret_s32(static_cast<detail_sve::sizeless_t<T>>(arg))));
         }
 
         template <class A, class T, detail::enable_sized_unsigned_t<T, 8> = 0>
         XSIMD_INLINE batch<T, A> neg(batch<T, A> const& arg, requires_arch<sve>) noexcept
         {
-            return svreinterpret_u64(svneg_x(detail::sve_ptrue<T>(), svreinterpret_s64(static_cast<detail::sve_sizeless_t<T>>(arg))));
+            return svreinterpret_u64(svneg_x(detail_sve::ptrue<T>(), svreinterpret_s64(static_cast<detail_sve::sizeless_t<T>>(arg))));
         }
 
         template <class A, class T, detail::enable_signed_numeral_t<T> = 0>
         XSIMD_INLINE batch<T, A> neg(batch<T, A> const& arg, requires_arch<sve>) noexcept
         {
-            return svneg_x(detail::sve_ptrue<T>(), arg);
+            return svneg_x(detail_sve::ptrue<T>(), arg);
         }
 
         // abs
@@ -344,21 +355,21 @@ namespace xsimd
         template <class A, class T, detail::enable_signed_numeral_t<T> = 0>
         XSIMD_INLINE batch<T, A> abs(batch<T, A> const& arg, requires_arch<sve>) noexcept
         {
-            return svabs_x(detail::sve_ptrue<T>(), arg);
+            return svabs_x(detail_sve::ptrue<T>(), arg);
         }
 
         // fma: x * y + z
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> fma(batch<T, A> const& x, batch<T, A> const& y, batch<T, A> const& z, requires_arch<sve>) noexcept
         {
-            return svmad_x(detail::sve_ptrue<T>(), x, y, z);
+            return svmad_x(detail_sve::ptrue<T>(), x, y, z);
         }
 
         // fnma: z - x * y
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> fnma(batch<T, A> const& x, batch<T, A> const& y, batch<T, A> const& z, requires_arch<sve>) noexcept
         {
-            return svmsb_x(detail::sve_ptrue<T>(), x, y, z);
+            return svmsb_x(detail_sve::ptrue<T>(), x, y, z);
         }
 
         // fms: x * y - z
@@ -383,191 +394,194 @@ namespace xsimd
         template <class A, class T, detail::enable_integral_t<T> = 0>
         XSIMD_INLINE batch<T, A> bitwise_and(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<sve>) noexcept
         {
-            return svand_x(detail::sve_ptrue<T>(), lhs, rhs);
+            return svand_x(detail_sve::ptrue<T>(), lhs, rhs);
         }
 
         template <class A>
         XSIMD_INLINE batch<float, A> bitwise_and(batch<float, A> const& lhs, batch<float, A> const& rhs, requires_arch<sve>) noexcept
         {
-            const auto lhs_bits = svreinterpret_u32(static_cast<detail::sve_sizeless_t<float>>(lhs));
-            const auto rhs_bits = svreinterpret_u32(static_cast<detail::sve_sizeless_t<float>>(rhs));
-            const auto result_bits = svand_x(detail::sve_ptrue<float>(), lhs_bits, rhs_bits);
+            const auto lhs_bits = svreinterpret_u32(static_cast<detail_sve::sizeless_t<float>>(lhs));
+            const auto rhs_bits = svreinterpret_u32(static_cast<detail_sve::sizeless_t<float>>(rhs));
+            const auto result_bits = svand_x(detail_sve::ptrue<float>(), lhs_bits, rhs_bits);
             return svreinterpret_f32(result_bits);
         }
 
         template <class A>
         XSIMD_INLINE batch<double, A> bitwise_and(batch<double, A> const& lhs, batch<double, A> const& rhs, requires_arch<sve>) noexcept
         {
-            const auto lhs_bits = svreinterpret_u64(static_cast<detail::sve_sizeless_t<double>>(lhs));
-            const auto rhs_bits = svreinterpret_u64(static_cast<detail::sve_sizeless_t<double>>(rhs));
-            const auto result_bits = svand_x(detail::sve_ptrue<double>(), lhs_bits, rhs_bits);
+            const auto lhs_bits = svreinterpret_u64(static_cast<detail_sve::sizeless_t<double>>(lhs));
+            const auto rhs_bits = svreinterpret_u64(static_cast<detail_sve::sizeless_t<double>>(rhs));
+            const auto result_bits = svand_x(detail_sve::ptrue<double>(), lhs_bits, rhs_bits);
             return svreinterpret_f64(result_bits);
         }
 
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> bitwise_and(batch_bool<T, A> const& lhs, batch_bool<T, A> const& rhs, requires_arch<sve>) noexcept
         {
-            return svand_z(detail::sve_ptrue<T>(), lhs, rhs);
+            return svand_z(detail_sve::ptrue<T>(), lhs, rhs);
         }
 
         // bitwise_andnot
         template <class A, class T, detail::enable_integral_t<T> = 0>
         XSIMD_INLINE batch<T, A> bitwise_andnot(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<sve>) noexcept
         {
-            return svbic_x(detail::sve_ptrue<T>(), lhs, rhs);
+            return svbic_x(detail_sve::ptrue<T>(), lhs, rhs);
         }
 
         template <class A>
         XSIMD_INLINE batch<float, A> bitwise_andnot(batch<float, A> const& lhs, batch<float, A> const& rhs, requires_arch<sve>) noexcept
         {
-            const auto lhs_bits = svreinterpret_u32(static_cast<detail::sve_sizeless_t<float>>(lhs));
-            const auto rhs_bits = svreinterpret_u32(static_cast<detail::sve_sizeless_t<float>>(rhs));
-            const auto result_bits = svbic_x(detail::sve_ptrue<float>(), lhs_bits, rhs_bits);
+            const auto lhs_bits = svreinterpret_u32(static_cast<detail_sve::sizeless_t<float>>(lhs));
+            const auto rhs_bits = svreinterpret_u32(static_cast<detail_sve::sizeless_t<float>>(rhs));
+            const auto result_bits = svbic_x(detail_sve::ptrue<float>(), lhs_bits, rhs_bits);
             return svreinterpret_f32(result_bits);
         }
 
         template <class A>
         XSIMD_INLINE batch<double, A> bitwise_andnot(batch<double, A> const& lhs, batch<double, A> const& rhs, requires_arch<sve>) noexcept
         {
-            const auto lhs_bits = svreinterpret_u64(static_cast<detail::sve_sizeless_t<double>>(lhs));
-            const auto rhs_bits = svreinterpret_u64(static_cast<detail::sve_sizeless_t<double>>(rhs));
-            const auto result_bits = svbic_x(detail::sve_ptrue<double>(), lhs_bits, rhs_bits);
+            const auto lhs_bits = svreinterpret_u64(static_cast<detail_sve::sizeless_t<double>>(lhs));
+            const auto rhs_bits = svreinterpret_u64(static_cast<detail_sve::sizeless_t<double>>(rhs));
+            const auto result_bits = svbic_x(detail_sve::ptrue<double>(), lhs_bits, rhs_bits);
             return svreinterpret_f64(result_bits);
         }
 
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> bitwise_andnot(batch_bool<T, A> const& lhs, batch_bool<T, A> const& rhs, requires_arch<sve>) noexcept
         {
-            return svbic_z(detail::sve_ptrue<T>(), lhs, rhs);
+            return svbic_z(detail_sve::ptrue<T>(), lhs, rhs);
         }
 
         // bitwise_or
         template <class A, class T, detail::enable_integral_t<T> = 0>
         XSIMD_INLINE batch<T, A> bitwise_or(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<sve>) noexcept
         {
-            return svorr_x(detail::sve_ptrue<T>(), lhs, rhs);
+            return svorr_x(detail_sve::ptrue<T>(), lhs, rhs);
         }
 
         template <class A>
         XSIMD_INLINE batch<float, A> bitwise_or(batch<float, A> const& lhs, batch<float, A> const& rhs, requires_arch<sve>) noexcept
         {
-            const auto lhs_bits = svreinterpret_u32(static_cast<detail::sve_sizeless_t<float>>(lhs));
-            const auto rhs_bits = svreinterpret_u32(static_cast<detail::sve_sizeless_t<float>>(rhs));
-            const auto result_bits = svorr_x(detail::sve_ptrue<float>(), lhs_bits, rhs_bits);
+            const auto lhs_bits = svreinterpret_u32(static_cast<detail_sve::sizeless_t<float>>(lhs));
+            const auto rhs_bits = svreinterpret_u32(static_cast<detail_sve::sizeless_t<float>>(rhs));
+            const auto result_bits = svorr_x(detail_sve::ptrue<float>(), lhs_bits, rhs_bits);
             return svreinterpret_f32(result_bits);
         }
 
         template <class A>
         XSIMD_INLINE batch<double, A> bitwise_or(batch<double, A> const& lhs, batch<double, A> const& rhs, requires_arch<sve>) noexcept
         {
-            const auto lhs_bits = svreinterpret_u64(static_cast<detail::sve_sizeless_t<double>>(lhs));
-            const auto rhs_bits = svreinterpret_u64(static_cast<detail::sve_sizeless_t<double>>(rhs));
-            const auto result_bits = svorr_x(detail::sve_ptrue<double>(), lhs_bits, rhs_bits);
+            const auto lhs_bits = svreinterpret_u64(static_cast<detail_sve::sizeless_t<double>>(lhs));
+            const auto rhs_bits = svreinterpret_u64(static_cast<detail_sve::sizeless_t<double>>(rhs));
+            const auto result_bits = svorr_x(detail_sve::ptrue<double>(), lhs_bits, rhs_bits);
             return svreinterpret_f64(result_bits);
         }
 
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> bitwise_or(batch_bool<T, A> const& lhs, batch_bool<T, A> const& rhs, requires_arch<sve>) noexcept
         {
-            return svorr_z(detail::sve_ptrue<T>(), lhs, rhs);
+            return svorr_z(detail_sve::ptrue<T>(), lhs, rhs);
         }
 
         // bitwise_xor
         template <class A, class T, detail::enable_integral_t<T> = 0>
         XSIMD_INLINE batch<T, A> bitwise_xor(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<sve>) noexcept
         {
-            return sveor_x(detail::sve_ptrue<T>(), lhs, rhs);
+            return sveor_x(detail_sve::ptrue<T>(), lhs, rhs);
         }
 
         template <class A>
         XSIMD_INLINE batch<float, A> bitwise_xor(batch<float, A> const& lhs, batch<float, A> const& rhs, requires_arch<sve>) noexcept
         {
-            const auto lhs_bits = svreinterpret_u32(static_cast<detail::sve_sizeless_t<float>>(lhs));
-            const auto rhs_bits = svreinterpret_u32(static_cast<detail::sve_sizeless_t<float>>(rhs));
-            const auto result_bits = sveor_x(detail::sve_ptrue<float>(), lhs_bits, rhs_bits);
+            const auto lhs_bits = svreinterpret_u32(static_cast<detail_sve::sizeless_t<float>>(lhs));
+            const auto rhs_bits = svreinterpret_u32(static_cast<detail_sve::sizeless_t<float>>(rhs));
+            const auto result_bits = sveor_x(detail_sve::ptrue<float>(), lhs_bits, rhs_bits);
             return svreinterpret_f32(result_bits);
         }
 
         template <class A>
         XSIMD_INLINE batch<double, A> bitwise_xor(batch<double, A> const& lhs, batch<double, A> const& rhs, requires_arch<sve>) noexcept
         {
-            const auto lhs_bits = svreinterpret_u64(static_cast<detail::sve_sizeless_t<double>>(lhs));
-            const auto rhs_bits = svreinterpret_u64(static_cast<detail::sve_sizeless_t<double>>(rhs));
-            const auto result_bits = sveor_x(detail::sve_ptrue<double>(), lhs_bits, rhs_bits);
+            const auto lhs_bits = svreinterpret_u64(static_cast<detail_sve::sizeless_t<double>>(lhs));
+            const auto rhs_bits = svreinterpret_u64(static_cast<detail_sve::sizeless_t<double>>(rhs));
+            const auto result_bits = sveor_x(detail_sve::ptrue<double>(), lhs_bits, rhs_bits);
             return svreinterpret_f64(result_bits);
         }
 
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> bitwise_xor(batch_bool<T, A> const& lhs, batch_bool<T, A> const& rhs, requires_arch<sve>) noexcept
         {
-            return sveor_z(detail::sve_ptrue<T>(), lhs, rhs);
+            return sveor_z(detail_sve::ptrue<T>(), lhs, rhs);
         }
 
         // bitwise_not
         template <class A, class T, detail::enable_integral_t<T> = 0>
         XSIMD_INLINE batch<T, A> bitwise_not(batch<T, A> const& arg, requires_arch<sve>) noexcept
         {
-            return svnot_x(detail::sve_ptrue<T>(), arg);
+            return svnot_x(detail_sve::ptrue<T>(), arg);
         }
 
         template <class A>
         XSIMD_INLINE batch<float, A> bitwise_not(batch<float, A> const& arg, requires_arch<sve>) noexcept
         {
-            const auto arg_bits = svreinterpret_u32(static_cast<detail::sve_sizeless_t<float>>(arg));
-            const auto result_bits = svnot_x(detail::sve_ptrue<float>(), arg_bits);
+            const auto arg_bits = svreinterpret_u32(static_cast<detail_sve::sizeless_t<float>>(arg));
+            const auto result_bits = svnot_x(detail_sve::ptrue<float>(), arg_bits);
             return svreinterpret_f32(result_bits);
         }
 
         template <class A>
         XSIMD_INLINE batch<double, A> bitwise_not(batch<double, A> const& arg, requires_arch<sve>) noexcept
         {
-            const auto arg_bits = svreinterpret_u64(static_cast<detail::sve_sizeless_t<double>>(arg));
-            const auto result_bits = svnot_x(detail::sve_ptrue<double>(), arg_bits);
+            const auto arg_bits = svreinterpret_u64(static_cast<detail_sve::sizeless_t<double>>(arg));
+            const auto result_bits = svnot_x(detail_sve::ptrue<double>(), arg_bits);
             return svreinterpret_f64(result_bits);
         }
 
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> bitwise_not(batch_bool<T, A> const& arg, requires_arch<sve>) noexcept
         {
-            return svnot_z(detail::sve_ptrue<T>(), arg);
+            return svnot_z(detail_sve::ptrue<T>(), arg);
         }
 
         /**********
          * Shifts *
          **********/
 
-        namespace detail
+        namespace detail_sve
         {
-            template <class A, class T, class U>
-            XSIMD_INLINE batch<U, A> sve_to_unsigned_batch_impl(batch<T, A> const& arg, index<1>) noexcept
+            inline namespace XSIMD_SVE_NAMESPACE
             {
-                return svreinterpret_u8(static_cast<sve_sizeless_t<T>>(arg));
-            }
+                template <class A, class T, class U>
+                XSIMD_INLINE batch<U, A> to_unsigned_batch_impl(batch<T, A> const& arg, index<1>) noexcept
+                {
+                    return svreinterpret_u8(static_cast<sizeless_t<T>>(arg));
+                }
 
-            template <class A, class T, class U>
-            XSIMD_INLINE batch<U, A> sve_to_unsigned_batch_impl(batch<T, A> const& arg, index<2>) noexcept
-            {
-                return svreinterpret_u16(static_cast<sve_sizeless_t<T>>(arg));
-            }
+                template <class A, class T, class U>
+                XSIMD_INLINE batch<U, A> to_unsigned_batch_impl(batch<T, A> const& arg, index<2>) noexcept
+                {
+                    return svreinterpret_u16(static_cast<sizeless_t<T>>(arg));
+                }
 
-            template <class A, class T, class U>
-            XSIMD_INLINE batch<U, A> sve_to_unsigned_batch_impl(batch<T, A> const& arg, index<4>) noexcept
-            {
-                return svreinterpret_u32(static_cast<sve_sizeless_t<T>>(arg));
-            }
+                template <class A, class T, class U>
+                XSIMD_INLINE batch<U, A> to_unsigned_batch_impl(batch<T, A> const& arg, index<4>) noexcept
+                {
+                    return svreinterpret_u32(static_cast<sizeless_t<T>>(arg));
+                }
 
-            template <class A, class T, class U>
-            XSIMD_INLINE batch<U, A> sve_to_unsigned_batch_impl(batch<T, A> const& arg, index<8>) noexcept
-            {
-                return svreinterpret_u64(static_cast<sve_sizeless_t<T>>(arg));
-            }
+                template <class A, class T, class U>
+                XSIMD_INLINE batch<U, A> to_unsigned_batch_impl(batch<T, A> const& arg, index<8>) noexcept
+                {
+                    return svreinterpret_u64(static_cast<sizeless_t<T>>(arg));
+                }
 
-            template <class A, class T, class U = as_unsigned_integer_t<T>>
-            XSIMD_INLINE batch<U, A> sve_to_unsigned_batch(batch<T, A> const& arg) noexcept
-            {
-                return sve_to_unsigned_batch_impl<A, T, U>(arg, index<sizeof(T)> {});
-            }
-        } // namespace detail
+                template <class A, class T, class U = as_unsigned_integer_t<T>>
+                XSIMD_INLINE batch<U, A> to_unsigned_batch(batch<T, A> const& arg) noexcept
+                {
+                    return to_unsigned_batch_impl<A, T, U>(arg, index<sizeof(T)> {});
+                }
+            } // namespace XSIMD_SVE_NAMESPACE
+        } // namespace detail_sve
 
         // bitwise_lshift
         template <class A, class T, detail::enable_integral_t<T> = 0>
@@ -575,13 +589,13 @@ namespace xsimd
         {
             constexpr std::size_t size = sizeof(typename batch<T, A>::value_type) * 8;
             assert(0 <= n && static_cast<std::size_t>(n) < size && "index in bounds");
-            return svlsl_x(detail::sve_ptrue<T>(), arg, n);
+            return svlsl_x(detail_sve::ptrue<T>(), arg, n);
         }
 
         template <class A, class T, detail::enable_integral_t<T> = 0>
         XSIMD_INLINE batch<T, A> bitwise_lshift(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<sve>) noexcept
         {
-            return svlsl_x(detail::sve_ptrue<T>(), lhs, detail::sve_to_unsigned_batch<A, T>(rhs));
+            return svlsl_x(detail_sve::ptrue<T>(), lhs, detail_sve::to_unsigned_batch<A, T>(rhs));
         }
 
         // bitwise_rshift
@@ -590,13 +604,13 @@ namespace xsimd
         {
             constexpr std::size_t size = sizeof(typename batch<T, A>::value_type) * 8;
             assert(0 <= n && static_cast<std::size_t>(n) < size && "index in bounds");
-            return svlsr_x(detail::sve_ptrue<T>(), arg, static_cast<T>(n));
+            return svlsr_x(detail_sve::ptrue<T>(), arg, static_cast<T>(n));
         }
 
         template <class A, class T, detail::enable_unsigned_integral_t<T> = 0>
         XSIMD_INLINE batch<T, A> bitwise_rshift(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<sve>) noexcept
         {
-            return svlsr_x(detail::sve_ptrue<T>(), lhs, rhs);
+            return svlsr_x(detail_sve::ptrue<T>(), lhs, rhs);
         }
 
         template <class A, class T, detail::enable_signed_integral_t<T> = 0>
@@ -604,13 +618,13 @@ namespace xsimd
         {
             constexpr std::size_t size = sizeof(typename batch<T, A>::value_type) * 8;
             assert(0 <= n && static_cast<std::size_t>(n) < size && "index in bounds");
-            return svasr_x(detail::sve_ptrue<T>(), arg, static_cast<as_unsigned_integer_t<T>>(n));
+            return svasr_x(detail_sve::ptrue<T>(), arg, static_cast<as_unsigned_integer_t<T>>(n));
         }
 
         template <class A, class T, detail::enable_signed_integral_t<T> = 0>
         XSIMD_INLINE batch<T, A> bitwise_rshift(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<sve>) noexcept
         {
-            return svasr_x(detail::sve_ptrue<T>(), lhs, detail::sve_to_unsigned_batch<A, T>(rhs));
+            return svasr_x(detail_sve::ptrue<T>(), lhs, detail_sve::to_unsigned_batch<A, T>(rhs));
         }
 
         /**************
@@ -622,21 +636,21 @@ namespace xsimd
         XSIMD_INLINE V reduce_add(batch<T, A> const& arg, requires_arch<sve>) noexcept
         {
             // sve integer reduction results are promoted to 64 bits
-            return static_cast<V>(svaddv(detail::sve_ptrue<T>(), arg));
+            return static_cast<V>(svaddv(detail_sve::ptrue<T>(), arg));
         }
 
         // reduce_max
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE T reduce_max(batch<T, A> const& arg, requires_arch<sve>) noexcept
         {
-            return svmaxv(detail::sve_ptrue<T>(), arg);
+            return svmaxv(detail_sve::ptrue<T>(), arg);
         }
 
         // reduce_min
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE T reduce_min(batch<T, A> const& arg, requires_arch<sve>) noexcept
         {
-            return svminv(detail::sve_ptrue<T>(), arg);
+            return svminv(detail_sve::ptrue<T>(), arg);
         }
 
         // haddp
@@ -649,7 +663,7 @@ namespace xsimd
             {
                 sums[i] = reduce_add(row[i], sve {});
             }
-            return svld1(detail::sve_ptrue<T>(), sums);
+            return svld1(detail_sve::ptrue<T>(), sums);
         }
 
         /***************
@@ -660,55 +674,55 @@ namespace xsimd
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> eq(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<sve>) noexcept
         {
-            return svcmpeq(detail::sve_ptrue<T>(), lhs, rhs);
+            return svcmpeq(detail_sve::ptrue<T>(), lhs, rhs);
         }
 
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> eq(batch_bool<T, A> const& lhs, batch_bool<T, A> const& rhs, requires_arch<sve>) noexcept
         {
-            const auto neq_result = sveor_z(detail::sve_ptrue<T>(), lhs, rhs);
-            return svnot_z(detail::sve_ptrue<T>(), neq_result);
+            const auto neq_result = sveor_z(detail_sve::ptrue<T>(), lhs, rhs);
+            return svnot_z(detail_sve::ptrue<T>(), neq_result);
         }
 
         // neq
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> neq(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<sve>) noexcept
         {
-            return svcmpne(detail::sve_ptrue<T>(), lhs, rhs);
+            return svcmpne(detail_sve::ptrue<T>(), lhs, rhs);
         }
 
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> neq(batch_bool<T, A> const& lhs, batch_bool<T, A> const& rhs, requires_arch<sve>) noexcept
         {
-            return sveor_z(detail::sve_ptrue<T>(), lhs, rhs);
+            return sveor_z(detail_sve::ptrue<T>(), lhs, rhs);
         }
 
         // lt
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> lt(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<sve>) noexcept
         {
-            return svcmplt(detail::sve_ptrue<T>(), lhs, rhs);
+            return svcmplt(detail_sve::ptrue<T>(), lhs, rhs);
         }
 
         // le
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> le(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<sve>) noexcept
         {
-            return svcmple(detail::sve_ptrue<T>(), lhs, rhs);
+            return svcmple(detail_sve::ptrue<T>(), lhs, rhs);
         }
 
         // gt
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> gt(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<sve>) noexcept
         {
-            return svcmpgt(detail::sve_ptrue<T>(), lhs, rhs);
+            return svcmpgt(detail_sve::ptrue<T>(), lhs, rhs);
         }
 
         // ge
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> ge(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<sve>) noexcept
         {
-            return svcmpge(detail::sve_ptrue<T>(), lhs, rhs);
+            return svcmpge(detail_sve::ptrue<T>(), lhs, rhs);
         }
 
         /***************
@@ -761,55 +775,58 @@ namespace xsimd
          *************/
 
         // extract_pair
-        namespace detail
+        namespace detail_sve
         {
-            template <class A, class T>
-            XSIMD_INLINE batch<T, A> sve_extract_pair(batch<T, A> const&, batch<T, A> const& /*rhs*/, std::size_t, std::index_sequence<>) noexcept
+            inline namespace XSIMD_SVE_NAMESPACE
             {
-                assert(false && "extract_pair out of bounds");
-                return batch<T, A> {};
-            }
-
-            template <class A, class T, size_t I, size_t... Is>
-            XSIMD_INLINE batch<T, A> sve_extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, std::index_sequence<I, Is...>) noexcept
-            {
-                if (n == I)
-                {
-                    return svext(rhs, lhs, I);
-                }
-                else
+                template <class A, class T>
+                XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const&, batch<T, A> const& /*rhs*/, std::size_t, std::index_sequence<>) noexcept
                 {
-                    return sve_extract_pair(lhs, rhs, n, std::index_sequence<Is...>());
+                    assert(false && "extract_pair out of bounds");
+                    return batch<T, A> {};
                 }
-            }
 
-            template <class A, class T, size_t... Is>
-            XSIMD_INLINE batch<T, A> sve_extract_pair_impl(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, std::index_sequence<0, Is...>) noexcept
-            {
-                if (n == 0)
+                template <class A, class T, size_t I, size_t... Is>
+                XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, std::index_sequence<I, Is...>) noexcept
                 {
-                    return rhs;
+                    if (n == I)
+                    {
+                        return svext(rhs, lhs, I);
+                    }
+                    else
+                    {
+                        return extract_pair(lhs, rhs, n, std::index_sequence<Is...>());
+                    }
                 }
-                else
+
+                template <class A, class T, size_t... Is>
+                XSIMD_INLINE batch<T, A> extract_pair_impl(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, std::index_sequence<0, Is...>) noexcept
                 {
-                    return sve_extract_pair(lhs, rhs, n, std::index_sequence<Is...>());
+                    if (n == 0)
+                    {
+                        return rhs;
+                    }
+                    else
+                    {
+                        return extract_pair(lhs, rhs, n, std::index_sequence<Is...>());
+                    }
                 }
-            }
-        }
+            } // namespace XSIMD_SVE_NAMESPACE
+        } // namespace detail_sve
 
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, requires_arch<sve>) noexcept
         {
             constexpr std::size_t size = batch<T, A>::size;
             assert(n < size && "index in bounds");
-            return detail::sve_extract_pair_impl(lhs, rhs, n, std::make_index_sequence<size>());
+            return detail_sve::extract_pair_impl(lhs, rhs, n, std::make_index_sequence<size>());
         }
 
         // select
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> select(batch_bool<T, A> const& cond, batch<T, A> const& a, batch<T, A> const& b, requires_arch<sve>) noexcept
         {
-            return svsel(cond, static_cast<detail::sve_sizeless_t<T>>(a), static_cast<detail::sve_sizeless_t<T>>(b));
+            return svsel(cond, static_cast<detail_sve::sizeless_t<T>>(a), static_cast<detail_sve::sizeless_t<T>>(b));
         }
 
         template <class A, class T, bool... b>
@@ -847,7 +864,7 @@ namespace xsimd
         template <class A, class T, detail::enable_floating_point_t<T> = 0>
         XSIMD_INLINE batch<T, A> sqrt(batch<T, A> const& arg, requires_arch<sve>) noexcept
         {
-            return svsqrt_x(detail::sve_ptrue<T>(), arg);
+            return svsqrt_x(detail_sve::ptrue<T>(), arg);
         }
 
         // reciprocal
@@ -862,44 +879,47 @@ namespace xsimd
          ******************************/
 
         // fast_cast
-        namespace detail
+        namespace detail_sve
         {
-            template <class A, class T, detail::enable_sized_integral_t<T, 4> = 0>
-            XSIMD_INLINE batch<float, A> fast_cast(batch<T, A> const& arg, batch<float, A> const&, requires_arch<sve>) noexcept
+            inline namespace XSIMD_SVE_NAMESPACE
             {
-                return svcvt_f32_x(detail::sve_ptrue<T>(), arg);
-            }
+                template <class A, class T, detail::enable_sized_integral_t<T, 4> = 0>
+                XSIMD_INLINE batch<float, A> fast_cast(batch<T, A> const& arg, batch<float, A> const&, requires_arch<sve>) noexcept
+                {
+                    return svcvt_f32_x(detail_sve::ptrue<T>(), arg);
+                }
 
-            template <class A, class T, detail::enable_sized_integral_t<T, 8> = 0>
-            XSIMD_INLINE batch<double, A> fast_cast(batch<T, A> const& arg, batch<double, A> const&, requires_arch<sve>) noexcept
-            {
-                return svcvt_f64_x(detail::sve_ptrue<T>(), arg);
-            }
+                template <class A, class T, detail::enable_sized_integral_t<T, 8> = 0>
+                XSIMD_INLINE batch<double, A> fast_cast(batch<T, A> const& arg, batch<double, A> const&, requires_arch<sve>) noexcept
+                {
+                    return svcvt_f64_x(detail_sve::ptrue<T>(), arg);
+                }
 
-            template <class A>
-            XSIMD_INLINE batch<int32_t, A> fast_cast(batch<float, A> const& arg, batch<int32_t, A> const&, requires_arch<sve>) noexcept
-            {
-                return svcvt_s32_x(detail::sve_ptrue<float>(), arg);
-            }
+                template <class A>
+                XSIMD_INLINE batch<int32_t, A> fast_cast(batch<float, A> const& arg, batch<int32_t, A> const&, requires_arch<sve>) noexcept
+                {
+                    return svcvt_s32_x(detail_sve::ptrue<float>(), arg);
+                }
 
-            template <class A>
-            XSIMD_INLINE batch<uint32_t, A> fast_cast(batch<float, A> const& arg, batch<uint32_t, A> const&, requires_arch<sve>) noexcept
-            {
-                return svcvt_u32_x(detail::sve_ptrue<float>(), arg);
-            }
+                template <class A>
+                XSIMD_INLINE batch<uint32_t, A> fast_cast(batch<float, A> const& arg, batch<uint32_t, A> const&, requires_arch<sve>) noexcept
+                {
+                    return svcvt_u32_x(detail_sve::ptrue<float>(), arg);
+                }
 
-            template <class A>
-            XSIMD_INLINE batch<int64_t, A> fast_cast(batch<double, A> const& arg, batch<int64_t, A> const&, requires_arch<sve>) noexcept
-            {
-                return svcvt_s64_x(detail::sve_ptrue<double>(), arg);
-            }
+                template <class A>
+                XSIMD_INLINE batch<int64_t, A> fast_cast(batch<double, A> const& arg, batch<int64_t, A> const&, requires_arch<sve>) noexcept
+                {
+                    return svcvt_s64_x(detail_sve::ptrue<double>(), arg);
+                }
 
-            template <class A>
-            XSIMD_INLINE batch<uint64_t, A> fast_cast(batch<double, A> const& arg, batch<uint64_t, A> const&, requires_arch<sve>) noexcept
-            {
-                return svcvt_u64_x(detail::sve_ptrue<double>(), arg);
-            }
-        }
+                template <class A>
+                XSIMD_INLINE batch<uint64_t, A> fast_cast(batch<double, A> const& arg, batch<uint64_t, A> const&, requires_arch<sve>) noexcept
+                {
+                    return svcvt_u64_x(detail_sve::ptrue<double>(), arg);
+                }
+            } // namespace XSIMD_SVE_NAMESPACE
+        } // namespace detail_sve
 
         /*********
          * Miscs *
@@ -909,46 +929,49 @@ namespace xsimd
         template <class A, class T, class... Args>
         XSIMD_INLINE batch<T, A> set(batch<T, A> const&, requires_arch<sve>, Args... args) noexcept
         {
-            return detail::sve_vector_type<T> { args... };
+            return detail_sve::sve_vector_type<T> { args... };
         }
 
         template <class A, class T, class... Args>
         XSIMD_INLINE batch<std::complex<T>, A> set(batch<std::complex<T>, A> const&, requires_arch<sve>,
                                                    Args... args_complex) noexcept
         {
-            return batch<std::complex<T>>(detail::sve_vector_type<T> { args_complex.real()... },
-                                          detail::sve_vector_type<T> { args_complex.imag()... });
+            return batch<std::complex<T>>(detail_sve::sve_vector_type<T> { args_complex.real()... },
+                                          detail_sve::sve_vector_type<T> { args_complex.imag()... });
         }
 
         template <class A, class T, class... Args>
         XSIMD_INLINE batch_bool<T, A> set(batch_bool<T, A> const&, requires_arch<sve>, Args... args) noexcept
         {
             using U = as_unsigned_integer_t<T>;
-            const auto values = detail::sve_vector_type<U> { static_cast<U>(args)... };
+            const auto values = detail_sve::sve_vector_type<U> { static_cast<U>(args)... };
             const auto zero = broadcast<A, U>(static_cast<U>(0), sve {});
-            return svcmpne(detail::sve_ptrue<T>(), values, zero);
+            return svcmpne(detail_sve::ptrue<T>(), values, zero);
         }
 
         // insert
-        namespace detail
+        namespace detail_sve
         {
-            // generate index sequence (iota)
-            XSIMD_INLINE svuint8_t sve_iota_impl(index<1>) noexcept { return svindex_u8(0, 1); }
-            XSIMD_INLINE svuint16_t sve_iota_impl(index<2>) noexcept { return svindex_u16(0, 1); }
-            XSIMD_INLINE svuint32_t sve_iota_impl(index<4>) noexcept { return svindex_u32(0, 1); }
-            XSIMD_INLINE svuint64_t sve_iota_impl(index<8>) noexcept { return svindex_u64(0, 1); }
+            inline namespace XSIMD_SVE_NAMESPACE
+            {
+                // generate index sequence (iota)
+                XSIMD_INLINE svuint8_t iota_impl(index<1>) noexcept { return svindex_u8(0, 1); }
+                XSIMD_INLINE svuint16_t iota_impl(index<2>) noexcept { return svindex_u16(0, 1); }
+                XSIMD_INLINE svuint32_t iota_impl(index<4>) noexcept { return svindex_u32(0, 1); }
+                XSIMD_INLINE svuint64_t iota_impl(index<8>) noexcept { return svindex_u64(0, 1); }
 
-            template <class T, class V = sve_vector_type<as_unsigned_integer_t<T>>>
-            XSIMD_INLINE V sve_iota() noexcept { return sve_iota_impl(index<sizeof(T)> {}); }
-        } // namespace detail
+                template <class T, class V = sve_vector_type<as_unsigned_integer_t<T>>>
+                XSIMD_INLINE V iota() noexcept { return iota_impl(index<sizeof(T)> {}); }
+            } // namespace XSIMD_SVE_NAMESPACE
+        } // namespace detail_sve
 
         template <class A, class T, size_t I, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> insert(batch<T, A> const& arg, T val, index<I>, requires_arch<sve>) noexcept
         {
             // create a predicate with only the I-th lane activated
-            const auto iota = detail::sve_iota<T>();
-            const auto index_predicate = svcmpeq(detail::sve_ptrue<T>(), iota, static_cast<as_unsigned_integer_t<T>>(I));
-            return svsel(index_predicate, static_cast<detail::sve_sizeless_t<T>>(broadcast<A, T>(val, sve {})), static_cast<detail::sve_sizeless_t<T>>(arg));
+            const auto iota = detail_sve::iota<T>();
+            const auto index_predicate = svcmpeq(detail_sve::ptrue<T>(), iota, static_cast<as_unsigned_integer_t<T>>(I));
+            return svsel(index_predicate, static_cast<detail_sve::sizeless_t<T>>(broadcast<A, T>(val, sve {})), static_cast<detail_sve::sizeless_t<T>>(arg));
         }
 
         // first
@@ -962,7 +985,7 @@ namespace xsimd
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE bool all(batch_bool<T, A> const& arg, requires_arch<sve>) noexcept
         {
-            return detail::sve_pcount<T>(arg) == batch_bool<T, A>::size;
+            return detail_sve::pcount<T>(arg) == batch_bool<T, A>::size;
         }
 
         // any
@@ -976,61 +999,61 @@ namespace xsimd
         template <class A, class T, class R, detail::enable_arithmetic_t<T> = 0, detail::enable_sized_unsigned_t<R, 1> = 0>
         XSIMD_INLINE batch<R, A> bitwise_cast(batch<T, A> const& arg, batch<R, A> const&, requires_arch<sve>) noexcept
         {
-            return svreinterpret_u8(static_cast<detail::sve_sizeless_t<T>>(arg));
+            return svreinterpret_u8(static_cast<detail_sve::sizeless_t<T>>(arg));
         }
 
         template <class A, class T, class R, detail::enable_arithmetic_t<T> = 0, detail::enable_sized_signed_t<R, 1> = 0>
         XSIMD_INLINE batch<R, A> bitwise_cast(batch<T, A> const& arg, batch<R, A> const&, requires_arch<sve>) noexcept
         {
-            return svreinterpret_s8(static_cast<detail::sve_sizeless_t<T>>(arg));
+            return svreinterpret_s8(static_cast<detail_sve::sizeless_t<T>>(arg));
         }
 
         template <class A, class T, class R, detail::enable_arithmetic_t<T> = 0, detail::enable_sized_unsigned_t<R, 2> = 0>
         XSIMD_INLINE batch<R, A> bitwise_cast(batch<T, A> const& arg, batch<R, A> const&, requires_arch<sve>) noexcept
         {
-            return svreinterpret_u16(static_cast<detail::sve_sizeless_t<T>>(arg));
+            return svreinterpret_u16(static_cast<detail_sve::sizeless_t<T>>(arg));
         }
 
         template <class A, class T, class R, detail::enable_arithmetic_t<T> = 0, detail::enable_sized_signed_t<R, 2> = 0>
         XSIMD_INLINE batch<R, A> bitwise_cast(batch<T, A> const& arg, batch<R, A> const&, requires_arch<sve>) noexcept
         {
-            return svreinterpret_s16(static_cast<detail::sve_sizeless_t<T>>(arg));
+            return svreinterpret_s16(static_cast<detail_sve::sizeless_t<T>>(arg));
         }
 
         template <class A, class T, class R, detail::enable_arithmetic_t<T> = 0, detail::enable_sized_unsigned_t<R, 4> = 0>
         XSIMD_INLINE batch<R, A> bitwise_cast(batch<T, A> const& arg, batch<R, A> const&, requires_arch<sve>) noexcept
         {
-            return svreinterpret_u32(static_cast<detail::sve_sizeless_t<T>>(arg));
+            return svreinterpret_u32(static_cast<detail_sve::sizeless_t<T>>(arg));
         }
 
         template <class A, class T, class R, detail::enable_arithmetic_t<T> = 0, detail::enable_sized_signed_t<R, 4> = 0>
         XSIMD_INLINE batch<R, A> bitwise_cast(batch<T, A> const& arg, batch<R, A> const&, requires_arch<sve>) noexcept
         {
-            return svreinterpret_s32(static_cast<detail::sve_sizeless_t<T>>(arg));
+            return svreinterpret_s32(static_cast<detail_sve::sizeless_t<T>>(arg));
         }
 
         template <class A, class T, class R, detail::enable_arithmetic_t<T> = 0, detail::enable_sized_unsigned_t<R, 8> = 0>
         XSIMD_INLINE batch<R, A> bitwise_cast(batch<T, A> const& arg, batch<R, A> const&, requires_arch<sve>) noexcept
         {
-            return svreinterpret_u64(static_cast<detail::sve_sizeless_t<T>>(arg));
+            return svreinterpret_u64(static_cast<detail_sve::sizeless_t<T>>(arg));
         }
 
         template <class A, class T, class R, detail::enable_arithmetic_t<T> = 0, detail::enable_sized_signed_t<R, 8> = 0>
         XSIMD_INLINE batch<R, A> bitwise_cast(batch<T, A> const& arg, batch<R, A> const&, requires_arch<sve>) noexcept
         {
-            return svreinterpret_s64(static_cast<detail::sve_sizeless_t<T>>(arg));
+            return svreinterpret_s64(static_cast<detail_sve::sizeless_t<T>>(arg));
         }
 
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<float, A> bitwise_cast(batch<T, A> const& arg, batch<float, A> const&, requires_arch<sve>) noexcept
         {
-            return svreinterpret_f32(static_cast<detail::sve_sizeless_t<T>>(arg));
+            return svreinterpret_f32(static_cast<detail_sve::sizeless_t<T>>(arg));
         }
 
         template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<double, A> bitwise_cast(batch<T, A> const& arg, batch<double, A> const&, requires_arch<sve>) noexcept
         {
-            return svreinterpret_f64(static_cast<detail::sve_sizeless_t<T>>(arg));
+            return svreinterpret_f64(static_cast<detail_sve::sizeless_t<T>>(arg));
         }
 
         // batch_bool_cast
@@ -1048,71 +1071,77 @@ namespace xsimd
         }
 
         // slide_left
-        namespace detail
+        namespace detail_sve
         {
-            template <size_t N>
-            struct sve_slider_left
+            inline namespace XSIMD_SVE_NAMESPACE
             {
-                template <class A, class T>
-                XSIMD_INLINE batch<T, A> operator()(batch<T, A> const& arg) noexcept
+                template <size_t N>
+                struct slider_left
                 {
-                    using u8_vector = batch<uint8_t, A>;
-                    const auto left = svdup_n_u8(0);
-                    const auto right = bitwise_cast(arg, u8_vector {}, sve {}).data;
-                    const u8_vector result(svext(left, right, u8_vector::size - N));
-                    return bitwise_cast(result, batch<T, A> {}, sve {});
-                }
-            };
-
-            template <>
-            struct sve_slider_left<0>
-            {
-                template <class A, class T>
-                XSIMD_INLINE batch<T, A> operator()(batch<T, A> const& arg) noexcept
+                    template <class A, class T>
+                    XSIMD_INLINE batch<T, A> operator()(batch<T, A> const& arg) noexcept
+                    {
+                        using u8_vector = batch<uint8_t, A>;
+                        const auto left = svdup_n_u8(0);
+                        const auto right = bitwise_cast(arg, u8_vector {}, sve {}).data;
+                        const u8_vector result(svext(left, right, u8_vector::size - N));
+                        return bitwise_cast(result, batch<T, A> {}, sve {});
+                    }
+                };
+
+                template <>
+                struct slider_left<0>
                 {
-                    return arg;
-                }
-            };
-        } // namespace detail
+                    template <class A, class T>
+                    XSIMD_INLINE batch<T, A> operator()(batch<T, A> const& arg) noexcept
+                    {
+                        return arg;
+                    }
+                };
+            } // namespace XSIMD_SVE_NAMESPACE
+        } // namespace detail_sve
 
         template <size_t N, class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> slide_left(batch<T, A> const& arg, requires_arch<sve>) noexcept
         {
-            return detail::sve_slider_left<N>()(arg);
+            return detail_sve::slider_left<N>()(arg);
         }
 
         // slide_right
-        namespace detail
+        namespace detail_sve
         {
-            template <size_t N>
-            struct sve_slider_right
+            inline namespace XSIMD_SVE_NAMESPACE
             {
-                template <class A, class T>
-                XSIMD_INLINE batch<T, A> operator()(batch<T, A> const& arg) noexcept
+                template <size_t N>
+                struct slider_right
                 {
-                    using u8_vector = batch<uint8_t, A>;
-                    const auto left = bitwise_cast(arg, u8_vector {}, sve {}).data;
-                    const auto right = svdup_n_u8(0);
-                    const u8_vector result(svext(left, right, N));
-                    return bitwise_cast(result, batch<T, A> {}, sve {});
-                }
-            };
-
-            template <>
-            struct sve_slider_right<batch<uint8_t, sve>::size>
-            {
-                template <class A, class T>
-                XSIMD_INLINE batch<T, A> operator()(batch<T, A> const&) noexcept
+                    template <class A, class T>
+                    XSIMD_INLINE batch<T, A> operator()(batch<T, A> const& arg) noexcept
+                    {
+                        using u8_vector = batch<uint8_t, A>;
+                        const auto left = bitwise_cast(arg, u8_vector {}, sve {}).data;
+                        const auto right = svdup_n_u8(0);
+                        const u8_vector result(svext(left, right, N));
+                        return bitwise_cast(result, batch<T, A> {}, sve {});
+                    }
+                };
+
+                template <>
+                struct slider_right<batch<uint8_t, sve>::size>
                 {
-                    return batch<T, A> {};
-                }
-            };
-        } // namespace detail
+                    template <class A, class T>
+                    XSIMD_INLINE batch<T, A> operator()(batch<T, A> const&) noexcept
+                    {
+                        return batch<T, A> {};
+                    }
+                };
+            } // namespace XSIMD_SVE_NAMESPACE
+        } // namespace detail_sve
 
         template <size_t N, class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> slide_right(batch<T, A> const& arg, requires_arch<sve>) noexcept
         {
-            return detail::sve_slider_right<N>()(arg);
+            return detail_sve::slider_right<N>()(arg);
         }
 
         // isnan
@@ -1126,29 +1155,29 @@ namespace xsimd
         template <class A, class T, detail::enable_floating_point_t<T> = 0>
         XSIMD_INLINE batch<T, A> nearbyint(batch<T, A> const& arg, requires_arch<sve>) noexcept
         {
-            return svrintx_x(detail::sve_ptrue<T>(), arg);
+            return svrintx_x(detail_sve::ptrue<T>(), arg);
         }
 
         // nearbyint_as_int
         template <class A>
         XSIMD_INLINE batch<int32_t, A> nearbyint_as_int(batch<float, A> const& arg, requires_arch<sve>) noexcept
         {
-            const auto nearest = svrintx_x(detail::sve_ptrue<float>(), arg);
-            return svcvt_s32_x(detail::sve_ptrue<float>(), nearest);
+            const auto nearest = svrintx_x(detail_sve::ptrue<float>(), arg);
+            return svcvt_s32_x(detail_sve::ptrue<float>(), nearest);
         }
 
         template <class A>
         XSIMD_INLINE batch<int64_t, A> nearbyint_as_int(batch<double, A> const& arg, requires_arch<sve>) noexcept
         {
-            const auto nearest = svrintx_x(detail::sve_ptrue<double>(), arg);
-            return svcvt_s64_x(detail::sve_ptrue<double>(), nearest);
+            const auto nearest = svrintx_x(detail_sve::ptrue<double>(), arg);
+            return svcvt_s64_x(detail_sve::ptrue<double>(), nearest);
         }
 
         // ldexp
         template <class A, class T, detail::enable_floating_point_t<T> = 0>
         XSIMD_INLINE batch<T, A> ldexp(const batch<T, A>& x, const batch<as_integer_t<T>, A>& exp, requires_arch<sve>) noexcept
         {
-            return svscale_x(detail::sve_ptrue<T>(), x, exp);
+            return svscale_x(detail_sve::ptrue<T>(), x, exp);
         }
 
     } // namespace kernel