12 Modern CLI Tools Every Developer Should Use in 2026

Short answer: if you only install two tools from this list, make them fzf and zoxide; they remove more daily friction than everything else combined. Then add ripgrep for search, lazygit for Git, and bat for reading files. The full list, with install commands verified current for mid-2026, is below.

The terminal you use every day probably still runs tools designed decades ago. That is a choice, not a necessity: the command line has quietly entered a renaissance, and modern CLI tools are faster, more intuitive, and increasingly AI-powered.

These 12 tools are not incremental improvements over the classics. They change how you interact with your file system, code, and development environment. Every one of them is actively maintained as of July 2026, and every install command here has been checked against the current official instructions (two of the old standbys quietly broke this year; more on that below).

Quick Reference: Modern CLI Tools

File Navigation and Search

1. fzf - The Fuzzy Finder

fzf is perhaps the single most impactful CLI tool you can install. It's a general-purpose fuzzy finder that integrates with everything: your shell history, file system, Git branches, and any text input. It is also one of the most actively developed tools on this list, with releases still landing monthly in 2026.

What it does: Type a few characters and fzf instantly filters thousands of items to find matches. Press Enter to select, and the result pipes to whatever command you're running.

Key use cases:

• Shell history: Press Ctrl+R and fuzzy search through every command you've ever run
• File finding: fzf in any directory shows all files recursively, filtered as you type
• Git branches: git checkout $(git branch | fzf) lets you pick branches visually
• Process killing: ps aux | fzf | awk '{print $2}' | xargs kill

Installation:

# macOS
brew install fzf

# Ubuntu/Debian
sudo apt install fzf

# Enable shell integration (add to ~/.zshrc or ~/.bashrc)
source <(fzf --zsh)     # zsh
eval "$(fzf --bash)"    # bash

Note: older guides point you at an install script inside the Homebrew prefix. That still exists, but the one-liner shell integration above is the current documented method.

Why it matters: Once you use fzf, typing exact names feels primitive. Fuzzy matching is how our brains actually work.

2. ripgrep (rg) - Faster Than grep

ripgrep has become the de facto replacement for grep in modern development. VS Code uses it internally for search, and it keeps evolving: ripgrep 15 (late 2025) added support for Jujutsu (jj) repositories alongside Git, a small sign of how current this tool stays.

What makes it better:

• Speed: Dramatically faster than grep on real codebases (the author publishes benchmarks; the gap depends on workload, but it is rarely close)
• Smart defaults: Ignores .gitignore patterns, binary files, and hidden directories
• Familiar syntax: Same regex patterns you know, but with sensible flags
• Pretty output: Colored matches with line numbers by default

Common usage:

# Search for "TODO" in all files
rg TODO

# Search only in JavaScript files
rg "function" --type js

# Case-insensitive search
rg -i "error"

# Show context around matches
rg "import" -C 3

Installation:

# macOS
brew install ripgrep

# Ubuntu/Debian
sudo apt install ripgrep

3. fd - A Simpler find

The find command is powerful but its syntax is notoriously obtuse. fd provides a modern alternative with intuitive syntax and sensible defaults.

Comparison:

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

# fd equivalent
fd -e js

Key improvements:

• Simple syntax: Patterns work like you'd expect
• Speed: Uses parallel processing
• Smart ignoring: Respects .gitignore by default
• Colorized output: Easier to scan results

Common usage:

# Find all Python files
fd -e py

# Find directories named "test"
fd -t d test

# Find and delete all .log files
fd -e log -x rm

# Find files modified in last 24 hours
fd --changed-within 24h

4. zoxide - Smarter cd

zoxide learns which directories you visit most and lets you jump to them with partial names. After a few days of use, you'll never type full paths again.

How it works:

# First, visit directories normally
cd ~/Projects/nexasphere/content/posts

# Later, jump directly with partial match
z posts    # Jumps to the most likely "posts" directory
z nex      # Jumps to nexasphere
z proj     # Jumps to Projects

Installation:

# macOS
brew install zoxide

# Add to your .zshrc or .bashrc
eval "$(zoxide init zsh)"

zoxide tracks "frecency" (frequency + recency), so directories you visit often and recently rank higher.

Better File Viewing

5. bat - cat with Wings

bat displays files with syntax highlighting, line numbers, and Git integration. It's a drop-in replacement for cat that makes reading code in the terminal pleasant.

Features:

• Syntax highlighting: Supports 100+ languages
• Line numbers: Always visible, easily referenced
• Git integration: Shows modifications inline
• Paging: Automatically pipes long output to a pager

Usage:

# View a file with highlighting
bat src/index.js

# Show all files matching a pattern
bat *.py

# Plain output (for piping)
bat -p file.txt | other_command

Pro tip: Alias cat to bat in your shell config:

alias cat="bat"

6. eza - A Modern ls

eza (formerly exa) replaces ls with a modern alternative featuring icons, colors, Git status indicators, and a tree view.

What it adds:

