Best CLI Tools Every Developer Should Know in 2026

The command line has experienced a renaissance. A wave of modern tools – written mostly in Rust and Go – have replaced decades-old Unix utilities with faster, more intuitive, and more visually informative alternatives. These are not just cosmetic upgrades. Tools like ripgrep are genuinely faster than grep, fd is simpler than find, and bat adds syntax highlighting that makes reading code in the terminal a productive experience.

This guide covers the CLI tools that consistently appear in developer setups and have proven their value across thousands of real-world workflows.

Quick Reference Table

File Navigation and Listing

eza – Modern ls Replacement

eza (the maintained fork of the now-archived exa) replaces ls with a more readable, more informative directory listing.

Why it matters:

# Standard ls output -- plain text, no context
ls -la

# eza output -- icons, git status, color-coded file types
eza -la --icons --git

Key features: - File type icons – instantly distinguish directories, images, configs, source files - Git status integration – see which files are modified, staged, or untracked directly in the listing - Tree view – eza --tree --level=3 replaces the tree command with git-aware, color-coded output - Column headers – optional headers make permission and ownership columns readable - Smart defaults – color output, human-readable sizes, and sorted by name

Install:

# macOS
brew install eza

# Ubuntu/Debian
sudo apt install eza

# Arch
pacman -S eza

Recommended alias:

alias ls="eza --icons"
alias ll="eza -la --icons --git"
alias lt="eza --tree --level=3 --icons"

zoxide – Smarter cd

zoxide tracks which directories you visit most frequently and lets you jump to them with partial name matches. It replaces cd with a frecency-based algorithm (frequency + recency).

Why it matters:

# Traditional navigation
cd ~/projects/company/frontend/src/components

# With zoxide -- from anywhere
z components
# Jumps to the most-visited directory matching "components"

After a few days of use, zoxide learns your patterns. Type z proj and it jumps to ~/projects. Type z front and it goes to your most-visited frontend directory. The time savings compound – according to developer surveys, directory navigation accounts for 8-12% of terminal interactions.

Install:

brew install zoxide
# Add to .zshrc: eval "$(zoxide init zsh)"

fzf – Fuzzy Finder for Everything

fzf is a general-purpose fuzzy finder that transforms any list into an interactive, searchable, filterable interface. It integrates with your shell history, file system, git branches, and any command that produces text output.

Why it matters:

# Search command history interactively
# Press Ctrl+R with fzf installed -- instantly searchable history

# Find and open files
vim $(fzf)

# Checkout a git branch interactively
git branch | fzf | xargs git checkout

# Kill a process interactively
ps aux | fzf | awk '{print $2}' | xargs kill

fzf is arguably the single most productivity-enhancing CLI tool. It replaces the painful process of typing long paths or grepping through history with instant, typo-tolerant search across any text.

Install:

brew install fzf
# Run install script for key bindings
$(brew --prefix)/opt/fzf/install

File Viewing and Searching

bat – cat with Syntax Highlighting

bat replaces cat with automatic syntax highlighting, line numbers, git integration, and paging for long files.

Why it matters:

# cat shows raw text
cat config.yaml

# bat shows syntax-highlighted, line-numbered output with git diff markers
bat config.yaml

Features beyond highlighting: - Git integration – shows modified lines in the gutter (like a miniature diff) - Automatic paging – pipes to a pager for long files, passes through for short ones - File concatenation – still works as a cat replacement for piping - Theme support – 25+ built-in themes matching popular editor themes

Install:

brew install bat

Recommended alias:

alias cat="bat --paging=never"

ripgrep (rg) – grep, but Fast

ripgrep is a line-oriented search tool that recursively searches directories for a regex pattern. It is written in Rust and is consistently benchmarked as the fastest grep alternative available.

Why it matters:

Benchmarks show ripgrep outperforming grep by 5-10x on large codebases and outperforming ag (The Silver Searcher) by 2-3x. But speed is only part of the story:

