2025-04-29 12:03:53 +00:00
75 changed files with 8409 additions and 9973 deletions
--- a/.clang-tidy
+++ b/.clang-tidy
@ -27,6 +27,7 @@ clang-analyzer-*,

 WarningsAsErrors: ''
 HeaderFilterRegex: '*spdlog/[^f].*'
+AnalyzeTemporaryDtors: false
 FormatStyle:     none

 CheckOptions:    
--- a/.github/workflows/linux.yml
+++ b/.github/workflows/linux.yml
@ -1,15 +1,9 @@
-name: linux
+name: ci

 on: [push, pull_request]

-permissions:
-  contents: read
-
 jobs:
-  # -----------------------------------------------------------------------
-  # Linux build matrix
-  # -----------------------------------------------------------------------
-  build:
+  build_linux:
    runs-on: ubuntu-latest
    defaults:
      run:
@ -22,18 +16,16 @@ jobs:
          - { 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: gcc, version: 12, build_type: Debug, cppstd: 20, asan: ON }
-          - { compiler: clang, version: 12, build_type: Debug, cppstd: 17 }
-          - { compiler: clang, version: 15, build_type: Release, cppstd: 20, tsan: ON }
+          - { 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 }} ${{ matrix.config.asan == 'ON' && 'ASAN' || '' }}${{ matrix.config.tsan == 'ON' && 'TSAN' || '' }})"
+    name: "${{ matrix.config.compiler}} ${{ matrix.config.version }} (C++${{ matrix.config.cppstd }}, ${{ matrix.config.build_type }})"
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@main
      - name: Setup
        run: |
-          apt-get update
-          apt-get install -y curl git pkg-config libsystemd-dev
+          apt-get update && apt-get install -y curl git pkg-config libsystemd-dev
          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
@ -41,8 +33,10 @@ jobs:
      - 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
@ -57,19 +51,15 @@ jobs:
            -DSPDLOG_BUILD_BENCH=OFF \
            -DSPDLOG_BUILD_TESTS=ON \
            -DSPDLOG_BUILD_TESTS_HO=OFF \
-            -DSPDLOG_SANITIZE_ADDRESS=${{ matrix.config.asan || 'OFF' }} \
-            -DSPDLOG_SANITIZE_THREAD=${{ matrix.config.tsan || 'OFF' }}
-          make -j 4
-          ctest -j 4 --output-on-failure
+            -DSPDLOG_SANITIZE_ADDRESS=${{ matrix.config.asan || 'ON' }}
+          make -j2
+          ctest -j2 --output-on-failure

-  # -----------------------------------------------------------------------
-  # OS X build matrix
-  # -----------------------------------------------------------------------
  build_osx:
    runs-on: macOS-latest
    name: "OS X Clang (C++11, Release)"
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@main
      - name: Build
        run: |
          mkdir -p build && cd build
@ -83,5 +73,6 @@ jobs:
            -DSPDLOG_BUILD_TESTS=ON \
            -DSPDLOG_BUILD_TESTS_HO=OFF \
            -DSPDLOG_SANITIZE_ADDRESS=OFF
-          make -j 4
-          ctest -j 4 --output-on-failure
+          make -j2
+          ctest -j2 --output-on-failure
+
--- a/.github/workflows/macos.yml
+++ b/.github/workflows/macos.yml
@ -1,38 +0,0 @@
-name: macos
-
-on: [push, pull_request]
-
-permissions:
-  contents: read
-
-jobs:
-  build:
-    runs-on: macOS-latest
-    name: "macOS Clang (C++11, Release)"
-    strategy:
-      fail-fast: true
-      matrix:
-        config:
-            - USE_STD_FORMAT: 'ON'
-              BUILD_EXAMPLE: 'OFF'
-            - USE_STD_FORMAT: 'OFF'
-              BUILD_EXAMPLE: 'ON'
-              
-    steps:
-      - uses: actions/checkout@v4
-      - name: Build
-        run: |
-          mkdir -p build && cd build
-          cmake .. \
-            -DCMAKE_BUILD_TYPE=Release \
-            -DCMAKE_CXX_STANDARD=11 \
-            -DSPDLOG_BUILD_EXAMPLE=${{ matrix.config.BUILD_EXAMPLE }} \
-            -DSPDLOG_BUILD_EXAMPLE_HO=${{ matrix.config.BUILD_EXAMPLE }} \
-            -DSPDLOG_BUILD_WARNINGS=ON \
-            -DSPDLOG_BUILD_BENCH=OFF \
-            -DSPDLOG_BUILD_TESTS=ON \
-            -DSPDLOG_BUILD_TESTS_HO=OFF \
-            -DSPDLOG_USE_STD_FORMAT=${{ matrix.config.USE_STD_FORMAT }} \
-            -DSPDLOG_SANITIZE_ADDRESS=OFF
-          make -j 4
-          ctest -j 4 --output-on-failure
--- a/.github/workflows/windows.yml
+++ b/.github/workflows/windows.yml
@ -1,148 +0,0 @@
-name: windows
-
-on: [push, pull_request]
-
-permissions:
-  contents: read
-
-jobs:
-  build:
-    runs-on: windows-latest
-    strategy:
-      fail-fast: true
-      matrix:
-        config:
-          - GENERATOR: "Visual Studio 17 2022"
-            BUILD_TYPE: Release
-            BUILD_SHARED: 'ON'
-            FATAL_ERRORS: 'ON'
-            WCHAR: 'OFF'
-            WCHAR_FILES: 'OFF'
-            BUILD_EXAMPLE: 'OFF'
-            USE_STD_FORMAT: 'ON'
-            CXX_STANDARD: 20
-          - GENERATOR: "Visual Studio 17 2022"
-            BUILD_TYPE: Release
-            BUILD_SHARED: 'ON'
-            FATAL_ERRORS: 'ON'
-            WCHAR: 'ON'
-            WCHAR_FILES: 'ON'
-            BUILD_EXAMPLE: 'OFF'
-            USE_STD_FORMAT: 'ON'
-            CXX_STANDARD: 20
-          - GENERATOR: "Visual Studio 17 2022"
-            BUILD_TYPE: Release
-            BUILD_SHARED: 'ON'
-            FATAL_ERRORS: 'ON'
-            WCHAR: 'OFF'
-            WCHAR_FILES: 'OFF'
-            BUILD_EXAMPLE: 'ON'
-            USE_STD_FORMAT: 'OFF'
-            CXX_STANDARD: 17
-
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: CMake ${{ matrix.config.GENERATOR }} CXX=${{matrix.config.CXX_STANDARD}} WCHAR=${{matrix.config.WCHAR_FILES}} STD_FORMAT=${{matrix.config.USE_STD_FORMAT}}
-        shell: pwsh
-        run: |
-          mkdir build
-          cd build
-          cmake -G "${{ matrix.config.GENERATOR }}"  -A x64 `
-            -D CMAKE_BUILD_TYPE=${{ matrix.config.BUILD_TYPE }} `
-            -D BUILD_SHARED_LIBS=${{ matrix.config.BUILD_SHARED }} `
-            -D SPDLOG_WCHAR_SUPPORT=${{ matrix.config.WCHAR }} `
-            -D SPDLOG_WCHAR_FILENAMES=${{ matrix.config.WCHAR_FILES }} `
-            -D SPDLOG_BUILD_EXAMPLE=${{ matrix.config.BUILD_EXAMPLE }} `
-            -D SPDLOG_BUILD_EXAMPLE_HO=${{ matrix.config.BUILD_EXAMPLE }} `
-            -D SPDLOG_BUILD_TESTS=ON `
-            -D SPDLOG_BUILD_TESTS_HO=OFF `
-            -D SPDLOG_BUILD_WARNINGS=${{ matrix.config.FATAL_ERRORS }} `
-            -D SPDLOG_USE_STD_FORMAT=${{ matrix.config.USE_STD_FORMAT }} `
-            -D CMAKE_CXX_STANDARD=${{ matrix.config.CXX_STANDARD }} ..
-
-      - name: Build
-        shell: pwsh
-        run: |
-          cd build
-          cmake --build  . --parallel --config ${{ matrix.config.BUILD_TYPE }}
-
-      - name: Run Tests
-        shell: pwsh
-        env:
-          PATH: ${{ env.PATH }};${{ github.workspace }}\build\_deps\catch2-build\src\${{ matrix.config.BUILD_TYPE }};${{ github.workspace }}\build\${{ matrix.config.BUILD_TYPE }}
-        run: |
-          build\tests\${{ matrix.config.BUILD_TYPE }}\spdlog-utests.exe
-
-  # -----------------------------------------------------------------------
-  # MSVC 2019 build matrix
-  # -----------------------------------------------------------------------
-  build_2019:
-    runs-on: windows-2019
-    strategy:
-      fail-fast: true
-      matrix:
-        config:
-          - GENERATOR: "Visual Studio 16 2019"
-            BUILD_TYPE: Release
-            BUILD_SHARED: 'ON'
-            FATAL_ERRORS: 'ON'
-            WCHAR: 'OFF'
-            WCHAR_FILES: 'OFF'
-            BUILD_EXAMPLE: 'ON'
-            USE_STD_FORMAT: 'OFF'
-            CXX_STANDARD: 17
-          - GENERATOR: "Visual Studio 16 2019"
-            BUILD_TYPE: Release
-            BUILD_SHARED: 'ON'
-            FATAL_ERRORS: 'ON'
-            WCHAR: 'OFF'
-            WCHAR_FILES: 'OFF'
-            BUILD_EXAMPLE: 'ON'
-            USE_STD_FORMAT: 'OFF'
-            CXX_STANDARD: 14
-          - GENERATOR: "Visual Studio 16 2019"
-            BUILD_TYPE: Release
-            BUILD_SHARED: 'ON'
-            FATAL_ERRORS: 'ON'
-            WCHAR: 'OFF'
-            WCHAR_FILES: 'OFF'
-            BUILD_EXAMPLE: 'ON'
-            USE_STD_FORMAT: 'OFF'
-            CXX_STANDARD: 11
-
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: CMake ${{ matrix.config.GENERATOR }} CXX=${{matrix.config.CXX_STANDARD}} WCHAR=${{matrix.config.WCHAR_FILES}} STD_FORMAT=${{matrix.config.USE_STD_FORMAT}}
-        shell: pwsh
-        run: |
-          mkdir build
-          cd build
-          cmake -G "${{ matrix.config.GENERATOR }}"  -A x64 `
-            -D CMAKE_BUILD_TYPE=${{ matrix.config.BUILD_TYPE }} `
-            -D BUILD_SHARED_LIBS=${{ matrix.config.BUILD_SHARED }} `
-            -D SPDLOG_WCHAR_SUPPORT=${{ matrix.config.WCHAR }} `
-            -D SPDLOG_WCHAR_FILENAMES=${{ matrix.config.WCHAR_FILES }} `
-            -D SPDLOG_BUILD_EXAMPLE=${{ matrix.config.BUILD_EXAMPLE }} `
-            -D SPDLOG_BUILD_EXAMPLE_HO=${{ matrix.config.BUILD_EXAMPLE }} `
-            -D SPDLOG_BUILD_TESTS=ON `
-            -D SPDLOG_BUILD_TESTS_HO=OFF `
-            -D SPDLOG_BUILD_WARNINGS=${{ matrix.config.FATAL_ERRORS }} `
-            -D SPDLOG_USE_STD_FORMAT=${{ matrix.config.USE_STD_FORMAT }} `
-            -D CMAKE_CXX_STANDARD=${{ matrix.config.CXX_STANDARD }} ..
-
-      - name: Build
-        shell: pwsh
-        run: |
-          cd build
-          cmake --build  . --parallel --config ${{ matrix.config.BUILD_TYPE }}
-
-      - name: Run Tests
-        shell: pwsh
-        env:
-          PATH: ${{ env.PATH }};${{ github.workspace }}\build\_deps\catch2-build\src\${{ matrix.config.BUILD_TYPE }};${{ github.workspace }}\build\${{ matrix.config.BUILD_TYPE }}
-        run: |
-          build\tests\${{ matrix.config.BUILD_TYPE }}\spdlog-utests.exe
--- a/.gitignore
+++ b/.gitignore
@ -93,6 +93,3 @@ cmake-build-*/
 # macos
 *.DS_store
 *.xcodeproj/
-/.vs
-/out/build
-/CMakeSettings.json
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -1,6 +1,6 @@
 # Copyright(c) 2019 spdlog authors Distributed under the MIT License (http://opensource.org/licenses/MIT)

-cmake_minimum_required(VERSION 3.10...3.21)
+cmake_minimum_required(VERSION 3.11)

 # ---------------------------------------------------------------------------------------
 # Start spdlog project
@ -18,39 +18,43 @@ include(GNUInstallDirs)
 # ---------------------------------------------------------------------------------------
 # Set default build to release
 # ---------------------------------------------------------------------------------------
-if (NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
    set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose Release or Debug" FORCE)
-endif ()
+endif()

 # ---------------------------------------------------------------------------------------
 # Compiler config
 # ---------------------------------------------------------------------------------------
-if (SPDLOG_USE_STD_FORMAT)
+if(SPDLOG_USE_STD_FORMAT)
    set(CMAKE_CXX_STANDARD 20)
    set(CMAKE_CXX_STANDARD_REQUIRED ON)
-elseif (NOT CMAKE_CXX_STANDARD)
+elseif(NOT CMAKE_CXX_STANDARD)
    set(CMAKE_CXX_STANDARD 11)
    set(CMAKE_CXX_STANDARD_REQUIRED ON)
-endif ()
+endif()

+# make sure __cplusplus is defined when using msvc and enable parallel build
+if(MSVC)
+    string(APPEND CMAKE_CXX_FLAGS " /Zc:__cplusplus /MP")
+endif()

 set(CMAKE_CXX_EXTENSIONS OFF)

-if (CMAKE_SYSTEM_NAME MATCHES "CYGWIN" OR CMAKE_SYSTEM_NAME MATCHES "MSYS" OR CMAKE_SYSTEM_NAME MATCHES "MINGW")
+if(CMAKE_SYSTEM_NAME MATCHES "CYGWIN" OR CMAKE_SYSTEM_NAME MATCHES "MSYS")
    set(CMAKE_CXX_EXTENSIONS ON)
-endif ()
+endif()

 # ---------------------------------------------------------------------------------------
 # Set SPDLOG_MASTER_PROJECT to ON if we are building spdlog
 # ---------------------------------------------------------------------------------------
 # Check if spdlog is being used directly or via add_subdirectory, but allow overriding
-if (NOT DEFINED SPDLOG_MASTER_PROJECT)
-    if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
+if(NOT DEFINED SPDLOG_MASTER_PROJECT)
+    if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
        set(SPDLOG_MASTER_PROJECT ON)
-    else ()
+    else()
        set(SPDLOG_MASTER_PROJECT OFF)
-    endif ()
-endif ()
+    endif()
+endif()

 option(SPDLOG_BUILD_ALL "Build all artifacts" OFF)

@ -76,10 +80,6 @@ option(SPDLOG_BUILD_BENCH "Build benchmarks (Requires https://github.com/google/

 # sanitizer options
 option(SPDLOG_SANITIZE_ADDRESS "Enable address sanitizer in tests" OFF)
-option(SPDLOG_SANITIZE_THREAD "Enable thread sanitizer in tests" OFF)
-if (SPDLOG_SANITIZE_ADDRESS AND SPDLOG_SANITIZE_THREAD)
-    message(FATAL_ERROR "SPDLOG_SANITIZE_ADDRESS and SPDLOG_SANITIZE_THREAD are mutually exclusive")
-endif ()

 # warning options
 option(SPDLOG_BUILD_WARNINGS "Enable compiler warnings" OFF)
@ -92,38 +92,32 @@ option(SPDLOG_FMT_EXTERNAL "Use external fmt library instead of bundled" OFF)
 option(SPDLOG_FMT_EXTERNAL_HO "Use external fmt header-only library instead of bundled" OFF)
 option(SPDLOG_NO_EXCEPTIONS "Compile with -fno-exceptions. Call abort() on any spdlog exceptions" OFF)

-if (SPDLOG_FMT_EXTERNAL AND SPDLOG_FMT_EXTERNAL_HO)
+if(SPDLOG_FMT_EXTERNAL AND SPDLOG_FMT_EXTERNAL_HO)
    message(FATAL_ERROR "SPDLOG_FMT_EXTERNAL and SPDLOG_FMT_EXTERNAL_HO are mutually exclusive")
-endif ()
+endif()

-if (SPDLOG_USE_STD_FORMAT AND SPDLOG_FMT_EXTERNAL_HO)
+if(SPDLOG_USE_STD_FORMAT AND SPDLOG_FMT_EXTERNAL_HO)
    message(FATAL_ERROR "SPDLOG_USE_STD_FORMAT and SPDLOG_FMT_EXTERNAL_HO are mutually exclusive")
-endif ()
+endif()

-if (SPDLOG_USE_STD_FORMAT AND SPDLOG_FMT_EXTERNAL)
+if(SPDLOG_USE_STD_FORMAT AND SPDLOG_FMT_EXTERNAL)
    message(FATAL_ERROR "SPDLOG_USE_STD_FORMAT and SPDLOG_FMT_EXTERNAL are mutually exclusive")
-endif ()
+endif()

 # misc tweakme options
-if (WIN32)
+if(WIN32)
    option(SPDLOG_WCHAR_SUPPORT "Support wchar api" OFF)
    option(SPDLOG_WCHAR_FILENAMES "Support wchar filenames" OFF)
-    option(SPDLOG_WCHAR_CONSOLE "Support wchar output to console" OFF)
-else ()
+else()
    set(SPDLOG_WCHAR_SUPPORT OFF CACHE BOOL "non supported option" FORCE)
    set(SPDLOG_WCHAR_FILENAMES OFF CACHE BOOL "non supported option" FORCE)
-    set(SPDLOG_WCHAR_CONSOLE OFF CACHE BOOL "non supported option" FORCE)
-endif ()
+endif()

-if (MSVC)
-    option(SPDLOG_MSVC_UTF8 "Enable/disable msvc /utf-8 flag required by fmt lib" ON)
-endif ()
-
-if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
+if(${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
    option(SPDLOG_CLOCK_COARSE "Use CLOCK_REALTIME_COARSE instead of the regular clock," OFF)
-else ()
+else()
    set(SPDLOG_CLOCK_COARSE OFF CACHE BOOL "non supported option" FORCE)
-endif ()
+endif()

 option(SPDLOG_PREVENT_CHILD_FD "Prevent from child processes to inherit log file descriptors" OFF)
 option(SPDLOG_NO_THREAD_ID "prevent spdlog from querying the thread id on each log call if thread id is not needed" OFF)
@ -133,20 +127,19 @@ option(
    "prevent spdlog from using of std::atomic log levels (use only if your code never modifies log levels concurrently"
    OFF)
 option(SPDLOG_DISABLE_DEFAULT_LOGGER "Disable default logger creation" OFF)
-option(SPDLOG_FWRITE_UNLOCKED "Use the unlocked variant of fwrite. Leave this on unless your libc doesn't have it" ON)

 # clang-tidy
 option(SPDLOG_TIDY "run clang-tidy" OFF)

-if (SPDLOG_TIDY)
+if(SPDLOG_TIDY)
    set(CMAKE_CXX_CLANG_TIDY "clang-tidy")
    set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
    message(STATUS "Enabled clang-tidy")
-endif ()
+endif()

-if (SPDLOG_BUILD_PIC)
+if(SPDLOG_BUILD_PIC)
    set(CMAKE_POSITION_INDEPENDENT_CODE ON)
-endif ()
+endif()

 find_package(Threads REQUIRED)
 message(STATUS "Build type: " ${CMAKE_BUILD_TYPE})
@ -155,34 +148,34 @@ message(STATUS "Build type: " ${CMAKE_BUILD_TYPE})
 # ---------------------------------------------------------------------------------------
 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)
+if(NOT SPDLOG_USE_STD_FORMAT AND NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)
    list(APPEND SPDLOG_SRCS src/bundled_fmtlib_format.cpp)
-endif ()
+endif()

-if (SPDLOG_BUILD_SHARED OR BUILD_SHARED_LIBS)
-    if (WIN32)
+if(SPDLOG_BUILD_SHARED OR BUILD_SHARED_LIBS)
+    if(WIN32)
        configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/version.rc.in ${CMAKE_CURRENT_BINARY_DIR}/version.rc @ONLY)
        list(APPEND SPDLOG_SRCS ${CMAKE_CURRENT_BINARY_DIR}/version.rc)
-    endif ()
+    endif()
    add_library(spdlog SHARED ${SPDLOG_SRCS} ${SPDLOG_ALL_HEADERS})
    target_compile_definitions(spdlog PUBLIC SPDLOG_SHARED_LIB)
-    if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+    if(MSVC)
        target_compile_options(spdlog PUBLIC $<$<AND:$<CXX_COMPILER_ID:MSVC>,$<NOT:$<COMPILE_LANGUAGE:CUDA>>>:/wd4251
                                             /wd4275>)
-    endif ()
-    if (NOT SPDLOG_USE_STD_FORMAT AND NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)
-        target_compile_definitions(spdlog PRIVATE FMT_LIB_EXPORT PUBLIC FMT_SHARED)
-    endif ()
-else ()
+    endif()
+    if(NOT SPDLOG_USE_STD_FORMAT AND NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)
+        target_compile_definitions(spdlog PRIVATE FMT_EXPORT PUBLIC FMT_SHARED)
+    endif()
+else()
    add_library(spdlog STATIC ${SPDLOG_SRCS} ${SPDLOG_ALL_HEADERS})
-endif ()
+endif()

 add_library(spdlog::spdlog ALIAS spdlog)

 set(SPDLOG_INCLUDES_LEVEL "")
-if (SPDLOG_SYSTEM_INCLUDES)
+if(SPDLOG_SYSTEM_INCLUDES)
    set(SPDLOG_INCLUDES_LEVEL "SYSTEM")
-endif ()
+endif()

 target_compile_definitions(spdlog PUBLIC SPDLOG_COMPILED_LIB)
 target_include_directories(spdlog ${SPDLOG_INCLUDES_LEVEL} PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>"
@ -194,17 +187,10 @@ 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)
+if(COMMAND target_precompile_headers AND SPDLOG_ENABLE_PCH)
    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/pch.h.in ${PROJECT_BINARY_DIR}/spdlog_pch.h @ONLY)
    target_precompile_headers(spdlog PRIVATE ${PROJECT_BINARY_DIR}/spdlog_pch.h)
-endif ()
-
-# sanitizer support
-if (SPDLOG_SANITIZE_ADDRESS)
-    spdlog_enable_addr_sanitizer(spdlog)
-elseif (SPDLOG_SANITIZE_THREAD)
-    spdlog_enable_thread_sanitizer(spdlog)
-endif ()
+endif()

 # ---------------------------------------------------------------------------------------
 # Header only version
@ -220,58 +206,40 @@ target_link_libraries(spdlog_header_only INTERFACE Threads::Threads)
 # ---------------------------------------------------------------------------------------
 # Use fmt package if using external fmt
 # ---------------------------------------------------------------------------------------
-if (SPDLOG_FMT_EXTERNAL OR SPDLOG_FMT_EXTERNAL_HO)
-    if (NOT TARGET fmt::fmt)
+if(SPDLOG_FMT_EXTERNAL OR SPDLOG_FMT_EXTERNAL_HO)
+    if(NOT TARGET fmt::fmt)
        find_package(fmt CONFIG REQUIRED)
-    endif ()
+    endif()
    target_compile_definitions(spdlog PUBLIC SPDLOG_FMT_EXTERNAL)
    target_compile_definitions(spdlog_header_only INTERFACE SPDLOG_FMT_EXTERNAL)

-    # use external fmt-header-only
-    if (SPDLOG_FMT_EXTERNAL_HO)
+    # use external fmt-header-nly
+    if(SPDLOG_FMT_EXTERNAL_HO)
        target_link_libraries(spdlog PUBLIC fmt::fmt-header-only)
        target_link_libraries(spdlog_header_only INTERFACE fmt::fmt-header-only)
-    else () # use external compile fmt
+    else() # use external compile fmt
        target_link_libraries(spdlog PUBLIC fmt::fmt)
        target_link_libraries(spdlog_header_only INTERFACE fmt::fmt)
-    endif ()
+    endif()

    set(PKG_CONFIG_REQUIRES fmt) # add dependency to pkg-config
-endif ()
-
-# ---------------------------------------------------------------------------------------
-# Check if fwrite_unlocked/_fwrite_nolock is available
-# ---------------------------------------------------------------------------------------
-if (SPDLOG_FWRITE_UNLOCKED)
-    include(CheckSymbolExists)
-    if (WIN32)
-        check_symbol_exists(_fwrite_nolock "stdio.h" HAVE_FWRITE_UNLOCKED)
-    else ()
-        check_symbol_exists(fwrite_unlocked "stdio.h" HAVE_FWRITE_UNLOCKED)
-    endif ()
-    if (HAVE_FWRITE_UNLOCKED)
-        target_compile_definitions(spdlog PRIVATE SPDLOG_FWRITE_UNLOCKED)
-        target_compile_definitions(spdlog_header_only INTERFACE SPDLOG_FWRITE_UNLOCKED)
-    endif ()
-endif ()
+endif()

 # ---------------------------------------------------------------------------------------
 # Add required libraries for Android CMake build
 # ---------------------------------------------------------------------------------------
-if (ANDROID)
+if(ANDROID)
    target_link_libraries(spdlog PUBLIC log)
    target_link_libraries(spdlog_header_only INTERFACE log)
-endif ()
+endif()

 # ---------------------------------------------------------------------------------------
 # Misc definitions according to tweak options
 # ---------------------------------------------------------------------------------------
 set(SPDLOG_WCHAR_TO_UTF8_SUPPORT ${SPDLOG_WCHAR_SUPPORT})
-set(SPDLOG_UTF8_TO_WCHAR_CONSOLE ${SPDLOG_WCHAR_CONSOLE})
-foreach (
+foreach(
    SPDLOG_OPTION
    SPDLOG_WCHAR_TO_UTF8_SUPPORT
-        SPDLOG_UTF8_TO_WCHAR_CONSOLE
    SPDLOG_WCHAR_FILENAMES
    SPDLOG_NO_EXCEPTIONS
    SPDLOG_CLOCK_COARSE
@ -281,65 +249,52 @@ foreach (
    SPDLOG_NO_ATOMIC_LEVELS
    SPDLOG_DISABLE_DEFAULT_LOGGER
    SPDLOG_USE_STD_FORMAT)
-    if (${SPDLOG_OPTION})
+    if(${SPDLOG_OPTION})
        target_compile_definitions(spdlog PUBLIC ${SPDLOG_OPTION})
        target_compile_definitions(spdlog_header_only INTERFACE ${SPDLOG_OPTION})
-    endif ()
-endforeach ()
-
-if (MSVC)
-    target_compile_options(spdlog PRIVATE "/Zc:__cplusplus")
-    target_compile_options(spdlog_header_only INTERFACE "/Zc:__cplusplus")
-    if (SPDLOG_MSVC_UTF8)
-        # fmtlib requires the /utf-8 flag when building with msvc.
-        # see https://github.com/fmtlib/fmt/pull/4159 on the purpose of the additional
-        # "$<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CXX_COMPILER_ID:MSVC>>"
-        target_compile_options(spdlog PUBLIC $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CXX_COMPILER_ID:MSVC>>:/utf-8>)
-        target_compile_options(spdlog_header_only INTERFACE $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CXX_COMPILER_ID:MSVC>>:/utf-8>)
-    endif ()
-endif ()
+    endif()
+endforeach()

 # ---------------------------------------------------------------------------------------
 # If exceptions are disabled, disable them in the bundled fmt as well
 # ---------------------------------------------------------------------------------------
-if (SPDLOG_NO_EXCEPTIONS)
-    if (NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)
-        target_compile_definitions(spdlog PUBLIC FMT_USE_EXCEPTIONS=0)
-    endif ()
-    if (NOT MSVC)
+if(SPDLOG_NO_EXCEPTIONS)
+    if(NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)
+        target_compile_definitions(spdlog PUBLIC FMT_EXCEPTIONS=0)
+    endif()
+    if(NOT MSVC)
        target_compile_options(spdlog PRIVATE -fno-exceptions)
-    else ()
+    else()
        target_compile_options(spdlog PRIVATE /EHs-c-)
-        target_compile_definitions(spdlog PRIVATE _HAS_EXCEPTIONS=0)
-    endif ()
-endif ()
+    endif()
+endif()
 # ---------------------------------------------------------------------------------------
 # Build binaries
 # ---------------------------------------------------------------------------------------
-if (SPDLOG_BUILD_EXAMPLE OR SPDLOG_BUILD_EXAMPLE_HO OR SPDLOG_BUILD_ALL)
+if(SPDLOG_BUILD_EXAMPLE OR SPDLOG_BUILD_EXAMPLE_HO OR SPDLOG_BUILD_ALL)
    message(STATUS "Generating example(s)")
    add_subdirectory(example)
    spdlog_enable_warnings(example)
-    if (SPDLOG_BUILD_EXAMPLE_HO)
+    if(SPDLOG_BUILD_EXAMPLE_HO)
        spdlog_enable_warnings(example_header_only)
-    endif ()
-endif ()
+    endif()
+endif()

-if (SPDLOG_BUILD_TESTS OR SPDLOG_BUILD_TESTS_HO OR SPDLOG_BUILD_ALL)
+if(SPDLOG_BUILD_TESTS OR SPDLOG_BUILD_TESTS_HO OR SPDLOG_BUILD_ALL)
    message(STATUS "Generating tests")
    enable_testing()
    add_subdirectory(tests)
-endif ()
+endif()

-if (SPDLOG_BUILD_BENCH OR SPDLOG_BUILD_ALL)
+if(SPDLOG_BUILD_BENCH OR SPDLOG_BUILD_ALL)
    message(STATUS "Generating benchmarks")
    add_subdirectory(bench)
-endif ()
+endif()

 # ---------------------------------------------------------------------------------------
 # Install
 # ---------------------------------------------------------------------------------------
-if (SPDLOG_INSTALL)
+if(SPDLOG_INSTALL)
    message(STATUS "Generating install")
    set(project_config_in "${CMAKE_CURRENT_LIST_DIR}/cmake/spdlogConfig.cmake.in")
    set(project_config_out "${CMAKE_CURRENT_BINARY_DIR}/spdlogConfig.cmake")
@ -360,24 +315,24 @@ if (SPDLOG_INSTALL)
        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})

-    if (NOT SPDLOG_USE_STD_FORMAT AND NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)
+    if(NOT SPDLOG_USE_STD_FORMAT AND NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)
        install(DIRECTORY include/${PROJECT_NAME}/fmt/bundled/
                DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME}/fmt/bundled/")
-    endif ()
+    endif()

    # ---------------------------------------------------------------------------------------
    # Install pkg-config file
    # ---------------------------------------------------------------------------------------
-    if (IS_ABSOLUTE "${CMAKE_INSTALL_INCLUDEDIR}")
+    if(IS_ABSOLUTE "${CMAKE_INSTALL_INCLUDEDIR}")
        set(PKG_CONFIG_INCLUDEDIR "${CMAKE_INSTALL_INCLUDEDIR}")
-    else ()
+    else()
        set(PKG_CONFIG_INCLUDEDIR "\${prefix}/${CMAKE_INSTALL_INCLUDEDIR}")
-    endif ()
-    if (IS_ABSOLUTE "${CMAKE_INSTALL_LIBDIR}")
+    endif()
+    if(IS_ABSOLUTE "${CMAKE_INSTALL_LIBDIR}")
        set(PKG_CONFIG_LIBDIR "${CMAKE_INSTALL_LIBDIR}")
-    else ()
+    else()
        set(PKG_CONFIG_LIBDIR "\${exec_prefix}/${CMAKE_INSTALL_LIBDIR}")
-    endif ()
+    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}")
@ -401,4 +356,4 @@ if (SPDLOG_INSTALL)
    # Support creation of installable packages
    # ---------------------------------------------------------------------------------------
    include(cmake/spdlogCPack.cmake)
