15 rust cli tools that are so fast, sleek, and powerful, you’ll finally uninstall your 200-line bash script

Introduction: why rust cli tools slap harder than your old bash scripts

You ever open your terminal, type ls, and think, “This looks like it hasn’t evolved since the dinosaurs”? Yeah, same.

Enter Rust — the language that’s not just memory-safe, but apparently also terminal-drip certified. The Rust community has been quietly (and not-so-quietly) building CLI tools that are faster, safer, more intuitive, and way more fun than most of the legacy stuff we’ve been duct-taping into our scripts since the 90s.

These tools aren’t just “rewrites in Rust” they feel like what these utilities should’ve been all along. They boot faster than your coffee machine, render prettier output than most frontend apps, and some even remember where you’ve cd'd last (seriously).

In this article, I’ll walk you through 15 Rust-powered CLI tools that will make you question every shell alias you’ve ever written. If you love the terminal but hate its outdated UX, you’re in for a treat.

⚠️ Warning: You might fall in love with your command line again.

Let’s get started with the first tool one that makes grep feel like it's using dial-up.

Ripgrep when grep needs a gym membership

Let’s be honest grep is a legend. But also, it’s kind of like your grandpa’s toolbox: still functional, but dusty, slow, and not built for modern workflows.

That’s where ripgrep (aka rg) kicks in.

Written in Rust by Andrew Gallant (aka BurntSushi), ripgrep is everything grep wishes it could be:

• Insanely fast
• Respects .gitignore by default
• Recursive by default
• Works on huge codebases without breaking a sweat

Here’s the deal: instead of typing

grep -r --exclude-dir=.git "functionName" .

You can just do:

rg functionName

And boom it searches fast, clean, and only shows you what matters. It even highlights matches. Feels like your terminal just got a GPU upgrade.

Pro tip: Use it with editors like VSCode and NeoVim. Many plugins default to rg for project-wide search and for good reason.

ripgrep uses Rust’s regex engine and memory safety to avoid all the common grep pitfalls no segfaults, just speed.

Fd the find command your fingers will actually remember

Raise your hand if you’ve ever had to Google how to use find. 🙋‍♂️
Now keep it raised if you still didn’t understand what -name, -type f, and -exec do. Exactly.

Meet fd the search command that just works. No weird flags. No crying. No man-page yoga.

Here’s a side-by-side for perspective:

# With find
find . -type f -name "*.js"

# With fd
fd .js

That’s it. That’s the tweet.

Why devs love fd:

• Smart defaults it only shows files (not directories) unless you tell it otherwise
• Syntax you don’t have to whisper ancient incantations to understand
• Built-in colorized output
• Fast AF thanks again to Rust

You can even do cool stuff like:

fd -x rm    # Dangerous but cool
fd -e rs    # Files ending with .rs
fd -H       # Include hidden files

Bonus: It’s also gitignore-aware, just like ripgrep. So no more wading through node_modules.

Dev quote: “Using fd made me realize I didn’t hate the terminal I just hated find.”

Bat cat, but with syntax highlighting and a cape

You know cat, right? The good ol' “let me dump this file to the screen” command.
Well, bat said: “Cool idea, but what if it looked awesome, highlighted code, showed line numbers, and had git integration?”

Yep, it’s basically the superhero version of cat.

Here’s what bat brings to the table:

• Syntax highlighting for over 100+ languages
• Line numbers, because we’re not animals
• Git diff indicators in the gutter
• Works exactly like cat, so no learning curve

# Instead of this:
cat main.rs

# Do this:
bat main.rs

Your terminal instantly turns into a mini IDE.

Fun tip: You can even use bat as a pager for man pages:

man ls | bat

or use it with --paging=always to keep things scrollable and fancy.

Also works great with Markdown:

bat README.md

Now your cat command is no longer the equivalent of Windows Notepad.

If cat is a fork, bat is a Swiss Army chainsaw.

exa ls, but from the future where terminals are beautiful

Tired of ls looking like it’s running on a floppy disk?
Say hello to exa, the ls alternative built with modern devs in mind because your file listings should spark some joy.

exa brings terminal file browsing into the 21st century:

• Tree view for nested directories
• Color-coded output
• Git status indicators (yes, inside your ls output)
• Human-readable file sizes (finally!)
• And you don’t need a PhD in flags to use it

Here’s the glow-up in action:

# Basic listing
exa

