--- title: "Best CLI Tools Every Developer Should Know in 2026 | Dev Toolkit" url: https://tools.aileapers.com/articles/16-best-cli-tools-2026.html description: "The essential CLI tools that make terminal workflows faster and more productive. Modern replacements for ls, cat, find, grep, and more -- with install guides and real usage examples." updated: 2026-07-23 --- [DT Dev Toolkit](https://tools.aileapers.com/index.html) # Best CLI Tools Every Developer Should Know in 2026 Last updated: 2026-05-28 13 min read Reviewed by the Dev Toolkit editorial team [How we review →](https://tools.aileapers.com/about.html) **Disclosure:** This page contains affiliate links. We may earn a commission at no extra cost to you. Our recommendations are based on manufacturer specs, expert reviews, and verified owner feedback. 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 | Classic Tool | Modern Replacement | Language | Key Improvement | | --- | --- | --- | --- | | `ls` | `eza` (formerly `exa`) | Rust | Icons, git status, tree view | | `cat` | `bat` | Rust | Syntax highlighting, line numbers | | `find` | `fd` | Rust | Intuitive syntax, 5x faster | | `grep` | `ripgrep` (`rg`) | Rust | 10x faster, respects .gitignore | | `top` | `btop` / `htop` | C++ / C | Visual resource monitoring | | `du` | `dust` | Rust | Visual disk usage | | `diff` | `delta` | Rust | Syntax-highlighted git diffs | | `cd` | `zoxide` | Rust | Frecency-based smart navigation | | `curl` | `httpie` / `xh` | Python / Rust | Human-readable HTTP requests | | `man` | `tldr` | Various | Practical examples, not manuals | ## 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: - **ripgrep** – searching code is a daily activity, and rg is dramatically faster - **fzf** – fuzzy finding transforms shell history and file navigation - **bat** – reading files with syntax highlighting is immediately useful - **zoxide** – smart directory navigation saves time from the first day - **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.* ## Related Reviews - [Best CLI Tools for Developers 2026](https://tools.aileapers.com/articles/80-best-cli-tools-developers-2026.html) - [CLI Tools That Replace GUI Apps in 2026](https://tools.aileapers.com/articles/13-cli-tools-replace-gui-apps.html) - [Best CI/CD Tools 2026 Compared: GitHub Actions vs GitLab CI vs Jenkins](https://tools.aileapers.com/articles/best-ci-cd-tools-2026.html)