If you spend a lot of time in the Linux terminal, you probably already know the usual commands: ls, grep, cat, top, and ping. They do their jobs and no one questions them. But the open-source community has quietly made a new generation of tools that make those old commands look like they belong in a museum. These are the kinds of useful Linux terminal commands that your coworkers use and that make you wonder, "What is that colored output in your terminal?" This guide talks about 10 of them that have been tested on Ubuntu OS. You can then choose which ones to add to your own workflow.
Every tool on this list is free, open source, and being worked on as of 2026. Some can be installed with just one line of apt, while others need brew or cargo. Once they are installed, you don't need root to use any of them. This list has something for everyone, whether you're a complete beginner who just learned how to navigate directories, a sysadmin who manages dozens of servers, or a DevOps engineer who benchmarks pipelines for fun.
This article focuses on lesser-known productivity tools, not core system commands. If you are still getting comfortable with the fundamentals, our Basic Linux Commands guide and the Linux Quick Start Guide 2026 are the right starting points before diving in here.
Examples
As of 2026, all of the tools in this article are free to use, open source, and regularly updated. You can install most of them using your distribution's package manager (apt), Homebrew (brew), or Rust's package manager (cargo), depending on what you have available. There are no hidden fees or subscriptions.
Pure Joy — Start Here (cbonsai & glow)
Not every tool has to fix a big problem with infrastructure. Making your terminal look alive is sometimes the best way to fall in love with it. These are the two tools you show to a friend who thinks the command line is boring, and they change their mind right away.
cbonsai — Grow an Animated Bonsai Tree in Your Terminal
What it does: cbonsai uses ncurses to draw a procedurally generated ASCII bonsai tree in your terminal. The tree looks a little different every time you run it, but it still has the same calming effect. You can change how fast it grows, add a message at the bottom, turn on bird animations, or use it as a screensaver that keeps playing. It may seem silly, but this is the kind of tool that people share on Reddit, put in their dotfiles, and leave there for years.
Perfect as a terminal screensaver on monitoring stations or shared screens — beats a blank cursor and makes the terminal feel alive.
Example 1: A live animated tree that grows faster:
~/ *
/ \ \
~ ~ ~~~ ~
|
/|\
/ | \
___/__|__\___
The --time flag controls the delay in seconds between each growth step. Lower values grow faster. Try 0.02 for an almost instant tree, or 0.2 for a slow, zen-like experience.
Example 2: The screensaver mode keeps going until you press a key.
press any key to quit screensaver mode
You can install cbonsai on Ubuntu/Debian with sudo apt install cbonsai. On macOS or Linux with Homebrew, use brew install cbonsai. The cbonsai GitHub page also has build instructions for distros where it is not in the default repos.
glow — Read Markdown Files Beautifully Right in the Terminal
What it does: Most developers open a README by either squinting at raw Markdown code in cat or switching to a browser to see it. glow fixes that by showing Markdown — headings, bold text, code blocks, tables, blockquotes — right in your terminal with the right colors and formatting. The Charm team, who also made bubbletea and lipgloss, made glow. It comes with a full TUI browser that lets you browse through whole directories of .md files without using a mouse.
Stop switching to the browser just to read a project README. Render it right where you are working, without leaving the terminal.
Example 1: Show a certain Markdown file:
A short description of what this project does.
## Installation
┌───────────────────────────────────┐
│ $ npm install my-project │
└───────────────────────────────────┘
## Features
• Fast • Lightweight • Cross-platform
Example 2: Open the TUI browser to see all the Markdown files in the current folder:
──────────────────────────────────────
› README.md 2 days ago
CHANGELOG.md 1 week ago
docs/CONTRIBUTING.md 3 weeks ago
↑/↓ navigate enter open q quit
Install glow with brew install glow, or via Go with go install github.com/charmbracelet/glow@latest. Visit the glow GitHub page for the full list of rendering options and themes.
This part is where things go from "fun to show off" to "really making your day better." These three tools help with real problems like forgetting how to use commands, having to read through man pages, and not getting any useful information from a basic ping.
What it does: Rust is used to build navi, and fzf is used to power it. It lets you search for shell command cheatsheets in a fuzzy way. You can get cheatsheets from its big community repository, add your own, or import any GitHub-hosted cheatsheet repo. The real magic is that it lets you fill in the variable arguments before it runs, instead of just showing you the command. You don't have to remember the exact order of the flags anymore.
Forget scrambling through browser tabs to remember a specific ffmpeg or rsync flag combination — navi surfaces it instantly and fills the variables for you.
Example 1: Start the interactive cheatsheet browser:
tar -czf <output_file> <source_dir>
> find files modified in the last N days [find]
find <path> -mtime -<days>
↑/↓ navigate tab fill args enter run ctrl-c exit
Example 2: Use GitHub to add a custom cheatsheet repository:
remote: Enumerating objects: 312, done.
Repository added successfully.
Install navi with brew install navi or cargo install navi. You can also write your own .cheat files and place them in ~/.local/share/navi/cheats/ — they show up automatically in the browser. See the navi GitHub repository for the full cheatsheet syntax.
tldr — Man Pages for People Who Just Want the Command
What it does: The name "tldr" means "Too Long; Didn't Read," and it lives up to that. Instead of giving you a 400-line man page full of legal jargon, it shows you the 4–5 most common real-world examples for each command. The community keeps the pages up to date and very accurate. You won't believe how much you needed tldr after just ten minutes with it. This is the one tool that most people recommend for beginners on Linux, but experienced admins use it every day for commands they don't use as often.
When you just need to remember the tar flag to extract to a specific directory, tldr gives you the answer in two seconds instead of scrolling through a man page for two minutes.
Example 1: Learn how to use the tar command with real-world examples:
Archiving utility.
- Create an archive from files:
tar cf target.tar file1 file2 file3
- Create a gzip-compressed archive:
tar czf target.tar.gz path/to/directory
- Extract a compressed archive into the current directory:
tar xf source.tar.gz
- Extract to a specific directory:
tar xf source.tar.gz --directory=path/to/directory
Example 2: Find examples of rsync (no more searching for the flags every time):
Transfer files either to or from a remote host.
- Transfer a file:
rsync path/to/source path/to/destination
- Sync a local folder to a remote server, deleting removed files:
rsync -avz --delete path/to/local/ user@host:path/to/remote/
- Resume an incomplete transfer:
rsync --partial --progress source destination
First-time users should run tldr --update after install to pull the latest page cache. On Ubuntu, install with sudo apt install tldr. Also available via brew install tldr and npm install -g tldr. The full community page index lives at the tldr-pages GitHub repository.
gping — Real-Time Latency Graph Instead of a Stream of Numbers
What it does: Standard ping prints a new line every second, which is helpful, but you have to keep track of trends in your head. Instead of a wall of numbers, gping shows a live ASCII latency graph that moves in real time. You can see multiple hosts on the same graph at the same time, which makes it very easy to see which connection is getting worse. In addition to ICMP ping, it also has a --cmd mode that measures the latency of any command. This is useful for measuring HTTP response times from the terminal.
When diagnosing a network issue, a visual latency graph across two or three hosts instantly tells you whether the problem is local, the ISP, or the remote server.
Example 1: Watch two hosts at the same time with a live graph:
▁▁▂▂▁▂▁▂▂▁▁▂▁▂▂▁▂▁▁▂▁▁▂▁▁▁▂▂▁▁▂▃▂▁▁▂▁▂▁▁
cloudflare.com ─── 9ms avg
▁▁▁▂▁▁▁▂▁▁▁▁▁▂▁▁▁▁▁▂▁▁▁▁▁▂▁▁▁▁▁▁▁▂▁▁▁▁▁▁
Example 2: Check how long it takes for an HTTP command to respond over time:
▂▂▃▂▂▂▂▃▂▂▃▂▂▂▂▃▂▂▂▃▂▂▂▂▂▂▃▂▂▂▃▂▂▂▂▂▂▃▂▂
Install gping with brew install gping or cargo install gping. Check the gping GitHub page for binary releases if you prefer not to compile from source. Also pair it with your Linux networking commands toolkit for a more complete picture of network diagnostics.
Dashboard & Visibility (wtfutil)
There is a kind of developer who never shuts down the terminal. If that sounds like you, wtfutil is what happens when someone decides that the terminal should also be a full personal information dashboard.
wtfutil — Your Entire Workday Dashboard, Inside the Terminal
What it does: wtfutil, also known as WTF or wtf terminal dashboard, is a terminal dashboard written in Go that can be customized and is made up of different parts. With just one YAML configuration file, you can get calendar events, GitHub activity, Jira tickets, system stats, weather, your public IP, Slack messages, Trello cards, and more than 60 other modules. All of these will be displayed in a grid in one terminal window. Before getting to work, thousands of developers use it as their "mission control" view in the morning.
Instead of switching between your calendar, GitHub, Slack, and a system monitor, you can glance at a single terminal window and see all of it at once.
Example 1: Start wtfutil (it gets its settings from the default path):
│ 09:14:32 │ │ ● 3 open PRs │
│ Wed Mar 25 │ │ ✓ 2 merged yesterday │
└────────────────┘ └────────────────────────────┘
┌─── Weather ────┐ ┌─── System ─────────────────┐
│ ☁ 24°C │ │ CPU 12% MEM 4.1/16 GB │
│ Partly cloudy │ │ Disk 142/500 GB used │
└────────────────┘ └────────────────────────────┘
wtfutil reads its configuration from ~/.config/wtf/config.yml. A single indentation mistake or typo in the YAML file causes the dashboard to exit without any useful error message. Always validate your config changes with wtfutil --help and test with a minimal config first before adding modules one by one. Keep a backup of any config that works.
Example 2: Open the config file to change your dashboard:
grid:
columns: [45, 45]
rows: [13, 13]
mods:
clocks:
enabled: true
position:
top: 0
left: 0
width: 1
height: 1
Install wtfutil with brew install wtfutil or go install github.com/wtfutil/wtf@latest. The full module reference and configuration examples are at the wtfutil GitHub repository. Start with just 2–3 modules and expand from there.
Power User Picks (pv, ncdu, bat)
These three tools are the ones that make you look like you really know what you're doing. They don't have TUI browsers or ASCII art, and they aren't flashy. They just make things that used to be annoying completely painless.
pv — Add a Progress Bar to Any Linux Pipe Operation
What it does: pv is short for Pipe Viewer. It fits right into any pipeline and tells you exactly how much data has gone through, how fast it has gone through, and when the operation will be done. If you've ever run a dd command to write a disk image and then stared at a blinking cursor for ten minutes, wondering if anything was happening, pv is the answer. It works with any command that reads from stdin and writes to stdout.
Eliminates the guesswork from any long-running pipe operation — disk writes, database dumps, file transfers — by giving you a live progress bar and ETA.
Example 1: Create a disk image with a progress bar that updates in real time:
Example 2: Zip up a big folder and keep an eye on the throughput:
Inserting pv into a pipeline that already redirects stdout (e.g. commands using > redirection on the same stream) can produce unexpected results or corrupt output. Always test your pipeline structure on a small, non-critical dataset before running it against production data or real disk devices.
Install on Ubuntu/Debian with sudo apt install pv, or on macOS/Linux with Homebrew via brew install pv. The pv man page documents every flag including --size (when pv cannot auto-detect the data size), --rate-limit, and --bytes. Combine pv with your Linux backup and restore workflows for full visibility on large transfers.
ncdu — Drill Into Your Disk Usage Interactively
What it does: The classic du command shows how much space is used on a disk, but its output is a flat, sorted list that doesn't make it easy to move around or clean up. ncdu (ncurses Disk Usage) shows the same information as an interactive tree that you can move around with the arrow keys. You can go into any folder and see exactly what is taking up space. You can also delete files right from the interface. It is the best tool for cleaning up disks that you can use only in the terminal.
When a disk hits 95% and you need to find what is consuming space quickly, ncdu gets you from zero to "found and deleted the culprit" in under two minutes.
Example 1: Look at your whole root filesystem in real time:
--- / ─────────────────────────────────────── 487.2 GiB used ---
35.2 GiB /var
28.6 GiB /home
18.1 GiB /usr
4.4 GiB /opt
1.2 GiB /tmp
Total disk usage: 87.5 GiB Apparent size: 84.2 GiB
Example 2: Scan a certain folder, like Downloads, to find big files:
8.1 GiB ubuntu-24.04-desktop-amd64.iso
2.3 GiB old-project-backup.tar.gz
934.2 MiB virtual-machine-snapshot.vmdk
421.5 MiB videos/
Install ncdu on Ubuntu/Debian with sudo apt install ncdu, or via Homebrew with brew install ncdu. Inside the interface, press d to delete a highlighted item, i for file details, and ? for the full help screen. For a broader set of disk usage tools, see our guide on basic du command usage and the df command guide.
bat — A cat Replacement With Syntax Highlighting and Git Integration
What it does: bat is a Rust-based cat replacement. It adds line numbers, syntax highlighting for more than 150 languages, and git change indicators (showing which lines were added, changed, or deleted since the last commit) without any setup. Instead of a wall of text, reading config files, checking scripts, or looking at code diffs right in the terminal becomes a lot more fun. In most cases, you can just use it instead of cat.
The moment you open a config.yaml or a Python script with bat instead of cat, you will never go back to cat for reading files.
Example 1: Open a YAML config file with line numbers and syntax highlighting:
1 │ server:
2 │ host: 0.0.0.0
3 + │ port: 9090
4 │ debug: false
5 │ database:
6 │ name: myapp_db
+ indicates lines changed since last git commit
Example 2: Open a Python file in plain mode, with no decorations and just highlighting:
print("Hello from bat — cleaner than cat")
return 0
if __name__ == "__main__":
main()
On Ubuntu and Debian, the bat package installs the binary as batcat (to avoid a naming conflict with an older unrelated package). To use it as bat, add the following alias to your ~/.bashrc or ~/.zshrc:
alias bat='batcat'
Then run source ~/.bashrc to apply it immediately. On RHEL, macOS, and Homebrew installs, the binary is already named bat.
Install with sudo apt install bat, brew install bat, or cargo install bat. You can also set bat as the default pager for man pages by adding export MANPAGER="sh -c 'col -bx | bat -l man -p'" to your shell config. See the bat GitHub page for the full options list. To compare bat with the tool it replaces, see our cat command guide.
Bonus Wildcard (hyperfine)
This last tool is for engineers who want proof, not guesses. Hyperfine settles the debate with statistical rigor if you've ever argued with a coworker about whether grep or ripgrep is faster, or if you've ever wondered if your shell startup time got better after a refactor.
hyperfine — Statistical Benchmarking for Any Shell Command
What it does: hyperfine is a benchmarking tool for the command line that was made with Rust. The built-in time command only runs a command once and gives you one result. Hyperfine, on the other hand, runs commands several times with configurable warmup rounds, throws away outlier results, and reports the median, mean, and standard deviation of the timings. You can run two commands at the same time and see which one is better. This is what proper performance testing looks like in the command line.
Stop guessing whether your "optimised" script is actually faster. hyperfine gives you statistically meaningful timing data in under a minute.
Example 1: Look at a real codebase and compare grep and ripgrep:
Time (mean ± σ): 841.3 ms ± 14.2 ms [User: 796.5 ms, System: 44.7 ms]
Range (min … max): 821.4 ms … 872.6 ms 10 runs
Benchmark 2: rg foo .
Time (mean ± σ): 112.4 ms ± 4.9 ms [User: 187.3 ms, System: 31.2 ms]
Range (min … max): 107.1 ms … 123.0 ms 10 runs
Summary
'rg foo .' ran 7.48 ± 0.34 times faster than 'grep -r foo .'
Example 2: Use warm-up rounds to get cache-warmed timings for the benchmark:
Time (mean ± σ): 2.4 ms ± 0.3 ms [User: 1.1 ms, System: 1.2 ms]
Range (min … max): 2.1 ms … 3.4 ms 245 runs
Install hyperfine with brew install hyperfine or cargo install hyperfine. Use --export-markdown result.md to save benchmark results as a formatted Markdown table — great for sharing in pull requests. The full documentation lives at the hyperfine GitHub page. Also worth pairing with the Linux system monitoring cheat sheet for a complete performance toolkit.
People Also Ask
Yes, for the most part, but be careful. Tools like tldr, bat, pv, and ncdu are well-known and used a lot on production systems. Some, like cbonsai and glow, are developer workstation tools that don't affect the system as a whole. You shouldn't run wtfutil on a server unless you know what API tokens it needs. Always use official package managers like apt, brew, or cargo to install software on production machines instead of random scripts.
Both tools help you find and use commands faster, but they do so in different ways. tldr is a read-only lookup tool. You type tldr tar and it shows you static examples of the most common use cases. navi is interactive; it shows a list of commands that you can search and fills in variable arguments before running them. This makes it more powerful for complicated commands, but it takes more time to set up. Start with tldr if you are new to the terminal. When you're ready, add navi for commands with a lot of arguments that you often change.
For the most part, bat is a drop-in replacement for reading file contents, but there are times when plain cat is still better. When you need to pipe binary data, join files together programmatically, or work inside a script where you need raw output without any decoration, stick with cat. bat is the best way to look at config files, scripts, and code every day. Most people change the name of cat to bat in their shell config, but they still have the original name for scripts.
Yes, a lot more. The built-in time command runs the command once and gives you one measurement. This measurement is heavily affected by system noise, disk caches, and CPU scheduling. Hyperfine runs the command many times (at least 10 times by default), does warmup rounds to get the caches ready, and then calculates the mean, median, and standard deviation. This gives you a statistically meaningful picture of how well the command works. Hyperfine is the best tool for making a real comparison between two approaches.
Depending on the flags used, ncdu and du can show different sizes because they measure different things. By default, du shows how much space is being used on the disk (rounded to the nearest block boundary). Depending on your version and flags, ncdu can show either the apparent size (the actual bytes in the file) or the disk usage. The numbers are also affected by sparse files, hard links, and the sizes of filesystem blocks. Run ncdu --apparent-size or du --apparent-size on the same directory to compare apples to apples if you notice a difference.
This article lists 10 tools that work on macOS. From the beginning, most of them were made to work on more than one platform. Homebrew is the easiest way to install them on macOS because almost every tool on this list has a brew install formula. Tools made with Rust, like bat, gping, navi, and hyperfine, can also be compiled directly on macOS using cargo install. On macOS, you should be aware that some tools may work a little differently or have different keyboard shortcuts in the TUI than they do on Linux.
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.
1 reply on “10 CLI Commands You Have Probably Never Used — But Should”
Just a word about glow. Looks interesting. I did install it. It downloaded so many dependencies, I thought It was Javascript not Go… My alternative:
“`
#! /bin/bash
if [ $# != 1 ]; then
echo “usage: `basename $0` file.md”
exit 1
fi
markdown $1 | lynx -stdin
“`