Post cover image
Image by Author

June 22, 2026

These 10 Linux Tools Changed Everything

Living in the terminal has been fun lately

By Sahib Dhanjal

9 min read

My articles are free to read for everyone. If you don't have a Medium subscription, read this article by following this link.

With tools like Claude Code and other AI-powered terminal applications taking off, I've found myself spending an astronomical amount of time inside the terminal lately. The command line has become my primary workspace.

The problem? While the traditional Unix toolset is legendary, many of the classic commands are starting to show their age.

Don't get me wrong — cat, grep, find, and cd have powered the world's infrastructure for decades. They're battle-tested, reliable, and aren't going anywhere. However, using some of these tools today can feel a bit like coding in Vim when you know modern IDEs like Cursor exist. Sure, it's a badge of honor, but it definitely slows you down 🤷‍♂️

A new generation of command-line tools is changing that — modern utilities are bringing fuzzy search, syntax highlighting, interactive dashboards, intelligent navigation, and better developer ergonomics directly into your shell. They preserve everything we love about Linux while adding quality-of-life upgrades drastically improving the user experience.

If you're like me and spend most of your days connected to a server, and want to make your command line experience more zenful, here are some tools which have had the biggest impact on my workflow.

1. fzf — The Ultimate Fuzzy Finder

None

If I had to wipe my machine and start from scratch tomorrow, fzf would probably be one of the first tools I'd reinstall. At its core, it's a fuzzy finder. Give it a list of things and it lets you search through them interactively, be it files, directories, git branches, docker containers, processes, shell history—if it can be represented as text, it can probably be searched with fzf.

The biggest game changer for me was command history. Most of us rely on Ctrl + R to search previous commands, but once you've integrated fzf, that shortcut becomes addictive. Need that Docker command you ran three weeks ago? Hit Ctrl + R, type a few scattered characters, and it's usually there before you've finished typing. It basically removes the need to remember exact commands and file names, making your terminal feel almost telepathic. It's one of those tools that quietly rewires your muscle memory.

After a few weeks of using it, going back to a terminal without fzf feels broken. While it's very powerful by itself, it truly shines when integrated with other commands, for example:

# Interactive password selection from the linux password manager
pass show $(pass ls | fzf)

# Or with shell integration, just press TAB:
pass show   # Opens fzf interface

# Search command history (Ctrl+R with fzf integration)
history | fzf

Install fzf — https://github.com/junegunn/fzf

2. tmux — Full-Featured Terminal Multiplexer

None

I ignored tmux for years. Every time someone recommended it, I'd look at the keybindings, get overwhelmed, and go back to opening more terminal tabs. It all worked fine, until I started spending more time on remote machines and started losing my sessions when running multi-day simulations.

tmux is basically a terminal multiplexer, meaning it lets you spawn multiple pseudo terminals, and split them into windows, panes or even sessions, each of which you can navigate between. The primary reason I use it though is because it refuses to die.

Long-running jobs, development environments, database migrations, training scripts — everything keeps running even if your SSH connection drops, your laptop sleeps, or your Wi-Fi decides today's the day. As long as the server is up, you're good. You can disconnect, go for a stroll, reconnect from another laptop even, and everything is exactly where you left it.

Key features are that it's app agnostic (works on any terminal emulator), has a CLI interface, and creates persistent sessions. Example usage for session persistence would be:

# SSH into server and start tmux
ssh user@server
tmux

# Start a long-running task
htop

# Detach from session (Ctrl+b, then d)
# Even if SSH connection drops, you can reconnect:
ssh user@server
# Reattach to existing session (add -t <session> if you have multiple sessions)
tmux attach

Personally, I don't like the default keybindings so have my own set which you can find here. It adds mouse interactivity as well as copy/paste from clipboard making it way easier to use. Simply copy and paste this into your linux server at ~/.config/tmux/tmux.conf . If you want to stick to the defaults, check out their Man Page.

Install tmux — https://github.com/tmux/tmux/wiki/installing