-endif ()
+endif()
--- a/17
+++ b/17
@ -1,27 +1,24 @@
-Header Only Version
+Header only version:
 ==================================================================
 Just copy the files to your build tree and use a C++11 compiler.
 Or use CMake:
-``` 
  add_executable(example_header_only example.cpp)
  target_link_libraries(example_header_only spdlog::spdlog_header_only)
-```

-Compiled Library Version
+
+Compiled library version:
 ==================================================================
 CMake:
-```  
  add_executable(example example.cpp)
  target_link_libraries(example spdlog::spdlog)
-```

 Or copy files src/*.cpp to your build tree and pass the -DSPDLOG_COMPILED_LIB to the compiler.

-Important Information for Compilation:
-==================================================================
-* If you encounter compilation errors with gcc 4.8.x, please note that gcc 4.8.x does not fully support C++11. In such cases, consider upgrading your compiler or using a different version that fully supports C++11 standards
-
 Tested on:
 gcc 4.8.1 and above
 clang 3.5
 Visual Studio 2013
+
+
+
+
--- a/README.md
+++ b/README.md
@ -1,25 +1,18 @@
 # spdlog

- 
-[![ci](https://github.com/gabime/spdlog/actions/workflows/linux.yml/badge.svg)](https://github.com/gabime/spdlog/actions/workflows/linux.yml)&nbsp;
-[![ci](https://github.com/gabime/spdlog/actions/workflows/windows.yml/badge.svg)](https://github.com/gabime/spdlog/actions/workflows/windows.yml)&nbsp;
-[![ci](https://github.com/gabime/spdlog/actions/workflows/macos.yml/badge.svg)](https://github.com/gabime/spdlog/actions/workflows/macos.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)
-
-Fast C++ logging library
-
+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](include/spdlog) to your build tree and use a C++11 compiler.
+Copy the include [folder](https://github.com/gabime/spdlog/tree/v1.x/include/spdlog) to your build tree and use a C++11 compiler.

 #### Compiled version (recommended - much faster compile times)
 ```console
 $ git clone https://github.com/gabime/spdlog.git
 $ cd spdlog && mkdir build && cd build
-$ cmake .. && cmake --build .
+$ cmake .. && make -j
 ```
-see example [CMakeLists.txt](example/CMakeLists.txt) on how to use.
+see example [CMakeLists.txt](https://github.com/gabime/spdlog/blob/v1.x/example/CMakeLists.txt) on how to use.

 ## Platforms
 * Linux, FreeBSD, OpenBSD, Solaris, AIX
@ -36,9 +29,8 @@ see example [CMakeLists.txt](example/CMakeLists.txt) on how to use.
 * Gentoo: `emerge dev-libs/spdlog`
 * Arch Linux: `pacman -S spdlog`
 * openSUSE: `sudo zypper in spdlog-devel`
-* ALT Linux: `apt-get install libspdlog-devel`
 * vcpkg: `vcpkg install spdlog`
-* conan: `conan install --requires=spdlog/[*]`
+* conan: `spdlog/[>=1.4.1]`
 * conda: `conda install -c conda-forge spdlog`
 * build2: ```depends: spdlog ^1.8.2```

@ -48,7 +40,7 @@ see example [CMakeLists.txt](example/CMakeLists.txt) on how to use.
 * Headers only or compiled
 * Feature-rich formatting, using the excellent [fmt](https://github.com/fmtlib/fmt) library.
 * Asynchronous mode (optional)
-* [Custom](https://github.com/gabime/spdlog/wiki/Custom-formatting) formatting.
+* [Custom](https://github.com/gabime/spdlog/wiki/3.-Custom-formatting) formatting.
 * Multi/Single threaded loggers.
 * Various log targets:
  * Rotating log files.
@ -58,7 +50,7 @@ see example [CMakeLists.txt](example/CMakeLists.txt) on how to use.
  * Windows event log.
  * Windows debugger (```OutputDebugString(..)```).
  * Log to Qt widgets ([example](#log-to-qt-with-nice-colors)).
-  * Easily [extendable](https://github.com/gabime/spdlog/wiki/Sinks#implementing-your-own-sink) with custom log targets.
+  * Easily [extendable](https://github.com/gabime/spdlog/wiki/4.-Sinks#implementing-your-own-sink) with custom log targets.
 * Log filtering - log levels can be modified at runtime as well as compile time.
 * Support for loading log levels from argv or environment var.
 * [Backtrace](#backtrace-support) support - store debug messages in a ring buffer and display them later on demand.
@ -87,8 +79,7 @@ int main()
    spdlog::set_pattern("[%H:%M:%S %z] [%n] [%^---%L---%$] [thread %t] %v");
    
    // Compile time log levels
-    // Note that this does not change the current log level, it will only
-    // remove (depending on SPDLOG_ACTIVE_LEVEL) the call on the release code.
+    // define SPDLOG_ACTIVE_LEVEL to desired level
    SPDLOG_TRACE("Some trace message with param {}", 42);
    SPDLOG_DEBUG("Some debug message");
 }
@ -281,7 +272,6 @@ void async_example()
 ---
 #### Asynchronous logger with multi sinks
 ```c++
-#include "spdlog/async.h"
 #include "spdlog/sinks/stdout_color_sinks.h"
 #include "spdlog/sinks/rotating_file_sink.h"

@ -304,7 +294,7 @@ struct fmt::formatter<my_type> : fmt::formatter<std::string>
 {
    auto format(my_type my, format_context &ctx) const -> decltype(ctx.out())
    {
-        return fmt::format_to(ctx.out(), "[my_type i={}]", my.i);
+        return format_to(ctx.out(), "[my_type i={}]", my.i);
    }
 };

@ -388,9 +378,6 @@ void android_example()
 int main (int argc, char *argv[])
 {
    spdlog::cfg::load_env_levels();
-    // or specify the env variable name:
-    // MYAPP_LEVEL=info,mylogger=trace && ./example
-    // spdlog::cfg::load_env_levels("MYAPP_LEVEL");
    // or from the command line:
    // ./example SPDLOG_LEVEL=info,mylogger=trace
    // #include "spdlog/cfg/argv.h" // for loading levels from argv
@ -448,26 +435,11 @@ MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent)
    logger->info("Some info message");
 }
 ```
---

-#### Mapped Diagnostic Context
-```c++
-// Mapped Diagnostic Context (MDC) is a map that stores key-value pairs (string values) in thread local storage.
-// Each thread maintains its own MDC, which loggers use to append diagnostic information to log outputs.
-// Note: it is not supported in asynchronous mode due to its reliance on thread-local storage.
-#include "spdlog/mdc.h"
-void mdc_example()
-{
-    spdlog::mdc::put("key1", "value1");
-    spdlog::mdc::put("key2", "value2");
-    // if not using the default format, use the %& formatter to print mdc data
-    // spdlog::set_pattern("[%H:%M:%S %z] [%^%L%$] [%&] %v");
-}
-```
 ---
 ## Benchmarks

-Below are some [benchmarks](bench/bench.cpp) done in Ubuntu 64 bit, Intel i7-4770 CPU @ 3.40GHz
+Below are some [benchmarks](https://github.com/gabime/spdlog/blob/v1.x/bench/bench.cpp) done in Ubuntu 64 bit, Intel i7-4770 CPU @ 3.40GHz

 #### Synchronous mode
 ```
@ -519,8 +491,7 @@ Below are some [benchmarks](bench/bench.cpp) done in Ubuntu 64 bit, Intel i7-477
 ```

 ## Documentation
-
-Documentation can be found in the [wiki](https://github.com/gabime/spdlog/wiki) pages.
+Documentation can be found in the [wiki](https://github.com/gabime/spdlog/wiki/1.-QuickStart) pages.

 ---

--- a/bench/async_bench.cpp
+++ b/bench/async_bench.cpp
@ -160,7 +160,7 @@ void bench_mt(int howmany, std::shared_ptr<spdlog::logger> logger, int thread_co

    for (auto &t : threads) {
        t.join();
-    }
+    };

    auto delta = high_resolution_clock::now() - start;
    auto delta_d = duration_cast<duration<double>>(delta).count();
--- a/bench/bench.cpp
+++ b/bench/bench.cpp
@ -181,7 +181,7 @@ void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, size_t thread_co

    for (auto &t : threads) {
        t.join();
-    }
+    };

    auto delta = high_resolution_clock::now() - start;
    auto delta_d = duration_cast<duration<double>>(delta).count();
--- a/bench/latency.cpp
+++ b/bench/latency.cpp
@ -121,7 +121,7 @@ int main(int argc, char *argv[]) {
    tracing_null_logger_st->enable_backtrace(64);
    benchmark::RegisterBenchmark("null_sink_st/backtrace", bench_logger, tracing_null_logger_st);

-#ifdef __linux__
+#ifdef __linux
    bench_dev_null();
 #endif  // __linux__

--- a/cmake/utils.cmake
+++ b/cmake/utils.cmake
@ -49,7 +49,7 @@ function(spdlog_enable_warnings target_name)
 endfunction()

 # Enable address sanitizer (gcc/clang only)
-function(spdlog_enable_addr_sanitizer target_name)
+function(spdlog_enable_sanitizer target_name)
    if(NOT CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
        message(FATAL_ERROR "Sanitizer supported only for gcc/clang")
    endif()
@ -58,16 +58,5 @@ function(spdlog_enable_addr_sanitizer target_name)
    target_compile_options(${target_name} PRIVATE -fno-sanitize=signed-integer-overflow)
    target_compile_options(${target_name} PRIVATE -fno-sanitize-recover=all)
    target_compile_options(${target_name} PRIVATE -fno-omit-frame-pointer)
-    target_link_libraries(${target_name} PRIVATE -fsanitize=address,undefined)
-endfunction()
-
-# Enable thread sanitizer (gcc/clang only)
-function(spdlog_enable_thread_sanitizer target_name)
-    if(NOT CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
-        message(FATAL_ERROR "Sanitizer supported only for gcc/clang")
-    endif()
-    message(STATUS "Thread sanitizer enabled")
-    target_compile_options(${target_name} PRIVATE -fsanitize=thread)
-    target_compile_options(${target_name} PRIVATE -fno-omit-frame-pointer)
-    target_link_libraries(${target_name} PRIVATE -fsanitize=thread)
+    target_link_libraries(${target_name} PRIVATE -fsanitize=address,undefined -fuse-ld=gold)
 endfunction()
--- a/example/example.cpp
+++ b/example/example.cpp
@ -26,7 +26,6 @@ void udp_example();
 void custom_flags_example();
 void file_events_example();
 void replace_default_logger_example();
-void mdc_example();

 #include "spdlog/spdlog.h"
 #include "spdlog/cfg/env.h"   // support for loading levels from the environment variable
@ -85,7 +84,6 @@ int main(int, char *[]) {
        custom_flags_example();
        file_events_example();
        replace_default_logger_example();
-        mdc_example();

        // Flush all *registered* loggers using a worker thread every 3 seconds.
        // note: registered loggers *must* be thread safe for this to work correctly!
@ -148,9 +146,6 @@ void load_levels_example() {
    // Set the log level to "info" and mylogger to "trace":
    // SPDLOG_LEVEL=info,mylogger=trace && ./example
    spdlog::cfg::load_env_levels();
-    // or specify the env variable name:
-    // MYAPP_LEVEL=info,mylogger=trace && ./example
-    // spdlog::cfg::load_env_levels("MYAPP_LEVEL");
    // or from command line:
    // ./example SPDLOG_LEVEL=info,mylogger=trace
    // #include "spdlog/cfg/argv.h" // for loading levels from argv
@ -269,13 +264,13 @@ void multi_sink_example() {
 struct my_type {
    int i = 0;
    explicit my_type(int i)
-        : i(i){}
+        : i(i){};
 };

 #ifndef SPDLOG_USE_STD_FORMAT  // when using fmtlib
 template <>
 struct fmt::formatter<my_type> : fmt::formatter<std::string> {
-    auto format(my_type my, format_context &ctx) const -> decltype(ctx.out()) {
+    auto format(my_type my, format_context &ctx) -> decltype(ctx.out()) {
        return fmt::format_to(ctx.out(), "[my_type i={}]", my.i);
    }
 };
@ -284,7 +279,7 @@ struct fmt::formatter<my_type> : fmt::formatter<std::string> {
 template <>
 struct std::formatter<my_type> : std::formatter<std::string> {
    auto format(my_type my, format_context &ctx) const -> decltype(ctx.out()) {
-        return std::format_to(ctx.out(), "[my_type i={}]", my.i);
+        return format_to(ctx.out(), "[my_type i={}]", my.i);
    }
 };
 #endif
@ -381,23 +376,3 @@ void replace_default_logger_example() {

    spdlog::set_default_logger(old_logger);
 }
-
-// Mapped Diagnostic Context (MDC) is a map that stores key-value pairs (string values) in thread local storage.
-// Each thread maintains its own MDC, which loggers use to append diagnostic information to log outputs.
-// Note: it is not supported in asynchronous mode due to its reliance on thread-local storage.
-
-#ifndef SPDLOG_NO_TLS
-    #include "spdlog/mdc.h"
-void mdc_example()
-{
-    spdlog::mdc::put("key1", "value1");
-    spdlog::mdc::put("key2", "value2");
-    // if not using the default format, you can use the %& formatter to print mdc data as well
-    spdlog::set_pattern("[%H:%M:%S %z] [%^%L%$] [%&] %v");
-    spdlog::info("Some log message with context");
-}
-#else
-void mdc_example() {
-    // if TLS feature is disabled
-}
-#endif
--- a/include/spdlog/cfg/env.h
+++ b/include/spdlog/cfg/env.h
@ -25,8 +25,8 @@

 namespace spdlog {
 namespace cfg {
-inline void load_env_levels(const char* var = "SPDLOG_LEVEL") {
-    auto env_val = details::os::getenv(var);
+inline void load_env_levels() {
+    auto env_val = details::os::getenv("SPDLOG_LEVEL");
    if (!env_val.empty()) {
        helpers::load_levels(env_val);
    }
--- a/include/spdlog/common.h
+++ b/include/spdlog/common.h
@ -319,7 +319,7 @@ struct source_loc {
          line{line_in},
          funcname{funcname_in} {}

-    SPDLOG_CONSTEXPR bool empty() const SPDLOG_NOEXCEPT { return line <= 0; }
+    SPDLOG_CONSTEXPR bool empty() const SPDLOG_NOEXCEPT { return line == 0; }
    const char *filename{nullptr};
    int line{0};
    const char *funcname{nullptr};
@ -364,7 +364,12 @@ SPDLOG_CONSTEXPR_FUNC spdlog::wstring_view_t to_string_view(spdlog::wstring_view
 }
 #endif

-#if defined(SPDLOG_USE_STD_FORMAT) &&  __cpp_lib_format >= 202207L
+#ifndef SPDLOG_USE_STD_FORMAT
+template <typename T, typename... Args>
+inline fmt::basic_string_view<T> to_string_view(fmt::basic_format_string<T, Args...> fmt) {
+    return fmt;
+}
+#elif __cpp_lib_format >= 202207L
 template <typename T, typename... Args>
 SPDLOG_CONSTEXPR_FUNC std::basic_string_view<T> to_string_view(
    std::basic_format_string<T, Args...> fmt) SPDLOG_NOEXCEPT {
--- a/include/spdlog/details/circular_q.h
+++ b/include/spdlog/details/circular_q.h
@ -7,8 +7,6 @@
 #include <cassert>
 #include <vector>

-#include "spdlog/common.h"
-
 namespace spdlog {
 namespace details {
 template <typename T>
--- a/include/spdlog/details/file_helper-inl.h
+++ b/include/spdlog/details/file_helper-inl.h
@ -98,11 +98,10 @@ SPDLOG_INLINE void file_helper::close() {
 }

 SPDLOG_INLINE void file_helper::write(const memory_buf_t &buf) {
-    if (fd_ == nullptr) return;
+    if(fd_ == nullptr) return;
    size_t msg_size = buf.size();
    auto data = buf.data();
-
-    if (!details::os::fwrite_bytes(data, msg_size, fd_)) {
+    if (std::fwrite(data, 1, msg_size, fd_) != msg_size) {
        throw_spdlog_ex("Failed writing to file " + os::filename_to_str(filename_), errno);
    }
 }
--- a/include/spdlog/details/mpmc_blocking_q.h
+++ b/include/spdlog/details/mpmc_blocking_q.h
@ -148,19 +148,19 @@ public:
 #endif

    size_t overrun_counter() {
-        std::lock_guard<std::mutex> lock(queue_mutex_);
+        std::unique_lock<std::mutex> lock(queue_mutex_);
        return q_.overrun_counter();
    }

    size_t discard_counter() { return discard_counter_.load(std::memory_order_relaxed); }

    size_t size() {
-        std::lock_guard<std::mutex> lock(queue_mutex_);
+        std::unique_lock<std::mutex> lock(queue_mutex_);
        return q_.size();
    }

    void reset_overrun_counter() {
-        std::lock_guard<std::mutex> lock(queue_mutex_);
+        std::unique_lock<std::mutex> lock(queue_mutex_);
        q_.reset_overrun_counter();
    }

--- a/include/spdlog/details/os-inl.h
+++ b/include/spdlog/details/os-inl.h
@ -177,12 +177,12 @@ SPDLOG_INLINE int rename(const filename_t &filename1, const filename_t &filename
 // Return true if path exists (file or directory)
 SPDLOG_INLINE bool path_exists(const filename_t &filename) SPDLOG_NOEXCEPT {
 #ifdef _WIN32
-    struct _stat buffer;
    #ifdef SPDLOG_WCHAR_FILENAMES
-    return (::_wstat(filename.c_str(), &buffer) == 0);
+    auto attribs = ::GetFileAttributesW(filename.c_str());
    #else
-    return (::_stat(filename.c_str(), &buffer) == 0);
+    auto attribs = ::GetFileAttributesA(filename.c_str());
    #endif
+    return attribs != INVALID_FILE_ATTRIBUTES;
 #else  // common linux/unix all have the stat system call
    struct stat buffer;
    return (::stat(filename.c_str(), &buffer) == 0);
@ -267,8 +267,7 @@ SPDLOG_INLINE int utc_minutes_offset(const std::tm &tm) {

    #if defined(sun) || defined(__sun) || defined(_AIX) || \
        (defined(__NEWLIB__) && !defined(__TM_GMTOFF)) ||  \
-        (!defined(__APPLE__) && !defined(_BSD_SOURCE) && !defined(_GNU_SOURCE) && \
-            (!defined(_POSIX_VERSION) || (_POSIX_VERSION < 202405L)))
+        (!defined(_BSD_SOURCE) && !defined(_GNU_SOURCE))
    // 'tm_gmtoff' field is BSD extension and it's missing on SunOS/Solaris
    struct helper {
        static long int calculate_gmt_offset(const std::tm &localtm = details::os::localtime(),
@ -440,7 +439,7 @@ SPDLOG_INLINE bool in_terminal(FILE *file) SPDLOG_NOEXCEPT {

 #if (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && defined(_WIN32)
 SPDLOG_INLINE void wstr_to_utf8buf(wstring_view_t wstr, memory_buf_t &target) {
-    if (wstr.size() > static_cast<size_t>((std::numeric_limits<int>::max)()) / 4 - 1) {
+    if (wstr.size() > static_cast<size_t>((std::numeric_limits<int>::max)()) / 2 - 1) {
        throw_spdlog_ex("UTF-16 string is too big to be converted to UTF-8");
    }

@ -451,7 +450,7 @@ SPDLOG_INLINE void wstr_to_utf8buf(wstring_view_t wstr, memory_buf_t &target) {
    }

    int result_size = static_cast<int>(target.capacity());
-    if ((wstr_size + 1) * 4 > result_size) {
+    if ((wstr_size + 1) * 2 > result_size) {
        result_size =
            ::WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr_size, NULL, 0, NULL, NULL);
    }
@ -484,12 +483,12 @@ SPDLOG_INLINE void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t &target) {

    // find the size to allocate for the result buffer
    int result_size =
-        ::MultiByteToWideChar(CP_UTF8, 0, str.data(), str_size, NULL, 0);
+        ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, str.data(), str_size, NULL, 0);

    if (result_size > 0) {
        target.resize(result_size);
-        result_size = ::MultiByteToWideChar(CP_UTF8, 0, str.data(), str_size, target.data(),
-                                            result_size);
+        result_size = ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, str.data(), str_size,
+                                            target.data(), result_size);
        if (result_size > 0) {
            assert(result_size == target.size());
            return;
@ -535,15 +534,6 @@ SPDLOG_INLINE bool create_dir(const filename_t &path) {
        }

        auto subdir = path.substr(0, token_pos);
-#ifdef _WIN32
-        // if subdir is just a drive letter, add a slash e.g. "c:"=>"c:\",
-        // otherwise path_exists(subdir) returns false (issue #3079)
-        const bool is_drive = subdir.length() == 2 && subdir[1] == ':';
-        if (is_drive) {
-            subdir += '\\';
-            token_pos++;
-        }
-#endif

        if (!subdir.empty() && !path_exists(subdir) && !mkdir_(subdir)) {
            return false;  // return error if failed creating dir
@ -590,18 +580,6 @@ SPDLOG_INLINE bool fsync(FILE *fp) {
 #endif
 }

-// Do non-locking fwrite if possible by the os or use the regular locking fwrite
-// Return true on success.
-SPDLOG_INLINE bool fwrite_bytes(const void *ptr, const size_t n_bytes, FILE *fp) {
-    #if defined(_WIN32) && defined(SPDLOG_FWRITE_UNLOCKED)
-    return _fwrite_nolock(ptr, 1, n_bytes, fp) == n_bytes;
-    #elif defined(SPDLOG_FWRITE_UNLOCKED)
-    return ::fwrite_unlocked(ptr, 1, n_bytes, fp) == n_bytes;
-    #else
-    return std::fwrite(ptr, 1, n_bytes, fp) == n_bytes;
-    #endif
-}
-
 }  // namespace os
 }  // namespace details
 }  // namespace spdlog
--- a/include/spdlog/details/os.h
+++ b/include/spdlog/details/os.h
@ -114,10 +114,6 @@ SPDLOG_API std::string getenv(const char *field);
 // Return true on success.
 SPDLOG_API bool fsync(FILE *fp);

-// Do non-locking fwrite if possible by the os or use the regular locking fwrite
-// Return true on success.
-SPDLOG_API bool fwrite_bytes(const void *ptr, const size_t n_bytes, FILE *fp);
-
 }  // namespace os
 }  // namespace details
 }  // namespace spdlog
--- a/include/spdlog/details/periodic_worker.h
+++ b/include/spdlog/details/periodic_worker.h
@ -38,7 +38,6 @@ public:
            }
        });
    }
-    std::thread &get_thread() { return worker_thread_; }
    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
@ -99,6 +99,10 @@ SPDLOG_INLINE logger *registry::get_default_raw() { return default_logger_.get()
 // default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map.
 SPDLOG_INLINE void registry::set_default_logger(std::shared_ptr<logger> new_default_logger) {
    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    // remove previous default logger from the map
+    if (default_logger_ != nullptr) {
+        loggers_.erase(default_logger_->name());
+    }
    if (new_default_logger != nullptr) {
        loggers_[new_default_logger->name()] = new_default_logger;
    }
--- a/include/spdlog/details/registry.h
+++ b/include/spdlog/details/registry.h
@ -42,10 +42,8 @@ public:
    // another.
    logger *get_default_raw();

-    // set default logger and add it to the registry if not registered already.
+    // set default logger.
    // default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map.
-    // Note: Make sure to unregister it when no longer needed or before calling again with a new
-    // logger.
    void set_default_logger(std::shared_ptr<logger> new_default_logger);

    void set_tp(std::shared_ptr<thread_pool> tp);
@ -70,11 +68,6 @@ public:
        periodic_flusher_ = details::make_unique<periodic_worker>(clbk, interval);
    }

-    std::unique_ptr<periodic_worker> &get_flusher() {
-        std::lock_guard<std::mutex> lock(flusher_mutex_);
-        return periodic_flusher_;
-    }
-
    void set_error_handler(err_handler handler);

    void apply_all(const std::function<void(const std::shared_ptr<logger>)> &fun);
--- a/include/spdlog/fmt/bin_to_hex.h
+++ b/include/spdlog/fmt/bin_to_hex.h
@ -102,7 +102,7 @@ namespace

 template <typename T>
 struct formatter<spdlog::details::dump_info<T>, char> {
-    char delimiter = ' ';
+    const char delimiter = ' ';
    bool put_newlines = true;
    bool put_delimiters = true;
    bool use_uppercase = false;
--- a/include/spdlog/fmt/bundled/args.h
+++ b/include/spdlog/fmt/bundled/args.h
@ -1,4 +1,4 @@
-// Formatting library for C++ - dynamic argument lists
+// Formatting library for C++ - dynamic format arguments
 //
 // Copyright (c) 2012 - present, Victor Zverovich
 // All rights reserved.
@ -8,39 +8,34 @@
 #ifndef FMT_ARGS_H_
 #define FMT_ARGS_H_

-#ifndef FMT_MODULE
-#  include <functional>  // std::reference_wrapper
-#  include <memory>      // std::unique_ptr
-#  include <vector>
-#endif
+#include <functional>  // std::reference_wrapper
+#include <memory>      // std::unique_ptr
+#include <vector>

-#include "format.h"  // std_string_view
+#include "core.h"

 FMT_BEGIN_NAMESPACE
+
 namespace detail {

 template <typename T> struct is_reference_wrapper : std::false_type {};
 template <typename T>
 struct is_reference_wrapper<std::reference_wrapper<T>> : std::true_type {};

-template <typename T> auto unwrap(const T& v) -> const T& { return v; }
-template <typename T>
-auto unwrap(const std::reference_wrapper<T>& v) -> const T& {
+template <typename T> const T& unwrap(const T& v) { return v; }
+template <typename T> const T& unwrap(const std::reference_wrapper<T>& v) {
  return static_cast<const T&>(v);
 }

-// node is defined outside dynamic_arg_list to workaround a C2504 bug in MSVC
-// 2022 (v17.10.0).
-//
-// Workaround for clang's -Wweak-vtables. Unlike for regular classes, for
-// templates it doesn't complain about inability to deduce single translation
-// unit for placing vtable. So node is made a fake template.
-template <typename = void> struct node {
+class dynamic_arg_list {
+  // Workaround for clang's -Wweak-vtables. Unlike for regular classes, for
+  // templates it doesn't complain about inability to deduce single translation
+  // unit for placing vtable. So storage_node_base is made a fake template.
+  template <typename = void> struct node {
    virtual ~node() = default;
    std::unique_ptr<node<>> next;
-};
+  };

-class dynamic_arg_list {
  template <typename T> struct typed_node : node<> {
    T value;

@ -55,7 +50,7 @@ class dynamic_arg_list {
  std::unique_ptr<node<>> head_;

 public:
-  template <typename T, typename Arg> auto push(const Arg& arg) -> const T& {
+  template <typename T, typename Arg> const T& push(const Arg& arg) {
    auto new_node = std::unique_ptr<typed_node<T>>(new typed_node<T>(arg));
    auto& value = new_node->value;
    new_node->next = std::move(head_);
@ -66,18 +61,28 @@ class dynamic_arg_list {
 }  // namespace detail

 /**
- * A dynamic list of formatting arguments with storage.
- *
- * It can be implicitly converted into `fmt::basic_format_args` for passing
- * into type-erased formatting functions such as `fmt::vformat`.
+  \rst
+  A dynamic version of `fmt::format_arg_store`.
+  It's equipped with a storage to potentially temporary objects which lifetimes
+  could be shorter than the format arguments object.
+
+  It can be implicitly converted into `~fmt::basic_format_args` for passing
+  into type-erased formatting functions such as `~fmt::vformat`.
+  \endrst
 */
