diff --git a/libcxx/docs/FeatureTestMacroTable.rst b/libcxx/docs/FeatureTestMacroTable.rst
--- a/libcxx/docs/FeatureTestMacroTable.rst
+++ b/libcxx/docs/FeatureTestMacroTable.rst
@@ -286,7 +286,7 @@
     --------------------------------------------------- -----------------
     ``__cpp_lib_string_view``                           ``201803L``
     --------------------------------------------------- -----------------
-    ``__cpp_lib_syncbuf``                               *unimplemented*
+    ``__cpp_lib_syncbuf``                               ``201803L``
     --------------------------------------------------- -----------------
     ``__cpp_lib_three_way_comparison``                  *unimplemented*
     --------------------------------------------------- -----------------
diff --git a/libcxx/docs/Status/Cxx20Papers.csv b/libcxx/docs/Status/Cxx20Papers.csv
--- a/libcxx/docs/Status/Cxx20Papers.csv
+++ b/libcxx/docs/Status/Cxx20Papers.csv
@@ -3,7 +3,7 @@
 "`P0674R1 <https://wg21.link/P0674R1>`__","LWG","Extending make_shared to Support Arrays","Toronto","|Complete|","15.0"
 "","","","","","",""
 "`P0020R6 <https://wg21.link/P0020R6>`__","LWG","Floating Point Atomic","Albuquerque","",""
-"`P0053R7 <https://wg21.link/P0053R7>`__","LWG","C++ Synchronized Buffered Ostream","Albuquerque","",""
+"`P0053R7 <https://wg21.link/P0053R7>`__","LWG","C++ Synchronized Buffered Ostream","Albuquerque","|Complete|","18.0"
 "`P0202R3 <https://wg21.link/P0202R3>`__","LWG","Add constexpr modifiers to functions in <algorithm> and <utility> Headers","Albuquerque","|Complete|","12.0"
 "`P0415R1 <https://wg21.link/P0415R1>`__","LWG","Constexpr for ``std::complex``\ ","Albuquerque","|Complete|","16.0"
 "`P0439R0 <https://wg21.link/P0439R0>`__","LWG","Make ``std::memory_order``\  a scoped enumeration","Albuquerque","|Complete|",""
diff --git a/libcxx/include/CMakeLists.txt b/libcxx/include/CMakeLists.txt
--- a/libcxx/include/CMakeLists.txt
+++ b/libcxx/include/CMakeLists.txt
@@ -981,6 +981,7 @@
   string.h
   string_view
   strstream
+  syncstream
   system_error
   tgmath.h
   thread
diff --git a/libcxx/include/__std_clang_module b/libcxx/include/__std_clang_module
--- a/libcxx/include/__std_clang_module
+++ b/libcxx/include/__std_clang_module
@@ -201,6 +201,7 @@
 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
 #  include <strstream>
 #endif
+#include <syncstream>
 #include <system_error>
 #include <tgmath.h>
 #if !defined(_LIBCPP_HAS_NO_THREADS)
diff --git a/libcxx/include/iosfwd b/libcxx/include/iosfwd
--- a/libcxx/include/iosfwd
+++ b/libcxx/include/iosfwd
@@ -90,6 +90,18 @@
 using u16streampos = fpos<char_traits<char16_t>::state_type>;
 using u32streampos = fpos<char_traits<char32_t>::state_type>;
 
+template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
+    class basic_syncbuf;                          // C++20
+
+using syncbuf = basic_syncbuf<char>;              // C++20
+using wsyncbuf = basic_syncbuf<wchar_t>;          // C++20
+
+template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
+    class basic_osyncstream;                      // C++20
+
+using osyncstream = basic_osyncstream<char>;      // C++20
+using wosyncstream = basic_osyncstream<wchar_t>;  // C++20
+
 }  // std
 
 */
@@ -130,6 +142,22 @@
 typedef fpos<mbstate_t>    u16streampos;
 typedef fpos<mbstate_t>    u32streampos;
 
+#if _LIBCPP_STD_VER >= 20
+
+template <class _CharT, class _Traits = char_traits<_CharT>, class _Allocator = allocator<_CharT>>
+class basic_syncbuf;
+
+using syncbuf  = basic_syncbuf<char>;
+using wsyncbuf = basic_syncbuf<wchar_t>;
+
+template <class _CharT, class _Traits = char_traits<_CharT>, class _Allocator = allocator<_CharT>>
+class basic_osyncstream;
+
+using osyncstream  = basic_osyncstream<char>;
+using wosyncstream = basic_osyncstream<wchar_t>;
+
+#endif // _LIBCPP_STD_VER >=20
+
 // Include other forward declarations here
 template <class _Tp, class _Alloc = allocator<_Tp> >
 class _LIBCPP_TEMPLATE_VIS vector;
