Is there anything specific to Rust that this library does which modern C++ can’t match in performance? I’d be very interested to understand if there is.
* it's a Cargo package, which is trivial to add to a project. Pure-Rust projects are easier to build cross-platform.
* It exports a safe Rust interface. It has configurable levels of thread safety, which are protected from misuse at compile time.
The point isn't that C++ can match performance, but that you don't have to use C++, and still get the performance, plus other niceties.
This is "is there anything specific to C++ that assembly can't match in performance?" one step removed.
A more nebulous Rust perf thing is ability rely on the compiler to check lifetimes and immutability/exclusivity of pointers. This allows using fine-grained multithreading, even with 3rd party code, without the worry it's going to cause heisenbugs. It allows library APIs to work with temporary complex references that would be footguns otherwise (e.g. prefer string_view instead of string. Don't copy inputs defensively, because it's known they can't be mutated or freed even by a broken caller).
Standard C++ doesn't but `noalias` is available in basically every major compiler (including the more niche embedded toolchains).
Rust is not magic and you can compile both with llvm (clang++).
If you specify that the pointers don’t alias, and don’t use any language sugar that adds overhead on either side, the performance will be very similar.
The Rust implementation even needs to use a few unsafe blocks (to work with UnsafeCells internally) but is mostly safe code. Other than that you can achieve the same in C++. But I think the real benefit is that you can write the rest of your code in safe Rust.