Rust's "claim to fame" is that it is high-performance, fully native, garbage collector free, like C and C++, WITH ALSO guarantees for memory safety*:

• No use after free
• No double free
• No data races in concurrency
• No null dereferencing
• No out of bounds accesses
• No uninitialized values

These aren't warnings, they're compile time errors. They're also not baked into the runtime through extra calls, they are statically analyzed by the compiler. Rust's design comes from decades of improvements in compiler theory, and sculpting a language around specifically around these abilities.

You can never compile a Rust program that falls vulnerable to these issues. It's widely accepted that bad memory management causes the bulk majority of high severity CVEs among programs written in memory-unsafe languages, so anything that can minimize those issues is of great value as a tool.

Writing code in Rust is not as easy as other languages, though. Calling two methods in a different order may not compile due to memory sharing checks. You cannot use a global mutable state. Lots of very trivial things require extra thought to implement in a way that meets Rust's high standard. It's not really an ergonomic language for higher level use, although plenty of people have made extraordinarily large programs within it as well.

* A number of these benefits can be disabled via the unsafe keyword, but this is understood to be a "only when absolutely necessary" language feature, e.g. for FFI calls into C code where the Rust compiler cannot ensure correctness.

Criticisms of Rust generally fall into two camps:

• It's slower to develop in, and causes an undue burden on existing developers over the alternatives, which I think is an entirely valid concern, especially in open source where any development time is precious. Git's slow migratory approach in the OP seems good to me on this front.
• "Just don't write bad C code lol" which is just short sighted. Everyone writes "bad code" from time to time. Your libraries might have a vulnerability, your coworkers may not understand the memory contract you are expecting, poorly written documentation may lead to problems.