diff --git a/docs/compiler.adoc b/docs/compiler.adoc
index 89aa9a8..940be33 100644
--- a/docs/compiler.adoc
+++ b/docs/compiler.adoc
@@ -6,8 +6,6 @@ provides macros for decorating declarations, which resolve either to keywords or
 to compiler-specific attributes:
 
 * https://clang.llvm.org/docs/AttributeReference.html#always-inline-force-inline[`ALWAYS_INLINE`]
-* https://en.cppreference.com/w/cpp/language/consteval[`CONSTEVAL`]
-* https://en.cppreference.com/w/cpp/language/constinit[`CONSTINIT`]
 * https://clang.llvm.org/docs/AttributeReference.html#lifetimebound[`LIFETIMEBOUND`]
 * https://clang.llvm.org/docs/AttributeReference.html#musttail[`MUSTTAIL`]
 * https://clang.llvm.org/docs/AttributeReference.html#noinline[`NEVER_INLINE`]
diff --git a/include/stdx/bit.hpp b/include/stdx/bit.hpp
index 1142717..4cc930b 100644
--- a/include/stdx/bit.hpp
+++ b/include/stdx/bit.hpp
@@ -403,7 +403,7 @@ template <typename T, std::size_t N> struct bitmask_subtract<std::array<T, N>> {
 
 template <typename T, std::size_t Msb = detail::num_digits_v<T> - 1,
           std::size_t Lsb = 0>
-[[nodiscard]] CONSTEVAL auto bit_mask() noexcept -> T {
+[[nodiscard]] consteval auto bit_mask() noexcept -> T {
     static_assert(Msb < detail::num_digits_v<T>,
                   "bit_mask requested exceeds the range of the type");
     static_assert(Msb >= Lsb, "bit_mask range is invalid");
@@ -422,7 +422,7 @@ template <typename T> constexpr auto bit_size() -> std::size_t {
     return sizeof(T) * CHAR_BIT;
 }
 
-template <std::size_t N> CONSTEVAL auto smallest_uint() {
+template <std::size_t N> consteval auto smallest_uint() {
     if constexpr (N <= std::numeric_limits<std::uint8_t>::digits) {
         return std::uint8_t{};
     } else if constexpr (N <= std::numeric_limits<std::uint16_t>::digits) {
diff --git a/include/stdx/bitset.hpp b/include/stdx/bitset.hpp
index 5f9c88f..b897a8e 100644
--- a/include/stdx/bitset.hpp
+++ b/include/stdx/bitset.hpp
@@ -102,7 +102,7 @@ class bitset {
     using iter_arg_t = conditional_t<std::is_enum_v<decltype(Size)>,
                                      decltype(Size), std::size_t>;
 
-    template <typename T> CONSTEVAL static auto admissible_enum() {
+    template <typename T> consteval static auto admissible_enum() {
         return not std::is_enum_v<T> or std::is_same_v<T, decltype(Size)>;
     }
 
diff --git a/include/stdx/call_by_need.hpp b/include/stdx/call_by_need.hpp
index 509b066..daef889 100644
--- a/include/stdx/call_by_need.hpp
+++ b/include/stdx/call_by_need.hpp
@@ -27,14 +27,14 @@ struct call_info {
 };
 
 template <std::size_t R, typename T, std::size_t N>
-CONSTEVAL auto truncate_array(std::array<T, N> const &arr) {
+consteval auto truncate_array(std::array<T, N> const &arr) {
     return [&]<std::size_t... Is>(std::index_sequence<Is...>) {
         return std::array<T, sizeof...(Is)>{arr[Is]...};
     }(std::make_index_sequence<R>{});
 }
 
 template <typename T, std::size_t N, std::size_t M>
-CONSTEVAL auto concat(std::array<T, N> const &a1, std::array<T, M> const &a2)
+consteval auto concat(std::array<T, N> const &a1, std::array<T, M> const &a2)
     -> std::array<T, N + M> {
     std::array<T, N + M> result{};
     auto it = std::copy(std::cbegin(a1), std::cend(a1), std::begin(result));
@@ -64,7 +64,7 @@ constexpr auto invoke(F &&f, Args &&args) -> decltype(auto) {
 
 template <typename... Fs> struct by_need {
     template <typename... Args>
-    [[nodiscard]] CONSTEVAL static auto compute_call_info_impl() {
+    [[nodiscard]] consteval static auto compute_call_info_impl() {
         auto results = std::array<call_info, sizeof...(Fs) + sizeof...(Args)>{};
         auto result_count = std::size_t{};
 
@@ -108,7 +108,7 @@ template <typename... Fs> struct by_need {
     }
 
     template <typename... Args>
-    [[nodiscard]] CONSTEVAL static auto compute_call_info() {
+    [[nodiscard]] consteval static auto compute_call_info() {
         constexpr auto given_calls = [] {
             constexpr auto cs = compute_call_info_impl<Args...>();
             return truncate_array<cs.second>(cs.first);
diff --git a/include/stdx/compiler.hpp b/include/stdx/compiler.hpp
index 5b1c2d0..452cf49 100644
--- a/include/stdx/compiler.hpp
+++ b/include/stdx/compiler.hpp
@@ -2,34 +2,6 @@
 
 // NOLINTBEGIN(cppcoreguidelines-macro-usage)
 
-#ifndef CONSTINIT
-#ifndef __cpp_constinit
-#ifdef __clang__
-#define CONSTINIT [[clang::require_constant_initialization]]
-#else
-#define CONSTINIT
-#endif
-#else
-#define CONSTINIT constinit
-#endif
-#endif
-
-#ifndef CONSTEVAL
-#ifndef __cpp_consteval
-#define CONSTEVAL constexpr
-#else
-#define CONSTEVAL consteval
-#endif
-#endif
-
-#ifndef CONSTEVAL_UDL
-#ifdef __clang__
-#define CONSTEVAL_UDL constexpr
-#else
-#define CONSTEVAL_UDL CONSTEVAL
-#endif
-#endif
-
 #ifndef USING_ATTR_NS
 #ifdef __clang__
 #define USING_ATTR_NS using clang:
@@ -89,7 +61,7 @@
 #endif
 #endif
 
-#ifndef NRVO
+#ifndef STDX_NRVO
 #ifdef __clang__
 #define STDX_NRVO(x) std::move(x)
 #else
diff --git a/include/stdx/ct_conversions.hpp b/include/stdx/ct_conversions.hpp
index 64ca586..0cd9005 100644
--- a/include/stdx/ct_conversions.hpp
+++ b/include/stdx/ct_conversions.hpp
@@ -9,7 +9,7 @@ inline namespace v1 {
 template <typename...> constexpr bool always_false_v = false;
 
 template <typename Tag>
-CONSTEVAL static auto type_as_string() -> std::string_view {
+consteval static auto type_as_string() -> std::string_view {
 #ifdef __clang__
     constexpr std::string_view function_name = __PRETTY_FUNCTION__;
     constexpr auto rhs = function_name.size() - 2;
@@ -26,14 +26,14 @@ CONSTEVAL static auto type_as_string() -> std::string_view {
 }
 
 template <typename T>
-CONSTEVAL static auto template_base() -> std::string_view {
+consteval static auto template_base() -> std::string_view {
     constexpr auto t = stdx::type_as_string<T>();
     constexpr auto rhs = t.find('<');
     return t.substr(0, rhs);
 }
 
 template <auto Value>
-CONSTEVAL static auto enum_as_string() -> std::basic_string_view<char> {
+consteval static auto enum_as_string() -> std::basic_string_view<char> {
 #ifdef __clang__
     constexpr std::string_view value_string = __PRETTY_FUNCTION__;
 #elif defined(__GNUC__) || defined(__GNUG__)
diff --git a/include/stdx/ct_format.hpp b/include/stdx/ct_format.hpp
index dc99c44..6f9c567 100644
--- a/include/stdx/ct_format.hpp
+++ b/include/stdx/ct_format.hpp
@@ -36,7 +36,7 @@ struct named_arg {
     constexpr static std::integral_constant<bool, (End < Begin)> is_runtime{};
 
     template <int StringOffset, int ArgOffset>
-    CONSTEVAL static auto apply_offset() {
+    consteval static auto apply_offset() {
         if constexpr (is_runtime) {
             return named_arg<Name, T, Begin + ArgOffset, End + ArgOffset>{};
         } else {
@@ -65,7 +65,7 @@ using apply_offset =
 
 template <typename Str, typename Args, typename NamedArgs>
 struct format_result {
-    CONSTEVAL static auto ct_string_convertible()
+    consteval static auto ct_string_convertible()
         -> std::bool_constant<Args::size() == 0>;
 
     [[no_unique_address]] Str str;
@@ -92,7 +92,7 @@ struct format_result {
 template <typename Str, typename Args, typename NamedArgs>
     requires(Args::size() == 0 and is_cx_value_v<Str>)
 struct format_result<Str, Args, NamedArgs> {
-    CONSTEVAL static auto ct_string_convertible() -> std::true_type;
+    consteval static auto ct_string_convertible() -> std::true_type;
 
     [[no_unique_address]] Str str;
     [[no_unique_address]] Args args{};
@@ -116,14 +116,14 @@ constexpr auto make_format_result(Str s, Args args = {}) {
 
 inline namespace literals {
 inline namespace ct_string_literals {
-template <ct_string S> CONSTEVAL_UDL auto operator""_fmt_res() {
+template <ct_string S> consteval auto operator""_fmt_res() {
     return make_format_result(cts_t<S>{});
 }
 } // namespace ct_string_literals
 } // namespace literals
 
 namespace detail {
-template <typename It> CONSTEVAL auto find_spec(It first, It last) -> It {
+template <typename It> consteval auto find_spec(It first, It last) -> It {
     for (auto spec_start = std::find(first, last, '{'); spec_start != last;
          spec_start = std::find(spec_start, last, '{')) {
         if (spec_start + 1 != last) {
@@ -137,7 +137,7 @@ template <typename It> CONSTEVAL auto find_spec(It first, It last) -> It {
     return last;
 }
 
-CONSTEVAL auto count_specifiers(std::string_view fmt) -> std::size_t {
+consteval auto count_specifiers(std::string_view fmt) -> std::size_t {
     auto count = std::size_t{};
     for (auto spec_start = find_spec(fmt.begin(), fmt.end());
          spec_start != fmt.end();
@@ -157,7 +157,7 @@ struct split_spec {
 };
 
 template <std::size_t N>
-CONSTEVAL auto split_specifiers(std::string_view fmt)
+consteval auto split_specifiers(std::string_view fmt)
     -> std::array<split_spec, N> {
     auto splits = std::array<split_spec, N>{};
     auto count = std::size_t{};
@@ -182,7 +182,7 @@ CONSTEVAL auto split_specifiers(std::string_view fmt)
     return splits;
 }
 
-template <ct_string S, std::size_t Start> CONSTEVAL auto extract_format1_str() {
+template <ct_string S, std::size_t Start> consteval auto extract_format1_str() {
     constexpr auto name_start = Start + 1;
     constexpr auto it = [] {
         for (auto i = S.value.cbegin() + name_start; i != S.value.cend(); ++i) {
@@ -231,7 +231,7 @@ concept fmt_cx_value =
     is_cx_value_v<T> or requires(T t) { ct_string_from_type(t); };
 
 template <typename T, T V>
-CONSTEVAL auto arg_value(std::integral_constant<T, V>) {
+consteval auto arg_value(std::integral_constant<T, V>) {
     if constexpr (std::is_enum_v<T>) {
         return enum_as_string<V>();
     } else {
@@ -239,13 +239,13 @@ CONSTEVAL auto arg_value(std::integral_constant<T, V>) {
     }
 }
 
-template <typename T> CONSTEVAL auto arg_value(type_identity<T>) {
+template <typename T> consteval auto arg_value(type_identity<T>) {
     return type_as_string<T>();
 }
 
-template <ct_string S> CONSTEVAL auto arg_value(cts_t<S>) { return S; }
+template <ct_string S> consteval auto arg_value(cts_t<S>) { return S; }
 
-CONSTEVAL auto arg_value(fmt_cx_value auto a) {
+consteval auto arg_value(fmt_cx_value auto a) {
     if constexpr (is_specialization_of_v<decltype(a), format_result>) {
         return a;
     } else if constexpr (requires { arg_value(a()); }) {
@@ -259,12 +259,12 @@ CONSTEVAL auto arg_value(fmt_cx_value auto a) {
     }
 }
 
-template <typename T> CONSTEVAL auto arg_type(T) -> T;
+template <typename T> consteval auto arg_type(T) -> T;
 
 template <typename T, T V>
-CONSTEVAL auto arg_type(std::integral_constant<T, V>) -> T;
+consteval auto arg_type(std::integral_constant<T, V>) -> T;
 
-CONSTEVAL auto arg_type(fmt_cx_value auto a) {
+consteval auto arg_type(fmt_cx_value auto a) {
     if constexpr (requires { ct_string_from_type(a); }) {
         return ct_string_from_type(a);
     } else {
@@ -301,11 +301,11 @@ constexpr auto operator+(format_result<Str1, Args1, NamedArgs1> r1,
 
 template <typename T, T...> struct null_output;
 
-template <std::size_t Sz> CONSTEVAL auto to_ct_string(std::string_view s) {
+template <std::size_t Sz> consteval auto to_ct_string(std::string_view s) {
     return ct_string<Sz + 1>{s.data(), s.size()};
 }
 
-CONSTEVAL auto convert_input(auto s) {
+consteval auto convert_input(auto s) {
     if constexpr (requires { ct_string_from_type(s); }) {
         return ct_string_from_type(s);
     } else {
@@ -315,7 +315,7 @@ CONSTEVAL auto convert_input(auto s) {
 
 template <ct_string S,
           template <typename T, T...> typename Output = detail::null_output>
-CONSTEVAL auto convert_output() {
+consteval auto convert_output() {
     if constexpr (same_as<Output<char>, null_output<char>>) {
         return cts_t<S>{};
     } else {
@@ -324,7 +324,7 @@ CONSTEVAL auto convert_output() {
 }
 
 template <std::size_t N>
-CONSTEVAL auto perform_format(auto s, auto const &v) -> ct_string<N + 1> {
+consteval auto perform_format(auto s, auto const &v) -> ct_string<N + 1> {
     ct_string<N + 1> cts{};
     fmt::format_to(cts.begin(), s, v);
     return cts;
diff --git a/include/stdx/ct_string.hpp b/include/stdx/ct_string.hpp
index 0010028..f6da6a5 100644
--- a/include/stdx/ct_string.hpp
+++ b/include/stdx/ct_string.hpp
@@ -25,10 +25,10 @@ concept format_convertible = requires(T t) {
 } // namespace detail
 
 template <std::size_t N> struct ct_string {
-    CONSTEVAL ct_string() = default;
+    consteval ct_string() = default;
 
     // NOLINTNEXTLINE(*-avoid-c-arrays, google-explicit-constructor)
-    CONSTEVAL explicit(false) ct_string(char const (&str)[N]) {
+    consteval explicit(false) ct_string(char const (&str)[N]) {
         for (auto i = std::size_t{}; i < N; ++i) {
             // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-*)
             value[i] = str[i];
@@ -37,16 +37,16 @@ template <std::size_t N> struct ct_string {
 
     template <detail::format_convertible T>
     // NOLINTNEXTLINE(google-explicit-constructor)
-    CONSTEVAL explicit(false) ct_string(T t) : ct_string(+t) {}
+    consteval explicit(false) ct_string(T t) : ct_string(+t) {}
 
-    CONSTEVAL explicit(true) ct_string(char const *str, std::size_t sz) {
+    consteval explicit(true) ct_string(char const *str, std::size_t sz) {
         for (auto i = std::size_t{}; i < sz; ++i) {
             // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-*)
             value[i] = str[i];
         }
     }
 
-    CONSTEVAL explicit(true) ct_string(std::string_view str)
+    consteval explicit(true) ct_string(std::string_view str)
         : ct_string{str.data(), str.size()} {}
 
     [[nodiscard]] constexpr auto begin() LIFETIMEBOUND { return value.begin(); }
@@ -86,12 +86,12 @@ template <std::size_t N, std::size_t M>
 }
 
 template <template <typename C, C...> typename T, char... Cs>
-[[nodiscard]] CONSTEVAL auto ct_string_from_type(T<char, Cs...>) {
+[[nodiscard]] consteval auto ct_string_from_type(T<char, Cs...>) {
     return ct_string<sizeof...(Cs) + 1U>{{Cs..., 0}};
 }
 
 template <ct_string S, template <typename C, C...> typename T>
-[[nodiscard]] CONSTEVAL auto ct_string_to_type() {
+[[nodiscard]] consteval auto ct_string_to_type() {
     return [&]<auto... Is>(std::index_sequence<Is...>) {
         return T<char, std::get<Is>(S.value)...>{};
     }(std::make_index_sequence<S.size()>{});
@@ -141,7 +141,7 @@ template <ct_string S> struct cts_t {
     using value_type = decltype(S);
     constexpr static auto value = S;
 
-    CONSTEVAL static auto ct_string_convertible() -> std::true_type;
+    consteval static auto ct_string_convertible() -> std::true_type;
     friend constexpr auto operator+(cts_t const &) { return value; }
     constexpr auto operator()() const noexcept { return value; }
     using cx_value_t [[maybe_unused]] = void;
@@ -172,17 +172,15 @@ namespace detail {
 template <std::size_t N> struct ct_helper<ct_string<N>>;
 } // namespace detail
 
-template <ct_string Value> CONSTEVAL auto ct() { return cts_t<Value>{}; }
+template <ct_string Value> consteval auto ct() { return cts_t<Value>{}; }
 
 template <ct_string Value> constexpr auto is_ct_v<cts_t<Value>> = true;
 
 inline namespace literals {
 inline namespace ct_string_literals {
-template <ct_string S> CONSTEVAL_UDL auto operator""_cts() { return S; }
+template <ct_string S> consteval auto operator""_cts() { return S; }
 
-template <ct_string S> CONSTEVAL_UDL auto operator""_ctst() {
-    return cts_t<S>{};
-}
+template <ct_string S> consteval auto operator""_ctst() { return cts_t<S>{}; }
 } // namespace ct_string_literals
 } // namespace literals
 } // namespace v1
diff --git a/include/stdx/detail/fmt.hpp b/include/stdx/detail/fmt.hpp
index 73c833f..13042a3 100644
--- a/include/stdx/detail/fmt.hpp
+++ b/include/stdx/detail/fmt.hpp
@@ -34,7 +34,7 @@ struct fmt_spec {
     bool well_formed{true};
 };
 
-CONSTEVAL auto parse_fmt_spec(auto fmtstr) -> fmt_spec {
+consteval auto parse_fmt_spec(auto fmtstr) -> fmt_spec {
     constexpr auto fmt = fmtstr();
     auto i = fmt.begin();
     while (*i != '{') {
@@ -50,11 +50,11 @@ CONSTEVAL auto parse_fmt_spec(auto fmtstr) -> fmt_spec {
 }
 
 template <stdx::range R>
-CONSTEVAL auto formatted_size(fmt_spec, R const &r) -> std::size_t {
+consteval auto formatted_size(fmt_spec, R const &r) -> std::size_t {
     return r.size();
 }
 
-CONSTEVAL auto formatted_size(fmt_spec, char const *str) -> std::size_t {
+consteval auto formatted_size(fmt_spec, char const *str) -> std::size_t {
     std::size_t sz{};
     while (*str) {
         ++sz;
@@ -63,10 +63,10 @@ CONSTEVAL auto formatted_size(fmt_spec, char const *str) -> std::size_t {
     return sz;
 }
 
-CONSTEVAL auto formatted_size(fmt_spec, char) -> std::size_t { return 1; }
+consteval auto formatted_size(fmt_spec, char) -> std::size_t { return 1; }
 
 template <stdx::integral I>
-CONSTEVAL auto formatted_size(fmt_spec s, I i) -> std::size_t {
+consteval auto formatted_size(fmt_spec s, I i) -> std::size_t {
     if (i == 0) {
         return 1;
     } else {
@@ -84,7 +84,7 @@ CONSTEVAL auto formatted_size(fmt_spec s, I i) -> std::size_t {
 }
 } // namespace detail
 
-CONSTEVAL auto formatted_size(auto fmtstr, auto v) -> std::size_t {
+consteval auto formatted_size(auto fmtstr, auto v) -> std::size_t {
     constexpr auto spec = detail::parse_fmt_spec(fmtstr);
     static_assert(
         spec.well_formed,
@@ -96,7 +96,7 @@ CONSTEVAL auto formatted_size(auto fmtstr, auto v) -> std::size_t {
 
 namespace detail {
 template <typename It, stdx::range R>
-CONSTEVAL auto format_to(fmt_spec, It dest, R const &r) -> It {
+consteval auto format_to(fmt_spec, It dest, R const &r) -> It {
     for (auto const c : r) {
         *dest++ = c;
     }
@@ -104,7 +104,7 @@ CONSTEVAL auto format_to(fmt_spec, It dest, R const &r) -> It {
 }
 
 template <typename It>
-CONSTEVAL auto format_to(fmt_spec, It dest, char const *str) -> It {
+consteval auto format_to(fmt_spec, It dest, char const *str) -> It {
     while (*str) {
         *dest++ = *str++;
     }
@@ -112,13 +112,13 @@ CONSTEVAL auto format_to(fmt_spec, It dest, char const *str) -> It {
 }
 
 template <typename It>
-CONSTEVAL auto format_to(fmt_spec, It dest, char c) -> It {
+consteval auto format_to(fmt_spec, It dest, char c) -> It {
     *dest++ = c;
     return dest;
 }
 
 template <typename It, stdx::integral I>
-CONSTEVAL auto format_to(fmt_spec s, It dest, I i) -> It {
+consteval auto format_to(fmt_spec s, It dest, I i) -> It {
     if (i == 0) {
         *dest++ = '0';
     } else {
@@ -149,7 +149,7 @@ CONSTEVAL auto format_to(fmt_spec s, It dest, I i) -> It {
 } // namespace detail
 
 template <typename It>
-CONSTEVAL auto format_to(It dest, auto fmtstr, auto v) -> void {
+consteval auto format_to(It dest, auto fmtstr, auto v) -> void {
     constexpr auto fmt = fmtstr();
     constexpr auto spec = detail::parse_fmt_spec(fmtstr);
 
diff --git a/include/stdx/env.hpp b/include/stdx/env.hpp
index 2924733..b414c81 100644
--- a/include/stdx/env.hpp
+++ b/include/stdx/env.hpp
@@ -12,7 +12,7 @@ namespace _env {
 template <auto Query, auto Value> struct ct_prop {
     using query_t = std::remove_cvref_t<decltype(Query)>;
 
-    [[nodiscard]] CONSTEVAL static auto query(query_t) noexcept {
+    [[nodiscard]] consteval static auto query(query_t) noexcept {
         return Value;
     }
 };
@@ -31,7 +31,7 @@ template <typename Q> struct has_query {
 
 template <typename... Envs> struct env {
     template <_env::valid_query_over<Envs...> Q>
-    [[nodiscard]] CONSTEVAL static auto query(Q) noexcept {
+    [[nodiscard]] consteval static auto query(Q) noexcept {
         using I = boost::mp11::mp_find_if_q<boost::mp11::mp_list<Envs...>,
                                             _env::has_query<Q>>;
         using E = nth_t<I::value, Envs...>;
@@ -45,7 +45,7 @@ concept envlike = is_specialization_of_v<T, env>;
 namespace _env {
 template <typename T> struct autowrap {
     // NOLINTNEXTLINE(google-explicit-constructor)
-    CONSTEVAL autowrap(T t) : value(t) {}
+    consteval autowrap(T t) : value(t) {}
     T value;
 };
 
@@ -54,7 +54,7 @@ template <std::size_t N> using str_lit_t = char const (&)[N];
 
 template <std::size_t N> struct autowrap<str_lit_t<N>> {
     // NOLINTNEXTLINE(google-explicit-constructor)
-    CONSTEVAL autowrap(str_lit_t<N> str) : value(str) {}
+    consteval autowrap(str_lit_t<N> str) : value(str) {}
     stdx::ct_string<N> value;
 };
 
diff --git a/include/stdx/iterator.hpp b/include/stdx/iterator.hpp
index 7abe139..4a6b97b 100644
--- a/include/stdx/iterator.hpp
+++ b/include/stdx/iterator.hpp
@@ -30,7 +30,7 @@ template <typename T, std::size_t N> constexpr auto ct_capacity_v<T[N]> = N;
 template <typename T> constexpr auto ct_capacity_v<T const> = ct_capacity_v<T>;
 
 template <typename T>
-CONSTEVAL auto ct_capacity([[maybe_unused]] T &&) -> std::size_t {
+consteval auto ct_capacity([[maybe_unused]] T &&) -> std::size_t {
     return ct_capacity_v<remove_cvref_t<T>>;
 }
 
diff --git a/include/stdx/tuple.hpp b/include/stdx/tuple.hpp
index 52f8f77..fc29f92 100644
--- a/include/stdx/tuple.hpp
+++ b/include/stdx/tuple.hpp
@@ -18,7 +18,7 @@ using index_constant = std::integral_constant<std::size_t, I>;
 template <std::size_t I> constexpr static index_constant<I> index{};
 
 inline namespace literals {
-template <char... Chars> CONSTEVAL_UDL auto operator""_idx() {
+template <char... Chars> consteval auto operator""_idx() {
     return index<parse_literal<std::size_t, Chars...>()>;
 }
 } // namespace literals
diff --git a/include/stdx/type_traits.hpp b/include/stdx/type_traits.hpp
index 48467ad..34c3602 100644
--- a/include/stdx/type_traits.hpp
+++ b/include/stdx/type_traits.hpp
@@ -238,7 +238,7 @@ concept is_shrinkwrapped = requires { typename T::is_shrinkwrapped; };
 
 template <typename T,
           auto F = []()->auto (*)() -> shrinkwrap<T> { return nullptr; }>
-CONSTEVAL auto shrink() {
+consteval auto shrink() {
     return F;
 }
 
@@ -247,9 +247,9 @@ concept is_shrunk = requires(T const &t) {
     { t()() } -> is_shrinkwrapped;
 };
 
-template <typename T> CONSTEVAL auto maybe_expand() -> T;
+template <typename T> consteval auto maybe_expand() -> T;
 template <is_shrunk T>
-CONSTEVAL auto maybe_expand() -> typename decltype(T{}()())::type;
+consteval auto maybe_expand() -> typename decltype(T{}()())::type;
 
 template <typename T> constexpr auto maybe_expand(T &&t) -> decltype(auto) {
     return T(std::forward<T>(t));
@@ -269,18 +269,18 @@ constexpr auto maybe_expand(T &&) ->
 }
 } // namespace detail
 
-template <typename T> CONSTEVAL auto shrink() -> decltype(detail::shrink<T>()) {
+template <typename T> consteval auto shrink() -> decltype(detail::shrink<T>()) {
     static_assert(
         always_false_v<T>,
         "shrink<T>() should not be called outside an unevaluated context");
 }
 template <typename T>
-CONSTEVAL auto shrink(T const &) -> decltype(detail::shrink<T>()) {
+consteval auto shrink(T const &) -> decltype(detail::shrink<T>()) {
     return {};
 }
 
 template <typename T>
-CONSTEVAL auto expand() -> decltype(detail::maybe_expand<T>()) {
+consteval auto expand() -> decltype(detail::maybe_expand<T>()) {
     using R = decltype(detail::maybe_expand<T>());
     static_assert(
         always_false_v<R>,
diff --git a/include/stdx/udls.hpp b/include/stdx/udls.hpp
index aa3a590..4421dfd 100644
--- a/include/stdx/udls.hpp
+++ b/include/stdx/udls.hpp
@@ -31,7 +31,7 @@ constexpr static auto integral_value_v =
     is_decimal_digit_v<C> ? C - '0' : force_lower_case<C> - 'a' + 10;
 
 template <auto Base, char C, typename Sum>
-CONSTEVAL auto maybe_add_digit(Sum s) {
+consteval auto maybe_add_digit(Sum s) {
     if constexpr (not is_digit_sep_v<C>) {
         s *= Base;
         s += integral_value_v<C>;
@@ -40,7 +40,7 @@ CONSTEVAL auto maybe_add_digit(Sum s) {
 }
 
 template <auto Base, char... Cs> struct raw_parser {
-    template <typename T> CONSTEVAL static auto parse() {
+    template <typename T> consteval static auto parse() {
         using U = decltype(stdx::to_underlying(std::declval<T>()));
         auto x = U{};
         ((x = maybe_add_digit<Base, Cs>(x)), ...);
@@ -69,7 +69,7 @@ template <char... Cs>
 struct parser<'0', 'B', Cs...> : parser<'0', 'b', Cs...> {};
 } // namespace detail
 
-template <typename T, char... Chars> CONSTEVAL auto parse_literal() -> T {
+template <typename T, char... Chars> consteval auto parse_literal() -> T {
     using parser_t = detail::parser<Chars...>;
     return parser_t::template parse<T>();
 }
@@ -78,7 +78,7 @@ template <auto I> using constant = std::integral_constant<decltype(I), I>;
 template <auto I> constexpr static constant<I> _c{};
 
 inline namespace literals {
-template <char... Chars> CONSTEVAL_UDL auto operator""_c() {
+template <char... Chars> consteval auto operator""_c() {
     return _c<parse_literal<std::uint32_t, Chars...>()>;
 }
 } // namespace literals
@@ -89,52 +89,50 @@ enum struct length_t : std::uint32_t {};
 
 inline namespace literals {
 // NOLINTBEGIN(google-runtime-int)
-CONSTEVAL_UDL auto operator""_lsb(unsigned long long int n) -> lsb_t {
+consteval auto operator""_lsb(unsigned long long int n) -> lsb_t {
     return static_cast<lsb_t>(n);
 }
-CONSTEVAL_UDL auto operator""_msb(unsigned long long int n) -> msb_t {
+consteval auto operator""_msb(unsigned long long int n) -> msb_t {
     return static_cast<msb_t>(n);
 }
-CONSTEVAL_UDL auto operator""_len(unsigned long long int n) -> length_t {
+consteval auto operator""_len(unsigned long long int n) -> length_t {
     return static_cast<length_t>(n);
 }
 // NOLINTEND(google-runtime-int)
 } // namespace literals
 
 inline namespace literals {
-CONSTEVAL_UDL auto operator""_b(char const *, std::size_t) -> bool {
+consteval auto operator""_b(char const *, std::size_t) -> bool { return true; }
+consteval auto operator""_true(char const *, std::size_t) -> bool {
     return true;
 }
-CONSTEVAL_UDL auto operator""_true(char const *, std::size_t) -> bool {
-    return true;
-}
-CONSTEVAL_UDL auto operator""_false(char const *, std::size_t) -> bool {
+consteval auto operator""_false(char const *, std::size_t) -> bool {
     return false;
 }
 
 // NOLINTBEGIN(google-runtime-int)
-CONSTEVAL_UDL auto operator""_k(unsigned long long int n)
+consteval auto operator""_k(unsigned long long int n)
     -> unsigned long long int {
     return n * 1'000u;
 }
-CONSTEVAL_UDL auto operator""_M(unsigned long long int n)
+consteval auto operator""_M(unsigned long long int n)
     -> unsigned long long int {
     return n * 1'000'000u;
 }
-CONSTEVAL_UDL auto operator""_G(unsigned long long int n)
+consteval auto operator""_G(unsigned long long int n)
     -> unsigned long long int {
     return n * 1'000'000'000u;
 }
 
-CONSTEVAL_UDL auto operator""_ki(unsigned long long int n)
+consteval auto operator""_ki(unsigned long long int n)
     -> unsigned long long int {
     return n * 1'024u;
 }
-CONSTEVAL_UDL auto operator""_Mi(unsigned long long int n)
+consteval auto operator""_Mi(unsigned long long int n)
     -> unsigned long long int {
     return n * 1'024ull * 1'024ull;
 }
-CONSTEVAL_UDL auto operator""_Gi(unsigned long long int n)
+consteval auto operator""_Gi(unsigned long long int n)
     -> unsigned long long int {
     return n * 1'024ull * 1'024ull * 1'024ull;
 }
@@ -142,7 +140,7 @@ CONSTEVAL_UDL auto operator""_Gi(unsigned long long int n)
 // NOLINTBEGIN(cppcoreguidelines-macro-usage)
 
 #define STDX_SMALL_INT_LITERAL_DEF(x)                                          \
-    CONSTEVAL_UDL auto operator""_##x(char const *, std::size_t)               \
+    consteval auto operator""_##x(char const *, std::size_t)                   \
         ->std::integral_constant<std::size_t, x##u> {                          \
         return {};                                                             \
     }
diff --git a/include/stdx/utility.hpp b/include/stdx/utility.hpp
index 81fa68e..7ec1995 100644
--- a/include/stdx/utility.hpp
+++ b/include/stdx/utility.hpp
@@ -180,16 +180,16 @@ template <typename T, std::size_t N> struct udl_sized {
 };
 
 inline namespace literals {
-template <char... Chars> CONSTEVAL_UDL auto operator""_z8() {
+template <char... Chars> consteval auto operator""_z8() {
     return udl_sized<std::uint8_t, parse_literal<std::size_t, Chars...>()>{};
 }
-template <char... Chars> CONSTEVAL_UDL auto operator""_z16() {
+template <char... Chars> consteval auto operator""_z16() {
     return udl_sized<std::uint16_t, parse_literal<std::size_t, Chars...>()>{};
 }
-template <char... Chars> CONSTEVAL_UDL auto operator""_z32() {
+template <char... Chars> consteval auto operator""_z32() {
     return udl_sized<std::uint32_t, parse_literal<std::size_t, Chars...>()>{};
 }
-template <char... Chars> CONSTEVAL_UDL auto operator""_z64() {
+template <char... Chars> consteval auto operator""_z64() {
     return udl_sized<std::uint64_t, parse_literal<std::size_t, Chars...>()>{};
 }
 } // namespace literals
@@ -259,7 +259,7 @@ constexpr auto is_aligned_with = [](auto v) -> bool {
 namespace detail {
 template <typename T> struct ct_helper {
     // NOLINTNEXTLINE(google-explicit-constructor)
-    CONSTEVAL ct_helper(auto t) : value(t) {}
+    consteval ct_helper(auto t) : value(t) {}
     T value;
 };
 
@@ -267,14 +267,14 @@ template <typename T> ct_helper(T) -> ct_helper<T>;
 template <typename T, T I>
 ct_helper(std::integral_constant<T, I>) -> ct_helper<T>;
 
-template <auto> CONSTEVAL auto cx_detect0() {}
-CONSTEVAL auto cx_detect1(auto) { return 0; }
+template <auto> consteval auto cx_detect0() {}
+consteval auto cx_detect1(auto) { return 0; }
 } // namespace detail
 
-template <detail::ct_helper Value> CONSTEVAL auto ct() {
+template <detail::ct_helper Value> consteval auto ct() {
     return std::integral_constant<decltype(Value.value), Value.value>{};
 }
-template <typename T> CONSTEVAL auto ct() { return type_identity<T>{}; }
+template <typename T> consteval auto ct() { return type_identity<T>{}; }
 
 template <typename> constexpr auto is_ct_v = false;
 template <typename T, T V>
diff --git a/test/env.cpp b/test/env.cpp
index d7f166b..bf3f1a1 100644
--- a/test/env.cpp
+++ b/test/env.cpp
@@ -8,13 +8,13 @@ namespace {
 [[maybe_unused]] constexpr inline struct custom_t {
     template <typename T>
         requires true // more constrained
-    [[nodiscard]] CONSTEVAL auto operator()(T &&t) const
+    [[nodiscard]] consteval auto operator()(T &&t) const
         noexcept(noexcept(std::forward<T>(t).query(std::declval<custom_t>())))
             -> decltype(std::forward<T>(t).query(*this)) {
         return std::forward<T>(t).query(*this);
     }
 
-    [[nodiscard]] CONSTEVAL auto operator()(auto &&) const { return 42; }
+    [[nodiscard]] consteval auto operator()(auto &&) const { return 42; }
 } custom;
 } // namespace
 
@@ -29,7 +29,7 @@ TEST_CASE("lookup query with default (free function)", "[env]") {
 namespace {
 [[maybe_unused]] constexpr inline struct custom_no_default_t {
     template <typename T>
-    [[nodiscard]] CONSTEVAL auto operator()(T &&t) const
+    [[nodiscard]] consteval auto operator()(T &&t) const
         noexcept(noexcept(std::forward<T>(t).query(std::declval<custom_t>())))
             -> decltype(std::forward<T>(t).query(*this)) {
         return std::forward<T>(t).query(*this);