diff --git a/include/libsiedler2/ICloneable.h b/include/libsiedler2/ICloneable.h
index 7a87700..c642c91 100644
--- a/include/libsiedler2/ICloneable.h
+++ b/include/libsiedler2/ICloneable.h
@@ -19,14 +19,17 @@ namespace detail {
     struct is_static_castable<T, U, decltype(void(static_cast<U>(std::declval<T>())))> : std::true_type
     {};
 
+    template<typename T, typename U>
+    inline constexpr bool is_static_castable_v = is_static_castable<T, U>::value;
+
     template<typename To, typename From>
-    std::enable_if_t<is_static_castable<From*, To*>::value, To*> safePtrCast(From* from)
+    std::enable_if_t<is_static_castable_v<From*, To*>, To*> safePtrCast(From* from)
     {
         return static_cast<To*>(from);
     }
 
     template<typename To, typename From>
-    std::enable_if_t<!is_static_castable<From*, To*>::value, To*> safePtrCast(From* from)
+    std::enable_if_t<!is_static_castable_v<From*, To*>, To*> safePtrCast(From* from)
     {
         return dynamic_cast<To*>(from);
     }
diff --git a/tests/testArchiv.cpp b/tests/testArchiv.cpp
index 08a0003..c927f0c 100644
--- a/tests/testArchiv.cpp
+++ b/tests/testArchiv.cpp
@@ -159,10 +159,10 @@ struct TestItem : libsiedler2::ArchivItem
     RTTR_CLONEABLE(TestItem)
 };
 
-static_assert(!std::is_copy_constructible<libsiedler2::ArchivItem>::value, "Should not be Copyable/Movable");
-static_assert(!std::is_move_constructible<libsiedler2::ArchivItem>::value, "Should not be Copyable/Movable");
-static_assert(!std::is_copy_assignable<libsiedler2::ArchivItem>::value, "Should not be Copyable/Movable");
-static_assert(!std::is_move_assignable<libsiedler2::ArchivItem>::value, "Should not be Copyable/Movable");
+static_assert(!std::is_copy_constructible_v<libsiedler2::ArchivItem>, "Should not be Copyable/Movable");
+static_assert(!std::is_move_constructible_v<libsiedler2::ArchivItem>, "Should not be Copyable/Movable");
+static_assert(!std::is_copy_assignable_v<libsiedler2::ArchivItem>, "Should not be Copyable/Movable");
+static_assert(!std::is_move_assignable_v<libsiedler2::ArchivItem>, "Should not be Copyable/Movable");
 
 int TestItem::numLiveItems = 0;
 
diff --git a/tests/testClone.cpp b/tests/testClone.cpp
index 70bf0d8..394343b 100644
--- a/tests/testClone.cpp
+++ b/tests/testClone.cpp
@@ -34,26 +34,26 @@ struct Bar : virtual BarBase
 using TestedTypes = boost::mpl::list<Foo, Bar>;
 } // namespace
 
-static_assert(detail::is_static_castable<int, int>::value);
-static_assert(detail::is_static_castable<int, float>::value);
-static_assert(detail::is_static_castable<int*, const int*>::value);
-static_assert(!detail::is_static_castable<const int*, int*>::value);
+static_assert(detail::is_static_castable_v<int, int>);
+static_assert(detail::is_static_castable_v<int, float>);
+static_assert(detail::is_static_castable_v<int*, const int*>);
+static_assert(!detail::is_static_castable_v<const int*, int*>);
 
