diff --git a/strings/base_array.h b/strings/base_array.h
index 3b46f26a9..46c1fbdbf 100644
--- a/strings/base_array.h
+++ b/strings/base_array.h
@@ -71,18 +71,20 @@ WINRT_EXPORT namespace winrt
         {}
 
         template <typename OtherType>
-        array_view(array_view<OtherType> const& other,
-            std::enable_if_t<std::is_convertible_v<OtherType(*)[], T(*)[]>, int> = 0) noexcept :
+            requires std::convertible_to<OtherType(*)[], T(*)[]>
+        array_view(array_view<OtherType> const& other) noexcept :
             array_view(other.data(), other.size())
         {}
 
-        template <typename U, std::enable_if_t<std::is_same_v<std::remove_cv_t<T>, std::remove_cv_t<U>>, int> = 0>
+        template <typename U>
+            requires std::same_as<std::remove_cv_t<T>, std::remove_cv_t<U>>
         bool operator==(array_view<U> const& right) const noexcept
         {
             return std::equal(begin(), end(), right.begin(), right.end());
         }
 
-        template <typename U, std::enable_if_t<std::is_same_v<std::remove_cv_t<T>, std::remove_cv_t<U>>, int> = 0>
+        template <typename U>
+            requires std::same_as<std::remove_cv_t<T>, std::remove_cv_t<U>>
         std::weak_ordering operator<=>(array_view<U> const& right) const noexcept
         {
             return std::lexicographical_compare_three_way(begin(), end(), right.begin(), right.end());
@@ -284,7 +286,8 @@ WINRT_EXPORT namespace winrt
             std::uninitialized_fill_n(this->m_data, count, value);
         }
 
-        template <typename InIt, typename = std::void_t<typename std::iterator_traits<InIt>::difference_type>>
+        template <typename InIt>
+            requires std::input_iterator<InIt>
         com_array(InIt first, InIt last)
         {
             alloc(static_cast<size_type>(std::distance(first, last)));
@@ -317,7 +320,8 @@ WINRT_EXPORT namespace winrt
             com_array(value.begin(), value.end())
         {}
 
-        template <typename U, typename = std::enable_if_t<std::is_convertible_v<U, T>>>
+        template <typename U>
+            requires std::convertible_to<U, T>
         com_array(std::initializer_list<U> value) :
             com_array(value.begin(), value.end())
         {}
@@ -402,7 +406,8 @@ WINRT_EXPORT namespace winrt
     };
 
     template <typename C> com_array(std::uint32_t, C const&) -> com_array<std::decay_t<C>>;
-    template <typename InIt, typename = std::void_t<typename std::iterator_traits<InIt>::difference_type>>
+    template <typename InIt>
+        requires std::input_iterator<InIt>
     com_array(InIt, InIt) -> com_array<std::decay_t<typename std::iterator_traits<InIt>::value_type>>;
     template <typename C> com_array(std::vector<C> const&) -> com_array<std::decay_t<C>>;
     template <std::size_t N, typename C> com_array(std::array<C, N> const&) -> com_array<std::decay_t<C>>;
diff --git a/strings/base_collections_base.h b/strings/base_collections_base.h
index d299cc0c8..6c31fe5a6 100644
--- a/strings/base_collections_base.h
+++ b/strings/base_collections_base.h
@@ -46,7 +46,8 @@ WINRT_EXPORT namespace winrt::impl
     };
 
     template <typename D>
-    struct removed_values<D, std::enable_if_t<!std::is_trivially_destructible_v<typename container_type_t<D>::value_type>>>
+    requires (!std::is_trivially_destructible_v<typename container_type_t<D>::value_type>)
+    struct removed_values<D, void>
     {
         container_type_t<D> m_value;
 
@@ -65,7 +66,8 @@ WINRT_EXPORT namespace winrt::impl
     };
 
     template <typename T>
-    struct removed_value<T, std::enable_if_t<std::is_move_constructible_v<T> && !std::is_trivially_destructible_v<T>>>
+    requires (std::is_move_constructible_v<T> && !std::is_trivially_destructible_v<T>)
+    struct removed_value<T, void>
     {
         std::optional<T> m_value;
 
diff --git a/strings/base_collections_input_iterable.h b/strings/base_collections_input_iterable.h
index e9d3af251..f3e503103 100644
--- a/strings/base_collections_input_iterable.h
+++ b/strings/base_collections_input_iterable.h
@@ -92,7 +92,8 @@ WINRT_EXPORT namespace winrt::param
             attach_abi(m_pair.first, winrt::get_abi(values));
         }
 
