Why Are Developers Rewriting Stuff in Rust?

So, I recently came across Limbo a Rust fork of SQLite. And it got me thinking:

why are so many projects being rewritten in Rust?

I’m not a Rust dev myself, but I did some research, compared Rust to other languages, and yeah, it’s pretty impressive.

But it got me wondering—is the performance alone enough to justify rewriting something that's already fast and functional?

Rust Rewrites Everywhere

Limbo isn’t the first Rust rewrite I’ve seen.

There’s Ripgrep (an alternative to grep), Bat (a better version of cat with syntax highlighting), coreutils (a collection of Unix tools), and more and even Rust versions tools like curl.

And let’s be honest, there are some super talented devs behind these projects.

But why rewrite at all?

What’s the draw to Rust?

Why Go Rust?

Memory Safety Without a Garbage Collector

One of Rust’s big selling points is memory safety. Unlike C or C++, Rust helps avoid memory bugs like null pointer errors or data races by using its ownership model.

This is important for software like SQLite, where stability is key.

Concurrency That Actually Works

Writing multi-threaded code is tough, and the majority of programming languages don’t make it any easier.

Rust, though, enforces safe concurrency from the get-go.

It makes it way simpler to write fast, parallel code without worrying about thread safety.

Performance

Rust is fast—super fast.

It gives you the speed of C/C++ but with modern features and safety.

Plus, its zero-cost abstractions mean you get high-level benefits without the performance hit.

Better DX

Rust comes with amazing tooling, like Cargo (its package manager).

It just feels more modern and smoother compared to older languages like C.

For a lot of devs, this alone is enough to make the switch.

When Does a Rewrite Make Sense?

I get it—Rust is cool, but do we need to rewrite everything?

Probably not.

There are a few situations where it might make sense, though:

The original project is a mess

If the original software has tons of technical debt, a Rust rewrite could be a fresh start that’s easier to maintain.

Safety is non-negotiable

If your project is handling sensitive stuff or critical systems, Rust’s memory safety guarantees are hard to beat.

The language itself is holding you back

If performance is a major bottleneck, and the original language is a limiting factor, Rust can help you push the limits further.

That being said, rewriting something that’s already solid can be risky.

It’s not just about translating code—it’s about recreating years of optimizations, bug fixes, and reliability.

Is It Really Worth It?

The more I think about this Rust rewrite trend, the more I realize it’s not just about the language—it’s about a mindset.

Rust encourages clean, safe, and modern code, and that’s appealing to a lot of devs.

But should we really rewrite everything in Rust?

For projects like Limbo, sure, if the rewrite brings more safety and a better dev experience, why not?

But if it’s only about chasing performance that the original software already provides, maybe not.

To Wrap It Up

Rust is a powerful language, no doubt about it.

But not every project needs to be rewritten in it.

The key is to ask whether the rewrite actually brings something better to the table—or if we’re just rewriting for the sake of it.

Shoutout to this X post for the inspiration: