7.0.1

• Updated the inline version namespace name.

• Worked around a gcc bug in mangling of alias templates (#1753).

• Fixed a linkage error on Windows (#1757). Thanks @Kurkin (Dmitry Kurkin).

• Fixed minor issues with the documentation.

7.0.0

• Reduced the library size. For example, on macOS a stripped test binary statically linked with {fmt} shrank from ~368k to less than 100k.

• Added a simpler and more efficient format string compilation API:

  #include <fmt/compile.h>
  
  // Converts 42 into std::string using the most efficient method and no
  // runtime format string processing.
  std::string s = fmt::format(FMT_COMPILE("{}"), 42);

  The old fmt::compile API is now deprecated.

  Thanks @ldionne (Louis Dionne) for the suggestion and @hanickadot (Hana Dusíková) for the initial prototype.

• Optimized integer formatting: format_to with format string compilation and a stack-allocated buffer is now faster than to_chars on both libc++ and libstdc++.

• Optimized handling of small format strings. For example,

  fmt::format("Result: {}: ({},{},{},{})", str1, str2, str3, str4, str5)

  is now ~40% faster (#1685).

• Applied extern templates to improve compile times when using the core API and fmt/format.h (#1452). For example, on macOS with clang the compile time of a test translation unit dropped from 2.3s to 0.3s with -O2 and from 0.6s to 0.3s with the default settings (-O0).

  Before (-O2):

  % time c++ -c test.cc -I include -std=c++17 -O2
  c++ -c test.cc -I include -std=c++17 -O2  2.22s user 0.08s system 99% cpu 2.311 total
  

  After (-O2):

  % time c++ -c test.cc -I include -std=c++17 -O2
  c++ -c test.cc -I include -std=c++17 -O2  0.26s user 0.04s system 98% cpu 0.303 total
  

  Before (default):

  % time c++ -c test.cc -I include -std=c++17
  c++ -c test.cc -I include -std=c++17  0.53s user 0.06s system 98% cpu 0.601 total
  

  After (default):

  % time c++ -c test.cc -I include -std=c++17
  c++ -c test.cc -I include -std=c++17  0.24s user 0.06s system 98% cpu 0.301 total
  

  It is still recommended to use fmt/core.h instead of fmt/format.h but the compile time difference is now smaller. Thanks @alex3d for the suggestion.

• Named arguments are now stored on stack (no dynamic memory allocations) and the compiled code is more compact and efficient. For example

  #include <fmt/core.h>
  
  int main() {
    fmt::print("The answer is {answer}\n", fmt::arg("answer", 42));
  }

  compiles to just (godbolt)

  .LC0:
          .string "answer"
  .LC1:
          .string "The answer is {answer}\n"
  main:
          sub     rsp, 56
          mov     edi, OFFSET FLAT:.LC1
          mov     esi, 23
          movabs  rdx, 4611686018427387905
          lea     rax, [rsp+32]
          lea     rcx, [rsp+16]
          mov     QWORD PTR [rsp+8], 1
          mov     QWORD PTR [rsp], rax
          mov     DWORD PTR [rsp+16], 42
          mov     QWORD PTR [rsp+32], OFFSET FLAT:.LC0
          mov     DWORD PTR [rsp+40], 0
          call    fmt::v6::vprint(fmt::v6::basic_string_view<char>,
                                  fmt::v6::format_args)
          xor     eax, eax
          add     rsp, 56
          ret
  
      .L.str.1:
              .asciz  "answer"
  

• Implemented compile-time checks for dynamic width and precision (#1614):

  #include <fmt/format.h>
  
  int main() {
    fmt::print(FMT_STRING("{0:{1}}"), 42);
  }

  now gives a compilation error because argument 1 doesn't exist:

  In file included from test.cc:1:
  include/fmt/format.h:2726:27: error: constexpr variable 'invalid_format' must be
  initialized by a constant expression
    FMT_CONSTEXPR_DECL bool invalid_format =
                            ^
  ...
  include/fmt/core.h:569:26: note: in call to
  '&checker(s, {}).context_->on_error(&"argument not found"[0])'
      if (id >= num_args_) on_error("argument not found");
                          ^
  

• Added sentinel support to fmt::join (#1689)

  struct zstring_sentinel {};
  bool operator==(const char* p, zstring_sentinel) { return *p == '\0'; }
  bool operator!=(const char* p, zstring_sentinel) { return *p != '\0'; }
  
  struct zstring {
    const char* p;
    const char* begin() const { return p; }
    zstring_sentinel end() const { return {}; }
  };
  
  auto s = fmt::format("{}", fmt::join(zstring{"hello"}, "_"));
  // s == "h_e_l_l_o"

  Thanks @BRevzin (Barry Revzin).

• Added support for named args, clear and reserve to dynamic_format_arg_store (#1655, #1663, #1674, #1677). Thanks @vsolontsov-ll (Vladimir Solontsov).

• Added support for the 'c' format specifier to integral types for compatibility with std::format (#1652).

• Replaced the 'n' format specifier with 'L' for compatibility with std::format (#1624). The 'n' specifier can be enabled via the FMT_DEPRECATED_N_SPECIFIER macro.

• The '=' format specifier is now disabled by default for compatibility with std::format. It can be enabled via the FMT_DEPRECATED_NUMERIC_ALIGN macro.

• Removed the following deprecated APIs:

  • FMT_STRING_ALIAS and fmt macros - replaced by FMT_STRING

  • fmt::basic_string_view::char_type - replaced by fmt::basic_string_view::value_type

  • convert_to_int

  • format_arg_store::types

  • *parse_context - replaced by *format_parse_context

  • FMT_DEPRECATED_INCLUDE_OS

  • FMT_DEPRECATED_PERCENT - incompatible with std::format

  • *writer - replaced by compiled format API

• Renamed the internal namespace to detail (#1538). The former is still provided as an alias if the FMT_USE_INTERNAL macro is defined.

• Improved compatibility between fmt::printf with the standard specs (#1595, #1682, #1683, #1687, #1699). Thanks @rimathia.

• Fixed handling of operator<< overloads that use copyfmt (#1666).

• Added the FMT_OS CMake option to control inclusion of OS-specific APIs in the fmt target. This can be useful for embedded platforms (#1654, #1656). Thanks @kwesolowski (Krzysztof Wesolowski).

• Replaced FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION with the FMT_FUZZ macro to prevent interferring with fuzzing of projects using {fmt} (#1650). Thanks @asraa (Asra Ali).

• Fixed compatibility with emscripten (#1636, #1637). Thanks @ArthurSonzogni (Arthur Sonzogni).

• Improved documentation (#704, #1643, #1660, #1681, #1691, #1706, #1714, #1721, #1739, #1740, #1741, #1751). Thanks @senior7515 (Alexander Gallego), @lsr0 (Lindsay Roberts), @puetzk (Kevin Puetz), @fpelliccioni (Fernando Pelliccioni), Alexey Kuzmenko, @jelly (jelle van der Waa), @claremacrae (Clare Macrae), @jiapengwen (文佳鹏), @gsjaardema (Greg Sjaardema), @alexey-milovidov.

• Implemented various build configuration fixes and improvements (#1603, #1657, #1702, #1728). Thanks @scramsby (Scott Ramsby), @jtojnar (Jan Tojnar), @orivej (Orivej Desh), @flagarde.

• Fixed various warnings and compilation issues (#1616, #1620, #1622, #1625, #1627, #1628, #1629, #1631, #1633, #1649, #1658, #1661, #1667, #1668, #1669, #1692, #1696, #1697, #1707, #1712, #1716, #1722, #1724, #1729, #1738, #1742, #1743, #1744, #1747, #1750). Thanks @gsjaardema (Greg Sjaardema), @gabime (Gabi Melman), @johnor (Johan), @gabime (Dmitry Kurkin), @invexed (James Beach), @peterbell10, @daixtrose (Markus Werle), @petrutlucian94 (Lucian Petrut), @Neargye (Daniil Goncharov), @ambitslix (Attila M. Szilagyi), @gabime (Gabi Melman), @erthink (Leonid Yuriev), @tohammer (Tobias Hammer), @0x8000-0000 (Florin Iucha).

6.2.1

• Fixed ostream support in sprintf (#1631).

• Fixed type detection when using implicit conversion to string_view and ostream operator<< inconsistently (#1662).

6.2.0

• Improved error reporting when trying to format an object of a non-formattable type:

  fmt::format("{}", S());

  now gives:

  include/fmt/core.h:1015:5: error: static_assert failed due to requirement
  'formattable' "Cannot format argument. To make type T formattable provide a
  formatter<T> specialization:
  https://fmt.dev/latest/api.html#formatting-user-defined-types"
      static_assert(
      ^
  ...
  note: in instantiation of function template specialization
  'fmt::v6::format<char [3], S, char>' requested here
    fmt::format("{}", S());
         ^
  

  if S is not formattable.

• Reduced library size by ~10%.

• Always print decimal point if # is specified (#1476, #1498):

  fmt::print("{:#.0f}", 42.0);

  now prints 42.

• Implemented the 'L' specifier for locale-specific numeric formatting to improve compatibility with std::format. The 'n' specifier is now deprecated and will be removed in the next major release.

• Moved OS-specific APIs such as windows_error from fmt/format.h to fmt/os.h. You can define FMT_DEPRECATED_INCLUDE_OS to automatically include fmt/os.h from fmt/format.h for compatibility but this will be disabled in the next major release.

• Added precision overflow detection in floating-point formatting.

• Implemented detection of invalid use of fmt::arg.

• Used type_identity to block unnecessary template argument deduction. Thanks Tim Song.

• Improved UTF-8 handling (#1109):

  fmt::print("┌{0:─^{2}}┐\n"
             "│{1: ^{2}}│\n"
             "└{0:─^{2}}┘\n", "", "Привет, мир!", 20);

  now prints:

  ┌────────────────────┐
  │    Привет, мир!    │
  └────────────────────┘
  

  on systems that support Unicode.

• Added experimental dynamic argument storage (#1170, #1584):

  fmt::dynamic_format_arg_store<fmt::format_context> store;
  store.push_back("answer");
  store.push_back(42);
  fmt::vprint("The {} is {}.\n", store);

  prints:

  The answer is 42.
  

  Thanks @vsolontsov-ll (Vladimir Solontsov).

• Made fmt::join accept initializer_list (#1591). Thanks @Rapotkinnik (Nikolay Rapotkin).

• Fixed handling of empty tuples (#1588).

• Fixed handling of output iterators in format_to_n (#1506).

• Fixed formatting of std::chrono::duration types to wide output (#1533). Thanks @zeffy (pilao).

• Added const begin and end overload to buffers (#1553). Thanks @dominicpoeschko.

• Added the ability to disable floating-point formatting via FMT_USE_FLOAT, FMT_USE_DOUBLE and FMT_USE_LONG_DOUBLE macros for extremely memory-constrained embedded system (#1590). Thanks @albaguirre (Alberto Aguirre).

• Made FMT_STRING work with constexpr string_view (#1589). Thanks @scramsby (Scott Ramsby).

• Implemented a minor optimization in the format string parser (#1560). Thanks @IkarusDeveloper.

• Improved attribute detection (#1469, #1475, #1576). Thanks @federico-busato (Federico), @chronoxor (Ivan Shynkarenka), @refnum.

• Improved documentation (#1481, #1523). Thanks @JackBoosY (Jack·Boos·Yu), @imba-tjd (谭九鼎).

• Fixed symbol visibility on Linux when compiling with -fvisibility=hidden (#1535). Thanks @milianw (Milian Wolff).

• Implemented various build configuration fixes and improvements (#1264, #1460, #1534, #1536, #1545, #1546, #1566, #1582, #1597, #1598). Thanks @ambitslix (Attila M. Szilagyi), @jwillikers (Jordan Williams), @stac47 (Laurent Stacul).

• Fixed various warnings and compilation issues (#1433, #1461, #1470, #1480, #1485, #1492, #1493, #1504, #1505, #1512, #1515, #1516, #1518, #1519, #1520, #1521, #1522, #1524, #1530, #1531, #1532, #1539, #1547, #1548, #1554, #1567, #1568, #1569, #1571, #1573, #1575, #1581, #1583, #1586, #1587, #1594, #1596, #1604, #1606, #1607, #1609). Thanks @marti4d (Chris Martin), @iPherian, @parkertomatoes, @gsjaardema (Greg Sjaardema), @chronoxor (Ivan Shynkarenka), @DanielaE (Daniela Engert), @torsten48, @tohammer (Tobias Hammer), @lefticus (Jason Turner), @ryusakki (Haise), @adnsv (Alex Denisov), @fghzxm, @refnum, @pramodk (Pramod Kumbhar), @Spirrwell, @scramsby (Scott Ramsby).

6.1.2

• Fixed ABI compatibility with libfmt.so.6.0.0 (#1471).

• Fixed handling types convertible to std::string_view (#1451). Thanks @denizevrenci (Deniz Evrenci).

• Made CUDA test an opt-in enabled via the FMT_CUDA_TEST CMake option.

• Fixed sign conversion warnings (#1440). Thanks @0x8000-0000 (Florin Iucha).

6.1.1

• Fixed shared library build on Windows (#1443, #1445, #1446, #1450). Thanks @egorpugin (Egor Pugin), @bbolli (Beat Bolli).

• Added a missing decimal point in exponent notation with trailing zeros.

• Removed deprecated format_arg_store::TYPES.

6.1.0

• {fmt} now formats IEEE 754 float and double using the shortest decimal representation with correct rounding by default:

  #include <cmath>
  #include <fmt/core.h>
  
  int main() {
    fmt::print("{}", M_PI);
  }

  prints 3.141592653589793.

• Made the fast binary to decimal floating-point formatter the default, simplified it and improved performance. {fmt} is now 15 times faster than libc++'s std::ostringstream, 11 times faster than printf and 10% faster than double-conversion on dtoa-benchmark:

  Function	Time (ns)	Speedup
  ostringstream	1,346.30	1.00x
  ostrstream	1,195.74	1.13x
  sprintf	995.08	1.35x
  doubleconv	99.10	13.59x
  fmt	88.34	15.24x

  

• {fmt} no longer converts float arguments to double. In particular this improves the default (shortest) representation of floats and makes fmt::format consistent with std::format specs (#1336, #1353, #1360, #1361):

  fmt::print("{}", 0.1f);

  prints 0.1 instead of 0.10000000149011612. Thanks @orivej (Orivej Desh).

• Made floating-point formatting output consistent with printf/iostreams (#1376, #1417).

• Added support for 128-bit integers (#1287):

  fmt::print("{}", std::numeric_limits<__int128_t>::max());

  prints 170141183460469231731687303715884105727. Thanks @denizevrenci (Deniz Evrenci).

• The overload of print that takes text_style is now atomic, i.e. the output from different threads doesn't interleave (#1351). Thanks @tankiJong (Tanki Zhang).

• Made compile time in the header-only mode ~20% faster by reducing the number of template instantiations. wchar_t overload of vprint was moved from fmt/core.h to fmt/format.h.

• Added an overload of fmt::join that works with tuples (#1322, #1330):

  #include <tuple>
  #include <fmt/ranges.h>
  
  int main() {
    std::tuple<char, int, float> t{'a', 1, 2.0f};
    fmt::print("{}", t);
  }

  prints ('a', 1, 2.0). Thanks @jeremyong (Jeremy Ong).

• Changed formatting of octal zero with prefix from "00" to "0":

  fmt::print("{:#o}", 0);

  prints 0.

• The locale is now passed to ostream insertion (<<) operators (#1406):

  #include <fmt/locale.h>
  #include <fmt/ostream.h>
  
  struct S {
    double value;
  };
  
  std::ostream& operator<<(std::ostream& os, S s) {
    return os << s.value;
  }
  
  int main() {
    auto s = fmt::format(std::locale("fr_FR.UTF-8"), "{}", S{0.42});
    // s == "0,42"
  }

  Thanks @dlaugt (Daniel Laügt).

• Locale-specific number formatting now uses grouping (#1393 #1394). Thanks @skrdaniel.

• Fixed handling of types with deleted implicit rvalue conversion to const char** (#1421):

  struct mystring {
    operator const char*() const&;
    operator const char*() &;
    operator const char*() const&& = delete;
    operator const char*() && = delete;
  };
  mystring str;
  fmt::print("{}", str); // now compiles

• Enums are now mapped to correct underlying types instead of int (#1286). Thanks @agmt (Egor Seredin).

• Enum classes are no longer implicitly converted to int (#1424).

• Added basic_format_parse_context for consistency with C++20 std::format and deprecated basic_parse_context.

• Fixed handling of UTF-8 in precision (#1389, #1390). Thanks @tajtiattila (Attila Tajti).

• {fmt} can now be installed on Linux, macOS and Windows with Conda using its conda-forge package (#1410):

  conda install -c conda-forge fmt
  

  Thanks @tdegeus (Tom de Geus).

• Added a CUDA test (#1285, #1317). Thanks @luncliff (Park DongHa) and @risa2000.

• Improved documentation (#1276, #1291, #1296, #1315, #1332, #1337, #1395 #1418). Thanks @waywardmonkeys (Bruce Mitchener), @pauldreik (Paul Dreik), @jackoalan (Jack Andersen).

• Various code improvements (#1358, #1407). Thanks @orivej (Orivej Desh), @dpacbach (David P. Sicilia),

• Fixed compile-time format string checks for user-defined types (#1292).

• Worked around a false positive in unsigned-integer-overflow sanitizer (#1377).

• Fixed various warnings and compilation issues (#1273, #1278, #1280, #1281, #1288, #1290, #1301, #1305, #1306, #1309, #1312, #1313, #1316, #1319, #1320, #1326, #1328, #1344, #1345, #1347, #1349, #1354, #1362, #1366, #1364, #1370, #1371, #1385, #1388, #1397, #1414, #1416, #1422 #1427, #1431, #1433). Thanks @hhb, @gsjaardema (Greg Sjaardema), @gabime (Gabi Melman), @neheb (Rosen Penev), @vedranmiletic (Vedran Miletić), @dkavolis (Daumantas Kavolis), @mwinterb, @orivej (Orivej Desh), @denizevrenci (Deniz Evrenci) @leonklingele, @chronoxor (Ivan Shynkarenka), @kent-tri, @0x8000-0000 (Florin Iucha), @marti4d (Chris Martin).

6.0.0

• Switched to the MIT license with an optional exception that allows distributing binary code without attribution.

• Floating-point formatting is now locale-independent by default:

  #include <locale>
  #include <fmt/core.h>
  
  int main() {
    std::locale::global(std::locale("ru_RU.UTF-8"));
    fmt::print("value = {}", 4.2);
  }

  prints "value = 4.2" regardless of the locale. For locale-specific formatting use the n specifier:

  std::locale::global(std::locale("ru_RU.UTF-8"));
  fmt::print("value = {:n}", 4.2);

  prints "value = 4,2".

• Added an experimental Grisu floating-point formatting algorithm implementation (disabled by default). To enable it compile with the FMT_USE_GRISU macro defined to 1:

  #define FMT_USE_GRISU 1
  #include <fmt/format.h>
  
  auto s = fmt::format("{}", 4.2); // formats 4.2 using Grisu

  With Grisu enabled, {fmt} is 13x faster than std::ostringstream (libc++) and 10x faster than sprintf on dtoa-benchmark (full results):

• Separated formatting and parsing contexts for consistency with C++20 std::format, removing the undocumented basic_format_context::parse_context() function.

• Added oss-fuzz support (#1199). Thanks @pauldreik (Paul Dreik).

• formatter specializations now always take precedence over operator<< (#952):

  #include <iostream>
  #include <fmt/ostream.h>
  
  struct S {};
  
  std::ostream& operator<<(std::ostream& os, S) {
    return os << 1;
  }
  
  template <>
  struct fmt::formatter<S> : fmt::formatter<int> {
    auto format(S, format_context& ctx) {
      return formatter<int>::format(2, ctx);
    }
  };
  
  int main() {
    std::cout << S() << "\n"; // prints 1 using operator<<
    fmt::print("{}\n", S());  // prints 2 using formatter
  }

• Introduced the experimental fmt::compile function that does format string compilation (#618, #1169, #1171):

  #include <fmt/compile.h>
  
  auto f = fmt::compile<int>("{}");
  std::string s = fmt::format(f, 42); // can be called multiple times to format
                                      // different values
  // s == "42"

  It moves the cost of parsing a format string outside of the format function which can be beneficial when identically formatting many objects of the same types. Thanks @stryku (Mateusz Janek).

• Added experimental support for the % format specifier that formats floating-point values as percentages (#1060, #1069, #1071):

  auto s = fmt::format("{:.1%}", 0.42); // s == "42.0%"

  Thanks @gawain-bolton (Gawain Bolton).

• Implemented precision for floating-point durations (#1004, #1012):

  auto s = fmt::format("{:.1}", std::chrono::duration<double>(1.234));
  // s == 1.2s

  Thanks @DanielaE (Daniela Engert).

• Implemented chrono format specifiers %Q and %q that give the value and the unit respectively (#1019):

  auto value = fmt::format("{:%Q}", 42s); // value == "42"
  auto unit  = fmt::format("{:%q}", 42s); // unit == "s"

  Thanks @DanielaE (Daniela Engert).

• Fixed handling of dynamic width in chrono formatter:

  auto s = fmt::format("{0:{1}%H:%M:%S}", std::chrono::seconds(12345), 12);
  //                        ^ width argument index                     ^ width
  // s == "03:25:45    "

  Thanks Howard Hinnant.

• Removed deprecated fmt/time.h. Use fmt/chrono.h instead.

• Added fmt::format and fmt::vformat overloads that take text_style (#993, #994):

  #include <fmt/color.h>
  
  std::string message = fmt::format(fmt::emphasis::bold | fg(fmt::color::red),
                                    "The answer is {}.", 42);

  Thanks @Naios (Denis Blank).

• Removed the deprecated color API (print_colored). Use the new API, namely print overloads that take text_style instead.

• Made std::unique_ptr and std::shared_ptr formattable as pointers via fmt::ptr (#1121):

  std::unique_ptr<int> p = ...;
  fmt::print("{}", fmt::ptr(p)); // prints p as a pointer

  Thanks @sighingnow (Tao He).

• Made print and vprint report I/O errors (#1098, #1099). Thanks @BillyDonahue (Billy Donahue).

• Marked deprecated APIs with the [[deprecated]] attribute and removed internal uses of deprecated APIs (#1022). Thanks @eliaskosunen (Elias Kosunen).

• Modernized the codebase using more C++11 features and removing workarounds. Most importantly, buffer_context is now an alias template, so use buffer_context<T> instead of buffer_context<T>::type. These features require GCC 4.8 or later.

• formatter specializations now always take precedence over implicit conversions to int and the undocumented convert_to_int trait is now deprecated.

• Moved the undocumented basic_writer, writer, and wwriter types to the internal namespace.

• Removed deprecated basic_format_context::begin(). Use out() instead.

• Disallowed passing the result of join as an lvalue to prevent misuse.

• Refactored the undocumented structs that represent parsed format specifiers to simplify the API and allow multibyte fill.

• Moved SFINAE to template parameters to reduce symbol sizes.

• Switched to fputws for writing wide strings so that it's no longer required to call _setmode on Windows (#1229, #1243). Thanks @jackoalan (Jack Andersen).

• Improved literal-based API (#1254). Thanks @sylveon (Charles Milette).

• Added support for exotic platforms without uintptr_t such as IBM i (AS/400) which has 128-bit pointers and only 64-bit integers (#1059).

• Added Sublime Text syntax highlighting config (#1037). Thanks @Kronuz (Germán Méndez Bravo).

• Added the FMT_ENFORCE_COMPILE_STRING macro to enforce the use of compile-time format strings (#1231). Thanks @jackoalan (Jack Andersen).

• Stopped setting CMAKE_BUILD_TYPE if {fmt} is a subproject (#1081).

• Various build improvements (#1039, #1078, #1091, #1103, #1177). Thanks @luncliff (Park DongHa), @jasonszang (Jason Shuo Zang), @olafhering (Olaf Hering), @Lecetem, @pauldreik (Paul Dreik).

• Improved documentation (#1049, #1051, #1083, #1113, #1114, #1146, #1180, #1250, #1252, #1265). Thanks @mikelui (Michael Lui), @foonathan (Jonathan Müller), @BillyDonahue (Billy Donahue), @jwakely (Jonathan Wakely), @kaisbe (Kais Ben Salah), @sdebionne (Samuel Debionne).

• Fixed ambiguous formatter specialization in fmt/ranges.h (#1123).

• Fixed formatting of a non-empty std::filesystem::path which is an infinitely deep range of its components (#1268).

• Fixed handling of general output iterators when formatting characters (#1056, #1058). Thanks @abolz (Alexander Bolz).

• Fixed handling of output iterators in formatter specialization for ranges (#1064).

• Fixed handling of exotic character types (#1188).

• Made chrono formatting work with exceptions disabled (#1062).

• Fixed DLL visibility issues (#1134, #1147). Thanks @denchat.

• Disabled the use of UDL template extension on GCC 9 (#1148).

• Removed misplaced format compile-time checks from printf (#1173).

• Fixed issues in the experimental floating-point formatter (#1072, #1129, #1153, #1155, #1210, #1222). Thanks @alabuzhev (Alex Alabuzhev).

• Fixed bugs discovered by fuzzing or during fuzzing integration (#1124, #1127, #1132, #1135, #1136, #1141, #1142, #1178, #1179, #1194). Thanks @pauldreik (Paul Dreik).

• Fixed building tests on FreeBSD and Hurd (#1043). Thanks @jackyf (Eugene V. Lyubimkin).

• Fixed various warnings and compilation issues (#998, #1006, #1008, #1011, #1025, #1027, #1028, #1029, #1030, #1031, #1054, #1063, #1068, #1074, #1075, #1079, #1086, #1088, #1089, #1094, #1101, #1102, #1105, #1107, #1115, #1117, #1118, #1120, #1123, #1139, #1140, #1143, #1144, #1150, #1151, #1152, #1154, #1156, #1159, #1175, #1181, #1186, #1187, #1191, #1197, #1200, #1203, #1205, #1206, #1213, #1214, #1217, #1228, #1230, #1232, #1235, #1236, #1240). Thanks @DanielaE (Daniela Engert), @mwinterb, @eliaskosunen (Elias Kosunen), @morinmorin, @ricco19 (Brian Ricciardelli), @waywardmonkeys (Bruce Mitchener), @chronoxor (Ivan Shynkarenka), @remyabel, @pauldreik (Paul Dreik), [@gsjaardema (...

5.3.0

• Introduced experimental chrono formatting support:

  #include <fmt/chrono.h>
  
  int main() {
    using namespace std::literals::chrono_literals;
    fmt::print("Default format: {} {}\n", 42s, 100ms);
    fmt::print("strftime-like format: {:%H:%M:%S}\n", 3h + 15min + 30s);
  }

  prints:

  Default format: 42s 100ms
  strftime-like format: 03:15:30
  

• Added experimental support for emphasis (bold, italic, underline, strikethrough), colored output to a file stream, and improved colored formatting API (#961, #967, #973):

  #include <fmt/color.h>
  
  int main() {
    print(fg(fmt::color::crimson) | fmt::emphasis::bold,
          "Hello, {}!\n", "world");
    print(fg(fmt::color::floral_white) | bg(fmt::color::slate_gray) |
          fmt::emphasis::underline, "Hello, {}!\n", "мир");
    print(fg(fmt::color::steel_blue) | fmt::emphasis::italic,
          "Hello, {}!\n", "世界");
  }

  prints the following on modern terminals with RGB color support:

  

  Thanks @Rakete1111 (Nicolas).

• Added support for 4-bit terminal colors (#968, #974)

  #include <fmt/color.h>
  
  int main() {
    print(fg(fmt::terminal_color::red), "stop\n");
  }

  Note that these colors vary by terminal:Thanks @Rakete1111 (Nicolas).

• Parameterized formatting functions on the type of the format string (#880, #881, #883, #885, #897, #920). Any object of type S that has an overloaded to_string_view(const S&) returning fmt::string_view can be used as a format string:

  namespace my_ns {
  inline string_view to_string_view(const my_string& s) {
    return {s.data(), s.length()};
  }
  }
  
  std::string message = fmt::format(my_string("The answer is {}."), 42);

  Thanks @DanielaE (Daniela Engert).

• Made std::string_view work as a format string (#898):

  auto message = fmt::format(std::string_view("The answer is {}."), 42);

  Thanks @DanielaE (Daniela Engert).

• Added wide string support to compile-time format string checks (#924):

  print(fmt(L"{:f}"), 42); // compile-time error: invalid type specifier

  Thanks @XZiar.

• Made colored print functions work with wide strings (#867):

  #include <fmt/color.h>
  
  int main() {
    print(fg(fmt::color::red), L"{}\n", 42);
  }

  Thanks @DanielaE (Daniela Engert).

• Introduced experimental Unicode support (#628, #891):

  using namespace fmt::literals;
  auto s = fmt::format("{:*^5}"_u, "🤡"_u); // s == "**🤡**"_u

• Improved locale support:

  #include <fmt/locale.h>
  
  struct numpunct : std::numpunct<char> {
   protected:
    char do_thousands_sep() const override { return '~'; }
  };
  
  std::locale loc;
  auto s = fmt::format(std::locale(loc, new numpunct()), "{:n}", 1234567);
  // s == "1~234~567"

• Constrained formatting functions on proper iterator types (#921). Thanks @DanielaE (Daniela Engert).

• Added make_printf_args and make_wprintf_args functions (#934). Thanks @tnovotny.

• Deprecated fmt::visit, parse_context, and wparse_context. Use fmt::visit_format_arg, format_parse_context, and wformat_parse_context instead.

• Removed undocumented basic_fixed_buffer which has been superseded by the iterator-based API (#873, #902). Thanks @superfunc (hollywood programmer).

• Disallowed repeated leading zeros in an argument ID:

  fmt::print("{000}", 42); // error

• Reintroduced support for gcc 4.4.

• Fixed compilation on platforms with exotic double (#878).

• Improved documentation (#164, #877, #901, #906, #979). Thanks @kookjr (Mathew Cucuzella), @DarkDimius (Dmitry Petrashko), @HecticSerenity.

• Added pkgconfig support which makes it easier to consume the library from meson and other build systems (#916). Thanks @colemickens (Cole Mickens).

• Various build improvements (#909, #926, #937, #953, #959). Thanks @tchaikov (Kefu Chai), @luncliff (Park DongHa), @AndreasSchoenle (Andreas Schönle), @hotwatermorning, @Zefz (JohanJansen).

• Improved string_view construction performance (#914). Thanks @gabime (Gabi Melman).

• Fixed non-matching char types (#895). Thanks @DanielaE (Daniela Engert).

• Fixed format_to_n with std::back_insert_iterator (#913). Thanks @DanielaE (Daniela Engert).

• Fixed locale-dependent formatting (#905).

• Fixed various compiler warnings and errors (#882, #886, #933, #941, #931, #943, #954, #956, #962, #965, #977, #983, #989). Thanks @Luthaf (Guillaume Fraux), @stevenhoving (Steven Hoving), @christinaa (Kristina Brooks), @lgritz (Larry Gritz), @DanielaE (Daniela Engert), @0x8000-0000 (Sign Bit), @liuping1997.

5.2.1

• Fixed visit lookup issues on gcc 7 & 8 (#870). Thanks @medithe.

• Fixed linkage errors on older gcc.

• Prevented fmt/range.h from specializing fmt::basic_string_view (#865, #868). Thanks @hhggit (dual).

• Improved error message when formatting unknown types (#872). Thanks @foonathan (Jonathan Müller),

• Disabled templated user-defined literals when compiled under nvcc (#875). Thanks @CandyGumdrop (Candy Gumdrop),

• Fixed format_to formatting to wmemory_buffer (#874).