-template <typename Context> class dynamic_format_arg_store {
+template <typename Context>
+class dynamic_format_arg_store
+#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
+    // Workaround a GCC template argument substitution bug.
+    : public basic_format_args<Context>
+#endif
+{
 private:
  using char_type = typename Context::char_type;

  template <typename T> struct need_copy {
    static constexpr detail::type mapped_type =
-        detail::mapped_type_constant<T, char_type>::value;
+        detail::mapped_type_constant<T, Context>::value;

    enum {
      value = !(detail::is_reference_wrapper<T>::value ||
@ -90,7 +95,7 @@ template <typename Context> class dynamic_format_arg_store {
  };

  template <typename T>
-  using stored_t = conditional_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>;
@ -105,71 +110,79 @@ template <typename Context> class dynamic_format_arg_store {

  friend class basic_format_args<Context>;

-  auto data() const -> const basic_format_arg<Context>* {
+  unsigned long long get_types() const {
+    return detail::is_unpacked_bit | data_.size() |
+           (named_info_.empty()
+                ? 0ULL
+                : static_cast<unsigned long long>(detail::has_named_args_bit));
+  }
+
+  const basic_format_arg<Context>* data() const {
    return named_info_.empty() ? data_.data() : data_.data() + 1;
  }

  template <typename T> void emplace_arg(const T& arg) {
-    data_.emplace_back(arg);
+    data_.emplace_back(detail::make_arg<Context>(arg));
  }

  template <typename T>
  void emplace_arg(const detail::named_arg<char_type, T>& arg) {
-    if (named_info_.empty())
-      data_.insert(data_.begin(), basic_format_arg<Context>(nullptr, 0));
-    data_.emplace_back(detail::unwrap(arg.value));
+    if (named_info_.empty()) {
+      constexpr const detail::named_arg_info<char_type>* zero_ptr{nullptr};
+      data_.insert(data_.begin(), {zero_ptr, 0});
+    }
+    data_.emplace_back(detail::make_arg<Context>(detail::unwrap(arg.value)));
    auto pop_one = [](std::vector<basic_format_arg<Context>>* data) {
      data->pop_back();
    };
    std::unique_ptr<std::vector<basic_format_arg<Context>>, decltype(pop_one)>
        guard{&data_, pop_one};
    named_info_.push_back({arg.name, static_cast<int>(data_.size() - 2u)});
-    data_[0] = {named_info_.data(), named_info_.size()};
+    data_[0].value_.named_args = {named_info_.data(), named_info_.size()};
    guard.release();
  }

 public:
  constexpr dynamic_format_arg_store() = default;

-  operator basic_format_args<Context>() const {
-    return basic_format_args<Context>(data(), static_cast<int>(data_.size()),
-                                      !named_info_.empty());
-  }
-
  /**
-   * Adds an argument into the dynamic store for later passing to a formatting
-   * function.
-   *
-   * Note that custom types and string types (but not string views) are copied
-   * into the store dynamically allocating memory if necessary.
-   *
-   * **Example**:
-   *
-   *     fmt::dynamic_format_arg_store<fmt::format_context> store;
-   *     store.push_back(42);
-   *     store.push_back("abc");
-   *     store.push_back(1.5f);
-   *     std::string result = fmt::vformat("{} and {} and {}", store);
+    \rst
+    Adds an argument into the dynamic store for later passing to a formatting
+    function.
+
+    Note that custom types and string types (but not string views) are copied
+    into the store dynamically allocating memory if necessary.
+
+    **Example**::
+
+      fmt::dynamic_format_arg_store<fmt::format_context> store;
+      store.push_back(42);
+      store.push_back("abc");
+      store.push_back(1.5f);
+      std::string result = fmt::vformat("{} and {} and {}", store);
+    \endrst
  */
  template <typename T> void push_back(const T& arg) {
    if (detail::const_check(need_copy<T>::value))
-      emplace_arg(dynamic_args_.push<stored_t<T>>(arg));
+      emplace_arg(dynamic_args_.push<stored_type<T>>(arg));
    else
      emplace_arg(detail::unwrap(arg));
  }

  /**
-   * Adds a reference to the argument into the dynamic store for later passing
-   * to a formatting function.
-   *
-   * **Example**:
-   *
-   *     fmt::dynamic_format_arg_store<fmt::format_context> store;
-   *     char band[] = "Rolling Stones";
-   *     store.push_back(std::cref(band));
-   *     band[9] = 'c'; // Changing str affects the output.
-   *     std::string result = fmt::vformat("{}", store);
-   *     // result == "Rolling Scones"
+    \rst
+    Adds a reference to the argument into the dynamic store for later passing to
+    a formatting function.
+
+    **Example**::
+
+      fmt::dynamic_format_arg_store<fmt::format_context> store;
+      char band[] = "Rolling Stones";
+      store.push_back(std::cref(band));
+      band[9] = 'c'; // Changing str affects the output.
+      std::string result = fmt::vformat("{}", store);
+      // result == "Rolling Scones"
+    \endrst
  */
  template <typename T> void push_back(std::reference_wrapper<T> arg) {
    static_assert(
@ -179,9 +192,9 @@ template <typename Context> class dynamic_format_arg_store {
  }

  /**
-   * Adds named argument into the dynamic store for later passing to a
-   * formatting function. `std::reference_wrapper` is supported to avoid
-   * copying of the argument. The name is always copied into the store.
+    Adds named argument into the dynamic store for later passing to a formatting
+    function. ``std::reference_wrapper`` is supported to avoid copying of the
+    argument. The name is always copied into the store.
  */
  template <typename T>
  void push_back(const detail::named_arg<char_type, T>& arg) {
@ -189,30 +202,31 @@ template <typename Context> class dynamic_format_arg_store {
        dynamic_args_.push<std::basic_string<char_type>>(arg.name).c_str();
    if (detail::const_check(need_copy<T>::value)) {
      emplace_arg(
-          fmt::arg(arg_name, dynamic_args_.push<stored_t<T>>(arg.value)));
+          fmt::arg(arg_name, dynamic_args_.push<stored_type<T>>(arg.value)));
    } else {
      emplace_arg(fmt::arg(arg_name, arg.value));
    }
  }

-  /// Erase all elements from the store.
+  /** Erase all elements from the store */
  void clear() {
    data_.clear();
    named_info_.clear();
-    dynamic_args_ = {};
+    dynamic_args_ = detail::dynamic_arg_list();
  }

-  /// Reserves space to store at least `new_cap` arguments including
-  /// `new_cap_named` named arguments.
+  /**
+    \rst
+    Reserves space to store at least *new_cap* arguments including
+    *new_cap_named* named arguments.
+    \endrst
+  */
  void reserve(size_t new_cap, size_t new_cap_named) {
    FMT_ASSERT(new_cap >= new_cap_named,
-               "set of arguments includes set of named arguments");
+               "Set of arguments includes set of named arguments");
    data_.reserve(new_cap);
    named_info_.reserve(new_cap_named);
  }
-
-  /// Returns the number of elements in the store.
-  size_t size() const noexcept { return data_.size(); }
 };

 FMT_END_NAMESPACE
--- a/include/spdlog/fmt/bundled/base.h
+++ b/include/spdlog/fmt/bundled/base.h
--- a/include/spdlog/fmt/bundled/chrono.h
+++ b/include/spdlog/fmt/bundled/chrono.h
--- a/include/spdlog/fmt/bundled/color.h
+++ b/include/spdlog/fmt/bundled/color.h
@ -11,7 +11,7 @@
 #include "format.h"

 FMT_BEGIN_NAMESPACE
-FMT_BEGIN_EXPORT
+FMT_MODULE_EXPORT_BEGIN

 enum class color : uint32_t {
  alice_blue = 0xF0F8FF,               // rgb(240,248,255)
@ -203,7 +203,7 @@ struct rgb {
  uint8_t b;
 };

-namespace detail {
+FMT_BEGIN_DETAIL_NAMESPACE

 // color is a struct of either a rgb color or a terminal color.
 struct color_type {
@ -225,21 +225,22 @@ struct color_type {
    uint32_t rgb_color;
  } value;
 };
-}  // namespace detail

-/// A text style consisting of foreground and background colors and emphasis.
+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()) noexcept
      : set_foreground_color(), set_background_color(), ems(em) {}

-  FMT_CONSTEXPR auto operator|=(const text_style& rhs) -> text_style& {
+  FMT_CONSTEXPR text_style& operator|=(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)
-        report_error("can't OR a terminal color");
+        FMT_THROW(format_error("can't OR a terminal color"));
      foreground_color.value.rgb_color |= rhs.foreground_color.value.rgb_color;
    }

@ -248,7 +249,7 @@ class text_style {
      background_color = rhs.background_color;
    } else if (rhs.set_background_color) {
      if (!background_color.is_rgb || !rhs.background_color.is_rgb)
-        report_error("can't OR a terminal color");
+        FMT_THROW(format_error("can't OR a terminal color"));
      background_color.value.rgb_color |= rhs.background_color.value.rgb_color;
    }

@ -257,29 +258,29 @@ class text_style {
    return *this;
  }

-  friend FMT_CONSTEXPR auto operator|(text_style lhs, const text_style& rhs)
-      -> text_style {
+  friend FMT_CONSTEXPR text_style operator|(text_style lhs,
+                                            const text_style& rhs) {
    return lhs |= rhs;
  }

-  FMT_CONSTEXPR auto has_foreground() const noexcept -> bool {
+  FMT_CONSTEXPR bool has_foreground() const noexcept {
    return set_foreground_color;
  }
-  FMT_CONSTEXPR auto has_background() const noexcept -> bool {
+  FMT_CONSTEXPR bool has_background() const noexcept {
    return set_background_color;
  }
-  FMT_CONSTEXPR auto has_emphasis() const noexcept -> bool {
+  FMT_CONSTEXPR bool has_emphasis() const noexcept {
    return static_cast<uint8_t>(ems) != 0;
  }
-  FMT_CONSTEXPR auto get_foreground() const noexcept -> detail::color_type {
+  FMT_CONSTEXPR detail::color_type get_foreground() const noexcept {
    FMT_ASSERT(has_foreground(), "no foreground specified for this style");
    return foreground_color;
  }
-  FMT_CONSTEXPR auto get_background() const noexcept -> detail::color_type {
+  FMT_CONSTEXPR detail::color_type get_background() const noexcept {
    FMT_ASSERT(has_background(), "no background specified for this style");
    return background_color;
  }
-  FMT_CONSTEXPR auto get_emphasis() const noexcept -> emphasis {
+  FMT_CONSTEXPR emphasis get_emphasis() const noexcept {
    FMT_ASSERT(has_emphasis(), "no emphasis specified for this style");
    return ems;
  }
@ -297,11 +298,9 @@ class text_style {
    }
  }

-  friend FMT_CONSTEXPR auto fg(detail::color_type foreground) noexcept
-      -> text_style;
+  friend FMT_CONSTEXPR text_style fg(detail::color_type foreground) noexcept;

-  friend FMT_CONSTEXPR auto bg(detail::color_type background) noexcept
-      -> text_style;
+  friend FMT_CONSTEXPR text_style bg(detail::color_type background) noexcept;

  detail::color_type foreground_color;
  detail::color_type background_color;
@ -310,27 +309,24 @@ class text_style {
  emphasis ems;
 };

-/// Creates a text style from the foreground (text) color.
-FMT_CONSTEXPR inline auto fg(detail::color_type foreground) noexcept
-    -> text_style {
+/** Creates a text style from the foreground (text) color. */
+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 auto bg(detail::color_type background) noexcept
-    -> text_style {
+/** Creates a text style from the background color. */
+FMT_CONSTEXPR inline text_style bg(detail::color_type background) noexcept {
  return text_style(false, background);
 }

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

-namespace detail {
+FMT_BEGIN_DETAIL_NAMESPACE

 template <typename Char> struct ansi_color_escape {
-  FMT_CONSTEXPR ansi_color_escape(color_type text_color,
+  FMT_CONSTEXPR ansi_color_escape(detail::color_type text_color,
                                  const char* esc) noexcept {
    // If we have a terminal color, we need to output another escape code
    // sequence.
@ -389,9 +385,9 @@ template <typename Char> struct ansi_color_escape {
  }
  FMT_CONSTEXPR operator const Char*() const noexcept { return buffer; }

-  FMT_CONSTEXPR auto begin() const noexcept -> const Char* { return buffer; }
-  FMT_CONSTEXPR20 auto end() const noexcept -> const Char* {
-    return buffer + basic_string_view<Char>(buffer).size();
+  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);
  }

 private:
@ -405,152 +401,194 @@ template <typename Char> struct ansi_color_escape {
    out[2] = static_cast<Char>('0' + c % 10);
    out[3] = static_cast<Char>(delimiter);
  }
-  static FMT_CONSTEXPR auto has_emphasis(emphasis em, emphasis mask) noexcept
-      -> bool {
+  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 auto make_foreground_color(color_type foreground) noexcept
-    -> ansi_color_escape<Char> {
+FMT_CONSTEXPR ansi_color_escape<Char> make_foreground_color(
+    detail::color_type foreground) noexcept {
  return ansi_color_escape<Char>(foreground, "\x1b[38;2;");
 }

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

 template <typename Char>
-FMT_CONSTEXPR auto make_emphasis(emphasis em) noexcept
-    -> ansi_color_escape<Char> {
+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) {
+  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) {
+  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) {
+  fputs("\x1b[0m", stream);
+}
+
+template <> inline void reset_color<wchar_t>(FILE* stream) {
+  fputs(L"\x1b[0m", stream);
+}
+
 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 : view {
+template <typename T> struct styled_arg {
  const T& value;
  text_style style;
-  styled_arg(const T& v, text_style s) : value(v), style(s) {}
 };

 template <typename Char>
 void vformat_to(buffer<Char>& buf, const text_style& ts,
-                basic_string_view<Char> fmt,
-                basic_format_args<buffered_context<Char>> args) {
+                basic_string_view<Char> format_str,
+                basic_format_args<buffer_context<type_identity_t<Char>>> args) {
  bool has_style = false;
  if (ts.has_emphasis()) {
    has_style = true;
-    auto emphasis = make_emphasis<Char>(ts.get_emphasis());
+    auto emphasis = detail::make_emphasis<Char>(ts.get_emphasis());
    buf.append(emphasis.begin(), emphasis.end());
  }
  if (ts.has_foreground()) {
    has_style = true;
-    auto foreground = make_foreground_color<Char>(ts.get_foreground());
+    auto foreground = detail::make_foreground_color<Char>(ts.get_foreground());
    buf.append(foreground.begin(), foreground.end());
  }
  if (ts.has_background()) {
    has_style = true;
-    auto background = make_background_color<Char>(ts.get_background());
+    auto background = detail::make_background_color<Char>(ts.get_background());
    buf.append(background.begin(), background.end());
  }
-  vformat_to(buf, fmt, args);
-  if (has_style) reset_color<Char>(buf);
+  detail::vformat_to(buf, format_str, args, {});
+  if (has_style) detail::reset_color<Char>(buf);
 }
-}  // namespace detail

-inline void vprint(FILE* f, const text_style& ts, string_view fmt,
-                   format_args args) {
-  auto buf = memory_buffer();
-  detail::vformat_to(buf, ts, fmt, args);
-  print(f, FMT_STRING("{}"), string_view(buf.begin(), buf.size()));
+FMT_END_DETAIL_NAMESPACE
+
+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, 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);
+  }
 }

 /**
- * Formats a string and prints it to the specified file stream using ANSI
- * escape sequences to specify text formatting.
- *
- * **Example**:
- *
- *     fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
- *                "Elapsed time: {0:.2f} seconds", 1.23);
+  \rst
+  Formats a string and prints it to the specified file stream using ANSI
+  escape sequences to specify text formatting.
+
+  **Example**::
+
+    fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
+               "Elapsed time: {0:.2f} seconds", 1.23);
+  \endrst
 */
-template <typename... T>
-void print(FILE* f, const text_style& ts, format_string<T...> fmt,
-           T&&... args) {
-  vprint(f, ts, fmt.str, vargs<T...>{{args...}});
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(detail::is_string<S>::value)>
+void print(std::FILE* f, const text_style& ts, const S& format_str,
+           const Args&... args) {
+  vprint(f, ts, format_str,
+         fmt::make_format_args<buffer_context<char_t<S>>>(args...));
 }

 /**
- * Formats a string and prints it to stdout using ANSI escape sequences to
- * specify text formatting.
- *
- * **Example**:
- *
- *     fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
- *                "Elapsed time: {0:.2f} seconds", 1.23);
+  \rst
+  Formats a string and prints it to stdout using ANSI escape sequences to
+  specify text formatting.
+
+  **Example**::
+
+    fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
+               "Elapsed time: {0:.2f} seconds", 1.23);
+  \endrst
 */
-template <typename... T>
-void print(const text_style& ts, format_string<T...> fmt, T&&... args) {
-  return print(stdout, ts, fmt, std::forward<T>(args)...);
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(detail::is_string<S>::value)>
+void print(const text_style& ts, const S& format_str, const Args&... args) {
+  return print(stdout, ts, format_str, args...);
 }

-inline auto vformat(const text_style& ts, string_view fmt, format_args args)
-    -> std::string {
-  auto buf = memory_buffer();
-  detail::vformat_to(buf, ts, fmt, args);
+template <typename S, typename Char = char_t<S>>
+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, detail::to_string_view(format_str), args);
  return fmt::to_string(buf);
 }

 /**
- * Formats arguments and returns the result as a string using ANSI escape
- * sequences to specify text formatting.
- *
- * **Example**:
- *
- * ```
- * #include <fmt/color.h>
- * std::string message = fmt::format(fmt::emphasis::bold | fg(fmt::color::red),
- *                                   "The answer is {}", 42);
- * ```
- */
-template <typename... T>
-inline auto format(const text_style& ts, format_string<T...> fmt, T&&... args)
-    -> std::string {
-  return fmt::vformat(ts, fmt.str, vargs<T...>{{args...}});
-}
+  \rst
+  Formats arguments and returns the result as a string using ANSI
+  escape sequences to specify text formatting.

-/// Formats a string with the given text_style and writes the output to `out`.
-template <typename OutputIt,
-          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
-auto vformat_to(OutputIt out, const text_style& ts, string_view fmt,
-                format_args args) -> OutputIt {
-  auto&& buf = detail::get_buffer<char>(out);
-  detail::vformat_to(buf, ts, fmt, args);
-  return detail::get_iterator(buf, out);
+  **Example**::
+
+    #include <fmt/color.h>
+    std::string message = fmt::format(fmt::emphasis::bold | fg(fmt::color::red),
+                                      "The answer is {}", 42);
+  \endrst
+*/
+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, detail::to_string_view(format_str),
+                      fmt::make_format_args<buffer_context<Char>>(args...));
 }

 /**
- * Formats arguments with the given text style, writes the result to the output
- * iterator `out` and returns the iterator past the end of the output range.
- *
- * **Example**:
- *
- *     std::vector<char> out;
- *     fmt::format_to(std::back_inserter(out),
- *                    fmt::emphasis::bold | fg(fmt::color::red), "{}", 42);
+  Formats a string with the given text_style and writes the output to ``out``.
 */
-template <typename OutputIt, typename... T,
-          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
-inline auto format_to(OutputIt out, const text_style& ts,
-                      format_string<T...> fmt, T&&... args) -> OutputIt {
-  return vformat_to(out, ts, fmt.str, vargs<T...>{{args...}});
+template <typename OutputIt, typename Char,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value)>
+OutputIt vformat_to(
+    OutputIt out, const text_style& ts, basic_string_view<Char> format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+  auto&& buf = detail::get_buffer<Char>(out);
+  detail::vformat_to(buf, ts, format_str, args);
+  return detail::get_iterator(buf);
+}
+
+/**
+  \rst
+  Formats arguments with the given text_style, writes the result to the output
+  iterator ``out`` and returns the iterator past the end of the output range.
+
+  **Example**::
+
+    std::vector<char> out;
+    fmt::format_to(std::back_inserter(out),
+                   fmt::emphasis::bold | fg(fmt::color::red), "{}", 42);
+  \endrst
+*/
+template <typename OutputIt, typename S, typename... Args,
+          bool enable = detail::is_output_iterator<OutputIt, char_t<S>>::value&&
+              detail::is_string<S>::value>
+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, detail::to_string_view(format_str),
+                    fmt::make_format_args<buffer_context<char_t<S>>>(args...));
 }

 template <typename T, typename Char>
@ -559,44 +597,47 @@ struct formatter<detail::styled_arg<T>, Char> : formatter<T, Char> {
  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 = detail::copy<Char>(emphasis.begin(), emphasis.end(), out);
+      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 = detail::copy<Char>(foreground.begin(), foreground.end(), out);
+      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 = detail::copy<Char>(background.begin(), background.end(), out);
+      out = std::copy(background.begin(), background.end(), out);
    }
-    out = formatter<T, Char>::format(arg.value, ctx);
+    out = formatter<T, Char>::format(value, ctx);
    if (has_style) {
      auto reset_color = string_view("\x1b[0m");
-      out = detail::copy<Char>(reset_color.begin(), reset_color.end(), out);
+      out = std::copy(reset_color.begin(), reset_color.end(), out);
    }
    return out;
  }
 };

 /**
- * 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)));
+  \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)
@ -604,7 +645,7 @@ FMT_CONSTEXPR auto styled(const T& value, text_style ts)
  return detail::styled_arg<remove_cvref_t<T>>{value, ts};
 }

-FMT_END_EXPORT
+FMT_MODULE_EXPORT_END
 FMT_END_NAMESPACE

 #endif  // FMT_COLOR_H_
--- a/include/spdlog/fmt/bundled/compile.h
+++ b/include/spdlog/fmt/bundled/compile.h
@ -8,41 +8,134 @@
 #ifndef FMT_COMPILE_H_
 #define FMT_COMPILE_H_

-#ifndef FMT_MODULE
-#  include <iterator>  // std::back_inserter
-#endif
-
 #include "format.h"

 FMT_BEGIN_NAMESPACE
+namespace detail {
+
+template <typename Char, typename InputIt>
+FMT_CONSTEXPR inline counting_iterator copy_str(InputIt begin, InputIt end,
+                                                counting_iterator it) {
+  return it + (end - begin);
+}
+
+template <typename OutputIt> class truncating_iterator_base {
+ protected:
+  OutputIt out_;
+  size_t limit_;
+  size_t count_ = 0;
+
+  truncating_iterator_base() : out_(), limit_(0) {}
+
+  truncating_iterator_base(OutputIt out, size_t limit)
+      : out_(out), limit_(limit) {}
+
+ public:
+  using iterator_category = std::output_iterator_tag;
+  using value_type = typename std::iterator_traits<OutputIt>::value_type;
+  using difference_type = std::ptrdiff_t;
+  using pointer = void;
+  using reference = void;
+  FMT_UNCHECKED_ITERATOR(truncating_iterator_base);
+
+  OutputIt base() const { return out_; }
+  size_t count() const { return count_; }
+};
+
+// An output iterator that truncates the output and counts the number of objects
+// written to it.
+template <typename OutputIt,
+          typename Enable = typename std::is_void<
+              typename std::iterator_traits<OutputIt>::value_type>::type>
+class truncating_iterator;
+
+template <typename OutputIt>
+class truncating_iterator<OutputIt, std::false_type>
+    : public truncating_iterator_base<OutputIt> {
+  mutable typename truncating_iterator_base<OutputIt>::value_type blackhole_;
+
+ public:
+  using value_type = typename truncating_iterator_base<OutputIt>::value_type;
+
+  truncating_iterator() = default;
+
+  truncating_iterator(OutputIt out, size_t limit)
+      : truncating_iterator_base<OutputIt>(out, limit) {}
+
+  truncating_iterator& operator++() {
+    if (this->count_++ < this->limit_) ++this->out_;
+    return *this;
+  }
+
+  truncating_iterator operator++(int) {
+    auto it = *this;
+    ++*this;
+    return it;
+  }
+
+  value_type& operator*() const {
+    return this->count_ < this->limit_ ? *this->out_ : blackhole_;
+  }
+};
+
+template <typename OutputIt>
+class truncating_iterator<OutputIt, std::true_type>
+    : public truncating_iterator_base<OutputIt> {
+ public:
+  truncating_iterator() = default;
+
+  truncating_iterator(OutputIt out, size_t limit)
+      : truncating_iterator_base<OutputIt>(out, limit) {}
+
+  template <typename T> truncating_iterator& operator=(T val) {
+    if (this->count_++ < this->limit_) *this->out_++ = val;
+    return *this;
+  }
+
+  truncating_iterator& operator++() { return *this; }
+  truncating_iterator& operator++(int) { return *this; }
+  truncating_iterator& operator*() { return *this; }
+};

 // A compile-time string which is compiled into fast formatting code.
-FMT_EXPORT class compiled_string {};
+class compiled_string {};

 template <typename S>
 struct is_compiled_string : std::is_base_of<compiled_string, S> {};

-namespace detail {
-
 /**
- * Converts a string literal `s` into a format string that will be parsed at
- * compile time and converted into efficient formatting code. Requires C++17
- * `constexpr if` compiler support.
- *
- * **Example**:
- *
- *     // Converts 42 into std::string using the most efficient method and no
- *     // runtime format string processing.
- *     std::string s = fmt::format(FMT_COMPILE("{}"), 42);
+  \rst
+  Converts a string literal *s* into a format string that will be parsed at
+  compile time and converted into efficient formatting code. Requires C++17
+  ``constexpr if`` compiler support.
+
+  **Example**::
+
+    // Converts 42 into std::string using the most efficient method and no
+    // runtime format string processing.
+    std::string s = fmt::format(FMT_COMPILE("{}"), 42);
+  \endrst
 */
 #if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
-#  define FMT_COMPILE(s) FMT_STRING_IMPL(s, fmt::compiled_string)
+#  define FMT_COMPILE(s) \
+    FMT_STRING_IMPL(s, fmt::detail::compiled_string, explicit)
 #else
 #  define FMT_COMPILE(s) FMT_STRING(s)
 #endif

+#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;
+  explicit constexpr operator basic_string_view<char_type>() const {
+    return {Str.data, N - 1};
+  }
+};
+#endif
+
 template <typename T, typename... Tail>
-auto first(const T& value, const Tail&...) -> const T& {
+const T& first(const T& value, const Tail&...) {
  return value;
 }

@ -60,29 +153,6 @@ constexpr const auto& get([[maybe_unused]] const T& first,
    return detail::get<N - 1>(rest...);
 }

-#  if FMT_USE_NONTYPE_TEMPLATE_ARGS
-template <int N, typename T, typename... Args, typename Char>
-constexpr auto get_arg_index_by_name(basic_string_view<Char> name) -> int {
-  if constexpr (is_static_named_arg<T>()) {
-    if (name == T::name) return N;
-  }
-  if constexpr (sizeof...(Args) > 0)
-    return get_arg_index_by_name<N + 1, Args...>(name);
-  (void)name;  // Workaround an MSVC bug about "unused" parameter.
-  return -1;
-}
-#  endif
-
-template <typename... Args, typename Char>
-FMT_CONSTEXPR auto get_arg_index_by_name(basic_string_view<Char> name) -> int {
-#  if FMT_USE_NONTYPE_TEMPLATE_ARGS
-  if constexpr (sizeof...(Args) > 0)
-    return get_arg_index_by_name<0, Args...>(name);
-#  endif
-  (void)name;
-  return -1;
-}
-
 template <typename Char, typename... Args>
 constexpr int get_arg_index_by_name(basic_string_view<Char> name,
                                    type_list<Args...>) {
@ -126,8 +196,7 @@ template <typename Char> struct code_unit {

  template <typename OutputIt, typename... Args>
  constexpr OutputIt format(OutputIt out, const Args&...) const {
-    *out++ = value;
-    return out;
+    return write<Char>(out, value);
  }
 };

@ -151,13 +220,7 @@ template <typename Char, typename T, int N> struct field {

  template <typename OutputIt, typename... Args>
  constexpr OutputIt format(OutputIt out, const Args&... args) const {
-    const T& arg = get_arg_checked<T, N>(args...);
-    if constexpr (std::is_convertible<T, basic_string_view<Char>>::value) {
-      auto s = basic_string_view<Char>(arg);
-      return copy<Char>(s.begin(), s.end(), out);
-    } else {
-      return write<Char>(out, arg);
-    }
+    return write<Char>(out, get_arg_checked<T, N>(args...));
  }
 };

@ -245,12 +308,13 @@ constexpr size_t parse_text(basic_string_view<Char> str, size_t pos) {
 }

 template <typename Args, size_t POS, int ID, typename S>
-constexpr auto compile_format_string(S fmt);
+constexpr auto compile_format_string(S format_str);

 template <typename Args, size_t POS, int ID, typename T, typename S>
-constexpr auto parse_tail(T head, S fmt) {
-  if constexpr (POS != basic_string_view<typename S::char_type>(fmt).size()) {
-    constexpr auto tail = compile_format_string<Args, POS, ID>(fmt);
+constexpr auto parse_tail(T head, S format_str) {
+  if constexpr (POS !=
+                basic_string_view<typename S::char_type>(format_str).size()) {
+    constexpr auto tail = compile_format_string<Args, POS, ID>(format_str);
    if constexpr (std::is_same<remove_cvref_t<decltype(tail)>,
                               unknown_format>())
      return tail;
@ -267,14 +331,14 @@ template <typename T, typename Char> struct parse_specs_result {
  int next_arg_id;
 };

-enum { manual_indexing_id = -1 };
+constexpr int manual_indexing_id = -1;

 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 =
-      compile_parse_context<Char>(str, max_value<int>(), nullptr, 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()),
@ -282,36 +346,36 @@ constexpr parse_specs_result<T, Char> parse_specs(basic_string_view<Char> str,
 }

 template <typename Char> struct arg_id_handler {
-  arg_id_kind kind;
  arg_ref<Char> arg_id;

-  constexpr int on_auto() {
+  constexpr int operator()() {
    FMT_ASSERT(false, "handler cannot be used with automatic indexing");
    return 0;
  }
-  constexpr int on_index(int id) {
-    kind = arg_id_kind::index;
+  constexpr int operator()(int id) {
    arg_id = arg_ref<Char>(id);
    return 0;
  }
-  constexpr int on_name(basic_string_view<Char> id) {
-    kind = arg_id_kind::name;
+  constexpr int operator()(basic_string_view<Char> id) {
    arg_id = arg_ref<Char>(id);
    return 0;
  }
+
+  constexpr void on_error(const char* message) {
+    FMT_THROW(format_error(message));
+  }
 };

 template <typename Char> struct parse_arg_id_result {
-  arg_id_kind kind;
  arg_ref<Char> arg_id;
  const Char* arg_id_end;
 };

 template <int ID, typename Char>
 constexpr auto parse_arg_id(const Char* begin, const Char* end) {
-  auto handler = arg_id_handler<Char>{arg_id_kind::none, arg_ref<Char>{}};
+  auto handler = arg_id_handler<Char>{arg_ref<Char>{}};
  auto arg_id_end = parse_arg_id(begin, end, handler);
-  return parse_arg_id_result<Char>{handler.kind, handler.arg_id, arg_id_end};
+  return parse_arg_id_result<Char>{handler.arg_id, arg_id_end};
 }

 template <typename T, typename Enable = void> struct field_type {
@ -325,13 +389,14 @@ struct field_type<T, enable_if_t<detail::is_named_arg<T>::value>> {

 template <typename T, typename Args, size_t END_POS, int ARG_INDEX, int NEXT_ID,
          typename S>
-constexpr auto parse_replacement_field_then_tail(S fmt) {
+constexpr auto parse_replacement_field_then_tail(S format_str) {
  using char_type = typename S::char_type;
-  constexpr auto str = basic_string_view<char_type>(fmt);
+  constexpr auto str = basic_string_view<char_type>(format_str);
  constexpr char_type c = END_POS != str.size() ? str[END_POS] : char_type();
  if constexpr (c == '}') {
    return parse_tail<Args, END_POS + 1, NEXT_ID>(
-        field<char_type, typename field_type<T>::type, ARG_INDEX>(), fmt);
+        field<char_type, typename field_type<T>::type, ARG_INDEX>(),
+        format_str);
  } else if constexpr (c != ':') {
    FMT_THROW(format_error("expected ':'"));
  } else {
@ -344,7 +409,7 @@ constexpr auto parse_replacement_field_then_tail(S fmt) {
      return parse_tail<Args, result.end + 1, result.next_arg_id>(
          spec_field<char_type, typename field_type<T>::type, ARG_INDEX>{
              result.fmt},
-          fmt);
+          format_str);
    }
  }
 }
@ -352,21 +417,22 @@ constexpr auto parse_replacement_field_then_tail(S fmt) {
 // Compiles a non-empty format string and returns the compiled representation
 // or unknown_format() on unrecognized input.
 template <typename Args, size_t POS, int ID, typename S>
-constexpr auto compile_format_string(S fmt) {
+constexpr auto compile_format_string(S format_str) {
  using char_type = typename S::char_type;
-  constexpr auto str = basic_string_view<char_type>(fmt);
+  constexpr auto str = basic_string_view<char_type>(format_str);
  if constexpr (str[POS] == '{') {
    if constexpr (POS + 1 == str.size())
      FMT_THROW(format_error("unmatched '{' in format string"));
    if constexpr (str[POS + 1] == '{') {
-      return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), fmt);
+      return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), format_str);
    } else if constexpr (str[POS + 1] == '}' || str[POS + 1] == ':') {
      static_assert(ID != manual_indexing_id,
                    "cannot switch from manual to automatic argument indexing");
      constexpr auto next_id =
          ID != manual_indexing_id ? ID + 1 : manual_indexing_id;
      return parse_replacement_field_then_tail<get_type<ID, Args>, Args,
-                                               POS + 1, ID, next_id>(fmt);
+                                               POS + 1, ID, next_id>(
+          format_str);
    } else {
      constexpr auto arg_id_result =
          parse_arg_id<ID>(str.data() + POS + 1, str.data() + str.size());
@ -374,62 +440,68 @@ constexpr auto compile_format_string(S fmt) {
      constexpr char_type c =
          arg_id_end_pos != str.size() ? str[arg_id_end_pos] : char_type();
      static_assert(c == '}' || c == ':', "missing '}' in format string");
-      if constexpr (arg_id_result.kind == arg_id_kind::index) {
+      if constexpr (arg_id_result.arg_id.kind == arg_id_kind::index) {
        static_assert(
            ID == manual_indexing_id || ID == 0,
            "cannot switch from automatic to manual argument indexing");
-        constexpr auto arg_index = arg_id_result.arg_id.index;
+        constexpr auto arg_index = arg_id_result.arg_id.val.index;
        return parse_replacement_field_then_tail<get_type<arg_index, Args>,
                                                 Args, arg_id_end_pos,
                                                 arg_index, manual_indexing_id>(
-            fmt);
-      } else if constexpr (arg_id_result.kind == arg_id_kind::name) {
+            format_str);
+      } else if constexpr (arg_id_result.arg_id.kind == arg_id_kind::name) {
        constexpr auto arg_index =
-            get_arg_index_by_name(arg_id_result.arg_id.name, Args{});
-        if constexpr (arg_index >= 0) {
+            get_arg_index_by_name(arg_id_result.arg_id.val.name, Args{});
+        if constexpr (arg_index != invalid_arg_index) {
          constexpr auto next_id =
              ID != manual_indexing_id ? ID + 1 : manual_indexing_id;
          return parse_replacement_field_then_tail<
              decltype(get_type<arg_index, Args>::value), Args, arg_id_end_pos,
-              arg_index, next_id>(fmt);
-        } else if constexpr (c == '}') {
+              arg_index, next_id>(format_str);
+        } else {
+          if constexpr (c == '}') {
            return parse_tail<Args, arg_id_end_pos + 1, ID>(
-              runtime_named_field<char_type>{arg_id_result.arg_id.name}, fmt);
+                runtime_named_field<char_type>{arg_id_result.arg_id.val.name},
+                format_str);
          } else if constexpr (c == ':') {
            return unknown_format();  // no type info for specs parsing
          }
        }
      }
+    }
  } else if constexpr (str[POS] == '}') {
    if constexpr (POS + 1 == str.size())
      FMT_THROW(format_error("unmatched '}' in format string"));
-    return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), fmt);
+    return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), format_str);
  } else {
    constexpr auto end = parse_text(str, POS + 1);
    if constexpr (end - POS > 1) {
-      return parse_tail<Args, end, ID>(make_text(str, POS, end - POS), fmt);
+      return parse_tail<Args, end, ID>(make_text(str, POS, end - POS),
+                                       format_str);
    } else {
-      return parse_tail<Args, end, ID>(code_unit<char_type>{str[POS]}, fmt);
+      return parse_tail<Args, end, ID>(code_unit<char_type>{str[POS]},
+                                       format_str);
    }
  }
 }

 template <typename... Args, typename S,
-          FMT_ENABLE_IF(is_compiled_string<S>::value)>
-constexpr auto compile(S fmt) {
-  constexpr auto str = basic_string_view<typename S::char_type>(fmt);
+          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+constexpr auto compile(S format_str) {
+  constexpr auto str = basic_string_view<typename S::char_type>(format_str);
  if constexpr (str.size() == 0) {
    return detail::make_text(str, 0, 0);
  } else {
    constexpr auto result =
-        detail::compile_format_string<detail::type_list<Args...>, 0, 0>(fmt);
+        detail::compile_format_string<detail::type_list<Args...>, 0, 0>(
+            format_str);
    return result;
  }
 }
 #endif  // defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
 }  // namespace detail

-FMT_BEGIN_EXPORT
+FMT_MODULE_EXPORT_BEGIN

 #if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)

@ -451,7 +523,7 @@ constexpr FMT_INLINE OutputIt format_to(OutputIt out, const CompiledFormat& cf,
 }

 template <typename S, typename... Args,
-          FMT_ENABLE_IF(is_compiled_string<S>::value)>
+          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
 FMT_INLINE std::basic_string<typename S::char_type> format(const S&,
                                                           Args&&... args) {
  if constexpr (std::is_same<typename S::char_type, char>::value) {
@ -478,7 +550,7 @@ FMT_INLINE std::basic_string<typename S::char_type> format(const S&,
 }

 template <typename OutputIt, typename S, typename... Args,
-          FMT_ENABLE_IF(is_compiled_string<S>::value)>
+          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
 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)>,
@ -493,47 +565,47 @@ FMT_CONSTEXPR OutputIt format_to(OutputIt out, const S&, Args&&... args) {
 #endif

 template <typename OutputIt, typename S, typename... Args,
-          FMT_ENABLE_IF(is_compiled_string<S>::value)>
-auto format_to_n(OutputIt out, size_t n, const S& fmt, Args&&... args)
-    -> format_to_n_result<OutputIt> {
-  using traits = detail::fixed_buffer_traits;
-  auto buf = detail::iterator_buffer<OutputIt, char, traits>(out, n);
-  fmt::format_to(std::back_inserter(buf), fmt, std::forward<Args>(args)...);
-  return {buf.out(), buf.count()};
+          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 = 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(is_compiled_string<S>::value)>
-FMT_CONSTEXPR20 auto formatted_size(const S& fmt, const Args&... args)
-    -> size_t {
-  auto buf = detail::counting_buffer<>();
-  fmt::format_to(appender(buf), fmt, args...);
-  return buf.count();
+          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+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(is_compiled_string<S>::value)>
-void print(std::FILE* f, const S& fmt, const Args&... args) {
-  auto buf = memory_buffer();
-  fmt::format_to(appender(buf), fmt, args...);
-  detail::print(f, {buf.data(), buf.size()});
+          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+void print(std::FILE* f, const S& format_str, const Args&... args) {
+  memory_buffer buffer;
+  fmt::format_to(std::back_inserter(buffer), format_str, args...);
+  detail::print(f, {buffer.data(), buffer.size()});
 }

 template <typename S, typename... Args,
-          FMT_ENABLE_IF(is_compiled_string<S>::value)>
-void print(const S& fmt, const Args&... args) {
-  print(stdout, fmt, args...);
+          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+void print(const S& format_str, const Args&... args) {
+  print(stdout, format_str, args...);
 }

 #if FMT_USE_NONTYPE_TEMPLATE_ARGS
 inline namespace literals {
-template <detail::fixed_string Str> constexpr auto operator""_cf() {
-  return FMT_COMPILE(Str.data);
+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

-FMT_END_EXPORT
+FMT_MODULE_EXPORT_END
 FMT_END_NAMESPACE

 #endif  // FMT_COMPILE_H_
--- 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/locale.h
+++ b/include/spdlog/fmt/bundled/locale.h
@ -0,0 +1,2 @@
+#include "xchar.h"
+#warning fmt/locale.h is deprecated, include fmt/format.h or fmt/xchar.h instead
--- a/include/spdlog/fmt/bundled/os.h
+++ b/include/spdlog/fmt/bundled/os.h
@ -8,19 +8,17 @@
 #ifndef FMT_OS_H_
 #define FMT_OS_H_

+#include <cerrno>
+#include <cstddef>
+#include <cstdio>
+#include <system_error>  // std::system_error
+
+#if defined __APPLE__ || defined(__FreeBSD__)
+#  include <xlocale.h>  // for LC_NUMERIC_MASK on OS X
+#endif
+
 #include "format.h"

-#ifndef FMT_MODULE
-#  include <cerrno>
-#  include <cstddef>
-#  include <cstdio>
-#  include <system_error>  // std::system_error
-
-#  if FMT_HAS_INCLUDE(<xlocale.h>)
-#    include <xlocale.h>  // LC_NUMERIC_MASK on macOS
-#  endif
-#endif  // FMT_MODULE
-
 #ifndef FMT_USE_FCNTL
 // UWP doesn't provide _pipe.
 #  if FMT_HAS_INCLUDE("winapifamily.h")
@ -48,7 +46,6 @@

 // Calls to system functions are wrapped in FMT_SYSTEM for testability.
 #ifdef FMT_SYSTEM
-#  define FMT_HAS_SYSTEM
 #  define FMT_POSIX_CALL(call) FMT_SYSTEM(call)
 #else
 #  define FMT_SYSTEM(call) ::call
@ -74,89 +71,143 @@
 #define FMT_RETRY(result, expression) FMT_RETRY_VAL(result, expression, -1)

 FMT_BEGIN_NAMESPACE
-FMT_BEGIN_EXPORT
+FMT_MODULE_EXPORT_BEGIN

 /**
- * A reference to a null-terminated string. It can be constructed from a C
- * string or `std::string`.
- *
- * You can use one of the following type aliases for common character types:
- *
- * +---------------+-----------------------------+
- * | Type          | Definition                  |
- * +===============+=============================+
- * | cstring_view  | basic_cstring_view<char>    |
- * +---------------+-----------------------------+
- * | wcstring_view | basic_cstring_view<wchar_t> |
- * +---------------+-----------------------------+
- *
- * This class is most useful as a parameter type for functions that wrap C APIs.
+  \rst
+  A reference to a null-terminated string. It can be constructed from a C
+  string or ``std::string``.
+
+  You can use one of the following type aliases for common character types:
+
+  +---------------+-----------------------------+
+  | Type          | Definition                  |
+  +===============+=============================+
+  | cstring_view  | basic_cstring_view<char>    |
+  +---------------+-----------------------------+
+  | wcstring_view | basic_cstring_view<wchar_t> |
+  +---------------+-----------------------------+
+
+  This class is most useful as a parameter type to allow passing
+  different types of strings to a function, for example::
+
+    template <typename... Args>
+    std::string format(cstring_view format_str, const Args & ... args);
+
+    format("{}", 42);
+    format(std::string("{}"), 42);
+  \endrst
 */
 template <typename Char> class basic_cstring_view {
 private:
  const Char* data_;

 public:
-  /// Constructs a string reference object from a C string.
+  /** Constructs a string reference object from a C string. */
  basic_cstring_view(const Char* s) : data_(s) {}

-  /// Constructs a string reference from an `std::string` object.
+  /**
+    \rst
+    Constructs a string reference from an ``std::string`` object.
+    \endrst
+   */
  basic_cstring_view(const std::basic_string<Char>& s) : data_(s.c_str()) {}

-  /// Returns the pointer to a C string.
-  auto c_str() const -> const Char* { return data_; }
+  /** Returns the pointer to a C string. */
+  const Char* c_str() const { return data_; }
 };

 using cstring_view = basic_cstring_view<char>;
 using wcstring_view = basic_cstring_view<wchar_t>;

+template <typename Char> struct formatter<std::error_code, Char> {
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+
+  template <typename FormatContext>
+  FMT_CONSTEXPR auto format(const std::error_code& ec, FormatContext& ctx) const
+      -> decltype(ctx.out()) {
+    auto out = ctx.out();
+    out = detail::write_bytes(out, ec.category().name(),
+                              basic_format_specs<Char>());
+    out = detail::write<Char>(out, Char(':'));
+    out = detail::write<Char>(out, ec.value());
+    return out;
+  }
+};
+
 #ifdef _WIN32
 FMT_API const std::error_category& system_category() noexcept;

-namespace detail {
+FMT_BEGIN_DETAIL_NAMESPACE
+// A converter from UTF-16 to UTF-8.
+// It is only provided for Windows since other systems support UTF-8 natively.
+class utf16_to_utf8 {
+ private:
+  memory_buffer buffer_;
+
+ public:
+  utf16_to_utf8() {}
+  FMT_API explicit utf16_to_utf8(basic_string_view<wchar_t> s);
+  operator string_view() const { return string_view(&buffer_[0], size()); }
+  size_t size() const { return buffer_.size() - 1; }
+  const char* c_str() const { return &buffer_[0]; }
+  std::string str() const { return std::string(&buffer_[0], size()); }
+
+  // Performs conversion returning a system error code instead of
+  // throwing exception on conversion error. This method may still throw
+  // in case of memory allocation error.
+  FMT_API int convert(basic_string_view<wchar_t> s);
+};
+
 FMT_API void format_windows_error(buffer<char>& out, int error_code,
                                  const char* message) noexcept;
-}
+FMT_END_DETAIL_NAMESPACE

-FMT_API std::system_error vwindows_error(int error_code, string_view fmt,
+FMT_API std::system_error vwindows_error(int error_code, string_view format_str,
                                         format_args args);

 /**
- * Constructs a `std::system_error` object with the description of the form
- *
- *     <message>: <system-message>
- *
- * where `<message>` is the formatted message and `<system-message>` is the
- * system message corresponding to the error code.
- * `error_code` is a Windows error code as given by `GetLastError`.
- * If `error_code` is not a valid error code such as -1, the system message
- * will look like "error -1".
- *
- * **Example**:
- *
- *     // This throws a system_error with the description
- *     //   cannot open file 'madeup': The system cannot find the file
- * specified.
- *     // or similar (system message may vary).
- *     const char *filename = "madeup";
- *     LPOFSTRUCT of = LPOFSTRUCT();
- *     HFILE file = OpenFile(filename, &of, OF_READ);
- *     if (file == HFILE_ERROR) {
- *       throw fmt::windows_error(GetLastError(),
- *                                "cannot open file '{}'", filename);
- *     }
- */
-template <typename... T>
-auto windows_error(int error_code, string_view message, const T&... args)
-    -> std::system_error {
-  return vwindows_error(error_code, message, vargs<T...>{{args...}});
+ \rst
+ Constructs a :class:`std::system_error` object with the description
+ of the form
+
+ .. parsed-literal::
+   *<message>*: *<system-message>*
+
+ where *<message>* is the formatted message and *<system-message>* is the
+ system message corresponding to the error code.
+ *error_code* is a Windows error code as given by ``GetLastError``.
+ If *error_code* is not a valid error code such as -1, the system message
+ will look like "error -1".
+
+ **Example**::
+
+   // This throws a system_error with the description
+   //   cannot open file 'madeup': The system cannot find the file specified.
+   // or similar (system message may vary).
+   const char *filename = "madeup";
+   LPOFSTRUCT of = LPOFSTRUCT();
+   HFILE file = OpenFile(filename, &of, OF_READ);
+   if (file == HFILE_ERROR) {
+     throw fmt::windows_error(GetLastError(),
+                              "cannot open file '{}'", filename);
+   }
+ \endrst
+*/
+template <typename... Args>
+std::system_error windows_error(int error_code, string_view message,
+                                const Args&... args) {
+  return vwindows_error(error_code, message, fmt::make_format_args(args...));
 }

 // 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) noexcept;
 #else
-inline auto system_category() noexcept -> const std::error_category& {
+inline const std::error_category& system_category() noexcept {
  return std::system_category();
 }
 #endif  // _WIN32
@ -164,8 +215,8 @@ inline auto system_category() noexcept -> const std::error_category& {
 // std::system is not available on some platforms such as iOS (#2248).
 #ifdef __OSX__
 template <typename S, typename... Args, typename Char = char_t<S>>
-void say(const S& fmt, Args&&... args) {
-  std::system(format("say \"{}\"", format(fmt, args...)).c_str());
+void say(const S& format_str, Args&&... args) {
+  std::system(format("say \"{}\"", format(format_str, args...)).c_str());
 }
 #endif

@ -176,24 +227,24 @@ class buffered_file {

  friend class file;

-  inline explicit buffered_file(FILE* f) : file_(f) {}
+  explicit buffered_file(FILE* f) : file_(f) {}

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

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

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

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

-  inline auto operator=(buffered_file&& other) -> buffered_file& {
+  buffered_file& operator=(buffered_file&& other) {
    close();
    file_ = other.file_;
    other.file_ = nullptr;
@ -207,20 +258,21 @@ class buffered_file {
  FMT_API void close();

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

-  FMT_API auto descriptor() const -> int;
+  FMT_API int descriptor() const;

-  template <typename... T>
-  inline void print(string_view fmt, const T&... args) {
-    fmt::vargs<T...> vargs = {{args...}};
-    detail::is_locking<T...>() ? fmt::vprint_buffered(file_, fmt, vargs)
-                               : fmt::vprint(file_, fmt, vargs);
+  void vprint(string_view format_str, format_args args) {
+    fmt::vprint(file_, format_str, args);
+  }
+
+  template <typename... Args>
+  inline void print(string_view format_str, const Args&... args) {
+    vprint(format_str, fmt::make_format_args(args...));
  }
 };

 #if FMT_USE_FCNTL
-
 // A file. Closed file is represented by a file object with descriptor -1.
 // Methods that are not declared with noexcept may throw
 // fmt::system_error in case of failure. Note that some errors such as
@ -234,8 +286,6 @@ class FMT_API file {
  // Constructs a file object with a given descriptor.
  explicit file(int fd) : fd_(fd) {}

-  friend struct pipe;
-
 public:
  // Possible values for the oflag argument to the constructor.
  enum {
@ -248,7 +298,7 @@ class FMT_API file {
  };

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

  // Opens a file and constructs a file object representing this file.
  file(cstring_view path, int oflag);
@ -257,10 +307,10 @@ class FMT_API file {
  file(const file&) = delete;
  void operator=(const file&) = delete;

-  inline file(file&& other) 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.
-  inline auto operator=(file&& other) -> file& {
+  file& operator=(file&& other) {
    close();
    fd_ = other.fd_;
    other.fd_ = -1;
@ -271,24 +321,24 @@ class FMT_API file {
  ~file() noexcept;

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

  // Closes the file.
  void close();

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

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

  // Attempts to write count bytes from the specified buffer to the file.
-  auto write(const void* buffer, size_t count) -> size_t;
+  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.
-  static auto dup(int fd) -> file;
+  static file dup(int fd);

  // Makes fd be the copy of this file descriptor, closing fd first if
  // necessary.
@ -298,35 +348,24 @@ class FMT_API file {
  // necessary.
  void dup2(int fd, std::error_code& ec) noexcept;

-  // Creates a buffered_file object associated with this file and detaches
-  // this file object from the file.
-  auto fdopen(const char* mode) -> buffered_file;
-
-#  if defined(_WIN32) && !defined(__MINGW32__)
-  // Opens a file and constructs a file object representing this file by
-  // wcstring_view filename. Windows only.
-  static file open_windows_file(wcstring_view path, int oflag);
-#  endif
-};
-
-struct FMT_API pipe {
-  file read_end;
-  file write_end;
-
  // Creates a pipe setting up read_end and write_end file objects for reading
  // and writing respectively.
-  pipe();
+  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.
+  buffered_file fdopen(const char* mode);
 };

 // Returns the memory page size.
-auto getpagesize() -> long;
+long getpagesize();

-namespace detail {
+FMT_BEGIN_DETAIL_NAMESPACE

 struct buffer_size {
-  constexpr buffer_size() = default;
+  buffer_size() = default;
  size_t value = 0;
-  FMT_CONSTEXPR auto operator=(size_t val) const -> buffer_size {
+  buffer_size operator=(size_t val) const {
    auto bs = buffer_size();
    bs.value = val;
    return bs;
@ -337,7 +376,7 @@ struct ostream_params {
  int oflag = file::WRONLY | file::CREATE | file::TRUNC;
  size_t buffer_size = BUFSIZ > 32768 ? BUFSIZ : 32768;

-  constexpr ostream_params() {}
+  ostream_params() {}

  template <typename... T>
  ostream_params(T... params, int new_oflag) : ostream_params(params...) {
@ -358,70 +397,82 @@ struct ostream_params {
 #  endif
 };

-}  // namespace detail
+FMT_END_DETAIL_NAMESPACE

-FMT_INLINE_VARIABLE constexpr auto buffer_size = detail::buffer_size();
+// Added {} below to work around default constructor error known to
+// occur in Xcode versions 7.2.1 and 8.2.1.
+constexpr detail::buffer_size buffer_size{};

-/// A fast buffered output stream for writing from a single thread. Writing from
-/// multiple threads without external synchronization may result in a data race.
-class FMT_API ostream : private detail::buffer<char> {
+/** A fast output stream which is not thread-safe. */
+class FMT_API ostream final : private detail::buffer<char> {
 private:
  file file_;

-  ostream(cstring_view path, const detail::ostream_params& params);
+  void grow(size_t) override;

-  static void grow(buffer<char>& buf, size_t);
-
- public:
-  ostream(ostream&& other) noexcept;
-  ~ostream();
-
-  operator writer() {
-    detail::buffer<char>& buf = *this;
-    return buf;
+  ostream(cstring_view path, const detail::ostream_params& params)
+      : file_(path, params.oflag) {
+    set(new char[params.buffer_size], params.buffer_size);
  }

-  inline void flush() {
+ public:
+  ostream(ostream&& other)
+      : detail::buffer<char>(other.data(), other.size(), other.capacity()),
+        file_(std::move(other.file_)) {
+    other.clear();
+    other.set(nullptr, 0);
+  }
+  ~ostream() {
+    flush();
+    delete[] data();
+  }
+
+  void flush() {
    if (size() == 0) return;
-    file_.write(data(), size() * sizeof(data()[0]));
+    file_.write(data(), size());
    clear();
  }

  template <typename... T>
-  friend auto output_file(cstring_view path, T... params) -> ostream;
+  friend ostream output_file(cstring_view path, T... params);

-  inline void close() {
+  void close() {
    flush();
    file_.close();
  }

-  /// Formats `args` according to specifications in `fmt` and writes the
-  /// output to the file.
+  /**
+    Formats ``args`` according to specifications in ``fmt`` and writes the
+    output to the file.
+   */
  template <typename... T> void print(format_string<T...> fmt, T&&... args) {
-    vformat_to(appender(*this), fmt.str, vargs<T...>{{args...}});
+    vformat_to(detail::buffer_appender<char>(*this), fmt,
+               fmt::make_format_args(args...));
  }
 };

 /**
- * Opens a file for writing. Supported parameters passed in `params`:
- *
- * - `<integer>`: Flags passed to [open](
- *   https://pubs.opengroup.org/onlinepubs/007904875/functions/open.html)
- *   (`file::WRONLY | file::CREATE | file::TRUNC` by default)
- * - `buffer_size=<integer>`: Output buffer size
- *
- * **Example**:
- *
- *     auto out = fmt::output_file("guide.txt");
- *     out.print("Don't {}", "Panic");
+  \rst
+  Opens a file for writing. Supported parameters passed in *params*:
+
+  * ``<integer>``: Flags passed to `open
+    <https://pubs.opengroup.org/onlinepubs/007904875/functions/open.html>`_
+    (``file::WRONLY | file::CREATE | file::TRUNC`` by default)
+  * ``buffer_size=<integer>``: Output buffer size
+
+  **Example**::
+
+    auto out = fmt::output_file("guide.txt");
+    out.print("Don't {}", "Panic");
+  \endrst
 */
 template <typename... T>
-inline auto output_file(cstring_view path, T... params) -> ostream {
+inline ostream output_file(cstring_view path, T... params) {
  return {path, detail::ostream_params(params...)};
 }
 #endif  // FMT_USE_FCNTL

-FMT_END_EXPORT
+FMT_MODULE_EXPORT_END
 FMT_END_NAMESPACE

 #endif  // FMT_OS_H_
--- a/include/spdlog/fmt/bundled/ostream.h
+++ b/include/spdlog/fmt/bundled/ostream.h
@ -8,53 +8,108 @@
 #ifndef FMT_OSTREAM_H_
 #define FMT_OSTREAM_H_

-#ifndef FMT_MODULE
-#  include <fstream>  // std::filebuf
-#endif
-
-#ifdef _WIN32
-#  ifdef __GLIBCXX__
+#include <fstream>
+#include <ostream>
+#if defined(_WIN32) && defined(__GLIBCXX__)
 #  include <ext/stdio_filebuf.h>
 #  include <ext/stdio_sync_filebuf.h>
-#  endif
-#  include <io.h>
+#elif defined(_WIN32) && defined(_LIBCPP_VERSION)
+#  include <__std_stream>
 #endif

-#include "chrono.h"  // formatbuf
-
-#ifdef _MSVC_STL_UPDATE
-#  define FMT_MSVC_STL_UPDATE _MSVC_STL_UPDATE
-#elif defined(_MSC_VER) && _MSC_VER < 1912  // VS 15.5
-#  define FMT_MSVC_STL_UPDATE _MSVC_LANG
-#else
-#  define FMT_MSVC_STL_UPDATE 0
-#endif
+#include "format.h"

 FMT_BEGIN_NAMESPACE
+
+template <typename OutputIt, typename Char> class basic_printf_context;
+
 namespace detail {

+// Checks if T has a user-defined operator<<.
+template <typename T, typename Char, typename Enable = void>
+class is_streamable {
+ private:
+  template <typename U>
+  static auto test(int)
+      -> bool_constant<sizeof(std::declval<std::basic_ostream<Char>&>()
+                              << std::declval<U>()) != 0>;
+
+  template <typename> static auto test(...) -> std::false_type;
+
+  using result = decltype(test<T>(0));
+
+ public:
+  is_streamable() = default;
+
+  static const bool value = result::value;
+};
+
+// Formatting of built-in types and arrays is intentionally disabled because
+// it's handled by standard (non-ostream) formatters.
+template <typename T, typename Char>
+struct is_streamable<
+    T, Char,
+    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_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 <typename Tag, typename BufType, FILE* BufType::*FileMemberPtr>
+template <class Tag, class BufType, FILE* BufType::*FileMemberPtr>
 class file_access {
  friend auto get_file(BufType& obj) -> FILE* { return obj.*FileMemberPtr; }
 };

-#if FMT_MSVC_STL_UPDATE
+#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>
 void write_buffer(std::basic_ostream<Char>& os, buffer<Char>& buf) {
  const Char* buf_data = buf.data();
-  using unsigned_streamsize = make_unsigned_t<std::streamsize>;
+  using unsigned_streamsize = std::make_unsigned<std::streamsize>::type;
  unsigned_streamsize size = buf.size();
  unsigned_streamsize max_size = to_unsigned(max_value<std::streamsize>());
  do {
@ -65,9 +120,20 @@ void write_buffer(std::basic_ostream<Char>& os, buffer<Char>& buf) {
  } while (size != 0);
 }

-template <typename T> struct streamed_view {
-  const T& value;
-};
+template <typename Char, typename T>
+void format_value(buffer<Char>& buf, const T& value,
+                  locale_ref loc = locale_ref()) {
+  auto&& format_buf = formatbuf<std::basic_streambuf<Char>>(buf);
+  auto&& output = std::basic_ostream<Char>(&format_buf);
+#if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
+  if (loc) output.imbue(loc.get<std::locale>());
+#endif
+  output << value;
+  output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
+}
+
+template <typename T> struct streamed_view { const T& value; };
+
 }  // namespace detail

 // Formats an object of type T that has an overloaded ostream operator<<.
@ -75,14 +141,11 @@ template <typename Char>
 struct basic_ostream_formatter : formatter<basic_string_view<Char>, Char> {
  void set_debug_format() = delete;

-  template <typename T, typename Context>
-  auto format(const T& value, Context& ctx) const -> decltype(ctx.out()) {
+  template <typename T, typename OutputIt>
+  auto format(const T& value, basic_format_context<OutputIt, Char>& ctx) const
+      -> OutputIt {
    auto buffer = basic_memory_buffer<Char>();
-    auto&& formatbuf = detail::formatbuf<std::basic_streambuf<Char>>(buffer);
-    auto&& output = std::basic_ostream<Char>(&formatbuf);
-    output.imbue(std::locale::classic());  // The default is always unlocalized.
-    output << value;
-    output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
+    format_value(buffer, value, ctx.locale());
    return formatter<basic_string_view<Char>, Char>::format(
        {buffer.data(), buffer.size()}, ctx);
  }
@ -93,72 +156,80 @@ 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 Context>
-  auto format(detail::streamed_view<T> view, Context& ctx) const
-      -> decltype(ctx.out()) {
+  template <typename OutputIt>
+  auto format(detail::streamed_view<T> view,
+              basic_format_context<OutputIt, Char>& ctx) const -> OutputIt {
    return basic_ostream_formatter<Char>::format(view.value, ctx);
  }
 };

 /**
- * Returns a view that formats `value` via an ostream `operator<<`.
- *
- * **Example**:
- *
- *     fmt::print("Current thread id: {}\n",
- *                fmt::streamed(std::this_thread::get_id()));
+  \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>
-constexpr auto streamed(const T& value) -> detail::streamed_view<T> {
+auto streamed(const T& value) -> detail::streamed_view<T> {
  return {value};
 }

-inline void vprint(std::ostream& os, string_view fmt, format_args args) {
+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, fmt, args);
-  FILE* f = nullptr;
-#if FMT_MSVC_STL_UPDATE && FMT_USE_RTTI
-  if (auto* buf = dynamic_cast<std::filebuf*>(os.rdbuf()))
-    f = detail::get_file(*buf);
-#elif defined(_WIN32) && defined(__GLIBCXX__) && FMT_USE_RTTI
-  auto* rdbuf = os.rdbuf();
-  if (auto* sfbuf = dynamic_cast<__gnu_cxx::stdio_sync_filebuf<char>*>(rdbuf))
-    f = sfbuf->file();
-  else if (auto* fbuf = dynamic_cast<__gnu_cxx::stdio_filebuf<char>*>(rdbuf))
-    f = fbuf->file();
-#endif
-#ifdef _WIN32
-  if (f) {
-    int fd = _fileno(f);
-    if (_isatty(fd)) {
-      os.flush();
-      if (detail::write_console(fd, {buffer.data(), buffer.size()})) return;
-    }
-  }
-#endif
-  detail::ignore_unused(f);
+  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<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);
 }

 /**
- * Prints formatted data to the stream `os`.
- *
- * **Example**:
- *
- *     fmt::print(cerr, "Don't {}!", "panic");
+  \rst
+  Prints formatted data to the stream *os*.
+
+  **Example**::
+
+    fmt::print(cerr, "Don't {}!", "panic");
+  \endrst
 */
-FMT_EXPORT template <typename... T>
+FMT_MODULE_EXPORT template <typename... T>
 void print(std::ostream& os, format_string<T...> fmt, T&&... args) {
-  fmt::vargs<T...> vargs = {{args...}};
-  if (detail::const_check(detail::use_utf8)) return vprint(os, fmt.str, vargs);
-  auto buffer = memory_buffer();
-  detail::vformat_to(buffer, fmt.str, vargs);
-  detail::write_buffer(os, buffer);
+  const auto& vargs = fmt::make_format_args(args...);
+  if (detail::is_utf8())
+    vprint(os, fmt, vargs);
+  else
+    detail::vprint_directly(os, fmt, vargs);
 }

-FMT_EXPORT template <typename... T>
-void println(std::ostream& os, format_string<T...> fmt, T&&... args) {
-  fmt::print(os, "{}\n", fmt::format(fmt, std::forward<T>(args)...));
+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
--- a/include/spdlog/fmt/bundled/printf.h
+++ b/include/spdlog/fmt/bundled/printf.h
@ -8,121 +8,107 @@
 #ifndef FMT_PRINTF_H_
 #define FMT_PRINTF_H_

-#ifndef FMT_MODULE
-#  include <algorithm>  // std::max
-#  include <limits>     // std::numeric_limits
-#endif
+#include <algorithm>  // std::max
+#include <limits>     // std::numeric_limits

 #include "format.h"

 FMT_BEGIN_NAMESPACE
-FMT_BEGIN_EXPORT
+FMT_MODULE_EXPORT_BEGIN

-template <typename T> struct printf_formatter {
-  printf_formatter() = delete;
+template <typename T> struct printf_formatter { printf_formatter() = delete; };
+
+template <typename Char>
+class basic_printf_parse_context : public basic_format_parse_context<Char> {
+  using basic_format_parse_context<Char>::basic_format_parse_context;
 };

-template <typename Char> class basic_printf_context {
+template <typename OutputIt, typename Char> class basic_printf_context {
 private:
-  basic_appender<Char> out_;
+  OutputIt out_;
  basic_format_args<basic_printf_context> args_;

-  static_assert(std::is_same<Char, char>::value ||
-                    std::is_same<Char, wchar_t>::value,
-                "Unsupported code unit type.");
-
 public:
  using char_type = Char;
-  using parse_context_type = parse_context<Char>;
+  using format_arg = basic_format_arg<basic_printf_context>;
+  using parse_context_type = basic_printf_parse_context<Char>;
  template <typename T> using formatter_type = printf_formatter<T>;
-  enum { builtin_types = 1 };

-  /// Constructs a `printf_context` object. References to the arguments are
-  /// stored in the context object so make sure they have appropriate lifetimes.
-  basic_printf_context(basic_appender<Char> out,
+  /**
+    \rst
+    Constructs a ``printf_context`` object. References to the arguments are
+    stored in the context object so make sure they have appropriate lifetimes.
+    \endrst
+   */
+  basic_printf_context(OutputIt out,
                       basic_format_args<basic_printf_context> args)
      : out_(out), args_(args) {}

-  auto out() -> basic_appender<Char> { return out_; }
-  void advance_to(basic_appender<Char>) {}
+  OutputIt out() { return out_; }
+  void advance_to(OutputIt it) { out_ = it; }

-  auto locale() -> detail::locale_ref { return {}; }
+  detail::locale_ref locale() { return {}; }

-  auto arg(int id) const -> basic_format_arg<basic_printf_context> {
-    return args_.get(id);
+  format_arg arg(int id) const { return args_.get(id); }
+
+  FMT_CONSTEXPR void on_error(const char* message) {
+    detail::error_handler().on_error(message);
  }
 };

-namespace detail {
-
-// Return the result via the out param to workaround gcc bug 77539.
-template <bool IS_CONSTEXPR, typename T, typename Ptr = const T*>
-FMT_CONSTEXPR auto find(Ptr first, Ptr last, T value, Ptr& out) -> bool {
-  for (out = first; out != last; ++out) {
-    if (*out == value) return true;
-  }
-  return false;
-}
-
-template <>
-inline auto find<false, char>(const char* first, const char* last, char value,
-                              const char*& out) -> bool {
-  out =
-      static_cast<const char*>(memchr(first, value, to_unsigned(last - first)));
-  return out != nullptr;
-}
+FMT_BEGIN_DETAIL_NAMESPACE

 // Checks if a value fits in int - used to avoid warnings about comparing
 // signed and unsigned integers.
 template <bool IsSigned> struct int_checker {
-  template <typename T> static auto fits_in_int(T value) -> bool {
-    unsigned max = to_unsigned(max_value<int>());
+  template <typename T> static bool fits_in_int(T value) {
+    unsigned max = max_value<int>();
    return value <= max;
  }
-  inline static auto fits_in_int(bool) -> bool { return true; }
+  static bool fits_in_int(bool) { return true; }
 };

 template <> struct int_checker<true> {
-  template <typename T> static auto fits_in_int(T value) -> bool {
+  template <typename T> static bool fits_in_int(T value) {
    return value >= (std::numeric_limits<int>::min)() &&
           value <= max_value<int>();
  }
-  inline static auto fits_in_int(int) -> bool { return true; }
+  static bool fits_in_int(int) { return true; }
 };

-struct printf_precision_handler {
+class printf_precision_handler {
+ public:
  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-  auto operator()(T value) -> int {
+  int operator()(T value) {
    if (!int_checker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
-      report_error("number is too big");
+      FMT_THROW(format_error("number is too big"));
    return (std::max)(static_cast<int>(value), 0);
  }

  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
-  auto operator()(T) -> int {
-    report_error("precision is not integer");
+  int operator()(T) {
+    FMT_THROW(format_error("precision is not integer"));
    return 0;
  }
 };

 // An argument visitor that returns true iff arg is a zero integer.
-struct is_zero_int {
+class is_zero_int {
+ public:
  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-  auto operator()(T value) -> bool {
+  bool operator()(T value) {
    return value == 0;
  }

  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
-  auto operator()(T) -> bool {
+  bool operator()(T) {
    return false;
  }
 };

 template <typename T> struct make_unsigned_or_bool : std::make_unsigned<T> {};

-template <> struct make_unsigned_or_bool<bool> {
-  using type = bool;
-};
+template <> struct make_unsigned_or_bool<bool> { using type = bool; };

 template <typename T, typename Context> class arg_converter {
 private:
@ -145,19 +131,24 @@ template <typename T, typename Context> class arg_converter {
    using target_type = conditional_t<std::is_same<T, void>::value, U, T>;
    if (const_check(sizeof(target_type) <= sizeof(int))) {
      // Extra casts are used to silence warnings.
-      using unsigned_type = typename make_unsigned_or_bool<target_type>::type;
-      if (is_signed)
-        arg_ = static_cast<int>(static_cast<target_type>(value));
-      else
-        arg_ = static_cast<unsigned>(static_cast<unsigned_type>(value));
+      if (is_signed) {
+        arg_ = detail::make_arg<Context>(
+            static_cast<int>(static_cast<target_type>(value)));
      } else {
+        using unsigned_type = typename make_unsigned_or_bool<target_type>::type;
+        arg_ = detail::make_arg<Context>(
+            static_cast<unsigned>(static_cast<unsigned_type>(value)));
+      }
+    } else {
+      if (is_signed) {
        // glibc's printf doesn't sign extend arguments of smaller types:
        //   std::printf("%lld", -42);  // prints "4294967254"
        // but we don't have to do the same because it's a UB.
-      if (is_signed)
-        arg_ = static_cast<long long>(value);
-      else
-        arg_ = static_cast<typename make_unsigned_or_bool<U>::type>(value);
+        arg_ = detail::make_arg<Context>(static_cast<long long>(value));
+      } else {
+        arg_ = detail::make_arg<Context>(
+            static_cast<typename make_unsigned_or_bool<U>::type>(value));
+      }
    }
  }

@ -171,7 +162,7 @@ template <typename T, typename Context> class arg_converter {
 // unsigned).
 template <typename T, typename Context, typename Char>
 void convert_arg(basic_format_arg<Context>& arg, Char type) {
-  arg.visit(arg_converter<T, Context>(arg, type));
+  visit_format_arg(arg_converter<T, Context>(arg, type), arg);
 }

 // Converts an integer argument to char for printf.
@ -184,7 +175,8 @@ template <typename Context> class char_converter {

  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
  void operator()(T value) {
-    arg_ = static_cast<typename Context::char_type>(value);
+    arg_ = detail::make_arg<Context>(
+        static_cast<typename Context::char_type>(value));
  }

  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
@ -194,148 +186,150 @@ template <typename Context> class char_converter {
 // An argument visitor that return a pointer to a C string if argument is a
 // string or null otherwise.
 template <typename Char> struct get_cstring {
-  template <typename T> auto operator()(T) -> const Char* { return nullptr; }
-  auto operator()(const Char* s) -> const Char* { return s; }
+  template <typename T> const Char* operator()(T) { return nullptr; }
+  const Char* operator()(const Char* s) { return s; }
 };

 // Checks if an argument is a valid printf width specifier and sets
 // left alignment if it is negative.
-class printf_width_handler {
+template <typename Char> class printf_width_handler {
 private:
+  using format_specs = basic_format_specs<Char>;
+
  format_specs& specs_;

 public:
-  inline explicit printf_width_handler(format_specs& specs) : specs_(specs) {}
+  explicit printf_width_handler(format_specs& specs) : specs_(specs) {}

  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-  auto operator()(T value) -> unsigned {
+  unsigned operator()(T value) {
    auto width = static_cast<uint32_or_64_or_128_t<T>>(value);
    if (detail::is_negative(value)) {
-      specs_.set_align(align::left);
+      specs_.align = align::left;
      width = 0 - width;
    }
-    unsigned int_max = to_unsigned(max_value<int>());
-    if (width > int_max) report_error("number is too big");
+    unsigned int_max = max_value<int>();
+    if (width > int_max) FMT_THROW(format_error("number is too big"));
    return static_cast<unsigned>(width);
  }

  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
-  auto operator()(T) -> unsigned {
-    report_error("width is not integer");
+  unsigned operator()(T) {
+    FMT_THROW(format_error("width is not integer"));
    return 0;
  }
 };

-// Workaround for a bug with the XL compiler when initializing
-// printf_arg_formatter's base class.
-template <typename Char>
-auto make_arg_formatter(basic_appender<Char> iter, format_specs& s)
-    -> arg_formatter<Char> {
-  return {iter, s, locale_ref()};
-}
-
-// The `printf` argument formatter.
-template <typename Char>
+// The ``printf`` argument formatter.
+template <typename OutputIt, typename Char>
 class printf_arg_formatter : public arg_formatter<Char> {
 private:
  using base = arg_formatter<Char>;
-  using context_type = basic_printf_context<Char>;
+  using context_type = basic_printf_context<OutputIt, Char>;
+  using format_specs = basic_format_specs<Char>;

  context_type& context_;

-  void write_null_pointer(bool is_string = false) {
+  OutputIt write_null_pointer(bool is_string = false) {
    auto s = this->specs;
-    s.set_type(presentation_type::none);
-    write_bytes<Char>(this->out, is_string ? "(null)" : "(nil)", s);
-  }
-
-  template <typename T> void write(T value) {
-    detail::write<Char>(this->out, value, this->specs, this->locale);
+    s.type = presentation_type::none;
+    return write_bytes(this->out, is_string ? "(null)" : "(nil)", s);
  }

 public:
-  printf_arg_formatter(basic_appender<Char> iter, format_specs& s,
-                       context_type& ctx)
-      : base(make_arg_formatter(iter, s)), context_(ctx) {}
+  printf_arg_formatter(OutputIt iter, format_specs& s, context_type& ctx)
+      : base{iter, s, locale_ref()}, context_(ctx) {}

-  void operator()(monostate value) { write(value); }
+  OutputIt operator()(monostate value) { return base::operator()(value); }

  template <typename T, FMT_ENABLE_IF(detail::is_integral<T>::value)>
-  void operator()(T value) {
+  OutputIt operator()(T value) {
    // MSVC2013 fails to compile separate overloads for bool and Char so use
    // std::is_same instead.
-    if (!std::is_same<T, Char>::value) {
-      write(value);
-      return;
-    }
-    format_specs s = this->specs;
-    if (s.type() != presentation_type::none &&
-        s.type() != presentation_type::chr) {
+    if (std::is_same<T, Char>::value) {
+      format_specs fmt_specs = this->specs;
+      if (fmt_specs.type != presentation_type::none &&
+          fmt_specs.type != presentation_type::chr) {
        return (*this)(static_cast<int>(value));
      }
-    s.set_sign(sign::none);
-    s.clear_alt();
-    s.set_fill(' ');  // Ignore '0' flag for char types.
+      fmt_specs.sign = sign::none;
+      fmt_specs.alt = false;
+      fmt_specs.fill[0] = ' ';  // Ignore '0' flag for char types.
      // align::numeric needs to be overwritten here since the '0' flag is
      // ignored for non-numeric types
-    if (s.align() == align::none || s.align() == align::numeric)
-      s.set_align(align::right);
-    detail::write<Char>(this->out, static_cast<Char>(value), s);
+      if (fmt_specs.align == align::none || fmt_specs.align == align::numeric)
+        fmt_specs.align = align::right;
+      return write<Char>(this->out, static_cast<Char>(value), fmt_specs);
+    }
+    return base::operator()(value);
  }

  template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
-  void operator()(T value) {
-    write(value);
+  OutputIt operator()(T value) {
+    return base::operator()(value);
  }

-  void operator()(const char* value) {
-    if (value)
-      write(value);
-    else
-      write_null_pointer(this->specs.type() != presentation_type::pointer);
+  /** Formats a null-terminated C string. */
+  OutputIt operator()(const char* value) {
+    if (value) return base::operator()(value);
+    return write_null_pointer(this->specs.type != presentation_type::pointer);
  }

-  void operator()(const wchar_t* value) {
-    if (value)
-      write(value);
-    else
-      write_null_pointer(this->specs.type() != presentation_type::pointer);
+  /** Formats a null-terminated wide C string. */
+  OutputIt operator()(const wchar_t* value) {
+    if (value) return base::operator()(value);
+    return write_null_pointer(this->specs.type != presentation_type::pointer);
  }

-  void operator()(basic_string_view<Char> value) { write(value); }
-
-  void operator()(const void* value) {
-    if (value)
-      write(value);
-    else
-      write_null_pointer();
+  OutputIt operator()(basic_string_view<Char> value) {
+    return base::operator()(value);
  }

-  void operator()(typename basic_format_arg<context_type>::handle handle) {
-    auto parse_ctx = parse_context<Char>({});
+  /** Formats a pointer. */
+  OutputIt operator()(const void* value) {
+    return value ? base::operator()(value) : write_null_pointer();
+  }
+
+  /** Formats an argument of a custom (user-defined) type. */
+  OutputIt operator()(typename basic_format_arg<context_type>::handle handle) {
+    auto parse_ctx =
+        basic_printf_parse_context<Char>(basic_string_view<Char>());
    handle.format(parse_ctx, context_);
+    return this->out;
  }
 };

 template <typename Char>
-void parse_flags(format_specs& specs, const Char*& it, const Char* end) {
+void parse_flags(basic_format_specs<Char>& specs, const Char*& it,
+                 const Char* end) {
  for (; it != end; ++it) {
    switch (*it) {
-    case '-': specs.set_align(align::left); break;
-    case '+': specs.set_sign(sign::plus); break;
-    case '0': specs.set_fill('0'); break;
-    case ' ':
-      if (specs.sign() != sign::plus) specs.set_sign(sign::space);
+    case '-':
+      specs.align = align::left;
      break;
-    case '#': specs.set_alt(); break;
-    default:  return;
+    case '+':
+      specs.sign = sign::plus;
+      break;
+    case '0':
+      specs.fill[0] = '0';
+      break;
+    case ' ':
+      if (specs.sign != sign::plus) {
+        specs.sign = sign::space;
+      }
+      break;
+    case '#':
+      specs.alt = true;
+      break;
+    default:
+      return;
    }
  }
 }

 template <typename Char, typename GetArg>
-auto parse_header(const Char*& it, const Char* end, format_specs& specs,
-                  GetArg get_arg) -> int {
+int parse_header(const Char*& it, const Char* end,
+                 basic_format_specs<Char>& specs, GetArg get_arg) {
  int arg_index = -1;
  Char c = *it;
  if (c >= '0' && c <= '9') {
@ -346,11 +340,11 @@ auto parse_header(const Char*& it, const Char* end, format_specs& specs,
      ++it;
      arg_index = value != -1 ? value : max_value<int>();
    } else {
-      if (c == '0') specs.set_fill('0');
+      if (c == '0') specs.fill[0] = '0';
      if (value != 0) {
        // Nonzero value means that we parsed width and don't need to
        // parse it or flags again, so return now.
-        if (value == -1) report_error("number is too big");
+        if (value == -1) FMT_THROW(format_error("number is too big"));
        specs.width = value;
        return arg_index;
      }
@ -361,47 +355,23 @@ auto parse_header(const Char*& it, const Char* end, format_specs& specs,
  if (it != end) {
    if (*it >= '0' && *it <= '9') {
      specs.width = parse_nonnegative_int(it, end, -1);
-      if (specs.width == -1) report_error("number is too big");
+      if (specs.width == -1) FMT_THROW(format_error("number is too big"));
    } else if (*it == '*') {
      ++it;
-      specs.width = static_cast<int>(
-          get_arg(-1).visit(detail::printf_width_handler(specs)));
+      specs.width = static_cast<int>(visit_format_arg(
+          detail::printf_width_handler<Char>(specs), get_arg(-1)));
    }
  }
  return arg_index;
 }

-inline auto parse_printf_presentation_type(char c, type t, bool& upper)
-    -> presentation_type {
-  using pt = presentation_type;
-  constexpr auto integral_set = sint_set | uint_set | bool_set | char_set;
-  switch (c) {
-  case 'd': return in(t, integral_set) ? pt::dec : pt::none;
-  case 'o': return in(t, integral_set) ? pt::oct : pt::none;
-  case 'X': upper = true; FMT_FALLTHROUGH;
-  case 'x': return in(t, integral_set) ? pt::hex : pt::none;
-  case 'E': upper = true; FMT_FALLTHROUGH;
-  case 'e': return in(t, float_set) ? pt::exp : pt::none;
-  case 'F': upper = true; FMT_FALLTHROUGH;
-  case 'f': return in(t, float_set) ? pt::fixed : pt::none;
-  case 'G': upper = true; FMT_FALLTHROUGH;
-  case 'g': return in(t, float_set) ? pt::general : pt::none;
-  case 'A': upper = true; FMT_FALLTHROUGH;
-  case 'a': return in(t, float_set) ? pt::hexfloat : pt::none;
-  case 'c': return in(t, integral_set) ? pt::chr : pt::none;
-  case 's': return in(t, string_set | cstring_set) ? pt::string : pt::none;
-  case 'p': return in(t, pointer_set | cstring_set) ? pt::pointer : pt::none;
-  default:  return pt::none;
-  }
-}
-
 template <typename Char, typename Context>
 void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
             basic_format_args<Context> args) {
-  using iterator = basic_appender<Char>;
-  auto out = iterator(buf);
-  auto context = basic_printf_context<Char>(out, args);
-  auto parse_ctx = parse_context<Char>(format);
+  using OutputIt = buffer_appender<Char>;
+  auto out = OutputIt(buf);
+  auto context = basic_printf_context<OutputIt, Char>(out, args);
+  auto parse_ctx = basic_printf_parse_context<Char>(format);

  // Returns the argument with specified index or, if arg_index is -1, the next
  // argument.
@ -417,24 +387,26 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
  const Char* end = parse_ctx.end();
  auto it = start;
  while (it != end) {
-    if (!find<false, Char>(it, end, '%', it)) {
-      it = end;  // find leaves it == nullptr if it doesn't find '%'.
+    if (!detail::find<false, Char>(it, end, '%', it)) {
+      it = end;  // detail::find leaves it == nullptr if it doesn't find '%'
      break;
    }
    Char c = *it++;
    if (it != end && *it == c) {
-      write(out, basic_string_view<Char>(start, to_unsigned(it - start)));
+      out = detail::write(
+          out, basic_string_view<Char>(start, detail::to_unsigned(it - start)));
      start = ++it;
      continue;
    }
-    write(out, basic_string_view<Char>(start, to_unsigned(it - 1 - start)));
+    out = detail::write(out, basic_string_view<Char>(
+                                 start, detail::to_unsigned(it - 1 - start)));

-    auto specs = format_specs();
-    specs.set_align(align::right);
+    basic_format_specs<Char> specs;
+    specs.align = align::right;

    // Parse argument index, flags and width.
    int arg_index = parse_header(it, end, specs, get_arg);
-    if (arg_index == 0) report_error("argument not found");
+    if (arg_index == 0) parse_ctx.on_error("argument not found");

    // Parse precision.
    if (it != end && *it == '.') {
@ -444,8 +416,8 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
        specs.precision = parse_nonnegative_int(it, end, 0);
      } else if (c == '*') {
        ++it;
-        specs.precision =
-            static_cast<int>(get_arg(-1).visit(printf_precision_handler()));
+        specs.precision = static_cast<int>(
+            visit_format_arg(detail::printf_precision_handler(), get_arg(-1)));
      } else {
        specs.precision = 0;
      }
@ -454,31 +426,32 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
    auto arg = get_arg(arg_index);
    // For d, i, o, u, x, and X conversion specifiers, if a precision is
    // specified, the '0' flag is ignored
-    if (specs.precision >= 0 && is_integral_type(arg.type())) {
-      // Ignore '0' for non-numeric types or if '-' present.
-      specs.set_fill(' ');
-    }
-    if (specs.precision >= 0 && arg.type() == type::cstring_type) {
-      auto str = arg.visit(get_cstring<Char>());
+    if (specs.precision >= 0 && arg.is_integral())
+      specs.fill[0] =
+          ' ';  // Ignore '0' flag for non-numeric types or if '-' present.
+    if (specs.precision >= 0 && arg.type() == detail::type::cstring_type) {
+      auto str = visit_format_arg(detail::get_cstring<Char>(), arg);
      auto str_end = str + specs.precision;
      auto nul = std::find(str, str_end, Char());
-      auto sv = basic_string_view<Char>(
-          str, to_unsigned(nul != str_end ? nul - str : specs.precision));
-      arg = sv;
-    }
-    if (specs.alt() && arg.visit(is_zero_int())) specs.clear_alt();
-    if (specs.fill_unit<Char>() == '0') {
-      if (is_arithmetic_type(arg.type()) && specs.align() != align::left) {
-        specs.set_align(align::numeric);
-      } else {
-        // Ignore '0' flag for non-numeric types or if '-' flag is also present.
-        specs.set_fill(' ');
+      arg = detail::make_arg<basic_printf_context<OutputIt, Char>>(
+          basic_string_view<Char>(
+              str, detail::to_unsigned(nul != str_end ? nul - str
+                                                      : specs.precision)));
    }
+    if (specs.alt && visit_format_arg(detail::is_zero_int(), arg))
+      specs.alt = false;
+    if (specs.fill[0] == '0') {
+      if (arg.is_arithmetic() && specs.align != align::left)
+        specs.align = align::numeric;
+      else
+        specs.fill[0] = ' ';  // Ignore '0' flag for non-numeric types or if '-'
+                              // flag is also present.
    }

    // Parse length and convert the argument to the required type.
    c = it != end ? *it++ : 0;
    Char t = it != end ? *it : 0;
+    using detail::convert_arg;
    switch (c) {
    case 'h':
      if (t == 'h') {
@ -498,136 +471,170 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
        convert_arg<long>(arg, t);
      }
      break;
-    case 'j': convert_arg<intmax_t>(arg, t); break;
-    case 'z': convert_arg<size_t>(arg, t); break;
-    case 't': convert_arg<std::ptrdiff_t>(arg, t); break;
+    case 'j':
+      convert_arg<intmax_t>(arg, t);
+      break;
+    case 'z':
+      convert_arg<size_t>(arg, t);
+      break;
+    case 't':
+      convert_arg<std::ptrdiff_t>(arg, t);
+      break;
    case 'L':
      // printf produces garbage when 'L' is omitted for long double, no
      // need to do the same.
      break;
-    default: --it; convert_arg<void>(arg, c);
+    default:
+      --it;
+      convert_arg<void>(arg, c);
    }

    // Parse type.
-    if (it == end) report_error("invalid format string");
+    if (it == end) FMT_THROW(format_error("invalid format string"));
    char type = static_cast<char>(*it++);
-    if (is_integral_type(arg.type())) {
+    if (arg.is_integral()) {
      // Normalize type.
      switch (type) {
      case 'i':
-      case 'u': type = 'd'; break;
+      case 'u':
+        type = 'd';
+        break;
      case 'c':
-        arg.visit(char_converter<basic_printf_context<Char>>(arg));
+        visit_format_arg(
+            detail::char_converter<basic_printf_context<OutputIt, Char>>(arg),
+            arg);
        break;
      }
    }
-    bool upper = false;
-    specs.set_type(parse_printf_presentation_type(type, arg.type(), upper));
-    if (specs.type() == presentation_type::none)
-      report_error("invalid format specifier");
-    if (upper) specs.set_upper();
+    specs.type = parse_presentation_type(type);
+    if (specs.type == presentation_type::none)
+      parse_ctx.on_error("invalid type specifier");

    start = it;

    // Format argument.
-    arg.visit(printf_arg_formatter<Char>(out, specs, context));
+    out = visit_format_arg(
+        detail::printf_arg_formatter<OutputIt, Char>(out, specs, context), arg);
  }
-  write(out, basic_string_view<Char>(start, to_unsigned(it - start)));
+  detail::write(out, basic_string_view<Char>(start, to_unsigned(it - start)));
 }
-}  // namespace detail
+FMT_END_DETAIL_NAMESPACE

-using printf_context = basic_printf_context<char>;
-using wprintf_context = basic_printf_context<wchar_t>;
+template <typename Char>
+using basic_printf_context_t =
+    basic_printf_context<detail::buffer_appender<Char>, Char>;
+
+using printf_context = basic_printf_context_t<char>;
+using wprintf_context = basic_printf_context_t<wchar_t>;

 using printf_args = basic_format_args<printf_context>;
 using wprintf_args = basic_format_args<wprintf_context>;

-/// Constructs an `format_arg_store` object that contains references to
-/// arguments and can be implicitly converted to `printf_args`.
-template <typename Char = char, typename... T>
-inline auto make_printf_args(T&... args)
-    -> decltype(fmt::make_format_args<basic_printf_context<Char>>(args...)) {
-  return fmt::make_format_args<basic_printf_context<Char>>(args...);
-}
-
-template <typename Char> struct vprintf_args {
-  using type = basic_format_args<basic_printf_context<Char>>;
-};
-
-template <typename Char>
-inline auto vsprintf(basic_string_view<Char> fmt,
-                     typename vprintf_args<Char>::type args)
-    -> std::basic_string<Char> {
-  auto buf = basic_memory_buffer<Char>();
-  detail::vprintf(buf, fmt, args);
-  return {buf.data(), buf.size()};
+/**
+  \rst
+  Constructs an `~fmt::format_arg_store` object that contains references to
+  arguments and can be implicitly converted to `~fmt::printf_args`.
+  \endrst
+ */
+template <typename... T>
+inline auto make_printf_args(const T&... args)
+    -> format_arg_store<printf_context, T...> {
+  return {args...};
 }

 /**
- * Formats `args` according to specifications in `fmt` and returns the result
- * as as string.
- *
- * **Example**:
- *
- *     std::string message = fmt::sprintf("The answer is %d", 42);
+  \rst
+  Constructs an `~fmt::format_arg_store` object that contains references to
+  arguments and can be implicitly converted to `~fmt::wprintf_args`.
+  \endrst
 */
-template <typename S, typename... T, typename Char = detail::char_t<S>>
-inline auto sprintf(const S& fmt, const T&... args) -> std::basic_string<Char> {
-  return vsprintf(detail::to_string_view(fmt),
-                  fmt::make_format_args<basic_printf_context<Char>>(args...));
+template <typename... T>
+inline auto make_wprintf_args(const T&... args)
+    -> format_arg_store<wprintf_context, T...> {
+  return {args...};
 }

-template <typename Char>
-inline auto vfprintf(std::FILE* f, basic_string_view<Char> fmt,
-                     typename vprintf_args<Char>::type args) -> int {
-  auto buf = basic_memory_buffer<Char>();
-  detail::vprintf(buf, fmt, args);
-  size_t size = buf.size();
-  return std::fwrite(buf.data(), sizeof(Char), size, f) < size
+template <typename S, typename Char = char_t<S>>
+inline auto vsprintf(
+    const S& fmt,
+    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args)
+    -> std::basic_string<Char> {
+  basic_memory_buffer<Char> buffer;
+  vprintf(buffer, detail::to_string_view(fmt), args);
+  return to_string(buffer);
+}
+
+/**
+  \rst
+  Formats arguments and returns the result as a string.
+
+  **Example**::
+
+    std::string message = fmt::sprintf("The answer is %d", 42);
+  \endrst
+*/
+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(detail::to_string_view(fmt),
+                  fmt::make_format_args<context>(args...));
+}
+
+template <typename S, typename Char = char_t<S>>
+inline auto vfprintf(
+    std::FILE* f, const S& fmt,
+    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args)
+    -> int {
+  basic_memory_buffer<Char> buffer;
+  vprintf(buffer, detail::to_string_view(fmt), args);
+  size_t size = buffer.size();
+  return std::fwrite(buffer.data(), sizeof(Char), size, f) < size
             ? -1
             : static_cast<int>(size);
 }

 /**
- * Formats `args` according to specifications in `fmt` and writes the output
- * to `f`.
- *
- * **Example**:
- *
- *     fmt::fprintf(stderr, "Don't %s!", "panic");
+  \rst
+  Prints formatted data to the file *f*.
+
+  **Example**::
+
+    fmt::fprintf(stderr, "Don't %s!", "panic");
+  \endrst
 */
-template <typename S, typename... T, typename Char = detail::char_t<S>>
+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, detail::to_string_view(fmt),
-                  make_printf_args<Char>(args...));
+                  fmt::make_format_args<context>(args...));
 }

-template <typename Char>
-FMT_DEPRECATED inline auto vprintf(basic_string_view<Char> fmt,
-                                   typename vprintf_args<Char>::type args)
+template <typename S, typename Char = char_t<S>>
+inline auto vprintf(
+    const S& fmt,
+    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args)
    -> int {
-  return vfprintf(stdout, fmt, args);
+  return vfprintf(stdout, detail::to_string_view(fmt), args);
 }

 /**
- * Formats `args` according to specifications in `fmt` and writes the output
- * to `stdout`.
- *
- * **Example**:
- *
- *   fmt::printf("Elapsed time: %.2f seconds", 1.23);
+  \rst
+  Prints formatted data to ``stdout``.
+
+  **Example**::
+
+    fmt::printf("Elapsed time: %.2f seconds", 1.23);
+  \endrst
 */
-template <typename... T>
-inline auto printf(string_view fmt, const T&... args) -> int {
-  return vfprintf(stdout, fmt, make_printf_args(args...));
-}
-template <typename... T>
-FMT_DEPRECATED inline auto printf(basic_string_view<wchar_t> fmt,
-                                  const T&... args) -> int {
-  return vfprintf(stdout, fmt, make_printf_args<wchar_t>(args...));
+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(
+      detail::to_string_view(fmt),
+      fmt::make_format_args<basic_printf_context_t<char_t<S>>>(args...));
 }

-FMT_END_EXPORT
+FMT_MODULE_EXPORT_END
 FMT_END_NAMESPACE

 #endif  // FMT_PRINTF_H_
--- a/include/spdlog/fmt/bundled/ranges.h
+++ b/include/spdlog/fmt/bundled/ranges.h
--- a/include/spdlog/fmt/bundled/std.h
+++ b/include/spdlog/fmt/bundled/std.h
@ -8,354 +8,127 @@
 #ifndef FMT_STD_H_
 #define FMT_STD_H_

-#include "format.h"
+#include <thread>
+#include <type_traits>
+#include <utility>
+
 #include "ostream.h"

-#ifndef FMT_MODULE
-#  include <atomic>
-#  include <bitset>
-#  include <complex>
-#  include <cstdlib>
-#  include <exception>
-#  include <functional>
-#  include <memory>
-#  include <thread>
-#  include <type_traits>
-#  include <typeinfo>
-#  include <utility>
-#  include <vector>
-
-// Check FMT_CPLUSPLUS to suppress a bogus warning in MSVC.
-#  if FMT_CPLUSPLUS >= 201703L
-#    if FMT_HAS_INCLUDE(<filesystem>) && \
-        (!defined(FMT_CPP_LIB_FILESYSTEM) || FMT_CPP_LIB_FILESYSTEM != 0)
+#if FMT_HAS_INCLUDE(<version>)
+#  include <version>
+#endif
+// Checking FMT_CPLUSPLUS for warning suppression in MSVC.
+#if FMT_CPLUSPLUS >= 201703L
+#  if FMT_HAS_INCLUDE(<filesystem>)
 #    include <filesystem>
 #  endif
 #  if FMT_HAS_INCLUDE(<variant>)
 #    include <variant>
 #  endif
-#    if FMT_HAS_INCLUDE(<optional>)
-#      include <optional>
-#    endif
-#  endif
-// Use > instead of >= in the version check because <source_location> may be
-// available after C++17 but before C++20 is marked as implemented.
-#  if FMT_CPLUSPLUS > 201703L && FMT_HAS_INCLUDE(<source_location>)
-#    include <source_location>
-#  endif
-#  if FMT_CPLUSPLUS > 202002L && FMT_HAS_INCLUDE(<expected>)
-#    include <expected>
-#  endif
-#endif  // FMT_MODULE
-
-#if FMT_HAS_INCLUDE(<version>)
-#  include <version>
 #endif

-// GCC 4 does not support FMT_HAS_INCLUDE.
-#if FMT_HAS_INCLUDE(<cxxabi.h>) || defined(__GLIBCXX__)
-#  include <cxxabi.h>
-// Android NDK with gabi++ library on some architectures does not implement
-// abi::__cxa_demangle().
-#  ifndef __GABIXX_CXXABI_H__
-#    define FMT_HAS_ABI_CXA_DEMANGLE
-#  endif
-#endif
-
-// For older Xcode versions, __cpp_lib_xxx flags are inaccurately defined.
-#ifndef FMT_CPP_LIB_FILESYSTEM
-#  ifdef __cpp_lib_filesystem
-#    define FMT_CPP_LIB_FILESYSTEM __cpp_lib_filesystem
-#  else
-#    define FMT_CPP_LIB_FILESYSTEM 0
-#  endif
-#endif
-
-#ifndef FMT_CPP_LIB_VARIANT
-#  ifdef __cpp_lib_variant
-#    define FMT_CPP_LIB_VARIANT __cpp_lib_variant
-#  else
-#    define FMT_CPP_LIB_VARIANT 0
-#  endif
-#endif
-
-#if FMT_CPP_LIB_FILESYSTEM
+#ifdef __cpp_lib_filesystem
 FMT_BEGIN_NAMESPACE

 namespace detail {

-template <typename Char, typename PathChar>
-auto get_path_string(const std::filesystem::path& p,
-                     const std::basic_string<PathChar>& native) {
-  if constexpr (std::is_same_v<Char, char> && std::is_same_v<PathChar, wchar_t>)
-    return to_utf8<wchar_t>(native, to_utf8_error_policy::replace);
-  else
-    return p.string<Char>();
-}
-
-template <typename Char, typename PathChar>
+template <typename Char>
 void write_escaped_path(basic_memory_buffer<Char>& quoted,
-                        const std::filesystem::path& p,
-                        const std::basic_string<PathChar>& native) {
-  if constexpr (std::is_same_v<Char, char> &&
-                std::is_same_v<PathChar, wchar_t>) {
-    auto buf = basic_memory_buffer<wchar_t>();
-    write_escaped_string<wchar_t>(std::back_inserter(buf), native);
-    bool valid = to_utf8<wchar_t>::convert(quoted, {buf.data(), buf.size()});
-    FMT_ASSERT(valid, "invalid utf16");
-  } else if constexpr (std::is_same_v<Char, PathChar>) {
-    write_escaped_string<std::filesystem::path::value_type>(
-        std::back_inserter(quoted), native);
-  } else {
+                        const std::filesystem::path& p) {
  write_escaped_string<Char>(std::back_inserter(quoted), p.string<Char>());
-  }
+}
+#  ifdef _WIN32
+template <>
+inline void write_escaped_path<char>(basic_memory_buffer<char>& quoted,
+                                     const std::filesystem::path& p) {
+  auto s = p.u8string();
+  write_escaped_string<char>(
+      std::back_inserter(quoted),
+      string_view(reinterpret_cast<const char*>(s.c_str()), s.size()));
+}
+#  endif
+template <>
+inline void write_escaped_path<std::filesystem::path::value_type>(
+    basic_memory_buffer<std::filesystem::path::value_type>& quoted,
+    const std::filesystem::path& p) {
+  write_escaped_string<std::filesystem::path::value_type>(
+      std::back_inserter(quoted), p.native());
 }

 }  // namespace detail

-FMT_EXPORT
-template <typename Char> struct formatter<std::filesystem::path, Char> {
- private:
-  format_specs specs_;
-  detail::arg_ref<Char> width_ref_;
-  bool debug_ = false;
-  char path_type_ = 0;
-
- public:
-  FMT_CONSTEXPR void set_debug_format(bool set = true) { debug_ = set; }
-
-  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) {
-    auto it = ctx.begin(), end = ctx.end();
-    if (it == end) return it;
-
-    it = detail::parse_align(it, end, specs_);
-    if (it == end) return it;
-
-    Char c = *it;
-    if ((c >= '0' && c <= '9') || c == '{')
-      it = detail::parse_width(it, end, specs_, width_ref_, ctx);
-    if (it != end && *it == '?') {
-      debug_ = true;
-      ++it;
-    }
-    if (it != end && (*it == 'g')) path_type_ = detail::to_ascii(*it++);
-    return it;
-  }
-
+template <typename Char>
+struct formatter<std::filesystem::path, Char>
+    : formatter<basic_string_view<Char>> {
  template <typename FormatContext>
-  auto format(const std::filesystem::path& p, FormatContext& ctx) const {
-    auto specs = specs_;
-    auto path_string =
-        !path_type_ ? p.native()
-                    : p.generic_string<std::filesystem::path::value_type>();
-
-    detail::handle_dynamic_spec(specs.dynamic_width(), specs.width, width_ref_,
-                                ctx);
-    if (!debug_) {
-      auto s = detail::get_path_string<Char>(p, path_string);
-      return detail::write(ctx.out(), basic_string_view<Char>(s), specs);
-    }
-    auto quoted = basic_memory_buffer<Char>();
-    detail::write_escaped_path(quoted, p, path_string);
-    return detail::write(ctx.out(),
-                         basic_string_view<Char>(quoted.data(), quoted.size()),
-                         specs);
+  auto format(const std::filesystem::path& p, FormatContext& ctx) const ->
+      typename FormatContext::iterator {
+    basic_memory_buffer<Char> quoted;
+    detail::write_escaped_path(quoted, p);
+    return formatter<basic_string_view<Char>>::format(
+        basic_string_view<Char>(quoted.data(), quoted.size()), ctx);
  }
 };
-
-class path : public std::filesystem::path {
- public:
-  auto display_string() const -> std::string {
-    const std::filesystem::path& base = *this;
-    return fmt::format(FMT_STRING("{}"), base);
-  }
-  auto system_string() const -> std::string { return string(); }
-
-  auto generic_display_string() const -> std::string {
-    const std::filesystem::path& base = *this;
-    return fmt::format(FMT_STRING("{:g}"), base);
-  }
-  auto generic_system_string() const -> std::string { return generic_string(); }
-};
-
 FMT_END_NAMESPACE
-#endif  // FMT_CPP_LIB_FILESYSTEM
+#endif

 FMT_BEGIN_NAMESPACE
-FMT_EXPORT
-template <std::size_t N, typename Char>
-struct formatter<std::bitset<N>, Char>
-    : nested_formatter<basic_string_view<Char>, Char> {
- private:
-  // Functor because C++11 doesn't support generic lambdas.
-  struct writer {
-    const std::bitset<N>& bs;
-
-    template <typename OutputIt>
-    FMT_CONSTEXPR auto operator()(OutputIt out) -> OutputIt {
-      for (auto pos = N; pos > 0; --pos) {
-        out = detail::write<Char>(out, bs[pos - 1] ? Char('1') : Char('0'));
-      }
-
-      return out;
-    }
-  };
-
- public:
-  template <typename FormatContext>
-  auto format(const std::bitset<N>& bs, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    return this->write_padded(ctx, writer{bs});
-  }
-};
-
-FMT_EXPORT
 template <typename Char>
 struct formatter<std::thread::id, Char> : basic_ostream_formatter<Char> {};
 FMT_END_NAMESPACE

-#ifdef __cpp_lib_optional
+#ifdef __cpp_lib_variant
 FMT_BEGIN_NAMESPACE
-FMT_EXPORT
-template <typename T, typename Char>
-struct formatter<std::optional<T>, Char,
-                 std::enable_if_t<is_formattable<T, Char>::value>> {
- private:
-  formatter<T, Char> underlying_;
-  static constexpr basic_string_view<Char> optional =
-      detail::string_literal<Char, 'o', 'p', 't', 'i', 'o', 'n', 'a', 'l',
-                             '('>{};
-  static constexpr basic_string_view<Char> none =
-      detail::string_literal<Char, 'n', 'o', 'n', 'e'>{};
-
-  template <class U>
-  FMT_CONSTEXPR static auto maybe_set_debug_format(U& u, bool set)
-      -> decltype(u.set_debug_format(set)) {
-    u.set_debug_format(set);
-  }
-
-  template <class U>
-  FMT_CONSTEXPR static void maybe_set_debug_format(U&, ...) {}
-
- public:
-  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) {
-    maybe_set_debug_format(underlying_, true);
-    return underlying_.parse(ctx);
-  }
-
-  template <typename FormatContext>
-  auto format(const std::optional<T>& opt, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    if (!opt) return detail::write<Char>(ctx.out(), none);
-
-    auto out = ctx.out();
-    out = detail::write<Char>(out, optional);
-    ctx.advance_to(out);
-    out = underlying_.format(*opt, ctx);
-    return detail::write(out, ')');
-  }
-};
-FMT_END_NAMESPACE
-#endif  // __cpp_lib_optional
-
-#if defined(__cpp_lib_expected) || FMT_CPP_LIB_VARIANT
-
-FMT_BEGIN_NAMESPACE
-namespace detail {
-
-template <typename Char, typename OutputIt, typename T>
-auto write_escaped_alternative(OutputIt out, const T& v) -> OutputIt {
-  if constexpr (has_to_string_view<T>::value)
-    return write_escaped_string<Char>(out, detail::to_string_view(v));
-  if constexpr (std::is_same_v<T, Char>) return write_escaped_char(out, v);
-  return write<Char>(out, v);
-}
-
-}  // namespace detail
-
-FMT_END_NAMESPACE
-#endif
-
-#ifdef __cpp_lib_expected
-FMT_BEGIN_NAMESPACE
-
-FMT_EXPORT
-template <typename T, typename E, typename Char>
-struct formatter<std::expected<T, E>, Char,
-                 std::enable_if_t<(std::is_void<T>::value ||
-                                   is_formattable<T, Char>::value) &&
-                                  is_formattable<E, Char>::value>> {
-  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
+template <typename Char> struct formatter<std::monostate, Char> {
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
    return ctx.begin();
  }

  template <typename FormatContext>
-  auto format(const std::expected<T, E>& value, FormatContext& ctx) const
+  auto format(const std::monostate&, FormatContext& ctx) const
      -> decltype(ctx.out()) {
    auto out = ctx.out();
-
-    if (value.has_value()) {
-      out = detail::write<Char>(out, "expected(");
-      if constexpr (!std::is_void<T>::value)
-        out = detail::write_escaped_alternative<Char>(out, *value);
-    } else {
-      out = detail::write<Char>(out, "unexpected(");
-      out = detail::write_escaped_alternative<Char>(out, value.error());
-    }
-    *out++ = ')';
+    out = detail::write<Char>(out, "monostate");
    return out;
  }
 };
-FMT_END_NAMESPACE
-#endif  // __cpp_lib_expected

-#ifdef __cpp_lib_source_location
-FMT_BEGIN_NAMESPACE
-FMT_EXPORT
-template <> struct formatter<std::source_location> {
-  FMT_CONSTEXPR auto parse(parse_context<>& ctx) { return ctx.begin(); }
-
-  template <typename FormatContext>
-  auto format(const std::source_location& loc, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    auto out = ctx.out();
-    out = detail::write(out, loc.file_name());
-    out = detail::write(out, ':');
-    out = detail::write<char>(out, loc.line());
-    out = detail::write(out, ':');
-    out = detail::write<char>(out, loc.column());
-    out = detail::write(out, ": ");
-    out = detail::write(out, loc.function_name());
-    return out;
-  }
-};
-FMT_END_NAMESPACE
-#endif
-
-#if FMT_CPP_LIB_VARIANT
-FMT_BEGIN_NAMESPACE
 namespace detail {

 template <typename T>
 using variant_index_sequence =
    std::make_index_sequence<std::variant_size<T>::value>;

-template <typename> struct is_variant_like_ : std::false_type {};
-template <typename... Types>
-struct is_variant_like_<std::variant<Types...>> : std::true_type {};
+// variant_size and variant_alternative check.
+template <typename T, typename U = void>
+struct is_variant_like_ : std::false_type {};
+template <typename T>
+struct is_variant_like_<T, std::void_t<decltype(std::variant_size<T>::value)>>
+    : std::true_type {};

-// formattable element check.
+// formattable element check
 template <typename T, typename C> class is_variant_formattable_ {
-  template <std::size_t... Is>
+  template <std::size_t... I>
  static std::conjunction<
-      is_formattable<std::variant_alternative_t<Is, T>, C>...>
-      check(std::index_sequence<Is...>);
+      is_formattable<std::variant_alternative_t<I, T>, C>...>
+      check(std::index_sequence<I...>);

 public:
  static constexpr const bool value =
      decltype(check(variant_index_sequence<T>{}))::value;
 };

+template <typename Char, typename OutputIt, typename T>
+auto write_variant_alternative(OutputIt out, const T& v) -> OutputIt {
+  if constexpr (is_string<T>::value)
+    return write_escaped_string<Char>(out, detail::to_string_view(v));
+  else if constexpr (std::is_same_v<T, Char>)
+    return write_escaped_char(out, v);
+  else
+    return write<Char>(out, v);
+}
+
 }  // namespace detail

 template <typename T> struct is_variant_like {
@ -367,26 +140,13 @@ template <typename T, typename C> struct is_variant_formattable {
      detail::is_variant_formattable_<T, C>::value;
 };

-FMT_EXPORT
-template <typename Char> struct formatter<std::monostate, Char> {
-  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
-    return ctx.begin();
-  }
-
-  template <typename FormatContext>
-  auto format(const std::monostate&, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    return detail::write<Char>(ctx.out(), "monostate");
-  }
-};
-
-FMT_EXPORT
 template <typename Variant, typename Char>
 struct formatter<
    Variant, Char,
    std::enable_if_t<std::conjunction_v<
        is_variant_like<Variant>, is_variant_formattable<Variant, Char>>>> {
-  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
    return ctx.begin();
  }

@ -396,331 +156,16 @@ struct formatter<
    auto out = ctx.out();

    out = detail::write<Char>(out, "variant(");
-    FMT_TRY {
    std::visit(
        [&](const auto& v) {
-            out = detail::write_escaped_alternative<Char>(out, v);
+          out = detail::write_variant_alternative<Char>(out, v);
        },
        value);
-    }
-    FMT_CATCH(const std::bad_variant_access&) {
-      detail::write<Char>(out, "valueless by exception");
-    }
    *out++ = ')';
    return out;
  }
 };
 FMT_END_NAMESPACE
-#endif  // FMT_CPP_LIB_VARIANT
-
-FMT_BEGIN_NAMESPACE
-FMT_EXPORT
-template <> struct formatter<std::error_code> {
- private:
-  format_specs specs_;
-  detail::arg_ref<char> width_ref_;
-
- public:
-  FMT_CONSTEXPR auto parse(parse_context<>& ctx) -> const char* {
-    auto it = ctx.begin(), end = ctx.end();
-    if (it == end) return it;
-
-    it = detail::parse_align(it, end, specs_);
-    if (it == end) return it;
-
-    char c = *it;
-    if ((c >= '0' && c <= '9') || c == '{')
-      it = detail::parse_width(it, end, specs_, width_ref_, ctx);
-    return it;
-  }
-
-  template <typename FormatContext>
-  FMT_CONSTEXPR20 auto format(const std::error_code& ec,
-                              FormatContext& ctx) const -> decltype(ctx.out()) {
-    auto specs = specs_;
-    detail::handle_dynamic_spec(specs.dynamic_width(), specs.width, width_ref_,
-                                ctx);
-    memory_buffer buf;
-    buf.append(string_view(ec.category().name()));
-    buf.push_back(':');
-    detail::write<char>(appender(buf), ec.value());
-    return detail::write<char>(ctx.out(), string_view(buf.data(), buf.size()),
-                               specs);
-  }
-};
-
-#if FMT_USE_RTTI
-namespace detail {
-
-template <typename Char, typename OutputIt>
-auto write_demangled_name(OutputIt out, const std::type_info& ti) -> OutputIt {
-#  ifdef FMT_HAS_ABI_CXA_DEMANGLE
-  int status = 0;
-  std::size_t size = 0;
-  std::unique_ptr<char, void (*)(void*)> demangled_name_ptr(
-      abi::__cxa_demangle(ti.name(), nullptr, &size, &status), &std::free);
-
-  string_view demangled_name_view;
-  if (demangled_name_ptr) {
-    demangled_name_view = demangled_name_ptr.get();
-
-    // Normalization of stdlib inline namespace names.
-    // libc++ inline namespaces.
-    //  std::__1::*       -> std::*
-    //  std::__1::__fs::* -> std::*
-    // libstdc++ inline namespaces.
-    //  std::__cxx11::*             -> std::*
-    //  std::filesystem::__cxx11::* -> std::filesystem::*
-    if (demangled_name_view.starts_with("std::")) {
-      char* begin = demangled_name_ptr.get();
-      char* to = begin + 5;  // std::
-      for (char *from = to, *end = begin + demangled_name_view.size();
-           from < end;) {
-        // This is safe, because demangled_name is NUL-terminated.
-        if (from[0] == '_' && from[1] == '_') {
-          char* next = from + 1;
-          while (next < end && *next != ':') next++;
-          if (next[0] == ':' && next[1] == ':') {
-            from = next + 2;
-            continue;
-          }
-        }
-        *to++ = *from++;
-      }
-      demangled_name_view = {begin, detail::to_unsigned(to - begin)};
-    }
-  } else {
-    demangled_name_view = string_view(ti.name());
-  }
-  return detail::write_bytes<Char>(out, demangled_name_view);
-#  elif FMT_MSC_VERSION
-  const string_view demangled_name(ti.name());
-  for (std::size_t i = 0; i < demangled_name.size(); ++i) {
-    auto sub = demangled_name;
-    sub.remove_prefix(i);
-    if (sub.starts_with("enum ")) {
-      i += 4;
-      continue;
-    }
-    if (sub.starts_with("class ") || sub.starts_with("union ")) {
-      i += 5;
-      continue;
-    }
-    if (sub.starts_with("struct ")) {
-      i += 6;
-      continue;
-    }
-    if (*sub.begin() != ' ') *out++ = *sub.begin();
-  }
-  return out;
-#  else
-  return detail::write_bytes<Char>(out, string_view(ti.name()));
-#  endif
-}
-
-}  // namespace detail
-
-FMT_EXPORT
-template <typename Char>
-struct formatter<std::type_info, Char  // DEPRECATED! Mixing code unit types.
-                 > {
- public:
-  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
-    return ctx.begin();
-  }
-
-  template <typename Context>
-  auto format(const std::type_info& ti, Context& ctx) const
-      -> decltype(ctx.out()) {
-    return detail::write_demangled_name<Char>(ctx.out(), ti);
-  }
-};
 #endif

-FMT_EXPORT
-template <typename T, typename Char>
-struct formatter<
-    T, Char,  // DEPRECATED! Mixing code unit types.
-    typename std::enable_if<std::is_base_of<std::exception, T>::value>::type> {
- private:
-  bool with_typename_ = false;
-
- public:
-  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
-    auto it = ctx.begin();
-    auto end = ctx.end();
-    if (it == end || *it == '}') return it;
-    if (*it == 't') {
-      ++it;
-      with_typename_ = FMT_USE_RTTI != 0;
-    }
-    return it;
-  }
-
-  template <typename Context>
-  auto format(const std::exception& ex, Context& ctx) const
-      -> decltype(ctx.out()) {
-    auto out = ctx.out();
-#if FMT_USE_RTTI
-    if (with_typename_) {
-      out = detail::write_demangled_name<Char>(out, typeid(ex));
-      *out++ = ':';
-      *out++ = ' ';
-    }
-#endif
-    return detail::write_bytes<Char>(out, string_view(ex.what()));
-  }
-};
-
-namespace detail {
-
-template <typename T, typename Enable = void>
-struct has_flip : std::false_type {};
-
-template <typename T>
-struct has_flip<T, void_t<decltype(std::declval<T>().flip())>>
-    : std::true_type {};
-
-template <typename T> struct is_bit_reference_like {
-  static constexpr const bool value =
-      std::is_convertible<T, bool>::value &&
-      std::is_nothrow_assignable<T, bool>::value && has_flip<T>::value;
-};
-
-#ifdef _LIBCPP_VERSION
-
-// Workaround for libc++ incompatibility with C++ standard.
-// According to the Standard, `bitset::operator[] const` returns bool.
-template <typename C>
-struct is_bit_reference_like<std::__bit_const_reference<C>> {
-  static constexpr const bool value = true;
-};
-
-#endif
-
-}  // namespace detail
-
-// We can't use std::vector<bool, Allocator>::reference and
-// std::bitset<N>::reference because the compiler can't deduce Allocator and N
-// in partial specialization.
-FMT_EXPORT
-template <typename BitRef, typename Char>
-struct formatter<BitRef, Char,
-                 enable_if_t<detail::is_bit_reference_like<BitRef>::value>>
-    : formatter<bool, Char> {
-  template <typename FormatContext>
-  FMT_CONSTEXPR auto format(const BitRef& v, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    return formatter<bool, Char>::format(v, ctx);
-  }
-};
-
-template <typename T, typename Deleter>
-auto ptr(const std::unique_ptr<T, Deleter>& p) -> const void* {
-  return p.get();
-}
-template <typename T> auto ptr(const std::shared_ptr<T>& p) -> const void* {
-  return p.get();
-}
-
-FMT_EXPORT
-template <typename T, typename Char>
-struct formatter<std::atomic<T>, Char,
-                 enable_if_t<is_formattable<T, Char>::value>>
-    : formatter<T, Char> {
-  template <typename FormatContext>
-  auto format(const std::atomic<T>& v, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    return formatter<T, Char>::format(v.load(), ctx);
-  }
-};
-
-#ifdef __cpp_lib_atomic_flag_test
-FMT_EXPORT
-template <typename Char>
-struct formatter<std::atomic_flag, Char> : formatter<bool, Char> {
-  template <typename FormatContext>
-  auto format(const std::atomic_flag& v, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    return formatter<bool, Char>::format(v.test(), ctx);
-  }
-};
-#endif  // __cpp_lib_atomic_flag_test
-
-FMT_EXPORT
-template <typename T, typename Char> struct formatter<std::complex<T>, Char> {
- private:
-  detail::dynamic_format_specs<Char> specs_;
-
-  template <typename FormatContext, typename OutputIt>
-  FMT_CONSTEXPR auto do_format(const std::complex<T>& c,
-                               detail::dynamic_format_specs<Char>& specs,
-                               FormatContext& ctx, OutputIt out) const
-      -> OutputIt {
-    if (c.real() != 0) {
-      *out++ = Char('(');
-      out = detail::write<Char>(out, c.real(), specs, ctx.locale());
-      specs.set_sign(sign::plus);
-      out = detail::write<Char>(out, c.imag(), specs, ctx.locale());
-      if (!detail::isfinite(c.imag())) *out++ = Char(' ');
-      *out++ = Char('i');
-      *out++ = Char(')');
-      return out;
-    }
-    out = detail::write<Char>(out, c.imag(), specs, ctx.locale());
-    if (!detail::isfinite(c.imag())) *out++ = Char(' ');
-    *out++ = Char('i');
-    return out;
-  }
-
- public:
-  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
-    if (ctx.begin() == ctx.end() || *ctx.begin() == '}') return ctx.begin();
-    return parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx,
-                              detail::type_constant<T, Char>::value);
-  }
-
-  template <typename FormatContext>
-  auto format(const std::complex<T>& c, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    auto specs = specs_;
-    if (specs.dynamic()) {
-      detail::handle_dynamic_spec(specs.dynamic_width(), specs.width,
-                                  specs.width_ref, ctx);
-      detail::handle_dynamic_spec(specs.dynamic_precision(), specs.precision,
-                                  specs.precision_ref, ctx);
-    }
-
-    if (specs.width == 0) return do_format(c, specs, ctx, ctx.out());
-    auto buf = basic_memory_buffer<Char>();
-
-    auto outer_specs = format_specs();
-    outer_specs.width = specs.width;
-    outer_specs.copy_fill_from(specs);
-    outer_specs.set_align(specs.align());
-
-    specs.width = 0;
-    specs.set_fill({});
-    specs.set_align(align::none);
-
-    do_format(c, specs, ctx, basic_appender<Char>(buf));
-    return detail::write<Char>(ctx.out(),
-                               basic_string_view<Char>(buf.data(), buf.size()),
-                               outer_specs);
-  }
-};
-
-FMT_EXPORT
-template <typename T, typename Char>
-struct formatter<std::reference_wrapper<T>, Char,
-                 enable_if_t<is_formattable<remove_cvref_t<T>, Char>::value>>
-    : formatter<remove_cvref_t<T>, Char> {
-  template <typename FormatContext>
-  auto format(std::reference_wrapper<T> ref, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    return formatter<remove_cvref_t<T>, Char>::format(ref.get(), ctx);
-  }
-};
-
-FMT_END_NAMESPACE
 #endif  // FMT_STD_H_
--- a/include/spdlog/fmt/bundled/xchar.h
+++ b/include/spdlog/fmt/bundled/xchar.h
@ -8,131 +8,52 @@
 #ifndef FMT_XCHAR_H_
 #define FMT_XCHAR_H_

-#include "color.h"
-#include "format.h"
-#include "ostream.h"
-#include "ranges.h"
+#include <cwchar>

-#ifndef FMT_MODULE
-#  include <cwchar>
-#  if FMT_USE_LOCALE
-#    include <locale>
-#  endif
-#endif
+#include "format.h"

 FMT_BEGIN_NAMESPACE
 namespace detail {
-
 template <typename T>
 using is_exotic_char = bool_constant<!std::is_same<T, char>::value>;
-
-template <typename S, typename = void> struct format_string_char {};
-
-template <typename S>
-struct format_string_char<
-    S, void_t<decltype(sizeof(detail::to_string_view(std::declval<S>())))>> {
-  using type = char_t<S>;
-};
-
-template <typename S>
-struct format_string_char<
-    S, enable_if_t<std::is_base_of<detail::compile_string, S>::value>> {
-  using type = typename S::char_type;
-};
-
-template <typename S>
-using format_string_char_t = typename format_string_char<S>::type;
-
-inline auto write_loc(basic_appender<wchar_t> out, loc_value value,
-                      const format_specs& specs, locale_ref loc) -> bool {
-#if FMT_USE_LOCALE
-  auto& numpunct =
-      std::use_facet<std::numpunct<wchar_t>>(loc.get<std::locale>());
-  auto separator = std::wstring();
-  auto grouping = numpunct.grouping();
-  if (!grouping.empty()) separator = std::wstring(1, numpunct.thousands_sep());
-  return value.visit(loc_writer<wchar_t>{out, specs, separator, grouping, {}});
-#endif
-  return false;
 }
-}  // namespace detail

-FMT_BEGIN_EXPORT
+FMT_MODULE_EXPORT_BEGIN

 using wstring_view = basic_string_view<wchar_t>;
-using wformat_parse_context = parse_context<wchar_t>;
-using wformat_context = buffered_context<wchar_t>;
+using wformat_parse_context = basic_format_parse_context<wchar_t>;
+using wformat_context = buffer_context<wchar_t>;
 using wformat_args = basic_format_args<wformat_context>;
 using wmemory_buffer = basic_memory_buffer<wchar_t>;

-template <typename Char, typename... T> struct basic_fstring {
- private:
-  basic_string_view<Char> str_;
-
-  static constexpr int num_static_named_args =
-      detail::count_static_named_args<T...>();
-
-  using checker = detail::format_string_checker<
-      Char, static_cast<int>(sizeof...(T)), num_static_named_args,
-      num_static_named_args != detail::count_named_args<T...>()>;
-
-  using arg_pack = detail::arg_pack<T...>;
-
- public:
-  using t = basic_fstring;
-
-  template <typename S,
-            FMT_ENABLE_IF(
-                std::is_convertible<const S&, basic_string_view<Char>>::value)>
-  FMT_CONSTEVAL FMT_ALWAYS_INLINE basic_fstring(const S& s) : str_(s) {
-    if (FMT_USE_CONSTEVAL)
-      detail::parse_format_string<Char>(s, checker(s, arg_pack()));
-  }
-  template <typename S,
-            FMT_ENABLE_IF(std::is_base_of<detail::compile_string, S>::value&&
-                              std::is_same<typename S::char_type, Char>::value)>
-  FMT_ALWAYS_INLINE basic_fstring(const S&) : str_(S()) {
-    FMT_CONSTEXPR auto sv = basic_string_view<Char>(S());
-    FMT_CONSTEXPR int ignore =
-        (parse_format_string(sv, checker(sv, arg_pack())), 0);
-    detail::ignore_unused(ignore);
-  }
-  basic_fstring(runtime_format_string<Char> fmt) : str_(fmt.str) {}
-
-  operator basic_string_view<Char>() const { return str_; }
-  auto get() const -> basic_string_view<Char> { return str_; }
-};
-
-template <typename Char, typename... T>
-using basic_format_string = basic_fstring<Char, T...>;
-
-template <typename... T>
-using wformat_string = typename basic_format_string<wchar_t, T...>::t;
-inline auto runtime(wstring_view s) -> runtime_format_string<wchar_t> {
-  return {{s}};
-}
+#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 {};
+template <> struct is_char<detail::char8_type> : std::true_type {};
 template <> struct is_char<char16_t> : std::true_type {};
 template <> struct is_char<char32_t> : std::true_type {};

-#ifdef __cpp_char8_t
-template <> struct is_char<char8_t> : bool_constant<detail::is_utf8_enabled> {};
-#endif
-
-template <typename... T>
-constexpr auto make_wformat_args(T&... args)
-    -> decltype(fmt::make_format_args<wformat_context>(args...)) {
-  return fmt::make_format_args<wformat_context>(args...);
+template <typename... Args>
+constexpr format_arg_store<wformat_context, Args...> make_wformat_args(
+    const Args&... args) {
+  return {args...};
 }

-#if !FMT_USE_NONTYPE_TEMPLATE_ARGS
 inline namespace literals {
-inline auto operator""_a(const wchar_t* s, size_t) -> detail::udl_arg<wchar_t> {
+#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};
 }
-}  // namespace literals
 #endif
+}  // namespace literals

 template <typename It, typename Sentinel>
 auto join(It begin, Sentinel end, wstring_view sep)
@ -140,9 +61,9 @@ auto join(It begin, Sentinel end, wstring_view sep)
  return {begin, end, sep};
 }

-template <typename Range, FMT_ENABLE_IF(!is_tuple_like<Range>::value)>
+template <typename Range>
 auto join(Range&& range, wstring_view sep)
-    -> join_view<decltype(std::begin(range)), decltype(std::end(range)),
+    -> join_view<detail::iterator_t<Range>, detail::sentinel_t<Range>,
                 wchar_t> {
  return join(std::begin(range), std::end(range), sep);
 }
@ -153,19 +74,13 @@ auto join(std::initializer_list<T> list, wstring_view sep)
  return join(std::begin(list), std::end(list), sep);
 }

-template <typename Tuple, FMT_ENABLE_IF(is_tuple_like<Tuple>::value)>
-auto join(const Tuple& tuple, basic_string_view<wchar_t> sep)
-    -> tuple_join_view<wchar_t, Tuple> {
-  return {tuple, sep};
-}
-
 template <typename Char, FMT_ENABLE_IF(!std::is_same<Char, char>::value)>
-auto vformat(basic_string_view<Char> fmt,
-             typename detail::vformat_args<Char>::type args)
+auto vformat(basic_string_view<Char> format_str,
+             basic_format_args<buffer_context<type_identity_t<Char>>> args)
    -> std::basic_string<Char> {
-  auto buf = basic_memory_buffer<Char>();
-  detail::vformat_to(buf, fmt, args);
-  return {buf.data(), buf.size()};
+  basic_memory_buffer<Char> buffer;
+  detail::vformat_to(buffer, format_str, args);
+  return to_string(buffer);
 }

 template <typename... T>
@ -173,130 +88,119 @@ auto format(wformat_string<T...> fmt, T&&... args) -> std::wstring {
  return vformat(fmt::wstring_view(fmt), fmt::make_wformat_args(args...));
 }

-template <typename OutputIt, typename... T>
-auto format_to(OutputIt out, wformat_string<T...> fmt, T&&... args)
-    -> OutputIt {
-  return vformat_to(out, 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... T,
-          typename Char = detail::format_string_char_t<S>,
+template <typename S, typename... Args, typename Char = char_t<S>,
          FMT_ENABLE_IF(!std::is_same<Char, char>::value &&
                        !std::is_same<Char, wchar_t>::value)>
-auto format(const S& fmt, T&&... args) -> std::basic_string<Char> {
-  return vformat(detail::to_string_view(fmt),
-                 fmt::make_format_args<buffered_context<Char>>(args...));
+auto format(const S& format_str, Args&&... args) -> std::basic_string<Char> {
+  return vformat(detail::to_string_view(format_str),
+                 fmt::make_format_args<buffer_context<Char>>(args...));
 }

-template <typename Locale, typename S,
-          typename Char = detail::format_string_char_t<S>,
+template <typename Locale, typename S, typename Char = char_t<S>,
          FMT_ENABLE_IF(detail::is_locale<Locale>::value&&
                            detail::is_exotic_char<Char>::value)>
-inline auto vformat(const Locale& loc, const S& fmt,
-                    typename detail::vformat_args<Char>::type args)
+inline auto vformat(
+    const Locale& loc, const S& format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args)
    -> std::basic_string<Char> {
-  auto buf = basic_memory_buffer<Char>();
-  detail::vformat_to(buf, detail::to_string_view(fmt), args,
-                     detail::locale_ref(loc));
-  return {buf.data(), buf.size()};
+  return detail::vformat(loc, detail::to_string_view(format_str), args);
 }

-template <typename Locale, typename S, typename... T,
-          typename Char = detail::format_string_char_t<S>,
+template <typename Locale, typename S, typename... Args,
+          typename Char = char_t<S>,
          FMT_ENABLE_IF(detail::is_locale<Locale>::value&&
                            detail::is_exotic_char<Char>::value)>
-inline auto format(const Locale& loc, const S& fmt, T&&... args)
+inline auto format(const Locale& loc, const S& format_str, Args&&... args)
    -> std::basic_string<Char> {
-  return vformat(loc, detail::to_string_view(fmt),
-                 fmt::make_format_args<buffered_context<Char>>(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 = detail::format_string_char_t<S>,
+template <typename OutputIt, typename S, typename Char = char_t<S>,
          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
                            detail::is_exotic_char<Char>::value)>
-auto vformat_to(OutputIt out, const S& fmt,
-                typename detail::vformat_args<Char>::type args) -> OutputIt {
+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, detail::to_string_view(fmt), args);
-  return detail::get_iterator(buf, out);
+  detail::vformat_to(buf, detail::to_string_view(format_str), args);
+  return detail::get_iterator(buf);
 }

-template <typename OutputIt, typename S, typename... T,
-          typename Char = detail::format_string_char_t<S>,
-          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value &&
-                        !std::is_same<Char, char>::value &&
-                        !std::is_same<Char, wchar_t>::value)>
-inline auto format_to(OutputIt out, const S& fmt, T&&... args) -> OutputIt {
+template <typename OutputIt, typename S, typename... Args,
+          typename Char = char_t<S>,
+          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 {
  return vformat_to(out, detail::to_string_view(fmt),
-                    fmt::make_format_args<buffered_context<Char>>(args...));
+                    fmt::make_format_args<buffer_context<Char>>(args...));
 }

 template <typename Locale, typename S, typename OutputIt, typename... Args,
-          typename Char = detail::format_string_char_t<S>,
+          typename Char = char_t<S>,
          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
                            detail::is_locale<Locale>::value&&
                                detail::is_exotic_char<Char>::value)>
-inline auto vformat_to(OutputIt out, const Locale& loc, const S& fmt,
-                       typename detail::vformat_args<Char>::type args)
-    -> OutputIt {
+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, detail::to_string_view(fmt), args, detail::locale_ref(loc));
-  return detail::get_iterator(buf, out);
+  vformat_to(buf, detail::to_string_view(format_str), args,
+             detail::locale_ref(loc));
+  return detail::get_iterator(buf);
 }

-template <typename Locale, typename OutputIt, typename S, typename... T,
-          typename Char = detail::format_string_char_t<S>,
-          bool enable = detail::is_output_iterator<OutputIt, Char>::value &&
-                        detail::is_locale<Locale>::value &&
-                        detail::is_exotic_char<Char>::value>
-inline auto format_to(OutputIt out, const Locale& loc, const S& fmt,
-                      T&&... args) ->
+template <
+    typename OutputIt, typename Locale, typename S, typename... Args,
+    typename Char = char_t<S>,
+    bool enable = detail::is_output_iterator<OutputIt, Char>::value&&
+        detail::is_locale<Locale>::value&& detail::is_exotic_char<Char>::value>
+inline auto format_to(OutputIt out, const Locale& loc, const S& format_str,
+                      Args&&... args) ->
    typename std::enable_if<enable, OutputIt>::type {
-  return vformat_to(out, loc, detail::to_string_view(fmt),
-                    fmt::make_format_args<buffered_context<Char>>(args...));
+  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,
          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
                            detail::is_exotic_char<Char>::value)>
-inline auto vformat_to_n(OutputIt out, size_t n, basic_string_view<Char> fmt,
-                         typename detail::vformat_args<Char>::type args)
+inline auto vformat_to_n(
+    OutputIt out, size_t n, basic_string_view<Char> format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args)
    -> format_to_n_result<OutputIt> {
-  using traits = detail::fixed_buffer_traits;
-  auto buf = detail::iterator_buffer<OutputIt, Char, traits>(out, n);
-  detail::vformat_to(buf, fmt, args);
+  detail::iterator_buffer<OutputIt, Char, detail::fixed_buffer_traits> buf(out,
+                                                                           n);
+  detail::vformat_to(buf, format_str, args);
  return {buf.out(), buf.count()};
 }

-template <typename OutputIt, typename S, typename... T,
-          typename Char = detail::format_string_char_t<S>,
+template <typename OutputIt, typename S, typename... Args,
+          typename Char = char_t<S>,
          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
                            detail::is_exotic_char<Char>::value)>
-inline auto format_to_n(OutputIt out, size_t n, const S& fmt, T&&... args)
-    -> format_to_n_result<OutputIt> {
-  return vformat_to_n(out, n, fmt::basic_string_view<Char>(fmt),
-                      fmt::make_format_args<buffered_context<Char>>(args...));
+inline auto format_to_n(OutputIt out, size_t n, const S& fmt,
+                        const Args&... args) -> format_to_n_result<OutputIt> {
+  return vformat_to_n(out, n, detail::to_string_view(fmt),
+                      fmt::make_format_args<buffer_context<Char>>(args...));
 }

-template <typename S, typename... T,
-          typename Char = detail::format_string_char_t<S>,
+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, T&&... args) -> size_t {
-  auto buf = detail::counting_buffer<Char>();
+inline auto formatted_size(const S& fmt, Args&&... args) -> size_t {
+  detail::counting_buffer<Char> buf;
  detail::vformat_to(buf, detail::to_string_view(fmt),
-                     fmt::make_format_args<buffered_context<Char>>(args...));
+                     fmt::make_format_args<buffer_context<Char>>(args...));
  return buf.count();
 }

 inline void vprint(std::FILE* f, wstring_view fmt, wformat_args args) {
-  auto buf = wmemory_buffer();
-  detail::vformat_to(buf, fmt, args);
-  buf.push_back(L'\0');
-  if (std::fputws(buf.data(), f) == -1)
+  wmemory_buffer buffer;
+  detail::vformat_to(buffer, fmt, args);
+  buffer.push_back(L'\0');
+  if (std::fputws(buffer.data(), f) == -1)
    FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
 }

@ -313,61 +217,13 @@ template <typename... T> void print(wformat_string<T...> fmt, T&&... args) {
  return vprint(wstring_view(fmt), fmt::make_wformat_args(args...));
 }

-template <typename... T>
-void println(std::FILE* f, wformat_string<T...> fmt, T&&... args) {
-  return print(f, L"{}\n", fmt::format(fmt, std::forward<T>(args)...));
-}
-
-template <typename... T> void println(wformat_string<T...> fmt, T&&... args) {
-  return print(L"{}\n", fmt::format(fmt, std::forward<T>(args)...));
-}
-
-inline auto vformat(const text_style& ts, wstring_view fmt, wformat_args args)
-    -> std::wstring {
-  auto buf = wmemory_buffer();
-  detail::vformat_to(buf, ts, fmt, args);
-  return {buf.data(), buf.size()};
-}
-
-template <typename... T>
-inline auto format(const text_style& ts, wformat_string<T...> fmt, T&&... args)
-    -> std::wstring {
-  return fmt::vformat(ts, fmt, fmt::make_wformat_args(args...));
-}
-
-template <typename... T>
-FMT_DEPRECATED void print(std::FILE* f, const text_style& ts,
-                          wformat_string<T...> fmt, const T&... args) {
-  vprint(f, ts, fmt, fmt::make_wformat_args(args...));
-}
-
-template <typename... T>
-FMT_DEPRECATED void print(const text_style& ts, wformat_string<T...> fmt,
-                          const T&... args) {
-  return print(stdout, ts, fmt, args...);
-}
-
-inline void vprint(std::wostream& os, wstring_view fmt, wformat_args args) {
-  auto buffer = basic_memory_buffer<wchar_t>();
-  detail::vformat_to(buffer, fmt, args);
-  detail::write_buffer(os, buffer);
-}
-
-template <typename... T>
-void print(std::wostream& os, wformat_string<T...> fmt, T&&... args) {
-  vprint(os, fmt, fmt::make_format_args<buffered_context<wchar_t>>(args...));
-}
-
-template <typename... T>
-void println(std::wostream& os, wformat_string<T...> fmt, T&&... args) {
-  print(os, L"{}\n", fmt::format(fmt, std::forward<T>(args)...));
-}
-
-/// Converts `value` to `std::wstring` using the default format for type `T`.
+/**
+  Converts *value* to ``std::wstring`` using the default format for type *T*.
+ */
 template <typename T> inline auto to_wstring(const T& value) -> std::wstring {
  return format(FMT_STRING(L"{}"), value);
 }
-FMT_END_EXPORT
+FMT_MODULE_EXPORT_END
 FMT_END_NAMESPACE

 #endif  // FMT_XCHAR_H_
--- a/include/spdlog/fmt/fmt.h
+++ b/include/spdlog/fmt/fmt.h
@ -20,6 +20,10 @@
    #ifndef FMT_USE_WINDOWS_H
        #define FMT_USE_WINDOWS_H 0
    #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>
--- a/include/spdlog/mdc.h
+++ b/include/spdlog/mdc.h
@ -1,50 +0,0 @@
-// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-
-#pragma once
-
-#if defined(SPDLOG_NO_TLS)
-    #error "This header requires thread local storage support, but SPDLOG_NO_TLS is defined."
-#endif
-
-#include <map>
-#include <string>
-
-#include <spdlog/common.h>
-
-// MDC is a simple map of key->string values stored in thread local storage whose content will be printed by the loggers.
-// Note: Not supported in async mode (thread local storage - so the async thread pool have different copy).
-//
-// Usage example:
-// spdlog::mdc::put("mdc_key_1", "mdc_value_1");
-// spdlog::info("Hello, {}", "World!");  // => [2024-04-26 02:08:05.040] [info] [mdc_key_1:mdc_value_1] Hello, World!
-
-namespace spdlog {
-class SPDLOG_API mdc {
-public:
-    using mdc_map_t = std::map<std::string, std::string>;
-
-    static void put(const std::string &key, const std::string &value) {
-        get_context()[key] = value;
-    }
-
-    static std::string get(const std::string &key) {
-        auto &context = get_context();
-        auto it = context.find(key);
-        if (it != context.end()) {
-            return it->second;
-        }
-        return "";
-    }
-
-    static void remove(const std::string &key) { get_context().erase(key); }
-
-    static void clear() { get_context().clear(); }
-
-    static mdc_map_t &get_context() {
-        static thread_local mdc_map_t context;
-        return context;
-    }
-};
-
-}  // namespace spdlog
--- a/include/spdlog/pattern_formatter-inl.h
+++ b/include/spdlog/pattern_formatter-inl.h
@ -10,11 +10,6 @@
 #include <spdlog/details/fmt_helper.h>
 #include <spdlog/details/log_msg.h>
 #include <spdlog/details/os.h>
-
-#ifndef SPDLOG_NO_TLS
-    #include <spdlog/mdc.h>
-#endif
-
 #include <spdlog/fmt/fmt.h>
 #include <spdlog/formatter.h>

@ -70,9 +65,6 @@ public:
            pad_it(remaining_pad_);
        } else if (padinfo_.truncate_) {
            long new_size = static_cast<long>(dest_.size()) + remaining_pad_;
-            if (new_size < 0) {
-                new_size = 0;
-            }
            dest_.resize(static_cast<size_t>(new_size));
        }
    }
@ -183,7 +175,7 @@ public:

 // Abbreviated month
 static const std::array<const char *, 12> months{
-    {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}};
+    {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sept", "Oct", "Nov", "Dec"}};

 template <typename ScopedPadder>
 class b_formatter final : public flag_formatter {
@ -267,7 +259,7 @@ public:
        : flag_formatter(padinfo) {}

    void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override {
-        const size_t field_size = 8;
+        const size_t field_size = 10;
        ScopedPadder p(field_size, padinfo_, dest);

        fmt_helper::pad2(tm_time.tm_mon + 1, dest);
@ -791,49 +783,6 @@ private:
    log_clock::time_point last_message_time_;
 };

-// Class for formatting Mapped Diagnostic Context (MDC) in log messages.
-// Example: [logger-name] [info] [mdc_key_1:mdc_value_1 mdc_key_2:mdc_value_2] some message
-#ifndef SPDLOG_NO_TLS
-template <typename ScopedPadder>
-class mdc_formatter : public flag_formatter {
-public:
-    explicit mdc_formatter(padding_info padinfo)
-        : flag_formatter(padinfo) {}
-
-    void format(const details::log_msg &, const std::tm &, memory_buf_t &dest) override {
-        auto &mdc_map = mdc::get_context();
-        if (mdc_map.empty()) {
-            ScopedPadder p(0, padinfo_, dest);
-            return;
-        } else {
-            format_mdc(mdc_map, dest);
-        }
-    }
-
-    void format_mdc(const mdc::mdc_map_t &mdc_map, memory_buf_t &dest) {
-        auto last_element = --mdc_map.end();
-        for (auto it = mdc_map.begin(); it != mdc_map.end(); ++it) {
-            auto &pair = *it;
-            const auto &key = pair.first;
-            const auto &value = pair.second;
-            size_t content_size = key.size() + value.size() + 1;  // 1 for ':'
-
-            if (it != last_element) {
-                content_size++;  // 1 for ' '
-            }
-
-            ScopedPadder p(content_size, padinfo_, dest);
-            fmt_helper::append_string_view(key, dest);
-            fmt_helper::append_string_view(":", dest);
-            fmt_helper::append_string_view(value, dest);
-            if (it != last_element) {
-                fmt_helper::append_string_view(" ", dest);
-            }
-        }
-    }
-};
-#endif
-
 // Full info formatter
 // pattern: [%Y-%m-%d %H:%M:%S.%e] [%n] [%l] [%s:%#] %v
 class full_formatter final : public flag_formatter {
@ -909,17 +858,6 @@ public:
            dest.push_back(']');
            dest.push_back(' ');
        }
-
-#ifndef SPDLOG_NO_TLS
-        // add mdc if present
-        auto &mdc_map = mdc::get_context();
-        if (!mdc_map.empty()) {
-            dest.push_back('[');
-            mdc_formatter_.format_mdc(mdc_map, dest);
-            dest.push_back(']');
-            dest.push_back(' ');
-        }
-#endif
        // fmt_helper::append_string_view(msg.msg(), dest);
        fmt_helper::append_string_view(msg.payload, dest);
    }
@ -927,10 +865,6 @@ public:
 private:
    std::chrono::seconds cache_timestamp_{0};
    memory_buf_t cached_datetime_;
-
-#ifndef SPDLOG_NO_TLS
-    mdc_formatter<null_scoped_padder> mdc_formatter_{padding_info {}};
-#endif
 };

 }  // namespace details
@ -1225,12 +1159,6 @@ SPDLOG_INLINE void pattern_formatter::handle_flag_(char flag, details::padding_i
                    padding));
            break;

-#ifndef SPDLOG_NO_TLS  // mdc formatter requires TLS support
-        case ('&'):
-            formatters_.push_back(details::make_unique<details::mdc_formatter<Padder>>(padding));
-            break;
-#endif
-
        default:  // Unknown flag appears as is
            auto unknown_flag = details::make_unique<details::aggregate_formatter>();

--- a/include/spdlog/sinks/ansicolor_sink-inl.h
+++ b/include/spdlog/sinks/ansicolor_sink-inl.h
@ -20,7 +20,7 @@ SPDLOG_INLINE ansicolor_sink<ConsoleMutex>::ansicolor_sink(FILE *target_file, co
      formatter_(details::make_unique<spdlog::pattern_formatter>())

 {
-    set_color_mode_(mode);
+    set_color_mode(mode);
    colors_.at(level::trace) = to_string_(white);
    colors_.at(level::debug) = to_string_(cyan);
    colors_.at(level::info) = to_string_(green);
@ -82,18 +82,12 @@ SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_formatter(
 }

 template <typename ConsoleMutex>
-SPDLOG_INLINE bool ansicolor_sink<ConsoleMutex>::should_color() const {
+SPDLOG_INLINE bool ansicolor_sink<ConsoleMutex>::should_color() {
    return should_do_colors_;
 }

 template <typename ConsoleMutex>
 SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color_mode(color_mode mode) {
-    std::lock_guard<mutex_t> lock(mutex_);
-    set_color_mode_(mode);
-}
-
-template <typename ConsoleMutex>
-SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color_mode_(color_mode mode) {
    switch (mode) {
        case color_mode::always:
            should_do_colors_ = true;
@ -111,15 +105,15 @@ SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color_mode_(color_mode mode
 }

 template <typename ConsoleMutex>
-SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::print_ccode_(const string_view_t &color_code) const {
-    details::os::fwrite_bytes(color_code.data(), color_code.size(), target_file_);
+SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::print_ccode_(const string_view_t &color_code) {
+    fwrite(color_code.data(), sizeof(char), color_code.size(), target_file_);
 }

 template <typename ConsoleMutex>
 SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::print_range_(const memory_buf_t &formatted,
                                                              size_t start,
-                                                              size_t end) const {
-    details::os::fwrite_bytes(formatted.data() + start, end - start, target_file_);
+                                                              size_t end) {
+    fwrite(formatted.data() + start, sizeof(char), end - start, target_file_);
 }

 template <typename ConsoleMutex>
--- a/include/spdlog/sinks/ansicolor_sink.h
+++ b/include/spdlog/sinks/ansicolor_sink.h
@ -36,11 +36,11 @@ public:

    void set_color(level::level_enum color_level, string_view_t color);
    void set_color_mode(color_mode mode);
-    bool should_color() const;
+    bool should_color();

    void log(const details::log_msg &msg) override;
    void flush() override;
-    void set_pattern(const std::string &pattern) final override;
+    void set_pattern(const std::string &pattern) final;
    void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) override;

    // Formatting codes
@ -84,9 +84,8 @@ private:
    bool should_do_colors_;
    std::unique_ptr<spdlog::formatter> formatter_;
    std::array<std::string, level::n_levels> colors_;
-    void set_color_mode_(color_mode mode);
-    void print_ccode_(const string_view_t &color_code) const;
-    void print_range_(const memory_buf_t &formatted, size_t start, size_t end) const;
+    void print_ccode_(const string_view_t &color_code);
+    void print_range_(const memory_buf_t &formatted, size_t start, size_t end);
    static std::string to_string_(const string_view_t &sv);
 };

--- a/include/spdlog/sinks/base_sink.h
+++ b/include/spdlog/sinks/base_sink.h
@ -28,10 +28,10 @@ public:
    base_sink &operator=(const base_sink &) = delete;
    base_sink &operator=(base_sink &&) = delete;

-    void log(const details::log_msg &msg) final override;
-    void flush() final override;
-    void set_pattern(const std::string &pattern) final override;
-    void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) final override;
+    void log(const details::log_msg &msg) final;
+    void flush() final;
+    void set_pattern(const std::string &pattern) final;
+    void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) final;

 protected:
    // sink formatter
--- a/include/spdlog/sinks/basic_file_sink-inl.h
+++ b/include/spdlog/sinks/basic_file_sink-inl.h
@ -26,12 +26,6 @@ SPDLOG_INLINE const filename_t &basic_file_sink<Mutex>::filename() const {
    return file_helper_.filename();
 }

-template <typename Mutex>
-SPDLOG_INLINE void basic_file_sink<Mutex>::truncate() {
-    std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
-    file_helper_.reopen(true);
-}
-
 template <typename Mutex>
 SPDLOG_INLINE void basic_file_sink<Mutex>::sink_it_(const details::log_msg &msg) {
    memory_buf_t formatted;
--- a/include/spdlog/sinks/basic_file_sink.h
+++ b/include/spdlog/sinks/basic_file_sink.h
@ -23,7 +23,6 @@ public:
                             bool truncate = false,
                             const file_event_handlers &event_handlers = {});
    const filename_t &filename() const;
-    void truncate();

 protected:
    void sink_it_(const details::log_msg &msg) override;
--- a/include/spdlog/sinks/callback_sink.h
+++ b/include/spdlog/sinks/callback_sink.h
@ -27,7 +27,7 @@ public:

 protected:
    void sink_it_(const details::log_msg &msg) override { callback_(msg); }
-    void flush_() override{}
+    void flush_() override{};

 private:
    custom_log_callback callback_;
--- a/include/spdlog/sinks/daily_file_sink.h
+++ b/include/spdlog/sinks/daily_file_sink.h
@ -62,8 +62,6 @@ struct daily_filename_format_calculator {
 * Rotating file sink based on date.
 * If truncate != false , the created file will be truncated.
 * If max_files > 0, retain only the last max_files and delete previous.
- * Note that old log files from previous executions will not be deleted by this class,
- * rotation and deletion is only applied while the program is running.
 */
 template <typename Mutex, typename FileNameCalc = daily_filename_calculator>
 class daily_file_sink final : public base_sink<Mutex> {
--- a/include/spdlog/sinks/dup_filter_sink.h
+++ b/include/spdlog/sinks/dup_filter_sink.h
@ -40,21 +40,22 @@ template <typename Mutex>
 class dup_filter_sink : public dist_sink<Mutex> {
 public:
    template <class Rep, class Period>
-    explicit dup_filter_sink(std::chrono::duration<Rep, Period> max_skip_duration)
-        : max_skip_duration_{max_skip_duration} {}
+    explicit dup_filter_sink(std::chrono::duration<Rep, Period> max_skip_duration,
+                             level::level_enum notification_level = level::info)
+        : max_skip_duration_{max_skip_duration},
+          log_level_{notification_level} {}

 protected:
    std::chrono::microseconds max_skip_duration_;
    log_clock::time_point last_msg_time_;
    std::string last_msg_payload_;
    size_t skip_counter_ = 0;
-    level::level_enum skipped_msg_log_level_ = spdlog::level::level_enum::off;
+    level::level_enum log_level_;

    void sink_it_(const details::log_msg &msg) override {
        bool filtered = filter_(msg);
        if (!filtered) {
            skip_counter_ += 1;
-            skipped_msg_log_level_ = msg.level;
            return;
        }

@ -64,7 +65,7 @@ protected:
            auto msg_size = ::snprintf(buf, sizeof(buf), "Skipped %u duplicate messages..",
                                       static_cast<unsigned>(skip_counter_));
            if (msg_size > 0 && static_cast<size_t>(msg_size) < sizeof(buf)) {
-                details::log_msg skipped_msg{msg.source, msg.logger_name, skipped_msg_log_level_,
+                details::log_msg skipped_msg{msg.source, msg.logger_name, log_level_,
                                             string_view_t{buf, static_cast<size_t>(msg_size)}};
                dist_sink<Mutex>::sink_it_(skipped_msg);
            }
--- a/include/spdlog/sinks/hourly_file_sink.h
+++ b/include/spdlog/sinks/hourly_file_sink.h
@ -39,8 +39,6 @@ struct hourly_filename_calculator {
 * Rotating file sink based on time.
 * If truncate != false , the created file will be truncated.
 * If max_files > 0, retain only the last max_files and delete previous.
- * Note that old log files from previous executions will not be deleted by this class,
- * rotation and deletion is only applied while the program is running.
 */
 template <typename Mutex, typename FileNameCalc = hourly_filename_calculator>
 class hourly_file_sink final : public base_sink<Mutex> {
--- a/include/spdlog/sinks/msvc_sink.h
+++ b/include/spdlog/sinks/msvc_sink.h
@ -32,7 +32,7 @@ class msvc_sink : public base_sink<Mutex> {
 public:
    msvc_sink() = default;
    msvc_sink(bool check_debugger_present)
-        : check_debugger_present_{check_debugger_present} {}
+        : check_debugger_present_{check_debugger_present} {};

 protected:
    void sink_it_(const details::log_msg &msg) override {
--- a/include/spdlog/sinks/null_sink.h
+++ b/include/spdlog/sinks/null_sink.h
@ -13,7 +13,7 @@ namespace spdlog {
 namespace sinks {

 template <typename Mutex>
-class null_sink final : public base_sink<Mutex> {
+class null_sink : public base_sink<Mutex> {
 protected:
    void sink_it_(const details::log_msg &) override {}
    void flush_() override {}
--- a/include/spdlog/sinks/qt_sinks.h
+++ b/include/spdlog/sinks/qt_sinks.h
@ -4,7 +4,7 @@
 #pragma once

 //
-// Custom sink for QPlainTextEdit or QTextEdit and its children (QTextBrowser...
+// Custom sink for QPlainTextEdit or QTextEdit and its childs(QTextBrowser...
 // etc) Building and using requires Qt library.
 //
 // Warning: the qt_sink won't be notified if the target widget is destroyed.
@ -56,7 +56,7 @@ private:
    std::string meta_method_;
 };

-// Qt color sink to QTextEdit.
+// QT color sink to QTextEdit.
 // Color location is determined by the sink log pattern like in the rest of spdlog sinks.
 // Colors can be modified if needed using sink->set_color(level, qtTextCharFormat).
 // max_lines is the maximum number of lines that the sink will hold before removing the oldest
@ -282,7 +282,7 @@ inline std::shared_ptr<logger> qt_logger_st(const std::string &logger_name,
    return Factory::template create<sinks::qt_sink_st>(logger_name, qt_object, meta_method);
 }

-// log to QTextEdit with colorized output
+// log to QTextEdit with colorize output
 template <typename Factory = spdlog::synchronous_factory>
 inline std::shared_ptr<logger> qt_color_logger_mt(const std::string &logger_name,
                                                  QTextEdit *qt_text_edit,
--- a/include/spdlog/sinks/rotating_file_sink-inl.h
+++ b/include/spdlog/sinks/rotating_file_sink-inl.h
@ -60,7 +60,7 @@ SPDLOG_INLINE filename_t rotating_file_sink<Mutex>::calc_filename(const filename

    filename_t basename, ext;
    std::tie(basename, ext) = details::file_helper::split_by_extension(filename);
-    return fmt_lib::format(SPDLOG_FMT_STRING(SPDLOG_FILENAME_T("{}.{}{}")), basename, index, ext);
+    return fmt_lib::format(SPDLOG_FILENAME_T("{}.{}{}"), basename, index, ext);
 }

 template <typename Mutex>
@ -69,12 +69,6 @@ SPDLOG_INLINE filename_t rotating_file_sink<Mutex>::filename() {
    return file_helper_.filename();
 }

-template <typename Mutex>
-SPDLOG_INLINE void rotating_file_sink<Mutex>::rotate_now() {
-    std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
-    rotate_();
-}
-
 template <typename Mutex>
 SPDLOG_INLINE void rotating_file_sink<Mutex>::sink_it_(const details::log_msg &msg) {
    memory_buf_t formatted;
--- a/include/spdlog/sinks/rotating_file_sink.h
+++ b/include/spdlog/sinks/rotating_file_sink.h
@ -28,7 +28,6 @@ public:
                       const file_event_handlers &event_handlers = {});
    static filename_t calc_filename(const filename_t &filename, std::size_t index);
    filename_t filename();
-    void rotate_now();

 protected:
    void sink_it_(const details::log_msg &msg) override;
--- a/include/spdlog/sinks/stdout_sinks-inl.h
+++ b/include/spdlog/sinks/stdout_sinks-inl.h
@ -10,7 +10,6 @@
 #include <memory>
 #include <spdlog/details/console_globals.h>
 #include <spdlog/pattern_formatter.h>
-#include <spdlog/details/os.h>

 #ifdef _WIN32
    // under windows using fwrite to non-binary stream results in \r\r\n (see issue #1675)
@ -23,7 +22,7 @@

    #include <io.h>     // _get_osfhandle(..)
    #include <stdio.h>  // _fileno(..)
-#endif                  // _WIN32
+#endif                  // WIN32

 namespace spdlog {

@ -45,7 +44,7 @@ SPDLOG_INLINE stdout_sink_base<ConsoleMutex>::stdout_sink_base(FILE *file)
    if (handle_ == INVALID_HANDLE_VALUE && file != stdout && file != stderr) {
        throw_spdlog_ex("spdlog::stdout_sink_base: _get_osfhandle() failed", errno);
    }
-#endif  // _WIN32
+#endif  // WIN32
 }

 template <typename ConsoleMutex>
@ -68,8 +67,8 @@ SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::log(const details::log_msg &m
    std::lock_guard<mutex_t> lock(mutex_);
    memory_buf_t formatted;
    formatter_->format(msg, formatted);
-    details::os::fwrite_bytes(formatted.data(), formatted.size(), file_);
-#endif                // _WIN32
+    ::fwrite(formatted.data(), sizeof(char), formatted.size(), file_);
+#endif                // WIN32
    ::fflush(file_);  // flush every line to terminal
 }

--- a/include/spdlog/sinks/syslog_sink.h
+++ b/include/spdlog/sinks/syslog_sink.h
@ -64,14 +64,13 @@ protected:
    //
    // Simply maps spdlog's log level to syslog priority level.
    //
-    virtual int syslog_prio_from_level(const details::log_msg &msg) const {
+    int syslog_prio_from_level(const details::log_msg &msg) const {
        return syslog_levels_.at(static_cast<levels_array::size_type>(msg.level));
    }

+private:
    using levels_array = std::array<int, 7>;
    levels_array syslog_levels_;
-
-private:
    // must store the ident because the man says openlog might use the pointer as
    // is and not a string copy
    const std::string ident_;
--- a/include/spdlog/sinks/wincolor_sink-inl.h
+++ b/include/spdlog/sinks/wincolor_sink-inl.h
@ -134,18 +134,9 @@ void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::print_range_(const memory_buf_t
                                                             size_t start,
                                                             size_t end) {
    if (end > start) {
-#if defined(SPDLOG_UTF8_TO_WCHAR_CONSOLE)
-        wmemory_buf_t wformatted;
-        details::os::utf8_to_wstrbuf(string_view_t(formatted.data() + start, end - start),
-            wformatted);
-        auto size = static_cast<DWORD>(wformatted.size());
-        auto ignored = ::WriteConsoleW(static_cast<HANDLE>(out_handle_), wformatted.data(), size,
-            nullptr, nullptr);
-#else
        auto size = static_cast<DWORD>(end - start);
        auto ignored = ::WriteConsoleA(static_cast<HANDLE>(out_handle_), formatted.data() + start,
                                       size, nullptr, nullptr);
-#endif
        (void)(ignored);
    }
 }
--- a/include/spdlog/stopwatch.h
+++ b/include/spdlog/stopwatch.h
@ -39,10 +39,6 @@ public:
        return std::chrono::duration<double>(clock::now() - start_tp_);
    }

-    std::chrono::milliseconds elapsed_ms() const {
-        return std::chrono::duration_cast<std::chrono::milliseconds>(clock::now() - start_tp_);
-    }
-
    void reset() { start_tp_ = clock::now(); }
 };
 }  // namespace spdlog
--- a/include/spdlog/tweakme.h
+++ b/include/spdlog/tweakme.h
@ -104,13 +104,6 @@
 //
 // #define SPDLOG_LEVEL_NAMES { "MY TRACE", "MY DEBUG", "MY INFO", "MY WARNING", "MY ERROR", "MY
 // CRITICAL", "OFF" }
-//
-// For C++17 use string_view_literals:
-//
-// #include <string_view>
-// using namespace std::string_view_literals;
-// #define SPDLOG_LEVEL_NAMES { "MY TRACE"sv, "MY DEBUG"sv, "MY INFO"sv, "MY WARNING"sv, "MY ERROR"sv, "MY
-// CRITICAL"sv, "OFF"sv }
 ///////////////////////////////////////////////////////////////////////////////

 ///////////////////////////////////////////////////////////////////////////////
--- a/include/spdlog/version.h
+++ b/include/spdlog/version.h
@ -4,8 +4,8 @@
 #pragma once

 #define SPDLOG_VER_MAJOR 1
-#define SPDLOG_VER_MINOR 15
-#define SPDLOG_VER_PATCH 2
+#define SPDLOG_VER_MINOR 13
+#define SPDLOG_VER_PATCH 0

 #define SPDLOG_TO_VERSION(major, minor, patch) (major * 10000 + minor * 100 + patch)
 #define SPDLOG_VERSION SPDLOG_TO_VERSION(SPDLOG_VER_MAJOR, SPDLOG_VER_MINOR, SPDLOG_VER_PATCH)
--- a/src/bundled_fmtlib_format.cpp
+++ b/src/bundled_fmtlib_format.cpp
@ -1,4 +1,4 @@
-// Slightly modified version of fmt lib's format.cc source file.
+// Slightly modified version of fmt lib's format.cc (version 1.9.1) source file.
 // Copyright (c) 2012 - 2016, Victor Zverovich
 // All rights reserved.

@ -13,40 +13,37 @@
 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>;
+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>;

-#if FMT_USE_LOCALE
-// DEPRECATED! locale_ref in the detail namespace
-template FMT_API locale_ref::locale_ref(const std::locale& loc);
+    #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
+    #endif

 // Explicit instantiations for char.

-template FMT_API auto thousands_sep_impl(locale_ref)
-    -> thousands_sep_result<char>;
+template FMT_API auto thousands_sep_impl(locale_ref) -> thousands_sep_result<char>;
 template FMT_API auto decimal_point_impl(locale_ref) -> char;

-// DEPRECATED!
-template FMT_API void buffer<char>::append(const char*, const char*);
+template FMT_API void buffer<char>::append(const char *, const char *);

 // DEPRECATED!
-template FMT_API void vformat_to(buffer<char>&, string_view,
-                                 typename vformat_args<>::type, locale_ref);
+// 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 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*);
+template FMT_API void buffer<wchar_t>::append(const wchar_t *, const wchar_t *);

 }  // namespace detail
 FMT_END_NAMESPACE

-
 #endif  // !SPDLOG_FMT_EXTERNAL
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@ -48,8 +48,7 @@ set(SPDLOG_UTESTS_SOURCES
    test_cfg.cpp
    test_time_point.cpp
    test_stopwatch.cpp
-    test_circular_q.cpp
-    test_bin_to_hex.cpp)
+    test_circular_q.cpp)

 if(NOT SPDLOG_NO_EXCEPTIONS)
    list(APPEND SPDLOG_UTESTS_SOURCES test_errors.cpp)
@ -59,6 +58,10 @@ if(systemd_FOUND)
    list(APPEND SPDLOG_UTESTS_SOURCES test_systemd.cpp)
 endif()

+if(NOT SPDLOG_USE_STD_FORMAT)
+    list(APPEND SPDLOG_UTESTS_SOURCES test_bin_to_hex.cpp)
+endif()
+
 enable_testing()

 function(spdlog_prepare_test test_target spdlog_lib)
@ -70,10 +73,8 @@ function(spdlog_prepare_test test_target spdlog_lib)
    endif()
    target_link_libraries(${test_target} PRIVATE Catch2::Catch2WithMain)
    if(SPDLOG_SANITIZE_ADDRESS)
-        spdlog_enable_addr_sanitizer(${test_target})
-    elseif (SPDLOG_SANITIZE_THREAD)
-        spdlog_enable_thread_sanitizer(${test_target})
-    endif ()
+        spdlog_enable_sanitizer(${test_target})
+    endif()
    add_test(NAME ${test_target} COMMAND ${test_target})
    set_tests_properties(${test_target} PROPERTIES RUN_SERIAL ON)
 endfunction()
--- a/tests/includes.h
+++ b/tests/includes.h
@ -26,12 +26,6 @@
 #include "spdlog/spdlog.h"
 #include "spdlog/async.h"
 #include "spdlog/details/fmt_helper.h"
-#include "spdlog/details/os.h"
-
-#ifndef SPDLOG_NO_TLS
-    #include "spdlog/mdc.h"
-#endif
-
 #include "spdlog/sinks/basic_file_sink.h"
 #include "spdlog/sinks/daily_file_sink.h"
 #include "spdlog/sinks/null_sink.h"
--- a/tests/test_cfg.cpp
+++ b/tests/test_cfg.cpp
@ -19,15 +19,6 @@ TEST_CASE("env", "[cfg]") {
 #endif
    load_env_levels();
    REQUIRE(l1->level() == spdlog::level::warn);
-
-#ifdef CATCH_PLATFORM_WINDOWS
-    _putenv_s("MYAPP_LEVEL", "l1=trace");
-#else
-    setenv("MYAPP_LEVEL", "l1=trace", 1);
-#endif
-    load_env_levels("MYAPP_LEVEL");
-    REQUIRE(l1->level() == spdlog::level::trace);
-
    spdlog::set_default_logger(spdlog::create<test_sink_st>("cfg-default"));
    REQUIRE(spdlog::default_logger()->level() == spdlog::level::info);
 }
--- a/tests/test_create_dir.cpp
+++ b/tests/test_create_dir.cpp
@ -81,64 +81,3 @@ TEST_CASE("dir_name", "[create_dir]") {
    REQUIRE(dir_name(SPDLOG_FILENAME_T("../file.txt")) == SPDLOG_FILENAME_T(".."));
    REQUIRE(dir_name(SPDLOG_FILENAME_T("./file.txt")) == SPDLOG_FILENAME_T("."));
 }
-
-#ifdef _WIN32
-
-    //
-    // test windows cases when drive letter is given e.g. C:\\some-folder
-    //
-    #include <windows.h>
-    #include <fileapi.h>
-
-std::string get_full_path(const std::string &relative_folder_path) {
-    char full_path[MAX_PATH];
-
-    DWORD result = ::GetFullPathNameA(relative_folder_path.c_str(), MAX_PATH, full_path, nullptr);
-    // Return an empty string if failed to get full path
-    return result > 0 && result < MAX_PATH ? std::string(full_path) : std::string();
-}
-
-std::wstring get_full_path(const std::wstring &relative_folder_path) {
-    wchar_t full_path[MAX_PATH];
-    DWORD result = ::GetFullPathNameW(relative_folder_path.c_str(), MAX_PATH, full_path, nullptr);
-    return result > 0 && result < MAX_PATH ? std::wstring(full_path) : std::wstring();
-}
-
-spdlog::filename_t::value_type find_non_existing_drive() {
-    for (char drive = 'A'; drive <= 'Z'; ++drive) {
-        std::string root_path = std::string(1, drive) + ":\\";
-        UINT drive_type = GetDriveTypeA(root_path.c_str());
-        if (drive_type == DRIVE_NO_ROOT_DIR) {
-            return static_cast<spdlog::filename_t::value_type>(drive);
-        }
-    }
-    return '\0';  // No available drive found
-}
-
-TEST_CASE("create_abs_path1", "[create_dir]") {
-    prepare_logdir();
-    auto abs_path = get_full_path(SPDLOG_FILENAME_T("test_logs\\logdir1"));
-    REQUIRE(!abs_path.empty());
-    REQUIRE(create_dir(abs_path) == true);
-}
-
-TEST_CASE("create_abs_path2", "[create_dir]") {
-    prepare_logdir();
-    auto abs_path = get_full_path(SPDLOG_FILENAME_T("test_logs/logdir2"));
-    REQUIRE(!abs_path.empty());
-    REQUIRE(create_dir(abs_path) == true);
-}
-
-TEST_CASE("non_existing_drive", "[create_dir]") {
-    prepare_logdir();
-    spdlog::filename_t path;
-
-    auto non_existing_drive = find_non_existing_drive();
-    path += non_existing_drive;
-    path += SPDLOG_FILENAME_T(":\\");
-    REQUIRE(create_dir(path) == false);
-    path += SPDLOG_FILENAME_T("subdir");
-    REQUIRE(create_dir(path) == false);
-}
-// #endif  // SPDLOG_WCHAR_FILENAMES
-#endif  // _WIN32
--- a/tests/test_custom_callbacks.cpp
+++ b/tests/test_custom_callbacks.cpp
@ -16,8 +16,7 @@ TEST_CASE("custom_callback_logger", "[custom_callback_logger]") {
            spdlog::memory_buf_t formatted;
            formatter.format(msg, formatted);
            auto eol_len = strlen(spdlog::details::os::default_eol);
-            using diff_t = typename std::iterator_traits<decltype(formatted.end())>::difference_type; 
-            lines.emplace_back(formatted.begin(), formatted.end() - static_cast<diff_t>(eol_len));
+            lines.emplace_back(formatted.begin(), formatted.end() - eol_len);
        });
    std::shared_ptr<spdlog::sinks::test_sink_st> test_sink(new spdlog::sinks::test_sink_st);

--- a/tests/test_daily_logger.cpp
+++ b/tests/test_daily_logger.cpp
@ -46,10 +46,12 @@ TEST_CASE("daily_logger with dateonly calculator", "[daily_logger]") {

 struct custom_daily_file_name_calculator {
    static spdlog::filename_t calc_filename(const spdlog::filename_t &basename, const tm &now_tm) {
-        
-        return spdlog::fmt_lib::format(SPDLOG_FILENAME_T("{}{:04d}{:02d}{:02d}"),
+        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);
+
+        return SPDLOG_BUF_TO_STRING(w);
    }
 };

--- a/tests/test_errors.cpp
+++ b/tests/test_errors.cpp
@ -19,7 +19,7 @@ protected:
 };
 struct custom_ex {};

-#if !defined(SPDLOG_USE_STD_FORMAT)  // std format doesn't fully support runtime strings
+#if !defined(SPDLOG_USE_STD_FORMAT)  // std formt doesn't fully support tuntime strings
 TEST_CASE("default_error_handler", "[errors]") {
    prepare_logdir();
    spdlog::filename_t filename = SPDLOG_FILENAME_T(SIMPLE_LOG);
--- a/tests/test_file_helper.cpp
+++ b/tests/test_file_helper.cpp
@ -152,7 +152,7 @@ TEST_CASE("file_event_handlers", "[file_helper]") {
        helper.reopen(true);
        events.clear();
    }
-    // make sure that the file_helper destructor calls the close callbacks if needed
+    // make sure that the file_helper destrcutor calls the close callbacks if needed
    REQUIRE(events == std::vector<flags>{flags::before_close, flags::after_close});
    REQUIRE(file_contents(TEST_FILENAME) == "after_open\nbefore_close\n");
 }
--- a/tests/test_file_logging.cpp
+++ b/tests/test_file_logging.cpp
@ -45,26 +45,6 @@ TEST_CASE("flush_on", "[flush_on]") {
                                    default_eol, default_eol, default_eol));
 }

-TEST_CASE("simple_file_logger", "[truncate]") {
-    prepare_logdir();
-    const spdlog::filename_t filename = SPDLOG_FILENAME_T(SIMPLE_LOG);
-    const bool truncate = true;
-    const auto sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>(filename, truncate);
-    const auto logger = std::make_shared<spdlog::logger>("simple_file_logger", sink);
-
-    logger->info("Test message {}", 3.14);
-    logger->info("Test message {}", 2.71);
-    logger->flush();
-    REQUIRE(count_lines(SIMPLE_LOG) == 2);
-    
-    sink->truncate();
-    REQUIRE(count_lines(SIMPLE_LOG) == 0);
-
-    logger->info("Test message {}", 6.28);
-    logger->flush();
-    REQUIRE(count_lines(SIMPLE_LOG) == 1);
-}
-
 TEST_CASE("rotating_file_logger1", "[rotating_logger]") {
    prepare_logdir();
    size_t max_size = 1024 * 10;
@ -121,23 +101,3 @@ TEST_CASE("rotating_file_logger3", "[rotating_logger]") {
    REQUIRE_THROWS_AS(spdlog::rotating_logger_mt("logger", basename, max_size, 0),
                      spdlog::spdlog_ex);
 }
-
-// test on-demand rotation of logs
-TEST_CASE("rotating_file_logger4", "[rotating_logger]") {
-    prepare_logdir();
-    size_t max_size = 1024 * 10;
-    spdlog::filename_t basename = SPDLOG_FILENAME_T(ROTATING_LOG);
-    auto sink = std::make_shared<spdlog::sinks::rotating_file_sink_st>(basename, max_size, 2);
-    auto logger = std::make_shared<spdlog::logger>("rotating_sink_logger", sink);
-
-    logger->info("Test message - pre-rotation");
-    logger->flush();
-
-    sink->rotate_now();
-
-    logger->info("Test message - post-rotation");
-    logger->flush();
-
-    REQUIRE(get_filesize(ROTATING_LOG) > 0);
-    REQUIRE(get_filesize(ROTATING_LOG ".1") > 0);
-}
--- a/tests/test_misc.cpp
+++ b/tests/test_misc.cpp
@ -1,7 +1,3 @@
-#ifdef _WIN32 // to prevent fopen warning on windows
-#define _CRT_SECURE_NO_WARNINGS
-#endif
-
 #include "includes.h"
 #include "test_sink.h"

@ -109,9 +105,9 @@ TEST_CASE("clone-logger", "[clone]") {
 }

 TEST_CASE("clone async", "[clone]") {
-    using spdlog::sinks::test_sink_mt;
+    using spdlog::sinks::test_sink_st;
    spdlog::init_thread_pool(4, 1);
-    auto test_sink = std::make_shared<test_sink_mt>();
+    auto test_sink = std::make_shared<test_sink_st>();
    auto logger = std::make_shared<spdlog::async_logger>("orig", test_sink, spdlog::thread_pool());
    logger->set_pattern("%v");
    auto cloned = logger->clone("clone");
@ -171,52 +167,3 @@ TEST_CASE("default logger API", "[default logger]") {
    spdlog::drop_all();
    spdlog::set_pattern("%v");
 }
-
-#if (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && defined(_WIN32)
-TEST_CASE("utf8 to utf16 conversion using windows api", "[windows utf]") {
-    spdlog::wmemory_buf_t buffer;
-
-    spdlog::details::os::utf8_to_wstrbuf("", buffer);
-    REQUIRE(std::wstring(buffer.data(), buffer.size()) == std::wstring(L""));
-
-    spdlog::details::os::utf8_to_wstrbuf("abc", buffer);
-    REQUIRE(std::wstring(buffer.data(), buffer.size()) == std::wstring(L"abc"));
-
-    spdlog::details::os::utf8_to_wstrbuf("\xc3\x28", buffer); // Invalid UTF-8 sequence.
-    REQUIRE(std::wstring(buffer.data(), buffer.size()) == std::wstring(L"\xfffd("));
-
-    spdlog::details::os::utf8_to_wstrbuf("\xe3\x81\xad\xe3\x81\x93", buffer); // "Neko" in hiragana.
-    REQUIRE(std::wstring(buffer.data(), buffer.size()) == std::wstring(L"\x306d\x3053"));
-}
-#endif
-
-struct auto_closer {
-    FILE* fp = nullptr;
-    explicit auto_closer(FILE* f) : fp(f) {}
-    auto_closer(const auto_closer&) = delete;
-    auto_closer& operator=(const auto_closer&) = delete;
-    ~auto_closer() {
-        if (fp != nullptr) (void)std::fclose(fp);
-    }
-};
-
-TEST_CASE("os::fwrite_bytes", "[os]") {
-    using spdlog::details::os::fwrite_bytes;
-    using spdlog::details::os::create_dir;
-    const char* filename = "log_tests/test_fwrite_bytes.txt";
-    const char *msg = "hello";
-    prepare_logdir();
-    REQUIRE(create_dir(SPDLOG_FILENAME_T("log_tests")) == true);
-    {
-        auto_closer closer(std::fopen(filename, "wb"));
-        REQUIRE(closer.fp != nullptr);
-        REQUIRE(fwrite_bytes(msg, std::strlen(msg), closer.fp) == true);
-        REQUIRE(fwrite_bytes(msg, 0, closer.fp) == true);
-        std::fflush(closer.fp);
-        REQUIRE(spdlog::details::os::filesize(closer.fp) == 5);
-    }
-    // fwrite_bytes should return false on write failure
-    auto_closer closer(std::fopen(filename, "r"));
-    REQUIRE(closer.fp != nullptr);
-    REQUIRE_FALSE(fwrite_bytes("Hello", 5, closer.fp));
-}
--- a/tests/test_pattern_formatter.cpp
+++ b/tests/test_pattern_formatter.cpp
@ -1,8 +1,6 @@
 #include "includes.h"
 #include "test_sink.h"

-#include <chrono>
-
 using spdlog::memory_buf_t;
 using spdlog::details::to_string_view;

@ -21,21 +19,6 @@ static std::string log_to_str(const std::string &msg, const Args &...args) {
    return oss.str();
 }

-// log to str and return it with time
-template <typename... Args>
-static std::string log_to_str_with_time(spdlog::log_clock::time_point log_time, const std::string &msg, const Args &...args) {
-    std::ostringstream oss;
-    auto oss_sink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss);
-    spdlog::logger oss_logger("pattern_tester", oss_sink);
-    oss_logger.set_level(spdlog::level::info);
-
-    oss_logger.set_formatter(
-        std::unique_ptr<spdlog::formatter>(new spdlog::pattern_formatter(args...)));
-
-    oss_logger.log(log_time, {}, spdlog::level::info, msg);
-    return oss.str();
-}
-
 TEST_CASE("custom eol", "[pattern_formatter]") {
    std::string msg = "Hello custom eol test";
    std::string eol = ";)";
@ -75,15 +58,6 @@ TEST_CASE("date MM/DD/YY ", "[pattern_formatter]") {
            oss.str());
 }

-TEST_CASE("GMT offset ", "[pattern_formatter]") {
-    using namespace std::chrono_literals;
-    const auto now = std::chrono::system_clock::now();
-    const auto yesterday = now - 24h;
-
-    REQUIRE(log_to_str_with_time(yesterday, "Some message", "%z", spdlog::pattern_time_type::utc, "\n") ==
-            "+00:00\n");
-}
-
 TEST_CASE("color range test1", "[pattern_formatter]") {
    auto formatter = std::make_shared<spdlog::pattern_formatter>(
        "%^%v%$", spdlog::pattern_time_type::local, "\n");
@ -526,133 +500,3 @@ TEST_CASE("override need_localtime", "[pattern_formatter]") {
        REQUIRE(to_string_view(formatted) == oss.str());
    }
 }
-
-#ifndef SPDLOG_NO_TLS
-TEST_CASE("mdc formatter test-1", "[pattern_formatter]") {
-    spdlog::mdc::put("mdc_key_1", "mdc_value_1");
-    spdlog::mdc::put("mdc_key_2", "mdc_value_2");
-
-    auto formatter = std::make_shared<spdlog::pattern_formatter>();
-    formatter->set_pattern("[%n] [%l] [%&] %v");
-
-    memory_buf_t formatted;
-    spdlog::details::log_msg msg(spdlog::source_loc{}, "logger-name", spdlog::level::info,
-                                 "some message");
-    formatter->format(msg, formatted);
-
-    auto expected = spdlog::fmt_lib::format(
-        "[logger-name] [info] [mdc_key_1:mdc_value_1 mdc_key_2:mdc_value_2] some message{}",
-        spdlog::details::os::default_eol);
-    REQUIRE(to_string_view(formatted) == expected);
-
-    SECTION("Tear down") { spdlog::mdc::clear(); }
-}
-
-TEST_CASE("mdc formatter value update", "[pattern_formatter]") {
-    spdlog::mdc::put("mdc_key_1", "mdc_value_1");
-    spdlog::mdc::put("mdc_key_2", "mdc_value_2");
-
-    auto formatter = std::make_shared<spdlog::pattern_formatter>();
-    formatter->set_pattern("[%n] [%l] [%&] %v");
-
-    memory_buf_t formatted_1;
-    spdlog::details::log_msg msg(spdlog::source_loc{}, "logger-name", spdlog::level::info,
-                                 "some message");
-    formatter->format(msg, formatted_1);
-
-    auto expected = spdlog::fmt_lib::format(
-        "[logger-name] [info] [mdc_key_1:mdc_value_1 mdc_key_2:mdc_value_2] some message{}",
-        spdlog::details::os::default_eol);
-
-    REQUIRE(to_string_view(formatted_1) == expected);
-
-    spdlog::mdc::put("mdc_key_1", "new_mdc_value_1");
-    memory_buf_t formatted_2;
-    formatter->format(msg, formatted_2);
-    expected = spdlog::fmt_lib::format(
-        "[logger-name] [info] [mdc_key_1:new_mdc_value_1 mdc_key_2:mdc_value_2] some message{}",
-        spdlog::details::os::default_eol);
-
-    REQUIRE(to_string_view(formatted_2) == expected);
-
-    SECTION("Tear down") { spdlog::mdc::clear(); }
-}
-
-TEST_CASE("mdc different threads", "[pattern_formatter]") {
-    auto formatter = std::make_shared<spdlog::pattern_formatter>();
-    formatter->set_pattern("[%n] [%l] [%&] %v");
-    spdlog::details::log_msg msg(spdlog::source_loc{}, "logger-name", spdlog::level::info,
-                                 "some message");
-
-    memory_buf_t formatted_2;
-
-    auto lambda_1 = [formatter, msg]() {
-        spdlog::mdc::put("mdc_key", "thread_1_id");
-        memory_buf_t formatted;
-        formatter->format(msg, formatted);
-
-        auto expected =
-            spdlog::fmt_lib::format("[logger-name] [info] [mdc_key:thread_1_id] some message{}",
-                                    spdlog::details::os::default_eol);
-
-        REQUIRE(to_string_view(formatted) == expected);
-    };
-
-    auto lambda_2 = [formatter, msg]() {
-        spdlog::mdc::put("mdc_key", "thread_2_id");
-        memory_buf_t formatted;
-        formatter->format(msg, formatted);
-
-        auto expected =
-            spdlog::fmt_lib::format("[logger-name] [info] [mdc_key:thread_2_id] some message{}",
-                                    spdlog::details::os::default_eol);
-
-        REQUIRE(to_string_view(formatted) == expected);
-    };
-
-    std::thread thread_1(lambda_1);
-    std::thread thread_2(lambda_2);
-
-    thread_1.join();
-    thread_2.join();
-
-    SECTION("Tear down") { spdlog::mdc::clear(); }
-}
-
-TEST_CASE("mdc remove key", "[pattern_formatter]") {
-    spdlog::mdc::put("mdc_key_1", "mdc_value_1");
-    spdlog::mdc::put("mdc_key_2", "mdc_value_2");
-    spdlog::mdc::remove("mdc_key_1");
-
-    auto formatter = std::make_shared<spdlog::pattern_formatter>();
-    formatter->set_pattern("[%n] [%l] [%&] %v");
-
-    memory_buf_t formatted;
-    spdlog::details::log_msg msg(spdlog::source_loc{}, "logger-name", spdlog::level::info,
-                                 "some message");
-    formatter->format(msg, formatted);
-
-    auto expected =
-        spdlog::fmt_lib::format("[logger-name] [info] [mdc_key_2:mdc_value_2] some message{}",
-                                spdlog::details::os::default_eol);
-    REQUIRE(to_string_view(formatted) == expected);
-
-    SECTION("Tear down") { spdlog::mdc::clear(); }
-}
-
-TEST_CASE("mdc empty", "[pattern_formatter]") {
-    auto formatter = std::make_shared<spdlog::pattern_formatter>();
-    formatter->set_pattern("[%n] [%l] [%&] %v");
-
-    memory_buf_t formatted;
-    spdlog::details::log_msg msg(spdlog::source_loc{}, "logger-name", spdlog::level::info,
-                                 "some message");
-    formatter->format(msg, formatted);
-
-    auto expected = spdlog::fmt_lib::format("[logger-name] [info] [] some message{}",
-                                            spdlog::details::os::default_eol);
-    REQUIRE(to_string_view(formatted) == expected);
-
-    SECTION("Tear down") { spdlog::mdc::clear(); }
-}
-#endif
--- a/tests/test_sink.h
+++ b/tests/test_sink.h
@ -47,9 +47,8 @@ protected:
        base_sink<Mutex>::formatter_->format(msg, formatted);
        // save the line without the eol
        auto eol_len = strlen(details::os::default_eol);
-        using diff_t = typename std::iterator_traits<decltype(formatted.end())>::difference_type; 
        if (lines_.size() < lines_to_save) {
-            lines_.emplace_back(formatted.begin(), formatted.end() - static_cast<diff_t>(eol_len));
+            lines_.emplace_back(formatted.begin(), formatted.end() - eol_len);
        }
        msg_counter_++;
        std::this_thread::sleep_for(delay_);