• Respects .gitignore – automatically skips node_modules, target, .git, and other ignored paths
• Smart case sensitivity – case-insensitive by default, switches to case-sensitive when you use uppercase characters
• File type filtering – rg --type=py "import" searches only Python files
• Replacement – rg "old_name" -r "new_name" for find-and-replace across files

# Search a large codebase
rg "TODO|FIXME" --type=rust

# Search with context
rg -C 3 "function.*auth"

# Count matches per file
rg -c "import" --type=ts

Install:

brew install ripgrep

fd – find, but Intuitive

fd is a simple, fast alternative to find. Its syntax is designed for common use cases, eliminating the arcane flag combinations that find requires.

Why it matters:

# find -- verbose, hard to remember
find . -name "*.py" -type f -not -path "./venv/*"

# fd -- intuitive, fast
fd -e py
# Automatically ignores .gitignore'd paths

Key features: - Smart case sensitivity – same behavior as ripgrep - Regex by default – fd "test.*spec" works without flags - Parallel execution – fd -e log -x gzip {} compresses all log files in parallel - Respects .gitignore – no more manually excluding node_modules

Install:

brew install fd

System Monitoring

btop – Beautiful System Monitor

btop provides a full-featured, visually rich system monitor that shows CPU, memory, disk, network, and process information in a single terminal interface.

Why it matters:

While top shows raw process lists and htop adds color and sorting, btop provides: - CPU per-core graphs with historical data (not just current snapshot) - Memory breakdown showing cached, buffers, and available memory visually - Network monitoring with upload/download graphs - Disk I/O monitoring per device - Process tree view showing parent-child relationships - Mouse support – click to sort, select, and interact

btop replaces the need for multiple monitoring tools. Instead of switching between htop, iotop, nload, and df, everything is visible in one interface.

Install:

brew install btop

dust – Intuitive Disk Usage

dust provides a visual representation of disk usage, replacing du with output that is immediately understandable without piping through sort and head.

Why it matters:

# Traditional approach
du -sh * | sort -rh | head -20

# dust -- visual bar chart, sorted, with percentages
dust

dust shows a bar chart of disk usage with the largest directories at the bottom, percentages, and file counts. It answers “what is eating my disk space?” in one command instead of a pipeline.

Install:

brew install dust

Git Workflow

delta – Better Git Diffs

delta is a syntax-highlighting pager for git diff, git show, git log, and grep output. It transforms the default diff output into something that looks like a modern code review tool.

Why it matters:

• Syntax highlighting in diffs (the code itself is highlighted, not just the +/- lines)
• Side-by-side view – delta --side-by-side shows old and new code next to each other
• Line numbers in diffs for easy reference
• Word-level diff highlighting – within a changed line, delta highlights exactly which words changed
• Navigate between files – n and N to jump between changed files

Install:

brew install git-delta

Configure in ~/.gitconfig:

[core]
    pager = delta

[interactive]
    diffFilter = delta --color-only

[delta]
    navigate = true
    side-by-side = true
    line-numbers = true

lazygit – Terminal UI for Git

lazygit provides a full terminal user interface for git operations. It shows staged/unstaged changes, commit history, branches, and stashes in a multi-panel layout that you navigate with keyboard shortcuts.

Why it matters:

Common operations that require multiple git commands become single-keypress actions: - Stage individual hunks – press space on a specific change to stage just that part - Interactive rebase – visual interface for reordering, squashing, and editing commits - Branch management – create, checkout, merge, rebase, and delete branches from a visual list - Conflict resolution – see conflicts in context with one-keypress resolution

For developers who prefer the terminal over GUI git clients but find raw git commands tedious for complex operations, lazygit fills the gap.

Install:

brew install lazygit

HTTP and API Tools

httpie / xh – Human-Friendly HTTP