# Long format with permissions and git
exa -l --git

# Tree structure
exa -T

# Sorted by size
exa -S

Want your terminal to feel like a space station UI? Combine it with aliases:

alias ls='exa -al --color=always --group-directories-first'

Bonus move:
If you use zsh or fish, pair exa with a custom theme or shell prompt your terminal starts looking like a hacker movie in no time.

“Using exa is like watching your terminal glow up. It’s ls, but it drinks protein shakes and writes poetry.”

Procs ps aux just got a UI upgrade (without a UI)

If you’ve ever run ps aux | grep node and thought “this is so ugly I might cry”, you're not alone.
Enter procs, the Rust-powered process viewer that makes monitoring your system actually bearable.

Think of procs as ps and htop having a beautiful, color-coded child.

Why devs dig procs:

• Gorgeous, human-readable output
• Color-coded columns (makes spotting zombies fun again)
• Displays CPU & memory usage, PID, command, user, runtime
• Customizable columns (add/remove what you want to see)
• Supports JSON and YAML output too (yes, it’s that modern)

# Just run it
procs

# Filter by process name
procs node

# Show only specific columns
procs --columns pid,user,cpu,mem,command

It’s the kind of process manager that makes you go “why didn’t I know about this before?”

Bonus move:
Pair procs with kill or htop for a full-on terminal productivity suite. Or just use procs solo — it slaps hard enough.

“procs is like if ps finally got an intern who cared about design.”

Du-dust disk usage that doesn’t make your brain hurt

Ever used du -sh * and stared at the output like it's encrypted?
Same. That’s why dust (sometimes called du-dust) exists it takes the soul-crushing experience of analyzing disk usage and turns it into something visual and actually readable.

Made in Rust (of course), dust is a smarter, faster replacement for du, with a colorful, tree-style layout that shows you what’s eating your disk space instantly.

What makes dust so good?

• Visual bar charts for file/folder size
• Sorts automatically by size (so you know what’s bloating things)
• Uses colors that are easy on the eyes
• Works recursively by default, but respects depth if you want it to

# Show disk usage of current directory
dust

# Limit the depth of directory scan
dust -d 2

# Show hidden files too
dust -a

And the output?
You get something like:

50.3MB ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ /target
10.2MB ━━━━━━ /src
3.4MB  ━ /node_modules

Basically, it’s the visual du your terminal always deserved.

Bonus moment:
You’ll finally find out that your 300-line debug.log is 1GB and cry a little.

“dust is like du, if du read self-help books and decided to become a better person.”

Bottom the htop killer with graphs, vibes, and Rust speed

If htop is your friendly neighborhood sys monitor, then bottom (aka btm) is Iron Man with a dashboard in your terminal.

Built in Rust (surprise, surprise), bottom is a terminal-based system monitor that doesn’t just show CPU usage it visualizes it with real-time graphs, color-coded sections, and performance you can feel.

What makes bottom top-tier?

• Clean, interactive UI with mouse support (yup, really)
• Real-time graphs for CPU, RAM, disk, network, and temperatures
• Sortable process list
• Filter and search through processes easily
• Themes, layout config, and Vim-style keybindings

# Just launch it
btm

# Use tree mode for process hierarchy
btm --tree

# Customize refresh rate
btm --rate 1000

Wanna monitor your system like a dev pro and feel like you’re piloting a spaceship?
bottom is the vibe.

Bonus:
bottom is super light on resources and doesn’t lag, even on low-spec machines.

Tokei count your code like a data-driven dev

Ever wanted to flex how many lines of code your project has without opening every file manually?
Say hello to tokei your terminal’s new favorite codebase analytics tool.

tokei (Japanese for "clock") doesn’t just count files. It breaks down your codebase by:

• Languages used
• Lines of code vs comments vs blanks
• Total files and code stats
• And it does it fast even on massive projects

Here’s how simple it is:

tokei .

Output:

-------------------------------------------------------------------------------
 Language            Files        Lines         Code     Comments       Blanks
-------------------------------------------------------------------------------
 Rust                  15         3021         2220          501          300
 JavaScript             9         1987         1502          310          175
 Markdown               3          900          650            0          250
-------------------------------------------------------------------------------
 Total                 27         5908         4372          811          725
-------------------------------------------------------------------------------

Want it in JSON or Markdown? You got it:

tokei . --output json
tokei . --output markdown

