There's a section on "why not printf" which is Standard C, but I can't find any section on "why not std::format"[1] which is Standard C++ since C++20 and works on all major compilers today in 2025.

They do mention "std::print"[2] from C++23 (which uses std::format) and compile times, but, they don't touch on "std::format" at all.

See:

[1] https://en.cppreference.com/w/cpp/utility/format/format.html

[2] https://en.cppreference.com/w/cpp/io/print.html

I have recently started re-implementing parts of the standard library myself just to improve compile times (and I did - massively!), but I purposely kept {fmt} around, because I think it's a great library and I thought it would be as fast to compile as you could possibly make it (it likely still is considering what it can do). Also because the dev put a lot of effort into optimizing compile times [1] and seems to be much smarter than me. So I made benchmark to prove you wrong and show you it's not that easy. But it turns out formatting a couple of numbers and strings is much faster with your basic formatting library [2] [3].

Comparing using `hyperfine --warmup 3 "g++ FILE.cpp"` (and some flags for fmt) I get 72ms vs 198ms. So I changed my mind and might take a crack at replacing {fmt} as well. Cool stuff! Thank you.

[1] https://vitaut.net/posts/2024/faster-cpp-compile-times/

[2] https://godbolt.org/z/3YaovhrjP bench-fmt.cpp

[3] https://godbolt.org/z/qMfM39P3q bench-rikifmt.cpp

I'm lost at the first line of code:

  char buffer[64];

I was curious about the "Why not printf" section, but I found code I don't understand there, too. For example this admittedly non-working snippet is cited as idiomatic:

  char str[4] = {0};
  int cursor = 0;
  cursor += snprintf(str, sizeof str, "hello ");
  cursor += snprintf(str, sizeof str, "world!");

  char buffer[64];
  String_Buffer buf = {str, sizeof str};

Next time can you to do Python's string interpolation? ;-) It's much more pleasant to read (when properly used).

Pretty neat and a very nice walkthrough of the code.

For localization you might want numbered holes which makes it way more complicated.

You can detect if the backing buffer is too short, but can you detect other errors? Like having different numbers of holes and arguments? I couldn’t find any discussion about this.

I prefer https://github.com/rokudev/rostd/blob/main/doc/printx.adoc, but it does increase compile times (which OP was trying to avoid).

Love the method name uhm bool next_hole

I much prefer string interpolation like

$"i={i}"

Nice. I think most people have tried doing something like this in C++ at some point.

One issue that I had is that printing floating-point values really needs the ability for the user to specify the precision and format. It's actually absurd that `std::to_string(double)` does not allow this.

Also, I believe `std::to_chars(double)` uses a fast algorithm and allows writing directly into a buffer.

How many CVEs?