14 Best Terminal and CLI Tools for Developers in 2026

Most developers spend hours every week in the terminal. Yet most are still using tools from the 1970s.

The modern CLI ecosystem has quietly exploded with tools that are faster, smarter, and easier to use than the Unix utilities everyone still defaults to. These aren't just novelties. They're tools that save real time on tasks you do dozens of times per day.

I've tested hundreds of CLI tools over the years. These 14 are the ones I actually use. The ones that permanently changed how I work. Some replace slow defaults with blazing-fast alternatives. Others add features that should've existed decades ago. And a few do things you didn't know were possible from the command line.

1. ripgrep (rg)

Ripgrep is a line-oriented search tool that recursively searches your current directory for a regex pattern. It's basically grep, but orders of magnitude faster.

I switched to ripgrep three years ago and never looked back. It respects your .gitignore by default, which means it doesn't waste time searching node_modules or build directories. It's written in Rust, and the performance difference on large codebases is staggering. Searching through a multi-million-line codebase that took 30 seconds with grep takes 2 seconds with ripgrep.

Best for: Anyone who searches code. If you use grep or ack, stop. Use this instead.

Link: github.com/BurntSushi/ripgrep

Pro tip: Alias it to rg and add --hidden to search hidden files by default.

2. fzf

Fzf is a command-line fuzzy finder. You pipe any list of items to it, and it gives you an interactive filter to narrow down the results in real time.

This one's a game changer for working with Git, searching command history, or finding files. Instead of typing exact paths or remembering commit hashes, you just type a few characters and fzf narrows down the options instantly. I use it dozens of times a day without thinking about it. It integrates with your shell history (Ctrl+R becomes actually useful), file searches, and basically anything that returns a list.

Best for: Developers who want to stop typing full paths and exact commands.

Link: github.com/junegunn/fzf

Pro tip: Bind it to Ctrl+T for fuzzy file finding and Ctrl+R for command history. Your muscle memory will thank you.

3. bat

Bat is cat with syntax highlighting, Git integration, and automatic paging. It shows line numbers, highlights changes, and renders code with proper color schemes.

Honestly, I was skeptical when I first tried this. "Syntax highlighting in the terminal? That's overkill." Then I used it for a week and realized how much faster I could scan files. When you're reading code in the terminal, the syntax highlighting isn't just nice to have. It makes patterns jump out instantly. Plus, it automatically pages long files so you don't accidentally dump thousands of lines into your scrollback.

Best for: Anyone who uses cat to read files. Replace it with this.

Link: github.com/sharkdp/bat

Pro tip: Alias cat to bat --paging=never for short files, or use bat directly for longer ones.

4. exa (or eza)

Exa is a modern replacement for ls. It has better defaults, Git integration, tree views, and color schemes that actually make sense.

The original exa is no longer maintained, so the community forked it to eza. Both work fine, but eza is actively developed. The main reason I switched? Git status indicators. When you list files in a Git repo, eza shows you which files are modified, staged, or ignored right in the output. No more running git status to see what's changed. It also handles icons if your terminal supports them, making it easier to scan file types at a glance.

Best for: Developers who work with Git repos and want richer file listings.

Link: github.com/eza-community/eza

Pro tip: Alias ls to eza --git --icons and ll to eza -l --git --icons.

5. fd

Fd is a fast, user-friendly alternative to find. It has sane defaults, intuitive syntax, and respects .gitignore automatically.

The find command is powerful, but the syntax is a nightmare. Half the time I have to Google the exact flags to exclude directories or filter by file extension. Fd just works. Want to find all TypeScript files? fd -e ts. Want to search case-insensitively? That's the default. It's fast, it ignores files you don't care about, and the syntax is what find should have been from the start.

Best for: Anyone who's ever rage-quit trying to remember find syntax.

Link: github.com/sharkdp/fd

Pro tip: Combine it with fzf for interactive file finding: fd | fzf.

6. zoxide

Zoxide is a smarter cd. It tracks which directories you visit and lets you jump to them with partial matches.

Instead of typing cd ~/projects/work/api-gateway, you just type z api and you're there. It learns your patterns and ranks directories by frequency and recency. After a day of use, you'll forget how you ever navigated without it. I used to have aliases for all my common directories. Now I just type a few letters and zoxide figures out where I want to go.

Best for: Developers who navigate deep directory trees constantly.

Link: github.com/ajeetdsouza/zoxide

Pro tip: Alias cd to z so you can't accidentally go back to the old way.

7. tldr

Tldr provides simplified, example-focused help pages for command-line tools. It's like man pages, but actually useful.

Man pages are comprehensive. They're also dense, overwhelming, and written for people who already know what they're doing. Tldr gives you practical examples instead. Need to use tar? Instead of scrolling through 500 lines of documentation, tldr shows you the five most common use cases with actual commands you can copy. It's community-maintained and covers thousands of commands. I still use man pages for deep dives, but tldr is my first stop for 90% of lookups.

Best for: Anyone who's sick of Googling basic command syntax.

Link: github.com/tldr-pages/tldr

Pro tip: Install the Rust client (tealdeer) for faster lookups: tldr --update caches everything locally.

