diff --git a/Redcraft.Utility/Source/Private/Testing/ConceptsTesting.cpp b/Redcraft.Utility/Source/Private/Testing/ConceptsTesting.cpp
index a2a78e1..5eecc02 100644
--- a/Redcraft.Utility/Source/Private/Testing/ConceptsTesting.cpp
+++ b/Redcraft.Utility/Source/Private/Testing/ConceptsTesting.cpp
@@ -114,6 +114,75 @@ void TestConcepts()
 	always_check(!CFloatingPoint<int32>);
 	always_check(CFloatingPoint<float>);
 
+	// BooleanTestable.h
+
+	always_check(CBooleanTestable<bool>);
+	always_check(CBooleanTestable<int32>);
+	always_check(CBooleanTestable<float>);
+	always_check(!CBooleanTestable<FTestStructA>);
+
+	// Assignable.h
+
+	always_check((CAssignableFrom<int32&, int64>));
+	always_check((CAssignableFrom<int32&, int32>));
+	always_check((CAssignableFrom<int32&, int8>));
+	always_check(!(CAssignableFrom<FTestStructI&, int32>));
+	always_check(!(CAssignableFrom<FTestStructA&, void>));
+
+	// Common.h
+
+	always_check((CCommonWith<int32, int32>));
+	always_check((CCommonWith<int8, int32>));
+	always_check((CCommonWith<float, double>));
+	always_check(!(CCommonWith<FTestStructA, int32>));
+
+	always_check((CCommonReferenceWith<int8, int32>));
+	always_check((CCommonReferenceWith<float, int32>));
+	always_check((CCommonReferenceWith<float, double>));
+	always_check(!(CCommonReferenceWith<FTestStructA, double>));
+
+	// Comparable.h
+
+	always_check((CEqualityComparable<int32>));
+	always_check(!(CEqualityComparable<FTestStructA>));
+
+	always_check((CEqualityComparableWith<int32, int32>));
+	always_check((CEqualityComparableWith<int32, int64>));
+	always_check(!(CEqualityComparableWith<FTestStructA, FTestStructA>));
+
+	always_check((CTotallyOrdered<int32>));
+	always_check(!(CTotallyOrdered<FTestStructA>));
+
+	always_check((CTotallyOrderedWith<int32, int32>));
+	always_check((CTotallyOrderedWith<int32, int64>));
+	always_check(!(CTotallyOrderedWith<FTestStructA, FTestStructA>));
+
+	// Objects.h
+
+	always_check(CMovable<int32>);
+	always_check(CCopyable<int32>);
+	always_check(CSemiregular<int32>);
+	always_check(CRegular<int32>);
+	
+	always_check(CMovable<FTestStructQ>);
+	always_check(!CCopyable<FTestStructQ>);
+	always_check(!CSemiregular<FTestStructQ>);
+	always_check(!CRegular<FTestStructQ>);
+
+	always_check(CMovable<FTestStructN>);
+	always_check(CCopyable<FTestStructN>);
+	always_check(!CSemiregular<FTestStructN>);
+	always_check(!CRegular<FTestStructN>);
+	
+	// Swappable.h
+
+	always_check(CSwappable<int32>);
+	always_check(CSwappable<FTestStructG>);
+	always_check(CSwappable<FTestStructN>);
+//	always_check(!CSwappable<FSingleton>);
+
+	always_check((CSwappableWith<int32&, int32&>));
+
 }
 
 NAMESPACE_MODULE_END(Utility)