httpie (and its Rust-based counterpart xh) replaces curl with a more intuitive syntax and colorized, formatted output.

Why it matters:

# curl -- verbose, hard to read output
curl -X POST -H "Content-Type: application/json" -d '{"name":"test"}' https://api.example.com/users

# httpie -- intuitive syntax, formatted output
http POST api.example.com/users name=test

# xh -- same syntax, written in Rust (faster startup)
xh POST api.example.com/users name=test

Key differences: - Automatic JSON – name=value pairs are automatically sent as JSON - Colorized output – response headers and body are syntax-highlighted - Sensible defaults – Content-Type: application/json is automatic for POST with data - Session support – http --session=api remembers auth tokens between requests

Install:

brew install httpie
# or the Rust alternative
brew install xh

Documentation and Help

tldr – Practical Command Examples

tldr replaces dense man pages with concise, example-driven command references. Instead of reading 500 lines of documentation to find the right flags, tldr shows the 5-8 most common use cases.

Why it matters:

# man tar -- 800+ lines of documentation
man tar

# tldr tar -- 8 practical examples
tldr tar

The tldr community maintains pages for 2,000+ commands across Linux, macOS, and Windows. Each page shows real-world examples with explanations, covering 90% of typical usage.

Install:

brew install tldr

JSON Processing

jq – Command-Line JSON Processor

jq is the standard tool for parsing, filtering, and transforming JSON data in the terminal. When working with APIs, configuration files, or log data, jq is indispensable.

Why it matters:

# Pretty-print JSON
curl -s api.example.com/users | jq .

# Extract specific fields
cat data.json | jq '.users[] | {name, email}'

# Filter by condition
jq '.items[] | select(.price > 100)' products.json

# Count items
jq '.results | length' response.json

jq has a learning curve, but its query language is consistent and composable. Once you learn the basics (.field, [], |, select()), you can process complex JSON without writing scripts.

Install:

brew install jq

Recommended Starter Setup

For developers new to modern CLI tools, install these five first – they provide the highest immediate value with minimal configuration:

1. ripgrep – searching code is a daily activity, and rg is dramatically faster
2. fzf – fuzzy finding transforms shell history and file navigation
3. bat – reading files with syntax highlighting is immediately useful
4. zoxide – smart directory navigation saves time from the first day
5. eza – better directory listings with zero learning curve

# Install all five at once (macOS)
brew install ripgrep fzf bat zoxide eza

# Add to .zshrc
eval "$(zoxide init zsh)"
alias ls="eza --icons"
alias cat="bat --paging=never"

Total setup time: under 5 minutes. Immediate benefit: faster, more readable terminal interactions for every workflow.

Frequently Asked Questions

Do these tools work on Linux and macOS?

All tools listed here are cross-platform and work on macOS, Linux, and most work on Windows (via WSL or native builds). Package manager availability varies – brew works on macOS and Linux, while Linux distributions have these tools in their package managers (apt, pacman, dnf) with varying version freshness.

Will these break my existing scripts?

No, if you install them alongside existing tools. The aliasing approach (alias ls="eza") only affects interactive shell sessions. Scripts that reference /usr/bin/ls or /usr/bin/grep directly will continue using the system tools. If you want to be cautious, avoid aliasing and use the new tool names directly (type eza instead of aliased ls).

Are Rust-based CLI tools actually faster?

Yes, measurably. ripgrep benchmarks show 2-10x speed improvements over grep and 2-3x over ag (The Silver Searcher) on large codebases. fd is 5-8x faster than find for common operations. The performance difference is most noticeable on large repositories – on small projects, both old and new tools feel instant.

How do I remember all these new commands?

Start with the five-tool starter setup above. Use tldr to look up syntax when needed. After a week of daily use, the commands become muscle memory. The key is not to install everything at once – add one tool per week, get comfortable with it, then add the next.

This article contains affiliate links. We may earn a commission if you purchase through our links, at no extra cost to you.