8. htop

Htop is an interactive process viewer. It's top, but with colors, sorting, filtering, and a UI that doesn't feel like it's from 1984.

This one's been around for years, but a lot of developers still default to top. Htop shows CPU and memory usage per core, lets you kill processes with F9, and makes it trivial to find which process is eating your RAM. It's not new or trendy, but if you haven't switched yet, you're wasting time.

Best for: Monitoring system resources without leaving the terminal.

Link: htop.dev

Pro tip: Press F6 to sort by different columns (CPU, MEM, TIME). Press / to search for processes.

9. jq

Jq is a lightweight command-line JSON processor. It lets you slice, filter, map, and transform JSON with a concise query language.

If you work with APIs, you've needed this and maybe didn't know it existed. Instead of piping API responses to a file and opening them in an editor, you can parse, filter, and extract exactly what you need right in the terminal. Want the first five user IDs from an API response? curl api.example.com/users | jq '.[:5] | .[].id'. The syntax has a learning curve, but once you get the basics, it's indispensable.

Best for: Backend developers and anyone who debugs API responses.

Link: jqlang.github.io/jq

Pro tip: Use jq -C | less -R to colorize and page large JSON outputs.

10. lazygit

Lazygit is a terminal UI for Git. It gives you an interactive interface for staging, committing, branching, rebasing, and resolving conflicts without memorizing a hundred flags.

I'm good with Git from the command line. I know the commands. But lazygit makes the common workflows so much faster that I reach for it by default now. Staging individual hunks? Just press space. Viewing file diffs? It's right there. Rebasing interactively? You get a visual list you can reorder with arrow keys. It's not a crutch. It's an interface that respects your time.

Best for: Developers who use Git every day and want to stop Googling rebase flags.

Link: github.com/jesseduffield/lazygit

Pro tip: Bind it to an alias like lg. You'll use it constantly.

11. delta

Delta is a syntax-highlighting pager for Git diffs. It makes Git diff output readable with side-by-side views, better colors, and syntax highlighting.

The default Git diff is functional, but it's hard to scan. Delta turns it into something you can actually read quickly. It highlights word-level changes instead of just line-level, which makes it way easier to spot what actually changed in a line. It also integrates with lazygit and other Git tools, so once you install it, everything that shows diffs gets better.

Best for: Developers who review code or diffs in the terminal.

Link: github.com/dandavison/delta

Pro tip: Add it to your .gitconfig as the default pager: git config --global core.pager delta.

12. ncdu

Ncdu is a disk usage analyzer with an ncurses interface. It scans directories and shows you what's eating your disk space, with the ability to drill down and delete files interactively.

When your disk fills up, du and df tell you almost nothing useful. Ncdu scans your filesystem, shows you the biggest directories at the top, and lets you navigate into them to find what's hogging space. I've used it to find forgotten Docker images, old log files, and node_modules folders I didn't know existed. It's saved me hours of hunting through random directories.

Best for: Developers who need to free up disk space without guessing.

Link: dev.yorhel.nl/ncdu

Pro tip: Run ncdu / with sudo to scan your entire system. Press 'd' to delete files directly from the interface.

13. httpie

HTTPie is a user-friendly HTTP client. It's like curl, but with syntax that makes sense and output that's actually readable.

Curl is powerful, but the syntax is arcane and the output is ugly. HTTPie uses intuitive syntax (http POST api.example.com name=value), automatically formats JSON, and colorizes output. For quick API testing, it's way faster than curl and way lighter than Postman. I still use curl for scripts, but for interactive debugging, HTTPie wins.

Best for: Developers who test APIs from the command line.

Link: httpie.io

Pro tip: Use --session to save cookies and headers between requests when testing authenticated APIs.

14. tmux (or Zellij)

Tmux is a terminal multiplexer. It lets you run multiple terminal sessions inside one window, split panes, detach and reattach sessions, and keep processes running after you disconnect.

If you work on remote servers or run long-running processes, you need this. It's the difference between losing all your work when your SSH connection drops and just reconnecting to exactly where you left off. Tmux has been the standard forever, but Zellij is a newer alternative with better defaults and less configuration needed. Either one is fine. The important part is using a multiplexer at all. Once you do, you'll never go back.

Best for: Developers who work on remote servers or need persistent terminal sessions.

Link: github.com/tmux/tmux (tmux) or zellij.dev (Zellij)

Pro tip: Learn the basics: Ctrl+B % for vertical split, Ctrl+B " for horizontal split, Ctrl+B D to detach. That's 90% of what you need.

The Bottom Line

You don't need all 14 of these. Start with the ones that solve problems you actually have. If you spend a lot of time searching code, get ripgrep. If you're constantly navigating directories, get zoxide. If you work with Git every day, get lazygit and delta.

The cumulative effect of these tools isn't just about saving seconds. It's about reducing friction. When your tools are fast and intuitive, you think less about the mechanics of working and more about solving the actual problem. That's the difference between grinding through tasks and getting into flow.

Don't install them all at once. Pick two or three that address your biggest pain points. Use them for a week. Then come back and grab a couple more. Within a month, your terminal workflow will feel completely different.