diff --git a/Redcraft.Utility/Source/Public/Concepts/Assignable.h b/Redcraft.Utility/Source/Public/Concepts/Assignable.h
new file mode 100644
index 0000000..8b37a93
--- /dev/null
+++ b/Redcraft.Utility/Source/Public/Concepts/Assignable.h
@@ -0,0 +1,23 @@
+#pragma once
+
+#include "CoreTypes.h"
+#include "Concepts/Common.h"
+#include "Templates/Templates.h"
+#include "TypeTraits/TypeTraits.h"
+
+NAMESPACE_REDCRAFT_BEGIN
+NAMESPACE_MODULE_BEGIN(Redcraft)
+NAMESPACE_MODULE_BEGIN(Utility)
+
+template <typename T, typename U>
+concept CAssignableFrom =
+	TIsLValueReference<T>::Value &&
+	CCommonReferenceWith<const typename TRemoveReference<T>::Type&, const typename TRemoveReference<U>::Type&> &&
+	requires(T A, U&& B)
+	{
+		{ A = Forward<U>(B) } -> CSameAs<T>;
+	};
+
+NAMESPACE_MODULE_END(Utility)
+NAMESPACE_MODULE_END(Redcraft)
+NAMESPACE_REDCRAFT_END
diff --git a/Redcraft.Utility/Source/Public/Concepts/BooleanTestable.h b/Redcraft.Utility/Source/Public/Concepts/BooleanTestable.h
new file mode 100644
index 0000000..69073b4
--- /dev/null
+++ b/Redcraft.Utility/Source/Public/Concepts/BooleanTestable.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "CoreTypes.h"
+#include "Templates/Utility.h"
+#include "Concepts/Convertible.h"
+#include "TypeTraits/TypeTraits.h"
+
+NAMESPACE_REDCRAFT_BEGIN
+NAMESPACE_MODULE_BEGIN(Redcraft)
+NAMESPACE_MODULE_BEGIN(Utility)
+
+template <typename T>
+concept CBooleanTestable = CConvertibleTo<T, bool> &&
+	requires(T && B) { { !Forward<T>(B) } -> CConvertibleTo<bool>; };
+
+NAMESPACE_MODULE_END(Utility)
+NAMESPACE_MODULE_END(Redcraft)
+NAMESPACE_REDCRAFT_END
diff --git a/Redcraft.Utility/Source/Public/Concepts/Common.h b/Redcraft.Utility/Source/Public/Concepts/Common.h
new file mode 100644
index 0000000..07614b5
--- /dev/null
+++ b/Redcraft.Utility/Source/Public/Concepts/Common.h
@@ -0,0 +1,40 @@
+#pragma once
+
+#include "CoreTypes.h"
+#include "Concepts/Same.h"
+#include "Templates/Templates.h"
+#include "Concepts/Convertible.h"
+#include "TypeTraits/TypeTraits.h"
+
+NAMESPACE_REDCRAFT_BEGIN
+NAMESPACE_MODULE_BEGIN(Redcraft)
+NAMESPACE_MODULE_BEGIN(Utility)
+
+template <typename T, typename U>
+concept CCommonReferenceWith =
+	requires
+	{
+		typename TCommonReference<T, U>::Type;
+		typename TCommonReference<U, T>::Type;
+	} &&
+	CSameAs<typename TCommonReference<T, U>::Type, typename TCommonReference<U, T>::Type> &&
+	CConvertibleTo<T, typename TCommonReference<T, U>::Type>&&
+	CConvertibleTo<U, typename TCommonReference<T, U>::Type>;
+
+template <typename T, typename U>
+concept CCommonWith =
+	requires
+	{
+		typename TCommonType<T, U>::Type;
+		typename TCommonType<U, T>::Type;
+		requires CSameAs<typename TCommonType<T, U>::Type, typename TCommonType<U, T>::Type>;
+		static_cast<TCommonType<T, U>::Type>(DeclVal<T>());
+		static_cast<TCommonType<T, U>::Type>(DeclVal<U>());
+	} &&
+	CCommonReferenceWith<const T&, const U&> &&
+	CCommonReferenceWith<typename TCommonType<T, U>::Type&, typename TCommonReference<const T&, const U&>::Type> &&
+	CSameAs<typename TCommonReference<T, U>::Type, typename TCommonReference<U, T>::Type>;
+
+NAMESPACE_MODULE_END(Utility)
+NAMESPACE_MODULE_END(Redcraft)
+NAMESPACE_REDCRAFT_END
diff --git a/Redcraft.Utility/Source/Public/Concepts/Comparable.h b/Redcraft.Utility/Source/Public/Concepts/Comparable.h
new file mode 100644
index 0000000..d23340f
--- /dev/null
+++ b/Redcraft.Utility/Source/Public/Concepts/Comparable.h
@@ -0,0 +1,59 @@
+#pragma once
+
+#include "CoreTypes.h"
+#include "Concepts/Common.h"
+#include "TypeTraits/TypeTraits.h"
+#include "Concepts/BooleanTestable.h"
+
+NAMESPACE_REDCRAFT_BEGIN
+NAMESPACE_MODULE_BEGIN(Redcraft)
+NAMESPACE_MODULE_BEGIN(Utility)
+
+template <typename T, typename U>
+concept CWeaklyEqualityComparableWith =
+	requires(const TRemoveReference<T>::Type & A, const TRemoveReference<U>::Type & B)
+	{
+		{ A == B } -> CBooleanTestable;
+		{ A != B } -> CBooleanTestable;
+		{ B == A } -> CBooleanTestable;
+		{ B != A } -> CBooleanTestable;
+	};
+
+template <typename T>
+concept CEqualityComparable = CWeaklyEqualityComparableWith<T, T>;
+
+template <typename T, typename U>
+concept CEqualityComparableWith =
+	CEqualityComparable<T> &&
+	CEqualityComparable<U> &&
+	CWeaklyEqualityComparableWith<T, U> &&
+	CCommonReferenceWith<const typename TRemoveReference<T>::Type&, const typename TRemoveReference<U>::Type&> &&
+	CEqualityComparable<typename TCommonReference<const typename TRemoveReference<T>::Type&,  const typename TRemoveReference<U>::Type&>::Type>;
+
+template <typename T, typename U>
+concept CPartiallyOrderedWith =
+	requires(const TRemoveReference<T>::Type& A, const TRemoveReference<U>::Type& B)
+	{
+		{ A <  B } -> CBooleanTestable;
+		{ A >  B } -> CBooleanTestable;
+		{ A <= B } -> CBooleanTestable;
+		{ A >= B } -> CBooleanTestable;
+		{ B <  A } -> CBooleanTestable;
+		{ B >  A } -> CBooleanTestable;
+		{ B <= A } -> CBooleanTestable;
+		{ B >= A } -> CBooleanTestable;
+	};
+
+template <typename T>
+concept CTotallyOrdered = CEqualityComparable<T> && CPartiallyOrderedWith<T, T>;
+
+template <typename T, typename U>
+concept CTotallyOrderedWith =
+	CTotallyOrdered<T> && CTotallyOrdered<U> &&
+	CPartiallyOrderedWith<T, U> &&
+	CEqualityComparableWith<T, U> &&
+	CTotallyOrdered<typename TCommonReference<const typename TRemoveReference<T>::Type&, const typename TRemoveReference<U>::Type&>::Type>;
+
+NAMESPACE_MODULE_END(Utility)
+NAMESPACE_MODULE_END(Redcraft)
+NAMESPACE_REDCRAFT_END
diff --git a/Redcraft.Utility/Source/Public/Concepts/Concepts.h b/Redcraft.Utility/Source/Public/Concepts/Concepts.h
index c01449f..57c389f 100644
--- a/Redcraft.Utility/Source/Public/Concepts/Concepts.h
+++ b/Redcraft.Utility/Source/Public/Concepts/Concepts.h
@@ -3,25 +3,16 @@
 #include "CoreTypes.h"
 #include "Concepts/Same.h"
 #include "Concepts/Derived.h"
