---
title: "Modern Unix Tools: Next-Gen CLI Tools in Rust & Go"
description: "Discover modern replacements for classic Unix commands. Faster, safer, and more ergonomic tools written in Rust and Go for the contemporary developer."
url: "https://caro.sh/modern-unix-tools"
markdown_url: "https://caro.sh/modern-unix-tools.md"
lang: "en"
type: "website"
image: "https://caro.sh/og/modern-unix-tools.png"
---

The New Terminal

# Modern Unix Tools

Classic commands, reimagined in Rust & Go

The beloved Unix toolkit is being rewritten for the modern era. These tools honor the Unix philosophy while delivering **blazing performance**, **beautiful output**, and **sensible defaults**. Welcome to the future of the terminal.

[Files & Navigation](https://caro.sh/modern-unix-tools#file-navigation) [Search & Text](https://caro.sh/modern-unix-tools#text-search) [System](https://caro.sh/modern-unix-tools#system-monitoring) [Git & Diff](https://caro.sh/modern-unix-tools#git-tools) [Shell & Prompt](https://caro.sh/modern-unix-tools#shell-prompt) [Utilities](https://caro.sh/modern-unix-tools#utilities) [Networking](https://caro.sh/modern-unix-tools#networking)

## Why modern tools

🚀

### 10x Faster

Written in Rust and Go, these tools leverage parallelism, SIMD, and modern hardware to dramatically outperform their predecessors.

🎨

### Beautiful Output

Syntax highlighting, colors, icons, and thoughtful formatting make output instantly readable and a joy to work with.

🔒

### Memory Safe

Rust's ownership model eliminates buffer overflows, use-after-free, and data races at compile time.

⚡

### Smart Defaults

Sensible behavior out of the box. Respects .gitignore, human-readable sizes, and modern conventions.

📁

## Files & Navigation

List, find, and navigate your filesystem

### eza

replaces `ls`

Rust Popular

A modern replacement for `ls` with colors, icons, Git integration, and tree view built-in. Formerly known as `exa`.

Example

```
# List with icons and git status
eza -la --icons --git

# Tree view with git ignore
eza --tree --git-ignore

# Long format with header
eza -lh --header
```

`brew install eza` or `cargo install eza`

[View on GitHub →](https://github.com/eza-community/eza)

### fd

replaces `find`

Rust Popular

A simple, fast, and user-friendly alternative to `find`. Smart case sensitivity, regex by default, respects .gitignore.

Example

```
# Find files by pattern
fd "\.rs$"

# Find and execute
fd -e js -x prettier -w

# Include hidden files
fd -H config
```

`brew install fd` or `cargo install fd-find`

[View on GitHub →](https://github.com/sharkdp/fd)

### zoxide

replaces `cd`

Rust

A smarter `cd` command that learns your habits. Jump to frequently used directories with partial matches.

Example

```
# Jump to best match
z projects

# Interactive selection
zi

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

`brew install zoxide` or `cargo install zoxide`

[View on GitHub →](https://github.com/ajeetdsouza/zoxide)

### broot

replaces `tree`

Rust

An interactive tree view with fuzzy search. Navigate large directories, preview files, and perform operations without leaving.

Example

```
# Launch interactive tree
br

# Show sizes
br -s

# Search files
br -f pattern
```

`brew install broot` or `cargo install broot`

[View on GitHub →](https://github.com/Canop/broot)

### dust

replaces `du`

Rust

A more intuitive `du`. Visual representation of disk usage with colors and automatic depth limiting.

Example

```
# Analyze current directory
dust

# Limit depth
dust -d 2

# Reverse order
dust -r
```

`brew install dust` or `cargo install du-dust`

[View on GitHub →](https://github.com/bootandy/dust)

### lsd

replaces `ls`

Rust

LSDeluxe—another modern `ls` with colors, icons, tree view, and more. Alternative to eza with slightly different aesthetics.

Example

```
# List with all features
lsd -la

# Tree view
lsd --tree

# Sort by size
lsd -lS
```

`brew install lsd` or `cargo install lsd`

[View on GitHub →](https://github.com/lsd-rs/lsd)

🔍

## Search & Text Processing

Find, view, and transform text at lightning speed

### ripgrep (rg)

replaces `grep`

Rust Essential

The fastest grep around. Respects .gitignore, searches recursively by default, and uses smart case sensitivity. A must-have for any developer.

Example

```
# Search recursively
rg "pattern"

# Search specific file types
rg -t rust "fn main"

# Show context lines
rg -C 3 "TODO"
```

`brew install ripgrep` or `cargo install ripgrep`

[View on GitHub →](https://github.com/BurntSushi/ripgrep)

### bat

replaces `cat`

Rust Essential

A `cat` clone with wings. Syntax highlighting, line numbers, Git integration, and automatic paging. Makes reading code a pleasure.

Example

```
# View with syntax highlighting
bat file.rs

# Show line numbers only
bat -n file.py

# Plain output (for piping)
bat -p file.json
```

`brew install bat` or `cargo install bat`

[View on GitHub →](https://github.com/sharkdp/bat)

### sd

replaces `sed`

Rust

An intuitive find & replace CLI. Uses regex syntax you already know (not sed's arcane syntax), and supports replacements across multiple files.

Example

```
# Simple replacement
sd 'before' 'after' file.txt

# Regex capture groups
sd '(\d+)' '$1.0' data.txt

# In-place on multiple files
sd -i 'old' 'new' *.md
```

`brew install sd` or `cargo install sd`

[View on GitHub →](https://github.com/chmln/sd)

### fzf

enhances everything

Go Essential

A general-purpose fuzzy finder. Enhances shell history, file finding, and virtually any list-based selection. Integrates beautifully with other tools.

Example

```
# Fuzzy find files
fzf

# With preview
fzf --preview 'bat --color=always '

# Search history (Ctrl+R)
# Kill process (Ctrl+T)
```

`brew install fzf`

[View on GitHub →](https://github.com/junegunn/fzf)

### jq

JSON processor

C

The essential JSON processor. Filter, transform, and query JSON data from the command line. Indispensable for API work and configuration.

Example

```
# Pretty print JSON
cat data.json | jq '.'

# Extract field
jq '.name' package.json

# Filter array
jq '.[] | select(.active)' users.json
```

`brew install jq`

[View on GitHub →](https://github.com/jqlang/jq)

### hexyl

replaces `hexdump`

Rust

A colorful hex viewer. Displays binary files with byte categories highlighted in different colors. Much more readable than traditional hex dumps.

Example

```
# View binary file
hexyl binary.exe

# Limit bytes shown
hexyl -n 256 file.bin

# Skip to offset
hexyl --skip 512 file.dat
```

`brew install hexyl` or `cargo install hexyl`

[View on GitHub →](https://github.com/sharkdp/hexyl)

📊

## System Monitoring

Watch your system resources in style

### bottom (btm)

replaces `top`/`htop`

Rust Popular

A cross-platform graphical process/system monitor. Beautiful TUI with CPU, memory, disk, network, and process views. Vim keybindings available.

Example

```
# Launch bottom
btm

# Basic mode
btm -b

# With custom config
btm --config ~/.config/bottom/bottom.toml
```

`brew install bottom` or `cargo install bottom`

[View on GitHub →](https://github.com/ClementTsang/bottom)

### procs

replaces `ps`

Rust

A modern replacement for `ps`. Colorful output, tree view, Docker awareness, and pager support by default.

Example

```
# List all processes
procs

# Tree view
procs --tree

# Watch mode
procs --watch
```

`brew install procs` or `cargo install procs`

[View on GitHub →](https://github.com/dalance/procs)

### bandwhich

replaces `nethogs`

Rust

Network utilization by process. See which processes are consuming bandwidth, with remote addresses and connection information.

Example

```
# Monitor bandwidth (needs sudo)
sudo bandwhich

# Show raw mode
sudo bandwhich --raw
```

`brew install bandwhich` or `cargo install bandwhich`

[View on GitHub →](https://github.com/imsnif/bandwhich)

### hyperfine

replaces `time`

Rust

A command-line benchmarking tool. Statistical analysis, warmup runs, export to various formats, and comparison between multiple commands.

Example

```
# Benchmark a command
hyperfine 'rg pattern'

# Compare commands
hyperfine 'grep -r pattern' 'rg pattern'

# With warmup
hyperfine --warmup 3 'cargo build'
```

`brew install hyperfine` or `cargo install hyperfine`

[View on GitHub →](https://github.com/sharkdp/hyperfine)

### tokei

replaces `cloc`

Rust

Count lines of code quickly. Extremely fast, supports many languages, and provides detailed breakdowns by file type.

Example

```
# Count lines in current dir
tokei

# Specific directory
tokei src/

# Exclude directories
tokei --exclude node_modules
```

`brew install tokei` or `cargo install tokei`

[View on GitHub →](https://github.com/XAMPPRocky/tokei)

🌿

## Git & Diff Tools

Better diffs and Git workflows

### delta

replaces `diff`

Rust Essential

A syntax-highlighting pager for git, diff, and grep output. Side-by-side view, line numbers, and beautiful themes. Makes reviewing changes a pleasure.

Example

```
# Configure as git pager
[core]
    pager = delta

[interactive]
    diffFilter = delta --color-only

# Or use directly
diff file1 file2 | delta
```

`brew install git-delta` or `cargo install git-delta`

[View on GitHub →](https://github.com/dandavison/delta)

### lazygit

enhances `git`

Go Popular

A simple terminal UI for Git. Stage chunks interactively, browse history, manage branches, and handle conflicts visually. Git without memorizing flags.

Example

```
# Launch lazygit
lazygit

# In a specific repo
lazygit -p /path/to/repo

# With custom config
lazygit -ucf ~/.config/lazygit/config.yml
```

`brew install lazygit` or `go install github.com/jesseduffield/lazygit@latest`

[View on GitHub →](https://github.com/jesseduffield/lazygit)

### gitui

enhances `git`

Rust

Blazing fast terminal UI for Git. Similar to lazygit but written in Rust for maximum performance. Excellent for large repositories.

Example

```
# Launch gitui
gitui

# With custom key bindings
gitui -t ~/.config/gitui/theme.ron
```

`brew install gitui` or `cargo install gitui`

[View on GitHub →](https://github.com/extrawurst/gitui)

### gh

GitHub CLI

Go Official

GitHub's official CLI. Create PRs, manage issues, trigger workflows, and browse repos without leaving the terminal. Essential for GitHub users.

Example

```
# Create a PR
gh pr create

# View PR status
gh pr status

# Clone and enter repo
gh repo clone owner/repo
```

`brew install gh`

[View on GitHub →](https://github.com/cli/cli)

### difftastic

replaces `diff`

Rust

A structural diff tool that understands syntax. Compares files based on their AST, not just text, leading to more meaningful diffs for code.

Example

```
# Compare files
difft old.rs new.rs

# Use as git diff
git config --global diff.external difft

# Side by side
difft --display side-by-side old.py new.py
```

`brew install difftastic` or `cargo install difftastic`

[View on GitHub →](https://github.com/Wilfred/difftastic)

🐚

## Shell & Prompt

Modern shells and beautiful prompts

### Starship

cross-shell prompt

Rust Essential

A minimal, fast, and customizable prompt for any shell. Shows git status, language versions, container info, and more. One config works everywhere.

Example

```
# Add to .zshrc
eval "$(starship init zsh)"

# Add to .bashrc
eval "$(starship init bash)"

# Configure in starship.toml
[git_branch]
symbol = "🌿 "
```

`brew install starship` or `cargo install starship`

[View on GitHub →](https://github.com/starship/starship)

### Nushell

replaces `bash`/`zsh`

Rust

A new type of shell. Everything is structured data, not just text. Built-in data manipulation, modern syntax, and cross-platform consistency.

Example

```
# List files as table
ls | where size > 1mb

# Parse JSON directly
open package.json | get dependencies

# System info as data
sys | get host.name
```

`brew install nushell` or `cargo install nu`

[View on GitHub →](https://github.com/nushell/nushell)

### Zellij

replaces `tmux`/`screen`

Rust

A modern terminal multiplexer. Intuitive UI, WebAssembly plugin system, and sensible defaults. No more memorizing obscure key combinations.

Example

```
# Start zellij
zellij

# With layout
zellij --layout default

# Attach to session
zellij attach my-session
```

`brew install zellij` or `cargo install zellij`

[View on GitHub →](https://github.com/zellij-org/zellij)

### Atuin

replaces shell history

Rust

Magical shell history. Sync history across machines, full-text search with fuzzy finding, and analytics on your command usage. Never lose a command again.

Example

```
# Search history
atuin search docker

# Interactive history (Ctrl+R)
# Syncs automatically

# Stats about your usage
atuin stats
```

`brew install atuin` or `cargo install atuin`

[View on GitHub →](https://github.com/atuinsh/atuin)

🧰

## Utilities

Helpful tools for everyday tasks

### tldr

replaces `man`

Rust (tealdeer)

Simplified, community-driven man pages. See practical examples immediately instead of wading through verbose documentation. The `tealdeer` client is written in Rust.

Example

```
# Quick help for tar
tldr tar

# Update local cache
tldr --update

# List all pages
tldr --list
```

`brew install tealdeer` or `cargo install tealdeer`

[View on GitHub →](https://github.com/dbrgn/tealdeer)

### just

replaces `make`

Rust

A handy command runner. Like `make` but focused on running commands rather than building. No tabs-vs-spaces issues, better syntax, and cross-platform.

Example

```
# justfile
build:
    cargo build --release

test:
    cargo test

deploy: build test
    ./deploy.sh
```

`brew install just` or `cargo install just`

[View on GitHub →](https://github.com/casey/just)

### xh

replaces `curl`/`httpie`

Rust

Friendly HTTP client. HTTPie-compatible syntax with Rust performance. Colorized output, intuitive syntax for headers and data, and built-in JSON support.

Example

```
# GET request
xh httpbin.org/get

# POST JSON
xh POST api.example.com/users name=John

# With headers
xh GET api.example.com Authorization:token
```

`brew install xh` or `cargo install xh`

[View on GitHub →](https://github.com/ducaale/xh)

### yazi

replaces file managers

Rust

Blazing fast terminal file manager. Async I/O, image preview, extensive customization, and Vim-like keybindings. Navigate your filesystem at the speed of thought.

Example

```
# Launch yazi
yazi

# Start in directory
yazi /path/to/dir

# With custom config
yazi --config ~/.config/yazi
```

`brew install yazi` or `cargo install yazi-fm`

[View on GitHub →](https://github.com/sxyazi/yazi)

🌐

## Networking

Modern network tools and diagnostics

### dog

replaces `dig`

Rust

A command-line DNS client. Colorful output, supports DNS-over-TLS and DNS-over-HTTPS, and provides modern formatting for DNS queries.

Example

```
# Query A records
dog example.com

# Query MX records
dog example.com MX

# Use DoH
dog example.com --https @cloudflare
```

`brew install dog` or `cargo install dog`

[View on GitHub →](https://github.com/ogham/dog)

### gping

replaces `ping`

Rust

Ping with a graph. Visualize ping times over time in your terminal. Great for monitoring network stability and comparing multiple hosts.

Example

```
# Ping with graph
gping google.com

# Multiple hosts
gping google.com cloudflare.com

# Custom interval
gping -n 0.5 8.8.8.8
```

`brew install gping` or `cargo install gping`

[View on GitHub →](https://github.com/orf/gping)

### miniserve

replaces `python -m http.server`

Rust

A tiny HTTP server for quick file sharing. Colored output, QR code for mobile access, upload support, and directory listings. Zero config needed.

Example

```
# Serve current directory
miniserve .

# With upload support
miniserve --upload-files .

# Show QR code
miniserve --qrcode .
```

`brew install miniserve` or `cargo install miniserve`

[View on GitHub →](https://github.com/svenstaro/miniserve)

## Quick Install All Essentials

Get started with the most popular modern tools in one command:

```
# Install via Homebrew
brew install eza bat ripgrep fd dust bottom sd git-delta fzf zoxide starship
```

```
# Install via Cargo (requires Rust)
cargo install eza bat ripgrep fd-find du-dust bottom sd git-delta zoxide starship
```

## Let Caro Help You Navigate

Not sure which command to use? Caro understands both classic Unix and modern tools. Ask in natural language and get the right command—whether it's `grep` or `ripgrep`.

[Try Caro](https://caro.sh/) [Read the Blog Post](https://caro.sh/blog/rust-unix-tools)