diff --git a/libcxx/include/CMakeLists.txt b/libcxx/include/CMakeLists.txt
--- a/libcxx/include/CMakeLists.txt
+++ b/libcxx/include/CMakeLists.txt
@@ -310,6 +310,7 @@
   __format/formatter_pointer.h
   __format/formatter_string.h
   __format/parser_std_format_spec.h
+  __format/range_default_formatter.h
   __format/unicode.h
   __functional/binary_function.h
   __functional/binary_negate.h
@@ -625,6 +626,7 @@
   __type_traits/is_scoped_enum.h
   __type_traits/is_signed.h
   __type_traits/is_signed_integer.h
+  __type_traits/is_specialization.h
   __type_traits/is_standard_layout.h
   __type_traits/is_swappable.h
   __type_traits/is_trivial.h
diff --git a/libcxx/include/__format/concepts.h b/libcxx/include/__format/concepts.h
--- a/libcxx/include/__format/concepts.h
+++ b/libcxx/include/__format/concepts.h
@@ -15,6 +15,9 @@
 #include <__config>
 #include <__format/format_fwd.h>
 #include <__format/format_parse_context.h>
+#include <__type_traits/is_specialization.h>
+#include <__utility/pair.h>
+#include <tuple>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -56,6 +59,16 @@
 #  if _LIBCPP_STD_VER > 20
 template <class _Tp, class _CharT>
 concept formattable = __formattable<_Tp, _CharT>;
+
+// The paper P2165 "Compatibility between tuple, pair and tuple-like objects"
+// has a "tuple-like" concept, but that is not the same as this concept. That
+// paper doesn't affect the format header. Therefore use a different name for
+// the concept.
+template <class _Tp>
+concept __fmt_tuple_like = __is_specialization_v<_Tp, pair> ||
+                           // Use a requires since tuple_size_v may fail to instantiate,
+                           (__is_specialization_v<_Tp, tuple> && requires { tuple_size_v<_Tp> == 2; });
+
 #  endif //_LIBCPP_STD_VER > 20
 #endif //_LIBCPP_STD_VER > 17
 