diff --git a/libcxx/include/syncstream b/libcxx/include/syncstream
new file mode 100644
--- /dev/null
+++ b/libcxx/include/syncstream
@@ -0,0 +1,406 @@
+// -*- C++ -*-
+//===--------------------------- sstream ----------------------------------===//
+//
+// 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_SYNCSTREAM
+#define _LIBCPP_SYNCSTREAM
+
+/*
+    syncstream synopsis
+
+#include <ostream>  // see [ostream.syn]
+
+namespace std {
+    template<class charT, class traits, class Allocator>
+    class basic_syncbuf;
+
+    using syncbuf = basic_syncbuf<char>;
+    using wsyncbuf = basic_syncbuf<wchar_t>;
+
+    template<class charT, class traits, class Allocator>
+    class basic_osyncstream;
+
+    using osyncstream = basic_osyncstream<char>;
+    using wosyncstream = basic_osyncstream<wchar_t>;
+
+    template<class charT, class traits, class Allocator>
+    class basic_syncbuf : public basic_streambuf<charT, traits> {
+    public:
+        using char_type      = charT;
+        using int_type       = typename traits::int_type;
+        using pos_type       = typename traits::pos_type;
+        using off_type       = typename traits::off_type;
+        using traits_type    = traits;
+        using allocator_type = Allocator;
+
+        using streambuf_type = basic_streambuf<charT, traits>;
+
+        // [syncstream.syncbuf.cons], construction and destruction
+        explicit basic_syncbuf(streambuf_type* obuf = nullptr)
+          : basic_syncbuf(obuf, Allocator()) {}
+        basic_syncbuf(streambuf_type*, const Allocator&);
+        basic_syncbuf(basic_syncbuf&&);
+        ~basic_syncbuf();
+
+        // [syncstream.syncbuf.assign], assignment and swap
+        basic_syncbuf& operator=(basic_syncbuf&&);
+        void swap(basic_syncbuf&);
+
+        // [syncstream.syncbuf.members], member functions
+        bool emit();
+        streambuf_type* get_wrapped() const noexcept;
+        allocator_type get_allocator() const noexcept;
+        void set_emit_on_sync(bool) noexcept;
+
+    protected:
+        // [syncstream.syncbuf.virtuals], overridden virtual functions
+        int sync() override;
+
+    private:
+        streambuf_type* wrapped;    // exposition only
+        bool emit_on_sync{};        // exposition only
+    };
+
+    // [syncstream.syncbuf.special], specialized algorithms
+    template<class charT, class traits, class Allocator>
+    void swap(basic_syncbuf<charT, traits, Allocator>&,
+              basic_syncbuf<charT, traits, Allocator>&);
+
+    template<class charT, class traits, class Allocator>
+    class basic_osyncstream : public basic_ostream<charT, traits> {
+    public:
+        using char_type   = charT;
+        using int_type    = typename traits::int_type;
+        using pos_type    = typename traits::pos_type;
+        using off_type    = typename traits::off_type;
+        using traits_type = traits;
+
+        using allocator_type = Allocator;
+        using streambuf_type = basic_streambuf<charT, traits>;
+        using syncbuf_type   = basic_syncbuf<charT, traits, Allocator>;
+
+        // [syncstream.osyncstream.cons], construction and destruction
+        basic_osyncstream(streambuf_type*, const Allocator&);
+        explicit basic_osyncstream(streambuf_type* obuf)
+          : basic_osyncstream(obuf, Allocator()) {}
+        basic_osyncstream(basic_ostream<charT, traits>& os, const Allocator& allocator)
+          : basic_osyncstream(os.rdbuf(), allocator) {}
+        explicit basic_osyncstream(basic_ostream<charT, traits>& os)
+          : basic_osyncstream(os, Allocator()) {}
+        basic_osyncstream(basic_osyncstream&&) noexcept;
+        ~basic_osyncstream();
+
+        // [syncstream.osyncstream.assign], assignment
+        basic_osyncstream& operator=(basic_osyncstream&&) noexcept;
+
+        // [syncstream.osyncstream.members], member functions
+        void emit();
+        streambuf_type* get_wrapped() const noexcept;
+        syncbuf_type* rdbuf() const noexcept { return const_cast<syncbuf_type*>(addressof(sb)); }
+
+    private:
+        syncbuf_type sb;    // exposition only
+    };
+}
+
+*/
+
+#include <__config>
+#include <iosfwd>
+#include <mutex>
+#include <ostream>
+#include <string>
+#include <unordered_map>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 20
+
+// basic_syncbuf
+
+template <class _CharT, class _Traits, class _Allocator>
+class _LIBCPP_TEMPLATE_VIS basic_syncbuf : public basic_streambuf<_CharT, _Traits> {
+public:
+  using char_type      = _CharT;
+  using traits_type    = _Traits;
+  using int_type       = typename traits_type::int_type;
+  using pos_type       = typename traits_type::pos_type;
+  using off_type       = typename traits_type::off_type;
+  using allocator_type = _Allocator;
+
+  using streambuf_type = basic_streambuf<_CharT, _Traits>;
+  using mutex_ptr_type = shared_ptr<mutex>;
+  using string_type    = basic_string<_CharT, _Traits, _Allocator>;
+
+  // [syncstream.syncbuf.cons], construction and destruction
+
+  _LIBCPP_HIDE_FROM_ABI explicit basic_syncbuf(streambuf_type* __obuf = nullptr)
+      : basic_syncbuf(__obuf, _Allocator()) {}
+
+  _LIBCPP_HIDE_FROM_ABI basic_syncbuf(streambuf_type* __obuf, _Allocator const& __alloc)
+      : __wrapped_(__obuf), __alloc_(__alloc) {
+    __make_mtx_for_ptr(__obuf);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI basic_syncbuf(basic_syncbuf&& __other)
+      : __wrapped_(std::move(__other.get_wrapped())), __alloc_(std::move(__other.get_allocator())) {
+    __other.__wrapped_ = nullptr;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI ~basic_syncbuf() {
+#  ifndef _LIBCPP_NO_EXCEPTIONS
+    try {
+#  endif // _LIBCPP_NO_EXCEPTIONS
+      emit();
+#  ifndef _LIBCPP_NO_EXCEPTIONS
+    } catch (...) {
+    }
+#  endif // _LIBCPP_NO_EXCEPTIONS
+
+    __destroy_mtx_for_ptr(__wrapped_);
+  }
+
+  // [syncstream.syncbuf.assign], assignment and swap
+
+  _LIBCPP_HIDE_FROM_ABI basic_syncbuf& operator=(basic_syncbuf&& __other) {
+    __wrapped_         = std::move(__other.get_wrapped());
+    __alloc_           = std::move(__other.get_allocator());
+    __other.__wrapped_ = nullptr;
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI void swap(basic_syncbuf&& __other) {
+    basic_syncbuf __tmp(std::move(__other));
+    __other = std::move(*this);
+    *this   = std::move(__tmp);
+  }
+
+  // [syncstream.syncbuf.members], member functions
+
+  _LIBCPP_HIDE_FROM_ABI bool emit() {
+    bool __result = true;
+    auto* __mtx   = __get_mtx_for_ptr(__wrapped_);
+
+    if (__wrapped_ == nullptr || __mtx == nullptr)
+      __result = false;
+
+    if (__result) {
+      lock_guard __guard(*__mtx);
+
+      if (this->pptr()) {
+        __result &= (__wrapped_->sputn(__str_.data(), __str_.size()) != -1);
+        this->setp(nullptr, nullptr);
+      }
+
+      if (__should_flush_)
+        __result &= (__wrapped_->pubsync() != -1);
+    }
+
+    __should_flush_ = false;
+    return __result;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI streambuf_type* get_wrapped() const noexcept { return __wrapped_; }
+
+  _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const noexcept { return __alloc_; }
+
+  _LIBCPP_HIDE_FROM_ABI void set_emit_on_sync(bool __b) noexcept { __emit_on_sync_ = __b; }
+
+protected:
+  // [syncstream.syncbuf.virtuals], overridden virtual functions
+
+  int sync() override {
+    __should_flush_ = true;
+
+    if (__emit_on_sync_ && !emit())
+      return -1;
+    return 0;
+  }
+
+  int_type overflow(int_type __c = traits_type::eof()) override {
+    if (traits_type::eq_int_type(__c, traits_type::eof()))
+      return traits_type::not_eof(__c);
+
+    if (this->pptr() == this->epptr()) {
+#  ifndef _LIBCPP_NO_EXCEPTIONS
+      try {
+#  endif // _LIBCPP_NO_EXCEPTIONS
+        __str_.resize(__str_.capacity());
+
+        char_type* __p = static_cast<char_type*>(__str_.data());
+        this->setp(__p, __p + __str_.size());
+#  ifndef _LIBCPP_NO_EXCEPTIONS
+      } catch (...) {
+        return traits_type::eof();
+      }
+#  endif // _LIBCPP_NO_EXCEPTIONS
+    }
+
+    return this->sputc(traits_type::to_char_type(__c));
+  }
+
+private:
+  streambuf_type* __wrapped_;
+  allocator_type __alloc_;
+  string_type __str_;
+  bool __emit_on_sync_;
+  bool __should_flush_;
+};
+
+struct __count_mutex_pair {
+  mutex* __pointer = nullptr;
+  size_t __count   = 0;
+};
+
+// Each basic_streambuf needs to have exactly one mutex that it corresponds to.
+// If there are 100 osyncstreams we still need each one to map to the correct mutex.
+// So, below is a global map that maps streambuf pointers to mutex. This is used in emit.
+// void* used as key so that only one instance of this function is created (no template).
+//
+// An unordered_map is used here because pointers are easy to hash, copy, and store, so
+// it makes a lot of sense to prioritize constant lookup. Additionally, using a comparison
+// operator, such as a std::map might do, is UB for unrelated pointers.
+_LIBCPP_HIDE_FROM_ABI inline unordered_map<void*, __count_mutex_pair>& __get_mtx_pair_map() {
+  static unordered_map<void*, __count_mutex_pair> __mtx_ptr_map;
+  static_assert(alignof(void*) % 4 == 0, "This pointer alignment means that the resize constant must be updated.");
+  // The hash function for a pointer will simply return the pointer. We want the
+  // number of buckets to be relatively prime to the alignment of "void*" so that
+  // elements are evenly distributed across the unordered_map.
+  __mtx_ptr_map.reserve(64 - 1);
+  return __mtx_ptr_map;
+}
+
+_LIBCPP_HIDE_FROM_ABI inline mutex& __get_map_mtx() {
+  static mutex __mtx;
+  return __mtx;
+}
+
+_LIBCPP_HIDE_FROM_ABI inline mutex* __get_mtx_for_ptr(void* __ptr) {
+  if (!__ptr)
+    return nullptr;
+
+  mutex& __mtx = __get_map_mtx();
+  lock_guard __guard(__mtx);
+
+  auto& __mtx_pair_map = __get_mtx_pair_map();
+  auto& __mtx_pair     = __mtx_pair_map[__ptr];
+  _LIBCPP_ASSERT(__mtx_pair.__pointer != nullptr, "This should never be nullptr");
+  return __mtx_pair.__pointer;
+}
+
+_LIBCPP_HIDE_FROM_ABI inline void __make_mtx_for_ptr(void* __ptr) {
+  mutex& __mtx = __get_map_mtx();
+  lock_guard __guard(__mtx);
+
+  auto& __mtx_pair_map = __get_mtx_pair_map();
+  if (!__mtx_pair_map.contains(__ptr))
+    __mtx_pair_map[__ptr] = __count_mutex_pair{new mutex, 0};
+  __mtx_pair_map[__ptr].__count += 1;
+}
+
+_LIBCPP_HIDE_FROM_ABI inline void __destroy_mtx_for_ptr(void* __ptr) {
+  if (!__ptr)
+    return;
+
+  mutex& __mtx = __get_map_mtx();
+  lock_guard __guard(__mtx);
+
+  auto& __mtx_pair_map = __get_mtx_pair_map();
+  _LIBCPP_ASSERT(__mtx_pair_map.contains(__ptr), "Expected to have already created mutex.");
+  auto& __mtx_pair = __mtx_pair_map[__ptr];
+  if (--__mtx_pair.__count == 0) {
+    delete __mtx_pair.__pointer;
+    __mtx_pair_map.erase(__ptr);
+  }
+}
+
+// basic_osyncstream
+
+template <class _CharT, class _Traits, class _Allocator>
+class _LIBCPP_TEMPLATE_VIS basic_osyncstream : public basic_ostream<_CharT, _Traits> {
+public:
+  using char_type      = _CharT;
+  using traits_type    = _Traits;
+  using int_type       = typename traits_type::int_type;
+  using pos_type       = typename traits_type::pos_type;
+  using off_type       = typename traits_type::off_type;
+  using allocator_type = _Allocator;
+
+  using streambuf_type = basic_streambuf<char_type, traits_type>;
+  using syncbuf_type   = basic_syncbuf<char_type, traits_type, allocator_type>;
+
+  // [syncstream.osyncstream.cons], construction and destruction
+
+  _LIBCPP_HIDE_FROM_ABI basic_osyncstream(streambuf_type* __obuf, allocator_type const& __alloc)
+      : basic_ostream<_CharT, _Traits>(addressof(__sb_)), __sb_(__obuf, __alloc) {}
+
+  _LIBCPP_HIDE_FROM_ABI explicit basic_osyncstream(streambuf_type* __obuf)
+      : basic_osyncstream(__obuf, allocator_type()) {}
+
+  _LIBCPP_HIDE_FROM_ABI basic_osyncstream(basic_ostream<char_type, traits_type>& __os, allocator_type const& __alloc)
+      : basic_osyncstream(__os.rdbuf(), __alloc) {}
+
+  _LIBCPP_HIDE_FROM_ABI explicit basic_osyncstream(basic_ostream<char_type, traits_type>& __os)
+      : basic_osyncstream(__os, allocator_type()) {}
+
+  _LIBCPP_HIDE_FROM_ABI basic_osyncstream(basic_osyncstream&& __other) noexcept
+      : basic_ostream<_CharT, _Traits>(addressof(__sb_)), __sb_(std::move(__other.__sb_)) {
+    this->set_rdbuf(addressof(__sb_));
+  }
+
+  _LIBCPP_HIDE_FROM_ABI ~basic_osyncstream() {
+#  ifndef _LIBCPP_NO_EXCEPTIONS
+    try {
+#  endif // _LIBCPP_NO_EXCEPTIONS
+      emit();
+#  ifndef _LIBCPP_NO_EXCEPTIONS
+    } catch (...) {
+    }
+#  endif // _LIBCPP_NO_EXCEPTIONS
+  }
+
+  // [syncstream.osyncstream.assign], assignment
+
+  _LIBCPP_HIDE_FROM_ABI basic_osyncstream& operator=(basic_osyncstream&& __other) noexcept {
+#  ifndef _LIBCPP_NO_EXCEPTIONS
+    try {
+#  endif // _LIBCPP_NO_EXCEPTIONS
+      emit();
+#  ifndef _LIBCPP_NO_EXCEPTIONS
+    } catch (...) {
+    }
+#  endif // _LIBCPP_NO_EXCEPTIONS
+
+    __sb_ = std::move(__other.__sb_);
+    return *this;
+  }
+
+  // [syncstream.osyncstream.members], member functions
+
+  _LIBCPP_HIDE_FROM_ABI void emit() {
+    if (__sb_.emit() == false)
+      this->setstate(ios::badbit);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI streambuf_type* get_wrapped() const noexcept { return __sb_.get_wrapped(); }
+
+  _LIBCPP_HIDE_FROM_ABI syncbuf_type* rdbuf() const noexcept { return const_cast<syncbuf_type*>(addressof(__sb_)); }
+
+private:
+  syncbuf_type __sb_;
+};
+
+#endif // _LIBCPP_STD_VER >= 20
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_SYNCSTREAM
diff --git a/libcxx/include/version b/libcxx/include/version
--- a/libcxx/include/version
+++ b/libcxx/include/version
@@ -401,7 +401,7 @@
 # define __cpp_lib_starts_ends_with                     201711L
 # undef  __cpp_lib_string_view
 # define __cpp_lib_string_view                          201803L
-// # define __cpp_lib_syncbuf                              201803L
+# define __cpp_lib_syncbuf                              201803L
 // # define __cpp_lib_three_way_comparison                 201907L
 # define __cpp_lib_to_address                           201711L
 # define __cpp_lib_to_array                             201907L
diff --git a/libcxx/modules/std.cppm.in b/libcxx/modules/std.cppm.in
--- a/libcxx/modules/std.cppm.in
+++ b/libcxx/modules/std.cppm.in
@@ -148,6 +148,7 @@
 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
 #  include <strstream>
 #endif
+#include <syncstream>
 #include <system_error>
 #if !defined(_LIBCPP_HAS_NO_THREADS)
 #  include <thread>
@@ -189,9 +190,6 @@
 #if __has_include(<stdfloat>)
 #  error "update the header information for <stdfloat> in libcxx/utils/generate_std_cppm_in.py"
 #endif //   __has_include(<stdfloat>)
-#if __has_include(<syncstream>)
-#  error "update the header information for <syncstream> in libcxx/utils/generate_std_cppm_in.py"
-#endif //   __has_include(<syncstream>)
 #if __has_include(<text_encoding>)
 #  error "update the header information for <text_encoding> in libcxx/utils/generate_std_cppm_in.py"
 #endif //   __has_include(<text_encoding>)
diff --git a/libcxx/modules/std/syncstream.inc b/libcxx/modules/std/syncstream.inc
--- a/libcxx/modules/std/syncstream.inc
+++ b/libcxx/modules/std/syncstream.inc
@@ -8,21 +8,19 @@
 //===----------------------------------------------------------------------===//
 
 export namespace std {
-#if 0
   using std::basic_syncbuf;
 
   // [syncstream.syncbuf.special], specialized algorithms
   using std::swap;
 
   using std::syncbuf;
-#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
   using std::wsyncbuf;
-#  endif
+#endif
   using std::basic_osyncstream;
 
   using std::osyncstream;
-#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
   using std::wosyncstream;
-#  endif
 #endif
 } // namespace std
diff --git a/libcxx/test/libcxx/transitive_includes/cxx03.csv b/libcxx/test/libcxx/transitive_includes/cxx03.csv
--- a/libcxx/test/libcxx/transitive_includes/cxx03.csv
+++ b/libcxx/test/libcxx/transitive_includes/cxx03.csv
@@ -856,6 +856,11 @@
 strstream istream
 strstream ostream
 strstream version
+syncstream iosfwd
+syncstream mutex
+syncstream ostream
+syncstream string
+syncstream unordered_map
 system_error cerrno
 system_error compare
 system_error cstddef
diff --git a/libcxx/test/libcxx/transitive_includes/cxx11.csv b/libcxx/test/libcxx/transitive_includes/cxx11.csv
--- a/libcxx/test/libcxx/transitive_includes/cxx11.csv
+++ b/libcxx/test/libcxx/transitive_includes/cxx11.csv
@@ -862,6 +862,11 @@
 strstream istream
 strstream ostream
 strstream version
+syncstream iosfwd
+syncstream mutex
+syncstream ostream
+syncstream string
+syncstream unordered_map
 system_error cerrno
 system_error compare
 system_error cstddef
diff --git a/libcxx/test/libcxx/transitive_includes/cxx14.csv b/libcxx/test/libcxx/transitive_includes/cxx14.csv
--- a/libcxx/test/libcxx/transitive_includes/cxx14.csv
+++ b/libcxx/test/libcxx/transitive_includes/cxx14.csv
@@ -864,6 +864,11 @@
 strstream istream
 strstream ostream
 strstream version
+syncstream iosfwd
+syncstream mutex
+syncstream ostream
+syncstream string
+syncstream unordered_map
 system_error cerrno
 system_error compare
 system_error cstddef
diff --git a/libcxx/test/libcxx/transitive_includes/cxx17.csv b/libcxx/test/libcxx/transitive_includes/cxx17.csv
--- a/libcxx/test/libcxx/transitive_includes/cxx17.csv
+++ b/libcxx/test/libcxx/transitive_includes/cxx17.csv
@@ -864,6 +864,11 @@
 strstream istream
 strstream ostream
 strstream version
+syncstream iosfwd
+syncstream mutex
+syncstream ostream
+syncstream string
+syncstream unordered_map
 system_error cerrno
 system_error compare
 system_error cstddef
diff --git a/libcxx/test/libcxx/transitive_includes/cxx20.csv b/libcxx/test/libcxx/transitive_includes/cxx20.csv
--- a/libcxx/test/libcxx/transitive_includes/cxx20.csv
+++ b/libcxx/test/libcxx/transitive_includes/cxx20.csv
@@ -870,6 +870,11 @@
 strstream istream
 strstream ostream
 strstream version
+syncstream iosfwd
+syncstream mutex
+syncstream ostream
+syncstream string
+syncstream unordered_map
 system_error cerrno
 system_error compare
 system_error cstddef
diff --git a/libcxx/test/libcxx/transitive_includes/cxx23.csv b/libcxx/test/libcxx/transitive_includes/cxx23.csv
--- a/libcxx/test/libcxx/transitive_includes/cxx23.csv
+++ b/libcxx/test/libcxx/transitive_includes/cxx23.csv
@@ -620,6 +620,11 @@
 strstream istream
 strstream ostream
 strstream version
+syncstream iosfwd
+syncstream mutex
+syncstream ostream
+syncstream string
+syncstream unordered_map
 system_error cerrno
 system_error compare
 system_error cstddef
diff --git a/libcxx/test/libcxx/transitive_includes/cxx26.csv b/libcxx/test/libcxx/transitive_includes/cxx26.csv
--- a/libcxx/test/libcxx/transitive_includes/cxx26.csv
+++ b/libcxx/test/libcxx/transitive_includes/cxx26.csv
@@ -620,6 +620,11 @@
 strstream istream
 strstream ostream
 strstream version
+syncstream iosfwd
+syncstream mutex
+syncstream ostream
+syncstream string
+syncstream unordered_map
 system_error cerrno
 system_error compare
 system_error cstddef
diff --git a/libcxx/test/std/input.output/syncstream/osyncstream/assign.pass.cpp b/libcxx/test/std/input.output/syncstream/osyncstream/assign.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/input.output/syncstream/osyncstream/assign.pass.cpp
@@ -0,0 +1,67 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// <syncstream>
+
+// template <class charT, class traits, class Allocator>
+// class basic_osyncstream;
+
+// basic_osyncstream& operator=(basic_osyncstream&& rhs) noexcept;
+
+#include <syncstream>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <class T>
+struct test_allocator : std::allocator<T> {
+  int id;
+  int moves  = 0;
+  int copies = 0;
+
+  test_allocator(int id = 0) : id(id) {}
+  test_allocator(test_allocator const& other) : id(other.id), moves(other.moves), copies(other.copies) {}
+  test_allocator(test_allocator&& other)
+      : id(std::move(other.id)), moves(std::move(other.moves)), copies(std::move(other.copies)) {}
+};
+
+template <class T>
+class test_buf : public std::basic_streambuf<T> {};
+
+template <class CharT>
+void test_assign() {
+  using OS = std::basic_osyncstream<CharT, std::char_traits<CharT>, test_allocator<CharT>>;
+
+  test_buf<CharT> base;
+  test_allocator<CharT> alloc(42);
+  OS out1(&base, alloc);
+  typename OS::syncbuf_type* buff1 = out1.rdbuf();
+
+  assert(out1.get_wrapped() == &base);
+  assert(buff1->get_wrapped() == &base);
+
+  OS out2                          = std::move(out1);
+  typename OS::syncbuf_type* buff2 = out2.rdbuf();
+
+  assert(out2.get_wrapped() == &base);
+  assert(buff2->get_wrapped() == &base);
+  assert(buff2->get_allocator().id == alloc.id);
+  assert(out1.get_wrapped() == nullptr);
+  assert(buff1->get_wrapped() == nullptr);
+}
+
+int main(int, char**) {
+  test_assign<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test_assign<wchar_t>();
+#endif
+
+  return 0;
+}
diff --git a/libcxx/test/std/input.output/syncstream/osyncstream/const.pass.cpp b/libcxx/test/std/input.output/syncstream/osyncstream/const.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/input.output/syncstream/osyncstream/const.pass.cpp
@@ -0,0 +1,109 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// <syncstream>
+
+// template <class charT, class traits, class Allocator>
+// class basic_osyncstream;
+
+// basic_osyncstream(streambuf_type* buf, const Allocator& allocator);
+// basic_osyncstream(basic_osyncstream&& other) noexcept;
+
+#include <syncstream>
+#include <sstream>
+#include <cassert>
+#include <iostream>
+
+#include "test_macros.h"
+
+template <class T>
+struct test_allocator : std::allocator<T> {
+  int id;
+  int moves  = 0;
+  int copies = 0;
+
+  test_allocator(int id = 0) : id(id) {}
+  test_allocator(test_allocator const& other) : id(other.id), moves(other.moves), copies(other.copies) {}
+  test_allocator(test_allocator&& other)
+      : id(std::move(other.id)), moves(std::move(other.moves)), copies(std::move(other.copies)) {}
+};
+
+template <class T>
+class test_buf : public std::basic_streambuf<T> {};
+
+template <class CharT>
+void test_const() {
+  using OS = std::basic_osyncstream<CharT, std::char_traits<CharT>, test_allocator<CharT>>;
+
+  test_buf<CharT> base;
+  test_allocator<CharT> alloc(42);
+  OS out(&base, alloc);
+  typename OS::syncbuf_type* buff = out.rdbuf();
+
+  assert(out.get_wrapped() == &base);
+  assert(buff->get_wrapped() == &base);
+  assert(buff->get_allocator().id == alloc.id);
+};
+
+template <class CharT>
+void test_rvalue() {
+  using OS = std::basic_osyncstream<CharT, std::char_traits<CharT>, test_allocator<CharT>>;
+
+  test_buf<CharT> base;
+  test_allocator<CharT> alloc(42);
+  OS out1(&base, alloc);
+  typename OS::syncbuf_type* buff1 = out1.rdbuf();
+
+  assert(out1.get_wrapped() == &base);
+  assert(buff1->get_wrapped() == &base);
+
+  OS out2(std::move(out1));
+  typename OS::syncbuf_type* buff2 = out2.rdbuf();
+
+  assert(out2.get_wrapped() == &base);
+  assert(buff2->get_wrapped() == &base);
+  assert(buff2->get_allocator().id == alloc.id);
+  assert(out1.get_wrapped() == nullptr);
+  assert(buff1->get_wrapped() == nullptr);
+}
+
+template <class CharT>
+void test_dest() {
+  using OS = std::basic_osyncstream<CharT, std::char_traits<CharT>, std::allocator<CharT>>;
+  using SS = std::basic_ostringstream<CharT>;
+  CharT c  = 'f';
+
+  SS ss;
+  {
+    OS out(ss);
+    out << c;
+    assert(ss.str().empty());
+  }
+  assert(ss.str()[0] == c);
+}
+
+int main(int, char**) {
+  test_const<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test_const<wchar_t>();
+#endif
+
+  test_rvalue<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test_rvalue<wchar_t>();
+#endif
+
+  test_dest<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test_dest<wchar_t>();
+#endif
+
+  return 0;
+}
diff --git a/libcxx/test/std/input.output/syncstream/osyncstream/members.pass.cpp b/libcxx/test/std/input.output/syncstream/osyncstream/members.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/input.output/syncstream/osyncstream/members.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
+
+// <syncstream>
+
+// template <class charT, class traits, class Allocator>
+// class basic_osyncstream;
+
+// void emit();
+// streambuf_type* get_wrapped() const noexcept;
+
+#include <syncstream>
+#include <sstream>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <class T>
+class test_buf : public std::basic_streambuf<T> {};
+
+template <class CharT>
+void test_emit() {
+  using OS = std::basic_osyncstream<CharT, std::char_traits<CharT>, std::allocator<CharT>>;
+  using SS = std::basic_ostringstream<CharT>;
+  CharT c  = 'f';
+
+  SS ss;
+  OS out(ss);
+  out << c;
+  assert(ss.str().empty());
+  out.emit();
+  assert(ss.str()[0] == c);
+}
+
+template <class CharT>
+void test_get_wrapped() {
+  using OS = std::basic_osyncstream<CharT, std::char_traits<CharT>, std::allocator<CharT>>;
+
+  test_buf<CharT> base;
+  std::allocator<CharT> alloc;
+  OS out(&base, alloc);
+  assert(out.get_wrapped() == &base);
+  ASSERT_NOEXCEPT(out.get_wrapped());
+}
+
+template <class CharT>
+void test_rdbuf() {
+  using OS = std::basic_osyncstream<CharT, std::char_traits<CharT>, std::allocator<CharT>>;
+
+  test_buf<CharT> base;
+  std::allocator<CharT> alloc;
+  OS out(&base, alloc);
+  assert(out.rdbuf() != nullptr);
+  ASSERT_SAME_TYPE(decltype(out.rdbuf()), std::basic_syncbuf<CharT, std::char_traits<CharT>, std::allocator<CharT>>*);
+  ASSERT_NOEXCEPT(out.rdbuf());
+}
+
+int main(int, char**) {
+  test_emit<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test_emit<wchar_t>();
+#endif
+
+  test_get_wrapped<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test_get_wrapped<wchar_t>();
+#endif
+
+  test_rdbuf<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test_rdbuf<wchar_t>();
+#endif
+
+  return 0;
+}
diff --git a/libcxx/test/std/input.output/syncstream/osyncstream/thread/basic.pass.cpp b/libcxx/test/std/input.output/syncstream/osyncstream/thread/basic.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/input.output/syncstream/osyncstream/thread/basic.pass.cpp
@@ -0,0 +1,64 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// <syncstream>
+
+// template <class charT, class traits, class Allocator>
+// class basic_osyncstream;
+
+// void emit();
+// streambuf_type* get_wrapped() const noexcept;
+
+#include <syncstream>
+#include <sstream>
+#include <mutex>
+#include <thread>
+#include <cassert>
+#include <iostream>
+
+#include "test_macros.h"
+
+using ms = std::chrono::milliseconds;
+using OS = std::basic_osyncstream<char, std::char_traits<char>, std::allocator<char>>;
+
+static std::basic_ostringstream<char> ss;
+static const char a = 'a';
+static const char b = 'b';
+static const char c = 'c';
+static const char d = 'd';
+
+void f1() {
+  OS out(ss);
+  out << a;
+  std::this_thread::sleep_for(ms(250));
+  out << b;
+}
+
+void f2() {
+  OS out(ss);
+  out << c;
+  out << d;
+}
+
+void test_mutlithread() {
+  std::thread t1(f1);
+  std::thread t2(f2);
+  t1.join();
+  t2.join();
+
+  assert(strcmp(ss.str().data(), "cdab"));
+}
+
+int main(int, char**) {
+  // tested with char only for now
+  test_mutlithread();
+
+  return 0;
+}
diff --git a/libcxx/test/std/input.output/syncstream/osyncstream/thread/several_threads.pass.cpp b/libcxx/test/std/input.output/syncstream/osyncstream/thread/several_threads.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/input.output/syncstream/osyncstream/thread/several_threads.pass.cpp
@@ -0,0 +1,169 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// <syncstream>
+
+// template <class charT, class traits, class Allocator>
+// class basic_osyncstream;
+
+#include <cassert>
+#include <chrono>
+#include <mutex>
+#include <sstream>
+#include <string>
+#include <syncstream>
+#include <thread>
+#include <unordered_set>
+#include <vector>
+
+#include "test_macros.h"
+
+using OS = std::basic_osyncstream<char, std::char_traits<char>, std::allocator<char>>;
+
+static std::basic_ostringstream<char> ss;
+static std::unordered_multiset<std::string> test_strings = {
+    "C++",
+    "is",
+    "a",
+    "general-purpose",
+    "programming",
+    "language",
+    "created",
+    "by",
+    "Bjarne",
+    "Stroustrup",
+    "as",
+    "an",
+    "extension",
+    "of",
+    "the",
+    "C",
+    "programming",
+    "language,",
+    "or",
+    "C",
+    "with",
+    "Classes",
+    "The",
+    "language",
+    "has",
+    "expanded",
+    "significantly",
+    "over",
+    "time,",
+    "and",
+    "modern",
+    "C++",
+    "has",
+    "object-oriented,",
+    "generic,",
+    "and",
+    "functional",
+    "features",
+    "in",
+    "addition",
+    "to",
+    "facilities",
+    "for",
+    "low-level",
+    "memory",
+    "manipulation.",
+    "It",
+    "is",
+    "almost",
+    "always",
+    "implemented",
+    "as",
+    "a",
+    "compiled",
+    "language,",
+    "and",
+    "many",
+    "vendors",
+    "provide",
+    "C++",
+    "compilers,",
+    "including",
+    "the",
+    "Free",
+    "Software",
+    "Foundation,",
+    "LLVM,",
+    "Microsoft,",
+    "Intel,",
+    "and",
+    "IBM,",
+    "so",
+    "it",
+    "is",
+    "available",
+    "on",
+    "many",
+    "platforms."};
+
+void f(std::string text) {
+  OS out(ss);
+  out << text;
+}
+
+void test() {
+  ss = std::basic_ostringstream<char>();
+  std::vector<std::thread> threads;
+  for (std::string const& word : test_strings)
+    threads.push_back(std::thread(f, word));
+  for (size_t i = 0; i < test_strings.size(); (void)++i)
+    threads[i].join();
+
+  std::string output = ss.str();
+  for (std::string const& word : test_strings)
+    assert(output.find(word) != std::string::npos);
+}
+
+static std::basic_ostringstream<char> ss2;
+
+void simple_fn() {
+  OS out(ss2);
+  out << "X";
+}
+
+unsigned measure_average_operation(unsigned thread_count) {
+  std::vector<std::thread> threads;
+  threads.reserve(thread_count);
+  auto start = std::chrono::high_resolution_clock::now();
+  for (unsigned i = 0; i < thread_count; ++i)
+    threads.push_back(std::thread(simple_fn));
+  for (unsigned i = 0; i < thread_count; ++i)
+    threads[i].join();
+  auto end            = std::chrono::high_resolution_clock::now();
+  auto total_duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();
+  return total_duration / thread_count;
+}
+
+// TODO: this isn't a great test because the overhead of everything else if far more than any
+// performance issues syncstream might cause.
+void test_constant_performance() {
+  // Make sure that doing 10x the work takes no longer than 10x the time.
+  unsigned ten_threads      = measure_average_operation(10);
+  unsigned hundred_threads  = measure_average_operation(100);
+  unsigned thousand_threads = measure_average_operation(1000);
+  assert(ten_threads * 10 > hundred_threads);
+  assert(hundred_threads * 10 > thousand_threads);
+}
+
+int main(int, char**) {
+  // The more we test, the more likely we catch an error
+  for (size_t i = 0; i < 10000; ++i)
+    test();
+
+  // Test that the complexity is linear (adding x threads takes roughly x times longer).
+  test_constant_performance();
+
+  return 0;
+}
diff --git a/libcxx/test/std/input.output/syncstream/osyncstream/types.pass.cpp b/libcxx/test/std/input.output/syncstream/osyncstream/types.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/input.output/syncstream/osyncstream/types.pass.cpp
@@ -0,0 +1,50 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// <iosfwd>
+// <syncstream>
+
+#include <iosfwd>
+#include <syncstream>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <class CharT>
+void test_member_types() {
+  using Buf = std::basic_syncbuf<CharT>;
+  using OSS = std::basic_osyncstream<CharT>;
+
+  ASSERT_SAME_TYPE(typename Buf::char_type, CharT);
+  ASSERT_SAME_TYPE(typename Buf::traits_type, std::char_traits<CharT>);
+  ASSERT_SAME_TYPE(typename Buf::allocator_type, std::allocator<CharT>);
+
+  ASSERT_SAME_TYPE(typename OSS::char_type, CharT);
+  ASSERT_SAME_TYPE(typename OSS::traits_type, std::char_traits<CharT>);
+  ASSERT_SAME_TYPE(typename OSS::allocator_type, std::allocator<CharT>);
+}
+
+int main(int, char**) {
+  ASSERT_SAME_TYPE(std::syncbuf, std::basic_syncbuf<char>);
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  ASSERT_SAME_TYPE(std::wsyncbuf, std::basic_syncbuf<wchar_t>);
+#endif
+  ASSERT_SAME_TYPE(std::osyncstream, std::basic_osyncstream<char>);
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  ASSERT_SAME_TYPE(std::wosyncstream, std::basic_osyncstream<wchar_t>);
+#endif
+
+  test_member_types<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test_member_types<wchar_t>();
+#endif
+
+  return 0;
+}
diff --git a/libcxx/test/std/input.output/syncstream/syncbuf/assign.pass.cpp b/libcxx/test/std/input.output/syncstream/syncbuf/assign.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/input.output/syncstream/syncbuf/assign.pass.cpp
@@ -0,0 +1,112 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// <syncstream>
+
+// template <class charT, class traits, class Allocator>
+// class basic_syncbuf;
+
+// basic_syncbuf& operator=(basic_syncbuf&& rhs) noexcept;
+// void swap(basic_syncbuf& other) noexcept;
+
+#include <syncstream>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <class T>
+class test_buf : public std::basic_streambuf<T> {
+public:
+  int id;
+
+  test_buf(int id = 0) : id(id) {}
+
+  T* _pptr() { return this->pptr(); }
+};
+
+template <class T, class Alloc = std::allocator<T>>
+class test_syncbuf : public std::basic_syncbuf<T, std::char_traits<T>, Alloc> {
+  using Base = std::basic_syncbuf<T, std::char_traits<T>, Alloc>;
+
+public:
+  test_syncbuf() = default;
+
+  test_syncbuf(test_buf<T>* buf, Alloc alloc) : Base(buf, alloc) {}
+
+  test_syncbuf(typename Base::streambuf_type* buf, Alloc alloc) : Base(buf, alloc) {}
+
+  void _setp(T* begin, T* end) { return this->setp(begin, end); }
+};
+
+template <class CharT>
+void test_emit_on_assign() {
+  CharT arr[3] = {'a', 'b', 'c'};
+  CharT* ptr   = arr;
+
+  test_buf<CharT> base;
+  std::allocator<CharT> alloc;
+  test_syncbuf<CharT> buff(&base, alloc);
+
+  buff._setp(ptr, ptr + 3);
+  assert(base._pptr() == nullptr);
+  buff = test_syncbuf<CharT>();
+  assert(buff.get_wrapped() == nullptr);
+  CharT* pptr = base._pptr();
+  while (pptr) {
+    assert(*pptr++ == *ptr++);
+  }
+}
+
+template <class CharT>
+void test_assign() {
+  using BuffT = std::basic_syncbuf<CharT, std::char_traits<CharT>, std::allocator<CharT>>;
+
+  test_syncbuf<CharT> base;
+  std::allocator<CharT> alloc;
+  BuffT buff1(&base, alloc);
+  BuffT buff2 = std::move(buff1);
+
+  assert(buff1.get_wrapped() == nullptr);
+  assert(buff2.get_wrapped() == &base);
+
+  test_emit_on_assign<CharT>();
+
+  // Also LWG issue?
+  // assert(buff1.rdbuf()->pbase() == buff1.rdbuf()->pptr());
+}
+
+template <class CharT>
+void test_swap() {
+  using BuffT = std::basic_syncbuf<CharT, std::char_traits<CharT>, std::allocator<CharT>>;
+
+  test_syncbuf<CharT> base1;
+  test_syncbuf<CharT> base2;
+  std::allocator<CharT> alloc;
+  BuffT buff1(&base1, alloc);
+  BuffT buff2(&base2, alloc);
+  buff1.swap(std::move(buff2));
+
+  assert(buff1.get_wrapped() == &base2);
+  assert(buff2.get_wrapped() == &base1);
+}
+
+int main(int, char**) {
+  test_assign<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test_assign<wchar_t>();
+#endif
+
+  test_swap<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test_swap<wchar_t>();
+#endif
+
+  return 0;
+}
diff --git a/libcxx/test/std/input.output/syncstream/syncbuf/cons.pass.cpp b/libcxx/test/std/input.output/syncstream/syncbuf/cons.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/input.output/syncstream/syncbuf/cons.pass.cpp
@@ -0,0 +1,79 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// <syncstream>
+
+// template <class charT, class traits, class Allocator>
+// class basic_syncbuf;
+
+// basic_syncbuf(streambuf_type* obuf, const Allocator& allocator);
+// basic_syncbuf(basic_syncbuf&& other);
+
+#include <syncstream>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <class T>
+struct test_allocator : std::allocator<T> {
+  int id;
+  int moves  = 0;
+  int copies = 0;
+
+  test_allocator(int id = 0) : id(id) {}
+  test_allocator(test_allocator const& other) : id(other.id), moves(other.moves), copies(other.copies) {}
+  test_allocator(test_allocator&& other)
+      : id(std::move(other.id)), moves(std::move(other.moves)), copies(std::move(other.copies)) {}
+};
+
+template <class T>
+class test_buf : public std::basic_streambuf<T> {};
+
+template <class CharT>
+void test_streambuf_const() {
+  using BuffT = std::basic_syncbuf<CharT, std::char_traits<CharT>, test_allocator<CharT>>;
+
+  test_buf<CharT> base;
+  test_allocator<CharT> alloc(42);
+  BuffT buff(&base, alloc);
+
+  assert(buff.get_wrapped() == &base);
+  assert(buff.get_allocator().id == alloc.id);
+}
+
+template <class CharT>
+void test_move_const() {
+  using BuffT = std::basic_syncbuf<CharT, std::char_traits<CharT>, test_allocator<CharT>>;
+
+  test_buf<CharT> base;
+  test_allocator<CharT> alloc(42);
+  BuffT buff1(&base, alloc);
+  BuffT buff2(std::move(buff1));
+
+  assert(buff1.get_wrapped() == nullptr);
+  assert(buff2.get_wrapped() == &base);
+
+  // LWG issue?
+  // assert(buff1.rdbuf()->pbase() == buff1.rdbuf()->pptr());
+}
+
+int main(int, char**) {
+  test_streambuf_const<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test_streambuf_const<wchar_t>();
+#endif
+
+  test_move_const<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test_move_const<wchar_t>();
+#endif
+
+  return 0;
+}
diff --git a/libcxx/test/std/input.output/syncstream/syncbuf/members.pass.cpp b/libcxx/test/std/input.output/syncstream/syncbuf/members.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/input.output/syncstream/syncbuf/members.pass.cpp
@@ -0,0 +1,114 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// <syncstream>
+
+// template <class charT, class traits, class Allocator>
+// class basic_syncbuf;
+
+// basic_syncbuf(streambuf_type* obuf, const Allocator& allocator);
+// basic_syncbuf(basic_syncbuf&& other);
+
+#include <syncstream>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <class T>
+class test_buf : public std::basic_streambuf<T> {
+public:
+  int id;
+
+  test_buf(int id = 0) : id(id) {}
+
+  T* _pptr() { return this->pptr(); }
+};
+
+template <class T, class Alloc = std::allocator<T>>
+class test_syncbuf : public std::basic_syncbuf<T, std::char_traits<T>, Alloc> {
+public:
+  test_syncbuf(test_buf<T>* buf, Alloc alloc) : std::basic_syncbuf<T, std::char_traits<T>, Alloc>(buf, alloc) {}
+
+  void _setp(T* begin, T* end) { return this->setp(begin, end); }
+};
+
+template <class T>
+struct test_allocator : std::allocator<T> {
+  int id;
+  test_allocator(int id = 0) : id(id) {}
+};
+
+template <class CharT>
+void test_emit() {
+  // We do this because we want to be able to any CharT
+  CharT arr[3] = {'a', 'b', 'c'};
+  CharT* ptr   = arr;
+
+  test_buf<CharT> base;
+  std::allocator<CharT> alloc;
+  test_syncbuf<CharT> buff(&base, alloc);
+
+  buff._setp(ptr, ptr + 3);
+  assert(base._pptr() == nullptr);
+  buff.emit();
+  CharT* pptr = base._pptr();
+  while (pptr) {
+    assert(*pptr++ == *ptr++);
+  }
+}
+
+template <class T>
+void test_get_wrapped() {
+  test_buf<T> base(42);
+  std::allocator<T> alloc;
+  test_syncbuf<T> buff(&base, alloc);
+  assert(static_cast<test_buf<T>*>(buff.get_wrapped())->id == 42);
+  ASSERT_NOEXCEPT(buff.get_wrapped());
+}
+
+template <class T>
+void test_get_allocator() {
+  test_buf<T> base;
+  test_allocator<T> alloc(42);
+  test_syncbuf<T, test_allocator<T>> buff(&base, alloc);
+  assert(buff.get_allocator().id == 42);
+  ASSERT_NOEXCEPT(buff.get_allocator());
+}
+
+template <class T>
+void test_set_emit_on_sync() {
+  // set_emit_on_sync tested in sync
+  test_syncbuf<T, std::allocator<T>> buff(nullptr, std::allocator<T>());
+  ASSERT_NOEXCEPT(buff.set_emit_on_sync(false));
+}
+
+int main(int, char**) {
+  test_emit<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test_emit<wchar_t>();
+#endif
+
+  test_get_wrapped<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test_get_wrapped<wchar_t>();
+#endif
+
+  test_get_allocator<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test_get_allocator<wchar_t>();
+#endif
+
+  test_set_emit_on_sync<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test_set_emit_on_sync<wchar_t>();
+#endif
+
+  return 0;
+}
diff --git a/libcxx/test/std/input.output/syncstream/syncbuf/special.pass.cpp b/libcxx/test/std/input.output/syncstream/syncbuf/special.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/input.output/syncstream/syncbuf/special.pass.cpp
@@ -0,0 +1,49 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// <syncstream>
+
+// template <class charT, class traits, class Allocator>
+// class basic_syncbuf;
+
+// basic_syncbuf(streambuf_type* obuf, const Allocator& allocator);
+// basic_syncbuf(basic_syncbuf&& other);
+
+#include <syncstream>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <class T>
+class test_streambuf : public std::basic_streambuf<T> {};
+
+template <class CharT>
+void test_swap() {
+  using BuffT = std::basic_syncbuf<CharT, std::char_traits<CharT>, std::allocator<CharT>>;
+
+  test_streambuf<CharT> base1;
+  test_streambuf<CharT> base2;
+  std::allocator<CharT> alloc;
+  BuffT buff1(&base1, alloc);
+  BuffT buff2(&base2, alloc);
+  std::swap(buff1, buff2);
+
+  assert(buff1.get_wrapped() == &base2);
+  assert(buff2.get_wrapped() == &base1);
+}
+
+int main(int, char**) {
+  test_swap<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test_swap<wchar_t>();
+#endif
+
+  return 0;
+}
diff --git a/libcxx/test/std/input.output/syncstream/syncbuf/virtuals.pass.cpp b/libcxx/test/std/input.output/syncstream/syncbuf/virtuals.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/input.output/syncstream/syncbuf/virtuals.pass.cpp
@@ -0,0 +1,69 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// <syncstream>
+
+// template <class charT, class traits, class Allocator>
+// class basic_syncbuf;
+
+// basic_syncbuf(streambuf_type* obuf, const Allocator& allocator);
+// basic_syncbuf(basic_syncbuf&& other);
+
+#include <syncstream>
+#include <sstream>
+#include <iostream>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <class T>
+class test_buf : public std::basic_streambuf<T> {
+public:
+  T* _pbase() { return this->pbase(); }
+};
+
+template <class T>
+class test_syncbuf : public std::basic_syncbuf<T, std::char_traits<T>, std::allocator<T>> {
+public:
+  test_syncbuf(test_buf<T>* buf, std::allocator<T> alloc)
+      : std::basic_syncbuf<T, std::char_traits<T>, std::allocator<T>>(buf, alloc) {}
+
+  int _sync() { return this->sync(); }
+};
+
+template <class CharT>
+void test_sync(bool emit_on_sync) {
+  std::basic_ostringstream<CharT> ss;
+  test_buf<CharT>* base = reinterpret_cast<test_buf<CharT>*>(ss.rdbuf());
+  std::allocator<CharT> alloc;
+  test_syncbuf<CharT> buff(base, alloc);
+  std::basic_ostream<CharT> out(&buff);
+
+  buff.set_emit_on_sync(emit_on_sync);
+  out << 'a';
+  assert(base->_pbase() == nullptr);
+  assert(buff._sync() == 0);
+
+  if (emit_on_sync)
+    assert(*base->_pbase() == 'a');
+  else
+    assert(base->_pbase() == nullptr);
+}
+
+int main(int, char**) {
+  test_sync<char>(true);
+  test_sync<char>(false);
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test_sync<wchar_t>(true);
+  test_sync<wchar_t>(false);
+#endif
+
+  return 0;
+}
diff --git a/libcxx/test/std/language.support/support.limits/support.limits.general/syncstream.version.compile.pass.cpp b/libcxx/test/std/language.support/support.limits/support.limits.general/syncstream.version.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/language.support/support.limits/support.limits.general/syncstream.version.compile.pass.cpp
@@ -0,0 +1,71 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
+//
+// clang-format off
+
+// <syncstream>
+
+// Test the feature test macros defined by <syncstream>
+
+/*  Constant             Value
+    __cpp_lib_syncbuf    201803L [C++20]
+*/
+
+#include <syncstream>
+#include "test_macros.h"
+
+#if TEST_STD_VER < 14
+
+# ifdef __cpp_lib_syncbuf
+#   error "__cpp_lib_syncbuf should not be defined before c++20"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_syncbuf
+#   error "__cpp_lib_syncbuf should not be defined before c++20"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifdef __cpp_lib_syncbuf
+#   error "__cpp_lib_syncbuf should not be defined before c++20"
+# endif
+
+#elif TEST_STD_VER == 20
+
+# ifndef __cpp_lib_syncbuf
+#   error "__cpp_lib_syncbuf should be defined in c++20"
+# endif
+# if __cpp_lib_syncbuf != 201803L
+#   error "__cpp_lib_syncbuf should have the value 201803L in c++20"
+# endif
+
+#elif TEST_STD_VER == 23
+
+# ifndef __cpp_lib_syncbuf
+#   error "__cpp_lib_syncbuf should be defined in c++23"
+# endif
+# if __cpp_lib_syncbuf != 201803L
+#   error "__cpp_lib_syncbuf should have the value 201803L in c++23"
+# endif
+
+#elif TEST_STD_VER > 23
+
+# ifndef __cpp_lib_syncbuf
+#   error "__cpp_lib_syncbuf should be defined in c++26"
+# endif
+# if __cpp_lib_syncbuf != 201803L
+#   error "__cpp_lib_syncbuf should have the value 201803L in c++26"
+# endif
+
+#endif // TEST_STD_VER > 23
+
diff --git a/libcxx/test/std/language.support/support.limits/support.limits.general/syncstream.version.pass.cpp b/libcxx/test/std/language.support/support.limits/support.limits.general/syncstream.version.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/language.support/support.limits/support.limits.general/syncstream.version.pass.cpp
@@ -0,0 +1,61 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
+
+// <syncstream>
+
+// Test the feature test macros defined by <syncstream>
+
+/*  Constant             Value
+    __cpp_lib_syncbuf    201803L [C++20]
+*/
+
+#include <syncstream>
+#include "test_macros.h"
+
+#if TEST_STD_VER < 14
+
+#  ifdef __cpp_lib_syncbuf
+#    error "__cpp_lib_syncbuf should not be defined before c++20"
+#  endif
+
+#elif TEST_STD_VER == 14
+
+#  ifdef __cpp_lib_syncbuf
+#    error "__cpp_lib_syncbuf should not be defined before c++20"
+#  endif
+
+#elif TEST_STD_VER == 17
+
+#  ifdef __cpp_lib_syncbuf
+#    error "__cpp_lib_syncbuf should not be defined before c++20"
+#  endif
+
+#elif TEST_STD_VER == 20
+
+#  ifndef __cpp_lib_syncbuf
+#    error "__cpp_lib_syncbuf should be defined in c++20"
+#  endif
+#  if __cpp_lib_syncbuf != 201803L
+#    error "__cpp_lib_syncbuf should have the value 201803L in c++20"
+#  endif
+
+#elif TEST_STD_VER > 20
+
+#  ifndef __cpp_lib_syncbuf
+#    error "__cpp_lib_syncbuf should be defined in c++2b"
+#  endif
+#  if __cpp_lib_syncbuf != 201803L
+#    error "__cpp_lib_syncbuf should have the value 201803L in c++2b"
+#  endif
+
+#endif // TEST_STD_VER > 20
+
+int main(int, char**) { return 0; }
diff --git a/libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp b/libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp
--- a/libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp
+++ b/libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp
@@ -3822,17 +3822,11 @@
 #   error "__cpp_lib_submdspan should not be defined before c++26"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_syncbuf
-#     error "__cpp_lib_syncbuf should be defined in c++20"
-#   endif
-#   if __cpp_lib_syncbuf != 201803L
-#     error "__cpp_lib_syncbuf should have the value 201803L in c++20"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_syncbuf
-#     error "__cpp_lib_syncbuf should not be defined because it is unimplemented in libc++!"
-#   endif
+# ifndef __cpp_lib_syncbuf
+#   error "__cpp_lib_syncbuf should be defined in c++20"
+# endif
+# if __cpp_lib_syncbuf != 201803L
+#   error "__cpp_lib_syncbuf should have the value 201803L in c++20"
 # endif
 
 # ifdef __cpp_lib_text_encoding
@@ -5306,17 +5300,11 @@
 #   error "__cpp_lib_submdspan should not be defined before c++26"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_syncbuf
-#     error "__cpp_lib_syncbuf should be defined in c++23"
-#   endif
-#   if __cpp_lib_syncbuf != 201803L
-#     error "__cpp_lib_syncbuf should have the value 201803L in c++23"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_syncbuf
-#     error "__cpp_lib_syncbuf should not be defined because it is unimplemented in libc++!"
-#   endif
+# ifndef __cpp_lib_syncbuf
+#   error "__cpp_lib_syncbuf should be defined in c++23"
+# endif
+# if __cpp_lib_syncbuf != 201803L
+#   error "__cpp_lib_syncbuf should have the value 201803L in c++23"
 # endif
 
 # ifdef __cpp_lib_text_encoding
@@ -6892,17 +6880,11 @@
 #   endif
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_syncbuf
-#     error "__cpp_lib_syncbuf should be defined in c++26"
-#   endif
-#   if __cpp_lib_syncbuf != 201803L
-#     error "__cpp_lib_syncbuf should have the value 201803L in c++26"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_syncbuf
-#     error "__cpp_lib_syncbuf should not be defined because it is unimplemented in libc++!"
-#   endif
+# ifndef __cpp_lib_syncbuf
+#   error "__cpp_lib_syncbuf should be defined in c++26"
+# endif
+# if __cpp_lib_syncbuf != 201803L
+#   error "__cpp_lib_syncbuf should have the value 201803L in c++26"
 # endif
 
 # if !defined(_LIBCPP_VERSION)
diff --git a/libcxx/utils/generate_feature_test_macro_components.py b/libcxx/utils/generate_feature_test_macro_components.py
--- a/libcxx/utils/generate_feature_test_macro_components.py
+++ b/libcxx/utils/generate_feature_test_macro_components.py
@@ -1026,7 +1026,6 @@
             "name": "__cpp_lib_syncbuf",
             "values": {"c++20": 201803},
             "headers": ["syncstream"],
-            "unimplemented": True,
         },
         {
             "name": "__cpp_lib_text_encoding",
diff --git a/libcxx/utils/libcxx/header_information.py b/libcxx/utils/libcxx/header_information.py
--- a/libcxx/utils/libcxx/header_information.py
+++ b/libcxx/utils/libcxx/header_information.py
@@ -127,7 +127,7 @@
     "stack": ["compare", "initializer_list"],
     "string_view": ["compare"],
     "string": ["compare", "initializer_list"],
-    # TODO "syncstream": ["ostream"],
+    "syncstream": ["ostream"],
     "system_error": ["compare"],
     "tgmath.h": ["cmath", "complex"],
     "thread": ["compare"],
@@ -156,7 +156,6 @@
     "spanstream",
     "stacktrace",
     "stdfloat",
-    "syncstream",
     "text_encoding",
 ]