diff --git a/include/eve/arch/cpu/top_bits.hpp b/include/eve/arch/cpu/top_bits.hpp
index e7acd805f9..5df4477f6a 100644
--- a/include/eve/arch/cpu/top_bits.hpp
+++ b/include/eve/arch/cpu/top_bits.hpp
@@ -106,13 +106,13 @@ namespace detail
       else                            return movemask(logical_type{}).first;
     }
 
-    EVE_FORCEINLINE static constexpr std::ptrdiff_t bits_per_element_impl()
+    EVE_FORCEINLINE static consteval std::ptrdiff_t bits_per_element_impl()
     {
       if constexpr ( is_aggregated ) return top_bits<half_logical>::bits_per_element;
       else                           return decltype(movemask(logical_type{}).second){}();
     }
 
-    static constexpr bool is_cheap_impl()
+    static consteval bool is_cheap_impl()
     {
       if constexpr ( has_emulated_abi_v<logical_type> ) return true;
       else if constexpr ( is_aggregated ) return top_bits<half_logical>::is_cheap;
diff --git a/include/eve/module/core/named_shuffles/blend.hpp b/include/eve/module/core/named_shuffles/blend.hpp
index a7b81cd250..345ddac8b3 100644
--- a/include/eve/module/core/named_shuffles/blend.hpp
+++ b/include/eve/module/core/named_shuffles/blend.hpp
@@ -68,7 +68,7 @@ namespace eve
 struct blend_t
 {
   template<simd_value T, std::ptrdiff_t G, std::ptrdiff_t... I>
-  static constexpr auto pattern(eve::as<T>, eve::as<T>, eve::fixed<G>, pattern_t<I...>)
+  static consteval auto pattern(eve::as<T>, eve::as<T>, eve::fixed<G>, pattern_t<I...>)
   {
     static_assert(((0 <= I && I <= 1) && ...), "pattern for blend has to only contain 0 and 1");
     static_assert(pattern_t<I...>::size() * G == T::size(), "pattern has wrong number of elements");
@@ -82,7 +82,7 @@ struct blend_t
   }
 
   template<simd_value T, std::ptrdiff_t G, std::ptrdiff_t... I>
-  static constexpr std::ptrdiff_t level(eve::as<T>, eve::as<T>, eve::fixed<G> g, pattern_t<I...> p)
+  static consteval std::ptrdiff_t level(eve::as<T>, eve::as<T>, eve::fixed<G> g, pattern_t<I...> p)
   {
     if constexpr( sizeof...(I) == 1 ) return 0;
     else if constexpr( eve::has_aggregated_abi_v<T> )
@@ -142,14 +142,14 @@ struct blend_t
   }
 
   template<simd_value T, std::ptrdiff_t G>
-  static constexpr auto
+  static consteval auto
   pattern(eve::as<T> tgt, eve::as<T>, eve::fixed<G> g, pattern_formula auto gen)
   {
     return pattern(tgt, tgt, g, fix_pattern<T::size() / G>(gen));
   }
 
   template<simd_value T, std::ptrdiff_t G, std::ptrdiff_t... I>
-  static constexpr auto level(eve::as<T> tgt, eve::as<T>, eve::fixed<G> g, pattern_formula auto gen)
+  static consteval auto level(eve::as<T> tgt, eve::as<T>, eve::fixed<G> g, pattern_formula auto gen)
   {
     return level(tgt, tgt, g, fix_pattern<T::size() / G>(gen));
   }
diff --git a/include/eve/module/core/named_shuffles/broadcast_lane.hpp b/include/eve/module/core/named_shuffles/broadcast_lane.hpp
index bcdc341c7c..71f677a14a 100644
--- a/include/eve/module/core/named_shuffles/broadcast_lane.hpp
+++ b/include/eve/module/core/named_shuffles/broadcast_lane.hpp
@@ -59,14 +59,14 @@ namespace eve
 struct broadcast_lane_t
 {
   template<simd_value T, std::ptrdiff_t G, std::ptrdiff_t I>
-  static constexpr auto pattern(eve::as<T>, eve::fixed<G>, eve::index_t<I>)
+  static consteval auto pattern(eve::as<T>, eve::fixed<G>, eve::index_t<I>)
   {
     static_assert(I < T::size() / G);
     return eve::fix_pattern<T::size() / G>([](int, int) { return I; });
   }
 
   template<simd_value T, std::ptrdiff_t G, std::ptrdiff_t I>
-  static constexpr std::ptrdiff_t level(eve::as<T> tgt, eve::fixed<G> g, eve::index_t<I> i)
+  static consteval std::ptrdiff_t level(eve::as<T> tgt, eve::fixed<G> g, eve::index_t<I> i)
   {
     constexpr std::size_t    reg_size = sizeof(element_type_t<T>) * T::size();
     constexpr std::ptrdiff_t g_size   = sizeof(element_type_t<T>) * G;
diff --git a/include/eve/module/core/named_shuffles/reverse.hpp b/include/eve/module/core/named_shuffles/reverse.hpp
index ec89ef2264..ca2db55ecb 100644
--- a/include/eve/module/core/named_shuffles/reverse.hpp
+++ b/include/eve/module/core/named_shuffles/reverse.hpp
@@ -55,13 +55,13 @@ namespace eve
 //================================================================================================
 struct reverse_t
 {
-  template<simd_value T, std::ptrdiff_t G> static constexpr auto pattern(eve::as<T>, eve::fixed<G>)
+  template<simd_value T, std::ptrdiff_t G> static consteval auto pattern(eve::as<T>, eve::fixed<G>)
   {
     return eve::fix_pattern<T::size() / G>([](int i, int size) { return size - i - 1; });
   }
 
   template<simd_value T, std::ptrdiff_t G>
-  static constexpr std::ptrdiff_t level(eve::as<T> tgt, eve::fixed<G> g)
+  static consteval std::ptrdiff_t level(eve::as<T> tgt, eve::fixed<G> g)
   {
     if constexpr( eve::has_aggregated_abi_v<T> )
     {
diff --git a/include/eve/module/core/named_shuffles/reverse_in_subgroups.hpp b/include/eve/module/core/named_shuffles/reverse_in_subgroups.hpp
index 856d664892..76b78a9191 100644
--- a/include/eve/module/core/named_shuffles/reverse_in_subgroups.hpp
+++ b/include/eve/module/core/named_shuffles/reverse_in_subgroups.hpp
@@ -62,7 +62,7 @@ namespace eve
 struct reverse_in_subgroups_t
 {
   template<simd_value T, std::ptrdiff_t G, std::ptrdiff_t SubG>
-  static constexpr auto pattern(eve::as<T>, eve::fixed<G>, eve::fixed<SubG>)
+  static consteval auto pattern(eve::as<T>, eve::fixed<G>, eve::fixed<SubG>)
   {
     static_assert(SubG <= T::size() / G);
     static_assert(SubG >= 1);
@@ -77,7 +77,7 @@ struct reverse_in_subgroups_t
   }
 
   template<simd_value T, std::ptrdiff_t G, std::ptrdiff_t SubG>
-  static constexpr std::ptrdiff_t level(eve::as<T> tgt, eve::fixed<G> g, eve::fixed<SubG> sub_g)
+  static consteval std::ptrdiff_t level(eve::as<T> tgt, eve::fixed<G> g, eve::fixed<SubG> sub_g)
   {
     constexpr std::ptrdiff_t g_size   = sizeof(element_type_t<T>) * G;
     constexpr std::size_t    sub_size = g_size * SubG;
diff --git a/include/eve/module/core/named_shuffles/slide.hpp b/include/eve/module/core/named_shuffles/slide.hpp
index 44e6f9550e..f3e981f049 100644
--- a/include/eve/module/core/named_shuffles/slide.hpp
+++ b/include/eve/module/core/named_shuffles/slide.hpp
@@ -68,14 +68,14 @@ struct slide_left_impl_t
 {
   // One agr
   template<simd_value T, std::ptrdiff_t G, std::ptrdiff_t S>
-  static constexpr auto pattern(eve::as<T>, eve::fixed<G>, eve::index_t<S>)
+  static consteval auto pattern(eve::as<T>, eve::fixed<G>, eve::index_t<S>)
   {
     static_assert(G > 0 && 0 <= S && S <= T::size() / G);
     return eve::fix_pattern<T::size() / G>([](int i, int n) { return (i + S) < n ? i + S : na_; });
   }
 
   template<simd_value T, std::ptrdiff_t G, std::ptrdiff_t S_>
-  static constexpr std::ptrdiff_t level(eve::as<T> tgt, eve::fixed<G> g, eve::index_t<S_> s)
+  static consteval std::ptrdiff_t level(eve::as<T> tgt, eve::fixed<G> g, eve::index_t<S_> s)
   {
     using abi_t                             = typename T::abi_type;
     constexpr std::size_t    reg_size       = sizeof(element_type_t<T>) * T::size();
@@ -133,7 +133,7 @@ struct slide_left_impl_t
   // Two args
 
   template<simd_value T, std::ptrdiff_t G, std::ptrdiff_t S_>
-  static constexpr std::ptrdiff_t
+  static consteval std::ptrdiff_t
   level(eve::as<T> tgt, eve::as<T>, eve::fixed<G> g, eve::index_t<S_> s)
   {
     using abi_t                       = typename T::abi_type;
diff --git a/include/eve/module/core/named_shuffles/swap_adjacent.hpp b/include/eve/module/core/named_shuffles/swap_adjacent.hpp
index 0f3ae72b46..e46be290b5 100644
--- a/include/eve/module/core/named_shuffles/swap_adjacent.hpp
+++ b/include/eve/module/core/named_shuffles/swap_adjacent.hpp
@@ -53,7 +53,7 @@ namespace eve
 struct swap_adjacent_t
 {
   template<simd_value T, std::ptrdiff_t G>
-  static constexpr auto pattern(eve::as<T>, eve::fixed<G>)
+  static consteval auto pattern(eve::as<T>, eve::fixed<G>)
   requires(G < T::size())
   {
     return eve::fix_pattern<T::size() / G>(
@@ -65,7 +65,7 @@ struct swap_adjacent_t
   }
 
   template<simd_value T, std::ptrdiff_t G>
-  static constexpr std::ptrdiff_t level(eve::as<T> tgt, eve::fixed<G> g)
+  static consteval std::ptrdiff_t level(eve::as<T> tgt, eve::fixed<G> g)
   {
     constexpr std::ptrdiff_t g_size   = sizeof(element_type_t<T>) * G;
     constexpr std::size_t    reg_size = sizeof(element_type_t<T>) * T::size();