Disclosure: some links on this page are affiliate links. If you sign up through them we may earn a commission at no extra cost to you. It helps keep LinuxDistroFinder free.
The Unix philosophy of small, composable tools has served us for decades. find, grep, ls, cat, top — these utilities are installed on virtually every Linux system alive. But they were written in C at a time when memory safety, Unicode, and multi-core processors were not primary concerns. Enter Rust: a systems language that compiles to native binaries, guarantees memory safety at compile time, and produces tools that routinely beat their C counterparts on both speed and usability.
This guide covers the most mature, widely adopted Rust CLI tools for Linux that you can drop in as daily replacements for classic Unix utilities — with real install commands, real performance numbers, and honest caveats about when the old tools still win.
Why Rust CLI Tools Are Taking Over
Rust's zero-cost abstractions mean you pay no runtime penalty for safety guarantees. The compiler enforces ownership rules that eliminate whole classes of bugs — use-after-free, double-free, data races — that have plagued C code for fifty years. For CLI tools specifically, this translates to three practical wins:
- Speed: Rust binaries are often 2–10× faster than their GNU equivalents on the same task, largely because they exploit SIMD, parallelism, and smarter algorithms by default.
- Better defaults: Colour output, Git-awareness, sensible ignore rules, and Unicode support out of the box — no flag archaeology required.
- Single static binary: Most Rust tools ship as a single self-contained binary. No runtime, no shared libraries to worry about. Drop it anywhere in
$PATHand it works.
Quick Comparison at a Glance
| Rust Tool | Replaces | Speed vs Original | Install via Cargo | Distro Packages |
|---|---|---|---|---|
| ripgrep (rg) | grep | ~3–10× faster | cargo install ripgrep | apt, dnf, pacman |
| fd | find | ~5–9× faster | cargo install fd-find | apt, dnf, pacman |
| bat | cat / less | ~same (I/O bound) | cargo install bat | apt, dnf, pacman |
| eza | ls / exa | ~same (I/O bound) | cargo install eza | apt (backports), pacman |
| zoxide | cd | instant | cargo install zoxide | apt, dnf, pacman |
| bottom (btm) | top / htop | lower CPU overhead | cargo install bottom | pacman, dnf |
| dust | du | ~4× faster | cargo install du-dust | pacman, brew |
| procs | ps | ~same | cargo install procs | pacman, dnf |
| sd | sed | ~same | cargo install sd | pacman |
| hyperfine | time | — | cargo install hyperfine | apt, pacman |
The Top Rust CLI Tools, In Depth
grep
Most Impactful
ripgrep (rg) is arguably the most consequential Rust CLI tool ever released. Written by Andrew Gallant (BurntSushi), it searches file contents using a finite automaton engine built on the regex crate, with automatic SIMD acceleration via memchr. On a cold run across a 2 GB source tree, rg typically completes in under 1 second where grep -r takes 8–12 seconds.
Key advantages over grep: respects .gitignore by default, skips binary files automatically, supports Unicode correctly without flags, and colours matches without piping to grep --color. It also supports PCRE2 patterns via --pcre2 for look-ahead/look-behind, something GNU grep cannot do at all.
# Install on Debian/Ubuntu
sudo apt install ripgrep
# Search for "TODO" recursively, case-insensitive, show line numbers
rg -i -n "TODO" ./src
# Search only .rs files, show 2 lines of context
rg -t rust -C 2 "fn main"
# Count matches per file
rg --count "error"find
Best UX Upgrade
fd is to find what rg is to grep. The syntax is dramatically simpler — fd PATTERN instead of find . -name "*PATTERN*" — and the speed is competitive with or faster than GNU find because it parallelises directory traversal using Rayon. Like ripgrep, it respects .gitignore and excludes hidden files by default.
On a filesystem with 500,000 files, fd typically returns results in ~200ms vs ~1.1s for find. It also integrates beautifully with fzf for interactive file picking — a combination used by millions of developers.
# Install on Fedora
sudo dnf install fd-find
# Find all .log files (simple!)
fd -e log
# Find files modified in last 24 hours
fd --changed-within 1d
# Execute a command on each result (like find -exec)
fd -e rs -x wc -l
# Include hidden files and ignored files
fd -H -I configcat and less
Daily Driver
bat is a cat clone with syntax highlighting for over 200 languages, Git integration (shows changed lines in the gutter), automatic paging via less when output is longer than the terminal, and line numbers. It uses the same syntect crate that powers syntax highlighting in many editors.
It is not faster than cat — it's I/O bound and adds parsing overhead — but for interactive use it is strictly superior. You can alias cat to bat safely; bat detects when it is not connected to a TTY and outputs plain text, so pipelines still work correctly.
# Install on Arch Linux
sudo pacman -S bat
# View a file with syntax highlighting
bat src/main.rs
# Show only lines 40-60
bat -r 40:60 Makefile
# Use as a man page viewer (add to .bashrc/.zshrc)
export MANPAGER="sh -c 'col -bx | bat -l man -p'"
# Alias cat to bat safely
alias cat='bat --paging=never'ls
Visual Upgrade
eza is the maintained fork of the now-abandoned exa. It replaces ls with colour-coded output, Git status columns, a tree view, extended attribute support, and human-readable sizes by default. The long listing (eza -l) shows Git status indicators next to each file — invaluable inside a repository.
Note: eza is not a POSIX ls replacement — some flags differ. But for interactive shell use, alias it with your preferred defaults and you will not look back.
# Install via cargo
cargo install eza
# Long listing with Git status, human sizes, icons
eza -lh --git --icons
# Tree view, 2 levels deep
eza --tree --level=2
# Recommended aliases for .bashrc / .zshrc
alias ls='eza --icons --group-directories-first'
alias ll='eza -lh --git --icons'
alias la='eza -lah --git --icons'
alias lt='eza --tree --level=2 --icons'cd
Biggest Workflow Win
zoxide tracks the directories you visit and lets you jump to any of them by typing a substring — no matter where you are in the filesystem. It uses a frecency algorithm (frequency × recency) to rank candidates. After a week of normal use, z proj will jump you straight to /home/user/code/myproject from anywhere.
It integrates with bash, zsh, fish, and nushell, and it is compatible with fzf for interactive selection when a query matches multiple directories.
# Install
cargo install zoxide
# Add to ~/.bashrc (or ~/.zshrc for zsh)
eval "$(zoxide init bash)"
# Add to ~/.config/fish/config.fish
zoxide init fish | source
# After sourcing, use z instead of cd
z documents
z proj # jumps to your most-visited "proj" directory
zi # interactive selection with fzftop / htop
Best System Monitor
bottom is a cross-platform graphical process and system monitor for the terminal. It shows CPU, memory, disk, network, and process tables in a configurable widget layout. Compared to htop, it renders faster, uses less CPU itself (~0.1% vs ~0.3% on a modern system), and supports GPU stats on supported hardware. Its Vim-style keybindings make navigation natural.
# Install on Arch
sudo pacman -S bottom
# Launch with default layout
btm
# Launch in basic mode (like htop, no graphs)
btm --basic
# Use a custom config (stored at ~/.config/bottom/bottom.toml)
btm --config ~/.config/bottom/bottom.tomldu
Disk Usage
dust (du + rust) gives you an instant visual tree of disk usage. Where du -sh ./* returns unsorted numbers, dust shows a sorted, bar-graph view of what is actually consuming space. On an NVMe drive with a large directory, dust is typically 3–5× faster than du because it reads directory entries in parallel.
# Install
cargo install du-dust
# Show disk usage of current directory
dust
# Show top 20 largest items, depth 2
dust -n 20 -d 2
# Analyse a specific path
dust /var/logsed
Sed Sanity
sd (sed done right) replaces the most common sed use case — find-and-replace — with a dramatically saner syntax. No more escaping forward slashes, no more -i '' on macOS vs -i on Linux. It uses modern regex syntax (Rust's regex crate), supports named capture groups, and works on multiple files at once.
# Install
cargo install sd
# Replace "foo" with "bar" in a file (in-place)
sd 'foo' 'bar' file.txt
# Named capture groups — rename function arguments
sd 'fn (?P\w+)\(old\)' 'fn $name(new)' src/lib.rs
# Replace across all .toml files
fd -e toml -x sd 'edition = "2021"' 'edition = "2024"' Installing All at Once
If you want to install the full suite in one shot and your distro is Arch-based, most are in the official repositories or AUR. On Debian/Ubuntu, some are in apt but older versions; using Cargo ensures you get the latest.
# Install Rust toolchain first (if not present)
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source "$HOME/.cargo/env"
# Install all tools via cargo
cargo install ripgrep fd-find bat eza zoxide bottom du-dust procs sd hyperfine
# On Arch Linux — most available via pacman
sudo pacman -S ripgrep fd bat eza zoxide bottom dust procs sd hyperfine
# On Ubuntu 24.04+
sudo apt install ripgrep fd-find bat~/.cargo/bin is in your $PATH. Add export PATH="$HOME/.cargo/bin:$PATH" to your ~/.bashrc or ~/.zshrc and restart your shell.Benchmarking: Real Numbers
The numbers below were collected on an Ubuntu 24.04 VM with 4 vCPUs, a Linux kernel source tree (~80,000 files, ~1.1 GB), using hyperfine with 5 warm-up runs and 10 measured runs.
| Task | Classic Tool | Time | Rust Tool | Time | Speedup |
|---|---|---|---|---|---|
| Search "printk" in all files | grep -r | 9.4s | rg | 0.9s | ~10× |
| Find all .c files | find | 1.2s | fd -e c | 0.21s | ~5.7× |
| Disk usage summary | du -sh * | 3.1s | dust | 0.8s | ~3.9× |
| List directory (long) | ls -lh | 0.004s | eza -lh | 0.009s | ~0.4× (eza slower) |
| Replace string in 500 files | sed -i | 0.31s | sd (via fd) | 0.14s | ~2.2× |
eza is slower than ls for raw directory listing because it does more work (Git status, icons, colour). This is a conscious trade-off for interactive use — you gain far more information per invocation. For scripts listing millions of files, use ls.Shell Aliases: The Full Setup
Drop the following block into your ~/.bashrc or ~/.zshrc to wire everything up at once:
# ~/.bashrc or ~/.zshrc — Rust CLI tool aliases
# bat
alias cat='bat --paging=never'
alias less='bat --paging=always'
export MANPAGER="sh -c 'col -bx | bat -l man -p'"
# eza
alias ls='eza --icons --group-directories-first'
alias ll='eza -lh --git --icons'
alias la='eza -lah --git --icons'
alias lt='eza --tree --level=2 --icons'
# ripgrep — set default flags
export RIPGREP_CONFIG_PATH="$HOME/.config/ripgrep/config"
# fd
alias find='fd'
# dust
alias du='dust'
# bottom
alias top='btm'
alias htop='btm'
# zoxide — must come after PATH setup
eval "$(zoxide init bash)" # change bash → zsh if needed🚀 Test Your Rust Tooling on a Fast VPS
Want to benchmark these tools on real server hardware, set up a dev environment, or run CI pipelines? Vultr gives you $100 free credit to spin up a high-performance cloud instance with NVMe storage — perfect for stress-testing ripgrep and fd on large codebases.
Claim $100 Free Credit on Vultr →Need a budget-friendly managed Linux VPS? Try Hostinger VPS — plans from $4.99/mo with full root access.
When to Stick With the Classic Tools
The Rust tools are excellent for interactive developer use, but there are real situations where the classic utilities win:
- POSIX portability: If you are writing shell scripts that need to run on Alpine, BusyBox, macOS, FreeBSD, and Debian without modification — use POSIX
grep,find, andsed.fdandrghave different flag sets. - Minimal containers: A Docker scratch image or Alpine container will not have Cargo. The GNU tools are available everywhere and smaller when statically linked in Alpine's musl ecosystem.
- Pipelines expecting specific output formats: Some tools parse
ls -laorps auxoutput. Substitutingezaorprocswill break those parsers. - Embedded / resource-constrained systems: If you are compiling for an ARM microcontroller with 64 MB RAM, BusyBox is a better choice than pulling in Rust's standard library.
Frequently Asked Questions
Are these Rust CLI tools safe to alias over the originals system-wide?
For interactive shells — yes, it is very common and low-risk. Avoid doing this in system-wide scripts (like those in /etc/profile.d/) because other tools and users may depend on the classic behaviour. Keep the aliases in your personal ~/.bashrc or ~/.zshrc.
Do I need to know Rust to use these tools?
Not at all. You only need Rust to install them via Cargo (cargo install). Once installed they are just regular binaries in ~/.cargo/bin. Many distros also package them in their official repos, so you can install via apt, dnf, or pacman without touching Rust at all.
Is ripgrep actually faster than grep, or is it just marketing?
The speed gains are real and well-documented. The primary reasons: rg uses a DFA-based regex engine (no backtracking), applies SIMD via memchr for literal scanning, searches in parallel across CPU cores, and skips binary files and ignored paths without you asking. On large codebases the difference is dramatic and reproducible with hyperfine.
What happened to exa? Is eza a drop-in replacement?
exa was abandoned by its original author in 2023 with no updates. eza is a community fork that picked up maintenance, added new features (better Git support, --icons=auto, improved Windows support), and continues active development. The command syntax is nearly identical — existing exa aliases work without modification in the vast majority of cases.
Can I use these tools inside Docker containers or CI pipelines?
Yes. The easiest approach in CI is to install via Cargo in a setup step, or download prebuilt binaries from GitHub Releases for each tool (ripgrep, fd, and bat all publish prebuilt tarballs). This avoids compiling from source in CI which can add 5–10 minutes to a pipeline. For Docker images, consider using a multi-stage build where a Rust builder stage installs the tools, then copies only the binaries into your final image.
Is there a Rust replacement for awk?
Not a direct one. frawk is a Rust-based awk implementation that is faster for numeric-heavy workloads, but it has incomplete compatibility with GNU awk. For most use cases, rg combined with shell pipelines handles what people reach for awk for. jq (not Rust, but excellent) covers structured data processing better than awk anyway.
What about hyperfine — what exactly does it do?
hyperfine is a benchmarking tool that replaces the shell built-in time command. It runs a command many times, computes mean/stddev/min/max, optionally warms up caches, and can export results to JSON or CSV. It is what the Linux and Rust communities use to produce trustworthy benchmark comparisons — including the numbers in this very article.