diff --git a/include/fmt/base.h b/include/fmt/base.h
index 70f18c23271c..1a5e55a997d3 100644
--- a/include/fmt/base.h
+++ b/include/fmt/base.h
@@ -1858,136 +1858,6 @@ class fixed_buffer_traits {
   }
 };
 
-// A buffer that writes to an output iterator when flushed.
-template <typename OutputIt, typename T, typename Traits = buffer_traits>
-class iterator_buffer : public Traits, public buffer<T> {
- private:
-  OutputIt out_;
-  enum { buffer_size = 256 };
-  T data_[buffer_size];
-
-  static FMT_CONSTEXPR void grow(buffer<T>& buf, size_t) {
-    if (buf.size() == buffer_size) static_cast<iterator_buffer&>(buf).flush();
-  }
-
-  void flush() {
-    auto size = this->size();
-    this->clear();
-    const T* begin = data_;
-    const T* end = begin + this->limit(size);
-    while (begin != end) *out_++ = *begin++;
-  }
-
- public:
-  explicit iterator_buffer(OutputIt out, size_t n = buffer_size)
-      : Traits(n), buffer<T>(grow, data_, 0, buffer_size), out_(out) {}
-  iterator_buffer(iterator_buffer&& other) noexcept
-      : Traits(other),
-        buffer<T>(grow, data_, 0, buffer_size),
-        out_(other.out_) {}
-  ~iterator_buffer() {
-    // Don't crash if flush fails during unwinding.
-    FMT_TRY { flush(); }
-    FMT_CATCH(...) {}
-  }
-
-  auto out() -> OutputIt {
-    flush();
-    return out_;
-  }
-  auto count() const -> size_t { return Traits::count() + this->size(); }
-};
-
-template <typename T>
-class iterator_buffer<T*, T, fixed_buffer_traits> : public fixed_buffer_traits,
-                                                    public buffer<T> {
- private:
-  T* out_;
-  enum { buffer_size = 256 };
-  T data_[buffer_size];
-
-  static FMT_CONSTEXPR void grow(buffer<T>& buf, size_t) {
-    if (buf.size() == buf.capacity())
-      static_cast<iterator_buffer&>(buf).flush();
-  }
-
-  void flush() {
-    size_t n = this->limit(this->size());
-    if (this->data() == out_) {
-      out_ += n;
-      this->set(data_, buffer_size);
-    }
-    this->clear();
-  }
-
- public:
-  explicit iterator_buffer(T* out, size_t n = buffer_size)
-      : fixed_buffer_traits(n), buffer<T>(grow, out, 0, n), out_(out) {}
-  iterator_buffer(iterator_buffer&& other) noexcept
-      : fixed_buffer_traits(other),
-        buffer<T>(static_cast<iterator_buffer&&>(other)),
-        out_(other.out_) {
-    if (this->data() != out_) {
-      this->set(data_, buffer_size);
-      this->clear();
-    }
-  }
-  ~iterator_buffer() { flush(); }
-
-  auto out() -> T* {
-    flush();
-    return out_;
-  }
-  auto count() const -> size_t {
-    return fixed_buffer_traits::count() + this->size();
-  }
-};
-
-template <typename T> class iterator_buffer<T*, T> : public buffer<T> {
- public:
-  explicit iterator_buffer(T* out, size_t = 0)
-      : buffer<T>([](buffer<T>&, size_t) {}, out, 0, ~size_t()) {}
-
-  auto out() -> T* { return &*this->end(); }
-};
-
-template <typename Container>
-class container_buffer : public buffer<typename Container::value_type> {
- private:
-  using value_type = typename Container::value_type;
-
-  static FMT_CONSTEXPR void grow(buffer<value_type>& buf, size_t capacity) {
-    auto& self = static_cast<container_buffer&>(buf);
-    self.container.resize(capacity);
-    self.set(&self.container[0], capacity);
-  }
-
- public:
-  Container& container;
-
-  explicit container_buffer(Container& c)
-      : buffer<value_type>(grow, c.size()), container(c) {}
-};
-
-// A buffer that writes to a container with the contiguous storage.
-template <typename OutputIt>
-class iterator_buffer<
-    OutputIt,
-    enable_if_t<is_back_insert_iterator<OutputIt>::value &&
-                    is_contiguous<typename OutputIt::container_type>::value,
-                typename OutputIt::container_type::value_type>>
-    : public container_buffer<typename OutputIt::container_type> {
- private:
-  using base = container_buffer<typename OutputIt::container_type>;
-
- public:
-  explicit iterator_buffer(typename OutputIt::container_type& c) : base(c) {}
-  explicit iterator_buffer(OutputIt out, size_t = 0)
-      : base(get_container(out)) {}
-
-  auto out() -> OutputIt { return OutputIt(this->container); }
-};
-
 // A buffer that counts the number of code units written discarding the output.
 template <typename T = char> class counting_buffer : public buffer<T> {
  private:
@@ -2012,37 +1882,6 @@ template <typename T = char> class counting_buffer : public buffer<T> {
 template <typename T>
 struct is_back_insert_iterator<basic_appender<T>> : std::true_type {};
 
-template <typename It, typename Enable = std::true_type>
-struct is_buffer_appender : std::false_type {};
-template <typename It>
-struct is_buffer_appender<
-    It, bool_constant<
-            is_back_insert_iterator<It>::value &&
-            std::is_base_of<buffer<typename It::container_type::value_type>,
-                            typename It::container_type>::value>>
-    : std::true_type {};
-
-// Maps an output iterator to a buffer.
-template <typename T, typename OutputIt,
-          FMT_ENABLE_IF(!is_buffer_appender<OutputIt>::value)>
-auto get_buffer(OutputIt out) -> iterator_buffer<OutputIt, T> {
-  return iterator_buffer<OutputIt, T>(out);
-}
-template <typename T, typename OutputIt,
-          FMT_ENABLE_IF(is_buffer_appender<OutputIt>::value)>
-auto get_buffer(OutputIt out) -> buffer<T>& {
-  return get_container(out);
-}
-
-template <typename Buf, typename OutputIt>
-auto get_iterator(Buf& buf, OutputIt) -> decltype(buf.out()) {
-  return buf.out();
-}
-template <typename T, typename OutputIt>
-auto get_iterator(buffer<T>&, OutputIt out) -> OutputIt {
-  return out;
-}
-
 // This type is intentionally undefined, only used for errors.
 template <typename T, typename Char> struct type_is_unformattable_for;
 
@@ -2727,98 +2566,6 @@ inline auto arg(const char* name, const T& arg) -> named_arg<T> {
   return {name, arg};
 }
 
-/// Formats a string and writes the output to `out`.
-template <typename OutputIt,
-          FMT_ENABLE_IF(detail::is_output_iterator<remove_cvref_t<OutputIt>,
-                                                   char>::value)>
-// DEPRECATED! Passing out as a forwarding reference.
-auto vformat_to(OutputIt&& out, string_view fmt, format_args args)
-    -> remove_cvref_t<OutputIt> {
-  auto&& buf = detail::get_buffer<char>(out);
-  detail::vformat_to(buf, fmt, args, {});
-  return detail::get_iterator(buf, out);
-}
-
-/**
- * Formats `args` according to specifications in `fmt`, writes the result to
- * the output iterator `out` and returns the iterator past the end of the output
- * range. `format_to` does not append a terminating null character.
- *
- * **Example**:
- *
- *     auto out = std::vector<char>();
- *     fmt::format_to(std::back_inserter(out), "{}", 42);
- */
-template <typename OutputIt, typename... T,
-          FMT_ENABLE_IF(detail::is_output_iterator<remove_cvref_t<OutputIt>,
-                                                   char>::value)>
-FMT_INLINE auto format_to(OutputIt&& out, format_string<T...> fmt, T&&... args)
-    -> remove_cvref_t<OutputIt> {
-  return vformat_to(out, fmt.str, vargs<T...>{{args...}});
-}
-
-template <typename OutputIt> struct format_to_n_result {
-  OutputIt out;  ///< Iterator past the end of the output range.
-  size_t size;   ///< Total (not truncated) output size.
-};
-
-template <typename OutputIt, typename... T,
-          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
-auto vformat_to_n(OutputIt out, size_t n, string_view fmt, format_args args)
-    -> format_to_n_result<OutputIt> {
-  using traits = detail::fixed_buffer_traits;
-  auto buf = detail::iterator_buffer<OutputIt, char, traits>(out, n);
-  detail::vformat_to(buf, fmt, args, {});
-  return {buf.out(), buf.count()};
-}
-
-/**
- * Formats `args` according to specifications in `fmt`, writes up to `n`
- * characters of the result to the output iterator `out` and returns the total
- * (not truncated) output size and the iterator past the end of the output
- * range. `format_to_n` does not append a terminating null character.
- */
-template <typename OutputIt, typename... T,
-          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
-FMT_INLINE auto format_to_n(OutputIt out, size_t n, format_string<T...> fmt,
-                            T&&... args) -> format_to_n_result<OutputIt> {
-  return vformat_to_n(out, n, fmt.str, vargs<T...>{{args...}});
-}
-
-struct format_to_result {
-  char* out;       ///< Pointer to just after the last successful write.
-  bool truncated;  ///< Specifies if the output was truncated.
-
-  FMT_CONSTEXPR operator char*() const {
-    // Report truncation to prevent silent data loss.
-    if (truncated) report_error("output is truncated");
-    return out;
-  }
-};
-
-template <size_t N>
-FMT_DEPRECATED auto vformat_to(char (&out)[N], string_view fmt,
-                               format_args args) -> format_to_result {
-  auto result = vformat_to_n(out, N, fmt, args);
-  return {result.out, result.size > N};
-}
-
-template <size_t N, typename... T>
-FMT_INLINE auto format_to(char (&out)[N], format_string<T...> fmt, T&&... args)
-    -> format_to_result {
-  auto result = vformat_to_n(out, N, fmt.str, vargs<T...>{{args...}});
-  return {result.out, result.size > N};
-}
-
-/// Returns the number of chars in the output of `format(fmt, args...)`.
-template <typename... T>
-FMT_NODISCARD FMT_INLINE auto formatted_size(format_string<T...> fmt,
-                                             T&&... args) -> size_t {
-  auto buf = detail::counting_buffer<>();
-  detail::vformat_to(buf, fmt.str, vargs<T...>{{args...}}, {});
-  return buf.count();
-}
-
 FMT_API void vprint(string_view fmt, format_args args);
 FMT_API void vprint(FILE* f, string_view fmt, format_args args);
 FMT_API void vprintln(FILE* f, string_view fmt, format_args args);
diff --git a/include/fmt/format.h b/include/fmt/format.h
index b358f0425fa2..ba5e1d18dc62 100644
--- a/include/fmt/format.h
+++ b/include/fmt/format.h
@@ -607,6 +607,172 @@ FMT_CONSTEXPR auto copy(basic_string_view<V> s, OutputIt out) -> OutputIt {
   return copy<T>(s.begin(), s.end(), out);
 }
 
+// A buffer that writes to an output iterator when flushed.
+template <typename OutputIt, typename T, typename Traits = buffer_traits>
+class iterator_buffer : public Traits, public buffer<T> {
+ private:
+  OutputIt out_;
+  enum { buffer_size = 256 };
+  T data_[buffer_size];
+
+  static FMT_CONSTEXPR void grow(buffer<T>& buf, size_t) {
+    if (buf.size() == buffer_size) static_cast<iterator_buffer&>(buf).flush();
+  }
+
+  void flush() {
+    auto size = this->size();
+    this->clear();
+    const T* begin = data_;
+    const T* end = begin + this->limit(size);
+#if defined(__cpp_if_constexpr)
+    if constexpr (std::is_move_assignable<OutputIt>::value)
+      out_ = copy<T>(begin, end, out_);
+    else
+#endif
+      while (begin != end) *out_++ = *begin++;
+  }
+
+ public:
+  explicit iterator_buffer(OutputIt out, size_t n = buffer_size)
+      : Traits(n), buffer<T>(grow, data_, 0, buffer_size), out_(out) {}
+  iterator_buffer(iterator_buffer&& other) noexcept
+      : Traits(other),
+        buffer<T>(grow, data_, 0, buffer_size),
+        out_(other.out_) {}
+  ~iterator_buffer() {
+    // Don't crash if flush fails during unwinding.
+    FMT_TRY { flush(); }
+    FMT_CATCH(...) {}
+  }
+
+  auto out() -> OutputIt {
+    flush();
+    return out_;
+  }
+  auto count() const -> size_t { return Traits::count() + this->size(); }
+};
+
+template <typename T>
+class iterator_buffer<T*, T, fixed_buffer_traits> : public fixed_buffer_traits,
+                                                    public buffer<T> {
+ private:
+  T* out_;
+  enum { buffer_size = 256 };
+  T data_[buffer_size];
+
+  static FMT_CONSTEXPR void grow(buffer<T>& buf, size_t) {
+    if (buf.size() == buf.capacity())
+      static_cast<iterator_buffer&>(buf).flush();
+  }
+
+  void flush() {
+    size_t n = this->limit(this->size());
+    if (this->data() == out_) {
+      out_ += n;
+      this->set(data_, buffer_size);
+    }
+    this->clear();
+  }
+
+ public:
+  explicit iterator_buffer(T* out, size_t n = buffer_size)
+      : fixed_buffer_traits(n), buffer<T>(grow, out, 0, n), out_(out) {}
+  iterator_buffer(iterator_buffer&& other) noexcept
+      : fixed_buffer_traits(other),
+        buffer<T>(static_cast<iterator_buffer&&>(other)),
+        out_(other.out_) {
+    if (this->data() != out_) {
+      this->set(data_, buffer_size);
+      this->clear();
+    }
+  }
+  ~iterator_buffer() { flush(); }
+
+  auto out() -> T* {
+    flush();
+    return out_;
+  }
+  auto count() const -> size_t {
+    return fixed_buffer_traits::count() + this->size();
+  }
+};
+
+template <typename T> class iterator_buffer<T*, T> : public buffer<T> {
+ public:
+  explicit iterator_buffer(T* out, size_t = 0)
+      : buffer<T>([](buffer<T>&, size_t) {}, out, 0, ~size_t()) {}
+
+  auto out() -> T* { return &*this->end(); }
+};
+
+template <typename Container>
+class container_buffer : public buffer<typename Container::value_type> {
+ private:
+  using value_type = typename Container::value_type;
+
+  static FMT_CONSTEXPR void grow(buffer<value_type>& buf, size_t capacity) {
+    auto& self = static_cast<container_buffer&>(buf);
+    self.container.resize(capacity);
+    self.set(&self.container[0], capacity);
+  }
+
+ public:
+  Container& container;
+
+  explicit container_buffer(Container& c)
+      : buffer<value_type>(grow, c.size()), container(c) {}
+};
+
+// A buffer that writes to a container with the contiguous storage.
+template <typename OutputIt>
+class iterator_buffer<
+    OutputIt,
+    enable_if_t<is_back_insert_iterator<OutputIt>::value &&
+                    is_contiguous<typename OutputIt::container_type>::value,
+                typename OutputIt::container_type::value_type>>
+    : public container_buffer<typename OutputIt::container_type> {
+ private:
+  using base = container_buffer<typename OutputIt::container_type>;
+
+ public:
+  explicit iterator_buffer(typename OutputIt::container_type& c) : base(c) {}
+  explicit iterator_buffer(OutputIt out, size_t = 0)
+      : base(get_container(out)) {}
+
+  auto out() -> OutputIt { return OutputIt(this->container); }
+};
+
+template <typename It, typename Enable = std::true_type>
+struct is_buffer_appender : std::false_type {};
+template <typename It>
+struct is_buffer_appender<
+    It, bool_constant<
+            is_back_insert_iterator<It>::value &&
+            std::is_base_of<buffer<typename It::container_type::value_type>,
+                            typename It::container_type>::value>>
+    : std::true_type {};
+
+// Maps an output iterator to a buffer.
+template <typename T, typename OutputIt,
+          FMT_ENABLE_IF(!is_buffer_appender<OutputIt>::value)>
+auto get_buffer(OutputIt out) -> iterator_buffer<OutputIt, T> {
+  return iterator_buffer<OutputIt, T>(out);
+}
+template <typename T, typename OutputIt,
+          FMT_ENABLE_IF(is_buffer_appender<OutputIt>::value)>
+auto get_buffer(OutputIt out) -> buffer<T>& {
+  return get_container(out);
+}
+
+template <typename Buf, typename OutputIt>
+auto get_iterator(Buf& buf, OutputIt) -> decltype(buf.out()) {
+  return buf.out();
+}
+template <typename T, typename OutputIt>
+auto get_iterator(buffer<T>&, OutputIt out) -> OutputIt {
+  return out;
+}
+
 template <typename OutChar, typename InputIt, typename OutputIt>
 FMT_CONSTEXPR FMT_NOINLINE auto copy_noinline(InputIt begin, InputIt end,
                                               OutputIt out) -> OutputIt {
@@ -961,6 +1127,98 @@ FMT_NODISCARD auto to_string(const basic_memory_buffer<char, SIZE>& buf)
   return {buf.data(), size};
 }
 
+/// Formats a string and writes the output to `out`.
+template <typename OutputIt,
+          FMT_ENABLE_IF(detail::is_output_iterator<remove_cvref_t<OutputIt>,
+                                                   char>::value)>
+// DEPRECATED! Passing out as a forwarding reference.
+auto vformat_to(OutputIt&& out, string_view fmt, format_args args)
+    -> remove_cvref_t<OutputIt> {
+  auto&& buf = detail::get_buffer<char>(out);
+  detail::vformat_to(buf, fmt, args, {});
+  return detail::get_iterator(buf, out);
+}
+
+/**
+ * Formats `args` according to specifications in `fmt`, writes the result to
+ * the output iterator `out` and returns the iterator past the end of the output
+ * range. `format_to` does not append a terminating null character.
+ *
+ * **Example**:
+ *
+ *     auto out = std::vector<char>();
+ *     fmt::format_to(std::back_inserter(out), "{}", 42);
+ */
+template <typename OutputIt, typename... T,
+          FMT_ENABLE_IF(detail::is_output_iterator<remove_cvref_t<OutputIt>,
+                                                   char>::value)>
+FMT_INLINE auto format_to(OutputIt&& out, format_string<T...> fmt, T&&... args)
+    -> remove_cvref_t<OutputIt> {
+  return vformat_to(out, fmt.str, vargs<T...>{{args...}});
+}
+
+template <typename OutputIt> struct format_to_n_result {
+  OutputIt out;  ///< Iterator past the end of the output range.
+  size_t size;   ///< Total (not truncated) output size.
+};
+
+template <typename OutputIt, typename... T,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
+auto vformat_to_n(OutputIt out, size_t n, string_view fmt, format_args args)
+    -> format_to_n_result<OutputIt> {
+  using traits = detail::fixed_buffer_traits;
+  auto buf = detail::iterator_buffer<OutputIt, char, traits>(out, n);
+  detail::vformat_to(buf, fmt, args, {});
+  return {buf.out(), buf.count()};
+}
+
+/**
+ * Formats `args` according to specifications in `fmt`, writes up to `n`
+ * characters of the result to the output iterator `out` and returns the total
+ * (not truncated) output size and the iterator past the end of the output
+ * range. `format_to_n` does not append a terminating null character.
+ */
+template <typename OutputIt, typename... T,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
+FMT_INLINE auto format_to_n(OutputIt out, size_t n, format_string<T...> fmt,
+                            T&&... args) -> format_to_n_result<OutputIt> {
+  return vformat_to_n(out, n, fmt.str, vargs<T...>{{args...}});
+}
+
+struct format_to_result {
+  char* out;       ///< Pointer to just after the last successful write.
+  bool truncated;  ///< Specifies if the output was truncated.
+
+  FMT_CONSTEXPR operator char*() const {
+    // Report truncation to prevent silent data loss.
+    if (truncated) report_error("output is truncated");
+    return out;
+  }
+};
+
+template <size_t N>
+FMT_DEPRECATED auto vformat_to(char (&out)[N], string_view fmt,
+                               format_args args) -> format_to_result {
+  auto result = vformat_to_n(out, N, fmt, args);
+  return {result.out, result.size > N};
+}
+
+template <size_t N, typename... T>
+FMT_INLINE auto format_to(char (&out)[N], format_string<T...> fmt, T&&... args)
+    -> format_to_result {
+  auto result = vformat_to_n(out, N, fmt.str, vargs<T...>{{args...}});
+  return {result.out, result.size > N};
+}
+
+/// Returns the number of chars in the output of `format(fmt, args...)`.
+template <typename... T>
+FMT_NODISCARD FMT_INLINE auto formatted_size(format_string<T...> fmt,
+                                             T&&... args) -> size_t {
+  auto buf = detail::counting_buffer<>();
+  detail::vformat_to(buf, fmt.str, vargs<T...>{{args...}}, {});
+  return buf.count();
+}
+
 // A writer to a buffered stream. It doesn't own the underlying stream.
 class writer {
  private:
diff --git a/src/fmt-c.cc b/src/fmt-c.cc
index cb7dcc1c5be8..c3974e40e340 100644
--- a/src/fmt-c.cc
+++ b/src/fmt-c.cc
@@ -7,7 +7,7 @@
 
 #include "fmt/fmt-c.h"
 
-#include <fmt/base.h>
+#include <fmt/format.h>
 
 extern "C" int fmt_vformat(char* buffer, size_t size, const char* fmt,
                            const fmt_arg* args, size_t num_args) {
diff --git a/test/base-test.cc b/test/base-test.cc
index bf268875b3bf..b7571dc92790 100644
--- a/test/base-test.cc
+++ b/test/base-test.cc
@@ -13,7 +13,7 @@
 // Suppress warnings for pathological types convertible to detail::value.
 #pragma GCC diagnostic ignored "-Wconversion"
 
-#include "fmt/base.h"
+#include "fmt/format.h"
 
 #include <limits.h>  // INT_MAX
 #include <string.h>  // strlen
@@ -26,10 +26,6 @@
 
 #include "gmock/gmock.h"
 
-#ifdef FMT_FORMAT_H_
-#  error base-test includes format.h
-#endif
-
 using testing::_;
 using testing::Invoke;
 using testing::Return;