Bonus move:
Use tokei in your CI pipeline or README badge to show contributors how massive (or efficient) your repo is.

“tokei is like a Fitbit for your repo tracking your code health with stats and zero judgment.”

Bandwhich find out which process is stealing your internet like a sneaky raccoon

You’ve been there Wi-Fi slowing to a crawl, nothing obvious running, and you’re this close to blaming your neighbor.
But what if you could Sherlock your bandwidth usage straight from the terminal?

Meet bandwhich the Rust-powered network diagnostic tool that tells you which process, which port, and how much bandwidth it’s eating in real-time.

Why bandwhich rocks:

• Shows real-time bandwidth usage per process
• Displays remote addresses, ports, and protocols
• Beautiful terminal UI with colored graphs
• No more guessing find the culprit fast

sudo bandwhich

You’ll see something like:

PID    Process       Interface    Download     Upload      Remote Address
2451   firefox       wlan0        1.2 MB/s     56 KB/s     youtube.com:443
2217   docker-proxy  eth0         300 KB/s     700 KB/s    172.17.0.2:8080

Debug tip:
Perfect for catching that rogue Docker container or browser tab you forgot about or confirming that yes, npm install is nuking your connection.

“bandwhich is like netstat, if netstat went to hacker school and got good.”

gping ping with graphs because plain text is boring

Remember the first time you ran ping google.com and watched those little numbers bounce?
Yeah, now imagine that but with real-time graphs and way more flair.

Say hi to gping a visual twist on the classic ping command. It does everything ping does, but prettier. You get a terminal chart that updates live, showing you latency spikes and drops in a way numbers alone just can't.

Why devs love gping:

• Terminal-based latency graphs (yep, line charts in your terminal)
• Ping multiple hosts side-by-side
• Color-coded output for clarity
• Works with IPv4/IPv6, local IPs, domains, and even Docker networks

gping google.com

# Compare multiple hosts
gping google.com cloudflare.com github.com

You get a graph for each host updating in real time, helping you spot issues like DNS failures or dodgy routing at a glance.

Use case:
Diagnosing if your lag is local or upstream no more blaming your ISP without evidence.

“gping is like if ping went to a data viz bootcamp and came back with chart tattoos.”

Hyperfine the benchmark tool that ends all dev arguments

You know that classic dev debate:

“Dude, my script is faster.”
“Prove it.”
“…uh, lemme just… time it?”

Yeah, forget time it's 2025. Use hyperfine instead.

This Rust-built benchmarking beast gives you statistically sound, highly repeatable, and beautifully formatted results to settle performance battles once and for all.

Why hyperfine is a dev favorite:

• Runs your commands multiple times and gives mean, min, max, stddev
• Visual bar graphs in terminal
• Easy to compare multiple commands side-by-sid
• Supports exporting results to JSON, Markdown, CSV

hyperfine 'node script.js'

# Compare two tools
hyperfine 'rg "foo" .' 'grep -r "foo" .'

# Set warm-up runs
hyperfine --warmup 3 './my_script.sh'

Output looks like:

Benchmark #1: node script.js
  Time (mean ± σ):      12.3 ms ±   0.8 ms

Benchmark #2: deno run script.ts
  Time (mean ± σ):      8.1 ms ±   0.4 ms

Want bar charts? Just run --export-markdown and paste it into your README for dev bragging rights.

Pro tip:
Use hyperfine in CI to track performance regressions or just to win office bets.

“hyperfine is what happens when benchmarking stops being a guessing game and starts being science.”

Zoxide cd, but with memory and teleportation powers

Let’s face it typing long cd paths is a pain.
And using cd ../../.. feels like climbing out of a directory abyss with a rope made of regret.

Enter zoxide, the Rust-powered smart cd alternative that remembers where you’ve been and helps you jump back instantly — no more navigating like it’s 1998.

Why zoxide is a game-changer:

• Learns your most-visited directories
• Jump to a project or folder with just a few keystrokes
• Supports fuzzy matching
• Shell integration for bash, zsh, fish, powershell, and more

# Add zoxide to your shell (once)
eval "$(zoxide init zsh)"

# Use z instead of cd
z blog

# Jump to your Rust project folder
z rust

# List most visited dirs
zoxide query --list

It’s like having cd with autocomplete powered by AI except it’s just smart pattern matching and Rust performance.
You’ll forget you ever used cd the old-fashioned way.

Bonus move:
Pair zoxide with your editor launch:

