“Tradition is not the worship of ashes, but the preservation of fire.” — Gustav Mahler

Walk into any Linux forum today and it will not be long before someone mentions Rust.

For years the excitement around Rust centred on web browsers, embedded systems and operating system kernels. Today, however, many Linux users encounter Rust somewhere much more ordinary: in the terminal.

One by one, familiar command-line tools are acquiring modern counterparts written in Rust. We have ripgrep beside grep, fd beside find, bat beside cat, eza beside ls, zoxide beside cd, dust beside du, procs beside ps, and even one of the most security-sensitive programs on a Unix system, sudo, now has a Rust implementation under active development.

To some, this looks like unnecessary reinvention.

To others, it is the natural evolution of the Unix toolbox.

I find myself somewhere in between.

Why rewrite tools that already work?

The obvious question is: if GNU tools have served us faithfully for decades, why replace them?

The answer is that most developers are not replacing Unix ideas—they are replacing aging implementations.

Many classic utilities were written in C at a time when computers had a few megabytes of RAM and processors measured their speed in megahertz. They were brilliantly engineered for their era, but software engineering has moved on.

Rust brings several advantages:

• memory safety without garbage collection
• stronger compile-time guarantees
• easier maintenance for large projects
• improved concurrency
• modern Unicode handling
• fewer classes of security vulnerabilities

For administrators responsible for production systems, those advantages matter.

It is no coincidence that organizations interested in reducing memory-related vulnerabilities have invested heavily in Rust. Security and reliability have become just as important as raw speed.

The Unix philosophy remains

Perhaps the greatest misconception is that Rust tools abandon the Unix philosophy.

In reality, the opposite is often true.

ripgrep still reads text.

fd still finds files.

bat still prints files.

zoxide still changes directories.

They remain small programs that do one job well and work happily inside pipelines.

The philosophy has survived.

Only the implementation has changed.

That says something profound about Unix itself. Good ideas can outlive the languages used to implement them.

Faster defaults

One noticeable characteristic of many Rust utilities is that they assume sensible defaults.

Take ripgrep.

Instead of requiring long command lines, a simple command like

rg "configuration"

searches recursively through the current directory while automatically ignoring Git metadata and other files that rarely matter.

Likewise, fd often finds what I want with remarkably little typing.

Rather than replacing find, it provides a friendlier interface for the most common tasks.

Traditional tools remain incredibly powerful.

The Rust versions simply make the common cases feel effortless.

My unexpected favourite: zoxide

Among all these tools, one has quietly changed the way I work more than any other.

Not ripgrep.

Not fd.

Not even eza.

It is zoxide.

At first glance, it appears almost trivial. It learns the directories you visit and lets you jump back to them with short commands.

That hardly sounds revolutionary.

Yet after using it daily for more than two months, I no longer think about directory navigation in quite the same way.

Instead of remembering long paths, I remember projects.

Instead of typing

cd ~/Documents/projects/textsmith/primer/processing

I simply type

z processing

or even just enough of the directory name for zoxide to identify the destination.

It feels less like navigating a filesystem and more like asking an assistant,

“Take me back to where I was working yesterday.”

The beauty is that it adapts to your habits.

The more you use your computer, the smarter it becomes.

Unlike bookmarks or manually maintained shortcuts, it requires almost no maintenance.

It quietly learns.

I did not expect such a small tool to change my workflow so noticeably, yet it has become one of those utilities I miss immediately when working on another machine.

Should GNU tools disappear?

Absolutely not.

One lesson years of Linux administration have taught me is that portability matters.

Every Unix-like machine has grep.

Every Unix-like machine has find.

Every Unix-like machine has ls.

When writing shell scripts that may run on unknown systems, those commands remain the safest choice.

That is one reason I still encourage newcomers to learn the traditional tools first.

Once you understand grep, appreciating ripgrep becomes easy.

Once you know find, fd feels like a welcome convenience rather than a mysterious replacement.

The classics are still the common language spoken across Unix systems.

A sign of a healthy ecosystem

Some people see dozens of Rust replacements and conclude that Linux is fragmented.

I see something different.

I see experimentation.

Unix has always encouraged people to build better tools.

The existence of ripgrep does not diminish grep.

The popularity of fd does not invalidate find.

Competition forces ideas to evolve.

Sometimes the newcomers discover genuinely better interfaces.

Sometimes the older tools adopt those ideas.

Everyone benefits.

Looking ahead

The growing presence of Rust in Linux tells us something about the future of system administration.

Tomorrow’s administrators will probably use a mixture of classic GNU utilities and newer Rust programs.

The toolbox is expanding rather than shrinking.

The skills remain largely the same:

• understand text
• understand files
• understand pipelines
• understand automation

Whether the executable behind the command is written in C, Rust or another language is often less important than understanding the problem the tool solves.

That, perhaps, is the enduring lesson of Unix.

Languages evolve.

Implementations change.

The philosophy survives.

And if my own experience is any indication, sometimes one small Rust utility—like zoxide—can quietly become the tool you wonder how you ever lived without.