# Your Terminal Deserves Better: 10 Command-Line Tools Developers Are Switching To

The terminal hasn't changed much in decades, and that's both its strength and its trap. `grep`, `find`, `ls`, and `cat` still work. But a new generation of command-line tools, many written in Rust or Go, now does the same jobs faster, with friendlier defaults and output you can actually read.

You don't have to replace your whole workflow. Install one or two of these, use them for a week, and see which ones stick. Here are ten worth your time.

* * *

## 1\. ripgrep (`rg`): search code at absurd speed

**Replaces:** `grep -r`

[ripgrep](https://github.com/BurntSushi/ripgrep) searches a directory recursively, respects your `.gitignore`, skips binary files, and is dramatically faster than classic grep on large codebases. The defaults are what you wanted all along: colored output, line numbers, and no digging through `node_modules`.

```bash
# Find every TODO in Python files
rg "TODO" --type py

# Search with context lines
rg -C 3 "connection refused"

# List only the files that match
rg -l "deprecated"
```

Many editors, including [VS Code](https://code.visualstudio.com), already use ripgrep under the hood for project-wide search.

* * *

## 2\. fd: a `find` you can remember

**Replaces:** `find`

Quick: what's the syntax for finding all Markdown files modified in the last day with `find`? With [fd](https://github.com/sharkdp/fd), you don't need to look it up.

```bash
# Find all Markdown files
fd -e md

# Find files matching a pattern
fd "config"

# Modified within the last day
fd -e md --changed-within 1d

# Run a command on every result
fd -e png -x optipng {}
```

Like ripgrep, it ignores hidden and git-ignored files by default, which is almost always what you want.

* * *

## 3\. bat: `cat` with syntax highlighting

**Replaces:** `cat`

[bat](https://github.com/sharkdp/bat) prints files with syntax highlighting, line numbers, and git change markers in the margin. It also pages long output automatically.

```bash
bat src/main.rs

# Plain output, handy when piping
bat --plain config.yaml
```

> **Note:** On Debian and Ubuntu the binary may be installed as `batcat`. Add `alias bat=batcat` to your shell config.

It also makes a great previewer for fuzzy finders like fzf.

* * *

## 4\. eza: `ls`, but modern

**Replaces:** `ls`

[eza](https://github.com/eza-community/eza) is the actively maintained successor to [exa](https://github.com/ogham/exa). It adds colors, a tree view, git status columns, and optional file-type icons.

```bash
# Long listing with git status
eza -l --git

# Tree view, two levels deep
eza --tree --level=2

# Sort by modification time
eza -l --sort=modified
```

A popular setup is to alias it so your muscle memory does the rest:

```bash
alias ls="eza"
alias ll="eza -l --git"
alias tree="eza --tree"
```

You'll find the full set of aliases in the starter config below.

* * *

## 5\. zoxide: teach `cd` where you actually go

**Replaces:** `cd`

[zoxide](https://github.com/ajeetdsouza/zoxide) remembers the directories you visit and lets you jump to them with just a fragment of the name. After a few days of normal use, you'll rarely type a full path again.

```bash
# Add to your shell config (bash shown)
eval "$(zoxide init bash)"

# Then, from anywhere:
z projects      # jumps to your most-used match for "projects"
z blog api      # matches paths containing both terms
zi              # interactive selection with fzf
```

It ranks directories by a mix of how often and how recently you've used them, so the right one usually wins. The interactive `zi` mode relies on fzf (version 0.51 or newer), so it's worth installing both together.

* * *

## 6\. fzf: fuzzy find anything

**Replaces:** scrolling through long lists by hand

[fzf](https://github.com/junegunn/fzf) is a general-purpose fuzzy finder. Pipe any list into it and type a few letters to narrow it down. Its shell integration is where it shines:

-   **Ctrl+R** fuzzy-searches your command history
    
-   **Ctrl+T** pastes a fuzzy-selected file path onto your command line
    
-   **Alt+C** fuzzy-selects a directory and `cd`s into it
    

```bash
# Enable the shell integration (fzf 0.48 or newer)
eval "$(fzf --bash)"

# Open a file chosen interactively, with a bat preview
vim $(fzf --preview "bat --color=always {}")

# Kill a process interactively
kill -9 $(ps aux | fzf | awk '{print $2}')
```

The preview in that second example is powered by bat. Once you've used fzf, plain Ctrl+R feels like going back to a flip phone. (If you want history that also syncs across machines, take a look at atuin.)

* * *

## 7\. delta: diffs you can actually read

**Replaces:** the default `git diff` pager

[delta](https://github.com/dandavison/delta) gives Git diffs syntax highlighting, side-by-side view, line numbers, and word-level highlighting of what changed within a line. Add this to your `~/.gitconfig`:

```toml
[core]
    pager = delta

[interactive]
    diffFilter = delta --color-only

[delta]
    navigate = true    # use n and N to jump between files
    side-by-side = true

[merge]
    conflictstyle = zdiff3    # needs Git 2.35 or newer
```

Code review in the terminal gets noticeably more pleasant, and it works for `git log -p`, `git show`, and `git blame` too. It also pairs nicely with lazygit, which can be configured to use delta as its diff pager.

* * *

## 8\. lazygit: Git without memorizing flags

**Replaces:** a pile of Git commands (and sometimes a GUI)

[lazygit](https://github.com/jesseduffield/lazygit) is a full-screen terminal UI for [Git](https://git-scm.com). Stage individual lines, amend commits, interactive rebase, resolve conflicts, and browse branches, all with a few keystrokes and with the available shortcuts always shown on screen.

```bash
cd your-repo
lazygit
```

Some things that are genuinely faster here than on the raw command line:

-   Staging only some hunks of a file (press `Enter` on a file, then `Space` on lines)
    
-   Reordering or squashing commits during an interactive rebase
    
-   Cherry-picking commits between branches
    

It doesn't hide Git from you. It just makes the hard parts discoverable. For nicer diffs inside it, set up delta by adding this to lazygit's `config.yml`:

```yaml
git:
  paging:
    colorArg: always
    pager: delta --dark --paging=never
```

* * *

## 9\. btop: a system monitor worth leaving open

**Replaces:** `top` and `htop`

[btop](https://github.com/aristocratos/btop) shows CPU, memory, disks, network, and processes in a single responsive dashboard, with mouse support and graphs that update smoothly. You can sort, filter, and send signals to processes without leaving it.

```bash
btop
```

Useful when something is chewing through your battery or a build is eating all your RAM and you want to see exactly what and why.

* * *

## 10\. atuin: shell history that follows you

**Replaces:** the default shell history

[atuin](https://github.com/atuinsh/atuin) stores your history in a local [SQLite](https://www.sqlite.org) database along with context: the directory, exit code, duration, and host. You get a fast, searchable interface, and optional end-to-end encrypted sync across machines.

```bash
# Enable in your shell config (bash shown)
# bash needs bash-preexec (or ble.sh) loaded first
[[ -f ~/.bash-preexec.sh ]] && source ~/.bash-preexec.sh
eval "$(atuin init bash)"
```

On bash, Atuin depends on either [bash-preexec](https://github.com/rcaloras/bash-preexec) or [ble.sh](https://github.com/akinomyoga/ble.sh) to capture commands, so install one of them and source it before the `atuin init` line. Zsh and fish users can skip that step.

Then press **Ctrl+R** and search by command text, filter by the current directory, or show only commands that succeeded. If you've ever thought "I ran that exact command last month, on a different laptop," this is the fix.

One thing to know: atuin and fzf both bind Ctrl+R, so whichever integration your shell config loads last wins. Put the one you prefer at the end.

* * *

## Honorable mentions

A few more worth a look once you're comfortable:

| Tool | What it does |
| --- | --- |
| starship | A fast, customizable prompt that works in any shell |
| yazi | A quick terminal file manager with previews |
| hyperfine | Benchmark commands with proper statistics |
| dust | A friendlier, visual du for finding what's eating disk space |
| jq | The standard for slicing and transforming JSON on the command line |
| tldr | Short, practical examples instead of dense man pages |

* * *

## Install everything in one go

With [Homebrew](https://brew.sh) (macOS or Linux):

```bash
brew install ripgrep fd bat eza zoxide fzf git-delta lazygit btop atuin
```

On Debian/Ubuntu, many of these are in `apt`, though package names and versions vary (for example `fd-find` and `bat` installing as `fdfind` and `batcat`). Newer tools such as eza, lazygit, and atuin may be missing or outdated in older distro repos, in which case use the project's release binaries or `cargo install`. If you have a Rust toolchain (get one via [rustup](https://rustup.rs)), `cargo install` works for most of them as well.

Once everything is installed, head to the starter config below to wire it all up.

* * *

## A starter config

Drop this into your `~/.bashrc` or `~/.zshrc` (adjust the `init` lines for your shell). Make sure you've run the install command above first.

```bash
# Better defaults
alias ls="eza"
alias ll="eza -l --git"
alias cat="bat --paging=never"
alias grep="rg"

# Shell integrations
eval "$(zoxide init bash)"
eval "$(fzf --bash)"
[[ -f ~/.bash-preexec.sh ]] && source ~/.bash-preexec.sh   # bash only, needed by atuin
eval "$(atuin init bash)"
```

> **Tip:** Aliasing `grep` to `rg` is convenient for interactive use, but their flags aren't identical. Keep scripts calling the real `grep` explicitly, or use `command grep` when you need the original.

Because atuin is initialized last here, it takes over Ctrl+R from fzf, while fzf's Ctrl+T and Alt+C keep working.

* * *

## Final thoughts

None of these tools is magic on its own. The value comes from the small frictions they remove: a search that returns instantly, a diff you can parse at a glance, a directory you reach in three keystrokes. Multiply that by the hundreds of times a day you use a terminal, and it adds up.

Pick two from this list, install them today, and give them a week. Chances are you'll be adding the rest on your own.

_What's in your terminal toolkit? Share your favorites, especially the ones that didn't make this list._

---

*Published via [ZyVOP](https://zyvop.com/your-terminal-deserves-better-10-command-line-tools-developers-are-switching-to-ijfpa?utm_source=hashnode&utm_medium=crosspost&utm_campaign=syndication) — Write once in Markdown, auto-backup to GitHub, and syndicate to Dev.to, Medium & Hashnode in 1 click.*