• Icons: File type icons for visual scanning
• Git status: Shows modified, staged, and untracked files
• Extended attributes: File sizes, permissions, dates in readable formats
• Tree view: Built-in recursive tree display

Common usage:

# Basic listing with icons
eza --icons

# Long format with Git status
eza -l --git

# Tree view
eza --tree --level=2

# All files including hidden
eza -a

Recommended aliases:

alias ls="eza --icons"
alias ll="eza -l --git --icons"
alias tree="eza --tree --icons"

Git and Version Control

7. lazygit - Git Visualization in Terminal

lazygit brings a visual Git interface to your terminal. No more memorizing complex Git commands: navigate with arrow keys and shortcuts. It is one of the fastest-moving tools here, and the 2026 releases even show GitHub pull request status next to your branches (with the gh CLI installed).

What you can do:

• Stage files: Select individual files or hunks to stage
• Browse commits: Scroll through history with diffs
• Interactive rebase: Visual drag-and-drop reordering
• Branch management: Create, delete, merge branches visually
• Conflict resolution: Side-by-side diff views

Why it matters: Git's CLI is powerful but intimidating. lazygit provides the benefits of a GUI while keeping you in the terminal.

Installation:

# macOS
brew install lazygit

# Debian 13 / Ubuntu 25.10 and later
sudo apt install lazygit

# Older Ubuntu/Debian: download the binary from GitHub releases
# (the old lazygit-team PPA you may find in guides is dead)

8. delta - Beautiful Diffs

delta transforms Git diff output from walls of text into readable, syntax-highlighted comparisons. Once configured, all your git diff, git show, and git log -p commands look better.

Features:

• Syntax highlighting: Language-aware coloring
• Line numbers: Both sides visible
• Side-by-side view: Optional horizontal split
• Word-level highlighting: Shows exactly what changed within lines

Installation and setup:

# macOS
brew install git-delta

# Add to ~/.gitconfig
[core]
    pager = delta

[interactive]
    diffFilter = delta --color-only

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

System and Process Management

9. htop / btop - System Monitoring

htop replaces the ancient top command with a beautiful, interactive process viewer. btop takes this further with even richer visualizations.

Improvements over top:

• Mouse support: Click to select, scroll, and sort
• Visual CPU bars: Easy load assessment
• Process tree: See parent-child relationships
• Intuitive controls: F-key shortcuts are visible on screen

btop extras:

• GPU monitoring: See graphics card usage, including Apple Silicon GPUs as of the 2026 releases (note: the prebuilt official binaries ship without GPU support; use your distro's package or Homebrew, or build from source, if you want it)
• Network graphs: Real-time bandwidth visualization
• Disk I/O: Storage activity tracking

Installation:

# macOS
brew install htop btop

# Ubuntu (btop is in the standard repos since 22.04, no snap needed)
sudo apt install htop btop

10. tmux - Terminal Multiplexer

tmux lets you create multiple terminal sessions, split panes, and keep processes running even when you disconnect. Essential for remote development and long-running tasks. And after years of steady-as-she-goes releases, tmux 3.7 (June 2026) shipped a genuinely big feature: floating panes that hover over your layout (prefix + *), plus copy-mode line numbers.

Core concepts:

• Sessions: Independent terminal environments
• Windows: Tabs within a session
• Panes: Split views within a window, now including floating ones

Essential commands:

# Start new session
tmux new -s project

# Detach (keeps running)
Ctrl+b d

# List sessions
tmux ls

# Reattach
tmux attach -t project

# Split horizontally
Ctrl+b %

# Split vertically
Ctrl+b "

Why it matters: SSH into a server, start a long process in tmux, disconnect, and reconnect later. Your process kept running.

AI in the Terminal

11. Claude Code - AI-Powered CLI

Claude Code brings Anthropic's AI directly into your terminal. Unlike web-based chatbots, it runs in your terminal and works directly on your local files: it can read, edit, and create files in your project (the AI model itself runs in Anthropic's cloud).

What it can do:

• Multi-file editing: Make coordinated changes across your codebase
• Git operations: Commits, branches, and diffs with AI assistance
• Explanations: Understand unfamiliar code without leaving terminal
• Refactoring: Describe what you want and watch it happen

Example workflow:

# Start Claude Code in your project
claude

# Then interact naturally
> Add error handling to all API routes
> Explain what the auth middleware does
> Create tests for the user service

Claude Code represents the future of CLI tools: AI that understands your project context and can execute complex tasks autonomously.

Worth knowing: this is now a real three-way race. OpenAI's Codex CLI (open source, written in Rust) and Google's Gemini CLI (currently transitioning to their Antigravity branding) compete directly with Claude Code, and all three ship updates weekly. If you have strong feelings about a particular model provider, the same terminal-agent workflow exists for each.

12. tldr - Practical man Pages

Traditional man pages are comprehensive but overwhelming. tldr provides community-maintained, practical examples for common commands.

Comparison:

# Traditional (pages of documentation)
man tar

# tldr (just what you need)
tldr tar