diff --git a/libcxx/include/__format/range_default_formatter.h b/libcxx/include/__format/range_default_formatter.h
new file mode 100644
--- /dev/null
+++ b/libcxx/include/__format/range_default_formatter.h
@@ -0,0 +1,130 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___FORMAT_RANGE_DEFAULT_FORMATTER_H
+#define _LIBCPP___FORMAT_RANGE_DEFAULT_FORMATTER_H
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+#include <__availability>
+#include <__concepts/same_as.h>
+#include <__config>
+#include <__format/concepts.h>
+#include <__format/formatter.h>
+#include <__ranges/concepts.h>
+#include <__type_traits/remove_cvref.h>
+#include <__utility/pair.h>
+#include <tuple>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 20
+
+template <class _Rp, class _CharT>
+concept __const_formattable_range =
+    ranges::input_range<const _Rp> && formattable<ranges::range_reference_t<const _Rp>, _CharT>;
+
+template <class _Rp, class _CharT>
+using __fmt_maybe_const = conditional_t<__const_formattable_range<_Rp, _CharT>, const _Rp, _Rp>;
+
+enum class range_format { disabled, map, set, sequence, string, debug_string };
+
+// There is no definition of this struct, it's purely intended to be used to
+// generate diagnostics.
+template <class _Rp>
+struct _LIBCPP_TEMPLATE_VIS __instantiated_the_primary_template_of_format_kind;
+
+// Instantiation of the primary template is ill-formed.
+// This fails since the templated struct can't be instantiated. When the type
+// of format_kind is the templated struct it will generate two diagnostics per
+// instantiation. By using int as a type there's only one diagnostic.
+template <class _Rp>
+constexpr int format_kind = __instantiated_the_primary_template_of_format_kind<_Rp>{};
+
+template <ranges::input_range _Rp>
+consteval range_format __get_format_format() {
+  // [format.range.fmtkind]/2
+
+  // 2.1 If same_as<remove_cvref_t<ranges::range_reference_t<R>>, R> is true,
+  // Otherwise format_kind<R> is range_format::disabled.
+  if constexpr (same_as<remove_cvref_t<ranges::range_reference_t<_Rp>>, _Rp>)
+    return range_format::disabled;
+  // 2.2 Otherwise, if the qualified-id R::key_type is valid and denotes a type:
+  else if constexpr (requires { typename _Rp::key_type; }) {
+    // 2.2.1 If the qualified-id R::mapped_type is valid and denotes a type ...
+    if constexpr (requires { typename _Rp::mapped_type; } &&
+                  // 2.2.1 ... If either U is a specialization of pair or U is a specialization
+                  // of tuple and tuple_size_v<U> == 2
+                  __fmt_tuple_like<remove_cvref_t<ranges::range_reference_t<_Rp>>>)
+      return range_format::map;
+    else
+      // 2.2.2 Otherwise format_kind<R> is range_format::set.
+      return range_format::set;
+  } else
+    // 2.3 Otherwise, format_kind<R> is range_format::sequence.
+    return range_format::sequence;
+}
+
+template <ranges::input_range _Rp>
+  requires same_as<_Rp, remove_cvref_t<_Rp>>
+constexpr range_format format_kind<_Rp> = __get_format_format<_Rp>();
+
+// This is a non-standard work-around to fix instantiation of
+//   formatter<const _CharT[N], _CharT>
+// const _CharT[N] satisfies the ranges::input_range concept.
+// remove_cvref_t<const _CharT[N]> is _CharT[N] so it does not satisfy the
+// requirement of the above specialization. Instead it will instantiate the
+// primary template, which is ill-formed.
+//
+// An alternative solution is to remove the offending formatter.
+//
+// https://godbolt.org/z/bqjhhaexx
+template <class _CharT, size_t N>
+constexpr range_format format_kind<const _CharT[N]> = range_format::disabled;
+
+template <range_format _Kp, ranges::input_range _Rp, class _CharT>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT __range_default_formatter;
+
+// Required specializations
+
+template <ranges::input_range _Rp, class _CharT>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT __range_default_formatter<range_format::sequence, _Rp, _CharT> {
+  __range_default_formatter() = delete; // TODO FMT Implement
+};
+
+template <ranges::input_range _Rp, class _CharT>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT __range_default_formatter<range_format::map, _Rp, _CharT> {
+  __range_default_formatter() = delete; // TODO FMT Implement
+};
+
+template <ranges::input_range _Rp, class _CharT>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT __range_default_formatter<range_format::set, _Rp, _CharT> {
+  __range_default_formatter() = delete; // TODO FMT Implement
+};
+
+template <range_format _Kp, ranges::input_range _Rp, class _CharT>
+  requires(_Kp == range_format::string || _Kp == range_format::debug_string)
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT __range_default_formatter<range_format::set, _Rp, _CharT> {
+  __range_default_formatter() = delete; // TODO FMT Implement
+};
+
+// Dispatcher to select the specialization based on the type of the range.
+
+template <ranges::input_range _Rp, class _CharT>
+  requires(format_kind<_Rp> != range_format::disabled && formattable<ranges::range_reference_t<_Rp>, _CharT>)
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<_Rp, _CharT>
+    : __range_default_formatter<format_kind<_Rp>, _Rp, _CharT> {};
+
+#endif //_LIBCPP_STD_VER > 20
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___FORMAT_RANGE_DEFAULT_FORMATTER_H
diff --git a/libcxx/include/__type_traits/is_specialization.h b/libcxx/include/__type_traits/is_specialization.h
new file mode 100644
--- /dev/null
+++ b/libcxx/include/__type_traits/is_specialization.h
@@ -0,0 +1,45 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___TYPE_TRAITS_IS_SPECIALIZATION
+#define _LIBCPP___TYPE_TRAITS_IS_SPECIALIZATION
+
+// This contains parts of P2098R1 but is based on MSVC STL's implementation.
+//
+// The paper has been rejected
+//   We will not pursue P2098R0 (std::is_specialization_of) at this time; we'd
+//   like to see a solution to this problem, but it requires language evolution
+//   too.
+//
+// Since it is expected a real solution will be provided in the future only the
+// minimal part is implemented.
+//
+// Note a cvref qualified _Tp is never considered a specialization.
+
+#include <__config>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 14
+
+template <class _Tp, template <class...> class _Template>
+inline constexpr bool __is_specialization_v = false; // true if and only if _Tp is a specialization of _Template
+
+template <template <class...> class _Template, class... _Args>
+inline constexpr bool __is_specialization_v<_Template<_Args...>, _Template> = true;
+
+#endif // _LIBCPP_STD_VER > 14
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___TYPE_TRAITS_IS_SPECIALIZATION
diff --git a/libcxx/include/format b/libcxx/include/format
--- a/libcxx/include/format
+++ b/libcxx/include/format
@@ -112,6 +112,35 @@
   using format_parse_context = basic_format_parse_context<char>;
   using wformat_parse_context = basic_format_parse_context<wchar_t>;
 
