Version 1.11.0

Update ci.yml
2026-01-02 09:57:55 +08:00 · 2022-11-02 23:13:08 +02:00 · 2022-11-01 17:17:29 +02:00 · 2022-11-01 17:13:35 +02:00 · 2022-11-01 14:46:39 +02:00 · 2022-11-01 00:52:39 +02:00
65 changed files with 4048 additions and 3846 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,81 @@
+name: ci
+
+on: [push, pull_request]
+
+jobs:
+  build_linux:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        shell: bash
+    strategy:
+      matrix:
+        config:
+          - { compiler: gcc, version: 4.9, build_type: Release, cppstd: 11, examples: OFF, asan: OFF }
+          - { compiler: gcc, version: 7, build_type: Release, cppstd: 11 }
+          - { compiler: gcc, version: 9, build_type: Release, cppstd: 17 }
+          - { compiler: gcc, version: 11, build_type: Debug, cppstd: 20 }
+          - { compiler: gcc, version: 12, build_type: Release, cppstd: 20 }
+          - { compiler: clang, version: 3.5, build_type: Release, cppstd: 11, asan: OFF }
+          - { compiler: clang, version: 10, build_type: Release, cppstd: 11 }
+          - { compiler: clang, version: 10, build_type: Debug, cppstd: 17, asan: OFF }
+          - { compiler: clang, version: 12, build_type: Debug, cppstd: 17, asan: OFF }
+          - { compiler: clang, version: 15, build_type: Release, cppstd: 20, asan: OFF }
+    container:
+      image: ${{ matrix.config.compiler == 'clang' && 'teeks99/clang-ubuntu' || matrix.config.compiler }}:${{ matrix.config.version }}
+    name: "${{ matrix.config.compiler}} ${{ matrix.config.version }} (C++${{ matrix.config.cppstd }}, ${{ matrix.config.build_type }})"
+    steps:
+      - uses: actions/checkout@main
+      - name: Setup
+        run: |
+          apt-get update && apt-get install -y curl
+          CMAKE_VERSION="3.24.2"
+          curl -sSL https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION}/cmake-${CMAKE_VERSION}-linux-x86_64.sh -o install-cmake.sh
+          chmod +x install-cmake.sh
+          ./install-cmake.sh --prefix=/usr/local --skip-license
+      - name: Setup Compiler
+        if: matrix.config.compiler == 'clang'
+        run: |
+          if [[ "${{ matrix.config.version }}" -ge 4 ]]; then
+            scripts/ci_setup_clang.sh "${{ matrix.config.version }}"
+            echo "CXXFLAGS=-stdlib=libc++" >> $GITHUB_ENV
+          fi
+          echo "CC=clang-${{ matrix.config.version }}" >> $GITHUB_ENV
+          echo "CXX=clang++-${{ matrix.config.version }}" >> $GITHUB_ENV
+      - name: Build
+        run: |
+          mkdir -p build && cd build
+          cmake .. \
+            -DCMAKE_BUILD_TYPE=${{ matrix.config.build_type }} \
+            -DCMAKE_CXX_STANDARD=${{ matrix.config.cppstd }} \
+            -DSPDLOG_BUILD_EXAMPLE=${{ matrix.config.examples || 'ON' }} \
+            -DSPDLOG_BUILD_EXAMPLE_HO=${{ matrix.config.examples || 'ON' }} \
+            -DSPDLOG_BUILD_WARNINGS=ON \
+            -DSPDLOG_BUILD_BENCH=OFF \
+            -DSPDLOG_BUILD_TESTS=ON \
+            -DSPDLOG_BUILD_TESTS_HO=OFF \
+            -DSPDLOG_SANITIZE_ADDRESS=${{ matrix.config.asan || 'ON' }}
+          make -j2
+          ctest -j2 --output-on-failure
+
+  build_osx:
+    runs-on: macOS-latest
+    name: "OS X Clang (C++11, Release)"
+    steps:
+      - uses: actions/checkout@main
+      - name: Build
+        run: |
+          mkdir -p build && cd build
+          cmake .. \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DCMAKE_CXX_STANDARD=11 \
+            -DSPDLOG_BUILD_EXAMPLE=ON \
+            -DSPDLOG_BUILD_EXAMPLE_HO=ON \
+            -DSPDLOG_BUILD_WARNINGS=ON \
+            -DSPDLOG_BUILD_BENCH=OFF \
+            -DSPDLOG_BUILD_TESTS=ON \
+            -DSPDLOG_BUILD_TESTS_HO=OFF \
+            -DSPDLOG_SANITIZE_ADDRESS=OFF
+          make -j2
+          ctest -j2 --output-on-failure
+
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,155 +0,0 @@
-# Adapted from various sources, including:
-# - Louis Dionne's Hana: https://github.com/ldionne/hana
-# - Paul Fultz II's FIT: https://github.com/pfultz2/Fit
-# - Eric Niebler's range-v3: https://github.com/ericniebler/range-v3
-sudo: required
-language: cpp
-
-# gcc 4.9
-addons: &gcc49
-  apt:
-    packages:
-      - g++-4.9
-    sources:
-      - ubuntu-toolchain-r-test
-
-# gcc 7.0
-addons: &gcc7
-  apt:
-    packages:
-      - g++-7
-    sources:
-      - ubuntu-toolchain-r-test
-
-
-# gcc 9.0
-addons: &gcc9
-  apt:
-    packages:
-      - g++-9
-    sources:
-      - ubuntu-toolchain-r-test
-      
-# gcc 11.0
-addons: &gcc11
-  apt:
-    packages:
-      - g++-11
-    sources:
-      - ubuntu-toolchain-r-test
-
-
-# Clang 3.5
-addons: &clang35
-  apt:
-    packages:
-      - clang-3.5
-    sources:
-      - ubuntu-toolchain-r-test
-      - llvm-toolchain-precise-3.5
-      
-
-addons: &clang10
-  apt:
-    packages:
-      - clang-10
-      - lldb-10
-      - lld-10
-    sources:
-      - sourceline: "deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-10 main"
-        key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
-        
-addons: &clang12
-  apt:
-    packages:
-      - clang-12
-      - lldb-12
-      - lld-12
-    sources:
-      - sourceline: "deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-12 main"
-        key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"        
-
-env:
-  global:
-    - BUILD_EXAMPLE='ON'
-    
-matrix:
-  include:
-    # Test gcc-4.9: C++11, Build=Release
-    - env: GCC_VERSION=4.9 BUILD_TYPE=Release CPP=11 BUILD_EXAMPLE='OFF'
-      os: linux
-      addons: *gcc49
-      
-    # Test gcc-7: C++11, Build=Release
-    - env: GCC_VERSION=7 BUILD_TYPE=Release CPP=11
-      os: linux
-      addons: *gcc7
-      
-    # Test gcc-9: C++17, Build=Release
-    - env: GCC_VERSION=9 BUILD_TYPE=Release CPP=17
-      os: linux
-      addons: *gcc9
-
-    # Test gcc-11.0: C++20, Build=Debug
-    - env: GCC_VERSION=11 BUILD_TYPE=Debug CPP=20 ASAN=Off
-      os: linux
-      dist: bionic
-      addons: *gcc11
-      
-    # Test clang-3.5: C++11, Build=Release
-    - env: CLANG_VERSION=3.5 BUILD_TYPE=Release CPP=11
-      os: linux
-      addons: *clang35
-
-    # Text osx
-    - env: BUILD_TYPE=Release CPP=11 ASAN=Off TSAN=Off
-      os: osx
-
-    # Test clang-10.0: C++11, Build=Release
-    - env: CLANG_VERSION=10 BUILD_TYPE=Release CPP=11 ASAN=On
-      os: linux
-      dist: bionic
-      addons: *clang10
-      
-    # Test clang-10.0: C++17, Build=Debug
-    - env: CLANG_VERSION=10 BUILD_TYPE=Debug CPP=17 ASAN=Off
-      os: linux
-      dist: bionic
-      addons: *clang10
-      
-            
-    # Test clang-12.0: C++17, Build=Debug
-    - env: CLANG_VERSION=12 BUILD_TYPE=Debug CPP=17 ASAN=Off
-      os: linux
-      dist: bionic
-      addons: *clang12
-          
-                        
-before_script:
-  - if [ -n "$GCC_VERSION" ]; then export CXX="g++-${GCC_VERSION}" CC="gcc-${GCC_VERSION}"; fi
-  - if [ -n "$CLANG_VERSION" ]; then export CXX="clang++-${CLANG_VERSION}" CC="clang-${CLANG_VERSION}"; fi
-  - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then export CXX="clang++" CC="clang"; fi
-  - which $CXX
-  - which $CC
-  - $CXX --version
-  - cmake --version
-
-script:
-  - cd ${TRAVIS_BUILD_DIR}
-  - mkdir -p build && cd build
-  - |
-    cmake .. \
-      --warn-uninitialized \
-      -DCMAKE_BUILD_TYPE=$BUILD_TYPE \
-      -DCMAKE_CXX_STANDARD=$CPP \
-      -DSPDLOG_BUILD_EXAMPLE=$BUILD_EXAMPLE \
-      -DSPDLOG_BUILD_EXAMPLE_HO=$BUILD_EXAMPLE \
-      -DSPDLOG_BUILD_WARNINGS=ON \
-      -DSPDLOG_BUILD_BENCH=OFF \
-      -DSPDLOG_BUILD_TESTS=ON \
-      -DSPDLOG_BUILD_TESTS_HO=OFF \
-      -DSPDLOG_SANITIZE_ADDRESS=$ASAN 
-      
-  - make VERBOSE=1 -j2
-  - ctest -j2 --output-on-failure
-  
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -61,6 +61,9 @@ option(SPDLOG_BUILD_SHARED "Build shared library" OFF)
 # precompiled headers option
 option(SPDLOG_ENABLE_PCH "Build static or shared library using precompiled header to speed up compilation time" OFF)

+# build position independent code
+option(SPDLOG_BUILD_PIC "Build position independent code (-fPIC)" OFF)
+
 # example options
 option(SPDLOG_BUILD_EXAMPLE "Build example" ${SPDLOG_MASTER_PROJECT})
 option(SPDLOG_BUILD_EXAMPLE_HO "Build header only example" OFF)
@@ -132,15 +135,19 @@ if(SPDLOG_TIDY)
    message(STATUS "Enabled clang-tidy")
 endif()

+if(SPDLOG_BUILD_PIC)
+    set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+endif()
+
 find_package(Threads REQUIRED)
 message(STATUS "Build type: " ${CMAKE_BUILD_TYPE})
 # ---------------------------------------------------------------------------------------
-# Static/Shared library (shared not supported in windows yet)
+# Static/Shared library
 # ---------------------------------------------------------------------------------------
 set(SPDLOG_SRCS src/spdlog.cpp src/stdout_sinks.cpp src/color_sinks.cpp src/file_sinks.cpp src/async.cpp src/cfg.cpp)

 if(NOT SPDLOG_USE_STD_FORMAT AND NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)
-    list(APPEND SPDLOG_SRCS src/fmt.cpp)
+    list(APPEND SPDLOG_SRCS src/bundled_fmtlib_format.cpp)
 endif()

 if(SPDLOG_BUILD_SHARED OR BUILD_SHARED_LIBS)
