TL;DR:

  • Five Rust-built CLI tools — bat, fd, ripgrep, eza, and dust — replace cat, find, grep, ls, and du with faster, more readable alternatives that handle code-heavy workflows better
  • Each can be installed independently and aliased to the standard command name, so you can adopt them incrementally without changing your muscle memory
  • ripgrep alone is worth it on large codebases — it’s 5-10x faster than grep with sensible defaults and respects .gitignore automatically

Most developers spend a meaningful fraction of their working day in the terminal. The standard Unix tools — grep, find, ls, cat, du — are decades old and were designed for a different world. They work, but they have rough edges that slow you down: no syntax highlighting, no .gitignore awareness, verbose flags for common operations, and performance that noticeably degrades on large codebases. A set of Rust-built alternatives has matured to the point where they’re worth adopting for any developer who spends serious time at the command line.

Here’s the practical case for each tool, how to configure it, and how to alias it so you don’t have to change your habits.

bat — cat with syntax highlighting and git integration

bat replaces cat with syntax highlighting, line numbers, and git change indicators in the gutter. It supports over 200 languages out of the box, uses the same syntax highlighting themes as popular editors, and automatically pipes to a pager (like less) for files that don’t fit the screen.

Installation: brew install bat on macOS, apt install bat on Debian/Ubuntu (note: the binary may be named batcat on Debian systems — alias it manually).

The two most useful configurations:

# ~/.bashrc or ~/.zshrc
alias cat='bat --paging=never'   # use bat but don't page short files
export BAT_THEME="Dracula"        # or "gruvbox-dark", "OneHalfDark"

--paging=never makes it behave like cat for piping and scripting. When you want the pager, run bat directly.

The git integration is genuinely useful. Lines added since the last commit show + in green in the gutter; modified lines show ~; deleted lines show -. When you’re doing a quick review before a commit, bat myfile.rs shows you what changed without leaving the terminal.

fd — a faster, more intuitive find

find is powerful but the flag syntax is hostile. fd replaces it with sensible defaults: case-insensitive by default, respects .gitignore and .fdignore by default, and uses regex patterns rather than glob patterns. Running fd pattern searches the current directory recursively — no need for find . -name "*pattern*".

Installation: brew install fd, apt install fd-find (Debian), or cargo install fd-find.

# Find all TypeScript files
fd -e ts

# Find files matching a pattern, excluding node_modules (ignored by default via .gitignore)
fd "component"

# Execute a command on all matches (like find -exec but cleaner)
fd -e md -x pandoc {} -o {.}.html

The killer feature for developers is the .gitignore integration. When you run find . -name "*.ts" in a Node project, you get thousands of results from node_modules. fd -e ts returns only the files you actually care about. You can override this with --no-ignore when you genuinely need to search inside node_modules or dist.

ripgrep — grep that actually works on codebases

ripgrep (rg) is the tool with the biggest immediate impact on most developers. It’s dramatically faster than grep — typically 5-10x, sometimes much more on large codebases — and has better defaults for code search.

By default, ripgrep: respects .gitignore, skips hidden files, skips binary files, searches recursively from the current directory, and highlights matches with context. Compare grep -r "useState" . (painfully slow, includes node_modules, no colour) with rg "useState" (fast, coloured output, only your source files).

Installation: brew install ripgrep, apt install ripgrep, or cargo install ripgrep.

Most useful flags for daily use:

# Search for a string, showing context
rg "pattern" -C 3

# Search specific file types
rg "useState" -t ts

# Search with regex
rg "function \w+Async" --pcre2

# List only filenames that match
rg "pattern" -l

# Search for whole words only
rg -w "render"

You can configure a global ripgreprc file to set defaults:

# ~/.ripgreprc
--max-columns=150
--type-add=web:*.{html,css,js,ts,tsx,jsx}
--smart-case

Export RIPGREP_CONFIG_PATH=~/.ripgreprc to load it automatically.

eza — a modern ls replacement

eza (the maintained fork of exa) replaces ls with colour-coded output, git status per-file, and better defaults for tree views.

Installation: brew install eza, or available via most package managers.

The aliases most developers settle on:

alias ls='eza --icons'
alias ll='eza -l --icons --git'
alias la='eza -la --icons --git'
alias lt='eza --tree --level=2 --icons'

The --git flag adds a small git status column to the long listing — showing whether each file is modified, staged, untracked, or ignored. Combined with --icons (requires a Nerd Font), directory listings become noticeably more scannable.

The tree view (eza --tree) is the most practically useful feature. It renders a directory tree with syntax colouring without requiring you to install tree separately. eza --tree --level=2 gives you a concise project structure view that’s easier to read than find output.

dust — du that shows you what’s actually using space

dust replaces du for disk usage analysis. The standard du -sh ./* gives you a flat list of sizes that requires sorting and parsing. dust gives you a tree-structured visualisation of disk usage with a proportional bar chart, making it immediately clear where space is going.

Installation: brew install dust, cargo install du-dust.

# Show disk usage from current directory
dust

# Limit depth
dust -d 2

# Sort by name instead of size
dust -n

# Show apparent size (file sizes vs disk blocks)
dust -s

The typical use case is diagnosing why a project directory is large. dust in a Node project will immediately show you that node_modules or .next is consuming 95% of the space. In a Python project, it’ll surface .venv. In a Rust project, it’ll point to target/. The visual bar chart makes this obvious at a glance rather than requiring you to sort and interpret a number list.

Installing All Five

If you use Homebrew:

brew install bat fd ripgrep eza dust

With cargo:

cargo install bat fd-find ripgrep eza du-dust

Add these to your shell config for a complete drop-in setup:

alias cat='bat --paging=never'
alias ls='eza --icons'
alias ll='eza -l --icons --git'
alias la='eza -la --icons --git'
alias lt='eza --tree --level=2 --icons'
alias find='fd'
alias grep='rg'
alias du='dust'

The key advantage of this stack is that each tool independently justifies its adoption. You don’t need to commit to all five at once. Most developers start with ripgrep (fastest payoff on any codebase), then add bat (immediate visual improvement for file reading), then the others as they encounter the pain points the originals cause. The full stack together makes the terminal a noticeably faster, more readable environment.