+  // [format.range], formatting of ranges
+  // [format.range.fmtkind], variable template format_kind
+  enum class range_format {                                     // since C++23
+    disabled,
+    map,
+    set,
+    sequence,
+    string,
+    debug_string
+  };
+
+  template<class R>
+    constexpr unspecified format_kind = unspecified;            // since C++23
+
+  template<ranges::input_range R>
+      requires same_as<R, remove_cvref_t<R>>
+    constexpr range_format format_kind<R> = see below;          // since C++23
+
+  // [format.range.fmtdef], class template range-default-formatter
+  template<range_format K, ranges::input_range R, class charT>
+    struct range-default-formatter;                             // exposition only, since C++23
+
+  // [format.range.fmtmap], [format.range.fmtset], [format.range.fmtstr],
+  // specializations for maps, sets, and strings
+  template<ranges::input_range R, class charT>
+    requires (format_kind<R> != range_format::disabled) &&
+             formattable<ranges::range_reference_t<R>, charT>
+  struct formatter<R, charT> : range-default-formatter<format_kind<R>, R, charT> { }; // since C++23
+
   // [format.arguments], arguments
   // [format.arg], class template basic_format_arg
   template<class Context> class basic_format_arg;
@@ -163,6 +192,7 @@
 #include <__format/formatter_pointer.h>
 #include <__format/formatter_string.h>
 #include <__format/parser_std_format_spec.h>
+#include <__format/range_default_formatter.h>
 #include <__format/unicode.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
diff --git a/libcxx/include/module.modulemap.in b/libcxx/include/module.modulemap.in
--- a/libcxx/include/module.modulemap.in
+++ b/libcxx/include/module.modulemap.in
@@ -845,6 +845,7 @@
       module formatter_pointer               { private header "__format/formatter_pointer.h" }
       module formatter_string                { private header "__format/formatter_string.h" }
       module parser_std_format_spec          { private header "__format/parser_std_format_spec.h" }
+      module range_default_formatter         { private header "__format/range_default_formatter.h" }
       module unicode                         { private header "__format/unicode.h" }
     }
   }
@@ -1426,6 +1427,7 @@
     module is_scoped_enum                      { private header "__type_traits/is_scoped_enum.h" }
     module is_signed                           { private header "__type_traits/is_signed.h" }
     module is_signed_integer                   { private header "__type_traits/is_signed_integer.h" }
+    module is_specialization                   { private header "__type_traits/is_specialization.h" }
     module is_standard_layout                  { private header "__type_traits/is_standard_layout.h" }
     module is_swappable                        { private header "__type_traits/is_swappable.h" }
     module is_trivial                          { private header "__type_traits/is_trivial.h" }
diff --git a/libcxx/include/type_traits b/libcxx/include/type_traits
--- a/libcxx/include/type_traits
+++ b/libcxx/include/type_traits
@@ -497,6 +497,7 @@
 #include <__type_traits/is_scalar.h>
 #include <__type_traits/is_scoped_enum.h>
 #include <__type_traits/is_signed.h>
+#include <__type_traits/is_specialization.h>
 #include <__type_traits/is_standard_layout.h>
 #include <__type_traits/is_swappable.h>
 #include <__type_traits/is_trivial.h>
diff --git a/libcxx/test/libcxx/private_headers.verify.cpp b/libcxx/test/libcxx/private_headers.verify.cpp
--- a/libcxx/test/libcxx/private_headers.verify.cpp
+++ b/libcxx/test/libcxx/private_headers.verify.cpp
@@ -342,6 +342,7 @@
 #include <__format/formatter_pointer.h> // expected-error@*:* {{use of private header from outside its module: '__format/formatter_pointer.h'}}
 #include <__format/formatter_string.h> // expected-error@*:* {{use of private header from outside its module: '__format/formatter_string.h'}}
 #include <__format/parser_std_format_spec.h> // expected-error@*:* {{use of private header from outside its module: '__format/parser_std_format_spec.h'}}
