I don't think D's writefln is getting any special treatment from the compiler. It seems to use D's compile-time features to perform the check.
https://github.com/dlang/phobos/blob/v2.093.0/std/stdio.d#L4...
D also has the capability of implementing string interpolation using mixins - though the resulting code isn't quite as neat.
There are languages (C++, Rust) where you can write your own, safe formatting library just using the language. It's a world away from printf.
Compared to that, parent comment says that in D the compiler has to have checks for formatting built in to it and compares it to printf. Yuk!
https://dlang.org/phobos/std_stdio.html#.writef
D can also call C's printf, and checking that is magical indeed. It exactly follows the C99 Standard for printf. A major feature of D is being able to call C functions directly, and printf is one of them. (D doesn't recognize printf specifically, it has to have a special attribute for it `pragma(printf)` which the compiler recognizes. This is so the checking can be applied to user-defined functions that use conforming printf-style format strings.)
https://dlang.org/spec/pragma.html#printf
And the code to do it:
https://github.com/dlang/dmd/blob/master/src/dmd/chkformat.d
I now see you were just making an unrelated point first. And having a specific compiler feature just for printf (and co.) is totally reasonable given how widespread it.
Your first link answers what would've been a follow up question: OK, writef() is a variadic template implemented with just normal language features, but does it do compile-time checking of the format? The docs says that it does:
> fmt: The format string. When passed as a compile-time argument, the string will be statically checked against the argument types passed.
What if you, as library author (not compiler writer!), think of a much better formatting system? Or something that's maybe not better in general, but better for an unusual situation you're deploying in? Or you want to write something that's different to a formatting system but uses similar tricks? If you don't have language facilities to do this yourself then you're stuffed.
As well the original post showing it's possible in Rust, this is also possible in C++. For example, the C++ fmt [1] library allows compile-time time checking of the number of slots in format strings against the number of arguments, and even that the format specifications (.03d or whatever) match the passed in types. And it's not reliant on the compiler doing its own magic checking outside of the language.
[1] https://github.com/fmtlib/fmt