tldr output shows:

tar

Archiving utility.
Often combined with a compression method, such as gzip or bzip2.

- Create an archive from files:
    tar cf target.tar file1 file2 file3

- Create a gzipped archive:
    tar czf target.tar.gz file1 file2 file3

- Extract an archive in a target directory:
    tar xf source.tar -C directory

Installation:

One 2026 gotcha: the old Homebrew tldr formula was deprecated and disabled in late 2025 because the client behind it went unmaintained. The pages themselves are alive and well; you just need one of the current clients:

# macOS - official Rust client (installs a `tldr` command)
brew install tlrc

# or the popular alternative client
brew install tealdeer

# Update the cache
tldr --update

Setting Up Your Modern Terminal

Here's a complete setup script to install all these tools on macOS:

#!/bin/bash

# Install Homebrew if needed
if ! command -v brew &> /dev/null; then
    /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
fi

# Install all tools (tlrc provides the tldr command)
brew install fzf ripgrep fd bat eza zoxide git-delta htop btop tmux lazygit tlrc

# Set up fzf shell integration (add to .zshrc)
echo 'source <(fzf --zsh)' >> ~/.zshrc

# Initialize zoxide (add to .zshrc)
echo 'eval "$(zoxide init zsh)"' >> ~/.zshrc

# Configure Git to use delta
git config --global core.pager delta
git config --global interactive.diffFilter 'delta --color-only'
git config --global delta.navigate true

echo "Setup complete! Restart your terminal."

Recommended shell aliases (~/.zshrc):

# Modern replacements
alias ls="eza --icons"
alias ll="eza -l --git --icons"
alias la="eza -la --git --icons"
alias tree="eza --tree --icons"
alias cat="bat"
# Think twice about these two: rg and fd do not behave like POSIX grep/find,
# so aliasing them can surprise you when a snippet from the web breaks.
# alias grep="rg"
# alias find="fd"

# Shortcuts
alias lg="lazygit"
alias top="btop"

# fzf enhancements
alias preview="fzf --preview 'bat --color=always {}'"

Three More Worth Watching in 2026

Not in the core 12, but each earned a mention this year:

atuin replaces your shell history with a searchable SQLite database that can sync across machines. It is the natural next step after fzf's Ctrl+R, and its 2026 releases have been experimenting with exposing command history to AI tools.

starship is the cross-shell prompt written in Rust: fast, configured in one TOML file, and works identically in bash, zsh, and fish. It even shipped a Claude Code status line integration this year.

yazi is a terminal file manager with async performance, image previews, and Lua plugins. If you have ever wanted a proper file browser without leaving the terminal, this is the current best-in-class.

Frequently Asked Questions

Are these tools compatible with my existing scripts?

Most modern tools are designed as drop-in replacements. However, scripts that parse exact output formats may need adjustment. Aliases work for interactive use but won't affect scripts unless explicitly changed.

Do I need to replace all my existing tools?

No. Start with one or two tools that address your biggest pain points. fzf and ripgrep deliver the most immediate impact. Add others as you get comfortable.

Will these tools work on Linux servers?

Yes. All tools mentioned work on Linux. Installation methods differ (apt instead of brew), but functionality is identical. Many are also available on Windows via WSL or native ports.

How do I remember all the new commands?

Start small. Install tldr and use it to learn one tool at a time. Aliases help muscle memory: if ls always runs eza, you don't need to remember new commands.

Do modern CLI tools have performance overhead?

Generally no. Tools like ripgrep and fd are actually faster than their classic equivalents. Visualization tools like btop use slightly more resources but the overhead is negligible on modern hardware.

Can I use these with my existing IDE?

Yes. Many IDEs (including VS Code) integrate with tools like ripgrep internally. Your terminal tools and IDE can coexist and complement each other.

Conclusion

The terminal doesn't have to feel stuck in the 1980s. Modern CLI tools bring the polish and intelligence of graphical applications to the command line while preserving the speed and scriptability that make terminals powerful.

Start with these three tools that deliver the biggest immediate impact:

1. fzf - Fuzzy find everything
2. ripgrep - Search code instantly
3. bat - Read files with syntax highlighting

Install them today and you'll wonder how you ever worked without them. The modern terminal isn't just about nostalgia or minimalism. It's genuinely the fastest way to work once you have the right tools.

---

Related Articles

Want more developer productivity tips? Check these out:

• 15 Best VS Code Extensions for Developers in 2026: Essential extensions for your editor
• AI Coding Assistants Compared: Cursor vs Copilot vs Codeium: Find the right AI coding tool
• Screenshot Tools for Developers in 2026: Better tools for documentation and bug reports
• Building Chrome Extensions: A Beginner's Guide: Start building browser tools

---

Found this useful? Share it with a developer still using ancient CLI tools. And for visual content, check out Screenshot Beautifier to make your terminal screenshots look professional.

---

Related from NexaSphere: Building API integrations? API Dash is a REST and GraphQL client that lives inside Chrome DevTools. Free.