-        template <typename Collection, std::enable_if_t<std::is_convertible_v<Collection, interface_type>, int> = 0>
+        template <typename Collection>
+            requires std::convertible_to<Collection, interface_type>
         iterable(Collection const& values) noexcept
         {
             m_pair.first = values;
@@ -112,7 +113,8 @@ WINRT_EXPORT namespace winrt::param
         {
         }
 
-        template <typename U, std::enable_if_t<std::is_convertible_v<U, value_type>, int> = 0>
+        template <typename U>
+            requires std::convertible_to<U, value_type>
         iterable(std::initializer_list<U> values) : m_pair(impl::make_scoped_input_iterable<value_type>(values.begin(), values.end()))
         {
         }
@@ -164,7 +166,8 @@ WINRT_EXPORT namespace winrt::param
             attach_abi(m_pair.first, winrt::get_abi(values));
         }
 
-        template <typename Collection, std::enable_if_t<std::is_convertible_v<Collection, interface_type>, int> = 0>
+        template <typename Collection>
+            requires std::convertible_to<Collection, interface_type>
         iterable(Collection const& values) noexcept
         {
             m_pair.first = values;
@@ -247,7 +250,8 @@ WINRT_EXPORT namespace winrt::param
             attach_abi(m_interface, winrt::get_abi(values));
         }
 
-        template <typename Collection, std::enable_if_t<std::is_convertible_v<Collection, interface_type>, int> = 0>
+        template <typename Collection>
+            requires std::convertible_to<Collection, interface_type>
         async_iterable(Collection const& values) noexcept
         {
             m_interface = values;
@@ -301,7 +305,8 @@ WINRT_EXPORT namespace winrt::param
             attach_abi(m_interface, winrt::get_abi(values));
         }
 
-        template <typename Collection, std::enable_if_t<std::is_convertible_v<Collection, interface_type>, int> = 0>
+        template <typename Collection>
+            requires std::convertible_to<Collection, interface_type>
         async_iterable(Collection const& values) noexcept
         {
             m_interface = values;
diff --git a/strings/base_collections_input_map.h b/strings/base_collections_input_map.h
index 3fe146bf6..651662e1d 100644
--- a/strings/base_collections_input_map.h
+++ b/strings/base_collections_input_map.h
@@ -61,7 +61,8 @@ WINRT_EXPORT namespace winrt::param
             attach_abi(m_interface, winrt::get_abi(values));
         }
 
-        template <typename Collection, std::enable_if_t<std::is_convertible_v<Collection, interface_type>, int> = 0>
+        template <typename Collection>
+            requires std::convertible_to<Collection, interface_type>
         map(Collection const& values) noexcept
         {
             m_interface = values;
diff --git a/strings/base_collections_input_map_view.h b/strings/base_collections_input_map_view.h
index d79eed61d..eb7be25fc 100644
--- a/strings/base_collections_input_map_view.h
+++ b/strings/base_collections_input_map_view.h
@@ -91,7 +91,8 @@ WINRT_EXPORT namespace winrt::param
             attach_abi(m_pair.first, winrt::get_abi(values));
         }
 
-        template <typename Collection, std::enable_if_t<std::is_convertible_v<Collection, interface_type>, int> = 0>
+        template <typename Collection>
+            requires std::convertible_to<Collection, interface_type>
         map_view(Collection const& values) noexcept
         {
             m_pair.first = values;
@@ -169,7 +170,8 @@ WINRT_EXPORT namespace winrt::param
             attach_abi(m_interface, winrt::get_abi(values));
         }
 
-        template <typename Collection, std::enable_if_t<std::is_convertible_v<Collection, interface_type>, int> = 0>
+        template <typename Collection>
+            requires std::convertible_to<Collection, interface_type>
         async_map_view(Collection const& values) noexcept
         {
             m_interface = values;
diff --git a/strings/base_collections_input_vector.h b/strings/base_collections_input_vector.h
index a06e73b33..049b23754 100644
--- a/strings/base_collections_input_vector.h
+++ b/strings/base_collections_input_vector.h
@@ -55,7 +55,8 @@ WINRT_EXPORT namespace winrt::param
             attach_abi(m_interface, winrt::get_abi(values));
         }
 
