diff --git a/libcxx/include/concepts b/libcxx/include/concepts
--- a/libcxx/include/concepts
+++ b/libcxx/include/concepts
@@ -210,6 +210,15 @@
 template<class _Tp>
 concept floating_point = is_floating_point_v<_Tp>;
 
+// [concept.assignable]
+template<class _Lhs, class _Rhs>
+concept assignable_from =
+  is_lvalue_reference_v<_Lhs> &&
+  common_reference_with<const remove_reference_t<_Lhs>&, const remove_reference_t<_Rhs>&> &&
+  requires (_Lhs __lhs, _Rhs&& __rhs) {
+    { __lhs = _VSTD::forward<_Rhs>(__rhs) } -> same_as<_Lhs>;
+  };
+
 // [concept.destructible]
 
 template<class _Tp>
diff --git a/libcxx/test/std/concepts/lang/assignable.compile.pass.cpp b/libcxx/test/std/concepts/lang/assignable.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/concepts/lang/assignable.compile.pass.cpp
@@ -0,0 +1,393 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+
+// template<class From, class To>
+// concept assignable_from;
+
+#include <concepts>
+#include <vector>
+
+// Note: is_lvalue_reference is checked in all ModelsAssignableFrom calls.
+template <typename T1, typename T2>
+constexpr bool ModelsAssignableFrom() {
+  static_assert(!std::assignable_from<T1, T2>);
+  static_assert(!std::assignable_from<T1, const T2>);
+  static_assert(!std::assignable_from<T1, T2&>);
+  static_assert(!std::assignable_from<T1, const T2&>);
+  static_assert(!std::assignable_from<T1, volatile T2&>);
+  static_assert(!std::assignable_from<T1, const volatile T2&>);
+  static_assert(!std::assignable_from<T1, T2&&>);
+  static_assert(!std::assignable_from<T1, const T2&&>);
+  static_assert(!std::assignable_from<T1, volatile T2&&>);
+  static_assert(!std::assignable_from<T1, const volatile T2&&>);
+
+  static_assert(std::assignable_from<T1&, T2>);
+  static_assert(std::assignable_from<T1&, const T2>);
+  static_assert(std::assignable_from<T1&, T2&>);
+  static_assert(std::assignable_from<T1&, const T2&>);
+  static_assert(std::assignable_from<T1&, volatile T2&>);
+  static_assert(std::assignable_from<T1&, const volatile T2&>);
+  static_assert(std::assignable_from<T1&, T2&&>);
+  static_assert(std::assignable_from<T1&, const T2&&>);
+  static_assert(std::assignable_from<T1&, volatile T2&&>);
+  static_assert(std::assignable_from<T1&, const volatile T2&&>);
+
+  static_assert(!std::assignable_from<const T1&, T2>);
+  static_assert(!std::assignable_from<const T1&, const T2>);
+  static_assert(!std::assignable_from<const T1&, T2&>);
+  static_assert(!std::assignable_from<const T1&, const T2&>);
+  static_assert(!std::assignable_from<const T1&, volatile T2&>);
+  static_assert(!std::assignable_from<const T1&, const volatile T2&>);
+  static_assert(!std::assignable_from<const T1&, T2&&>);
+  static_assert(!std::assignable_from<const T1&, const T2&&>);
+  static_assert(!std::assignable_from<const T1&, volatile T2&&>);
+  static_assert(!std::assignable_from<const T1&, const volatile T2&&>);
+
+  static_assert(std::assignable_from<volatile T1&, T2>);
+  static_assert(std::assignable_from<volatile T1&, const T2>);
+  static_assert(std::assignable_from<volatile T1&, T2&>);
+  static_assert(std::assignable_from<volatile T1&, const T2&>);
+  static_assert(std::assignable_from<volatile T1&, volatile T2&>);
+  static_assert(std::assignable_from<volatile T1&, const volatile T2&>);
+  static_assert(std::assignable_from<volatile T1&, T2&&>);
+  static_assert(std::assignable_from<volatile T1&, const T2&&>);
+  static_assert(std::assignable_from<volatile T1&, volatile T2&&>);
+  static_assert(std::assignable_from<volatile T1&, const volatile T2&&>);
+
+  static_assert(!std::assignable_from<const volatile T1&, T2>);
+  static_assert(!std::assignable_from<const volatile T1&, const T2>);
+  static_assert(!std::assignable_from<const volatile T1&, T2&>);
+  static_assert(!std::assignable_from<const volatile T1&, const T2&>);
+  static_assert(!std::assignable_from<const volatile T1&, volatile T2&>);
+  static_assert(!std::assignable_from<const volatile T1&, const volatile T2&>);
+  static_assert(!std::assignable_from<const volatile T1&, T2&&>);
+  static_assert(!std::assignable_from<const volatile T1&, const T2&&>);
+  static_assert(!std::assignable_from<const volatile T1&, volatile T2&&>);
+  static_assert(!std::assignable_from<const volatile T1&, const volatile T2&&>);
+
+  static_assert(!std::assignable_from<T1&&, T2>);
+  static_assert(!std::assignable_from<T1&&, const T2>);
+  static_assert(!std::assignable_from<T1&&, T2&>);
+  static_assert(!std::assignable_from<T1&&, const T2&>);
+  static_assert(!std::assignable_from<T1&&, volatile T2&>);
+  static_assert(!std::assignable_from<T1&&, const volatile T2&>);
+  static_assert(!std::assignable_from<T1&&, T2&&>);
+  static_assert(!std::assignable_from<T1&&, const T2&&>);
+  static_assert(!std::assignable_from<T1&&, volatile T2&&>);
+  static_assert(!std::assignable_from<T1&&, const volatile T2&&>);
+
+  static_assert(!std::assignable_from<const T1&&, T2>);
+  static_assert(!std::assignable_from<const T1&&, const T2>);
+  static_assert(!std::assignable_from<const T1&&, T2&>);
+  static_assert(!std::assignable_from<const T1&&, const T2&>);
+  static_assert(!std::assignable_from<const T1&&, volatile T2&>);
+  static_assert(!std::assignable_from<const T1&&, const volatile T2&>);
+  static_assert(!std::assignable_from<const T1&&, T2&&>);
+  static_assert(!std::assignable_from<const T1&&, const T2&&>);
+  static_assert(!std::assignable_from<const T1&&, volatile T2&&>);
+  static_assert(!std::assignable_from<const T1&&, const volatile T2&&>);
+
+  static_assert(!std::assignable_from<volatile T1&&, T2>);
+  static_assert(!std::assignable_from<volatile T1&&, const T2>);
+  static_assert(!std::assignable_from<volatile T1&&, T2&>);
+  static_assert(!std::assignable_from<volatile T1&&, const T2&>);
+  static_assert(!std::assignable_from<volatile T1&&, volatile T2&>);
+  static_assert(!std::assignable_from<volatile T1&&, const volatile T2&>);
+  static_assert(!std::assignable_from<volatile T1&&, T2&&>);
+  static_assert(!std::assignable_from<volatile T1&&, const T2&&>);
+  static_assert(!std::assignable_from<volatile T1&&, volatile T2&&>);
+  static_assert(!std::assignable_from<volatile T1&&, const volatile T2&&>);
+
+  static_assert(!std::assignable_from<const volatile T1&&, T2>);
+  static_assert(!std::assignable_from<const volatile T1&&, const T2>);
+  static_assert(!std::assignable_from<const volatile T1&&, T2&>);
+  static_assert(!std::assignable_from<const volatile T1&&, const T2&>);
+  static_assert(!std::assignable_from<const volatile T1&&, volatile T2&>);
+  static_assert(!std::assignable_from<const volatile T1&&, const volatile T2&>);
+  static_assert(!std::assignable_from<const volatile T1&&, T2&&>);
+  static_assert(!std::assignable_from<const volatile T1&&, const T2&&>);
+  static_assert(!std::assignable_from<const volatile T1&&, volatile T2&&>);
+  static_assert(
+      !std::assignable_from<const volatile T1&&, const volatile T2&&>);
+
+  return std::assignable_from<T1&, T2>;
+}
+
+// Built-in types
+static_assert(ModelsAssignableFrom<int, int>());
+static_assert(ModelsAssignableFrom<int, double>());
+static_assert(ModelsAssignableFrom<double, int>());
+
+static_assert(ModelsAssignableFrom<int*, int*>());
+static_assert(!std::assignable_from<int*&, const int*>);
+static_assert(!std::assignable_from<int*&, volatile int*>);
+static_assert(!std::assignable_from<int*&, const volatile int*>);
+static_assert(ModelsAssignableFrom<const int*, int*>());
+static_assert(ModelsAssignableFrom<const int*, const int*>());
+static_assert(!std::assignable_from<const int*&, volatile int*>);
+static_assert(!std::assignable_from<const int*&, const volatile int*>);
+static_assert(ModelsAssignableFrom<volatile int*, int*>());
+static_assert(!std::assignable_from<volatile int*&, const int*>);
+static_assert(ModelsAssignableFrom<volatile int*, volatile int*>());
+static_assert(!std::assignable_from<volatile int*&, const volatile int*>);
+static_assert(ModelsAssignableFrom<const volatile int*, int*>());
+static_assert(ModelsAssignableFrom<const volatile int*, const int*>());
+static_assert(ModelsAssignableFrom<const volatile int*, volatile int*>());
+static_assert(ModelsAssignableFrom<const volatile int*, const volatile int*>());
+
+static_assert(ModelsAssignableFrom<int (*)(), int (*)()>());
+static_assert(ModelsAssignableFrom<int (*)(), int (*)() noexcept>());
+
+struct S {};
+static_assert(ModelsAssignableFrom<int S::*, int S::*>());
+static_assert(ModelsAssignableFrom<const int S::*, int S::*>());
+static_assert(ModelsAssignableFrom<int (S::*)(), int (S::*)()>());
+static_assert(ModelsAssignableFrom<int (S::*)(), int (S::*)() noexcept>());
+static_assert(ModelsAssignableFrom<int (S::*)() const, int (S::*)() const>());
+static_assert(
+    ModelsAssignableFrom<int (S::*)() const, int (S::*)() const noexcept>());
+static_assert(
+    ModelsAssignableFrom<int (S::*)() volatile, int (S::*)() volatile>());
+static_assert(ModelsAssignableFrom<int (S::*)() volatile,
+                                   int (S::*)() volatile noexcept>());
+static_assert(ModelsAssignableFrom<int (S::*)() const volatile,
+                                   int (S::*)() const volatile>());
+static_assert(ModelsAssignableFrom<int (S::*)() const volatile,
+                                   int (S::*)() const volatile noexcept>());
+
+static_assert(!std::assignable_from<void, int>);
+static_assert(!std::assignable_from<void, void>);
+static_assert(!std::assignable_from<int*&, long*>);
+static_assert(!std::assignable_from<int (&)[5], int[5]>);
+static_assert(!std::assignable_from<int (S::*&)(), int (S::*)() const>);
+static_assert(!std::assignable_from<int (S::*&)() const, int (S::*)()>);
+static_assert(!std::assignable_from<int (S::*&)(), int (S::*)() volatile>);
+static_assert(!std::assignable_from<int (S::*&)() volatile, int (S::*)()>);
+static_assert(
+    !std::assignable_from<int (S::*&)(), int (S::*)() const volatile>);
+static_assert(
+    !std::assignable_from<int (S::*&)() const volatile, int (S::*)()>);
+static_assert(!std::assignable_from<int (S::*&)() noexcept, int (S::*)()>);
+static_assert(
+    !std::assignable_from<int (S::*&)() const noexcept, int (S::*)() const>);
+static_assert(!std::assignable_from<int (S::*&)() volatile noexcept,
+                                    int (S::*)() volatile>);
+static_assert(!std::assignable_from<int (S::*&)() const volatile noexcept,
+                                    int (S::*)() const volatile>);
+
+struct T1 {};
+
+struct NoCommonReference {};
+static_assert(!std::common_reference_with<const T1&, const NoCommonReference&>);
+static_assert(!std::assignable_from<NoCommonReference&, T1>);
+
+struct AssignmentReturnsNonReference {
+  AssignmentReturnsNonReference operator=(T1);
+  operator T1() const;
+};
+static_assert(std::common_reference_with<const T1&,
+                                         const AssignmentReturnsNonReference&>);
+static_assert(!std::assignable_from<AssignmentReturnsNonReference&, T1>);
+
+struct NonCVAssignmentOnly {
+  NonCVAssignmentOnly& operator=(T1);
+  operator T1() const;
+};
+static_assert(
+    std::common_reference_with<const T1&, const NonCVAssignmentOnly&>);
+static_assert(std::assignable_from<NonCVAssignmentOnly&, T1>);
+static_assert(!std::assignable_from<const NonCVAssignmentOnly&, T1>);
+static_assert(!std::assignable_from<volatile NonCVAssignmentOnly&, T1>);
+static_assert(!std::assignable_from<const volatile NonCVAssignmentOnly&, T1>);
+
+struct NonCVAssignmentOnlyConstQualified {
+  NonCVAssignmentOnlyConstQualified& operator=(T1) const;
+  operator T1() const;
+};
+static_assert(std::common_reference_with<
+              const T1&, const NonCVAssignmentOnlyConstQualified&>);
+static_assert(std::assignable_from<NonCVAssignmentOnlyConstQualified&, T1>);
+static_assert(
+    !std::assignable_from<const NonCVAssignmentOnlyConstQualified&, T1>);
+static_assert(
+    !std::assignable_from<volatile NonCVAssignmentOnlyConstQualified&, T1>);
+static_assert(!std::assignable_from<
+              const volatile NonCVAssignmentOnlyConstQualified&, T1>);
+
+struct NonCVAssignmentVolatileQualified {
+  NonCVAssignmentVolatileQualified& operator=(T1) volatile;
+  operator T1() const volatile;
+};
+static_assert(std::common_reference_with<
+              const T1&, const NonCVAssignmentVolatileQualified&>);
+static_assert(std::assignable_from<NonCVAssignmentVolatileQualified&, T1>);
+static_assert(
+    !std::assignable_from<const NonCVAssignmentVolatileQualified&, T1>);
+static_assert(
+    !std::assignable_from<volatile NonCVAssignmentVolatileQualified&, T1>);
+static_assert(!std::assignable_from<
+              const volatile NonCVAssignmentVolatileQualified&, T1>);
+
+struct NonCVAssignmentOnlyCVQualified {
+  NonCVAssignmentOnlyCVQualified& operator=(T1) const volatile;
+  operator T1() const volatile;
+};
+static_assert(std::common_reference_with<
+              const T1&, const NonCVAssignmentOnlyCVQualified&>);
+static_assert(std::assignable_from<NonCVAssignmentOnlyCVQualified&, T1>);
+static_assert(!std::assignable_from<const NonCVAssignmentOnlyCVQualified&, T1>);
+static_assert(
+    !std::assignable_from<volatile NonCVAssignmentOnlyCVQualified&, T1>);
+static_assert(
+    !std::assignable_from<const volatile NonCVAssignmentOnlyCVQualified&, T1>);
+
+struct ConstAssignmentOnly {
+  const ConstAssignmentOnly& operator=(T1) const;
+  operator T1() const;
+};
+static_assert(
+    std::common_reference_with<const T1&, const ConstAssignmentOnly&>);
+static_assert(std::assignable_from<const ConstAssignmentOnly&, T1>);
+static_assert(!std::assignable_from<ConstAssignmentOnly&, T1>);
+static_assert(!std::assignable_from<volatile ConstAssignmentOnly&, T1>);
+static_assert(!std::assignable_from<const volatile ConstAssignmentOnly&, T1>);
+
+struct VolatileAssignmentOnly {
+  volatile VolatileAssignmentOnly& operator=(T1) volatile;
+  operator T1() const volatile;
+};
+static_assert(
+    std::common_reference_with<const T1&, const VolatileAssignmentOnly&>);
+static_assert(!std::assignable_from<VolatileAssignmentOnly&, T1>);
+static_assert(std::assignable_from<volatile VolatileAssignmentOnly&, T1>);
+
+struct CVAssignmentOnly {
+  const volatile CVAssignmentOnly& operator=(T1) const volatile;
+  operator T1() const volatile;
+};
+static_assert(std::common_reference_with<const T1&, const CVAssignmentOnly&>);
+static_assert(std::assignable_from<const volatile CVAssignmentOnly&, T1>);
+static_assert(!std::assignable_from<CVAssignmentOnly&, T1>);
+static_assert(!std::assignable_from<const CVAssignmentOnly&, T1>);
+static_assert(!std::assignable_from<volatile CVAssignmentOnly&, T1>);
+
+struct LvalueRefQualifiedWithRvalueT1Only {
+  LvalueRefQualifiedWithRvalueT1Only& operator=(T1&&) &;
+  const LvalueRefQualifiedWithRvalueT1Only& operator=(T1&&) const&;
+  volatile LvalueRefQualifiedWithRvalueT1Only& operator=(T1&&) volatile&;
+  const volatile LvalueRefQualifiedWithRvalueT1Only& operator=(T1&&) const
+      volatile&;
+  operator T1() const volatile;
+};
+static_assert(std::common_reference_with<
+              const T1&, const LvalueRefQualifiedWithRvalueT1Only&>);
+static_assert(std::assignable_from<LvalueRefQualifiedWithRvalueT1Only&, T1&&>);
+static_assert(
+    std::assignable_from<const LvalueRefQualifiedWithRvalueT1Only&, T1&&>);
+static_assert(
+    std::assignable_from<volatile LvalueRefQualifiedWithRvalueT1Only&, T1&&>);
+static_assert(std::assignable_from<
+              const volatile LvalueRefQualifiedWithRvalueT1Only&, T1&&>);
+static_assert(!std::assignable_from<LvalueRefQualifiedWithRvalueT1Only&, T1&>);
+static_assert(
+    !std::assignable_from<const LvalueRefQualifiedWithRvalueT1Only&, T1&>);
+static_assert(
+    !std::assignable_from<volatile LvalueRefQualifiedWithRvalueT1Only&, T1&>);
+static_assert(!std::assignable_from<
+              const volatile LvalueRefQualifiedWithRvalueT1Only&, T1&>);
+static_assert(
+    !std::assignable_from<LvalueRefQualifiedWithRvalueT1Only&, const T1&>);
+static_assert(!std::assignable_from<const LvalueRefQualifiedWithRvalueT1Only&,
+                                    const T1&>);
+static_assert(!std::assignable_from<
+              volatile LvalueRefQualifiedWithRvalueT1Only&, const T1&>);
+static_assert(!std::assignable_from<
+              const volatile LvalueRefQualifiedWithRvalueT1Only&, const T1&>);
+static_assert(
+    !std::assignable_from<LvalueRefQualifiedWithRvalueT1Only&, volatile T1&>);
+static_assert(!std::assignable_from<const LvalueRefQualifiedWithRvalueT1Only&,
+                                    volatile T1&>);
+static_assert(!std::assignable_from<
+              volatile LvalueRefQualifiedWithRvalueT1Only&, volatile T1&>);
+static_assert(
+    !std::assignable_from<const volatile LvalueRefQualifiedWithRvalueT1Only&,
+                          volatile T1&>);
+static_assert(!std::assignable_from<LvalueRefQualifiedWithRvalueT1Only&,
+                                    const volatile T1&>);
+static_assert(!std::assignable_from<const LvalueRefQualifiedWithRvalueT1Only&,
+                                    const volatile T1&>);
+static_assert(
+    !std::assignable_from<volatile LvalueRefQualifiedWithRvalueT1Only&,
+                          const volatile T1&>);
+static_assert(
+    !std::assignable_from<const volatile LvalueRefQualifiedWithRvalueT1Only&,
+                          const volatile T1&>);
+static_assert(
+    !std::assignable_from<LvalueRefQualifiedWithRvalueT1Only&, const T1&&>);
+static_assert(!std::assignable_from<const LvalueRefQualifiedWithRvalueT1Only&,
+                                    const T1&&>);
+static_assert(!std::assignable_from<
+              volatile LvalueRefQualifiedWithRvalueT1Only&, const T1&&>);
+static_assert(!std::assignable_from<
+              const volatile LvalueRefQualifiedWithRvalueT1Only&, const T1&&>);
+static_assert(
+    !std::assignable_from<LvalueRefQualifiedWithRvalueT1Only&, volatile T1&&>);
+static_assert(!std::assignable_from<const LvalueRefQualifiedWithRvalueT1Only&,
+                                    volatile T1&&>);
+static_assert(!std::assignable_from<
+              volatile LvalueRefQualifiedWithRvalueT1Only&, volatile T1&&>);
+static_assert(
+    !std::assignable_from<const volatile LvalueRefQualifiedWithRvalueT1Only&,
+                          volatile T1&&>);
+static_assert(!std::assignable_from<LvalueRefQualifiedWithRvalueT1Only&,
+                                    const volatile T1&&>);
+static_assert(!std::assignable_from<const LvalueRefQualifiedWithRvalueT1Only&,
+                                    const volatile T1&&>);
+static_assert(
+    !std::assignable_from<volatile LvalueRefQualifiedWithRvalueT1Only&,
+                          const volatile T1&&>);
+static_assert(
+    !std::assignable_from<const volatile LvalueRefQualifiedWithRvalueT1Only&,
+                          const volatile T1&&>);
+
+struct NoLvalueRefAssignment {
+  NoLvalueRefAssignment& operator=(T1) &&;
+  const NoLvalueRefAssignment& operator=(T1) const&&;
+  volatile NoLvalueRefAssignment& operator=(T1) volatile&&;
+  const volatile NoLvalueRefAssignment& operator=(T1) const volatile&&;
+  operator T1() const volatile;
+};
+static_assert(
+    std::common_reference_with<const T1&, const NoLvalueRefAssignment&>);
+static_assert(!std::assignable_from<NoLvalueRefAssignment&, T1>);
+static_assert(!std::assignable_from<NoLvalueRefAssignment&, const T1>);
+static_assert(!std::assignable_from<NoLvalueRefAssignment&, volatile T1>);
+static_assert(!std::assignable_from<NoLvalueRefAssignment&, const volatile T1>);
+static_assert(!std::assignable_from<const NoLvalueRefAssignment&, T1>);
+static_assert(!std::assignable_from<const NoLvalueRefAssignment&, const T1>);
+static_assert(!std::assignable_from<const NoLvalueRefAssignment&, volatile T1>);
+static_assert(
+    !std::assignable_from<const NoLvalueRefAssignment&, const volatile T1>);
+static_assert(!std::assignable_from<volatile NoLvalueRefAssignment&, T1>);
+static_assert(!std::assignable_from<volatile NoLvalueRefAssignment&, const T1>);
+static_assert(
+    !std::assignable_from<volatile NoLvalueRefAssignment&, volatile T1>);
+static_assert(
+    !std::assignable_from<volatile NoLvalueRefAssignment&, const volatile T1>);
+static_assert(!std::assignable_from<const volatile NoLvalueRefAssignment&, T1>);
+static_assert(
+    !std::assignable_from<const volatile NoLvalueRefAssignment&, const T1>);
+static_assert(
+    !std::assignable_from<const volatile NoLvalueRefAssignment&, volatile T1>);
+static_assert(!std::assignable_from<const volatile NoLvalueRefAssignment&,
+                                    const volatile T1>);
+
+int main(int, char**) { return 0; }