Linux Terminal Tools That Will Make You Faster

Your terminal is the fastest tool on your computer — but only if you know which commands to reach for. The default Unix tools (grep, find, cat, sort) have served us well for decades, but modern alternatives can dramatically speed up your workflow.

Here are five command-line tools that will make you noticeably faster at searching, processing, and navigating data in the terminal.

1. ripgrep (rg) — The Grep You’ll Actually Enjoy Using

ripgrep is a line-oriented search tool that recursively searches your current directory for a regex pattern. It’s built on top of Rust’s regex engine, which means it’s fast — often 5–10× faster than classic grep -r on large codebases.

What makes ripgrep special isn’t just speed, though. It respects your .gitignore automatically, so it never wastes time searching through node_modules, .git, or build artifacts. It also skips hidden files and binary files by default — exactly what you want 90% of the time.

Basic usage

rg "search term"                     # Search current dir (respects .gitignore)
rg -i "case insensitive"             # Case-insensitive search
rg "TODO|FIXME" --type py            # Search only Python files
rg -l "function"                     # List only filenames with matches
rg "pattern" ~/projects/             # Search a specific directory

The -l flag is a personal favourite — it lists matching filenames without the context lines, perfect for finding which files reference a particular function or import.

Why switch from grep?

• Automatically respects .gitignore
• Colourised output by default
• Handles large directories instantly
• Filters binary files automatically
• Search compressed files with -z

2. fd — A Modern Find

If you’ve ever wrestled with find‘s arcane syntax (find . -type f -name '*.txt' -exec ...), fd is a breath of fresh air. It’s another Rust-based tool that follows the same philosophy as ripgrep: sensible defaults, fast execution, and a simple interface.

Basic usage

fd "pattern"                         # Find files matching pattern
fd -e py                             # Find all Python files
fd -x wc -l                          # Run wc -l on each result
fd -E node_modules "config"          # Exclude a directory
fd --type d "src"                    # Find directories only

The -x flag is incredibly useful — it runs an arbitrary command on each match. Need to count lines in every Python file? fd -e py -x wc -l. It’s like find ... -exec but with syntax that doesn’t require a PhD in quoting rules.

Why switch from find?

• Intuitive -e for extensions instead of -name '*.ext'
• Respects .gitignore automatically
• Colourised output with icons
• Smart case: lowercase patterns are case-insensitive, uppercase are case-sensitive
• Ignores hidden directories by default

3. bat — A Cat With Wings

bat is a cat clone with syntax highlighting and Git integration. That’s the elevator pitch, but the actual experience is transformative: instead of dumping raw text to your terminal, bat shows coloured output with line numbers, Git modification markers, and automatic paging for long files.

Basic usage

bat file.py                          # Show with syntax highlighting + line numbers
bat README.md                        # Renders Markdown headings nicely
bat -n main.rs                       # Show line numbers even when disabled
bat -A script.sh                     # Show all characters (tabs, spaces, newlines)
bat --paging=never config.yaml       # Disable pager for short files

One of bat’s smartest features is theme-aware output: it respects your terminal’s colour scheme and picks a compatible syntax theme automatically. And when you pipe bat’s output to another command (bat file | grep pattern), it falls back to plain cat-mode so the piping stays clean.

Why switch from cat?

• Syntax highlighting for 200+ languages
• Line numbers and Git change markers
• Automatic paging with less for long files
• Theme-aware colour schemes
• Non-printable character display with -A

4. jq — JSON on the Command Line

APIs return JSON. Config files use JSON. Logs are increasingly JSON-formatted. jq is a lightweight, portable command-line JSON processor that lets you slice, filter, map, and transform JSON data with a concise (and surprisingly powerful) query language.

Basic usage

jq '.' data.json                     # Pretty-print JSON
jq '.name' data.json                 # Extract a field
jq '.users[] | {name, email}'        # Map over arrays and reshape
jq '. | length' data.json            # Count items
jq 'group_by(.category) | length'    # Group and count
curl api.example.com | jq '.data'    # Pipe from API calls

jq shines when you’re working with REST APIs. Instead of staring at a wall of minified JSON, pipe it through jq '.' and get beautifully formatted output with syntax highlighting (when combined with bat: curl ... | jq '.' | bat -l json).

Why use jq?

• Indispensable for API debugging and log analysis
• Portable — a single static binary
• Powerful query language supports filtering, mapping, and aggregation
• Works great in pipes with curl, bat, and other tools
• JSON output is always valid — no syntax errors from hand-written parsing

5. grep (classic) — Still Essential

I can’t write about terminal tools and skip the original. Good old grep is installed on every Unix-like system and remains the most universal tool in this list. While ripgrep is faster for big codebases, classic grep is always there — on servers, containers, embedded systems, and any environment where you can’t install new tools.

Essential flags you should know

grep -r "pattern" .                  # Recursive search
grep -i "pattern" file               # Case-insensitive
grep -v "pattern" file               # Invert match (show lines NOT matching)
grep -c "pattern" file               # Count matches
grep -l "pattern" *.txt              # List only filenames
grep -A5 -B5 "error" log.txt         # Show 5 lines of context before/after
grep -E "foo|bar" file               # Extended regex (alternation)

The -A (after) and -B (before) context flags are especially valuable for reading log files — they show you what happened around an error, not just the error line itself.

Combining Them for a Powerful Workflow

The real magic happens when you combine these tools. Here are a few practical workflows:

# Find all TODO comments in Python files, grouped by filename
rg "TODO|FIXME" --type py -l | xargs bat -l py

# Search your entire project for a config value
rg "api_key" --type yaml -n | bat

# Explore a new codebase
fd -e py -x wc -l | sort -rn | head -10   # What are the biggest files?
rg "def " --type py -c | sort -t: -k2 -rn | head -10  # Which file has the most functions?

# Parse API JSON and extract key fields
curl -s "https://api.github.com/repos/BurntSushi/ripgrep" | jq '{name, stars: .stargazers_count, language}'

Installation

All five tools are available in major package managers:

# Debian/Ubuntu
sudo apt install ripgrep fd-find bat jq

# Fedora
sudo dnf install ripgrep fd-find bat jq

# macOS (Homebrew)
brew install ripgrep fd bat jq

# Arch Linux
sudo pacman -S ripgrep fd bat jq

# Windows (Scoop)
scoop install ripgrep fd bat jq

Note: on Debian/Ubuntu, the fd command is installed as fdfind due to a naming conflict. You can alias it: alias fd=fdfind.

Why This Matters

These five tools — ripgrep, fd, bat, jq, and classic grep — form the foundation of a modern terminal workflow. They reduce friction, eliminate context-switching, and let you stay in the command line for tasks that would otherwise require opening a GUI editor or writing a Python script.

The best part? They all work together. ripgrep finds the line, bat displays it beautifully, jq makes JSON readable, and grep is always there as the universal fallback. Spend an afternoon learning them, and you’ll get that time back in the first week.

What are your go-to terminal tools? Browse the full directory for more open-source software to supercharge your workflow.