3. mosh — The Mobile Shell

None

If you've ever SSH'd into a remote machine over hotel Wi-Fi, airport Wi-Fi, or a flaky hotspot, you've probably experienced this:

You close your laptop. Walk to another room. Open it back up. And your SSH session is dead.

That's exactly what mosh (short for mobile shell) solves. Unlike SSH, which is tightly coupled to a specific network connection, mosh was designed for unreliable and flaky networks. You can switch between Wi-Fi and cellular, roam between networks, put your laptop to sleep, or briefly lose connectivity entirely without losing your terminal session.

The secret is that mosh uses a UDP-based synchronization protocol that keeps the client and server in sync independently of the underlying connection. It also uses predictive local echo, which makes typing feel noticeably more responsive—especially when you're connected to servers on the other side of the world. The best part is that you don't need to change your workflow. SSH still handles authentication, so your existing keys and login methods continue to work exactly as before.

# instead of
ssh user@server
# you use
mosh user@server

Combined with tmux, it's probably the most reliable remote-development setup I've ever used.

Install mosh — https://mosh.org/#getting

4. zoxide — Supercharged Directory Navigation

None

I never realized how much time I spent typing cd until I stopped doing it. Like most developers, I have far too many project directories, navigating between which started feeling like work.

That's where zoxide comes in. It is essentially a smarter cd command that learns where you spend your time and builds a ranking system based on frequency and recency making navigating your file system from the terminal extremely efficient. After using it for a few days, you stop thinking about paths entirely.

# instead of the verbose
cd ./../../../../../code/development/projects/frontend/customer/portal
# we simply use `z portal`
# that's way less typing to achieve the same thing.
# plus it doesn't care about your current directory.
z portal

It's a tiny improvement on paper. In practice, it's one less thing your brain has to think about hundreds of times per week. Best part is it has a direct integration with fzf making it even faster and more convenient. Check out their blog on how to integrate both of them!

zoxide + fzf: The Ultimate Guide to Interactive Navigation - zoxide Blog | Tips and Best Practices Learn how to combine zoxide with fzf for a powerful interactive directory selection workflow. Master fuzzy searching…

Install zoxide — https://zoxide.org/

5. bat — Cat Clone with Wings

None

Let's clear some things first, I don't dislike cat. But opening a large source file with it feels a little like reading code through a keyhole. bat takes the familiar simplicity of cat and adds all the things you'd expect in 2026 — syntax highlighting, line numbers, git integration, automatic paging for longer files, etc.

The first time you open a shell script, YAML file, or Python module with bat, it becomes obvious why so many developers adopt it immediately. It's nothing revolutionary, just a nicer default experience adding to your quality-of-life. And those small improvements add up when you spend all day staring at text.

Install bat — https://github.com/sharkdp/bat#installation

6. btop —A Zenful Top Experience

None

I thought htop was already pretty good, but then I tried btop. The difference isn't functionality — it's polish. btop gives you a real-time view of CPU usage, memory consumption, disk activity, network traffic, and running processes in a way that's actually enjoyable to look at. The graphs are clean, the interface is responsive and finding resource-hungry processes takes seconds. And when something inevitably starts consuming 100% CPU for no apparent reason, it's immediately obvious. This is one of those tools that's difficult to appreciate from screenshots. All this, plus it is extremely fast and doesn't hog resources as it is written in highly-optimized C++.

Install btop — https://github.com/aristocratos/btop#installation

7. ripgrep — Blazing Fast Text Search

ripgrep (invoked as rg) has become insanely useful in the age of AI coding agents. More often than not, I'm jumping into codebases I've never seen before — either because an AI generated part of it, I'm reviewing someone else's work, or I'm trying to understand a service I haven't touched in months.It is essentially a modern replacement for grep.

If you're unfamiliar with grep, it's the command-line tool most developers use to search for text inside files. The problem is that it happily crawls through unnecessary files (__pycache__, node_modules, etc) choking your system in the process.