-        template <typename Collection, std::enable_if_t<std::is_convertible_v<Collection, interface_type>, int> = 0>
+        template <typename Collection>
+            requires std::convertible_to<Collection, interface_type>
         vector(Collection const& values) noexcept
         {
             m_interface = values;
diff --git a/strings/base_collections_input_vector_view.h b/strings/base_collections_input_vector_view.h
index 30768c18e..d24a5b6db 100644
--- a/strings/base_collections_input_vector_view.h
+++ b/strings/base_collections_input_vector_view.h
@@ -86,7 +86,8 @@ WINRT_EXPORT namespace winrt::param
             attach_abi(m_pair.first, winrt::get_abi(values));
         }
 
-        template <typename Collection, std::enable_if_t<std::is_convertible_v<Collection, interface_type>, int> = 0>
+        template <typename Collection>
+            requires std::convertible_to<Collection, interface_type>
         vector_view(Collection const& values) noexcept
         {
             m_pair.first = values;
@@ -106,7 +107,8 @@ WINRT_EXPORT namespace winrt::param
         {
         }
 
-        template <typename U, std::enable_if_t<std::is_convertible_v<U, value_type>, int> = 0>
+        template <typename U>
+            requires std::convertible_to<U, value_type>
         vector_view(std::initializer_list<U> values) : m_pair(impl::make_scoped_input_vector_view<value_type>(values.begin(), values.end()))
         {
         }
@@ -164,7 +166,8 @@ WINRT_EXPORT namespace winrt::param
             attach_abi(m_interface, winrt::get_abi(values));
         }
 
-        template <typename Collection, std::enable_if_t<std::is_convertible_v<Collection, interface_type>, int> = 0>
+        template <typename Collection>
+            requires std::convertible_to<Collection, interface_type>
         async_vector_view(Collection const& values) noexcept
         {
             m_interface = values;
diff --git a/strings/base_com_ptr.h b/strings/base_com_ptr.h
index c82323988..1925bf5df 100644
--- a/strings/base_com_ptr.h
+++ b/strings/base_com_ptr.h
@@ -24,7 +24,8 @@ WINRT_EXPORT namespace winrt::impl
         return function(args..., guid_of<T>(), capture_decay{ result });
     }
 
-    template <typename T, typename O, typename M, typename...Args, std::enable_if_t<std::is_class_v<O> || std::is_union_v<O>, int> = 0>
+    template <typename T, typename O, typename M, typename...Args>
+        requires (std::is_class_v<O> || std::is_union_v<O>)
     std::int32_t capture_to(void** result, O* object, M method, Args&& ...args)
     {
         return (object->*method)(args..., guid_of<T>(), capture_decay{ result });
diff --git a/strings/base_coroutine_foundation.h b/strings/base_coroutine_foundation.h
index d242d2a1a..1252a4e05 100644
--- a/strings/base_coroutine_foundation.h
+++ b/strings/base_coroutine_foundation.h
@@ -259,7 +259,8 @@ WINRT_EXPORT namespace winrt::impl
 
 WINRT_EXPORT namespace winrt
 {
-    template<typename Async, typename = std::enable_if_t<std::is_convertible_v<Async, winrt::Windows::Foundation::IAsyncInfo>>>
+    template<typename Async>
+        requires std::convertible_to<Async, winrt::Windows::Foundation::IAsyncInfo>
     inline impl::await_adapter<std::decay_t<Async>, false> resume_agile(Async&& async)
     {
         return { std::forward<Async>(async) };
diff --git a/strings/base_implements.h b/strings/base_implements.h
index 302656cc5..8b4e6c209 100644
--- a/strings/base_implements.h
+++ b/strings/base_implements.h
@@ -145,14 +145,15 @@ WINRT_EXPORT namespace winrt::impl
     template <typename D, typename... I>
     struct root_implements;
 
-    template <typename T, typename = std::void_t<>>
+    template <typename T>
     struct unwrap_implements
     {
         using type = T;
     };
 
     template <typename T>
-    struct unwrap_implements<T, std::void_t<typename T::implements_type>>
+        requires requires { typename T::implements_type; }
+    struct unwrap_implements<T>
     {
         using type = typename T::implements_type;
     };
@@ -173,28 +174,31 @@ WINRT_EXPORT namespace winrt::impl
             "Duplicate nested implements found");
     };
 
-    template <typename D, typename Dummy = std::void_t<>, typename... I>
+    template <typename D, typename Dummy = void, typename... I>
     struct base_implements_impl
         : impl::identity<root_implements<D, I...>> {};
 
     template <typename D, typename... I>
-    struct base_implements_impl<D, std::void_t<typename nested_implements<I...>::type>, I...>
+        requires requires { typename nested_implements<I...>::type; }
+    struct base_implements_impl<D, void, I...>
         : nested_implements<I...> {};
 
     template <typename D, typename... I>
     using base_implements = base_implements_impl<D, void, I...>;
 
-    template <typename T, typename = std::void_t<>>
+    template <typename T>
     struct has_composable : std::false_type {};
 
     template <typename T>
-    struct has_composable<T, std::void_t<typename T::composable>> : std::true_type {};
+        requires requires { typename T::composable; }
+    struct has_composable<T> : std::true_type {};
 
-    template <typename T, typename = std::void_t<>>
+    template <typename T>
     struct has_class_type : std::false_type {};
 
     template <typename T>
-    struct has_class_type<T, std::void_t<typename T::class_type>> : std::true_type {};
+        requires requires { typename T::class_type; }
+    struct has_class_type<T> : std::true_type {};
 
     template <typename>
     struct has_static_lifetime : std::false_type {};
@@ -367,20 +371,22 @@ WINRT_EXPORT namespace winrt::impl
         static constexpr std::array<guid, sizeof...(T)> value{ winrt::guid_of<T>() ... };
     };
 