z blog && nvim .

“zoxide is like cd if it had a brain, a memory, and maybe a tiny bit of magic.”

Cargo-edit finally, a Rust dependency manager that doesn’t make you open Cargo.toml

If you’re a Rust dev (or just starting out), you’ve probably felt the pain of manually editing your Cargo.toml to add dependencies. It’s 2025, and we’re still copy-pasting from crates.io? Nah.

Say hello to cargo-edit the essential set of commands that lets you manage dependencies like you’re using npm, yarn, or pip.

What you get with cargo-edit:

• cargo add add a new crate to your project
• cargo rm remove a dependency
• cargo upgrade update to the latest version
• cargo set-version bump your crate version

# Add a new dependency
cargo add serde

# Add a specific version or with features
cargo add tokio --features full

# Remove a dependency
cargo rm regex

# Upgrade all dependencies
cargo upgrade

# Bump version for release
cargo set-version 1.0.0

No more scrolling through [dependencies] and praying the formatting doesn’t break.

Pro tip:
Use cargo upgrade --dry-run to preview updates before committing them avoid surprises.

“cargo-edit is the juice that makes Rust dev feel like modern frontend dev. Smooth, fast, zero pain.”

Starship the shell prompt that flexes your dev setup

Your terminal prompt is the first thing you see when you open a shell. So why does it still look like it’s from a 90s hacker movie… but without the cool soundtrack?

starship fixes that. It's a blazing-fast, cross-shell prompt written in Rust that gives your terminal the sleek, informative look it deserves.

And yes it’s compatible with bash, zsh, fish, powershell, and even nushell.

Why starship rocks:

• Customizable, minimal, and fast
• Displays Git status, language versions, Docker context, time, battery, and even Kubernetes cluster
• Works out-of-the-box but easy to theme
• Loads only what you use (no bloat)

# Add to your shell
eval "$(starship init zsh)"

# Example prompt display:
[🌍 dev] [🦀 Rust v1.73] [📁 my_project] [🔀 git:main ✚2]

# Config file lives at ~/.config/starship.toml

You can make it as loud or as clean as you want. Want nerd fonts? Colors? Unicode icons? Powerline vibes? It’s all here.

Bonus:
Use it with tools like zoxide, exa, and bat, and your terminal setup will have enough drip to start its own GitHub repo of dotfiles.

“starship is like a space-grade HUD for your terminal fast, lightweight, and nerdy AF.”

Just the modern make alternative your shell scripts wish they were

Let’s be real writing a Makefile feels like casting ancient spells from a dusty grimoire.
Wouldn’t it be nice if you could write shell commands that actually looked... readable?

Say hello to just, a modern command runner written in Rust that makes scripting fun again.
Think of it as the lovechild of make, npm scripts, and a snack-sized YAML file.

What just can do:

• Define reusable shell commands in a clean, readable format
• Run scripts with autocomplete-friendly names
• Supports variables, conditionals, and shell settings
• Great for dev tasks like building, testing, deploying, etc.

Here’s a justfile example:

# justfile

build:
  cargo build

test:
  cargo test

serve:
  echo "Starting server on port $PORT"
  ./server --port $PORT

Then run it like this:

just build
just serve PORT=8080

No .PHONY. No tab vs space drama. Just simple, readable commands.

Bonus features:

• Cross-platform
• Command aliases
• Shell setting (e.g. set -euxo pipefail baked in if you want it)

“just is like make if it had a UX designer and went to therapy.”

Conclusion: you don’t need to suffer with legacy tools anymore

Let’s be honest using some of the old-school Unix tools in 2025 feels like typing with one hand tied behind your back. Rust CLI tools aren’t just trendy replacements they’re faster, smarter, and designed for humans who live in terminals.

You don’t have to do a full system makeover overnight. Just start swapping the classics with their modern Rust-powered cousins. Each one adds a little more speed, a little more clarity, and a lot less frustration.

Your terminal can be your playground, your dashboard, your dev cockpit not a punishment.
This isn’t about reinventing the wheel it’s about swapping it for a turbocharged one.

Now go alias like a legend.

Helpful resources because we’re not monsters

• ripgrep grep, but make it fast
• fd find without tears
• bat cat but cute
• exa ls but classy
• procs process viewer that doesn’t suck
• dust du with visuals
• bottom the htop killer
• tokei codebase stats you’ll actually use
• bandwhich see who’s hogging your internet