@@ -169,7 +176,7 @@ target_include_directories(spdlog PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST
 target_link_libraries(spdlog PUBLIC Threads::Threads)
 spdlog_enable_warnings(spdlog)

-set_target_properties(spdlog PROPERTIES VERSION ${SPDLOG_VERSION} SOVERSION ${SPDLOG_VERSION_MAJOR})
+set_target_properties(spdlog PROPERTIES VERSION ${SPDLOG_VERSION} SOVERSION ${SPDLOG_VERSION_MAJOR}.${SPDLOG_VERSION_MINOR})
 set_target_properties(spdlog PROPERTIES DEBUG_POSTFIX d)

 if(COMMAND target_precompile_headers AND SPDLOG_ENABLE_PCH)
@@ -243,6 +250,11 @@ if(SPDLOG_NO_EXCEPTIONS AND NOT MSVC)
    target_compile_options(spdlog PRIVATE -fno-exceptions)
 endif()

+if(SPDLOG_USE_STD_FORMAT)
+    set(CMAKE_CXX_STANDARD 20)
+    set(CMAKE_CXX_STANDARD_REQUIRED ON)
+endif()
+
 # ---------------------------------------------------------------------------------------
 # Build binaries
 # ---------------------------------------------------------------------------------------
@@ -298,6 +310,16 @@ if(SPDLOG_INSTALL)
    # ---------------------------------------------------------------------------------------
    # Install pkg-config file
    # ---------------------------------------------------------------------------------------
+    if (IS_ABSOLUTE "${CMAKE_INSTALL_INCLUDEDIR}")
+        set(PKG_CONFIG_INCLUDEDIR "${CMAKE_INSTALL_INCLUDEDIR}")
+    else()
+        set(PKG_CONFIG_INCLUDEDIR "\${prefix}/${CMAKE_INSTALL_INCLUDEDIR}")
+    endif()
+    if (IS_ABSOLUTE "${CMAKE_INSTALL_LIBDIR}")
+        set(PKG_CONFIG_LIBDIR "${CMAKE_INSTALL_LIBDIR}")
+    else()
+        set(PKG_CONFIG_LIBDIR "\${exec_prefix}/${CMAKE_INSTALL_LIBDIR}")
+    endif()
    get_target_property(PKG_CONFIG_DEFINES spdlog INTERFACE_COMPILE_DEFINITIONS)
    string(REPLACE ";" " -D" PKG_CONFIG_DEFINES "${PKG_CONFIG_DEFINES}")
    string(CONCAT PKG_CONFIG_DEFINES "-D" "${PKG_CONFIG_DEFINES}")
@@ -307,6 +329,10 @@ if(SPDLOG_INSTALL)
    # ---------------------------------------------------------------------------------------
    # Install CMake config files
    # ---------------------------------------------------------------------------------------
+    export(
+      TARGETS spdlog
+      NAMESPACE spdlog::
+      FILE "${CMAKE_CURRENT_BINARY_DIR}/${config_targets_file}")
    install(EXPORT spdlog DESTINATION ${export_dest_dir} NAMESPACE spdlog:: FILE ${config_targets_file})

    include(CMakePackageConfigHelpers)
--- a/README.md
+++ b/README.md
@@ -1,12 +1,12 @@
 # spdlog

-Very fast, header-only/compiled, C++ logging library. [![Build Status](https://app.travis-ci.com/gabime/spdlog.svg?branch=v1.x)](https://app.travis-ci.com/gabime/spdlog)&nbsp; [![Build status](https://ci.appveyor.com/api/projects/status/d2jnxclg20vd0o50?svg=true&branch=v1.x)](https://ci.appveyor.com/project/gabime/spdlog) [![Release](https://img.shields.io/github/release/gabime/spdlog.svg)](https://github.com/gabime/spdlog/releases/latest)
+Very fast, header-only/compiled, C++ logging library. [![ci](https://github.com/gabime/spdlog/actions/workflows/ci.yml/badge.svg)](https://github.com/gabime/spdlog/actions/workflows/ci.yml)&nbsp; [![Build status](https://ci.appveyor.com/api/projects/status/d2jnxclg20vd0o50?svg=true&branch=v1.x)](https://ci.appveyor.com/project/gabime/spdlog) [![Release](https://img.shields.io/github/release/gabime/spdlog.svg)](https://github.com/gabime/spdlog/releases/latest)

 ## Install 
 #### Header only version
 Copy the include [folder](https://github.com/gabime/spdlog/tree/v1.x/include/spdlog) to your build tree and use a C++11 compiler.

-#### Static lib version (recommended - much faster compile times)
+#### Compiled version (recommended - much faster compile times)
 ```console
 $ git clone https://github.com/gabime/spdlog.git
 $ cd spdlog && mkdir build && cd build
@@ -29,6 +29,7 @@ $ cmake .. && make -j
 * Fedora: `dnf install spdlog`
 * Gentoo: `emerge dev-libs/spdlog`
 * Arch Linux: `pacman -S spdlog`
+* openSUSE: `sudo zypper in spdlog-devel`
 * vcpkg: `vcpkg install spdlog`
 * conan: `spdlog/[>=1.4.1]`
 * conda: `conda install -c conda-forge spdlog`
@@ -268,21 +269,18 @@ void multi_sink_example2()
 ---
 #### User defined types
 ```c++
-// user defined types logging by implementing operator<<
-#include "spdlog/fmt/ostr.h" // must be included
-struct my_type
+template<>
+struct fmt::formatter<my_type> : fmt::formatter<std::string>
 {
-    int i;
-    template<typename OStream>
-    friend OStream &operator<<(OStream &os, const my_type &c)
+    auto format(my_type my, format_context &ctx) -> decltype(ctx.out())
    {
-        return os << "[my_type i=" << c.i << "]";
+        return format_to(ctx.out(), "[my_type i={}]", my.i);
    }
 };

 void user_defined_example()
 {
-    spdlog::get("console")->info("user defined type: {}", my_type{14});
+    spdlog::info("user defined type: {}", my_type(14));
 }

 ```
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -5,6 +5,7 @@ environment:
    - GENERATOR: '"Visual Studio 14 2015"'
      BUILD_TYPE: Debug
      BUILD_SHARED: 'OFF'
+      FATAL_ERRORS: 'ON'
      WCHAR: 'OFF'
      WCHAR_FILES: 'OFF'
      BUILD_EXAMPLE: 'ON'
@@ -13,6 +14,7 @@ environment:
    - GENERATOR: '"Visual Studio 14 2015"'
      BUILD_TYPE: Release
      BUILD_SHARED: 'OFF'
+      FATAL_ERRORS: 'ON'
      WCHAR: 'ON'
      WCHAR_FILES: 'OFF'
      BUILD_EXAMPLE: 'ON'
@@ -21,6 +23,7 @@ environment:
    - GENERATOR: '"Visual Studio 14 2015 Win64"'
      BUILD_TYPE: Debug
      BUILD_SHARED: 'OFF'
+      FATAL_ERRORS: 'ON'
      WCHAR: 'ON'
      WCHAR_FILES: 'OFF'
      BUILD_EXAMPLE: 'ON'
@@ -29,6 +32,7 @@ environment:
    - GENERATOR: '"Visual Studio 14 2015 Win64"'
      BUILD_TYPE: Release
      BUILD_SHARED: 'OFF'
+      FATAL_ERRORS: 'ON'
      WCHAR: 'ON'
      WCHAR_FILES: 'OFF'
      BUILD_EXAMPLE: 'ON'
@@ -37,6 +41,7 @@ environment:
    - GENERATOR: '"Visual Studio 15 2017 Win64"'
      BUILD_TYPE: Debug
      BUILD_SHARED: 'OFF'
+      FATAL_ERRORS: 'OFF'
      WCHAR: 'ON'
      WCHAR_FILES: 'OFF'
      BUILD_EXAMPLE: 'ON'
@@ -45,6 +50,7 @@ environment:
    - GENERATOR: '"Visual Studio 15 2017 Win64"'
      BUILD_TYPE: Release
      BUILD_SHARED: 'OFF'
+      FATAL_ERRORS: 'OFF'
      WCHAR: 'OFF'
      WCHAR_FILES: 'OFF'
      BUILD_EXAMPLE: 'ON'
@@ -53,6 +59,7 @@ environment:
    - GENERATOR: '"Visual Studio 15 2017 Win64"'
      BUILD_TYPE: Release
      BUILD_SHARED: 'ON'
+      FATAL_ERRORS: 'OFF'
      WCHAR: 'OFF'
      WCHAR_FILES: 'OFF'
      BUILD_EXAMPLE: 'ON'
@@ -61,6 +68,7 @@ environment:
    - GENERATOR: '"Visual Studio 15 2017 Win64"'
      BUILD_TYPE: Release
      BUILD_SHARED: 'ON'
+      FATAL_ERRORS: 'OFF'
      WCHAR: 'ON'
      WCHAR_FILES: 'ON'
      BUILD_EXAMPLE: 'OFF'
@@ -69,6 +77,7 @@ environment:
    - GENERATOR: '"Visual Studio 16 2019" -A x64'
      BUILD_TYPE: Release
      BUILD_SHARED: 'ON'
+      FATAL_ERRORS: 'ON'
      WCHAR: 'OFF'
      WCHAR_FILES: 'OFF'
      BUILD_EXAMPLE: 'OFF'
@@ -78,6 +87,7 @@ environment:
    - GENERATOR: '"Visual Studio 17 2022" -A x64'
      BUILD_TYPE: Release
      BUILD_SHARED: 'ON'
+      FATAL_ERRORS: 'ON'
      WCHAR: 'OFF'
      WCHAR_FILES: 'OFF'
      BUILD_EXAMPLE: 'OFF'
@@ -87,6 +97,7 @@ environment:
    - GENERATOR: '"Visual Studio 17 2022" -A x64'
      BUILD_TYPE: Release
      BUILD_SHARED: 'ON'
+      FATAL_ERRORS: 'ON'
      WCHAR: 'ON'
      WCHAR_FILES: 'ON'
      BUILD_EXAMPLE: 'OFF'
@@ -103,7 +114,7 @@ build_script:

      set PATH=%PATH%;C:\Program Files\Git\usr\bin

-      cmake -G %GENERATOR% -D CMAKE_BUILD_TYPE=%BUILD_TYPE% -D BUILD_SHARED_LIBS=%BUILD_SHARED% -D SPDLOG_WCHAR_SUPPORT=%WCHAR% -D SPDLOG_WCHAR_FILENAMES=%WCHAR_FILES% -D SPDLOG_BUILD_EXAMPLE=%BUILD_EXAMPLE% -D SPDLOG_BUILD_EXAMPLE_HO=%BUILD_EXAMPLE% -D SPDLOG_BUILD_TESTS=ON -D SPDLOG_BUILD_TESTS_HO=OFF -D SPDLOG_BUILD_WARNINGS=ON -D SPDLOG_USE_STD_FORMAT=%USE_STD_FORMAT% -D CMAKE_CXX_STANDARD=%CXX_STANDARD% ..
+      cmake -G %GENERATOR% -D CMAKE_BUILD_TYPE=%BUILD_TYPE% -D BUILD_SHARED_LIBS=%BUILD_SHARED% -D SPDLOG_WCHAR_SUPPORT=%WCHAR% -D SPDLOG_WCHAR_FILENAMES=%WCHAR_FILES% -D SPDLOG_BUILD_EXAMPLE=%BUILD_EXAMPLE% -D SPDLOG_BUILD_EXAMPLE_HO=%BUILD_EXAMPLE% -D SPDLOG_BUILD_TESTS=ON -D SPDLOG_BUILD_TESTS_HO=OFF -D SPDLOG_BUILD_WARNINGS=%FATAL_ERRORS% -D SPDLOG_USE_STD_FORMAT=%USE_STD_FORMAT% -D CMAKE_CXX_STANDARD=%CXX_STANDARD% ..

      cmake --build . --config %BUILD_TYPE%

--- a/bench/latency.cpp
+++ b/bench/latency.cpp
@@ -45,7 +45,6 @@ void bench_logger_fmt_string(benchmark::State &state, std::shared_ptr<spdlog::lo
    for (auto _ : state)
    {
        logger->info(FMT_STRING("Hello logger: msg number {}..............."), ++i);
-        ;
    }
 }

@@ -98,7 +97,7 @@ int main(int argc, char *argv[])
    auto null_logger_st = std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_st>());
    benchmark::RegisterBenchmark("null_sink_st (500_bytes c_str)", bench_c_string, std::move(null_logger_st));
    benchmark::RegisterBenchmark("null_sink_st", bench_logger, null_logger_st);
-    benchmark::RegisterBenchmark("null_sink_fmt_string", bench_logger_fmt_string, null_logger_st);
+    benchmark::RegisterBenchmark("null_sink_FMT_STRING", bench_logger_fmt_string, null_logger_st);
    // with backtrace of 64
    auto tracing_null_logger_st = std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_st>());
    tracing_null_logger_st->enable_backtrace(64);
--- a/cmake/spdlog.pc.in
+++ b/cmake/spdlog.pc.in
@@ -1,7 +1,7 @@
 prefix=@CMAKE_INSTALL_PREFIX@
 exec_prefix=${prefix}
-includedir=${prefix}/include
-libdir=${exec_prefix}/@CMAKE_INSTALL_LIBDIR@
+includedir=@PKG_CONFIG_INCLUDEDIR@
+libdir=@PKG_CONFIG_LIBDIR@

 Name: lib@PROJECT_NAME@
 Description: Fast C++ logging library.
--- a/example/example.cpp
+++ b/example/example.cpp
@@ -262,16 +262,27 @@ struct my_type
        : i(i){};
 };

-namespace fmt_lib = spdlog::fmt_lib;
+#ifndef SPDLOG_USE_STD_FORMAT // when using fmtlib
 template<>
-struct fmt_lib::formatter<my_type> : fmt_lib::formatter<std::string>
+struct fmt::formatter<my_type> : fmt::formatter<std::string>
 {
    auto format(my_type my, format_context &ctx) -> decltype(ctx.out())
    {
-        return fmt_lib::format_to(ctx.out(), "[my_type i={}]", my.i);
+        return format_to(ctx.out(), "[my_type i={}]", my.i);
    }
 };

+#else // when using std::format
+template<>
+struct std::formatter<my_type> : std::formatter<std::string>
+{
+    auto format(my_type my, format_context &ctx) -> decltype(ctx.out())
+    {
+        return format_to(ctx.out(), "[my_type i={}]", my.i);
+    }
+};
+#endif
+
 void user_defined_example()
 {
    spdlog::info("user defined type: {}", my_type(14));
--- a/include/spdlog/common-inl.h
+++ b/include/spdlog/common-inl.h
@@ -34,7 +34,7 @@ SPDLOG_INLINE spdlog::level::level_enum from_str(const std::string &name) SPDLOG
 {
    auto it = std::find(std::begin(level_string_views), std::end(level_string_views), name);
    if (it != std::end(level_string_views))
-        return static_cast<level::level_enum>(it - std::begin(level_string_views));
+        return static_cast<level::level_enum>(std::distance(std::begin(level_string_views), it));

    // check also for "warn" and "err" before giving up..
    if (name == "warn")
--- a/include/spdlog/common.h
+++ b/include/spdlog/common.h
@@ -44,15 +44,15 @@

 #include <spdlog/fmt/fmt.h>

-#ifndef SPDLOG_USE_STD_FORMAT
-#    if FMT_VERSION >= 80000 // backward compatibility with fmt versions older than 8
-#        define SPDLOG_FMT_RUNTIME(format_string) fmt::runtime(format_string)
-#        if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
-#            include <spdlog/fmt/xchar.h>
-#        endif
-#    else
-#        define SPDLOG_FMT_RUNTIME(format_string) format_string
+#if !defined(SPDLOG_USE_STD_FORMAT) && FMT_VERSION >= 80000 // backward compatibility with fmt versions older than 8
+#    define SPDLOG_FMT_RUNTIME(format_string) fmt::runtime(format_string)
+#    define SPDLOG_FMT_STRING(format_string) FMT_STRING(format_string)
+#    if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
+#        include <spdlog/fmt/xchar.h>
 #    endif
+#else
+#    define SPDLOG_FMT_RUNTIME(format_string) format_string
+#    define SPDLOG_FMT_STRING(format_string) format_string
 #endif

 // visual studio up to 2013 does not support noexcept nor constexpr
@@ -147,7 +147,7 @@ using wmemory_buf_t = std::wstring;
 template<typename... Args>
 using wformat_string_t = std::wstring_view;
 #    endif
-
+#    define SPDLOG_BUF_TO_STRING(x) x
 #else // use fmt lib instead of std::format
 namespace fmt_lib = fmt;

@@ -175,6 +175,7 @@ using wmemory_buf_t = fmt::basic_memory_buffer<wchar_t, 250>;
 template<typename... Args>
 using wformat_string_t = fmt::wformat_string<Args...>;
 #    endif
+#    define SPDLOG_BUF_TO_STRING(x) fmt::to_string(x)
 #endif

 #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
@@ -307,16 +308,17 @@ struct source_loc

 struct file_event_handlers
 {
+    file_event_handlers()
+        : before_open(nullptr)
+        , after_open(nullptr)
+        , before_close(nullptr)
+        , after_close(nullptr)
+    {}
+
    std::function<void(const filename_t &filename)> before_open;
    std::function<void(const filename_t &filename, std::FILE *file_stream)> after_open;
    std::function<void(const filename_t &filename, std::FILE *file_stream)> before_close;
    std::function<void(const filename_t &filename)> after_close;
-    file_event_handlers()
-        : before_open{nullptr}
-        , after_open{nullptr}
-        , before_close{nullptr}
-        , after_close{nullptr}
-    {}
 };

 namespace details {
--- a/include/spdlog/details/circular_q.h
+++ b/include/spdlog/details/circular_q.h
@@ -121,6 +121,11 @@ public:
        return overrun_counter_;
    }

+    void reset_overrun_counter()
+    {
+        overrun_counter_ = 0;
+    }
+
 private:
    // copy from other&& and reset it to disabled state
    void copy_moveable(circular_q &&other) SPDLOG_NOEXCEPT
--- a/include/spdlog/details/fmt_helper.h
+++ b/include/spdlog/details/fmt_helper.h
@@ -107,7 +107,7 @@ inline void pad2(int n, memory_buf_t &dest)
    }
    else // unlikely, but just in case, let fmt deal with it
    {
-        fmt_lib::format_to(std::back_inserter(dest), "{:02}", n);
+        fmt_lib::format_to(std::back_inserter(dest), SPDLOG_FMT_STRING("{:02}"), n);
    }
 }

--- a/include/spdlog/details/mpmc_blocking_q.h
+++ b/include/spdlog/details/mpmc_blocking_q.h
@@ -116,6 +116,12 @@ public:
        return q_.size();
    }

+    void reset_overrun_counter()
+    {
+        std::unique_lock<std::mutex> lock(queue_mutex_);
+        q_.reset_overrun_counter();
+    }
+
 private:
    std::mutex queue_mutex_;
    std::condition_variable push_cv_;
--- a/include/spdlog/details/null_mutex.h
+++ b/include/spdlog/details/null_mutex.h
@@ -13,10 +13,6 @@ struct null_mutex
 {
    void lock() const {}
    void unlock() const {}
-    bool try_lock() const
-    {
-        return true;
-    }
 };

 struct null_atomic_int
--- a/include/spdlog/details/os-inl.h
+++ b/include/spdlog/details/os-inl.h
@@ -388,11 +388,7 @@ SPDLOG_INLINE std::string filename_to_str(const filename_t &filename)
 {
    memory_buf_t buf;
    wstr_to_utf8buf(filename, buf);
-#    ifdef SPDLOG_USE_STD_FORMAT
-    return buf;
-#    else
-    return fmt::to_string(buf);
-#    endif
+    return SPDLOG_BUF_TO_STRING(buf);
 }
 #else
 SPDLOG_INLINE std::string filename_to_str(const filename_t &filename)
--- a/include/spdlog/details/periodic_worker-inl.h
+++ b/include/spdlog/details/periodic_worker-inl.h
@@ -10,27 +10,6 @@
 namespace spdlog {
 namespace details {

-SPDLOG_INLINE periodic_worker::periodic_worker(const std::function<void()> &callback_fun, std::chrono::seconds interval)
-{
-    active_ = (interval > std::chrono::seconds::zero());
-    if (!active_)
-    {
-        return;
-    }
-
-    worker_thread_ = std::thread([this, callback_fun, interval]() {
-        for (;;)
-        {
-            std::unique_lock<std::mutex> lock(this->mutex_);
-            if (this->cv_.wait_for(lock, interval, [this] { return !this->active_; }))
-            {
-                return; // active_ == false, so exit this thread
-            }
-            callback_fun();
-        }
-    });
-}
-
 // stop the worker thread and join it
 SPDLOG_INLINE periodic_worker::~periodic_worker()
 {
--- a/include/spdlog/details/periodic_worker.h
+++ b/include/spdlog/details/periodic_worker.h
@@ -20,7 +20,27 @@ namespace details {
 class SPDLOG_API periodic_worker
 {
 public:
-    periodic_worker(const std::function<void()> &callback_fun, std::chrono::seconds interval);
+    template<typename Rep, typename Period>
+    periodic_worker(const std::function<void()> &callback_fun, std::chrono::duration<Rep, Period> interval)
+    {
+        active_ = (interval > std::chrono::duration<Rep, Period>::zero());
+        if (!active_)
+        {
+            return;
+        }
+
+        worker_thread_ = std::thread([this, callback_fun, interval]() {
+            for (;;)
+            {
+                std::unique_lock<std::mutex> lock(this->mutex_);
+                if (this->cv_.wait_for(lock, interval, [this] { return !this->active_; }))
+                {
+                    return; // active_ == false, so exit this thread
+                }
+                callback_fun();
+            }
+        });
+    }
    periodic_worker(const periodic_worker &) = delete;
    periodic_worker &operator=(const periodic_worker &) = delete;
    // stop the worker thread and join it
--- a/include/spdlog/details/registry-inl.h
+++ b/include/spdlog/details/registry-inl.h
@@ -188,13 +188,6 @@ SPDLOG_INLINE void registry::flush_on(level::level_enum log_level)
    flush_level_ = log_level;
 }

-SPDLOG_INLINE void registry::flush_every(std::chrono::seconds interval)
-{
-    std::lock_guard<std::mutex> lock(flusher_mutex_);
-    auto clbk = [this]() { this->flush_all(); };
-    periodic_flusher_ = details::make_unique<periodic_worker>(clbk, interval);
-}
-
 SPDLOG_INLINE void registry::set_error_handler(err_handler handler)
 {
    std::lock_guard<std::mutex> lock(logger_map_mutex_);
--- a/include/spdlog/details/registry.h
+++ b/include/spdlog/details/registry.h
@@ -9,6 +9,7 @@
 // This class is thread safe

 #include <spdlog/common.h>
+#include <spdlog/details/periodic_worker.h>

 #include <chrono>
 #include <functional>
@@ -22,7 +23,6 @@ class logger;

 namespace details {
 class thread_pool;
-class periodic_worker;

 class SPDLOG_API registry
 {
@@ -61,7 +61,13 @@ public:

    void flush_on(level::level_enum log_level);

-    void flush_every(std::chrono::seconds interval);
+    template<typename Rep, typename Period>
+    void flush_every(std::chrono::duration<Rep, Period> interval)
+    {
+        std::lock_guard<std::mutex> lock(flusher_mutex_);
+        auto clbk = [this]() { this->flush_all(); };
+        periodic_flusher_ = details::make_unique<periodic_worker>(clbk, interval);
+    }

    void set_error_handler(err_handler handler);

--- a/include/spdlog/details/thread_pool-inl.h
+++ b/include/spdlog/details/thread_pool-inl.h
@@ -75,6 +75,11 @@ size_t SPDLOG_INLINE thread_pool::overrun_counter()
    return q_.overrun_counter();
 }

+void SPDLOG_INLINE thread_pool::reset_overrun_counter()
+{
+    q_.reset_overrun_counter();
+}
+
 size_t SPDLOG_INLINE thread_pool::queue_size()
 {
    return q_.size();
--- a/include/spdlog/details/thread_pool.h
+++ b/include/spdlog/details/thread_pool.h
@@ -97,6 +97,7 @@ public:
    void post_log(async_logger_ptr &&worker_ptr, const details::log_msg &msg, async_overflow_policy overflow_policy);
    void post_flush(async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy);
    size_t overrun_counter();
+    void reset_overrun_counter();
    size_t queue_size();

 private:
--- a/include/spdlog/fmt/bin_to_hex.h
+++ b/include/spdlog/fmt/bin_to_hex.h
@@ -8,8 +8,10 @@
 #include <cctype>
 #include <spdlog/common.h>

-#if defined(__has_include) && __has_include(<version>)
-#    include <version>
+#if defined(__has_include)
+#    if __has_include(<version>)
+#        include <version>
+#    endif
 #endif

 #if __cpp_lib_span >= 202002L
@@ -239,7 +241,7 @@ struct formatter<spdlog::details::dump_info<T>, char>

        if (put_positions)
        {
-            spdlog::fmt_lib::format_to(inserter, "{:04X}: ", pos);
+            spdlog::fmt_lib::format_to(inserter, SPDLOG_FMT_STRING("{:04X}: "), pos);
        }
    }
 };
--- a/include/spdlog/fmt/bundled/args.h
+++ b/include/spdlog/fmt/bundled/args.h
@@ -95,10 +95,10 @@ class dynamic_format_arg_store
  };

  template <typename T>
-  using stored_type = conditional_t<detail::is_string<T>::value &&
-                                        !has_formatter<T, Context>::value &&
-                                        !detail::is_reference_wrapper<T>::value,
-                                    std::basic_string<char_type>, T>;
+  using stored_type = conditional_t<
+      std::is_convertible<T, std::basic_string<char_type>>::value &&
+          !detail::is_reference_wrapper<T>::value,
+      std::basic_string<char_type>, T>;

  // Storage of basic_format_arg must be contiguous.
  std::vector<basic_format_arg<Context>> data_;
--- a/include/spdlog/fmt/bundled/chrono.h
+++ b/include/spdlog/fmt/bundled/chrono.h
@@ -10,6 +10,8 @@

 #include <algorithm>
 #include <chrono>
+#include <cmath>    // std::isfinite
+#include <cstring>  // std::memcpy
 #include <ctime>
 #include <iterator>
 #include <locale>
@@ -201,7 +203,7 @@ To safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from,
    }
    const auto min1 =
        (std::numeric_limits<IntermediateRep>::min)() / Factor::num;
-    if (count < min1) {
+    if (!std::is_unsigned<IntermediateRep>::value && count < min1) {
      ec = 1;
      return {};
    }
@@ -321,14 +323,13 @@ constexpr const size_t codecvt_result<CodeUnit>::max_size;
 template <typename CodeUnit>
 void write_codecvt(codecvt_result<CodeUnit>& out, string_view in_buf,
                   const std::locale& loc) {
-  using codecvt = std::codecvt<CodeUnit, char, std::mbstate_t>;
 #if FMT_CLANG_VERSION
 #  pragma clang diagnostic push
 #  pragma clang diagnostic ignored "-Wdeprecated"
-  auto& f = std::use_facet<codecvt>(loc);
+  auto& f = std::use_facet<std::codecvt<CodeUnit, char, std::mbstate_t>>(loc);
 #  pragma clang diagnostic pop
 #else
-  auto& f = std::use_facet<codecvt>(loc);
+  auto& f = std::use_facet<std::codecvt<CodeUnit, char, std::mbstate_t>>(loc);
 #endif
  auto mb = std::mbstate_t();
  const char* from_next = nullptr;
@@ -344,7 +345,7 @@ auto write_encoded_tm_str(OutputIt out, string_view in, const std::locale& loc)
  if (detail::is_utf8() && loc != get_classic_locale()) {
    // char16_t and char32_t codecvts are broken in MSVC (linkage errors) and
    // gcc-4.
-#if FMT_MSC_VER != 0 || \
+#if FMT_MSC_VERSION != 0 || \
    (defined(__GLIBCXX__) && !defined(_GLIBCXX_USE_DUAL_ABI))
    // The _GLIBCXX_USE_DUAL_ABI macro is always defined in libstdc++ from gcc-5
    // and newer.
@@ -468,7 +469,7 @@ inline std::tm localtime(std::time_t time) {

    bool fallback(int res) { return res == 0; }

-#if !FMT_MSC_VER
+#if !FMT_MSC_VERSION
    bool fallback(detail::null<>) {
      using namespace fmt::detail;
      std::tm* tm = std::localtime(&time_);
@@ -514,7 +515,7 @@ inline std::tm gmtime(std::time_t time) {

    bool fallback(int res) { return res == 0; }

-#if !FMT_MSC_VER
+#if !FMT_MSC_VERSION
    bool fallback(detail::null<>) {
      std::tm* tm = std::gmtime(&time_);
      if (tm) tm_ = *tm;
@@ -562,10 +563,10 @@ inline void write_digit2_separated(char* buf, unsigned a, unsigned b,
  constexpr const size_t len = 8;
  if (const_check(is_big_endian())) {
    char tmp[len];
-    memcpy(tmp, &digits, len);
+    std::memcpy(tmp, &digits, len);
    std::reverse_copy(tmp, tmp + len, buf);
  } else {
-    memcpy(buf, &digits, len);
+    std::memcpy(buf, &digits, len);
  }
 }

@@ -1214,7 +1215,7 @@ template <typename OutputIt, typename Char> class tm_writer {
    char buf[10];
    size_t offset = 0;
    if (year >= 0 && year < 10000) {
-      copy2(buf, digits2(to_unsigned(year / 100)));
+      copy2(buf, digits2(static_cast<size_t>(year / 100)));
    } else {
      offset = 4;
      write_year_extended(year);
@@ -1387,15 +1388,6 @@ struct chrono_format_checker : null_chrono_spec_handler<chrono_format_checker> {
  FMT_CONSTEXPR void on_duration_unit() {}
 };

-template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-inline bool isnan(T) {
-  return false;
-}
-template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
-inline bool isnan(T value) {
-  return std::isnan(value);
-}
-
 template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
 inline bool isfinite(T) {
  return true;
@@ -1404,7 +1396,8 @@ inline bool isfinite(T) {
 // Converts value to Int and checks that it's in the range [0, upper).
 template <typename T, typename Int, FMT_ENABLE_IF(std::is_integral<T>::value)>
 inline Int to_nonnegative_int(T value, Int upper) {
-  FMT_ASSERT(value >= 0 && to_unsigned(value) <= to_unsigned(upper),
+  FMT_ASSERT(std::is_unsigned<Int>::value ||
+             (value >= 0 && to_unsigned(value) <= to_unsigned(upper)),
             "invalid value");
  (void)upper;
  return static_cast<Int>(value);
@@ -1470,14 +1463,22 @@ inline std::chrono::duration<Rep, std::milli> get_milliseconds(
 #endif
 }

-// Returns the number of fractional digits in the range [0, 18] according to the
+// Counts the number of fractional digits in the range [0, 18] according to the
 // C++20 spec. If more than 18 fractional digits are required then returns 6 for
 // microseconds precision.
-constexpr int count_fractional_digits(long long num, long long den, int n = 0) {
-  return num % den == 0
-             ? n
-             : (n > 18 ? 6 : count_fractional_digits(num * 10, den, n + 1));
-}
+template <long long Num, long long Den, int N = 0,
+          bool Enabled = (N < 19) && (Num <= max_value<long long>() / 10)>
+struct count_fractional_digits {
+  static constexpr int value =
+      Num % Den == 0 ? N : count_fractional_digits<Num * 10, Den, N + 1>::value;
+};
+
+// Base case that doesn't instantiate any more templates
+// in order to avoid overflow.
+template <long long Num, long long Den, int N>
+struct count_fractional_digits<Num, Den, N, false> {
+  static constexpr int value = (Num % Den == 0) ? N : 6;
+};

 constexpr long long pow10(std::uint32_t n) {
  return n == 0 ? 1 : 10 * pow10(n - 1);
@@ -1663,9 +1664,11 @@ struct chrono_formatter {
    out = format_decimal<char_type>(out, n, num_digits).end;
  }

-  template <class Duration> void write_fractional_seconds(Duration d) {
+  template <typename Duration> void write_fractional_seconds(Duration d) {
+    FMT_ASSERT(!std::is_floating_point<typename Duration::rep>::value, "");
    constexpr auto num_fractional_digits =
-        count_fractional_digits(Duration::period::num, Duration::period::den);
+        count_fractional_digits<Duration::period::num,
+                                Duration::period::den>::value;

    using subsecond_precision = std::chrono::duration<
        typename std::common_type<typename Duration::rep,
@@ -1674,12 +1677,9 @@ struct chrono_formatter {
    if (std::ratio_less<typename subsecond_precision::period,
                        std::chrono::seconds::period>::value) {
      *out++ = '.';
-      // Don't convert long double to integer seconds to avoid overflow.
-      using sec = conditional_t<
-          std::is_same<typename Duration::rep, long double>::value,
-          std::chrono::duration<long double>, std::chrono::seconds>;
-      auto fractional = detail::abs(d) - std::chrono::duration_cast<sec>(d);
-      const auto subseconds =
+      auto fractional =
+          detail::abs(d) - std::chrono::duration_cast<std::chrono::seconds>(d);
+      auto subseconds =
          std::chrono::treat_as_floating_point<
              typename subsecond_precision::rep>::value
              ? fractional.count()
@@ -1770,8 +1770,22 @@ struct chrono_formatter {
    if (handle_nan_inf()) return;

    if (ns == numeric_system::standard) {
-      write(second(), 2);
-      write_fractional_seconds(std::chrono::duration<rep, Period>{val});
+      if (std::is_floating_point<rep>::value) {
+        constexpr auto num_fractional_digits =
+            count_fractional_digits<Period::num, Period::den>::value;
+        auto buf = memory_buffer();
+        format_to(std::back_inserter(buf), runtime("{:.{}f}"),
+                  std::fmod(val * static_cast<rep>(Period::num) /
+                                static_cast<rep>(Period::den),
+                            static_cast<rep>(60)),
+                  num_fractional_digits);
+        if (negative) *out++ = '-';
+        if (buf.size() < 2 || buf[1] == '.') *out++ = '0';
+        out = std::copy(buf.begin(), buf.end(), out);
+      } else {
+        write(second(), 2);
+        write_fractional_seconds(std::chrono::duration<rep, Period>(val));
+      }
      return;
    }
    auto time = tm();
@@ -1988,13 +2002,9 @@ template <typename Char, typename Duration>
 struct formatter<std::chrono::time_point<std::chrono::system_clock, Duration>,
                 Char> : formatter<std::tm, Char> {
  FMT_CONSTEXPR formatter() {
-    this->do_parse(default_specs,
-                   default_specs + sizeof(default_specs) / sizeof(Char));
-  }
-
-  template <typename ParseContext>
-  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
-    return this->do_parse(ctx.begin(), ctx.end(), true);
+    basic_string_view<Char> default_specs =
+        detail::string_literal<Char, '%', 'F', ' ', '%', 'T'>{};
+    this->do_parse(default_specs.begin(), default_specs.end());
  }

  template <typename FormatContext>
@@ -2002,15 +2012,8 @@ struct formatter<std::chrono::time_point<std::chrono::system_clock, Duration>,
              FormatContext& ctx) const -> decltype(ctx.out()) {
    return formatter<std::tm, Char>::format(localtime(val), ctx);
  }
-
-  static constexpr const Char default_specs[] = {'%', 'F', ' ', '%', 'T'};
 };

-template <typename Char, typename Duration>
-constexpr const Char
-    formatter<std::chrono::time_point<std::chrono::system_clock, Duration>,
-              Char>::default_specs[];
-
 template <typename Char> struct formatter<std::tm, Char> {
 private:
  enum class spec {
@@ -2022,13 +2025,18 @@ template <typename Char> struct formatter<std::tm, Char> {
  basic_string_view<Char> specs;

 protected:
-  template <typename It>
-  FMT_CONSTEXPR auto do_parse(It begin, It end, bool with_default = false)
-      -> It {
+  template <typename It> FMT_CONSTEXPR auto do_parse(It begin, It end) -> It {
    if (begin != end && *begin == ':') ++begin;
    end = detail::parse_chrono_format(begin, end, detail::tm_format_checker());
-    if (!with_default || end != begin)
-      specs = {begin, detail::to_unsigned(end - begin)};
+    // Replace default spec only if the new spec is not empty.
+    if (end != begin) specs = {begin, detail::to_unsigned(end - begin)};
+    return end;
+  }
+
+ public:
+  FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx)
+      -> decltype(ctx.begin()) {
+    auto end = this->do_parse(ctx.begin(), ctx.end());
    // basic_string_view<>::compare isn't constexpr before C++17.
    if (specs.size() == 2 && specs[0] == Char('%')) {
      if (specs[1] == Char('F'))
@@ -2039,12 +2047,6 @@ template <typename Char> struct formatter<std::tm, Char> {
    return end;
  }

- public:
-  template <typename ParseContext>
-  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
-    return this->do_parse(ctx.begin(), ctx.end());
-  }
-
  template <typename FormatContext>
  auto format(const std::tm& tm, FormatContext& ctx) const
      -> decltype(ctx.out()) {
--- a/include/spdlog/fmt/bundled/color.h
+++ b/include/spdlog/fmt/bundled/color.h
@@ -10,13 +10,6 @@

 #include "format.h"

-// __declspec(deprecated) is broken in some MSVC versions.
-#if FMT_MSC_VER
-#  define FMT_DEPRECATED_NONMSVC
-#else
-#  define FMT_DEPRECATED_NONMSVC FMT_DEPRECATED
-#endif
-
 FMT_BEGIN_NAMESPACE
 FMT_MODULE_EXPORT_BEGIN

@@ -214,17 +207,16 @@ FMT_BEGIN_DETAIL_NAMESPACE

 // color is a struct of either a rgb color or a terminal color.
 struct color_type {
-  FMT_CONSTEXPR color_type() FMT_NOEXCEPT : is_rgb(), value{} {}
-  FMT_CONSTEXPR color_type(color rgb_color) FMT_NOEXCEPT : is_rgb(true),
-                                                           value{} {
+  FMT_CONSTEXPR color_type() noexcept : is_rgb(), value{} {}
+  FMT_CONSTEXPR color_type(color rgb_color) noexcept : is_rgb(true), value{} {
    value.rgb_color = static_cast<uint32_t>(rgb_color);
  }
-  FMT_CONSTEXPR color_type(rgb rgb_color) FMT_NOEXCEPT : is_rgb(true), value{} {
+  FMT_CONSTEXPR color_type(rgb rgb_color) noexcept : is_rgb(true), value{} {
    value.rgb_color = (static_cast<uint32_t>(rgb_color.r) << 16) |
                      (static_cast<uint32_t>(rgb_color.g) << 8) | rgb_color.b;
  }
-  FMT_CONSTEXPR color_type(terminal_color term_color) FMT_NOEXCEPT : is_rgb(),
-                                                                     value{} {
+  FMT_CONSTEXPR color_type(terminal_color term_color) noexcept
+      : is_rgb(), value{} {
    value.term_color = static_cast<uint8_t>(term_color);
  }
  bool is_rgb;
@@ -239,10 +231,8 @@ FMT_END_DETAIL_NAMESPACE
 /** A text style consisting of foreground and background colors and emphasis. */
 class text_style {
 public:
-  FMT_CONSTEXPR text_style(emphasis em = emphasis()) FMT_NOEXCEPT
-      : set_foreground_color(),
-        set_background_color(),
-        ems(em) {}
+  FMT_CONSTEXPR text_style(emphasis em = emphasis()) noexcept
+      : set_foreground_color(), set_background_color(), ems(em) {}

  FMT_CONSTEXPR text_style& operator|=(const text_style& rhs) {
    if (!set_foreground_color) {
@@ -273,44 +263,32 @@ class text_style {
    return lhs |= rhs;
  }

-  FMT_DEPRECATED_NONMSVC FMT_CONSTEXPR text_style& operator&=(
-      const text_style& rhs) {
-    return and_assign(rhs);
-  }
-
-  FMT_DEPRECATED_NONMSVC friend FMT_CONSTEXPR text_style
-  operator&(text_style lhs, const text_style& rhs) {
-    return lhs.and_assign(rhs);
-  }
-
-  FMT_CONSTEXPR bool has_foreground() const FMT_NOEXCEPT {
+  FMT_CONSTEXPR bool has_foreground() const noexcept {
    return set_foreground_color;
  }
-  FMT_CONSTEXPR bool has_background() const FMT_NOEXCEPT {
+  FMT_CONSTEXPR bool has_background() const noexcept {
    return set_background_color;
  }
-  FMT_CONSTEXPR bool has_emphasis() const FMT_NOEXCEPT {
+  FMT_CONSTEXPR bool has_emphasis() const noexcept {
    return static_cast<uint8_t>(ems) != 0;
  }
-  FMT_CONSTEXPR detail::color_type get_foreground() const FMT_NOEXCEPT {
+  FMT_CONSTEXPR detail::color_type get_foreground() const noexcept {
    FMT_ASSERT(has_foreground(), "no foreground specified for this style");
    return foreground_color;
  }
-  FMT_CONSTEXPR detail::color_type get_background() const FMT_NOEXCEPT {
+  FMT_CONSTEXPR detail::color_type get_background() const noexcept {
    FMT_ASSERT(has_background(), "no background specified for this style");
    return background_color;
  }
-  FMT_CONSTEXPR emphasis get_emphasis() const FMT_NOEXCEPT {
+  FMT_CONSTEXPR emphasis get_emphasis() const noexcept {
    FMT_ASSERT(has_emphasis(), "no emphasis specified for this style");
    return ems;
  }

 private:
  FMT_CONSTEXPR text_style(bool is_foreground,
-                           detail::color_type text_color) FMT_NOEXCEPT
-      : set_foreground_color(),
-        set_background_color(),
-        ems() {
+                           detail::color_type text_color) noexcept
+      : set_foreground_color(), set_background_color(), ems() {
    if (is_foreground) {
      foreground_color = text_color;
      set_foreground_color = true;
@@ -320,36 +298,9 @@ class text_style {
    }
  }

-  // DEPRECATED!
-  FMT_CONSTEXPR text_style& and_assign(const text_style& rhs) {
-    if (!set_foreground_color) {
-      set_foreground_color = rhs.set_foreground_color;
-      foreground_color = rhs.foreground_color;
-    } else if (rhs.set_foreground_color) {
-      if (!foreground_color.is_rgb || !rhs.foreground_color.is_rgb)
-        FMT_THROW(format_error("can't AND a terminal color"));
-      foreground_color.value.rgb_color &= rhs.foreground_color.value.rgb_color;
-    }
+  friend FMT_CONSTEXPR text_style fg(detail::color_type foreground) noexcept;

-    if (!set_background_color) {
-      set_background_color = rhs.set_background_color;
-      background_color = rhs.background_color;
-    } else if (rhs.set_background_color) {
-      if (!background_color.is_rgb || !rhs.background_color.is_rgb)
-        FMT_THROW(format_error("can't AND a terminal color"));
-      background_color.value.rgb_color &= rhs.background_color.value.rgb_color;
-    }
-
-    ems = static_cast<emphasis>(static_cast<uint8_t>(ems) &
-                                static_cast<uint8_t>(rhs.ems));
-    return *this;
-  }
-
-  friend FMT_CONSTEXPR_DECL text_style fg(detail::color_type foreground)
-      FMT_NOEXCEPT;
-
-  friend FMT_CONSTEXPR_DECL text_style bg(detail::color_type background)
-      FMT_NOEXCEPT;
+  friend FMT_CONSTEXPR text_style bg(detail::color_type background) noexcept;

  detail::color_type foreground_color;
  detail::color_type background_color;
@@ -359,17 +310,16 @@ class text_style {
 };

 /** Creates a text style from the foreground (text) color. */
-FMT_CONSTEXPR inline text_style fg(detail::color_type foreground) FMT_NOEXCEPT {
+FMT_CONSTEXPR inline text_style fg(detail::color_type foreground) noexcept {
  return text_style(true, foreground);
 }

 /** Creates a text style from the background color. */
-FMT_CONSTEXPR inline text_style bg(detail::color_type background) FMT_NOEXCEPT {
+FMT_CONSTEXPR inline text_style bg(detail::color_type background) noexcept {
  return text_style(false, background);
 }

-FMT_CONSTEXPR inline text_style operator|(emphasis lhs,
-                                          emphasis rhs) FMT_NOEXCEPT {
+FMT_CONSTEXPR inline text_style operator|(emphasis lhs, emphasis rhs) noexcept {
  return text_style(lhs) | rhs;
 }

@@ -377,7 +327,7 @@ FMT_BEGIN_DETAIL_NAMESPACE

 template <typename Char> struct ansi_color_escape {
  FMT_CONSTEXPR ansi_color_escape(detail::color_type text_color,
-                                  const char* esc) FMT_NOEXCEPT {
+                                  const char* esc) noexcept {
    // If we have a terminal color, we need to output another escape code
    // sequence.
    if (!text_color.is_rgb) {
@@ -412,7 +362,7 @@ template <typename Char> struct ansi_color_escape {
    to_esc(color.b, buffer + 15, 'm');
    buffer[19] = static_cast<Char>(0);
  }
-  FMT_CONSTEXPR ansi_color_escape(emphasis em) FMT_NOEXCEPT {
+  FMT_CONSTEXPR ansi_color_escape(emphasis em) noexcept {
    uint8_t em_codes[num_emphases] = {};
    if (has_emphasis(em, emphasis::bold)) em_codes[0] = 1;
    if (has_emphasis(em, emphasis::faint)) em_codes[1] = 2;
@@ -433,10 +383,10 @@ template <typename Char> struct ansi_color_escape {
    }
    buffer[index++] = static_cast<Char>(0);
  }
-  FMT_CONSTEXPR operator const Char*() const FMT_NOEXCEPT { return buffer; }
+  FMT_CONSTEXPR operator const Char*() const noexcept { return buffer; }

-  FMT_CONSTEXPR const Char* begin() const FMT_NOEXCEPT { return buffer; }
-  FMT_CONSTEXPR_CHAR_TRAITS const Char* end() const FMT_NOEXCEPT {
+  FMT_CONSTEXPR const Char* begin() const noexcept { return buffer; }
+  FMT_CONSTEXPR_CHAR_TRAITS const Char* end() const noexcept {
    return buffer + std::char_traits<Char>::length(buffer);
  }

@@ -445,59 +395,64 @@ template <typename Char> struct ansi_color_escape {
  Char buffer[7u + 3u * num_emphases + 1u];

  static FMT_CONSTEXPR void to_esc(uint8_t c, Char* out,
-                                   char delimiter) FMT_NOEXCEPT {
+                                   char delimiter) noexcept {
    out[0] = static_cast<Char>('0' + c / 100);
    out[1] = static_cast<Char>('0' + c / 10 % 10);
    out[2] = static_cast<Char>('0' + c % 10);
    out[3] = static_cast<Char>(delimiter);
  }
-  static FMT_CONSTEXPR bool has_emphasis(emphasis em,
-                                         emphasis mask) FMT_NOEXCEPT {
+  static FMT_CONSTEXPR bool has_emphasis(emphasis em, emphasis mask) noexcept {
    return static_cast<uint8_t>(em) & static_cast<uint8_t>(mask);
  }
 };

 template <typename Char>
 FMT_CONSTEXPR ansi_color_escape<Char> make_foreground_color(
-    detail::color_type foreground) FMT_NOEXCEPT {
+    detail::color_type foreground) noexcept {
  return ansi_color_escape<Char>(foreground, "\x1b[38;2;");
 }

 template <typename Char>
 FMT_CONSTEXPR ansi_color_escape<Char> make_background_color(
-    detail::color_type background) FMT_NOEXCEPT {
+    detail::color_type background) noexcept {
  return ansi_color_escape<Char>(background, "\x1b[48;2;");
 }

 template <typename Char>
-FMT_CONSTEXPR ansi_color_escape<Char> make_emphasis(emphasis em) FMT_NOEXCEPT {
+FMT_CONSTEXPR ansi_color_escape<Char> make_emphasis(emphasis em) noexcept {
  return ansi_color_escape<Char>(em);
 }

-template <typename Char>
-inline void fputs(const Char* chars, FILE* stream) FMT_NOEXCEPT {
-  std::fputs(chars, stream);
+template <typename Char> inline void fputs(const Char* chars, FILE* stream) {
+  int result = std::fputs(chars, stream);
+  if (result < 0)
+    FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
 }

-template <>
-inline void fputs<wchar_t>(const wchar_t* chars, FILE* stream) FMT_NOEXCEPT {
-  std::fputws(chars, stream);
+template <> inline void fputs<wchar_t>(const wchar_t* chars, FILE* stream) {
+  int result = std::fputws(chars, stream);
+  if (result < 0)
+    FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
 }

-template <typename Char> inline void reset_color(FILE* stream) FMT_NOEXCEPT {
+template <typename Char> inline void reset_color(FILE* stream) {
  fputs("\x1b[0m", stream);
 }

-template <> inline void reset_color<wchar_t>(FILE* stream) FMT_NOEXCEPT {
+template <> inline void reset_color<wchar_t>(FILE* stream) {
  fputs(L"\x1b[0m", stream);
 }

-template <typename Char>
-inline void reset_color(buffer<Char>& buffer) FMT_NOEXCEPT {
+template <typename Char> inline void reset_color(buffer<Char>& buffer) {
  auto reset_color = string_view("\x1b[0m");
  buffer.append(reset_color.begin(), reset_color.end());
 }

+template <typename T> struct styled_arg {
+  const T& value;
+  text_style style;
+};
+
 template <typename Char>
 void vformat_to(buffer<Char>& buf, const text_style& ts,
                basic_string_view<Char> format_str,
@@ -528,9 +483,13 @@ template <typename S, typename Char = char_t<S>>
 void vprint(std::FILE* f, const text_style& ts, const S& format,
            basic_format_args<buffer_context<type_identity_t<Char>>> args) {
  basic_memory_buffer<Char> buf;
-  detail::vformat_to(buf, ts, to_string_view(format), args);
-  buf.push_back(Char(0));
-  detail::fputs(buf.data(), f);
+  detail::vformat_to(buf, ts, detail::to_string_view(format), args);
+  if (detail::is_utf8()) {
+    detail::print(f, basic_string_view<Char>(buf.begin(), buf.size()));
+  } else {
+    buf.push_back(Char(0));
+    detail::fputs(buf.data(), f);
+  }
 }

 /**
@@ -549,7 +508,7 @@ template <typename S, typename... Args,
 void print(std::FILE* f, const text_style& ts, const S& format_str,
           const Args&... args) {
  vprint(f, ts, format_str,
-         fmt::make_args_checked<Args...>(format_str, args...));
+         fmt::make_format_args<buffer_context<char_t<S>>>(args...));
 }

 /**
@@ -574,7 +533,7 @@ inline std::basic_string<Char> vformat(
    const text_style& ts, const S& format_str,
    basic_format_args<buffer_context<type_identity_t<Char>>> args) {
  basic_memory_buffer<Char> buf;
-  detail::vformat_to(buf, ts, to_string_view(format_str), args);
+  detail::vformat_to(buf, ts, detail::to_string_view(format_str), args);
  return fmt::to_string(buf);
 }

@@ -593,8 +552,8 @@ inline std::basic_string<Char> vformat(
 template <typename S, typename... Args, typename Char = char_t<S>>
 inline std::basic_string<Char> format(const text_style& ts, const S& format_str,
                                      const Args&... args) {
-  return fmt::vformat(ts, to_string_view(format_str),
-                      fmt::make_args_checked<Args...>(format_str, args...));
+  return fmt::vformat(ts, detail::to_string_view(format_str),
+                      fmt::make_format_args<buffer_context<Char>>(args...));
 }

 /**
@@ -628,8 +587,62 @@ template <typename OutputIt, typename S, typename... Args,
 inline auto format_to(OutputIt out, const text_style& ts, const S& format_str,
                      Args&&... args) ->
    typename std::enable_if<enable, OutputIt>::type {
-  return vformat_to(out, ts, to_string_view(format_str),
-                    fmt::make_args_checked<Args...>(format_str, args...));
+  return vformat_to(out, ts, detail::to_string_view(format_str),
+                    fmt::make_format_args<buffer_context<char_t<S>>>(args...));
+}
+
+template <typename T, typename Char>
+struct formatter<detail::styled_arg<T>, Char> : formatter<T, Char> {
+  template <typename FormatContext>
+  auto format(const detail::styled_arg<T>& arg, FormatContext& ctx) const
+      -> decltype(ctx.out()) {
+    const auto& ts = arg.style;
+    const auto& value = arg.value;
+    auto out = ctx.out();
+
+    bool has_style = false;
+    if (ts.has_emphasis()) {
+      has_style = true;
+      auto emphasis = detail::make_emphasis<Char>(ts.get_emphasis());
+      out = std::copy(emphasis.begin(), emphasis.end(), out);
+    }
+    if (ts.has_foreground()) {
+      has_style = true;
+      auto foreground =
+          detail::make_foreground_color<Char>(ts.get_foreground());
+      out = std::copy(foreground.begin(), foreground.end(), out);
+    }
+    if (ts.has_background()) {
+      has_style = true;
+      auto background =
+          detail::make_background_color<Char>(ts.get_background());
+      out = std::copy(background.begin(), background.end(), out);
+    }
+    out = formatter<T, Char>::format(value, ctx);
+    if (has_style) {
+      auto reset_color = string_view("\x1b[0m");
+      out = std::copy(reset_color.begin(), reset_color.end(), out);
+    }
+    return out;
+  }
+};
+
+/**
+  \rst
+  Returns an argument that will be formatted using ANSI escape sequences,
+  to be used in a formatting function.
+
+  **Example**::
+
+    fmt::print("Elapsed time: {0:.2f} seconds",
+               fmt::styled(1.23, fmt::fg(fmt::color::green) |
+                                 fmt::bg(fmt::color::blue)));
+  \endrst
+ */
+template <typename T>
+FMT_CONSTEXPR auto styled(const T& value, text_style ts)
+    -> detail::styled_arg<remove_cvref_t<T>> {
+  return detail::styled_arg<remove_cvref_t<T>>{value, ts};
 }

 FMT_MODULE_EXPORT_END
--- a/include/spdlog/fmt/bundled/compile.h
+++ b/include/spdlog/fmt/bundled/compile.h
@@ -13,48 +13,9 @@
 FMT_BEGIN_NAMESPACE
 namespace detail {

-// An output iterator that counts the number of objects written to it and
-// discards them.
-class counting_iterator {
- private:
-  size_t count_;
-
- public:
-  using iterator_category = std::output_iterator_tag;
-  using difference_type = std::ptrdiff_t;
-  using pointer = void;
-  using reference = void;
-  using _Unchecked_type = counting_iterator;  // Mark iterator as checked.
-
-  struct value_type {
-    template <typename T> void operator=(const T&) {}
-  };
-
-  counting_iterator() : count_(0) {}
-
-  size_t count() const { return count_; }
-
-  counting_iterator& operator++() {
-    ++count_;
-    return *this;
-  }
-  counting_iterator operator++(int) {
-    auto it = *this;
-    ++*this;
-    return it;
-  }
-
-  friend counting_iterator operator+(counting_iterator it, difference_type n) {
-    it.count_ += static_cast<size_t>(n);
-    return it;
-  }
-
-  value_type operator*() const { return {}; }
-};
-
 template <typename Char, typename InputIt>
-inline counting_iterator copy_str(InputIt begin, InputIt end,
-                                  counting_iterator it) {
+FMT_CONSTEXPR inline counting_iterator copy_str(InputIt begin, InputIt end,
+                                                counting_iterator it) {
  return it + (end - begin);
 }

@@ -75,8 +36,7 @@ template <typename OutputIt> class truncating_iterator_base {
  using difference_type = std::ptrdiff_t;
  using pointer = void;
  using reference = void;
-  using _Unchecked_type =
-      truncating_iterator_base;  // Mark iterator as checked.
+  FMT_UNCHECKED_ITERATOR(truncating_iterator_base);

  OutputIt base() const { return out_; }
  size_t count() const { return count_; }
@@ -163,12 +123,12 @@ struct is_compiled_string : std::is_base_of<compiled_string, S> {};
 #  define FMT_COMPILE(s) FMT_STRING(s)
 #endif

-#if FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
+#if FMT_USE_NONTYPE_TEMPLATE_ARGS
 template <typename Char, size_t N,
          fmt::detail_exported::fixed_string<Char, N> Str>
 struct udl_compiled_string : compiled_string {
  using char_type = Char;
-  constexpr operator basic_string_view<char_type>() const {
+  explicit constexpr operator basic_string_view<char_type>() const {
    return {Str.data, N - 1};
  }
 };
@@ -377,10 +337,11 @@ template <typename T, typename Char>
 constexpr parse_specs_result<T, Char> parse_specs(basic_string_view<Char> str,
                                                  size_t pos, int next_arg_id) {
  str.remove_prefix(pos);
-  auto ctx = basic_format_parse_context<Char>(str, {}, next_arg_id);
+  auto ctx = compile_parse_context<Char>(str, max_value<int>(), nullptr, {},
+                                         next_arg_id);
  auto f = formatter<T, Char>();
  auto end = f.parse(ctx);
-  return {f, pos + fmt::detail::to_unsigned(end - str.data()) + 1,
+  return {f, pos + fmt::detail::to_unsigned(end - str.data()),
          next_arg_id == 0 ? manual_indexing_id : ctx.next_arg_id()};
 }

@@ -436,13 +397,20 @@ constexpr auto parse_replacement_field_then_tail(S format_str) {
    return parse_tail<Args, END_POS + 1, NEXT_ID>(
        field<char_type, typename field_type<T>::type, ARG_INDEX>(),
        format_str);
-  } else if constexpr (c == ':') {
+  } else if constexpr (c != ':') {
+    FMT_THROW(format_error("expected ':'"));
+  } else {
    constexpr auto result = parse_specs<typename field_type<T>::type>(
        str, END_POS + 1, NEXT_ID == manual_indexing_id ? 0 : NEXT_ID);
-    return parse_tail<Args, result.end, result.next_arg_id>(
-        spec_field<char_type, typename field_type<T>::type, ARG_INDEX>{
-            result.fmt},
-        format_str);
+    if constexpr (result.end >= str.size() || str[result.end] != '}') {
+      FMT_THROW(format_error("expected '}'"));
+      return 0;
+    } else {
+      return parse_tail<Args, result.end + 1, result.next_arg_id>(
+          spec_field<char_type, typename field_type<T>::type, ARG_INDEX>{
+              result.fmt},
+          format_str);
+    }
  }
 }

@@ -573,10 +541,11 @@ FMT_INLINE std::basic_string<typename S::char_type> format(const S&,
  constexpr auto compiled = detail::compile<Args...>(S());
  if constexpr (std::is_same<remove_cvref_t<decltype(compiled)>,
                             detail::unknown_format>()) {
-    return format(static_cast<basic_string_view<typename S::char_type>>(S()),
-                  std::forward<Args>(args)...);
+    return fmt::format(
+        static_cast<basic_string_view<typename S::char_type>>(S()),
+        std::forward<Args>(args)...);
  } else {
-    return format(compiled, std::forward<Args>(args)...);
+    return fmt::format(compiled, std::forward<Args>(args)...);
  }
 }

@@ -586,11 +555,11 @@ FMT_CONSTEXPR OutputIt format_to(OutputIt out, const S&, Args&&... args) {
  constexpr auto compiled = detail::compile<Args...>(S());
  if constexpr (std::is_same<remove_cvref_t<decltype(compiled)>,
                             detail::unknown_format>()) {
-    return format_to(out,
-                     static_cast<basic_string_view<typename S::char_type>>(S()),
-                     std::forward<Args>(args)...);
+    return fmt::format_to(
+        out, static_cast<basic_string_view<typename S::char_type>>(S()),
+        std::forward<Args>(args)...);
  } else {
-    return format_to(out, compiled, std::forward<Args>(args)...);
+    return fmt::format_to(out, compiled, std::forward<Args>(args)...);
  }
 }
 #endif
@@ -599,22 +568,24 @@ template <typename OutputIt, typename S, typename... Args,
          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
 format_to_n_result<OutputIt> format_to_n(OutputIt out, size_t n,
                                         const S& format_str, Args&&... args) {
-  auto it = format_to(detail::truncating_iterator<OutputIt>(out, n), format_str,
-                      std::forward<Args>(args)...);
+  auto it = fmt::format_to(detail::truncating_iterator<OutputIt>(out, n),
+                           format_str, std::forward<Args>(args)...);
  return {it.base(), it.count()};
 }

 template <typename S, typename... Args,
          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
-size_t formatted_size(const S& format_str, const Args&... args) {
-  return format_to(detail::counting_iterator(), format_str, args...).count();
+FMT_CONSTEXPR20 size_t formatted_size(const S& format_str,
+                                      const Args&... args) {
+  return fmt::format_to(detail::counting_iterator(), format_str, args...)
+      .count();
 }

 template <typename S, typename... Args,
          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
 void print(std::FILE* f, const S& format_str, const Args&... args) {
  memory_buffer buffer;
-  format_to(std::back_inserter(buffer), format_str, args...);
+  fmt::format_to(std::back_inserter(buffer), format_str, args...);
  detail::print(f, {buffer.data(), buffer.size()});
 }

@@ -624,14 +595,12 @@ void print(const S& format_str, const Args&... args) {
  print(stdout, format_str, args...);
 }

-#if FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
+#if FMT_USE_NONTYPE_TEMPLATE_ARGS
 inline namespace literals {
-template <detail_exported::fixed_string Str>
-constexpr detail::udl_compiled_string<
-    remove_cvref_t<decltype(Str.data[0])>,
-    sizeof(Str.data) / sizeof(decltype(Str.data[0])), Str>
-operator""_cf() {
-  return {};
+template <detail_exported::fixed_string Str> constexpr auto operator""_cf() {
+  using char_t = remove_cvref_t<decltype(Str.data[0])>;
+  return detail::udl_compiled_string<char_t, sizeof(Str.data) / sizeof(char_t),
+                                     Str>();
 }
 }  // namespace literals
 #endif
--- a/include/spdlog/fmt/bundled/core.h
+++ b/include/spdlog/fmt/bundled/core.h
--- a/include/spdlog/fmt/bundled/format-inl.h
+++ b/include/spdlog/fmt/bundled/format-inl.h
--- a/include/spdlog/fmt/bundled/format.h
+++ b/include/spdlog/fmt/bundled/format.h
--- a/include/spdlog/fmt/bundled/os.h
+++ b/include/spdlog/fmt/bundled/os.h
@@ -9,10 +9,8 @@
 #define FMT_OS_H_

 #include <cerrno>
-#include <clocale>  // locale_t
 #include <cstddef>
 #include <cstdio>
-#include <cstdlib>       // strtod_l
 #include <system_error>  // std::system_error

 #if defined __APPLE__ || defined(__FreeBSD__)
@@ -141,7 +139,7 @@ template <typename Char> struct formatter<std::error_code, Char> {
 };

 #ifdef _WIN32
-FMT_API const std::error_category& system_category() FMT_NOEXCEPT;
+FMT_API const std::error_category& system_category() noexcept;

 FMT_BEGIN_DETAIL_NAMESPACE
 // A converter from UTF-16 to UTF-8.
@@ -165,7 +163,7 @@ class utf16_to_utf8 {
 };

 FMT_API void format_windows_error(buffer<char>& out, int error_code,
-                                  const char* message) FMT_NOEXCEPT;
+                                  const char* message) noexcept;
 FMT_END_DETAIL_NAMESPACE

 FMT_API std::system_error vwindows_error(int error_code, string_view format_str,
@@ -207,10 +205,9 @@ std::system_error windows_error(int error_code, string_view message,

 // Reports a Windows error without throwing an exception.
 // Can be used to report errors from destructors.
-FMT_API void report_windows_error(int error_code,
-                                  const char* message) FMT_NOEXCEPT;
+FMT_API void report_windows_error(int error_code, const char* message) noexcept;
 #else
-inline const std::error_category& system_category() FMT_NOEXCEPT {
+inline const std::error_category& system_category() noexcept {
  return std::system_category();
 }
 #endif  // _WIN32
@@ -237,13 +234,13 @@ class buffered_file {
  void operator=(const buffered_file&) = delete;

  // Constructs a buffered_file object which doesn't represent any file.
-  buffered_file() FMT_NOEXCEPT : file_(nullptr) {}
+  buffered_file() noexcept : file_(nullptr) {}

  // Destroys the object closing the file it represents if any.
-  FMT_API ~buffered_file() FMT_NOEXCEPT;
+  FMT_API ~buffered_file() noexcept;

 public:
-  buffered_file(buffered_file&& other) FMT_NOEXCEPT : file_(other.file_) {
+  buffered_file(buffered_file&& other) noexcept : file_(other.file_) {
    other.file_ = nullptr;
  }

@@ -261,11 +258,9 @@ class buffered_file {
  FMT_API void close();

  // Returns the pointer to a FILE object representing this file.
-  FILE* get() const FMT_NOEXCEPT { return file_; }
+  FILE* get() const noexcept { return file_; }

-  // We place parentheses around fileno to workaround a bug in some versions
-  // of MinGW that define fileno as a macro.
-  FMT_API int(fileno)() const;
+  FMT_API int descriptor() const;

  void vprint(string_view format_str, format_args args) {
    fmt::vprint(file_, format_str, args);
@@ -279,12 +274,12 @@ class buffered_file {

 #if FMT_USE_FCNTL
 // A file. Closed file is represented by a file object with descriptor -1.
-// Methods that are not declared with FMT_NOEXCEPT may throw
+// Methods that are not declared with noexcept may throw
 // fmt::system_error in case of failure. Note that some errors such as
 // closing the file multiple times will cause a crash on Windows rather
 // than an exception. You can get standard behavior by overriding the
 // invalid parameter handler with _set_invalid_parameter_handler.
-class file {
+class FMT_API file {
 private:
  int fd_;  // File descriptor.

@@ -303,16 +298,16 @@ class file {
  };

  // Constructs a file object which doesn't represent any file.
-  file() FMT_NOEXCEPT : fd_(-1) {}
+  file() noexcept : fd_(-1) {}

  // Opens a file and constructs a file object representing this file.
-  FMT_API file(cstring_view path, int oflag);
+  file(cstring_view path, int oflag);

 public:
  file(const file&) = delete;
  void operator=(const file&) = delete;

-  file(file&& other) FMT_NOEXCEPT : fd_(other.fd_) { other.fd_ = -1; }
+  file(file&& other) noexcept : fd_(other.fd_) { other.fd_ = -1; }

  // Move assignment is not noexcept because close may throw.
  file& operator=(file&& other) {
@@ -323,43 +318,43 @@ class file {
  }

  // Destroys the object closing the file it represents if any.
-  FMT_API ~file() FMT_NOEXCEPT;
+  ~file() noexcept;

  // Returns the file descriptor.
-  int descriptor() const FMT_NOEXCEPT { return fd_; }
+  int descriptor() const noexcept { return fd_; }

  // Closes the file.
-  FMT_API void close();
+  void close();

  // Returns the file size. The size has signed type for consistency with
  // stat::st_size.
-  FMT_API long long size() const;
+  long long size() const;

  // Attempts to read count bytes from the file into the specified buffer.
-  FMT_API size_t read(void* buffer, size_t count);
+  size_t read(void* buffer, size_t count);

  // Attempts to write count bytes from the specified buffer to the file.
-  FMT_API size_t write(const void* buffer, size_t count);
+  size_t write(const void* buffer, size_t count);

  // Duplicates a file descriptor with the dup function and returns
  // the duplicate as a file object.
-  FMT_API static file dup(int fd);
+  static file dup(int fd);

  // Makes fd be the copy of this file descriptor, closing fd first if
  // necessary.
-  FMT_API void dup2(int fd);
+  void dup2(int fd);

  // Makes fd be the copy of this file descriptor, closing fd first if
  // necessary.
-  FMT_API void dup2(int fd, std::error_code& ec) FMT_NOEXCEPT;
+  void dup2(int fd, std::error_code& ec) noexcept;

  // Creates a pipe setting up read_end and write_end file objects for reading
  // and writing respectively.
-  FMT_API static void pipe(file& read_end, file& write_end);
+  static void pipe(file& read_end, file& write_end);

  // Creates a buffered_file object associated with this file and detaches
  // this file object from the file.
-  FMT_API buffered_file fdopen(const char* mode);
+  buffered_file fdopen(const char* mode);
 };

 // Returns the memory page size.
@@ -462,7 +457,7 @@ class FMT_API ostream final : private detail::buffer<char> {

  * ``<integer>``: Flags passed to `open
    <https://pubs.opengroup.org/onlinepubs/007904875/functions/open.html>`_
-    (``file::WRONLY | file::CREATE`` by default)
+    (``file::WRONLY | file::CREATE | file::TRUNC`` by default)
  * ``buffer_size=<integer>``: Output buffer size

  **Example**::
@@ -477,50 +472,6 @@ inline ostream output_file(cstring_view path, T... params) {
 }
 #endif  // FMT_USE_FCNTL

-#ifdef FMT_LOCALE
-// A "C" numeric locale.
-class locale {
- private:
-#  ifdef _WIN32
-  using locale_t = _locale_t;
-
-  static void freelocale(locale_t loc) { _free_locale(loc); }
-
-  static double strtod_l(const char* nptr, char** endptr, _locale_t loc) {
-    return _strtod_l(nptr, endptr, loc);
-  }
-#  endif
-
-  locale_t locale_;
-
- public:
-  using type = locale_t;
-  locale(const locale&) = delete;
-  void operator=(const locale&) = delete;
-
-  locale() {
-#  ifndef _WIN32
-    locale_ = FMT_SYSTEM(newlocale(LC_NUMERIC_MASK, "C", nullptr));
-#  else
-    locale_ = _create_locale(LC_NUMERIC, "C");
-#  endif
-    if (!locale_) FMT_THROW(system_error(errno, "cannot create locale"));
-  }
-  ~locale() { freelocale(locale_); }
-
-  type get() const { return locale_; }
-
-  // Converts string to floating-point number and advances str past the end
-  // of the parsed input.
-  FMT_DEPRECATED double strtod(const char*& str) const {
-    char* end = nullptr;
-    double result = strtod_l(str, &end, locale_);
-    str = end;
-    return result;
-  }
-};
-using Locale FMT_DEPRECATED_ALIAS = locale;
-#endif  // FMT_LOCALE
 FMT_MODULE_EXPORT_END
 FMT_END_NAMESPACE

--- a/include/spdlog/fmt/bundled/ostream.h
+++ b/include/spdlog/fmt/bundled/ostream.h
@@ -8,7 +8,14 @@
 #ifndef FMT_OSTREAM_H_
 #define FMT_OSTREAM_H_

+#include <fstream>
 #include <ostream>
+#if defined(_WIN32) && defined(__GLIBCXX__)
+#  include <ext/stdio_filebuf.h>
+#  include <ext/stdio_sync_filebuf.h>
+#elif defined(_WIN32) && defined(_LIBCPP_VERSION)
+#  include <__std_stream>
+#endif

 #include "format.h"

@@ -45,11 +52,58 @@ struct is_streamable<
    enable_if_t<
        std::is_arithmetic<T>::value || std::is_array<T>::value ||
        std::is_pointer<T>::value || std::is_same<T, char8_type>::value ||
-        std::is_same<T, std::basic_string<Char>>::value ||
+        std::is_convertible<T, fmt::basic_string_view<Char>>::value ||
        std::is_same<T, std_string_view<Char>>::value ||
        (std::is_convertible<T, int>::value && !std::is_enum<T>::value)>>
    : std::false_type {};

+// Generate a unique explicit instantion in every translation unit using a tag
+// type in an anonymous namespace.
+namespace {
+struct file_access_tag {};
+}  // namespace
+template <class Tag, class BufType, FILE* BufType::*FileMemberPtr>
+class file_access {
+  friend auto get_file(BufType& obj) -> FILE* { return obj.*FileMemberPtr; }
+};
+
+#if FMT_MSC_VERSION
+template class file_access<file_access_tag, std::filebuf,
+                           &std::filebuf::_Myfile>;
+auto get_file(std::filebuf&) -> FILE*;
+#elif defined(_WIN32) && defined(_LIBCPP_VERSION)
+template class file_access<file_access_tag, std::__stdoutbuf<char>,
+                           &std::__stdoutbuf<char>::__file_>;
+auto get_file(std::__stdoutbuf<char>&) -> FILE*;
+#endif
+
+inline bool write_ostream_unicode(std::ostream& os, fmt::string_view data) {
+#if FMT_MSC_VERSION
+  if (auto* buf = dynamic_cast<std::filebuf*>(os.rdbuf()))
+    if (FILE* f = get_file(*buf)) return write_console(f, data);
+#elif defined(_WIN32) && defined(__GLIBCXX__)
+  auto* rdbuf = os.rdbuf();
+  FILE* c_file;
+  if (auto* fbuf = dynamic_cast<__gnu_cxx::stdio_sync_filebuf<char>*>(rdbuf))
+    c_file = fbuf->file();
+  else if (auto* fbuf = dynamic_cast<__gnu_cxx::stdio_filebuf<char>*>(rdbuf))
+    c_file = fbuf->file();
+  else
+    return false;
+  if (c_file) return write_console(c_file, data);
+#elif defined(_WIN32) && defined(_LIBCPP_VERSION)
+  if (auto* buf = dynamic_cast<std::__stdoutbuf<char>*>(os.rdbuf()))
+    if (FILE* f = get_file(*buf)) return write_console(f, data);
+#else
+  ignore_unused(os, data);
+#endif
+  return false;
+}
+inline bool write_ostream_unicode(std::wostream&,
+                                  fmt::basic_string_view<wchar_t>) {
+  return false;
+}
+
 // Write the content of buf to os.
 // It is a separate function rather than a part of vprint to simplify testing.
 template <typename Char>
@@ -76,41 +130,79 @@ void format_value(buffer<Char>& buf, const T& value,
 #endif
  output << value;
  output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
-  buf.try_resize(buf.size());
 }

-// Formats an object of type T that has an overloaded ostream operator<<.
-template <typename T, typename Char>
-struct fallback_formatter<T, Char, enable_if_t<is_streamable<T, Char>::value>>
-    : private formatter<basic_string_view<Char>, Char> {
-  using formatter<basic_string_view<Char>, Char>::parse;
+template <typename T> struct streamed_view { const T& value; };

-  template <typename OutputIt>
-  auto format(const T& value, basic_format_context<OutputIt, Char>& ctx)
+}  // namespace detail
+
+// Formats an object of type T that has an overloaded ostream operator<<.
+template <typename Char>
+struct basic_ostream_formatter : formatter<basic_string_view<Char>, Char> {
+  void set_debug_format() = delete;
+
+  template <typename T, typename OutputIt>
+  auto format(const T& value, basic_format_context<OutputIt, Char>& ctx) const
      -> OutputIt {
    auto buffer = basic_memory_buffer<Char>();
    format_value(buffer, value, ctx.locale());
    return formatter<basic_string_view<Char>, Char>::format(
        {buffer.data(), buffer.size()}, ctx);
  }
+};

-  // DEPRECATED!
+using ostream_formatter = basic_ostream_formatter<char>;
+
+template <typename T, typename Char>
+struct formatter<detail::streamed_view<T>, Char>
+    : basic_ostream_formatter<Char> {
  template <typename OutputIt>
-  auto format(const T& value, basic_printf_context<OutputIt, Char>& ctx)
-      -> OutputIt {
-    auto buffer = basic_memory_buffer<Char>();
-    format_value(buffer, value, ctx.locale());
-    return std::copy(buffer.begin(), buffer.end(), ctx.out());
+  auto format(detail::streamed_view<T> view,
+              basic_format_context<OutputIt, Char>& ctx) const -> OutputIt {
+    return basic_ostream_formatter<Char>::format(view.value, ctx);
  }
 };
+
+/**
+  \rst
+  Returns a view that formats `value` via an ostream ``operator<<``.
+
+  **Example**::
+
+    fmt::print("Current thread id: {}\n",
+               fmt::streamed(std::this_thread::get_id()));
+  \endrst
+ */
+template <typename T>
+auto streamed(const T& value) -> detail::streamed_view<T> {
+  return {value};
+}
+
+namespace detail {
+
+// Formats an object of type T that has an overloaded ostream operator<<.
+template <typename T, typename Char>
+struct fallback_formatter<T, Char, enable_if_t<is_streamable<T, Char>::value>>
+    : basic_ostream_formatter<Char> {
+  using basic_ostream_formatter<Char>::format;
+};
+
+inline void vprint_directly(std::ostream& os, string_view format_str,
+                            format_args args) {
+  auto buffer = memory_buffer();
+  detail::vformat_to(buffer, format_str, args);
+  detail::write_buffer(os, buffer);
+}
+
 }  // namespace detail

-FMT_MODULE_EXPORT
-template <typename Char>
-void vprint(std::basic_ostream<Char>& os, basic_string_view<Char> format_str,
+FMT_MODULE_EXPORT template <typename Char>
+void vprint(std::basic_ostream<Char>& os,
+            basic_string_view<type_identity_t<Char>> format_str,
            basic_format_args<buffer_context<type_identity_t<Char>>> args) {
  auto buffer = basic_memory_buffer<Char>();
  detail::vformat_to(buffer, format_str, args);
+  if (detail::write_ostream_unicode(os, {buffer.data(), buffer.size()})) return;
  detail::write_buffer(os, buffer);
 }

@@ -123,13 +215,23 @@ void vprint(std::basic_ostream<Char>& os, basic_string_view<Char> format_str,
    fmt::print(cerr, "Don't {}!", "panic");
  \endrst
 */
-FMT_MODULE_EXPORT
-template <typename S, typename... Args,
-          typename Char = enable_if_t<detail::is_string<S>::value, char_t<S>>>
-void print(std::basic_ostream<Char>& os, const S& format_str, Args&&... args) {
-  vprint(os, to_string_view(format_str),
-         fmt::make_args_checked<Args...>(format_str, args...));
+FMT_MODULE_EXPORT template <typename... T>
+void print(std::ostream& os, format_string<T...> fmt, T&&... args) {
+  const auto& vargs = fmt::make_format_args(args...);
+  if (detail::is_utf8())
+    vprint(os, fmt, vargs);
+  else
+    detail::vprint_directly(os, fmt, vargs);
 }
+
+FMT_MODULE_EXPORT
+template <typename... Args>
+void print(std::wostream& os,
+           basic_format_string<wchar_t, type_identity_t<Args>...> fmt,
+           Args&&... args) {
+  vprint(os, fmt, fmt::make_format_args<buffer_context<wchar_t>>(args...));
+}
+
 FMT_END_NAMESPACE

 #endif  // FMT_OSTREAM_H_
--- a/include/spdlog/fmt/bundled/printf.h
+++ b/include/spdlog/fmt/bundled/printf.h
@@ -10,7 +10,6 @@

 #include <algorithm>  // std::max
 #include <limits>     // std::numeric_limits
-#include <ostream>

 #include "format.h"

@@ -561,7 +560,7 @@ inline auto vsprintf(
    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args)
    -> std::basic_string<Char> {
  basic_memory_buffer<Char> buffer;
-  vprintf(buffer, to_string_view(fmt), args);
+  vprintf(buffer, detail::to_string_view(fmt), args);
  return to_string(buffer);
 }

@@ -578,7 +577,8 @@ template <typename S, typename... T,
          typename Char = enable_if_t<detail::is_string<S>::value, char_t<S>>>
 inline auto sprintf(const S& fmt, const T&... args) -> std::basic_string<Char> {
  using context = basic_printf_context_t<Char>;
-  return vsprintf(to_string_view(fmt), fmt::make_format_args<context>(args...));
+  return vsprintf(detail::to_string_view(fmt),
+                  fmt::make_format_args<context>(args...));
 }

 template <typename S, typename Char = char_t<S>>
@@ -587,7 +587,7 @@ inline auto vfprintf(
    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args)
    -> int {
  basic_memory_buffer<Char> buffer;
-  vprintf(buffer, to_string_view(fmt), args);
+  vprintf(buffer, detail::to_string_view(fmt), args);
  size_t size = buffer.size();
  return std::fwrite(buffer.data(), sizeof(Char), size, f) < size
             ? -1
@@ -606,7 +606,7 @@ inline auto vfprintf(
 template <typename S, typename... T, typename Char = char_t<S>>
 inline auto fprintf(std::FILE* f, const S& fmt, const T&... args) -> int {
  using context = basic_printf_context_t<Char>;
-  return vfprintf(f, to_string_view(fmt),
+  return vfprintf(f, detail::to_string_view(fmt),
                  fmt::make_format_args<context>(args...));
 }

@@ -615,7 +615,7 @@ inline auto vprintf(
    const S& fmt,
    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args)
    -> int {
-  return vfprintf(stdout, to_string_view(fmt), args);
+  return vfprintf(stdout, detail::to_string_view(fmt), args);
 }

 /**
@@ -630,27 +630,10 @@ inline auto vprintf(
 template <typename S, typename... T, FMT_ENABLE_IF(detail::is_string<S>::value)>
 inline auto printf(const S& fmt, const T&... args) -> int {
  return vprintf(
-      to_string_view(fmt),
+      detail::to_string_view(fmt),
      fmt::make_format_args<basic_printf_context_t<char_t<S>>>(args...));
 }

-template <typename S, typename Char = char_t<S>>
-FMT_DEPRECATED auto vfprintf(
-    std::basic_ostream<Char>& os, const S& fmt,
-    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args)
-    -> int {
-  basic_memory_buffer<Char> buffer;
-  vprintf(buffer, to_string_view(fmt), args);
-  os.write(buffer.data(), static_cast<std::streamsize>(buffer.size()));
-  return static_cast<int>(buffer.size());
-}
-template <typename S, typename... T, typename Char = char_t<S>>
-FMT_DEPRECATED auto fprintf(std::basic_ostream<Char>& os, const S& fmt,
-                            const T&... args) -> int {
-  return vfprintf(os, to_string_view(fmt),
-                  fmt::make_format_args<basic_printf_context_t<Char>>(args...));
-}
-
 FMT_MODULE_EXPORT_END
 FMT_END_NAMESPACE

--- a/include/spdlog/fmt/bundled/ranges.h
+++ b/include/spdlog/fmt/bundled/ranges.h
@@ -55,7 +55,7 @@ template <typename T> class is_std_string_like {
  template <typename> static void check(...);

 public:
-  static FMT_CONSTEXPR_DECL const bool value =
+  static constexpr const bool value =
      is_string<T>::value ||
      std::is_convertible<T, std_string_view<char>>::value ||
      !std::is_void<decltype(check<T>(nullptr))>::value;
@@ -70,9 +70,9 @@ template <typename T> class is_map {

 public:
 #ifdef FMT_FORMAT_MAP_AS_LIST
-  static FMT_CONSTEXPR_DECL const bool value = false;
+  static constexpr const bool value = false;
 #else
-  static FMT_CONSTEXPR_DECL const bool value =
+  static constexpr const bool value =
      !std::is_void<decltype(check<T>(nullptr))>::value;
 #endif
 };
@@ -83,9 +83,9 @@ template <typename T> class is_set {

 public:
 #ifdef FMT_FORMAT_SET_AS_LIST
-  static FMT_CONSTEXPR_DECL const bool value = false;
+  static constexpr const bool value = false;
 #else
-  static FMT_CONSTEXPR_DECL const bool value =
+  static constexpr const bool value =
      !std::is_void<decltype(check<T>(nullptr))>::value && !is_map<T>::value;
 #endif
 };
@@ -94,7 +94,7 @@ template <typename... Ts> struct conditional_helper {};

 template <typename T, typename _ = void> struct is_range_ : std::false_type {};

-#if !FMT_MSC_VER || FMT_MSC_VER > 1800
+#if !FMT_MSC_VERSION || FMT_MSC_VERSION > 1800

 #  define FMT_DECLTYPE_RETURN(val)  \
    ->decltype(val) { return val; } \
@@ -174,12 +174,12 @@ template <typename T> class is_tuple_like_ {
  template <typename> static void check(...);

 public:
-  static FMT_CONSTEXPR_DECL const bool value =
+  static constexpr const bool value =
      !std::is_void<decltype(check<T>(nullptr))>::value;
 };

 // Check for integer_sequence
-#if defined(__cpp_lib_integer_sequence) || FMT_MSC_VER >= 1900
+#if defined(__cpp_lib_integer_sequence) || FMT_MSC_VERSION >= 1900
 template <typename T, T... N>
 using integer_sequence = std::integer_sequence<T, N...>;
 template <size_t... N> using index_sequence = std::index_sequence<N...>;
@@ -202,8 +202,33 @@ template <size_t N>
 using make_index_sequence = make_integer_sequence<size_t, N>;
 #endif

+template <typename T>
+using tuple_index_sequence = make_index_sequence<std::tuple_size<T>::value>;
+
+template <typename T, typename C, bool = is_tuple_like_<T>::value>
+class is_tuple_formattable_ {
+ public:
+  static constexpr const bool value = false;
+};
+template <typename T, typename C> class is_tuple_formattable_<T, C, true> {
+  template <std::size_t... I>
+  static std::true_type check2(index_sequence<I...>,
+                               integer_sequence<bool, (I == I)...>);
+  static std::false_type check2(...);
+  template <std::size_t... I>
+  static decltype(check2(
+      index_sequence<I...>{},
+      integer_sequence<
+          bool, (is_formattable<typename std::tuple_element<I, T>::type,
+                                C>::value)...>{})) check(index_sequence<I...>);
+
+ public:
+  static constexpr const bool value =
+      decltype(check(tuple_index_sequence<T>{}))::value;
+};
+
 template <class Tuple, class F, size_t... Is>
-void for_each(index_sequence<Is...>, Tuple&& tup, F&& f) FMT_NOEXCEPT {
+void for_each(index_sequence<Is...>, Tuple&& tup, F&& f) noexcept {
  using std::get;
  // using free function get<I>(T) now.
  const int _[] = {0, ((void)f(get<Is>(tup)), 0)...};
@@ -221,9 +246,36 @@ template <class Tuple, class F> void for_each(Tuple&& tup, F&& f) {
  for_each(indexes, std::forward<Tuple>(tup), std::forward<F>(f));
 }

+#if FMT_MSC_VERSION && FMT_MSC_VERSION < 1920
+// Older MSVC doesn't get the reference type correctly for arrays.
+template <typename R> struct range_reference_type_impl {
+  using type = decltype(*detail::range_begin(std::declval<R&>()));
+};
+
+template <typename T, std::size_t N> struct range_reference_type_impl<T[N]> {
+  using type = T&;
+};
+
+template <typename T>
+using range_reference_type = typename range_reference_type_impl<T>::type;
+#else
 template <typename Range>
-using value_type =
-    remove_cvref_t<decltype(*detail::range_begin(std::declval<Range>()))>;
+using range_reference_type =
+    decltype(*detail::range_begin(std::declval<Range&>()));
+#endif
+
+// We don't use the Range's value_type for anything, but we do need the Range's
+// reference type, with cv-ref stripped.
+template <typename Range>
+using uncvref_type = remove_cvref_t<range_reference_type<Range>>;
+
+template <typename Range>
+using uncvref_first_type =
+    remove_cvref_t<decltype(std::declval<range_reference_type<Range>>().first)>;
+
+template <typename Range>
+using uncvref_second_type = remove_cvref_t<
+    decltype(std::declval<range_reference_type<Range>>().second)>;

 template <typename OutputIt> OutputIt write_delimiter(OutputIt out) {
  *out++ = ',';
@@ -231,286 +283,9 @@ template <typename OutputIt> OutputIt write_delimiter(OutputIt out) {
  return out;
 }

-struct singleton {
-  unsigned char upper;
-  unsigned char lower_count;
-};
-
-inline auto is_printable(uint16_t x, const singleton* singletons,
-                         size_t singletons_size,
-                         const unsigned char* singleton_lowers,
-                         const unsigned char* normal, size_t normal_size)
-    -> bool {
-  auto upper = x >> 8;
-  auto lower_start = 0;
-  for (size_t i = 0; i < singletons_size; ++i) {
-    auto s = singletons[i];
-    auto lower_end = lower_start + s.lower_count;
-    if (upper < s.upper) break;
-    if (upper == s.upper) {
-      for (auto j = lower_start; j < lower_end; ++j) {
-        if (singleton_lowers[j] == (x & 0xff)) return false;
-      }
-    }
-    lower_start = lower_end;
-  }
-
-  auto xsigned = static_cast<int>(x);
-  auto current = true;
-  for (size_t i = 0; i < normal_size; ++i) {
-    auto v = static_cast<int>(normal[i]);
-    auto len = (v & 0x80) != 0 ? (v & 0x7f) << 8 | normal[++i] : v;
-    xsigned -= len;
-    if (xsigned < 0) break;
-    current = !current;
-  }
-  return current;
-}
-
-// Returns true iff the code point cp is printable.
-// This code is generated by support/printable.py.
-inline auto is_printable(uint32_t cp) -> bool {
-  static constexpr singleton singletons0[] = {
-      {0x00, 1},  {0x03, 5},  {0x05, 6},  {0x06, 3},  {0x07, 6},  {0x08, 8},
-      {0x09, 17}, {0x0a, 28}, {0x0b, 25}, {0x0c, 20}, {0x0d, 16}, {0x0e, 13},
-      {0x0f, 4},  {0x10, 3},  {0x12, 18}, {0x13, 9},  {0x16, 1},  {0x17, 5},
-      {0x18, 2},  {0x19, 3},  {0x1a, 7},  {0x1c, 2},  {0x1d, 1},  {0x1f, 22},
-      {0x20, 3},  {0x2b, 3},  {0x2c, 2},  {0x2d, 11}, {0x2e, 1},  {0x30, 3},
-      {0x31, 2},  {0x32, 1},  {0xa7, 2},  {0xa9, 2},  {0xaa, 4},  {0xab, 8},
-      {0xfa, 2},  {0xfb, 5},  {0xfd, 4},  {0xfe, 3},  {0xff, 9},
-  };
-  static constexpr unsigned char singletons0_lower[] = {
-      0xad, 0x78, 0x79, 0x8b, 0x8d, 0xa2, 0x30, 0x57, 0x58, 0x8b, 0x8c, 0x90,
-      0x1c, 0x1d, 0xdd, 0x0e, 0x0f, 0x4b, 0x4c, 0xfb, 0xfc, 0x2e, 0x2f, 0x3f,
-      0x5c, 0x5d, 0x5f, 0xb5, 0xe2, 0x84, 0x8d, 0x8e, 0x91, 0x92, 0xa9, 0xb1,
-      0xba, 0xbb, 0xc5, 0xc6, 0xc9, 0xca, 0xde, 0xe4, 0xe5, 0xff, 0x00, 0x04,
-      0x11, 0x12, 0x29, 0x31, 0x34, 0x37, 0x3a, 0x3b, 0x3d, 0x49, 0x4a, 0x5d,
-      0x84, 0x8e, 0x92, 0xa9, 0xb1, 0xb4, 0xba, 0xbb, 0xc6, 0xca, 0xce, 0xcf,
-      0xe4, 0xe5, 0x00, 0x04, 0x0d, 0x0e, 0x11, 0x12, 0x29, 0x31, 0x34, 0x3a,
-      0x3b, 0x45, 0x46, 0x49, 0x4a, 0x5e, 0x64, 0x65, 0x84, 0x91, 0x9b, 0x9d,
-      0xc9, 0xce, 0xcf, 0x0d, 0x11, 0x29, 0x45, 0x49, 0x57, 0x64, 0x65, 0x8d,
-      0x91, 0xa9, 0xb4, 0xba, 0xbb, 0xc5, 0xc9, 0xdf, 0xe4, 0xe5, 0xf0, 0x0d,
-      0x11, 0x45, 0x49, 0x64, 0x65, 0x80, 0x84, 0xb2, 0xbc, 0xbe, 0xbf, 0xd5,
-      0xd7, 0xf0, 0xf1, 0x83, 0x85, 0x8b, 0xa4, 0xa6, 0xbe, 0xbf, 0xc5, 0xc7,
-      0xce, 0xcf, 0xda, 0xdb, 0x48, 0x98, 0xbd, 0xcd, 0xc6, 0xce, 0xcf, 0x49,
-      0x4e, 0x4f, 0x57, 0x59, 0x5e, 0x5f, 0x89, 0x8e, 0x8f, 0xb1, 0xb6, 0xb7,
-      0xbf, 0xc1, 0xc6, 0xc7, 0xd7, 0x11, 0x16, 0x17, 0x5b, 0x5c, 0xf6, 0xf7,
-      0xfe, 0xff, 0x80, 0x0d, 0x6d, 0x71, 0xde, 0xdf, 0x0e, 0x0f, 0x1f, 0x6e,
-      0x6f, 0x1c, 0x1d, 0x5f, 0x7d, 0x7e, 0xae, 0xaf, 0xbb, 0xbc, 0xfa, 0x16,
-      0x17, 0x1e, 0x1f, 0x46, 0x47, 0x4e, 0x4f, 0x58, 0x5a, 0x5c, 0x5e, 0x7e,
-      0x7f, 0xb5, 0xc5, 0xd4, 0xd5, 0xdc, 0xf0, 0xf1, 0xf5, 0x72, 0x73, 0x8f,
-      0x74, 0x75, 0x96, 0x2f, 0x5f, 0x26, 0x2e, 0x2f, 0xa7, 0xaf, 0xb7, 0xbf,
-      0xc7, 0xcf, 0xd7, 0xdf, 0x9a, 0x40, 0x97, 0x98, 0x30, 0x8f, 0x1f, 0xc0,
-      0xc1, 0xce, 0xff, 0x4e, 0x4f, 0x5a, 0x5b, 0x07, 0x08, 0x0f, 0x10, 0x27,
-      0x2f, 0xee, 0xef, 0x6e, 0x6f, 0x37, 0x3d, 0x3f, 0x42, 0x45, 0x90, 0x91,
-      0xfe, 0xff, 0x53, 0x67, 0x75, 0xc8, 0xc9, 0xd0, 0xd1, 0xd8, 0xd9, 0xe7,
-      0xfe, 0xff,
-  };
-  static constexpr singleton singletons1[] = {
-      {0x00, 6},  {0x01, 1}, {0x03, 1},  {0x04, 2}, {0x08, 8},  {0x09, 2},
-      {0x0a, 5},  {0x0b, 2}, {0x0e, 4},  {0x10, 1}, {0x11, 2},  {0x12, 5},
-      {0x13, 17}, {0x14, 1}, {0x15, 2},  {0x17, 2}, {0x19, 13}, {0x1c, 5},
-      {0x1d, 8},  {0x24, 1}, {0x6a, 3},  {0x6b, 2}, {0xbc, 2},  {0xd1, 2},
-      {0xd4, 12}, {0xd5, 9}, {0xd6, 2},  {0xd7, 2}, {0xda, 1},  {0xe0, 5},
-      {0xe1, 2},  {0xe8, 2}, {0xee, 32}, {0xf0, 4}, {0xf8, 2},  {0xf9, 2},
-      {0xfa, 2},  {0xfb, 1},
-  };
-  static constexpr unsigned char singletons1_lower[] = {
-      0x0c, 0x27, 0x3b, 0x3e, 0x4e, 0x4f, 0x8f, 0x9e, 0x9e, 0x9f, 0x06, 0x07,
-      0x09, 0x36, 0x3d, 0x3e, 0x56, 0xf3, 0xd0, 0xd1, 0x04, 0x14, 0x18, 0x36,
-      0x37, 0x56, 0x57, 0x7f, 0xaa, 0xae, 0xaf, 0xbd, 0x35, 0xe0, 0x12, 0x87,
-      0x89, 0x8e, 0x9e, 0x04, 0x0d, 0x0e, 0x11, 0x12, 0x29, 0x31, 0x34, 0x3a,
-      0x45, 0x46, 0x49, 0x4a, 0x4e, 0x4f, 0x64, 0x65, 0x5c, 0xb6, 0xb7, 0x1b,
-      0x1c, 0x07, 0x08, 0x0a, 0x0b, 0x14, 0x17, 0x36, 0x39, 0x3a, 0xa8, 0xa9,
-      0xd8, 0xd9, 0x09, 0x37, 0x90, 0x91, 0xa8, 0x07, 0x0a, 0x3b, 0x3e, 0x66,
-      0x69, 0x8f, 0x92, 0x6f, 0x5f, 0xee, 0xef, 0x5a, 0x62, 0x9a, 0x9b, 0x27,
-      0x28, 0x55, 0x9d, 0xa0, 0xa1, 0xa3, 0xa4, 0xa7, 0xa8, 0xad, 0xba, 0xbc,
-      0xc4, 0x06, 0x0b, 0x0c, 0x15, 0x1d, 0x3a, 0x3f, 0x45, 0x51, 0xa6, 0xa7,
-      0xcc, 0xcd, 0xa0, 0x07, 0x19, 0x1a, 0x22, 0x25, 0x3e, 0x3f, 0xc5, 0xc6,
-      0x04, 0x20, 0x23, 0x25, 0x26, 0x28, 0x33, 0x38, 0x3a, 0x48, 0x4a, 0x4c,
-      0x50, 0x53, 0x55, 0x56, 0x58, 0x5a, 0x5c, 0x5e, 0x60, 0x63, 0x65, 0x66,
-      0x6b, 0x73, 0x78, 0x7d, 0x7f, 0x8a, 0xa4, 0xaa, 0xaf, 0xb0, 0xc0, 0xd0,
-      0xae, 0xaf, 0x79, 0xcc, 0x6e, 0x6f, 0x93,
-  };
-  static constexpr unsigned char normal0[] = {
-      0x00, 0x20, 0x5f, 0x22, 0x82, 0xdf, 0x04, 0x82, 0x44, 0x08, 0x1b, 0x04,
-      0x06, 0x11, 0x81, 0xac, 0x0e, 0x80, 0xab, 0x35, 0x28, 0x0b, 0x80, 0xe0,
-      0x03, 0x19, 0x08, 0x01, 0x04, 0x2f, 0x04, 0x34, 0x04, 0x07, 0x03, 0x01,
-      0x07, 0x06, 0x07, 0x11, 0x0a, 0x50, 0x0f, 0x12, 0x07, 0x55, 0x07, 0x03,
-      0x04, 0x1c, 0x0a, 0x09, 0x03, 0x08, 0x03, 0x07, 0x03, 0x02, 0x03, 0x03,
-      0x03, 0x0c, 0x04, 0x05, 0x03, 0x0b, 0x06, 0x01, 0x0e, 0x15, 0x05, 0x3a,
-      0x03, 0x11, 0x07, 0x06, 0x05, 0x10, 0x07, 0x57, 0x07, 0x02, 0x07, 0x15,
-      0x0d, 0x50, 0x04, 0x43, 0x03, 0x2d, 0x03, 0x01, 0x04, 0x11, 0x06, 0x0f,
-      0x0c, 0x3a, 0x04, 0x1d, 0x25, 0x5f, 0x20, 0x6d, 0x04, 0x6a, 0x25, 0x80,
-      0xc8, 0x05, 0x82, 0xb0, 0x03, 0x1a, 0x06, 0x82, 0xfd, 0x03, 0x59, 0x07,
-      0x15, 0x0b, 0x17, 0x09, 0x14, 0x0c, 0x14, 0x0c, 0x6a, 0x06, 0x0a, 0x06,
-      0x1a, 0x06, 0x59, 0x07, 0x2b, 0x05, 0x46, 0x0a, 0x2c, 0x04, 0x0c, 0x04,
-      0x01, 0x03, 0x31, 0x0b, 0x2c, 0x04, 0x1a, 0x06, 0x0b, 0x03, 0x80, 0xac,
-      0x06, 0x0a, 0x06, 0x21, 0x3f, 0x4c, 0x04, 0x2d, 0x03, 0x74, 0x08, 0x3c,
-      0x03, 0x0f, 0x03, 0x3c, 0x07, 0x38, 0x08, 0x2b, 0x05, 0x82, 0xff, 0x11,
-      0x18, 0x08, 0x2f, 0x11, 0x2d, 0x03, 0x20, 0x10, 0x21, 0x0f, 0x80, 0x8c,
-      0x04, 0x82, 0x97, 0x19, 0x0b, 0x15, 0x88, 0x94, 0x05, 0x2f, 0x05, 0x3b,
-      0x07, 0x02, 0x0e, 0x18, 0x09, 0x80, 0xb3, 0x2d, 0x74, 0x0c, 0x80, 0xd6,
-      0x1a, 0x0c, 0x05, 0x80, 0xff, 0x05, 0x80, 0xdf, 0x0c, 0xee, 0x0d, 0x03,
-      0x84, 0x8d, 0x03, 0x37, 0x09, 0x81, 0x5c, 0x14, 0x80, 0xb8, 0x08, 0x80,
-      0xcb, 0x2a, 0x38, 0x03, 0x0a, 0x06, 0x38, 0x08, 0x46, 0x08, 0x0c, 0x06,
-      0x74, 0x0b, 0x1e, 0x03, 0x5a, 0x04, 0x59, 0x09, 0x80, 0x83, 0x18, 0x1c,
-      0x0a, 0x16, 0x09, 0x4c, 0x04, 0x80, 0x8a, 0x06, 0xab, 0xa4, 0x0c, 0x17,
-      0x04, 0x31, 0xa1, 0x04, 0x81, 0xda, 0x26, 0x07, 0x0c, 0x05, 0x05, 0x80,
-      0xa5, 0x11, 0x81, 0x6d, 0x10, 0x78, 0x28, 0x2a, 0x06, 0x4c, 0x04, 0x80,
-      0x8d, 0x04, 0x80, 0xbe, 0x03, 0x1b, 0x03, 0x0f, 0x0d,
-  };
-  static constexpr unsigned char normal1[] = {
-      0x5e, 0x22, 0x7b, 0x05, 0x03, 0x04, 0x2d, 0x03, 0x66, 0x03, 0x01, 0x2f,
-      0x2e, 0x80, 0x82, 0x1d, 0x03, 0x31, 0x0f, 0x1c, 0x04, 0x24, 0x09, 0x1e,
-      0x05, 0x2b, 0x05, 0x44, 0x04, 0x0e, 0x2a, 0x80, 0xaa, 0x06, 0x24, 0x04,
-      0x24, 0x04, 0x28, 0x08, 0x34, 0x0b, 0x01, 0x80, 0x90, 0x81, 0x37, 0x09,
-      0x16, 0x0a, 0x08, 0x80, 0x98, 0x39, 0x03, 0x63, 0x08, 0x09, 0x30, 0x16,
-      0x05, 0x21, 0x03, 0x1b, 0x05, 0x01, 0x40, 0x38, 0x04, 0x4b, 0x05, 0x2f,
-      0x04, 0x0a, 0x07, 0x09, 0x07, 0x40, 0x20, 0x27, 0x04, 0x0c, 0x09, 0x36,
-      0x03, 0x3a, 0x05, 0x1a, 0x07, 0x04, 0x0c, 0x07, 0x50, 0x49, 0x37, 0x33,
-      0x0d, 0x33, 0x07, 0x2e, 0x08, 0x0a, 0x81, 0x26, 0x52, 0x4e, 0x28, 0x08,
-      0x2a, 0x56, 0x1c, 0x14, 0x17, 0x09, 0x4e, 0x04, 0x1e, 0x0f, 0x43, 0x0e,
-      0x19, 0x07, 0x0a, 0x06, 0x48, 0x08, 0x27, 0x09, 0x75, 0x0b, 0x3f, 0x41,
-      0x2a, 0x06, 0x3b, 0x05, 0x0a, 0x06, 0x51, 0x06, 0x01, 0x05, 0x10, 0x03,
-      0x05, 0x80, 0x8b, 0x62, 0x1e, 0x48, 0x08, 0x0a, 0x80, 0xa6, 0x5e, 0x22,
-      0x45, 0x0b, 0x0a, 0x06, 0x0d, 0x13, 0x39, 0x07, 0x0a, 0x36, 0x2c, 0x04,
-      0x10, 0x80, 0xc0, 0x3c, 0x64, 0x53, 0x0c, 0x48, 0x09, 0x0a, 0x46, 0x45,
-      0x1b, 0x48, 0x08, 0x53, 0x1d, 0x39, 0x81, 0x07, 0x46, 0x0a, 0x1d, 0x03,
-      0x47, 0x49, 0x37, 0x03, 0x0e, 0x08, 0x0a, 0x06, 0x39, 0x07, 0x0a, 0x81,
-      0x36, 0x19, 0x80, 0xb7, 0x01, 0x0f, 0x32, 0x0d, 0x83, 0x9b, 0x66, 0x75,
-      0x0b, 0x80, 0xc4, 0x8a, 0xbc, 0x84, 0x2f, 0x8f, 0xd1, 0x82, 0x47, 0xa1,
-      0xb9, 0x82, 0x39, 0x07, 0x2a, 0x04, 0x02, 0x60, 0x26, 0x0a, 0x46, 0x0a,
-      0x28, 0x05, 0x13, 0x82, 0xb0, 0x5b, 0x65, 0x4b, 0x04, 0x39, 0x07, 0x11,
-      0x40, 0x05, 0x0b, 0x02, 0x0e, 0x97, 0xf8, 0x08, 0x84, 0xd6, 0x2a, 0x09,
-      0xa2, 0xf7, 0x81, 0x1f, 0x31, 0x03, 0x11, 0x04, 0x08, 0x81, 0x8c, 0x89,
-      0x04, 0x6b, 0x05, 0x0d, 0x03, 0x09, 0x07, 0x10, 0x93, 0x60, 0x80, 0xf6,
-      0x0a, 0x73, 0x08, 0x6e, 0x17, 0x46, 0x80, 0x9a, 0x14, 0x0c, 0x57, 0x09,
-      0x19, 0x80, 0x87, 0x81, 0x47, 0x03, 0x85, 0x42, 0x0f, 0x15, 0x85, 0x50,
-      0x2b, 0x80, 0xd5, 0x2d, 0x03, 0x1a, 0x04, 0x02, 0x81, 0x70, 0x3a, 0x05,
-      0x01, 0x85, 0x00, 0x80, 0xd7, 0x29, 0x4c, 0x04, 0x0a, 0x04, 0x02, 0x83,
-      0x11, 0x44, 0x4c, 0x3d, 0x80, 0xc2, 0x3c, 0x06, 0x01, 0x04, 0x55, 0x05,
-      0x1b, 0x34, 0x02, 0x81, 0x0e, 0x2c, 0x04, 0x64, 0x0c, 0x56, 0x0a, 0x80,
-      0xae, 0x38, 0x1d, 0x0d, 0x2c, 0x04, 0x09, 0x07, 0x02, 0x0e, 0x06, 0x80,
-      0x9a, 0x83, 0xd8, 0x08, 0x0d, 0x03, 0x0d, 0x03, 0x74, 0x0c, 0x59, 0x07,
-      0x0c, 0x14, 0x0c, 0x04, 0x38, 0x08, 0x0a, 0x06, 0x28, 0x08, 0x22, 0x4e,
-      0x81, 0x54, 0x0c, 0x15, 0x03, 0x03, 0x05, 0x07, 0x09, 0x19, 0x07, 0x07,
-      0x09, 0x03, 0x0d, 0x07, 0x29, 0x80, 0xcb, 0x25, 0x0a, 0x84, 0x06,
-  };
-  auto lower = static_cast<uint16_t>(cp);
-  if (cp < 0x10000) {
-    return is_printable(lower, singletons0,
-                        sizeof(singletons0) / sizeof(*singletons0),
-                        singletons0_lower, normal0, sizeof(normal0));
-  }
-  if (cp < 0x20000) {
-    return is_printable(lower, singletons1,
-                        sizeof(singletons1) / sizeof(*singletons1),
-                        singletons1_lower, normal1, sizeof(normal1));
-  }
-  if (0x2a6de <= cp && cp < 0x2a700) return false;
-  if (0x2b735 <= cp && cp < 0x2b740) return false;
-  if (0x2b81e <= cp && cp < 0x2b820) return false;
-  if (0x2cea2 <= cp && cp < 0x2ceb0) return false;
-  if (0x2ebe1 <= cp && cp < 0x2f800) return false;
-  if (0x2fa1e <= cp && cp < 0x30000) return false;
-  if (0x3134b <= cp && cp < 0xe0100) return false;
-  if (0xe01f0 <= cp && cp < 0x110000) return false;
-  return cp < 0x110000;
-}
-
-inline auto needs_escape(uint32_t cp) -> bool {
-  return cp < 0x20 || cp == 0x7f || cp == '"' || cp == '\\' ||
-         !is_printable(cp);
-}
-
-template <typename Char> struct find_escape_result {
-  const Char* begin;
-  const Char* end;
-  uint32_t cp;
-};
-
-template <typename Char>
-auto find_escape(const Char* begin, const Char* end)
-    -> find_escape_result<Char> {
-  for (; begin != end; ++begin) {
-    auto cp = static_cast<typename std::make_unsigned<Char>::type>(*begin);
-    if (sizeof(Char) == 1 && cp >= 0x80) continue;
-    if (needs_escape(cp)) return {begin, begin + 1, cp};
-  }
-  return {begin, nullptr, 0};
-}
-
-inline auto find_escape(const char* begin, const char* end)
-    -> find_escape_result<char> {
-  if (!is_utf8()) return find_escape<char>(begin, end);
-  auto result = find_escape_result<char>{end, nullptr, 0};
-  for_each_codepoint(string_view(begin, to_unsigned(end - begin)),
-                     [&](uint32_t cp, string_view sv) {
-                       if (needs_escape(cp)) {
-                         result = {sv.begin(), sv.end(), cp};
-                         return false;
-                       }
-                       return true;
-                     });
-  return result;
-}
-
 template <typename Char, typename OutputIt>
 auto write_range_entry(OutputIt out, basic_string_view<Char> str) -> OutputIt {
-  *out++ = '"';
-  auto begin = str.begin(), end = str.end();
-  do {
-    auto escape = find_escape(begin, end);
-    out = copy_str<Char>(begin, escape.begin, out);
-    begin = escape.end;
-    if (!begin) break;
-    auto c = static_cast<Char>(escape.cp);
-    switch (escape.cp) {
-    case '\n':
-      *out++ = '\\';
-      c = 'n';
-      break;
-    case '\r':
-      *out++ = '\\';
-      c = 'r';
-      break;
-    case '\t':
-      *out++ = '\\';
-      c = 't';
-      break;
-    case '"':
-      FMT_FALLTHROUGH;
-    case '\\':
-      *out++ = '\\';
-      break;
-    default:
-      if (is_utf8()) {
-        if (escape.cp < 0x100) {
-          out = format_to(out, "\\x{:02x}", escape.cp);
-          continue;
-        }
-        if (escape.cp < 0x10000) {
-          out = format_to(out, "\\u{:04x}", escape.cp);
-          continue;
-        }
-        if (escape.cp < 0x110000) {
-          out = format_to(out, "\\U{:08x}", escape.cp);
-          continue;
-        }
-      }
-      for (Char escape_char : basic_string_view<Char>(
-               escape.begin, to_unsigned(escape.end - escape.begin))) {
-        out = format_to(
-            out, "\\x{:02x}",
-            static_cast<typename std::make_unsigned<Char>::type>(escape_char));
-      }
-      continue;
-    }
-    *out++ = c;
-  } while (begin != end);
-  *out++ = '"';
-  return out;
+  return write_escaped_string(out, str);
 }

 template <typename Char, typename OutputIt, typename T,
@@ -523,10 +298,7 @@ inline auto write_range_entry(OutputIt out, const T& str) -> OutputIt {
 template <typename Char, typename OutputIt, typename Arg,
          FMT_ENABLE_IF(std::is_same<Arg, Char>::value)>
 OutputIt write_range_entry(OutputIt out, const Arg v) {
-  *out++ = '\'';
-  *out++ = v;
-  *out++ = '\'';
-  return out;
+  return write_escaped_char(out, v);
 }

 template <
@@ -540,128 +312,285 @@ OutputIt write_range_entry(OutputIt out, const Arg& v) {
 }  // namespace detail

 template <typename T> struct is_tuple_like {
-  static FMT_CONSTEXPR_DECL const bool value =
+  static constexpr const bool value =
      detail::is_tuple_like_<T>::value && !detail::is_range_<T>::value;
 };

+template <typename T, typename C> struct is_tuple_formattable {
+  static constexpr const bool value =
+      detail::is_tuple_formattable_<T, C>::value;
+};
+
 template <typename TupleT, typename Char>
-struct formatter<TupleT, Char, enable_if_t<fmt::is_tuple_like<TupleT>::value>> {
+struct formatter<TupleT, Char,
+                 enable_if_t<fmt::is_tuple_like<TupleT>::value &&
+                             fmt::is_tuple_formattable<TupleT, Char>::value>> {
 private:
+  basic_string_view<Char> separator_ = detail::string_literal<Char, ',', ' '>{};
+  basic_string_view<Char> opening_bracket_ =
+      detail::string_literal<Char, '('>{};
+  basic_string_view<Char> closing_bracket_ =
+      detail::string_literal<Char, ')'>{};
+
  // C++11 generic lambda for format().
  template <typename FormatContext> struct format_each {
    template <typename T> void operator()(const T& v) {
-      if (i > 0) out = detail::write_delimiter(out);
+      if (i > 0) out = detail::copy_str<Char>(separator, out);
      out = detail::write_range_entry<Char>(out, v);
      ++i;
    }
    int i;
    typename FormatContext::iterator& out;
+    basic_string_view<Char> separator;
  };

 public:
+  FMT_CONSTEXPR formatter() {}
+
+  FMT_CONSTEXPR void set_separator(basic_string_view<Char> sep) {
+    separator_ = sep;
+  }
+
+  FMT_CONSTEXPR void set_brackets(basic_string_view<Char> open,
+                                  basic_string_view<Char> close) {
+    opening_bracket_ = open;
+    closing_bracket_ = close;
+  }
+
  template <typename ParseContext>
  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
    return ctx.begin();
  }

  template <typename FormatContext = format_context>
-  auto format(const TupleT& values, FormatContext& ctx) -> decltype(ctx.out()) {
+  auto format(const TupleT& values, FormatContext& ctx) const
+      -> decltype(ctx.out()) {
    auto out = ctx.out();
-    *out++ = '(';
-    detail::for_each(values, format_each<FormatContext>{0, out});
-    *out++ = ')';
+    out = detail::copy_str<Char>(opening_bracket_, out);
+    detail::for_each(values, format_each<FormatContext>{0, out, separator_});
+    out = detail::copy_str<Char>(closing_bracket_, out);
    return out;
  }
 };

 template <typename T, typename Char> struct is_range {
-  static FMT_CONSTEXPR_DECL const bool value =
+  static constexpr const bool value =
      detail::is_range_<T>::value && !detail::is_std_string_like<T>::value &&
-      !detail::is_map<T>::value &&
      !std::is_convertible<T, std::basic_string<Char>>::value &&
-      !std::is_constructible<detail::std_string_view<Char>, T>::value;
+      !std::is_convertible<T, detail::std_string_view<Char>>::value;
 };

-template <typename T, typename Char>
-struct formatter<
-    T, Char,
-    enable_if_t<
-        fmt::is_range<T, Char>::value
-// Workaround a bug in MSVC 2019 and earlier.
-#if !FMT_MSC_VER
-        && (is_formattable<detail::value_type<T>, Char>::value ||
-            detail::has_fallback_formatter<detail::value_type<T>, Char>::value)
+namespace detail {
+template <typename Context> struct range_mapper {
+  using mapper = arg_mapper<Context>;
+
+  template <typename T,
+            FMT_ENABLE_IF(has_formatter<remove_cvref_t<T>, Context>::value)>
+  static auto map(T&& value) -> T&& {
+    return static_cast<T&&>(value);
+  }
+  template <typename T,
+            FMT_ENABLE_IF(!has_formatter<remove_cvref_t<T>, Context>::value)>
+  static auto map(T&& value)
+      -> decltype(mapper().map(static_cast<T&&>(value))) {
+    return mapper().map(static_cast<T&&>(value));
+  }
+};
+
+template <typename Char, typename Element>
+using range_formatter_type = conditional_t<
+    is_formattable<Element, Char>::value,
+    formatter<remove_cvref_t<decltype(range_mapper<buffer_context<Char>>{}.map(
+                  std::declval<Element>()))>,
+              Char>,
+    fallback_formatter<Element, Char>>;
+
+template <typename R>
+using maybe_const_range =
+    conditional_t<has_const_begin_end<R>::value, const R, R>;
+
+// Workaround a bug in MSVC 2015 and earlier.
+#if !FMT_MSC_VERSION || FMT_MSC_VERSION >= 1910
+template <typename R, typename Char>
+struct is_formattable_delayed
+    : disjunction<
+          is_formattable<uncvref_type<maybe_const_range<R>>, Char>,
+          has_fallback_formatter<uncvref_type<maybe_const_range<R>>, Char>> {};
 #endif
-        >> {
-  template <typename ParseContext>
-  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
-    return ctx.begin();
+
+}  // namespace detail
+
+template <typename T, typename Char, typename Enable = void>
+struct range_formatter;
+
+template <typename T, typename Char>
+struct range_formatter<
+    T, Char,
+    enable_if_t<conjunction<
+        std::is_same<T, remove_cvref_t<T>>,
+        disjunction<is_formattable<T, Char>,
+                    detail::has_fallback_formatter<T, Char>>>::value>> {
+ private:
+  detail::range_formatter_type<Char, T> underlying_;
+  bool custom_specs_ = false;
+  basic_string_view<Char> separator_ = detail::string_literal<Char, ',', ' '>{};
+  basic_string_view<Char> opening_bracket_ =
+      detail::string_literal<Char, '['>{};
+  basic_string_view<Char> closing_bracket_ =
+      detail::string_literal<Char, ']'>{};
+
+  template <class U>
+  FMT_CONSTEXPR static auto maybe_set_debug_format(U& u, int)
+      -> decltype(u.set_debug_format()) {
+    u.set_debug_format();
  }

-  template <
-      typename FormatContext, typename U,
-      FMT_ENABLE_IF(
-          std::is_same<U, conditional_t<detail::has_const_begin_end<T>::value,
-                                        const T, T>>::value)>
-  auto format(U& range, FormatContext& ctx) -> decltype(ctx.out()) {
-#ifdef FMT_DEPRECATED_BRACED_RANGES
-    Char prefix = '{';
-    Char postfix = '}';
-#else
-    Char prefix = detail::is_set<T>::value ? '{' : '[';
-    Char postfix = detail::is_set<T>::value ? '}' : ']';
-#endif
+  template <class U>
+  FMT_CONSTEXPR static void maybe_set_debug_format(U&, ...) {}
+
+  FMT_CONSTEXPR void maybe_set_debug_format() {
+    maybe_set_debug_format(underlying_, 0);
+  }
+
+ public:
+  FMT_CONSTEXPR range_formatter() {}
+
+  FMT_CONSTEXPR auto underlying() -> detail::range_formatter_type<Char, T>& {
+    return underlying_;
+  }
+
+  FMT_CONSTEXPR void set_separator(basic_string_view<Char> sep) {
+    separator_ = sep;
+  }
+
+  FMT_CONSTEXPR void set_brackets(basic_string_view<Char> open,
+                                  basic_string_view<Char> close) {
+    opening_bracket_ = open;
+    closing_bracket_ = close;
+  }
+
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    auto it = ctx.begin();
+    auto end = ctx.end();
+    if (it == end || *it == '}') {
+      maybe_set_debug_format();
+      return it;
+    }
+
+    if (*it == 'n') {
+      set_brackets({}, {});
+      ++it;
+    }
+
+    if (*it == '}') {
+      maybe_set_debug_format();
+      return it;
+    }
+
+    if (*it != ':')
+      FMT_THROW(format_error("no other top-level range formatters supported"));
+
+    custom_specs_ = true;
+    ++it;
+    ctx.advance_to(it);
+    return underlying_.parse(ctx);
+  }
+
+  template <typename R, class FormatContext>
+  auto format(R&& range, FormatContext& ctx) const -> decltype(ctx.out()) {
+    detail::range_mapper<buffer_context<Char>> mapper;
    auto out = ctx.out();
-    *out++ = prefix;
+    out = detail::copy_str<Char>(opening_bracket_, out);
    int i = 0;
-    auto it = std::begin(range);
-    auto end = std::end(range);
+    auto it = detail::range_begin(range);
+    auto end = detail::range_end(range);
    for (; it != end; ++it) {
-      if (i > 0) out = detail::write_delimiter(out);
-      out = detail::write_range_entry<Char>(out, *it);
+      if (i > 0) out = detail::copy_str<Char>(separator_, out);
+      ;
+      ctx.advance_to(out);
+      out = underlying_.format(mapper.map(*it), ctx);
      ++i;
    }
-    *out++ = postfix;
+    out = detail::copy_str<Char>(closing_bracket_, out);
    return out;
  }
 };

-template <typename T, typename Char>
-struct formatter<
-    T, Char,
-    enable_if_t<
-        detail::is_map<T>::value
-// Workaround a bug in MSVC 2019 and earlier.
-#if !FMT_MSC_VER
-        && (is_formattable<detail::value_type<T>, Char>::value ||
-            detail::has_fallback_formatter<detail::value_type<T>, Char>::value)
-#endif
-        >> {
-  template <typename ParseContext>
-  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
-    return ctx.begin();
+enum class range_format { disabled, map, set, sequence, string, debug_string };
+
+namespace detail {
+template <typename T> struct range_format_kind_ {
+  static constexpr auto value = std::is_same<range_reference_type<T>, T>::value
+                                    ? range_format::disabled
+                                : is_map<T>::value ? range_format::map
+                                : is_set<T>::value ? range_format::set
+                                                   : range_format::sequence;
+};
+
+template <range_format K, typename R, typename Char, typename Enable = void>
+struct range_default_formatter;
+
+template <range_format K>
+using range_format_constant = std::integral_constant<range_format, K>;
+
+template <range_format K, typename R, typename Char>
+struct range_default_formatter<
+    K, R, Char,
+    enable_if_t<(K == range_format::sequence || K == range_format::map ||
+                 K == range_format::set)>> {
+  using range_type = detail::maybe_const_range<R>;
+  range_formatter<detail::uncvref_type<range_type>, Char> underlying_;
+
+  FMT_CONSTEXPR range_default_formatter() { init(range_format_constant<K>()); }
+
+  FMT_CONSTEXPR void init(range_format_constant<range_format::set>) {
+    underlying_.set_brackets(detail::string_literal<Char, '{'>{},
+                             detail::string_literal<Char, '}'>{});
  }

-  template <
-      typename FormatContext, typename U,
-      FMT_ENABLE_IF(
-          std::is_same<U, conditional_t<detail::has_const_begin_end<T>::value,
-                                        const T, T>>::value)>
-  auto format(U& map, FormatContext& ctx) -> decltype(ctx.out()) {
-    auto out = ctx.out();
-    *out++ = '{';
-    int i = 0;
-    for (const auto& item : map) {
-      if (i > 0) out = detail::write_delimiter(out);
-      out = detail::write_range_entry<Char>(out, item.first);
-      *out++ = ':';
-      *out++ = ' ';
-      out = detail::write_range_entry<Char>(out, item.second);
-      ++i;
-    }
-    *out++ = '}';
-    return out;
+  FMT_CONSTEXPR void init(range_format_constant<range_format::map>) {
+    underlying_.set_brackets(detail::string_literal<Char, '{'>{},
+                             detail::string_literal<Char, '}'>{});
+    underlying_.underlying().set_brackets({}, {});
+    underlying_.underlying().set_separator(
+        detail::string_literal<Char, ':', ' '>{});
  }
+
+  FMT_CONSTEXPR void init(range_format_constant<range_format::sequence>) {}
+
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    return underlying_.parse(ctx);
+  }
+
+  template <typename FormatContext>
+  auto format(range_type& range, FormatContext& ctx) const
+      -> decltype(ctx.out()) {
+    return underlying_.format(range, ctx);
+  }
+};
+}  // namespace detail
+
+template <typename T, typename Char, typename Enable = void>
+struct range_format_kind
+    : conditional_t<
+          is_range<T, Char>::value, detail::range_format_kind_<T>,
+          std::integral_constant<range_format, range_format::disabled>> {};
+
+template <typename R, typename Char>
+struct formatter<
+    R, Char,
+    enable_if_t<conjunction<bool_constant<range_format_kind<R, Char>::value !=
+                                          range_format::disabled>
+// Workaround a bug in MSVC 2015 and earlier.
+#if !FMT_MSC_VERSION || FMT_MSC_VERSION >= 1910
+                            ,
+                            detail::is_formattable_delayed<R, Char>
+#endif
+                            >::value>>
+    : detail::range_default_formatter<range_format_kind<R, Char>::value, R,
+                                      Char> {
 };

 template <typename Char, typename... T> struct tuple_join_view : detail::view {
--- a/include/spdlog/fmt/bundled/xchar.h
+++ b/include/spdlog/fmt/bundled/xchar.h
@@ -9,7 +9,6 @@
 #define FMT_XCHAR_H_

 #include <cwchar>
-#include <tuple>

 #include "format.h"

@@ -30,9 +29,11 @@ using wmemory_buffer = basic_memory_buffer<wchar_t>;
 #if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
 // Workaround broken conversion on older gcc.
 template <typename... Args> using wformat_string = wstring_view;
+inline auto runtime(wstring_view s) -> wstring_view { return s; }
 #else
 template <typename... Args>
 using wformat_string = basic_format_string<wchar_t, type_identity_t<Args>...>;
+inline auto runtime(wstring_view s) -> basic_runtime<wchar_t> { return {{s}}; }
 #endif

 template <> struct is_char<wchar_t> : std::true_type {};
@@ -47,12 +48,7 @@ constexpr format_arg_store<wformat_context, Args...> make_wformat_args(
 }

 inline namespace literals {
-constexpr auto operator"" _format(const wchar_t* s, size_t n)
-    -> detail::udl_formatter<wchar_t> {
-  return {{s, n}};
-}
-
-#if FMT_USE_USER_DEFINED_LITERALS && !FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
+#if FMT_USE_USER_DEFINED_LITERALS && !FMT_USE_NONTYPE_TEMPLATE_ARGS
 constexpr detail::udl_arg<wchar_t> operator"" _a(const wchar_t* s, size_t) {
  return {s};
 }
@@ -87,13 +83,19 @@ auto vformat(basic_string_view<Char> format_str,
  return to_string(buffer);
 }

+template <typename... T>
+auto format(wformat_string<T...> fmt, T&&... args) -> std::wstring {
+  return vformat(fmt::wstring_view(fmt), fmt::make_wformat_args(args...));
+}
+
 // Pass char_t as a default template parameter instead of using
 // std::basic_string<char_t<S>> to reduce the symbol size.
 template <typename S, typename... Args, typename Char = char_t<S>,
-          FMT_ENABLE_IF(!std::is_same<Char, char>::value)>
+          FMT_ENABLE_IF(!std::is_same<Char, char>::value &&
+                        !std::is_same<Char, wchar_t>::value)>
 auto format(const S& format_str, Args&&... args) -> std::basic_string<Char> {
-  const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...);
-  return vformat(to_string_view(format_str), vargs);
+  return vformat(detail::to_string_view(format_str),
+                 fmt::make_format_args<buffer_context<Char>>(args...));
 }

 template <typename Locale, typename S, typename Char = char_t<S>,
@@ -103,7 +105,7 @@ inline auto vformat(
    const Locale& loc, const S& format_str,
    basic_format_args<buffer_context<type_identity_t<Char>>> args)
    -> std::basic_string<Char> {
-  return detail::vformat(loc, to_string_view(format_str), args);
+  return detail::vformat(loc, detail::to_string_view(format_str), args);
 }

 template <typename Locale, typename S, typename... Args,
@@ -112,8 +114,8 @@ template <typename Locale, typename S, typename... Args,
                            detail::is_exotic_char<Char>::value)>
 inline auto format(const Locale& loc, const S& format_str, Args&&... args)
    -> std::basic_string<Char> {
-  return detail::vformat(loc, to_string_view(format_str),
-                         fmt::make_args_checked<Args...>(format_str, args...));
+  return detail::vformat(loc, detail::to_string_view(format_str),
+                         fmt::make_format_args<buffer_context<Char>>(args...));
 }

 template <typename OutputIt, typename S, typename Char = char_t<S>,
@@ -123,7 +125,7 @@ auto vformat_to(OutputIt out, const S& format_str,
                basic_format_args<buffer_context<type_identity_t<Char>>> args)
    -> OutputIt {
  auto&& buf = detail::get_buffer<Char>(out);
-  detail::vformat_to(buf, to_string_view(format_str), args);
+  detail::vformat_to(buf, detail::to_string_view(format_str), args);
  return detail::get_iterator(buf);
 }

@@ -132,18 +134,8 @@ template <typename OutputIt, typename S, typename... Args,
          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
                            detail::is_exotic_char<Char>::value)>
 inline auto format_to(OutputIt out, const S& fmt, Args&&... args) -> OutputIt {
-  const auto& vargs = fmt::make_args_checked<Args...>(fmt, args...);
-  return vformat_to(out, to_string_view(fmt), vargs);
-}
-
-template <typename S, typename... Args, typename Char, size_t SIZE,
-          typename Allocator, FMT_ENABLE_IF(detail::is_string<S>::value)>
-FMT_DEPRECATED auto format_to(basic_memory_buffer<Char, SIZE, Allocator>& buf,
-                              const S& format_str, Args&&... args) ->
-    typename buffer_context<Char>::iterator {
-  const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...);
-  detail::vformat_to(buf, to_string_view(format_str), vargs, {});
-  return detail::buffer_appender<Char>(buf);
+  return vformat_to(out, detail::to_string_view(fmt),
+                    fmt::make_format_args<buffer_context<Char>>(args...));
 }

 template <typename Locale, typename S, typename OutputIt, typename... Args,
@@ -155,7 +147,8 @@ inline auto vformat_to(
    OutputIt out, const Locale& loc, const S& format_str,
    basic_format_args<buffer_context<type_identity_t<Char>>> args) -> OutputIt {
  auto&& buf = detail::get_buffer<Char>(out);
-  vformat_to(buf, to_string_view(format_str), args, detail::locale_ref(loc));
+  vformat_to(buf, detail::to_string_view(format_str), args,
+             detail::locale_ref(loc));
  return detail::get_iterator(buf);
 }

@@ -167,8 +160,8 @@ template <
 inline auto format_to(OutputIt out, const Locale& loc, const S& format_str,
                      Args&&... args) ->
    typename std::enable_if<enable, OutputIt>::type {
-  const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...);
-  return vformat_to(out, loc, to_string_view(format_str), vargs);
+  return vformat_to(out, loc, to_string_view(format_str),
+                    fmt::make_format_args<buffer_context<Char>>(args...));
 }

 template <typename OutputIt, typename Char, typename... Args,
@@ -190,16 +183,16 @@ template <typename OutputIt, typename S, typename... Args,
                            detail::is_exotic_char<Char>::value)>
 inline auto format_to_n(OutputIt out, size_t n, const S& fmt,
                        const Args&... args) -> format_to_n_result<OutputIt> {
-  const auto& vargs = fmt::make_args_checked<Args...>(fmt, args...);
-  return vformat_to_n(out, n, to_string_view(fmt), vargs);
+  return vformat_to_n(out, n, detail::to_string_view(fmt),
+                      fmt::make_format_args<buffer_context<Char>>(args...));
 }

 template <typename S, typename... Args, typename Char = char_t<S>,
          FMT_ENABLE_IF(detail::is_exotic_char<Char>::value)>
 inline auto formatted_size(const S& fmt, Args&&... args) -> size_t {
  detail::counting_buffer<Char> buf;
-  const auto& vargs = fmt::make_args_checked<Args...>(fmt, args...);
-  detail::vformat_to(buf, to_string_view(fmt), vargs);
+  detail::vformat_to(buf, detail::to_string_view(fmt),
+                     fmt::make_format_args<buffer_context<Char>>(args...));
  return buf.count();
 }

--- a/include/spdlog/fmt/fmt.h
+++ b/include/spdlog/fmt/fmt.h
@@ -21,8 +21,12 @@
 #    endif
 // enable the 'n' flag in for backward compatibility with fmt 6.x
 #    define FMT_DEPRECATED_N_SPECIFIER
+// enable ostream formatting for backward compatibility with fmt 8.x
+#    define FMT_DEPRECATED_OSTREAM
+
 #    include <spdlog/fmt/bundled/core.h>
 #    include <spdlog/fmt/bundled/format.h>
+
 #else // SPDLOG_FMT_EXTERNAL is defined - use external fmtlib
 #    include <fmt/core.h>
 #    include <fmt/format.h>
--- a/include/spdlog/logger.h
+++ b/include/spdlog/logger.h
@@ -33,7 +33,7 @@
        {                                                                                                                                  \
            if (location.filename)                                                                                                         \
            {                                                                                                                              \
-                err_handler_(fmt_lib::format("{} [{}({})]", ex.what(), location.filename, location.line));                                 \
+                err_handler_(fmt_lib::format(SPDLOG_FMT_STRING("{} [{}({})]"), ex.what(), location.filename, location.line));              \
            }                                                                                                                              \
            else                                                                                                                           \
            {                                                                                                                              \
@@ -319,6 +319,10 @@ public:
    // each sink will get a separate instance of the formatter object.
    void set_formatter(std::unique_ptr<formatter> f);

+    // set formatting for the sinks in this logger.
+    // equivalent to
+    //     set_formatter(make_unique<pattern_formatter>(pattern, time_type))
+    // Note: each sink will get a new instance of a formatter object, replacing the old one.
    void set_pattern(std::string pattern, pattern_time_type time_type = pattern_time_type::local);

    // backtrace support.
@@ -363,12 +367,13 @@ protected:
        }
        SPDLOG_TRY
        {
-#ifdef SPDLOG_USE_STD_FORMAT
-            memory_buf_t buf = std::vformat(fmt, std::make_format_args(std::forward<Args>(args)...));
-#else
            memory_buf_t buf;
-            fmt::detail::vformat_to(buf, fmt, fmt::make_format_args(std::forward<Args>(args)...));
+#ifdef SPDLOG_USE_STD_FORMAT
+            fmt_lib::vformat_to(std::back_inserter(buf), fmt, fmt_lib::make_format_args(std::forward<Args>(args)...));
+#else
+            fmt::vformat_to(fmt::appender(buf), fmt, fmt::make_format_args(std::forward<Args>(args)...));
 #endif
+
            details::log_msg log_msg(loc, name_, lvl, string_view_t(buf.data(), buf.size()));
            log_it_(log_msg, log_enabled, traceback_enabled);
        }
@@ -388,13 +393,14 @@ protected:
        SPDLOG_TRY
        {
            // format to wmemory_buffer and convert to utf8
-            ;
-#    ifdef SPDLOG_USE_STD_FORMAT
-            wmemory_buf_t wbuf = std::vformat(fmt, std::make_wformat_args(std::forward<Args>(args)...));
-#    else
            wmemory_buf_t wbuf;
-            fmt::detail::vformat_to(wbuf, fmt, fmt::make_format_args<fmt::wformat_context>(std::forward<Args>(args)...));
+#    ifdef SPDLOG_USE_STD_FORMAT
+            fmt_lib::vformat_to(
+                std::back_inserter(wbuf), fmt, fmt_lib::make_format_args<fmt_lib::wformat_context>(std::forward<Args>(args)...));
+#    else
+            fmt::vformat_to(std::back_inserter(wbuf), fmt, fmt::make_format_args<fmt::wformat_context>(std::forward<Args>(args)...));
 #    endif
+
            memory_buf_t buf;
            details::os::wstr_to_utf8buf(wstring_view_t(wbuf.data(), wbuf.size()), buf);
            details::log_msg log_msg(loc, name_, lvl, string_view_t(buf.data(), buf.size()));
--- a/include/spdlog/pattern_formatter-inl.h
+++ b/include/spdlog/pattern_formatter-inl.h
@@ -1051,7 +1051,13 @@ SPDLOG_INLINE std::unique_ptr<formatter> pattern_formatter::clone() const
    {
        cloned_custom_formatters[it.first] = it.second->clone();
    }
-    return details::make_unique<pattern_formatter>(pattern_, pattern_time_type_, eol_, std::move(cloned_custom_formatters));
+    auto cloned = details::make_unique<pattern_formatter>(pattern_, pattern_time_type_, eol_, std::move(cloned_custom_formatters));
+    cloned->need_localtime(need_localtime_);
+#if defined(__GNUC__) && __GNUC__ < 5
+    return std::move(cloned);
+#else
+    return cloned;
+#endif
 }

 SPDLOG_INLINE void pattern_formatter::format(const details::log_msg &msg, memory_buf_t &dest)
@@ -1081,6 +1087,11 @@ SPDLOG_INLINE void pattern_formatter::set_pattern(std::string pattern)
    compile_pattern_(pattern_);
 }

+SPDLOG_INLINE void pattern_formatter::need_localtime(bool need)
+{
+    need_localtime_ = need;
+}
+
 SPDLOG_INLINE std::tm pattern_formatter::get_time_(const details::log_msg &msg)
 {
    if (pattern_time_type_ == pattern_time_type::local)
--- a/include/spdlog/pattern_formatter.h
+++ b/include/spdlog/pattern_formatter.h
@@ -98,6 +98,7 @@ public:
        return *this;
    }
    void set_pattern(std::string pattern);
+    void need_localtime(bool need = true);

 private:
    std::string pattern_;
--- a/include/spdlog/sinks/android_sink.h
+++ b/include/spdlog/sinks/android_sink.h
@@ -16,6 +16,7 @@
 #    include <mutex>
 #    include <string>
 #    include <thread>
+#    include <type_traits>

 #    if !defined(SPDLOG_ANDROID_RETRIES)
 #        define SPDLOG_ANDROID_RETRIES 2
@@ -25,9 +26,10 @@ namespace spdlog {
 namespace sinks {

 /*
- * Android sink (logging using __android_log_write)
+ * Android sink
+ * (logging using __android_log_write or __android_log_buf_write depending on the specified BufferID)
 */
-template<typename Mutex>
+template<typename Mutex, int BufferID = log_id::LOG_ID_MAIN>
 class android_sink final : public base_sink<Mutex>
 {
 public:
@@ -53,24 +55,39 @@ protected:
        const char *msg_output = formatted.data();

        // See system/core/liblog/logger_write.c for explanation of return value
-        int ret = __android_log_write(priority, tag_.c_str(), msg_output);
+        int ret = android_log(priority, tag_.c_str(), msg_output);
        int retry_count = 0;
        while ((ret == -11 /*EAGAIN*/) && (retry_count < SPDLOG_ANDROID_RETRIES))
        {
            details::os::sleep_for_millis(5);
-            ret = __android_log_write(priority, tag_.c_str(), msg_output);
+            ret = android_log(priority, tag_.c_str(), msg_output);
            retry_count++;
        }

        if (ret < 0)
        {
-            throw_spdlog_ex("__android_log_write() failed", ret);
+            throw_spdlog_ex("logging to Android failed", ret);
        }
    }

    void flush_() override {}

 private:
+    // There might be liblog versions used, that do not support __android_log_buf_write. So we only compile and link against
+    // __android_log_buf_write, if user explicitely provides a non-default log buffer. Otherwise, when using the default log buffer, always
+    // log via __android_log_write.
+    template<int ID = BufferID>
+    typename std::enable_if<ID == static_cast<int>(log_id::LOG_ID_MAIN), int>::type android_log(int prio, const char *tag, const char *text)
+    {
+        return __android_log_write(prio, tag, text);
+    }
+
+    template<int ID = BufferID>
+    typename std::enable_if<ID != static_cast<int>(log_id::LOG_ID_MAIN), int>::type android_log(int prio, const char *tag, const char *text)
+    {
+        return __android_log_buf_write(ID, prio, tag, text);
+    }
+
    static android_LogPriority convert_to_android_(spdlog::level::level_enum level)
    {
        switch (level)
@@ -98,6 +115,12 @@ private:

 using android_sink_mt = android_sink<std::mutex>;
 using android_sink_st = android_sink<details::null_mutex>;
+
+template<int BufferId = log_id::LOG_ID_MAIN>
+using android_sink_buf_mt = android_sink<std::mutex, BufferId>;
+template<int BufferId = log_id::LOG_ID_MAIN>
+using android_sink_buf_st = android_sink<details::null_mutex, BufferId>;
+
 } // namespace sinks

 // Create and register android syslog logger
--- a/include/spdlog/sinks/daily_file_sink.h
+++ b/include/spdlog/sinks/daily_file_sink.h
@@ -32,8 +32,8 @@ struct daily_filename_calculator
    {
        filename_t basename, ext;
        std::tie(basename, ext) = details::file_helper::split_by_extension(filename);
-        return fmt_lib::format(
-            SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}{}"), basename, now_tm.tm_year + 1900, now_tm.tm_mon + 1, now_tm.tm_mday, ext);
+        return fmt_lib::format(SPDLOG_FMT_STRING(SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}{}")), basename, now_tm.tm_year + 1900,
+            now_tm.tm_mon + 1, now_tm.tm_mday, ext);
    }
 };

@@ -76,12 +76,15 @@ struct daily_filename_format_calculator
        return buf;
 #else
        // generate fmt datetime format string, e.g. {:%Y-%m-%d}.
-        filename_t fmt_filename = fmt::format(SPDLOG_FILENAME_T("{{:{}}}"), filename);
-#    if defined(_MSC_VER) && defined(SPDLOG_WCHAR_FILENAMES) // for some reason msvc doesn't allow fmt::runtime(..) with wchar here
+        filename_t fmt_filename = fmt::format(SPDLOG_FMT_STRING(SPDLOG_FILENAME_T("{{:{}}}")), filename);
+
+        // MSVC doesn't allow fmt::runtime(..) with wchar, with fmtlib versions < 9.1.x
+#    if defined(_MSC_VER) && defined(SPDLOG_WCHAR_FILENAMES) && FMT_VERSION < 90101
        return fmt::format(fmt_filename, now_tm);
 #    else
        return fmt::format(SPDLOG_FMT_RUNTIME(fmt_filename), now_tm);
 #    endif
+
 #endif
    }

--- a/include/spdlog/sinks/dist_sink.h
+++ b/include/spdlog/sinks/dist_sink.h
@@ -57,20 +57,20 @@ public:
 protected:
    void sink_it_(const details::log_msg &msg) override
    {
-        for (auto &sink : sinks_)
+        for (auto &sub_sink : sinks_)
        {
-            if (sink->should_log(msg.level))
+            if (sub_sink->should_log(msg.level))
            {
-                sink->log(msg);
+                sub_sink->log(msg);
            }
        }
    }

    void flush_() override
    {
-        for (auto &sink : sinks_)
+        for (auto &sub_sink : sinks_)
        {
-            sink->flush();
+            sub_sink->flush();
        }
    }

@@ -82,9 +82,9 @@ protected:
    void set_formatter_(std::unique_ptr<spdlog::formatter> sink_formatter) override
    {
        base_sink<Mutex>::formatter_ = std::move(sink_formatter);
-        for (auto &sink : sinks_)
+        for (auto &sub_sink : sinks_)
        {
-            sink->set_formatter(base_sink<Mutex>::formatter_->clone());
+            sub_sink->set_formatter(base_sink<Mutex>::formatter_->clone());
        }
    }
    std::vector<std::shared_ptr<sink>> sinks_;
--- a/include/spdlog/sinks/hourly_file_sink.h
+++ b/include/spdlog/sinks/hourly_file_sink.h
@@ -57,6 +57,7 @@ public:
        auto now = log_clock::now();
        auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(now));
        file_helper_.open(filename, truncate_);
+        remove_init_file_ = file_helper_.size() == 0;
        rotation_tp_ = next_rotation_tp_();

        if (max_files_ > 0)
@@ -78,10 +79,16 @@ protected:
        bool should_rotate = time >= rotation_tp_;
        if (should_rotate)
        {
+            if (remove_init_file_)
+            {
+                file_helper_.close();
+                details::os::remove(file_helper_.filename());
+            }
            auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(time));
            file_helper_.open(filename, truncate_);
            rotation_tp_ = next_rotation_tp_();
        }
+        remove_init_file_ = false;
        memory_buf_t formatted;
        base_sink<Mutex>::formatter_->format(msg, formatted);
        file_helper_.write(formatted);
@@ -170,6 +177,7 @@ private:
    bool truncate_;
    uint16_t max_files_;
    details::circular_q<filename_t> filenames_q_;
+    bool remove_init_file_;
 };

 using hourly_file_sink_mt = hourly_file_sink<std::mutex>;
--- a/include/spdlog/sinks/mongo_sink.h
+++ b/include/spdlog/sinks/mongo_sink.h
@@ -30,16 +30,26 @@ class mongo_sink : public base_sink<Mutex>
 {
 public:
    mongo_sink(const std::string &db_name, const std::string &collection_name, const std::string &uri = "mongodb://localhost:27017")
+    try : mongo_sink(std::make_shared<mongocxx::instance>(), db_name, collection_name, uri)
+    {}
+    catch (const std::exception &e)
+    {
+        throw_spdlog_ex(fmt_lib::format("Error opening database: {}", e.what()));
+    }
+
+    mongo_sink(std::shared_ptr<mongocxx::instance> instance, const std::string &db_name, const std::string &collection_name,
+        const std::string &uri = "mongodb://localhost:27017")
+        : instance_(std::move(instance))
+        , db_name_(db_name)
+        , coll_name_(collection_name)
    {
        try
        {
            client_ = spdlog::details::make_unique<mongocxx::client>(mongocxx::uri{uri});
-            db_name_ = db_name;
-            coll_name_ = collection_name;
        }
-        catch (const std::exception)
+        catch (const std::exception &e)
        {
-            throw spdlog_ex("Error opening database");
+            throw_spdlog_ex(fmt_lib::format("Error opening database: {}", e.what()));
        }
    }

@@ -57,8 +67,8 @@ protected:
        if (client_ != nullptr)
        {
            auto doc = document{} << "timestamp" << bsoncxx::types::b_date(msg.time) << "level" << level::to_string_view(msg.level).data()
-                                  << "message" << std::string(msg.payload.begin(), msg.payload.end()) << "logger_name"
-                                  << std::string(msg.logger_name.begin(), msg.logger_name.end()) << "thread_id"
+                                  << "level_num" << msg.level << "message" << std::string(msg.payload.begin(), msg.payload.end())
+                                  << "logger_name" << std::string(msg.logger_name.begin(), msg.logger_name.end()) << "thread_id"
                                  << static_cast<int>(msg.thread_id) << finalize;
            client_->database(db_name_).collection(coll_name_).insert_one(doc.view());
        }
@@ -67,13 +77,11 @@ protected:
    void flush_() override {}

 private:
-    static mongocxx::instance instance_;
+    std::shared_ptr<mongocxx::instance> instance_;
    std::string db_name_;
    std::string coll_name_;
    std::unique_ptr<mongocxx::client> client_ = nullptr;
 };
-template<>
-mongocxx::instance mongo_sink<std::mutex>::instance_{};

 #include "spdlog/details/null_mutex.h"
 #include <mutex>
--- a/include/spdlog/sinks/msvc_sink.h
+++ b/include/spdlog/sinks/msvc_sink.h
@@ -1,8 +1,9 @@
-// Copyright(c) 2016 Alexander Dalshov.
+// Copyright(c) 2016 Alexander Dalshov & spdlog contributors.
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)

 #pragma once

+
 #if defined(_WIN32)

 #    include <spdlog/details/null_mutex.h>
@@ -13,6 +14,7 @@

 // Avoid including windows.h (https://stackoverflow.com/a/30741042)
 extern "C" __declspec(dllimport) void __stdcall OutputDebugStringA(const char *lpOutputString);
+extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();

 namespace spdlog {
 namespace sinks {
@@ -24,20 +26,25 @@ class msvc_sink : public base_sink<Mutex>
 {
 public:
    msvc_sink() = default;
+    msvc_sink(bool check_ebugger_present)
+        : check_debbugger_present_{check_ebugger_present} {};

 protected:
    void sink_it_(const details::log_msg &msg) override
    {
+        if (check_debbugger_present_ && !IsDebuggerPresent())
+        {
+            return;
+        }
        memory_buf_t formatted;
        base_sink<Mutex>::formatter_->format(msg, formatted);
-#    ifdef SPDLOG_USE_STD_FORMAT
-        OutputDebugStringA(formatted.c_str());
-#    else
-        OutputDebugStringA(fmt::to_string(formatted).c_str());
-#    endif
+        formatted.push_back('\0'); // add a null terminator for OutputDebugStringA
+        OutputDebugStringA(formatted.data());
    }

    void flush_() override {}
+
+    bool check_debbugger_present_ = true;
 };

 using msvc_sink_mt = msvc_sink<std::mutex>;
--- a/include/spdlog/sinks/ringbuffer_sink.h
+++ b/include/spdlog/sinks/ringbuffer_sink.h
@@ -50,11 +50,7 @@ public:
        {
            memory_buf_t formatted;
            base_sink<Mutex>::formatter_->format(q_.at(i), formatted);
-#ifdef SPDLOG_USE_STD_FORMAT
-            ret.push_back(std::move(formatted));
-#else
-            ret.push_back(fmt::to_string(formatted));
-#endif
+            ret.push_back(std::move(SPDLOG_BUF_TO_STRING(formatted)));
        }
        return ret;
    }
--- a/include/spdlog/sinks/win_eventlog_sink.h
+++ b/include/spdlog/sinks/win_eventlog_sink.h
@@ -241,12 +241,12 @@ protected:
        details::os::utf8_to_wstrbuf(string_view_t(formatted.data(), formatted.size()), buf);

        LPCWSTR lp_wstr = buf.data();
-        succeeded = ::ReportEventW(event_log_handle(), eventlog::get_event_type(msg), eventlog::get_event_category(msg), event_id_,
-            current_user_sid_.as_sid(), 1, 0, &lp_wstr, nullptr);
+        succeeded = static_cast<bool>(::ReportEventW(event_log_handle(), eventlog::get_event_type(msg), eventlog::get_event_category(msg), event_id_,
+            current_user_sid_.as_sid(), 1, 0, &lp_wstr, nullptr));
 #else
        LPCSTR lp_str = formatted.data();
-        succeeded = ::ReportEventA(event_log_handle(), eventlog::get_event_type(msg), eventlog::get_event_category(msg), event_id_,
-            current_user_sid_.as_sid(), 1, 0, &lp_str, nullptr);
+        succeeded = static_cast<bool>(::ReportEventA(event_log_handle(), eventlog::get_event_type(msg), eventlog::get_event_category(msg), event_id_,
+            current_user_sid_.as_sid(), 1, 0, &lp_str, nullptr));
 #endif

        if (!succeeded)
--- a/include/spdlog/sinks/wincolor_sink-inl.h
+++ b/include/spdlog/sinks/wincolor_sink-inl.h
@@ -45,7 +45,7 @@ template<typename ConsoleMutex>
 void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::set_color(level::level_enum level, std::uint16_t color)
 {
    std::lock_guard<mutex_t> lock(mutex_);
-    colors_[level] = color;
+    colors_[static_cast<size_t>(level)] = color;
 }

 template<typename ConsoleMutex>
@@ -66,7 +66,7 @@ void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::log(const details::log_msg &msg)
        // before color range
        print_range_(formatted, 0, msg.color_range_start);
        // in color range
-        auto orig_attribs = static_cast<WORD>(set_foreground_color_(colors_[msg.level]));
+        auto orig_attribs = static_cast<WORD>(set_foreground_color_(colors_[static_cast<size_t>(msg.level)]));
        print_range_(formatted, msg.color_range_start, msg.color_range_end);
        // reset to orig colors
        ::SetConsoleTextAttribute(static_cast<HANDLE>(out_handle_), orig_attribs);
--- a/include/spdlog/spdlog-inl.h
+++ b/include/spdlog/spdlog-inl.h
@@ -67,11 +67,6 @@ SPDLOG_INLINE void flush_on(level::level_enum log_level)
    details::registry::instance().flush_on(log_level);
 }

-SPDLOG_INLINE void flush_every(std::chrono::seconds interval)
-{
-    details::registry::instance().flush_every(interval);
-}
-
 SPDLOG_INLINE void set_error_handler(void (*handler)(const std::string &msg))
 {
    details::registry::instance().set_error_handler(handler);
--- a/include/spdlog/spdlog.h
+++ b/include/spdlog/spdlog.h
@@ -81,7 +81,11 @@ SPDLOG_API void flush_on(level::level_enum log_level);

 // Start/Restart a periodic flusher thread
 // Warning: Use only if all your loggers are thread safe!
-SPDLOG_API void flush_every(std::chrono::seconds interval);
+template<typename Rep, typename Period>
+inline void flush_every(std::chrono::duration<Rep, Period> interval)
+{
+    details::registry::instance().flush_every(interval);
+}

 // Set global error handler
 SPDLOG_API void set_error_handler(void (*handler)(const std::string &msg));
@@ -288,7 +292,12 @@ inline void critical(const T &msg)
 // SPDLOG_LEVEL_OFF
 //

-#define SPDLOG_LOGGER_CALL(logger, level, ...) (logger)->log(spdlog::source_loc{__FILE__, __LINE__, SPDLOG_FUNCTION}, level, __VA_ARGS__)
+#ifndef SPDLOG_NO_SOURCE_LOC
+#    define SPDLOG_LOGGER_CALL(logger, level, ...)                                                                                         \
+        (logger)->log(spdlog::source_loc{__FILE__, __LINE__, SPDLOG_FUNCTION}, level, __VA_ARGS__)
+#else
+#    define SPDLOG_LOGGER_CALL(logger, level, ...) (logger)->log(spdlog::source_loc{}, level, __VA_ARGS__)
+#endif

 #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_TRACE
 #    define SPDLOG_LOGGER_TRACE(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::trace, __VA_ARGS__)
--- a/include/spdlog/stopwatch.h
+++ b/include/spdlog/stopwatch.h
@@ -4,6 +4,7 @@
 #pragma once

 #include <spdlog/fmt/fmt.h>
+#include <chrono>

 // Stopwatch support for spdlog  (using std::chrono::steady_clock).
 // Displays elapsed seconds since construction as double.
--- a/include/spdlog/tweakme.h
+++ b/include/spdlog/tweakme.h
@@ -19,6 +19,13 @@
 // #define SPDLOG_CLOCK_COARSE
 ///////////////////////////////////////////////////////////////////////////////

+///////////////////////////////////////////////////////////////////////////////
+// Uncomment if source location logging is not needed.
+// This will prevent spdlog from using __FILE__, __LINE__ and SPDLOG_FUNCTION
+//
+// #define SPDLOG_NO_SOURCE_LOC
+///////////////////////////////////////////////////////////////////////////////
+
 ///////////////////////////////////////////////////////////////////////////////
 // Uncomment if thread id logging is not needed (i.e. no %t in the log pattern).
 // This will prevent spdlog from querying the thread id on each log call.
--- a/include/spdlog/version.h
+++ b/include/spdlog/version.h
@@ -4,7 +4,7 @@
 #pragma once

 #define SPDLOG_VER_MAJOR 1
-#define SPDLOG_VER_MINOR 10
+#define SPDLOG_VER_MINOR 11
 #define SPDLOG_VER_PATCH 0

 #define SPDLOG_VERSION (SPDLOG_VER_MAJOR * 10000 + SPDLOG_VER_MINOR * 100 + SPDLOG_VER_PATCH)
--- a/scripts/ci_setup_clang.sh
+++ b/scripts/ci_setup_clang.sh
@@ -0,0 +1,12 @@
+#!/bin/bash
+
+set -ex
+
+VERSION=$1
+
+apt-get update
+apt-get install -y libc++-${VERSION}-dev libc++abi-${VERSION}-dev
+
+if [[ "${VERSION}" -ge 12 ]]; then
+    apt-get install -y --no-install-recommends libunwind-${VERSION}-dev
+fi
--- a/src/async.cpp
+++ b/src/async.cpp
@@ -9,5 +9,3 @@
 #include <spdlog/async_logger-inl.h>
 #include <spdlog/details/periodic_worker-inl.h>
 #include <spdlog/details/thread_pool-inl.h>
-
-template class SPDLOG_API spdlog::details::mpmc_blocking_queue<spdlog::details::async_msg>;
--- a/src/bundled_fmtlib_format.cpp
+++ b/src/bundled_fmtlib_format.cpp
@@ -0,0 +1,52 @@
+// Slightly modified version of fmt lib's format.cc (version 1.9.1) source file.
+// Copyright (c) 2012 - 2016, Victor Zverovich
+// All rights reserved.
+
+#ifndef SPDLOG_COMPILED_LIB
+#    error Please define SPDLOG_COMPILED_LIB to compile this file.
+#endif
+
+#if !defined(SPDLOG_FMT_EXTERNAL) && !defined(SPDLOG_USE_STD_FORMAT)
+
+#include <spdlog/fmt/bundled/format-inl.h>
+
+FMT_BEGIN_NAMESPACE
+namespace detail {
+
+template FMT_API auto dragonbox::to_decimal(float x) noexcept
+    -> dragonbox::decimal_fp<float>;
+template FMT_API auto dragonbox::to_decimal(double x) noexcept
+    -> dragonbox::decimal_fp<double>;
+
+#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
+template FMT_API locale_ref::locale_ref(const std::locale& loc);
+template FMT_API auto locale_ref::get<std::locale>() const -> std::locale;
+#endif
+
+// Explicit instantiations for char.
+
+template FMT_API auto thousands_sep_impl(locale_ref)
+    -> thousands_sep_result<char>;
+template FMT_API auto decimal_point_impl(locale_ref) -> char;
+
+template FMT_API void buffer<char>::append(const char*, const char*);
+
+// DEPRECATED!
+// There is no correspondent extern template in format.h because of
+// incompatibility between clang and gcc (#2377).
+template FMT_API void vformat_to(buffer<char>&, string_view,
+    basic_format_args<FMT_BUFFER_CONTEXT(char)>,
+    locale_ref);
+
+// Explicit instantiations for wchar_t.
+
+template FMT_API auto thousands_sep_impl(locale_ref)
+    -> thousands_sep_result<wchar_t>;
+template FMT_API auto decimal_point_impl(locale_ref) -> wchar_t;
+
+template FMT_API void buffer<wchar_t>::append(const wchar_t*, const wchar_t*);
+
+}  // namespace detail
+FMT_END_NAMESPACE
+
+#endif // !SPDLOG_FMT_EXTERNAL
--- a/src/fmt.cpp
+++ b/src/fmt.cpp
@@ -1,110 +0,0 @@
-// Slightly modified version of fmt lib's format.cc source file.
-// Copyright (c) 2012 - 2016, Victor Zverovich
-// All rights reserved.
-
-#ifndef SPDLOG_COMPILED_LIB
-#    error Please define SPDLOG_COMPILED_LIB to compile this file.
-#endif
-
-#if !defined(SPDLOG_FMT_EXTERNAL) && !defined(SPDLOG_USE_STD_FORMAT)
-#    include <spdlog/fmt/bundled/format-inl.h>
-
-FMT_BEGIN_NAMESPACE
-namespace detail {
-
-// DEPRECATED!
-template<typename T = void>
-struct basic_data
-{
-    FMT_API static constexpr const char digits[100][2] = {{'0', '0'}, {'0', '1'}, {'0', '2'}, {'0', '3'}, {'0', '4'}, {'0', '5'},
-        {'0', '6'}, {'0', '7'}, {'0', '8'}, {'0', '9'}, {'1', '0'}, {'1', '1'}, {'1', '2'}, {'1', '3'}, {'1', '4'}, {'1', '5'}, {'1', '6'},
-        {'1', '7'}, {'1', '8'}, {'1', '9'}, {'2', '0'}, {'2', '1'}, {'2', '2'}, {'2', '3'}, {'2', '4'}, {'2', '5'}, {'2', '6'}, {'2', '7'},
-        {'2', '8'}, {'2', '9'}, {'3', '0'}, {'3', '1'}, {'3', '2'}, {'3', '3'}, {'3', '4'}, {'3', '5'}, {'3', '6'}, {'3', '7'}, {'3', '8'},
-        {'3', '9'}, {'4', '0'}, {'4', '1'}, {'4', '2'}, {'4', '3'}, {'4', '4'}, {'4', '5'}, {'4', '6'}, {'4', '7'}, {'4', '8'}, {'4', '9'},
-        {'5', '0'}, {'5', '1'}, {'5', '2'}, {'5', '3'}, {'5', '4'}, {'5', '5'}, {'5', '6'}, {'5', '7'}, {'5', '8'}, {'5', '9'}, {'6', '0'},
-        {'6', '1'}, {'6', '2'}, {'6', '3'}, {'6', '4'}, {'6', '5'}, {'6', '6'}, {'6', '7'}, {'6', '8'}, {'6', '9'}, {'7', '0'}, {'7', '1'},
-        {'7', '2'}, {'7', '3'}, {'7', '4'}, {'7', '5'}, {'7', '6'}, {'7', '7'}, {'7', '8'}, {'7', '9'}, {'8', '0'}, {'8', '1'}, {'8', '2'},
-        {'8', '3'}, {'8', '4'}, {'8', '5'}, {'8', '6'}, {'8', '7'}, {'8', '8'}, {'8', '9'}, {'9', '0'}, {'9', '1'}, {'9', '2'}, {'9', '3'},
-        {'9', '4'}, {'9', '5'}, {'9', '6'}, {'9', '7'}, {'9', '8'}, {'9', '9'}};
-    FMT_API static constexpr const char hex_digits[] = "0123456789abcdef";
-    FMT_API static constexpr const char signs[4] = {0, '-', '+', ' '};
-    FMT_API static constexpr const char left_padding_shifts[5] = {31, 31, 0, 1, 0};
-    FMT_API static constexpr const char right_padding_shifts[5] = {0, 31, 0, 1, 0};
-    FMT_API static constexpr const unsigned prefixes[4] = {0, 0, 0x1000000u | '+', 0x1000000u | ' '};
-};
-
-#    ifdef FMT_SHARED
-// Required for -flto, -fivisibility=hidden and -shared to work
-extern template struct basic_data<void>;
-#    endif
-
-#    if __cplusplus < 201703L
-// DEPRECATED! These are here only for ABI compatiblity.
-template<typename T>
-constexpr const char basic_data<T>::digits[][2];
-template<typename T>
-constexpr const char basic_data<T>::hex_digits[];
-template<typename T>
-constexpr const char basic_data<T>::signs[];
-template<typename T>
-constexpr const char basic_data<T>::left_padding_shifts[];
-template<typename T>
-constexpr const char basic_data<T>::right_padding_shifts[];
-template<typename T>
-constexpr const unsigned basic_data<T>::prefixes[];
-#    endif
-
-template<typename T>
-int format_float(char *buf, std::size_t size, const char *format, int precision, T value)
-{
-#    ifdef FMT_FUZZ
-    if (precision > 100000)
-        throw std::runtime_error("fuzz mode - avoid large allocation inside snprintf");
-#    endif
-    // Suppress the warning about nonliteral format string.
-    int (*snprintf_ptr)(char *, size_t, const char *, ...) = FMT_SNPRINTF;
-    return precision < 0 ? snprintf_ptr(buf, size, format, value) : snprintf_ptr(buf, size, format, precision, value);
-}
-
-template FMT_API dragonbox::decimal_fp<float> dragonbox::to_decimal(float x) FMT_NOEXCEPT;
-template FMT_API dragonbox::decimal_fp<double> dragonbox::to_decimal(double x) FMT_NOEXCEPT;
-} // namespace detail
-
-// Workaround a bug in MSVC2013 that prevents instantiation of format_float.
-int (*instantiate_format_float)(double, int, detail::float_specs, detail::buffer<char> &) = detail::format_float;
-
-#    ifndef FMT_STATIC_THOUSANDS_SEPARATOR
-template FMT_API detail::locale_ref::locale_ref(const std::locale &loc);
-template FMT_API std::locale detail::locale_ref::get<std::locale>() const;
-#    endif
-
-// Explicit instantiations for char.
-
-template FMT_API auto detail::thousands_sep_impl(locale_ref) -> thousands_sep_result<char>;
-template FMT_API char detail::decimal_point_impl(locale_ref);
-
-template FMT_API void detail::buffer<char>::append(const char *, const char *);
-
-// DEPRECATED!
-// There is no correspondent extern template in format.h because of
-// incompatibility between clang and gcc (#2377).
-template FMT_API void detail::vformat_to(
-    detail::buffer<char> &, string_view, basic_format_args<FMT_BUFFER_CONTEXT(char)>, detail::locale_ref);
-
-template FMT_API int detail::snprintf_float(double, int, detail::float_specs, detail::buffer<char> &);
-template FMT_API int detail::snprintf_float(long double, int, detail::float_specs, detail::buffer<char> &);
-template FMT_API int detail::format_float(double, int, detail::float_specs, detail::buffer<char> &);
-template FMT_API int detail::format_float(long double, int, detail::float_specs, detail::buffer<char> &);
-
-// Explicit instantiations for wchar_t.
-
-template FMT_API auto detail::thousands_sep_impl(locale_ref) -> thousands_sep_result<wchar_t>;
-template FMT_API wchar_t detail::decimal_point_impl(locale_ref);
-
-template FMT_API void detail::buffer<wchar_t>::append(const wchar_t *, const wchar_t *);
-
-template struct detail::basic_data<void>;
-
-FMT_END_NAMESPACE
-
-#endif // !SPDLOG_FMT_EXTERNAL
--- a/tests/includes.h
+++ b/tests/includes.h
@@ -1,6 +1,14 @@
 #pragma once

+#if defined(__GNUC__) && __GNUC__ == 12
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wmaybe-uninitialized" // Workaround for GCC 12
+#endif
 #include "catch.hpp"
+#if defined(__GNUC__) && __GNUC__ == 12
+#    pragma GCC diagnostic pop
+#endif
+
 #include "utils.h"
 #include <chrono>
 #include <cstdio>
@@ -17,10 +25,11 @@

 #include "spdlog/spdlog.h"
 #include "spdlog/async.h"
+#include "spdlog/details/fmt_helper.h"
 #include "spdlog/sinks/basic_file_sink.h"
 #include "spdlog/sinks/daily_file_sink.h"
 #include "spdlog/sinks/null_sink.h"
 #include "spdlog/sinks/ostream_sink.h"
 #include "spdlog/sinks/rotating_file_sink.h"
 #include "spdlog/sinks/stdout_color_sinks.h"
-#include "spdlog/pattern_formatter.h"
+#include "spdlog/pattern_formatter.h"
--- a/tests/main.cpp
+++ b/tests/main.cpp
@@ -1,2 +1,11 @@
+#if defined(__GNUC__) && __GNUC__ == 12
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wmaybe-uninitialized" // Workaround for GCC 12
+#endif
+
 #define CATCH_CONFIG_MAIN
-#include "catch.hpp"
+#include "catch.hpp"
+
+#if defined(__GNUC__) && __GNUC__ == 12
+#    pragma GCC diagnostic pop
+#endif
--- a/tests/test_daily_logger.cpp
+++ b/tests/test_daily_logger.cpp
@@ -9,6 +9,20 @@ using filename_memory_buf_t = std::basic_string<spdlog::filename_t::value_type>;
 using filename_memory_buf_t = fmt::basic_memory_buffer<spdlog::filename_t::value_type, 250>;
 #endif

+#ifdef SPDLOG_WCHAR_FILENAMES
+std::string filename_buf_to_utf8string(const filename_memory_buf_t &w)
+{
+    spdlog::memory_buf_t buf;
+    spdlog::details::os::wstr_to_utf8buf(spdlog::wstring_view_t(w.data(), w.size()), buf);
+    return SPDLOG_BUF_TO_STRING(buf);
+}
+#else
+std::string filename_buf_to_utf8string(const filename_memory_buf_t &w)
+{
+    return SPDLOG_BUF_TO_STRING(w);
+}
+#endif
+
 TEST_CASE("daily_logger with dateonly calculator", "[daily_logger]")
 {
    using sink_type = spdlog::sinks::daily_file_sink<std::mutex, spdlog::sinks::daily_filename_calculator>;
@@ -30,23 +44,7 @@ TEST_CASE("daily_logger with dateonly calculator", "[daily_logger]")
    }
    logger->flush();

-#ifdef SPDLOG_WCHAR_FILENAMES
-    spdlog::memory_buf_t buf;
-#    ifdef SPDLOG_USE_STD_FORMAT
-    spdlog::details::os::wstr_to_utf8buf(w, buf);
-    auto &filename = buf;
-#    else
-    spdlog::details::os::wstr_to_utf8buf(fmt::to_string(w), buf);
-    auto filename = fmt::to_string(buf);
-#    endif
-#else
-#    ifdef SPDLOG_USE_STD_FORMAT
-    auto &filename = w;
-#    else
-    auto filename = fmt::to_string(w);
-#    endif
-#endif
-    require_message_count(filename, 10);
+    require_message_count(filename_buf_to_utf8string(w), 10);
 }

 struct custom_daily_file_name_calculator
@@ -56,11 +54,8 @@ struct custom_daily_file_name_calculator
        filename_memory_buf_t w;
        spdlog::fmt_lib::format_to(std::back_inserter(w), SPDLOG_FILENAME_T("{}{:04d}{:02d}{:02d}"), basename, now_tm.tm_year + 1900,
            now_tm.tm_mon + 1, now_tm.tm_mday);
-#ifdef SPDLOG_USE_STD_FORMAT
-        return w;
-#else
-        return fmt::to_string(w);
-#endif
+
+        return SPDLOG_BUF_TO_STRING(w);
    }
 };

@@ -85,23 +80,7 @@ TEST_CASE("daily_logger with custom calculator", "[daily_logger]")

    logger->flush();

-#ifdef SPDLOG_WCHAR_FILENAMES
-    spdlog::memory_buf_t buf;
-#    ifdef SPDLOG_USE_STD_FORMAT
-    spdlog::details::os::wstr_to_utf8buf(w, buf);
-    auto &filename = buf;
-#    else
-    spdlog::details::os::wstr_to_utf8buf(fmt::to_string(w), buf);
-    auto filename = fmt::to_string(buf);
-#    endif
-#else
-#    ifdef SPDLOG_USE_STD_FORMAT
-    auto &filename = w;
-#    else
-    auto filename = fmt::to_string(w);
-#    endif
-#endif
-    require_message_count(filename, 10);
+    require_message_count(filename_buf_to_utf8string(w), 10);
 }

 /*
--- a/tests/test_errors.cpp
+++ b/tests/test_errors.cpp
@@ -29,11 +29,7 @@ TEST_CASE("default_error_handler", "[errors]]")

    auto logger = spdlog::create<spdlog::sinks::basic_file_sink_mt>("test-error", filename, true);
    logger->set_pattern("%v");
-#ifdef SPDLOG_USE_STD_FORMAT
-    logger->info("Test message {} {}", 1);
-#else
-    logger->info(fmt::runtime("Test message {} {}"), 1);
-#endif
+    logger->info(SPDLOG_FMT_RUNTIME("Test message {} {}"), 1);
    logger->info("Test message {}", 2);
    logger->flush();

@@ -53,11 +49,7 @@ TEST_CASE("custom_error_handler", "[errors]]")
    logger->set_error_handler([=](const std::string &) { throw custom_ex(); });
    logger->info("Good message #1");

-#ifdef SPDLOG_USE_STD_FORMAT
-    REQUIRE_THROWS_AS(logger->info("Bad format msg {} {}", "xxx"), custom_ex);
-#else
-    REQUIRE_THROWS_AS(logger->info(fmt::runtime("Bad format msg {} {}"), "xxx"), custom_ex);
-#endif
+    REQUIRE_THROWS_AS(logger->info(SPDLOG_FMT_RUNTIME("Bad format msg {} {}"), "xxx"), custom_ex);
    logger->info("Good message #2");
    require_message_count(SIMPLE_LOG, 2);
 }
@@ -96,11 +88,7 @@ TEST_CASE("async_error_handler", "[errors]]")
            ofs << err_msg;
        });
        logger->info("Good message #1");
-#ifdef SPDLOG_USE_STD_FORMAT
-        logger->info("Bad format msg {} {}", "xxx");
-#else
-        logger->info(fmt::runtime("Bad format msg {} {}"), "xxx");
-#endif
+        logger->info(SPDLOG_FMT_RUNTIME("Bad format msg {} {}"), "xxx");
        logger->info("Good message #2");
        spdlog::drop("logger"); // force logger to drain the queue and shutdown
    }
--- a/tests/test_fmt_helper.cpp
+++ b/tests/test_fmt_helper.cpp
@@ -1,19 +1,15 @@

 #include "includes.h"
-#include "spdlog/details/fmt_helper.h"

 using spdlog::memory_buf_t;
+using spdlog::details::fmt_helper::to_string_view;

 void test_pad2(int n, const char *expected)
 {
    memory_buf_t buf;
    spdlog::details::fmt_helper::pad2(n, buf);

-#ifdef SPDLOG_USE_STD_FORMAT
-    REQUIRE(buf == expected);
-#else
-    REQUIRE(fmt::to_string(buf) == expected);
-#endif
+    REQUIRE(to_string_view(buf) == expected);
 }

 void test_pad3(uint32_t n, const char *expected)
@@ -21,11 +17,7 @@ void test_pad3(uint32_t n, const char *expected)
    memory_buf_t buf;
    spdlog::details::fmt_helper::pad3(n, buf);

-#ifdef SPDLOG_USE_STD_FORMAT
-    REQUIRE(buf == expected);
-#else
-    REQUIRE(fmt::to_string(buf) == expected);
-#endif
+    REQUIRE(to_string_view(buf) == expected);
 }

 void test_pad6(std::size_t n, const char *expected)
@@ -33,11 +25,7 @@ void test_pad6(std::size_t n, const char *expected)
    memory_buf_t buf;
    spdlog::details::fmt_helper::pad6(n, buf);

-#ifdef SPDLOG_USE_STD_FORMAT
-    REQUIRE(buf == expected);
-#else
-    REQUIRE(fmt::to_string(buf) == expected);
-#endif
+    REQUIRE(to_string_view(buf) == expected);
 }

 void test_pad9(std::size_t n, const char *expected)
@@ -45,11 +33,7 @@ void test_pad9(std::size_t n, const char *expected)
    memory_buf_t buf;
    spdlog::details::fmt_helper::pad9(n, buf);

-#ifdef SPDLOG_USE_STD_FORMAT
-    REQUIRE(buf == expected);
-#else
-    REQUIRE(fmt::to_string(buf) == expected);
-#endif
+    REQUIRE(to_string_view(buf) == expected);
 }

 TEST_CASE("pad2", "[fmt_helper]")
--- a/tests/test_misc.cpp
+++ b/tests/test_misc.cpp
@@ -131,7 +131,7 @@ TEST_CASE("clone async", "[clone]")
    logger->info("Some message 1");
    cloned->info("Some message 2");

-    spdlog::details::os::sleep_for_millis(10);
+    spdlog::details::os::sleep_for_millis(100);

    REQUIRE(test_sink->lines().size() == 2);
    REQUIRE(test_sink->lines()[0] == "Some message 1");
--- a/tests/test_pattern_formatter.cpp
+++ b/tests/test_pattern_formatter.cpp
@@ -2,6 +2,7 @@
 #include "test_sink.h"

 using spdlog::memory_buf_t;
+using spdlog::details::fmt_helper::to_string_view;

 // log to str and return it
 template<typename... Args>
@@ -273,11 +274,7 @@ TEST_CASE("clone-default-formatter", "[pattern_formatter]")
    formatter_1->format(msg, formatted_1);
    formatter_2->format(msg, formatted_2);

-#ifdef SPDLOG_USE_STD_FORMAT
-    REQUIRE(formatted_1 == formatted_2);
-#else
-    REQUIRE(fmt::to_string(formatted_1) == fmt::to_string(formatted_2));
-#endif
+    REQUIRE(to_string_view(formatted_1) == to_string_view(formatted_2));
 }

 TEST_CASE("clone-default-formatter2", "[pattern_formatter]")
@@ -292,11 +289,7 @@ TEST_CASE("clone-default-formatter2", "[pattern_formatter]")
    formatter_1->format(msg, formatted_1);
    formatter_2->format(msg, formatted_2);

-#ifdef SPDLOG_USE_STD_FORMAT
-    REQUIRE(formatted_1 == formatted_2);
-#else
-    REQUIRE(fmt::to_string(formatted_1) == fmt::to_string(formatted_2));
-#endif
+    REQUIRE(to_string_view(formatted_1) == to_string_view(formatted_2));
 }

 TEST_CASE("clone-formatter", "[pattern_formatter]")
@@ -311,11 +304,7 @@ TEST_CASE("clone-formatter", "[pattern_formatter]")
    formatter_1->format(msg, formatted_1);
    formatter_2->format(msg, formatted_2);

-#ifdef SPDLOG_USE_STD_FORMAT
-    REQUIRE(formatted_1 == formatted_2);
-#else
-    REQUIRE(fmt::to_string(formatted_1) == fmt::to_string(formatted_2));
-#endif
+    REQUIRE(to_string_view(formatted_1) == to_string_view(formatted_2));
 }

 TEST_CASE("clone-formatter-2", "[pattern_formatter]")
@@ -331,11 +320,7 @@ TEST_CASE("clone-formatter-2", "[pattern_formatter]")
    formatter_1->format(msg, formatted_1);
    formatter_2->format(msg, formatted_2);

-#ifdef SPDLOG_USE_STD_FORMAT
-    REQUIRE(formatted_1 == formatted_2);
-#else
-    REQUIRE(fmt::to_string(formatted_1) == fmt::to_string(formatted_2));
-#endif
+    REQUIRE(to_string_view(formatted_1) == to_string_view(formatted_2));
 }

 class custom_test_flag : public spdlog::custom_flag_formatter
@@ -345,12 +330,18 @@ public:
        : some_txt{std::move(txt)}
    {}

-    void format(const spdlog::details::log_msg &, const std::tm &, spdlog::memory_buf_t &dest) override
+    void format(const spdlog::details::log_msg &, const std::tm &tm, spdlog::memory_buf_t &dest) override
    {
        if (some_txt == "throw_me")
        {
            throw spdlog::spdlog_ex("custom_flag_exception_test");
        }
+        else if (some_txt == "time")
+        {
+            auto formatted = spdlog::fmt_lib::format("{:d}:{:02d}{:s}", tm.tm_hour % 12, tm.tm_min, tm.tm_hour / 12 ? "PM" : "AM");
+            dest.append(formatted.data(), formatted.data() + formatted.size());
+            return;
+        }
        some_txt = std::string(padinfo_.width_, ' ') + some_txt;
        dest.append(some_txt.data(), some_txt.data() + some_txt.size());
    }
@@ -382,13 +373,8 @@ TEST_CASE("clone-custom_formatter", "[pattern_formatter]")

    auto expected = spdlog::fmt_lib::format("[logger-name] [custom_output] some message{}", spdlog::details::os::default_eol);

-#ifdef SPDLOG_USE_STD_FORMAT
-    REQUIRE(formatted_1 == expected);
-    REQUIRE(formatted_2 == expected);
-#else
-    REQUIRE(fmt::to_string(formatted_1) == expected);
-    REQUIRE(fmt::to_string(formatted_2) == expected);
-#endif
+    REQUIRE(to_string_view(formatted_1) == expected);
+    REQUIRE(to_string_view(formatted_2) == expected);
 }

 //
@@ -410,11 +396,7 @@ TEST_CASE("short filename formatter-1", "[pattern_formatter]")
    spdlog::details::log_msg msg(source_loc, "logger-name", spdlog::level::info, "Hello");
    formatter.format(msg, formatted);

-#ifdef SPDLOG_USE_STD_FORMAT
-    REQUIRE(formatted == "myfile.cpp");
-#else
-    REQUIRE(fmt::to_string(formatted) == "myfile.cpp");
-#endif
+    REQUIRE(to_string_view(formatted) == "myfile.cpp");
 }

 TEST_CASE("short filename formatter-2", "[pattern_formatter]")
@@ -426,11 +408,7 @@ TEST_CASE("short filename formatter-2", "[pattern_formatter]")
    spdlog::details::log_msg msg(source_loc, "logger-name", spdlog::level::info, "Hello");
    formatter.format(msg, formatted);

-#ifdef SPDLOG_USE_STD_FORMAT
-    REQUIRE(formatted == "myfile.cpp:123");
-#else
-    REQUIRE(fmt::to_string(formatted) == "myfile.cpp:123");
-#endif
+    REQUIRE(to_string_view(formatted) == "myfile.cpp:123");
 }

 TEST_CASE("short filename formatter-3", "[pattern_formatter]")
@@ -442,11 +420,7 @@ TEST_CASE("short filename formatter-3", "[pattern_formatter]")
    spdlog::details::log_msg msg(source_loc, "logger-name", spdlog::level::info, "Hello");
    formatter.format(msg, formatted);

-#ifdef SPDLOG_USE_STD_FORMAT
-    REQUIRE(formatted == " Hello");
-#else
-    REQUIRE(fmt::to_string(formatted) == " Hello");
-#endif
+    REQUIRE(to_string_view(formatted) == " Hello");
 }

 TEST_CASE("full filename formatter", "[pattern_formatter]")
@@ -458,11 +432,7 @@ TEST_CASE("full filename formatter", "[pattern_formatter]")
    spdlog::details::log_msg msg(source_loc, "logger-name", spdlog::level::info, "Hello");
    formatter.format(msg, formatted);

-#ifdef SPDLOG_USE_STD_FORMAT
-    REQUIRE(formatted == test_path);
-#else
-    REQUIRE(fmt::to_string(formatted) == test_path);
-#endif
+    REQUIRE(to_string_view(formatted) == test_path);
 }

 TEST_CASE("custom flags", "[pattern_formatter]")
@@ -476,11 +446,7 @@ TEST_CASE("custom flags", "[pattern_formatter]")
    formatter->format(msg, formatted);
    auto expected = spdlog::fmt_lib::format("[logger-name] [custom1] [custom2] some message{}", spdlog::details::os::default_eol);

-#ifdef SPDLOG_USE_STD_FORMAT
-    REQUIRE(formatted == expected);
-#else
-    REQUIRE(fmt::to_string(formatted) == expected);
-#endif
+    REQUIRE(to_string_view(formatted) == expected);
 }

 TEST_CASE("custom flags-padding", "[pattern_formatter]")
@@ -494,11 +460,7 @@ TEST_CASE("custom flags-padding", "[pattern_formatter]")
    formatter->format(msg, formatted);
    auto expected = spdlog::fmt_lib::format("[logger-name] [custom1] [     custom2] some message{}", spdlog::details::os::default_eol);

-#ifdef SPDLOG_USE_STD_FORMAT
-    REQUIRE(formatted == expected);
-#else
-    REQUIRE(fmt::to_string(formatted) == expected);
-#endif
+    REQUIRE(to_string_view(formatted) == expected);
 }

 TEST_CASE("custom flags-exception", "[pattern_formatter]")
@@ -510,3 +472,30 @@ TEST_CASE("custom flags-exception", "[pattern_formatter]")
    spdlog::details::log_msg msg(spdlog::source_loc{}, "logger-name", spdlog::level::info, "some message");
    CHECK_THROWS_AS(formatter->format(msg, formatted), spdlog::spdlog_ex);
 }
+
+TEST_CASE("override need_localtime", "[pattern_formatter]")
+{
+    auto formatter = std::make_shared<spdlog::pattern_formatter>(spdlog::pattern_time_type::local, "\n");
+    formatter->add_flag<custom_test_flag>('t', "time").set_pattern("%t> %v");
+
+    {
+        memory_buf_t formatted;
+        spdlog::details::log_msg msg(spdlog::source_loc{}, "logger-name", spdlog::level::info, "some message");
+        formatter->format(msg, formatted);
+        REQUIRE(to_string_view(formatted) == "0:00AM> some message\n");
+    }
+
+    {
+        formatter->need_localtime();
+
+        auto now_tm = spdlog::details::os::localtime();
+        std::stringstream oss;
+        oss << (now_tm.tm_hour % 12) << ":" << std::setfill('0') << std::setw(2) << now_tm.tm_min << (now_tm.tm_hour / 12 ? "PM" : "AM")
+            << "> some message\n";
+
+        memory_buf_t formatted;
+        spdlog::details::log_msg msg(spdlog::source_loc{}, "logger-name", spdlog::level::info, "some message");
+        formatter->format(msg, formatted);
+        REQUIRE(to_string_view(formatted) == oss.str());
+    }
+}
--- a/tests/test_stopwatch.cpp
+++ b/tests/test_stopwatch.cpp
@@ -5,31 +5,40 @@
 TEST_CASE("stopwatch1", "[stopwatch]")
 {
    using std::chrono::milliseconds;
+    using clock = std::chrono::steady_clock;
    milliseconds wait_ms(250);
    milliseconds tolerance_ms(250);
-
+    auto start = clock::now();
    spdlog::stopwatch sw;
    std::this_thread::sleep_for(wait_ms);
-    REQUIRE(sw.elapsed() >= wait_ms);
-    REQUIRE(sw.elapsed() <= wait_ms + tolerance_ms);
+    auto stop = clock::now();
+    auto diff_ms = std::chrono::duration_cast<milliseconds>(stop - start);
+    REQUIRE(sw.elapsed() >= diff_ms);
+    REQUIRE(sw.elapsed() <= diff_ms + tolerance_ms);
 }

 TEST_CASE("stopwatch2", "[stopwatch]")
 {
    using spdlog::sinks::test_sink_st;
+    using std::chrono::duration_cast;
+    using std::chrono::milliseconds;
+    using clock = std::chrono::steady_clock;

-    std::chrono::duration<double> wait_duration(0.250);
-    std::chrono::duration<double> tolerance_duration(0.250);
+    clock::duration wait_duration(milliseconds(250));
+    clock::duration tolerance_duration(milliseconds(250));

    auto test_sink = std::make_shared<test_sink_st>();

+    auto start = clock::now();
    spdlog::stopwatch sw;
    spdlog::logger logger("test-stopwatch", test_sink);
    logger.set_pattern("%v");
    std::this_thread::sleep_for(wait_duration);
+    auto stop = clock::now();
    logger.info("{}", sw);
    auto val = std::stod(test_sink->lines()[0]);
+    auto diff_duration = duration_cast<std::chrono::duration<double>>(stop - start);

-    REQUIRE(val >= wait_duration.count());
-    REQUIRE(val <= (wait_duration + tolerance_duration).count());
+    REQUIRE(val >= diff_duration.count());
+    REQUIRE(val <= (diff_duration + tolerance_duration).count());
 }
--- a/tests/utils.cpp
+++ b/tests/utils.cpp
@@ -1,7 +1,7 @@
 #include "includes.h"

 #ifdef _WIN32
-#    include <Windows.h>
+#    include <windows.h>
 #else
 #    include <sys/types.h>
 #    include <dirent.h>
Author	SHA1	Message	Date
Gabi Melman	ad0e89cbfb	Version 1.11.0	2022-11-02 23:13:08 +02:00
Gabi Melman	6a9d561671	Update ci.yml	2022-11-01 17:17:29 +02:00
Gabi Melman	545c301877	Update ci.yml	2022-11-01 17:13:35 +02:00
Gabi Melman	7aa00607ea	chrono.h: Remove warning suppression Not needed since fmt 9.x	2022-11-01 14:46:39 +02:00
gabime	bd5a81df70	Check IsDebuggerPresent in msvc_sink before doing work. Fix #2408	2022-11-01 00:52:39 +02:00
gabime	4accce5d7b	Try again fixing fmt::vformat_to when SPDLOG_WCHAR_TO_UTF8_SUPPORT is defined	2022-11-01 00:07:46 +02:00
gabime	4d7308f26d	Fixed msvc warning C4800 in win_eventlog_sink	2022-11-01 00:01:19 +02:00
gabime	678a79c0be	Fixed syntax error from prev commit	2022-10-31 23:51:48 +02:00
gabime	fbba6dff20	Fix #2431	2022-10-31 23:23:57 +02:00
gabime	fdb1f5926e	Fix fmt::vformat_to when SPDLOG_WCHAR_TO_UTF8_SUPPORT is defined	2022-10-31 22:56:29 +02:00
gabime	b59b4a2b45	Rvert suppressing msvc2017 warnings and fix ci instead	2022-10-31 22:52:01 +02:00
gabime	6c975fa13b	Replace fmt::detail::vformat_to(buf,..) with fmt::vformat_to(fmt::appender(buf)	2022-10-31 18:43:38 +02:00
gabime	c627c66560	Replace fmt::detail::vformat_to(buf,..) with fmt::vformat_to(fmt::appender(buf)	2022-10-31 18:26:07 +02:00
gabime	130ff0c8db	enable the ostream formatting for backward compatibility with fmt 8.x	2022-10-31 18:15:43 +02:00
gabime	31d6935b97	updated readme	2022-10-31 18:12:47 +02:00
gabime	14a29c03eb	suppress warning 4307 when including format-inline.h under msvc 2017	2022-10-31 17:47:12 +02:00
gabime	a7e2bf161e	Update user defined type example	2022-10-31 17:35:24 +02:00
gabime	070dd181df	clang format	2022-10-31 17:09:45 +02:00
gabime	7147da468f	Merge branch 'v1.x' of https://github.com/gabime/spdlog into v1.x	2022-10-31 17:04:20 +02:00
gabime	9125bda301	suppress "integral constant overflow" warning under msvc 2017	2022-10-31 17:03:53 +02:00
Gabi Melman	a4743370e2	Update appveyor.yml	2022-10-31 15:39:01 +02:00
Gabi Melman	867df8cf87	Update appveyor.yml Added fatal warnings option to appveyor	2022-10-31 15:10:51 +02:00
gabime	8a0b2231b1	Renamed bench name	2022-10-31 14:01:38 +02:00
gabime	3499dfeeb4	Bump bundled fmtlib to version 1.9.1	2022-10-31 13:47:47 +02:00
刘耘呈	3c0e036cc9	Use 'SPDLOG_FMT_RUNTIME' to fix compilation error throwed MSVC and fmt 9.1.x (#2517 ) * Use 'SPDLOG_FMT_RUNTIME' to fix compilation error throwed MSVC and fmt 9.1.x * Fix #2512	2022-10-20 02:11:16 +03:00
Gabi Melman	bced424855	Merge pull request #2519 from sandorzm/v1.x Mongo sink improvements	2022-10-19 22:37:29 +03:00
Sandor Magyar	5fba2867f5	Change mongocxx::exception handler to std::exception	2022-10-19 14:02:21 -04:00
Sandor Magyar	b5d361fc21	clang-format mongo_sink.h	2022-10-19 10:08:54 -04:00
Sandor Magyar	0674e79066	Improve arg passing and exceptions in mongo_sink	2022-10-19 09:53:33 -04:00
Sandor Magyar	5f67ef4d6f	Remove pointless try block in mongo_sink	2022-10-18 20:25:32 -04:00
Sandor Magyar	1bb1f05d73	Adjust MongoCXX instance handling in mongo_sink Changes suggested by @gabime on #2519	2022-10-18 20:13:17 -04:00
Gabi Melman	77429b2e2e	Merge pull request #2515 from puneetmatharu/v1.x Export targets file to build directory at configure time	2022-10-18 13:19:13 +03:00
Sandor Magyar	a3c47cc682	Don't force Mongo sink to own MongoCXX instance There can only be one instance in the whole program, so programs that use the Mongo sink and also separately use MongoCXX may have problems if the Mongo sink owns the instance. MongoCXX recommends that the main application manage its own instance so configuration parameters can be passed to the constructor: http://mongocxx.org/api/current/classmongocxx_1_1instance.html However, this commit is not a breaking change. If no instance has been created at construction time, the Mongo sink will still create and own the instance.	2022-10-17 17:32:08 -04:00
Sandor Magyar	0145223be1	Add numerical level to Mongo sink for easier queries Filtering to a certain log level or above, a useful operation, can now be done with an integer comparison as opposed to comparing to a list of strings in the database query.	2022-10-17 16:15:23 -04:00
Sandor Magyar	f3b61c70ba	Catch exception by reference to fix -Wcatch-value warning	2022-10-17 16:04:49 -04:00
Puneet Matharu	7768c6271c	Export targets to build directory so that it can be found at configure time.	2022-10-17 10:02:14 +01:00
Gabi Melman	d011332616	Merge pull request #2509 from kin4stat/v1.x Replace iterator difference with std::distance(revert #2030)	2022-10-15 00:41:16 +03:00
Daniil	93b9132b0a	Replace iterator difference with std::distance	2022-10-13 12:29:48 +03:00
Gabi Melman	936697e5b1	Merge pull request #2500 from offa/ghactions_ci Migrate to Github Actions CI	2022-10-03 18:52:35 +03:00
offa	cf6cdc5ba6	Replace Travis CI Badge with Github Actions	2022-10-03 16:04:40 +02:00
offa	ec81b321c2	Remove .travis.yml	2022-10-01 18:11:36 +02:00
offa	23fce5ffaa	Migrate to Github Actions CI	2022-10-01 18:11:36 +02:00
Gabi Melman	7fa59cf555	Merge pull request #2498 from offa/gcc12_workaround Workaround GCC 12 warning	2022-09-30 17:12:26 +03:00
offa	29b24f9e72	Use pragams instead of compile options	2022-09-30 13:20:15 +02:00
Gabi Melman	523a075f82	Merge pull request #2499 from offa/clang_cpp20_workaround Workaround deprecation warning on Clang with C++20	2022-09-30 00:07:28 +03:00
offa	06f9953fa8	Workaround deprecation warning on Clang with C++20	2022-09-29 20:14:53 +02:00
offa	b8fdc9bf5d	Workaround GCC 12 warning	2022-09-29 19:28:44 +02:00
Gabi Melman	7130676697	Merge pull request #2495 from panicgh/lowercase-windows-h Use lower-case "windows.h" for case-sensitive file systems	2022-09-26 14:20:29 +03:00
Nicolas Benes	5ca5fdff9f	Use lower-case "windows.h" for case-sensitive file systems The "windows.h" in MinGW-W64 is lower-case. When cross-compiling for Windows on Linux with a case-sensitive file system, the upper-case "Windows.h" file is not found and compilation fails. Always use lower-case "windows.h" to fix cross-compilation.	2022-09-26 12:42:01 +02:00
Gabi Melman	81de01c02c	Merge pull request #2475 from nigels-com/-fPIC cmake: set(CMAKE_POSITION_INDEPENDENT_CODE ON)	2022-09-08 01:09:42 +03:00
Gabi Melman	b60512731b	Merge pull request #2476 from nigels-com/SPDLOG_NO_SOURCE_LOC SPDLOG_NO_SOURCE_LOC support for omitting __FILE__, __LINE__ etc	2022-09-08 01:07:24 +03:00
Nigel Stewart	1eaf98cc10	SPDLOG_NO_SOURCE_LOC implementation refinement	2022-09-03 12:51:31 +10:00
Nigel Stewart	34f88d4382	cmake: SPDLOG_BUILD_PIC opt-in for CMAKE_POSITION_INDEPENDENT_CODE	2022-09-03 12:49:10 +10:00
Nigel Stewart	57e5814364	SPDLOG_NO_SOURCE_LOC support for omitting __FILE__, __LINE__ and SPDLOG_FUNCTION information	2022-09-02 12:18:06 +10:00
Nigel Stewart	de67ebdda1	cmake: set(CMAKE_POSITION_INDEPENDENT_CODE ON) for Linux static library purposes	2022-09-02 12:08:42 +10:00
Gabi Melman	f44fa31f51	Fix #2434	2022-08-17 17:47:22 +03:00
Gabi Melman	64e0724bd6	Merge pull request #2468 from LorenDB/patch-1 Add openSUSE installation	2022-08-12 20:27:02 +03:00
Loren Burkholder	afb1699e0a	Add openSUSE installation	2022-08-12 11:39:47 -04:00
Gabi Melman	b75edfafca	Merge pull request #2449 from Simon-Janos/Re-introduce-redundant-std-move-at-return-for-old-compilers Re-introduce std::move at return for old GCC (before version 5) inside an ifdef for e.g. CentOS 7	2022-07-27 10:10:54 +03:00
Simon-Janos	26f69ee9d2	Re-introduce redundant std::move at return for old GCC (before version 5) inside an ifdef for e.g. CentOS 7	2022-07-27 07:16:36 +02:00
Gabi Melman	61879237e9	Merge pull request #2445 from Hish15/Hish15/CorrectDoc	2022-07-25 21:42:31 +03:00
Hector PHARAM	fb3ddf749d	Removed doc "(shared not supported in windows yet)"	2022-07-25 15:23:07 +02:00
Gabi Melman	7d805c2231	Merge pull request #2443 from ibmibmibm/v1.x Explicitly casting level_enum to size_t.	2022-07-22 18:52:02 +03:00
Shen-Ta Hsieh	5f8877b665	Explicitly casting level_enum to size_t. See commit `2a4c34b878`	2022-07-21 20:24:01 +08:00
Gabi Melman	834840636c	Merge pull request #2439 from LucasChollet/duration Expend support for any std::chrono::duration in spdlog::flush_every	2022-07-17 22:07:06 +03:00
Lucas CHOLLET	dfe1009080	Expend support for any std::chrono::duration in `spdlog::flush_every` This allows things like: spdlog::flush_every(std::chrono::minutes(10)); spdlog::flush_every(std::chrono::milliseconds(100));	2022-07-17 20:28:39 +02:00
Gabi Melman	6c95f4c816	Fix #2419 by documenting the set_pattern behaviour	2022-07-01 10:53:05 +03:00
Gabi Melman	d7690d8e7e	Merge pull request #2415 from neheb/mingw test_stopwatch: fix on mingw	2022-06-27 01:51:11 +03:00
Rosen Penev	68f42a5b90	test_stopwatch: fix on mingw There are some timing shenanigans with GCC's chrono that make this unreliable. Add a start/stop and test for that to work around. Signed-off-by: Rosen Penev <rosenp@gmail.com>	2022-06-25 19:07:36 -07:00
Gabi Melman	ab7b325906	Update README.md	2022-06-24 20:08:47 +03:00
Gabi Melman	a26e174b36	Merge pull request #2402 from cookcocck/fix_cmake_spdlog_use_std_format Set c++20 when SPDLOG_USE_STD_FORMAT option is turned on	2022-06-19 02:24:01 +03:00
Gabi Melman	866fdaa6db	Merge pull request #2399 from bergen4/v1.x add overrun_counter reset function	2022-06-19 02:22:56 +03:00
Gabi Melman	03315853df	Merge pull request #2386 from panzhongxian/v1.x Romove the empty file if no log in first period in hourly logger	2022-06-19 02:22:28 +03:00
cookcocck	ca747c7572	Set c++20 when SPDLOG_USE_STD_FORMAT option is turned on	2022-06-14 11:12:49 +08:00
bergen	1f608a81e8	add overrun reset function	2022-06-09 19:45:40 +08:00
bergen	822f972842	update	2022-06-09 19:39:57 +08:00
Gabi Melman	298a200f69	Merge pull request #2396 from polesapart/v1.x Remove redundant std::move at return	2022-06-02 22:53:54 +03:00
Alexandre Pereira Nunes	beefee7929	Remove redundant std::move at return (triggers -Wredundant-move in Gcc, at least)	2022-06-02 13:18:00 -03:00
panzhongxian	1eafcfab70	Romove the empty file if no log in first period in hourly logger	2022-05-24 16:19:21 +08:00
Gabi Melman	9e8e52c048	Merge pull request #2385 from panzhongxian/v1.x Remove `try_lock` from null_mutex.	2022-05-20 12:09:26 +03:00
panzhongxian	1f0c2f9f36	Remove try_lock from null_mutex.	2022-05-20 16:20:19 +08:00
Gabi Melman	fc93ddbefe	Merge pull request #2384 from aengusjiang/v1.x fix error: cannot bind lvalue to right reference	2022-05-19 23:35:52 +03:00
Gabi Melman	ffd929c590	Merge pull request #2383 from alexshpilkin/fix-pkg-config Fix pkg-config generation with unconventional `CMAKE_INSTALL_*DIR`	2022-05-19 23:32:00 +03:00
Gabi Melman	d546201f12	Merge pull request #2381 from Esri/john4744/android_fmt_compile_time_check Add FMT_STRING to allow compilation with FMT_ENFORCE_COMPILE_STRING	2022-05-19 23:29:16 +03:00
John Armstrong	799802f93b	Add FMT_STRING to allow compilation with FMT_ENFORCE_COMPILE_STRING	2022-05-19 11:32:54 -07:00
Aengus.Jiang	3d7ee64661	fix error: cannot bind lvale to right reference	2022-05-19 22:50:04 +08:00
Alexander Shpilkin	876880fb3f	Reflect CMAKE_INSTALL_INCLUDEDIR in pkg-config	2022-05-19 17:49:16 +03:00
Alexander Shpilkin	afb69071d5	Allow absolute CMAKE_INSTALL_LIBDIR	2022-05-19 17:48:57 +03:00
Gabi Melman	0d8197cc9d	Update common.h Init file event handlers to nullptr	2022-05-13 23:06:11 +03:00
Gabi Melman	e36b69a0ec	Merge pull request #2376 from jengelh/master build: expand SOVERSION to not give false illusion of compatibility	2022-05-13 11:29:10 +03:00
Gabi Melman	0ef5228a77	Merge pull request #2372 from kslattery/v1.x C++14 build fixes for older gcc #2333	2022-05-13 11:01:19 +03:00
Gabi Melman	e05b8542a0	Merge pull request #2375 from kslattery/bugfix/default_file_event_handlers Add default file-event_handler callbacks. #2374	2022-05-13 10:58:55 +03:00
Jan Engelhardt	41efc971ad	build: expand SOVERSION to not give false illusion of compatibility Fixes #2369	2022-05-13 09:44:09 +02:00
Kevin Slattery	d89a1e66d8	Add default file-event_handler callbacks. #2374	2022-05-12 19:49:01 -05:00
Kevin Slattery	d3dee23e6c	Remove new macro, update example with correct way to specify fmt lib namespace when fmt_lib namespace alias cannot be used.	2022-05-12 18:55:08 -05:00
Kevin Slattery	5f5e70e96e	C++14 build fixes for older gcc #2333	2022-05-11 15:14:41 -05:00
gabime	128cbe5a06	clang-format	2022-05-08 13:01:45 +03:00
gabime	6d587f5181	Use fmt::detail::vformat_to(buf, ...) since it is ~20ns faster than fmt::vformat_to(std::back_inserter(buf),..)	2022-05-08 13:01:02 +03:00
Gabi Melman	9b4b373121	Merge pull request #2365 from conr2d/feature/need_localtime Allow overriding need_localtime for custom formatter	2022-05-07 21:53:32 +03:00
Jeeyong Um	aa7490d187	Set eol to the test for overriding need_localtime	2022-05-08 01:20:27 +08:00
Jeeyong Um	c03c925e29	Copy the value of need_localtime when cloning pattern_formatter	2022-05-08 01:16:31 +08:00
Jeeyong Um	38929f856d	Allow overriding need_localtime for custom formatter	2022-05-07 20:44:00 +08:00
Gabi Melman	bd0198de2d	Merge pull request #2364 from stkw0/v1.x fix clone async test	2022-05-07 14:18:28 +03:00
David Roman	ece96216c4	fix clone async test Fix #2363	2022-05-07 12:30:41 +02:00
Gabi Melman	a9347017db	Merge pull request #2358 from tiolan/topic/android_buffer_v1_x V1: Allow modifying the used Android buffer	2022-05-07 00:27:55 +03:00
Timo Lange	2eedf1fa28	remove usage of forward args	2022-05-06 17:06:35 +02:00
Timo Lange	0a875d7b2d	use __android_log_write or __android_log_buf_write based on template paramter	2022-05-06 08:55:41 +02:00
Gabi Melman	173d06578f	Fixed move in ringnuffer_sink	2022-04-27 08:35:50 +03:00
Gabi Melman	b299855ef2	Merge pull request #2346 from sylveon/v1.x Switch to vformat_to	2022-04-27 08:20:48 +03:00
Charles Milette	8338a48c5b	Remove fmt_helper::to_string	2022-04-26 23:27:55 -04:00
Charles Milette	cd4f6c1466	Replace fmt_helper::to_string by a macro	2022-04-26 23:25:35 -04:00
Charles Milette	37dd6bb159	Address PR review comments	2022-04-25 21:59:56 -04:00
Charles Milette	714cf12822	Add fmt_helper.h include to includes.h and os-inl.h	2022-04-22 23:28:28 -04:00
Charles Milette	ee00f2e07d	Remove fmt_helper.h include from logger.h	2022-04-22 22:52:56 -04:00
Charles Milette	c203b4df8e	Fix conversion from fmt::memory_buffer to fmt::string_view	2022-04-21 23:38:12 -04:00
Charles Milette	56adf64ccf	Actually fix bad #ifdef	2022-04-21 22:43:13 -04:00
Charles Milette	91019f4f46	Fix bad #ifdef	2022-04-21 22:36:04 -04:00
Charles Milette	3cf94968e7	Add missing include	2022-04-21 22:11:16 -04:00
Charles Milette	ebeb3707b1	Switch to vformat_to Drive-by: reduce the amount of occurences of #ifdef SPDLOG_USE_STD_FORMAT	2022-04-21 21:59:02 -04:00
Gabi Melman	b3ce5ed379	Remove comment	2022-04-21 15:24:37 +03:00
Gabi Melman	78fbc69c94	Merge pull request #2336 from aengusjiang/v1.x [issues/2332]clean code, clean up the warning	2022-04-21 15:17:14 +03:00
Gabi Melman	4ccbb5a71a	Merge pull request #2342 from espkk/v1.x Make file_event_handlers an aggregate	2022-04-15 12:22:35 +03:00
espkk	e6265c04ae	Make file_event_handlers an aggregate	2022-04-15 11:54:11 +03:00
Aengus.Jiang	184fae06d7	clean code, clean up the warning	2022-04-10 13:13:59 +08:00