-    template <typename T, typename = void>
+    template <typename T>
     struct implements_default_interface
     {
         using type = typename default_interface<typename implemented_interfaces<T>::first_interface>::type;
     };
 
     template <typename T>
-    struct implements_default_interface<T, std::void_t<typename T::class_type>>
+        requires requires { typename T::class_type; }
+    struct implements_default_interface<T>
     {
         using type = winrt::default_interface<typename T::class_type>;
     };
 
     template <typename T>
-    struct default_interface<T, std::void_t<typename T::implements_type>>
+        requires requires { typename T::implements_type; }
+    struct default_interface<T>
     {
         using type = typename implements_default_interface<T>::type;
     };
@@ -480,7 +486,7 @@ WINRT_EXPORT namespace winrt::impl
         }
     }
 
-    template <typename I, typename = std::void_t<>>
+    template <typename I>
     struct runtime_class_name
     {
         static hstring get()
@@ -490,7 +496,8 @@ WINRT_EXPORT namespace winrt::impl
     };
 
     template <typename I>
-    struct runtime_class_name<I, std::void_t<decltype(name_v<I>)>>
+        requires requires { name_v<I>; }
+    struct runtime_class_name<I>
     {
         static hstring get()
         {
@@ -554,7 +561,8 @@ WINRT_EXPORT namespace winrt::impl
     };
 
     template <typename D, typename I>
-    struct producer<D, I, std::enable_if_t<is_classic_com_interface<I>::value>> : I
+        requires is_classic_com_interface<I>::value
+    struct producer<D, I> : I
     {
 #ifndef WINRT_IMPL_IUNKNOWN_DEFINED
         static_assert(std::is_void_v<I> /* dependent_false */, "To implement classic COM interfaces, you must #include <unknwn.h> before including C++/WinRT headers.");
@@ -562,7 +570,8 @@ WINRT_EXPORT namespace winrt::impl
     };
 
     template <typename D, typename I>
-    struct producer_convert<D, I, std::enable_if_t<is_classic_com_interface<I>::value>> : producer<D, I>
+        requires is_classic_com_interface<I>::value
+    struct producer_convert<D, I> : producer<D, I>
     {
     };
 
diff --git a/strings/base_includes.h b/strings/base_includes.h
index 56e27e109..eb347d405 100644
--- a/strings/base_includes.h
+++ b/strings/base_includes.h
@@ -21,6 +21,7 @@
 #include <thread>
 #include <tuple>
 #include <type_traits>
+#include <concepts>
 #include <unordered_map>
 #include <utility>
 #include <vector>
diff --git a/strings/base_iterator.h b/strings/base_iterator.h
index e6670327d..9cc37252a 100644
--- a/strings/base_iterator.h
+++ b/strings/base_iterator.h
@@ -120,7 +120,8 @@ WINRT_EXPORT namespace winrt::impl
         static constexpr bool value = get_value<T>(0);
     };
 
