diff --git a/.clang-tidy b/.clang-tidy
index 0a9b13d72e..7e23214cc7 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -66,10 +66,6 @@ Checks: [-*,
          -modernize-use-std-format,
          -modernize-use-std-numbers,
          -modernize-use-std-print,
-
-         # C++20 supports constraints but until Spicy supports building with C++20
-         # this one has to stay disabled.
-         -modernize-use-constraints,
 ]
 
 HeaderFilterRegex: '.h'
diff --git a/src/Event.h b/src/Event.h
index 7fd5db7fcf..69914e1432 100644
--- a/src/Event.h
+++ b/src/Event.h
@@ -129,8 +129,8 @@ public:
      * A version of Enqueue() taking a variable number of arguments.
      */
     template<class... Args>
-    std::enable_if_t<std::is_convertible_v<std::tuple_element_t<0, std::tuple<Args...>>, ValPtr>> Enqueue(
-        const EventHandlerPtr& h, Args&&... args) {
+        requires std::is_convertible_v<std::tuple_element_t<0, std::tuple<Args...>>, ValPtr>
+    void Enqueue(const EventHandlerPtr& h, Args&&... args) {
         return Enqueue(h, zeek::Args{std::forward<Args>(args)...});
     }
 
diff --git a/src/Func.h b/src/Func.h
index 3b47057d98..e28d3414f0 100644
--- a/src/Func.h
+++ b/src/Func.h
@@ -104,8 +104,8 @@ public:
      * A version of Invoke() taking a variable number of individual arguments.
      */
     template<class... Args>
-    std::enable_if_t<std::is_convertible_v<std::tuple_element_t<0, std::tuple<Args...>>, ValPtr>, ValPtr> Invoke(
-        Args&&... args) const {
+        requires std::is_convertible_v<std::tuple_element_t<0, std::tuple<Args...>>, ValPtr>
+    ValPtr Invoke(Args&&... args) const {
         auto zargs = zeek::Args{std::forward<Args>(args)...};
         return Invoke(&zargs);
     }
diff --git a/src/IntrusivePtr.h b/src/IntrusivePtr.h
index c1e5db3bb7..b5b2a008ae 100644
--- a/src/IntrusivePtr.h
+++ b/src/IntrusivePtr.h
@@ -102,7 +102,8 @@ public:
 
     IntrusivePtr(const IntrusivePtr& other) noexcept : IntrusivePtr(NewRef{}, other.get()) {}
 
-    template<class U, class = std::enable_if_t<std::is_convertible_v<U*, T*>>>
+    template<class U>
+        requires std::is_convertible_v<U*, T*>
     IntrusivePtr(IntrusivePtr<U> other) noexcept : ptr_(other.release()) {
         // nop
     }
diff --git a/src/Span.h b/src/Span.h
index 96ce5e169b..dc0680b5ab 100644
--- a/src/Span.h
+++ b/src/Span.h
@@ -54,12 +54,12 @@ public:
     template<size_t Size>
     constexpr Span(element_type (&arr)[Size]) noexcept : memory_block(arr), num_elements(Size) {}
 
-    template<class Container, class Data = typename Container::value_type,
-             class = std::enable_if_t<std::is_convertible_v<Data*, T*>>>
+    template<class Container, class Data = typename Container::value_type>
+        requires std::is_convertible_v<Data*, T*>
     Span(Container& xs) noexcept : memory_block(xs.data()), num_elements(xs.size()) {}
 
-    template<class Container, class Data = typename Container::value_type,
-             class = std::enable_if_t<std::is_convertible_v<const Data*, T*>>>
+    template<class Container, class Data = typename Container::value_type>
+        requires std::is_convertible_v<const Data*, T*>
     Span(const Container& xs) noexcept : memory_block(xs.data()), num_elements(xs.size()) {}
 
     constexpr Span(const Span&) noexcept = default;
diff --git a/src/Val.h b/src/Val.h
index 5f2fc740a6..e1dcf6ca2d 100644
--- a/src/Val.h
+++ b/src/Val.h
@@ -1328,7 +1328,8 @@ public:
     // access to record fields (without requiring an intermediary Val).
     // It is up to the caller to ensure that the field exists in the
     // record (using HasRawField(), if necessary).
-    template<typename T, typename std::enable_if_t<is_zeek_val_v<T>, bool> = true>
+    template<typename T>
+        requires is_zeek_val_v<T>
     auto GetFieldAs(int field) const -> std::invoke_result_t<decltype(&T::Get), T> {
         if constexpr ( std::is_same_v<T, BoolVal> || std::is_same_v<T, IntVal> || std::is_same_v<T, EnumVal> )
             return record_val[field]->int_val;
@@ -1365,7 +1366,8 @@ public:
         }
     }
 
-    template<typename T, typename std::enable_if_t<! is_zeek_val_v<T>, bool> = true>
+    template<typename T>
+        requires(! is_zeek_val_v<T>)
     T GetFieldAs(int field) const {
         if constexpr ( std::is_integral_v<T> && std::is_signed_v<T> )
             return record_val[field]->int_val;
diff --git a/src/analyzer/Analyzer.h b/src/analyzer/Analyzer.h
index 9a60ec5545..51cd822646 100644
--- a/src/analyzer/Analyzer.h
+++ b/src/analyzer/Analyzer.h
@@ -624,8 +624,8 @@ public:
      * A version of EnqueueConnEvent() taking a variable number of arguments.
      */
     template<class... Args>
-    std::enable_if_t<std::is_convertible_v<std::tuple_element_t<0, std::tuple<Args...>>, ValPtr>> EnqueueConnEvent(
-        EventHandlerPtr h, Args&&... args) {
+        requires std::is_convertible_v<std::tuple_element_t<0, std::tuple<Args...>>, ValPtr>
+    void EnqueueConnEvent(EventHandlerPtr h, Args&&... args) {
         return EnqueueConnEvent(h, zeek::Args{std::forward<Args>(args)...});
     }
 
diff --git a/src/broker/Data.h b/src/broker/Data.h
index e7bb016195..0735acb28b 100644
--- a/src/broker/Data.h
+++ b/src/broker/Data.h
@@ -493,7 +493,8 @@ public:
 
     BrokerData() = default;
 
-    template<class DataType, class = std::enable_if_t<std::is_same_v<DataType, broker::data>>>
+    template<class DataType>
+        requires std::is_same_v<DataType, broker::data>
     explicit BrokerData(DataType value) : value_(std::move(value)) {
         // Note: we use enable_if here to avoid nasty implicit conversions of broker::data.
     }
diff --git a/src/session/Session.h b/src/session/Session.h
index 12e5111c53..4c28a0b30b 100644
--- a/src/session/Session.h
+++ b/src/session/Session.h
@@ -130,8 +130,8 @@ public:
      * A version of EnqueueEvent() taking a variable number of arguments.
      */
     template<class... Args>
-    std::enable_if_t<std::is_convertible_v<std::tuple_element_t<0, std::tuple<Args...>>, ValPtr>> EnqueueEvent(
-        EventHandlerPtr h, analyzer::Analyzer* analyzer, Args&&... args) {
+        requires std::is_convertible_v<std::tuple_element_t<0, std::tuple<Args...>>, ValPtr>
+    void EnqueueEvent(EventHandlerPtr h, analyzer::Analyzer* analyzer, Args&&... args) {
         return EnqueueEvent(h, analyzer, zeek::Args{std::forward<Args>(args)...});
     }