+#include "Concepts/Objects.h"
+#include "Concepts/Swappable.h"
+#include "Concepts/Assignable.h"
+#include "Concepts/Comparable.h"
 #include "Concepts/BuiltinType.h"
 #include "Concepts/Convertible.h"
 #include "Concepts/Destructible.h"
 #include "Concepts/Constructible.h"
+#include "Concepts/BooleanTestable.h"
 
-//template <typename T> concept CBooleanTestable; // Prerequisites: Forward
-//template <typename T> concept CMovable;         // Prerequisites: CAssignableFrom
-//template <typename T> concept CCopyable;        // Prerequisites: CAssignableFrom
-//template <typename T> concept CSemiregular;     // Prerequisites: CCopyable
-//template <typename T> concept CRegular;         // Prerequisites: CEqualityComparable
-
-//template <typename T, typename U> concept CAssignableFrom;         // Prerequisites: Forward
-//template <typename T> concept CEqualityComparable;                 // Prerequisites: CBooleanTestable
-//template <typename T, typename U> concept CEqualityComparableWith; // Prerequisites: CBooleanTestable
-//template <typename T> concept CTotallyOrdered;                     // Prerequisites: CBooleanTestable
-//template <typename T, typename U> concept CTotallyOrderedWith;     // Prerequisites: CBooleanTestable
-
-//template <typename T, typename U> concept CCommonWith;                     // Prerequisites: Declval
-//template <typename T, typename U> concept CCommonReferenceWith;            // Prerequisites: Declval
 //template <typename F, typename... Args> concept CInvocable;                // Prerequisites: Invoke, Forward
 //template <typename F, typename... Args> concept CRegularInvocable;         // Prerequisites: Invoke, Forward
 //template <typename F, typename... Args> concept CPredicate;                // Prerequisites: CBooleanTestable, CRegularInvocable