+#include <__format/range_default_formatter.h> // expected-error@*:* {{use of private header from outside its module: '__format/range_default_formatter.h'}}
 #include <__format/unicode.h> // expected-error@*:* {{use of private header from outside its module: '__format/unicode.h'}}
 #include <__functional/binary_function.h> // expected-error@*:* {{use of private header from outside its module: '__functional/binary_function.h'}}
 #include <__functional/binary_negate.h> // expected-error@*:* {{use of private header from outside its module: '__functional/binary_negate.h'}}
@@ -638,6 +639,7 @@
 #include <__type_traits/is_scoped_enum.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_scoped_enum.h'}}
 #include <__type_traits/is_signed.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_signed.h'}}
 #include <__type_traits/is_signed_integer.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_signed_integer.h'}}
+#include <__type_traits/is_specialization.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_specialization.h'}}
 #include <__type_traits/is_standard_layout.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_standard_layout.h'}}
 #include <__type_traits/is_swappable.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_swappable.h'}}
 #include <__type_traits/is_trivial.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_trivial.h'}}
diff --git a/libcxx/test/libcxx/type_traits/is_specialization.compile.pass.cpp b/libcxx/test/libcxx/type_traits/is_specialization.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/libcxx/type_traits/is_specialization.compile.pass.cpp
@@ -0,0 +1,54 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// template <class _Tp, template <class...> class _Template>
+// inline constexpr bool __is_specialization_v = true if and only if _Tp is a specialization of _Template
+//
+// Note instantiation for certain type combinations are ill-formed. These are
+// tested in is_specialization.verify.cpp.
+
+#include <type_traits>
+
+#include <array>
+#include <concepts>
+#include <string_view>
+#include <tuple>
+#include <utility>
+
+// Simple types
+static_assert(std::__is_specialization_v<std::pair<int, int>, std::pair>);
+static_assert(!std::__is_specialization_v<std::pair<int, int>, std::tuple>);
+static_assert(!std::__is_specialization_v<std::pair<int, int>, std::basic_string_view>);
+
+static_assert(std::__is_specialization_v<std::tuple<int>, std::tuple>);
+static_assert(std::__is_specialization_v<std::tuple<int, float>, std::tuple>);
+static_assert(std::__is_specialization_v<std::tuple<int, float, void*>, std::tuple>);
+
+static_assert(std::__is_specialization_v<std::string_view, std::basic_string_view>);
+static_assert(std::__is_specialization_v<std::wstring_view, std::basic_string_view>);
+
+// Nested types
+static_assert(std::__is_specialization_v<std::pair<std::tuple<int>, int>, std::pair>);
+static_assert(!std::__is_specialization_v<std::pair<std::tuple<int>, int>, std::tuple>);
+
+// cvref _Tp is no specialization.
+static_assert(!std::__is_specialization_v<const std::pair<int, int>, std::pair>);
+static_assert(!std::__is_specialization_v<volatile std::pair<int, int>, std::pair>);
+static_assert(!std::__is_specialization_v<const volatile std::pair<int, int>, std::pair>);
+
+static_assert(!std::__is_specialization_v<std::pair<int, int>&, std::pair>);
+static_assert(!std::__is_specialization_v<const std::pair<int, int>&, std::pair>);
+static_assert(!std::__is_specialization_v<volatile std::pair<int, int>&, std::pair>);
+static_assert(!std::__is_specialization_v<const volatile std::pair<int, int>&, std::pair>);
+
+static_assert(!std::__is_specialization_v<std::pair<int, int>&&, std::pair>);
+static_assert(!std::__is_specialization_v<const std::pair<int, int>&&, std::pair>);
+static_assert(!std::__is_specialization_v<volatile std::pair<int, int>&&, std::pair>);
+static_assert(!std::__is_specialization_v<const volatile std::pair<int, int>&&, std::pair>);
diff --git a/libcxx/test/libcxx/type_traits/is_specialization.verify.cpp b/libcxx/test/libcxx/type_traits/is_specialization.verify.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/libcxx/type_traits/is_specialization.verify.cpp
@@ -0,0 +1,22 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// template <class _Tp, template <class...> class _Template>
+// inline constexpr bool __is_specialization_v = true if and only if _Tp is a specialization of _Template
+//
+// Tests the ill-formed instantiations.
+
+#include <type_traits>
+
+#include <array>
+#include <utility>
+
+// expected-error@+1 {{template template argument has different template parameters than its corresponding template template parameter}}
+static_assert(!std::__is_specialization_v<std::pair<int, size_t>, std::array>);
diff --git a/libcxx/test/std/utilities/format/format.range/format.range.fmtkind/format_kind.compile.pass.cpp b/libcxx/test/std/utilities/format/format.range/format.range.fmtkind/format_kind.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/format/format.range/format.range.fmtkind/format_kind.compile.pass.cpp
@@ -0,0 +1,82 @@
+//===----------------------------------------------------------------------===//
+// 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, c++20
+// UNSUPPORTED: libcpp-has-no-incomplete-format
+
+// <format>
+
+// template<ranges::input_range R>
+//     requires same_as<R, remove_cvref_t<R>>
+//  constexpr range_format format_kind<R> = see below;
+
+#include <format>
+
+#include <array>
+#include <deque>
+#include <format>
+#include <forward_list>
+#include <list>
+#include <map>
+#include <set>
+#include <span>
+#include <vector>
+#include <unordered_map>
+#include <unordered_set>
+#include <valarray>
+
+#ifndef TEST_HAS_NO_FILESYSTEM_LIBRARY
+#  include <filesystem>
+#endif
+
+#ifndef TEST_HAS_NO_FILESYSTEM_LIBRARY
+static_assert(std::format_kind<std::filesystem::path> == std::range_format::disabled);
+#endif
+
+static_assert(std::format_kind<std::map<int, int>> == std::range_format::map);
+static_assert(std::format_kind<std::multimap<int, int>> == std::range_format::map);
+static_assert(std::format_kind<std::unordered_map<int, int>> == std::range_format::map);
+static_assert(std::format_kind<std::unordered_multimap<int, int>> == std::range_format::map);
+
+static_assert(std::format_kind<std::set<int>> == std::range_format::set);
+static_assert(std::format_kind<std::multiset<int>> == std::range_format::set);
+static_assert(std::format_kind<std::unordered_set<int>> == std::range_format::set);
+static_assert(std::format_kind<std::unordered_multiset<int>> == std::range_format::set);
+
+static_assert(std::format_kind<std::array<int, 1>> == std::range_format::sequence);
+static_assert(std::format_kind<std::vector<int>> == std::range_format::sequence);
+static_assert(std::format_kind<std::deque<int>> == std::range_format::sequence);
+static_assert(std::format_kind<std::forward_list<int>> == std::range_format::sequence);
+static_assert(std::format_kind<std::list<int>> == std::range_format::sequence);
+
+static_assert(std::format_kind<std::span<int>> == std::range_format::sequence);
+
+static_assert(std::format_kind<std::valarray<int>> == std::range_format::sequence);
+
+// [format.range.fmtkind]/3
+//   Remarks: Pursuant to [namespace.std], users may specialize format_kind for
+//   cv-unqualified program-defined types that model ranges::input_range. Such
+//   specializations shall be usable in constant expressions ([expr.const]) and
+//   have type const range_format.
+// Note only test the specializing, not all constraints.
+struct no_specialization : std::ranges::view_base {
+  using key_type = void;
+  int* begin() const;
+  int* end() const;
+};
+static_assert(std::format_kind<no_specialization> == std::range_format::set);
+
+// The struct's "contents" are the same as no_specialization.
+struct specialized : std::ranges::view_base {
+  using key_type = void;
+  int* begin() const;
+  int* end() const;
+};
+
+template <>
+constexpr std::range_format std::format_kind<specialized> = std::range_format::sequence;
+static_assert(std::format_kind<specialized> == std::range_format::sequence);
diff --git a/libcxx/test/std/utilities/format/format.range/format.range.fmtkind/format_kind.verify.cpp b/libcxx/test/std/utilities/format/format.range/format.range.fmtkind/format_kind.verify.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/format/format.range/format.range.fmtkind/format_kind.verify.cpp
@@ -0,0 +1,60 @@
+//===----------------------------------------------------------------------===//
+// 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, c++20
+// UNSUPPORTED: libcpp-has-no-incomplete-format
+
+// <format>
+
+// template<ranges::input_range R>
+//   requires same_as<R, remove_cvref_t<R>>
+// constexpr range_format format_kind<R> = see below;
+
+#include <format>
+
+#include <array>
+#include <queue>
+#include <stack>
+#include <tuple>
+#include <utility>
+
+constexpr std::range_format valid = std::format_kind<std::array<int, 1>>;
+
+// expected-error@*:* {{std::__instantiated_the_primary_template_of_format_kind<const std::array<int, 1>>}}
+constexpr std::range_format invalid_due_to_const = std::format_kind<const std::array<int, 1>>;
+
+// expected-error@*:* {{std::__instantiated_the_primary_template_of_format_kind<volatile std::array<int, 1>>}}
+constexpr std::range_format invalid_due_to_volatile = std::format_kind<volatile std::array<int, 1>>;
+
+// expected-error@*:* {{std::__instantiated_the_primary_template_of_format_kind<std::array<int, 1> &>}}
+constexpr std::range_format invalid_due_to_reference = std::format_kind<std::array<int, 1>&>;
+
+// expected-error@*:* {{std::__instantiated_the_primary_template_of_format_kind<int>}}
+constexpr std::range_format invalid_no_input_range = std::format_kind<int>;
+
+// expected-error@*:* {{std::__instantiated_the_primary_template_of_format_kind<std::stack<int>>}}
+constexpr std::range_format not_a_range_stack = std::format_kind<std::stack<int>>;
+
+// expected-error@*:* {{std::__instantiated_the_primary_template_of_format_kind<std::queue<int>>}}
+constexpr std::range_format not_a_range_queue = std::format_kind<std::queue<int>>;
+
+// expected-error@*:* {{std::__instantiated_the_primary_template_of_format_kind<std::priority_queue<int, std::vector<int>, std::less<int>>}}
+constexpr std::range_format not_a_range_priority_queue = std::format_kind<std::priority_queue<int>>;
+
+// expected-error@*:* {{std::__instantiated_the_primary_template_of_format_kind<std::pair<int, int>>}}
+constexpr std::range_format not_a_range_pair = std::format_kind<std::pair<int, int>>;
+
+// expected-error@*:* {{std::__instantiated_the_primary_template_of_format_kind<std::tuple<int>>}}
+constexpr std::range_format not_a_range_tuple_1 = std::format_kind<std::tuple<int>>;
+
+// expected-error@*:* {{std::__instantiated_the_primary_template_of_format_kind<std::tuple<int, int>>}}
+constexpr std::range_format not_a_range_tuple_2 = std::format_kind<std::tuple<int, int>>;
+
+// expected-error@*:* {{std::__instantiated_the_primary_template_of_format_kind<std::tuple<int, int, int>>}}
+constexpr std::range_format not_a_range_tuple_3 = std::format_kind<std::tuple<int, int, int>>;
+
+// valid types self defined
diff --git a/libcxx/test/std/utilities/format/format.range/format.range.fmtkind/range_format.compile.pass.cpp b/libcxx/test/std/utilities/format/format.range/format.range.fmtkind/range_format.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/format/format.range/format.range.fmtkind/range_format.compile.pass.cpp
@@ -0,0 +1,30 @@
+//===----------------------------------------------------------------------===//
+// 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, c++20
+// UNSUPPORTED: libcpp-has-no-incomplete-format
+
+// <format>
+
+// enum class range_format {
+//   disabled,
+//   map,
+//   set,
+//   sequence,
+//   string,
+//   debug_string
+// };
+
+#include <format>
+
+// test that the enumeration values exist
+static_assert(requires { std::range_format::disabled; });
+static_assert(requires { std::range_format::map; });
+static_assert(requires { std::range_format::set; });
+static_assert(requires { std::range_format::sequence; });
+static_assert(requires { std::range_format::string; });
+static_assert(requires { std::range_format::debug_string; });