-    template <typename T, std::enable_if_t<!has_GetAt<T>::value, int> = 0>
+    template <typename T>
+        requires (!has_GetAt<T>::value)
     auto get_begin_iterator(T const& collection) -> decltype(collection.First())
     {
         auto result = collection.First();
@@ -133,31 +134,36 @@ WINRT_EXPORT namespace winrt::impl
         return result;
     }
 
-    template <typename T, std::enable_if_t<!has_GetAt<T>::value, int> = 0>
+    template <typename T>
+        requires (!has_GetAt<T>::value)
     auto get_end_iterator([[maybe_unused]] T const& collection) noexcept -> decltype(collection.First())
     {
         return {};
     }
 
-    template <typename T, std::enable_if_t<has_GetAt<T>::value, int> = 0>
+    template <typename T>
+        requires has_GetAt<T>::value
     fast_iterator<T> get_begin_iterator(T const& collection) noexcept
     {
         return { collection, 0 };
     }
 
-    template <typename T, std::enable_if_t<has_GetAt<T>::value, int> = 0>
+    template <typename T>
+        requires has_GetAt<T>::value
     fast_iterator<T> get_end_iterator(T const& collection)
     {
         return { collection, collection.Size() };
     }
 
-    template <typename T, std::enable_if_t<has_GetAt<T>::value, int> = 0>
+    template <typename T>
+        requires has_GetAt<T>::value
     auto rbegin(T const& collection)
     {
         return std::make_reverse_iterator(get_end_iterator(collection));
     }
 
-    template <typename T, std::enable_if_t<has_GetAt<T>::value, int> = 0>
+    template <typename T>
+        requires has_GetAt<T>::value
     auto rend(T const& collection)
     {
         return std::make_reverse_iterator(get_begin_iterator(collection));
diff --git a/strings/base_meta.h b/strings/base_meta.h
index 6b28640ef..f3da5c73a 100644
--- a/strings/base_meta.h
+++ b/strings/base_meta.h
@@ -68,7 +68,8 @@ WINRT_EXPORT namespace winrt::impl
     };
 
     template <typename T>
-    struct abi<T, std::enable_if_t<std::is_enum_v<T>>>
+        requires std::is_enum_v<T>
+    struct abi<T>
     {
         using type = std::underlying_type_t<T>;
     };
@@ -85,7 +86,7 @@ WINRT_EXPORT namespace winrt::impl
     template <typename T, typename H>
     struct delegate;
 
-    template <typename T, typename = std::void_t<>>
+    template <typename T>
     struct default_interface
     {
         using type = T;
@@ -149,11 +150,12 @@ WINRT_EXPORT namespace winrt::impl
         return static_cast<std::underlying_type_t<T>>(value);
     }
 
-    template <typename, typename = std::void_t<>>
+    template <typename T>
     struct is_implements : std::false_type {};
 
     template <typename T>
-    struct is_implements<T, std::void_t<typename T::implements_type>> : std::true_type {};
+        requires requires { typename T::implements_type; }
+    struct is_implements<T> : std::true_type {};
 
     template <typename T>
     inline constexpr bool is_implements_v = is_implements<T>::value;
@@ -223,7 +225,8 @@ WINRT_EXPORT namespace winrt::impl
     };
 
     template <typename T>
-    struct arg<T, std::enable_if_t<std::is_base_of_v<Windows::Foundation::IUnknown, T>>>
+        requires std::is_base_of_v<Windows::Foundation::IUnknown, T>
+    struct arg<T>
     {
         using in = void*;
     };
diff --git a/strings/base_reference_produce.h b/strings/base_reference_produce.h
index 454ac4b2c..b3941a45b 100644
--- a/strings/base_reference_produce.h
+++ b/strings/base_reference_produce.h
@@ -480,7 +480,8 @@ WINRT_EXPORT namespace winrt::impl
         return default_value;
     }
 
-    template <typename To, typename From, std::enable_if_t<!is_com_interface_v<To>, int>>
+    template <typename To, typename From>
+        requires (!is_com_interface_v<To>)
     auto as(From* ptr)
     {
         if constexpr (impl::is_com_interface_v<From>)
@@ -493,7 +494,8 @@ WINRT_EXPORT namespace winrt::impl
         }
     }
 