-static_assert(detail::is_static_castable<Foo*, Foo*>::value);
-static_assert(detail::is_static_castable<Foo*, const Foo*>::value);
-static_assert(!detail::is_static_castable<const Foo*, Foo*>::value);
-static_assert(detail::is_static_castable<Foo*, Base*>::value);
-static_assert(detail::is_static_castable<Foo*, const Base*>::value);
-static_assert(detail::is_static_castable<Base*, Foo*>::value);
-static_assert(!detail::is_static_castable<const Base*, Foo*>::value);
+static_assert(detail::is_static_castable_v<Foo*, Foo*>);
+static_assert(detail::is_static_castable_v<Foo*, const Foo*>);
+static_assert(!detail::is_static_castable_v<const Foo*, Foo*>);
+static_assert(detail::is_static_castable_v<Foo*, Base*>);
+static_assert(detail::is_static_castable_v<Foo*, const Base*>);
+static_assert(detail::is_static_castable_v<Base*, Foo*>);
+static_assert(!detail::is_static_castable_v<const Base*, Foo*>);
 
-static_assert(detail::is_static_castable<BarBase*, Base*>::value);
-static_assert(detail::is_static_castable<Base*, BarBase*>::value);
-static_assert(detail::is_static_castable<Bar*, BarBase*>::value);
-static_assert(detail::is_static_castable<Bar*, Base*>::value);
+static_assert(detail::is_static_castable_v<BarBase*, Base*>);
+static_assert(detail::is_static_castable_v<Base*, BarBase*>);
+static_assert(detail::is_static_castable_v<Bar*, BarBase*>);
+static_assert(detail::is_static_castable_v<Bar*, Base*>);
 // Virtual inheritance -> no base to derived cast
-static_assert(!detail::is_static_castable<Base*, Bar*>::value);
-static_assert(!detail::is_static_castable<BarBase*, Bar*>::value);
+static_assert(!detail::is_static_castable_v<Base*, Bar*>);
+static_assert(!detail::is_static_castable_v<BarBase*, Bar*>);
 
 BOOST_AUTO_TEST_CASE_TEMPLATE(CloneWorks, T, TestedTypes)
 {
@@ -61,9 +61,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(CloneWorks, T, TestedTypes)
     auto f2 = clone(f);       // By unique_ptr
     auto f3 = clone(f.get()); // By raw ptr
     auto f4 = clone(*f);      // By reference
-    static_assert(std::is_same<decltype(f2), decltype(f)>::value, "Must be the same");
-    static_assert(std::is_same<decltype(f3), decltype(f)>::value, "Must be the same");
-    static_assert(std::is_same<decltype(f4), decltype(f)>::value, "Must be the same");
+    static_assert(std::is_same_v<decltype(f2), decltype(f)>, "Must be the same");
+    static_assert(std::is_same_v<decltype(f3), decltype(f)>, "Must be the same");
+    static_assert(std::is_same_v<decltype(f4), decltype(f)>, "Must be the same");
     BOOST_TEST((f && f2 && f3 && f4));
     BOOST_TEST(f->i == 42);
     BOOST_TEST(f2->i == 42);
@@ -76,7 +76,7 @@ BOOST_AUTO_TEST_CASE(CloneFromBasePtr)
     auto f = std::make_unique<Bar>(42, 1337);
     auto* basePtr = static_cast<BarBase*>(f.get());
     auto f2 = clone(basePtr);
-    static_assert(std::is_same<decltype(f2), std::unique_ptr<BarBase>>::value, "Must be the same");
+    static_assert(std::is_same_v<decltype(f2), std::unique_ptr<BarBase>>, "Must be the same");
     BOOST_TEST((f && f2 && basePtr));
     BOOST_TEST(f->i == 42);
     BOOST_TEST(f->j == 1337);
@@ -89,8 +89,8 @@ BOOST_AUTO_TEST_CASE(CloneNull)
     std::unique_ptr<Foo> f;
     auto f2 = clone(f);       // By unique_ptr
     auto f3 = clone(f.get()); // By raw ptr
-    static_assert(std::is_same<decltype(f2), decltype(f)>::value, "Must be the same");
-    static_assert(std::is_same<decltype(f3), decltype(f)>::value, "Must be the same");
+    static_assert(std::is_same_v<decltype(f2), decltype(f)>, "Must be the same");
+    static_assert(std::is_same_v<decltype(f3), decltype(f)>, "Must be the same");
     BOOST_TEST(!f2);
     BOOST_TEST(!f3);
 }