rg, on the other hand, is dramatically faster, as it respects your .gitignore files by default, searches recursively out of the box, and produces colorized output that's much easier to read. For example, if I'm trying to find every reference to an authorization check:

# grep command to search for "isAdmin" in the current project
# usually slow and includes node_modules
grep -r isAdmin .
# equivalent ripgrep command
rg isAdmin

The speed improvement and intelligent filtering make ripgrep very effective when working with larger projects. Trust me on this, the first time you use ripgrep on a large repository, you'll probably wonder why you waited so long to switch.

Install ripgrep — https://github.com/burntsushi/ripgrep#installation

8. fd — Modern File Finding

If ripgrep is a better grep, then fd is a better find. And honestly, that's all most developers need to know. I still don't remember the syntax for find. Every time I need something beyond the basics, I end up opening a cheat sheet or searching Stack Overflow or asking my AI agent to do the same.

A quick example for this:

# Lets say I want to list all the files with the word "util" in their filename
find . -type f -name "*util*"
# with fd, it is as simple as
fd util

Like ripgrep, fd comes with a bunch of sensible defaults. It's faster, respects .gitignore, performs case-insensitive searches by default, and supports both regex and glob patterns. If you want more advanced filtering, use it as:

# Find files containing "test" but exclude those with "route"
fd test --exclude "*route*"

As simple as it is, it's not a revolutionary tool, but an essential tool, providing a more seamless developer experience. What I appreciate most about fd is that it lets me focus on what I'm searching for rather than remembering command syntax.

Install fd — https://github.com/sharkdp/fd

9. delta — Syntax Highlighting

None

File diffs (using diff) and git diffs (git diff) became a lot less painful for me after I installed delta. The standard output for either diff or git diff works, but is a lot more cumbersome. You'll see how surprisingly tiring reviewing changes becomes once a pull request grows beyond a handful of files.

delta makes diffs easier on the eyes by adding syntax highlighting, line numbers, side-by-side views, and character-level highlighting. It's one of those tools that feels like it should have shipped with Git years ago. Checkout the README.md on the repository to see the full feature set.

Install delta — https://github.com/dandavison/delta

10. lazydocker — TUI for Docker Management

None

If you work with Docker every day, you've probably developed a muscle memory that looks something like this:

docker ps
docker logs <container>
docker stats
docker inspect <container>

lazydocker wraps all of that functionality into a single terminal interface. You get a live dashboard showing containers, images, volumes, logs, resource usage, and container state without constantly jumping between commands. You have the flexibility to check logs by selecting a container, restart one by pressing a key, even check resource usage for the container as it's already baked in to the dashboard. The experience feels very similar to what btop did for system monitoring. Once you start using it regularly, going back to manually stitching together Docker commands feels unnecessarily tedious.

ctop is a complementary tool to lazydocker but I find lazydocker is sufficient. I found this setup guide really helpful when I was picking it up. Hopefully you do too!

How to Set Up lazydocker for Docker Management on Ubuntu Install lazydocker on Ubuntu to get a terminal-based UI for managing Docker containers, images, volumes, and logs…

Install lazydocker — https://github.com/jesseduffield/lazydocker

Final Thoughts

One of my favorite things about the terminal is that it rewards small improvements. You don't need a complete workflow overhaul and you definitely don't need 50 different plugins and 100 different aliases. Sometimes a single tool that saves you five seconds dozens of times per day is enough to noticeably improve how you work.

These 10 CLI tools have fundamentally transformed how I work in the terminal over the past couple of years. My suggestions —

If you're just getting started locally, simply give fzf, zoxide, ripgrep and fd a try. If you're constantly connected to a remote server, you should NOT live without mosh , tmux and fzf. Once you're comfortable using at least some of these tools, you might want to give others a shot as you naturally run into the problems they solve.

If you think I'm missing something here, drop a comment and definitely let me know!

Enjoyed this post? Help me share this knowledge with others by clapping, and sharing your thoughts. You can follow me on Medium / LinkedIn for more insights on C++, Python, Robotics and Trading algorithms.