If you have been using Linux for a while, you are probably very comfortable with commands like cat, ls, grep, find, and top. These are reliable, battle-tested tools - they have been running Linux systems for decades and they are not going anywhere. But here is the honest truth: they were designed for a time when terminals had no color, no Git, and codebases fit inside a single folder.
In this article, we will demonstrate how to replace 10 classic Linux commands with their modern equivalents. These new-generation tools - many of which are written in Rust or Go - offer syntax highlighting, Git awareness, smarter navigation, and much faster performance, without breaking a single one of your existing shell scripts. Terminal modernization is no longer optional for power users who want real command line efficiency. This guide covers the best Linux CLI tools 2026 has to offer and includes a full alias setup so you can start using them right away.
You can use the same guide on Ubuntu, Debian, Arch Linux, Fedora, and macOS with a few minor modifications.
This tutorial assumes you are comfortable with the Linux terminal and have basic package manager knowledge. All 10 tools in this guide are open-source, actively maintained, and safe to install alongside your existing commands. Your old shell scripts using grep, cat, or ls will continue to work - aliases only affect your interactive terminal sessions.
Examples
Now, let us go through each tool in detail, with install commands, real usage examples, and sample output so you know exactly what to expect before you install anything.
bat — Replaces cat (bat vs cat)
Most of us use cat to quickly look inside a file. The result is a flat wall of plain text - no color, no line numbers, and no indication of what changed recently. bat is a direct, drop-in replacement for cat that is written in Rust. The moment you run it on any source file, the difference is immediately obvious. There is a reason why it is one of the most starred tools on GitHub today.
What makes bat better than cat? It provides syntax highlighting for over 150 languages - Python, JSON, YAML, Bash, C++, and many more. It also shows a Git integration sidebar that marks added, changed, and deleted lines, adds automatic line numbers, and handles smart paging for long files using less. Most importantly, it automatically falls back to plain text output when you pipe it into another command - so none of your existing scripts will break.
$ sudo apt install bat
# Arch Linux
$ pacman -S bat
# macOS (Homebrew)
$ brew install bat
On Ubuntu and Debian, the binary is installed as batcat, not bat. This is because a different package already owns the bat name. Simply add alias bat='batcat' to your ~/.bashrc or ~/.zshrc to fix this.
$ bat script.py
# View without paging — behaves exactly like plain cat
$ bat --paging=never config.yaml
# Show line numbers and colors — useful inside fzf preview
$ bat -n --color=always main.go
│ File: script.py
───────┼────────────────────────────────────
1 │ import os
2 │ import sys
3 + │ print("Hello, World!") # + = new line (git)
───────┴────────────────────────────────────
Add alias cat='bat --paging=never' to your shell config. This replaces cat everywhere in your interactive terminal while keeping the same quick-output behaviour you are used to.
eza — Replaces ls
The classic ls command gives you a basic list of files. No colors for different file types, no Git status, and no built-in tree view. eza is the modern, actively maintained successor to the now-deprecated exa project. It completely changes the experience of browsing directories - once you use it for a few days, going back to plain ls feels like going back to a black-and-white TV.
What makes eza better than ls? You get color-coded output for file types, directories, symlinks, and executables; Git status per file showing new, modified, and ignored files; a built-in --tree view that replaces the separate tree command; file icons with --icons; and automatic directories-first grouping. In my day-to-day work, I use it constantly.
$ sudo apt install eza
# Arch Linux
$ pacman -S eza
# macOS (Homebrew)
$ brew install eza
$ eza --icons --group-directories-first
# Long listing with Git status and icons
$ eza -lah --git --icons
# Tree view, 2 levels deep — replaces the tree command
$ eza --tree --level=2 --icons
drwxr-xr-x - N src/
drwxr-xr-x - - node_modules/
.rw-r--r-- 1.2k M README.md # M = modified
.rw-r--r-- 843 N package.json # N = new file
.rw-r--r-- 4.5k - main.go
Add these three lines to your ~/.bashrc or ~/.zshrc and you will never need plain ls again:
alias ls="eza --icons --group-directories-first"
alias ll="eza -lah --git --icons"
alias lt="eza --tree --level=2 --icons"
ripgrep (rg) — Replaces grep (ripgrep vs grep)
grep is a powerful tool, but it searches absolutely everything by default — your .git folder, node_modules, build artifacts, and binary files — unless you carefully add exclusion flags every single time. ripgrep (command: rg) was built from scratch to solve this problem. It searches your code quickly and intelligently, automatically respecting your project's ignore rules. In every benchmark I have run, it consistently comes out as the fastest code-searching tool available.
$ sudo apt install ripgrep
# Arch Linux
$ pacman -S ripgrep
# macOS (Homebrew)
$ brew install ripgrep
$ rg "function login"
# Case-insensitive search, Python files only
$ rg -i "error" --type py
# List only the filenames that contain a match
$ rg "TODO" -l
src/api.py:87: return function_login(data["user"], data["pass"])
rg uses smart case by default — a lowercase query is case-insensitive, but the moment you add any capital letter it switches to exact matching automatically. No extra flags required.
fd — Replaces find
The find command is notoriously difficult to remember. Want to list all .py files changed in the last three days? You will almost certainly have to look up the flags. fd solves this with a much cleaner, more intuitive design. The rule of thumb I follow is simple: use fd to find files by name and rg to search files by their contents. For a full reference on the classic tool, take a look at our guide on the find command in Linux.
$ sudo apt install fd-find
# Arch Linux
$ pacman -S fd
# macOS (Homebrew)
$ brew install fd
On Ubuntu and Debian, the binary is called fdfind, not fd. Add alias fd='fdfind' to your shell config so you can type fd like on every other platform.
$ fd -e py
# Find any file named "config" anywhere in the tree
$ fd config
# Find .log files changed within the last day
$ fd -e log --changed-within 1d
src/auth.py
tests/test_auth.py
utils/helpers.py
Like rg, fd automatically respects your .gitignore file. It skips node_modules, virtual environments, and build folders with no extra flags — exactly the behaviour you actually want when working inside a project.
zoxide — Replaces cd
How many times a day do you type out long directory paths that you have visited a hundred times before? zoxide keeps track of every directory you visit and builds a personal frequency database. After you have visited a directory once, you can jump back to it from anywhere on your system by typing only part of its name. It feels like a small change, but over a full working day it saves dozens of keystrokes every single hour.
$ sudo apt install zoxide
# Arch Linux
$ pacman -S zoxide
# macOS (Homebrew)
$ brew install zoxide
After installing, you must add this line to your ~/.bashrc or ~/.zshrc and then restart your shell. Without this step, zoxide will not work:
eval "$(zoxide init bash)" — replace bash with zsh or fish as needed.
$ z auth
# Jump to the last visited "back" directory
$ z back
# Interactive selection when multiple directories match
$ zi project
zoxide uses a frecency algorithm that combines how frequently and how recently you have visited a directory, always picking the most relevant match. You can still use z /full/path exactly like regular cd for directories you are visiting for the first time.
btop — Replaces top and htop
The original top command was designed for terminals that had no color support at all. htop was a massive improvement, but it can still feel dated compared to what modern terminals are capable of. btop is a C++ system monitor that gives you a real-time dashboard of your entire machine — CPU, memory, disk, network, and processes — all from the terminal, with a UI that actually looks good.
What makes btop better than top and htop? A beautiful color-coded interface with real-time graphs; full mouse support so you can click and scroll through the process list; GPU monitoring for both NVIDIA and AMD cards; a process tree view; and the ability to sort, filter, and kill processes without memorizing a single flag. You can even switch themes.
$ sudo apt install btop
# Arch Linux
$ pacman -S btop
# macOS (Homebrew)
$ brew install btop
$ btop
Memory [█████░░░░░░░░░░░] 6.2 GB / 16 GB
Network ↑ 1.2 MB/s ↓ 4.8 MB/s
Disk Read: 12 MB/s Write: 3 MB/s
PID USER CPU% MEM% COMMAND
1234 ubuntu 12.4 3.1 node server.js
891 ubuntu 4.2 1.8 python manage.py
Press ? inside btop to open the full help menu. You can click directly on any process to inspect it, or press k to kill a selected process immediately — no flags, no memorization required.
delta — Replaces git diff
If you have ever stared at raw git diff output trying to figure out what changed in a file, you know exactly how frustrating plain red and green text blocks can be. delta works as an automatic pager for Git, silently improving the output of every git diff, git log, git show, and git blame command — without any extra steps on your part. You configure it once and forget about it.
What makes delta better? Full syntax highlighting inside diffs that is language-aware rather than just red or green; a side-by-side view that lets you compare old and new code exactly like a proper code review tool; word-level highlighting that shows you precisely which words changed within a modified line; line numbers for both old and new versions; and shared colour themes with bat so your entire terminal stays consistent.
$ sudo apt install git-delta
# Arch Linux
$ pacman -S git-delta
# macOS (Homebrew)
$ brew install git-delta
$ git config --global core.pager delta
# Enable n/N key navigation between diff sections
$ git config --global delta.navigate true
# Enable side-by-side diff view
$ git config --global delta.side-by-side true
Once you have run these three config commands, just use git diff and git log -p as normal — delta takes over automatically. There are no new commands to learn and nothing else to change.
tldr — Replaces man
Man pages are thorough and complete — but when you just need to remember how to extract a .tar.gz file, reading through 2,000 lines of documentation is overkill. tldr is a community-maintained collection of simplified cheat sheets that shows you only the most common real-world use cases for each command. Think of it this way: use tldr for quick reminders and use man when you need to understand the complete details of a command.
$ sudo apt install tldr
# Arch Linux
$ pacman -S tldr
# macOS (Homebrew)
$ brew install tldr
$ tldr tar
# Get practical examples for rsync
$ tldr rsync
# Get the most common Git usage examples
$ tldr git
Archiving utility.
- Extract an archive:
tar xf archive.tar
- Create an archive from files:
tar cf archive.tar file1 file2
- Extract a .tar.gz archive:
tar xzf archive.tar.gz
Install tealdeer via cargo install tealdeer for a Rust-powered tldr client that caches all pages locally and works completely offline. Run tldr --update once after installation to sync the latest pages.
dust — Replaces du
Have you ever run du -sh * to find out what is eating your disk space, only to get back a list of numbers that are almost impossible to compare at a glance? dust solves this by rendering a visual bar chart next to each directory so you can instantly see which ones are taking up the most space. For a full reference on the classic tool, visit our guide on the du command in Linux.
$ cargo install du-dust
# macOS (Homebrew)
$ brew install dust
# Ubuntu/Debian: download the binary from GitHub releases
# https://github.com/bootandy/dust/releases
$ dust
# Limit the output to 2 directory levels deep
$ dust -d 2
# Check a specific directory — useful for /var/log troubleshooting
$ dust /var/log
890M .git ████ 14%
220M dist █ 4%
45M src ░ 1%
Run dust in any project folder to immediately identify the space culprit. The visual bars make it significantly faster to diagnose disk usage than sorting through a plain du list — especially on production servers where time matters.
fzf — The Fuzzy Finder for Everything
fzf is different from all nine tools above because it does not replace a single specific command. Instead, it adds interactive fuzzy search to almost everything in your terminal — command history, file search, directory navigation, Git branches, process lists, and anything else you can pipe into it. If the other tools on this list are individual upgrades, fzf is the glue that holds your entire modernised terminal workflow together.
What makes fzf so powerful? Ctrl+R now opens your full command history in a searchable, filterable list. Ctrl+T lets you fuzzy-search for files instantly with a bat preview panel on the right. Alt+C lets you jump between directories interactively. And because fzf exposes a scriptable API, you can pipe any list of items into it and get interactive selection back — making it one of the most versatile terminal tools ever written.
$ sudo apt install fzf
# Arch Linux
$ pacman -S fzf
# macOS (Homebrew)
$ brew install fzf
$ export FZF_CTRL_T_OPTS="--preview 'bat -n --color=always {}'"
$ export FZF_ALT_C_OPTS="--preview 'eza --tree --color=always {} | head -200'"
The most powerful combination in this entire guide is: fzf for searching → bat for previewing file content → zoxide for jumping to directories. Together, these three tools eliminate the majority of friction in day-to-day terminal navigation.
How to Get Started With Modern Linux Tools
You do not have to install all ten tools at the same time. Start with two or three that solve problems you already feel every day. That said, if you are ready to fully upgrade your terminal, here are the one-line install commands for each major platform. These open source CLI tools are among the best Linux tools to improve productivity in 2026 — and they are exactly the kind of Linux power user tools that will genuinely transform how you work every day.
# Required aliases on Ubuntu/Debian — add these to ~/.bashrc:
alias bat='batcat'
alias fd='fdfind'
Suggested Shell Aliases
To make these modern tools work seamlessly as drop-in replacements, add the following lines to your ~/.bashrc or ~/.zshrc file and then run source ~/.bashrc to apply. Remember — aliases only apply in interactive terminal sessions, so none of your existing shell scripts will be affected.
alias cat="bat --paging=never"
alias ls="eza --icons --group-directories-first"
alias ll="eza -lah --git --icons"
alias lt="eza --tree --level=2 --icons"
alias grep="rg"
alias find="fd"
alias top="btop"
# Ubuntu/Debian only — fix binary names
alias bat="batcat"
alias fd="fdfind"
# Enable zoxide (smart cd)
eval "$(zoxide init bash)" # change bash → zsh if needed
# fzf power previews
export FZF_CTRL_T_OPTS="--preview 'bat -n --color=always {}'"
export FZF_ALT_C_OPTS="--preview 'eza --tree --color=always {} | head -200'"
Remove the Ubuntu/Debian alias lines (alias bat="batcat" and alias fd="fdfind") if you are on Arch Linux or macOS — on those platforms the binaries are already named correctly and these aliases are not needed.
People Also Ask
Yes, absolutely. All 10 tools install next to your existing commands — they do not touch or replace the originals at the system level. Your shell scripts that use grep, cat, or ls will continue to work exactly as before. If you ever want to remove a tool or an alias, you can do so at any time without affecting your system in any way.
Most of them are available in the package managers of all major Linux distributions — Ubuntu, Debian, Arch, Fedora, and openSUSE. On some distros, you may need to install tools like dust using Cargo (cargo install du-dust). If you are on macOS, Homebrew gives you access to all 10 tools with a single install command.
I recommend starting with bat and eza — they are the easiest to appreciate because the improvement is visual and immediate. Install them, add the aliases, and you will notice the difference within minutes. Once those feel natural, add zoxide for navigation and ripgrep for searching and you will have covered the four most impactful upgrades.
Rust allows developers to write systems-level code that is as fast as C while being much safer with memory management. Tools like bat, eza, ripgrep, fd, zoxide, and dust all benefit from this combination of speed and safety. It is why ripgrep can be 10 to 100 times faster than grep on real codebases without sacrificing reliability.
Only zoxide requires a small initialisation line in your shell config (eval "$(zoxide init bash)"), and in practice this adds only a few milliseconds. All the other tools are simply binary replacements — they have zero effect on shell startup time. fzf can optionally set up key bindings, which is equally fast.
For day-to-day development work, I personally use ripgrep for searching code, fd for finding files, bat for reading files, delta for reviewing Git changes, and fzf for interactive selection. Add zoxide for smart directory navigation and your terminal is fully equipped for modern development work in 2026.
Conclusion
That's it! We have successfully covered 10 modern Linux tools that replace the classic commands you use every day. These are not just cosmetic upgrades — they are genuine productivity improvements backed by faster runtimes, smarter defaults, and better UX. If you are just getting started, install bat, eza, and zoxide first and add the aliases to your shell config. Once those feel natural, layer in ripgrep, fd, and fzf to complete your terminal transformation. The best part is that none of these tools break your existing workflow — your old scripts keep running exactly as before, while your interactive terminal becomes something you actually enjoy using every day.
Thank you for taking the time to read! We hope this article has helped you understand how these modern Linux CLI tools work and how to get started with them. Drop your feedback or questions in the comments below. Feel free to share this article with others if you found it useful.
From your first terminal command to advanced sysadmin skills — every guide here is written in plain English with real examples you can run right now.