diff --git a/Redcraft.Utility/Source/Public/Concepts/Constructible.h b/Redcraft.Utility/Source/Public/Concepts/Constructible.h
index 74d3158..edbc815 100644
--- a/Redcraft.Utility/Source/Public/Concepts/Constructible.h
+++ b/Redcraft.Utility/Source/Public/Concepts/Constructible.h
@@ -1,8 +1,9 @@
 #pragma once
 
 #include "CoreTypes.h"
-#include "TypeTraits/TypeTraits.h"
 #include "Concepts/Convertible.h"
+#include "TypeTraits/TypeTraits.h"
+#include "Concepts/Destructible.h"
 
 #include <new>
 
diff --git a/Redcraft.Utility/Source/Public/Concepts/Objects.h b/Redcraft.Utility/Source/Public/Concepts/Objects.h
new file mode 100644
index 0000000..f430bc9
--- /dev/null
+++ b/Redcraft.Utility/Source/Public/Concepts/Objects.h
@@ -0,0 +1,36 @@
+#pragma once
+
+#include "CoreTypes.h"
+#include "Concepts/Swappable.h"
+#include "Concepts/Assignable.h"
+#include "Concepts/Comparable.h"
+#include "TypeTraits/TypeTraits.h"
+#include "Concepts/Constructible.h"
+
+NAMESPACE_REDCRAFT_BEGIN
+NAMESPACE_MODULE_BEGIN(Redcraft)
+NAMESPACE_MODULE_BEGIN(Utility)
+
+template <typename T>
+concept CMovable =
+	TIsObject<T>::Value &&
+	CMoveConstructible<T> &&
+	CAssignableFrom<T&, T> &&
+	CSwappable<T>;
+
+template <typename T>
+concept CCopyable = CMovable<T> &&
+	CCopyConstructible<T> &&
+	CAssignableFrom<T&, T&> &&
+	CAssignableFrom<T&, const T&> &&
+	CAssignableFrom<T&, const T>;
+
+template <typename T>
+concept CSemiregular = CCopyable<T> && CDefaultInitializable<T>;
+
+template <typename T>
+concept CRegular = CSemiregular<T> && CEqualityComparable<T>;
+
+NAMESPACE_MODULE_END(Utility)
+NAMESPACE_MODULE_END(Redcraft)
+NAMESPACE_REDCRAFT_END
diff --git a/Redcraft.Utility/Source/Public/Concepts/Swappable.h b/Redcraft.Utility/Source/Public/Concepts/Swappable.h
new file mode 100644
index 0000000..93fd8d0
--- /dev/null
+++ b/Redcraft.Utility/Source/Public/Concepts/Swappable.h
@@ -0,0 +1,27 @@
+#pragma once
+
+#include "CoreTypes.h"
+#include "Concepts/Common.h"
+#include "Templates/Templates.h"
+#include "TypeTraits/TypeTraits.h"
+
+NAMESPACE_REDCRAFT_BEGIN
+NAMESPACE_MODULE_BEGIN(Redcraft)
+NAMESPACE_MODULE_BEGIN(Utility)
+
+template <typename T>
+concept CSwappable = requires(T& A, T& B) { Swap(A, B); };
+
+template <typename T, typename U>
+concept CSwappableWith = CCommonReferenceWith<T, U> &&
+	requires(T&& A, U&& B)
+	{
+		Swap(Forward<T>(A), Forward<T>(A));
+		Swap(Forward<U>(B), Forward<U>(B));
+		Swap(Forward<T>(A), Forward<U>(B));
+		Swap(Forward<U>(B), Forward<T>(A));
+	};
+
+NAMESPACE_MODULE_END(Utility)
+NAMESPACE_MODULE_END(Redcraft)
+NAMESPACE_REDCRAFT_END