-    template <typename To, typename From, std::enable_if_t<!is_com_interface_v<To>, int>>
+    template <typename To, typename From>
+        requires (!is_com_interface_v<To>)
     auto try_as(From* ptr) noexcept
     {
         using type = std::conditional_t<impl::is_com_interface_v<From>, Windows::Foundation::IUnknown, com_ptr<From>>;
@@ -508,7 +510,8 @@ WINRT_EXPORT namespace winrt
         return Windows::Foundation::IReference<hstring>(*(hstring*)(&value));
     }
 
-    template <typename T, std::enable_if_t<!std::is_convertible_v<T, param::hstring>, int> = 0>
+    template <typename T>
+        requires (!std::is_convertible_v<T, param::hstring>)
     Windows::Foundation::IInspectable box_value(T const& value)
     {
         if constexpr (std::is_base_of_v<Windows::Foundation::IInspectable, T>)
@@ -534,7 +537,8 @@ WINRT_EXPORT namespace winrt
         }
     }
 
-    template <typename T = hstring, std::enable_if_t<std::is_same_v<T, hstring>, int> = 0>
+    template <typename T = hstring>
+        requires std::same_as<T, hstring>
     hstring unbox_value_or(Windows::Foundation::IInspectable const& value, param::hstring const& default_value)
     {
         if (value)
@@ -548,7 +552,8 @@ WINRT_EXPORT namespace winrt
         return *(hstring*)(&default_value);
     }
 
-    template <typename T, std::enable_if_t<!std::is_same_v<T, hstring>, int> = 0>
+    template <typename T>
+        requires (!std::is_same_v<T, hstring>)
     T unbox_value_or(Windows::Foundation::IInspectable const& value, T const& default_value)
     {
         if (value)
diff --git a/strings/base_string.h b/strings/base_string.h
index 98b85590e..917a09556 100644
--- a/strings/base_string.h
+++ b/strings/base_string.h
@@ -701,7 +701,8 @@ WINRT_EXPORT namespace winrt
         return value;
     }
 
-    template <typename T, std::enable_if_t<std::is_same_v<T, bool>, int> = 0>
+    template <typename T>
+        requires std::same_as<T, bool>
     hstring to_hstring(T const value)
     {
         if (value)
@@ -724,7 +725,8 @@ WINRT_EXPORT namespace winrt
         return hstring{ buffer };
     }
 
-    template <typename T, std::enable_if_t<std::is_convertible_v<T, std::string_view>, int> = 0>
+    template <typename T>
+        requires std::convertible_to<T, std::string_view>
     hstring to_hstring(T const& value)
     {
         std::string_view const view(value);
diff --git a/strings/base_weak_ref.h b/strings/base_weak_ref.h
index efaa039b6..5f124045a 100644
--- a/strings/base_weak_ref.h
+++ b/strings/base_weak_ref.h
@@ -6,7 +6,8 @@ WINRT_EXPORT namespace winrt
     {
         weak_ref(std::nullptr_t = nullptr) noexcept {}
 
-        template<typename U = impl::com_ref<T> const&, typename = std::enable_if_t<std::is_convertible_v<U&&, impl::com_ref<T> const&>>>
+        template<typename U = impl::com_ref<T> const&>
+            requires std::convertible_to<U&&, impl::com_ref<T> const&>
         weak_ref(U&& object)
         {
             from_com_ref(static_cast<impl::com_ref<T> const&>(object));
diff --git a/strings/base_windows.h b/strings/base_windows.h
index 2976c91ad..d6d9071e8 100644
--- a/strings/base_windows.h
+++ b/strings/base_windows.h
@@ -69,13 +69,15 @@ WINRT_EXPORT namespace winrt::impl
     template <typename T>
     using com_ref = std::conditional_t<std::is_base_of_v<Windows::Foundation::IUnknown, T>, T, com_ptr<T>>;
 
-    template <typename T, std::enable_if_t<is_implements_v<T>, int> = 0>
+    template <typename T>
+        requires is_implements_v<T>
     com_ref<T> wrap_as_result(void* result)
     {
         return { &static_cast<produce<T, typename default_interface<T>::type>*>(result)->shim(), take_ownership_from_abi };
     }
 
-    template <typename T, std::enable_if_t<!is_implements_v<T>, int> = 0>
+    template <typename T>
+        requires (!is_implements_v<T>)
     com_ref<T> wrap_as_result(void* result)
     {
         return { result, take_ownership_from_abi };
@@ -91,10 +93,12 @@ WINRT_EXPORT namespace winrt::impl
     inline constexpr bool is_com_interface_v = is_com_interface<T>::value;
 
     // You must include <winrt/Windows.Foundation.h> to use this overload.
-    template <typename To, typename From, std::enable_if_t<!is_com_interface_v<To>, int> = 0>
+    template <typename To, typename From>
+        requires (!is_com_interface_v<To>)
     auto as(From* ptr);
 
-    template <typename To, typename From, std::enable_if_t<is_com_interface_v<To>, int> = 0>
+    template <typename To, typename From>
+        requires is_com_interface_v<To>
     com_ref<To> as(From* ptr)
     {
 #ifdef WINRT_DIAGNOSTICS
@@ -112,10 +116,12 @@ WINRT_EXPORT namespace winrt::impl
     }
 
     // You must include <winrt/Windows.Foundation.h> to use this overload.
-    template <typename To, typename From, std::enable_if_t<!is_com_interface_v<To>, int> = 0>
+    template <typename To, typename From>
+        requires (!is_com_interface_v<To>)
     auto try_as(From* ptr) noexcept;
 
-    template <typename To, typename From, std::enable_if_t<is_com_interface_v<To>, int> = 0>
+    template <typename To, typename From>
+        requires is_com_interface_v<To>
     com_ref<To> try_as(From* ptr) noexcept
     {
 #ifdef WINRT_DIAGNOSTICS
@@ -132,7 +138,8 @@ WINRT_EXPORT namespace winrt::impl
         return wrap_as_result<To>(result);
     }
 
-    template <typename To, typename From, std::enable_if_t<is_com_interface_v<To>, int> = 0>
+    template <typename To, typename From>
+        requires is_com_interface_v<To>
     com_ref<To> try_as_with_reason(From* ptr, hresult& code) noexcept
     {
 #ifdef WINRT_DIAGNOSTICS
@@ -341,13 +348,15 @@ WINRT_EXPORT namespace winrt::Windows::Foundation
 
 WINRT_EXPORT namespace winrt
 {
-    template <typename T, std::enable_if_t<!std::is_base_of_v<Windows::Foundation::IUnknown, T>, int> = 0>
+    template <typename T>
+        requires (!std::is_base_of_v<Windows::Foundation::IUnknown, T>)
     auto get_abi(T const& object) noexcept
     {
         return reinterpret_cast<impl::abi_t<T> const&>(object);
     }
 
-    template <typename T, std::enable_if_t<!std::is_base_of_v<Windows::Foundation::IUnknown, T>, int> = 0>
+    template <typename T>
+        requires (!std::is_base_of_v<Windows::Foundation::IUnknown, T>)
     auto put_abi(T& object) noexcept
     {
         if constexpr (!std::is_trivially_destructible_v<T>)
@@ -358,19 +367,22 @@ WINRT_EXPORT namespace winrt
         return reinterpret_cast<impl::abi_t<T>*>(&object);
     }
 
-    template <typename T, typename V, std::enable_if_t<!std::is_base_of_v<Windows::Foundation::IUnknown, T>, int> = 0>
+    template <typename T, typename V>
+        requires (!std::is_base_of_v<Windows::Foundation::IUnknown, T>)
     void copy_from_abi(T& object, V&& value)
     {
         object = reinterpret_cast<T const&>(value);
     }
 
-    template <typename T, typename V, std::enable_if_t<!std::is_base_of_v<Windows::Foundation::IUnknown, T>, int> = 0>
+    template <typename T, typename V>
+        requires (!std::is_base_of_v<Windows::Foundation::IUnknown, T>)
     void copy_to_abi(T const& object, V& value)
     {
         reinterpret_cast<T&>(value) = object;
     }
 
-    template <typename T, std::enable_if_t<!std::is_base_of_v<Windows::Foundation::IUnknown, std::decay_t<T>> && !std::is_convertible_v<T, std::wstring_view>, int> = 0>
+    template <typename T>
+        requires (!std::is_base_of_v<Windows::Foundation::IUnknown, std::decay_t<T>> && !std::is_convertible_v<T, std::wstring_view>)
     auto detach_abi(T&& object)
     {
         impl::abi_t<T> result{};