Supercharging Your Terminal

Install seven terminal tools on macOS, Linux and Windows, then see how each works: zoxide, fzf, ripgrep, tldr, atuin, lazygit and jq, with GIFs of them in use.

7 min read
11 questions
+65 XP
6 Oct 2026

Write-up

Go deeper

These seven command-line tools make the terminal faster to use. Each one handles a single job and works on its own, so install the ones you want on macOS, Linux or Windows.

Tool	You type	What it does
zoxide	`z`	Jumps to a folder from part of its name
fzf	`fzf`	Filters any list as you type
ripgrep	`rg`	Searches inside files
tldr	`tldr`	Shows short, practical help
atuin	`Ctrl-R`	Searches your command history
lazygit	`lazygit`	Runs Git from a terminal UI
jq	`jq`	Pulls fields out of JSON

Install them

Each system has one package manager that has all seven tools. After installing, zoxide, fzf and atuin also need a line or two in your shell's config file, the file your shell reads when it starts. The other four work as soon as they are installed.

macOS

Install them with Homebrew (check with brew --version; if it's missing, install it from the Homebrew website first):

brew install zoxide fzf ripgrep tlrc atuin lazygit jq

macOS uses zsh, so add these lines to the end of ~/.zshrc:

source <(fzf --zsh)
eval "$(atuin init zsh)"
eval "$(zoxide init zsh)"

Linux

Homebrew works on Linux too, and it has newer versions than most distributions' own package managers:

brew install zoxide fzf ripgrep tlrc atuin lazygit jq

Most Linux systems use bash, so add these lines to the end of ~/.bashrc. If your shell is zsh (check with echo $SHELL), use the macOS lines instead.

eval "$(fzf --bash)"
eval "$(atuin init bash)"
eval "$(zoxide init bash)"

You can use apt, dnf or pacman instead, but check the version you get: fzf's --bash and --zsh options need fzf 0.48 or later.

Windows

Install them with winget, which comes with Windows 10 and 11, in PowerShell:

winget install -e --id ajeetdsouza.zoxide
winget install -e --id junegunn.fzf
winget install -e --id BurntSushi.ripgrep.MSVC
winget install -e --id tldr-pages.tlrc
winget install -e --id Atuinsh.Atuin
winget install -e --id JesseDuffield.lazygit
winget install -e --id jqlang.jq

fzf's key bindings in PowerShell come from a module, and your profile (PowerShell's config file) can only run once scripts are allowed. Run these once, then open the profile:

Install-Module PSFzf -Scope CurrentUser
Set-ExecutionPolicy -Scope CurrentUser RemoteSigned
if (!(Test-Path $PROFILE)) {
  New-Item -Path $PROFILE -ItemType File -Force
}
notepad $PROFILE

Add these lines to the end of it:

Import-Module PSFzf
Set-PsFzfOption -PSReadlineChordProvider 'Ctrl+t'
atuin init powershell | Out-String | Invoke-Expression
Invoke-Expression (& { (zoxide init powershell | Out-String) })

If you work in WSL, follow the Linux instructions inside it instead.

On every system

Keep the lines in the order shown. zoxide asks to be last, and fzf and atuin both want Ctrl-R, so atuin goes after fzf to get it. Then open a new terminal window: a shell only reads its config file when it starts, and on Windows a new window is also what finds the newly installed commands.

zoxide: jump to folders

cd needs the path to a folder. zoxide remembers every folder you visit and scores it by how often and how recently you went there. z plus part of a name takes you to the best match, wherever you are:

Typing z tuna in the home folder jumps straight to ~/code/tuna-shop/fish/tuna.

z tuna       # the best match for 'tuna'
z shop tuna  # 'shop', then 'tuna', in that order
z -          # back to the last folder
zi tuna      # pick from every match (uses fzf)

zoxide only knows folders you have visited, so a new folder needs one cd before z can find it. cd keeps working as before alongside it.

fzf: pick from any list

fzf is a fuzzy finder. It reads a list of lines, shows them, and filters the list as you type. 'Fuzzy' means the letters you type have to appear in order but not side by side, so tna matches tuna.test.ts. On its own, fzf lists the files below the current folder, and Enter prints the one you pick:

fzf lists 1,204 files; typing tna narrows them to 102, and Enter prints fish/tuna/tuna.test.ts.

Because it reads any list, fzf works with other commands. Pipe in Git branches, running processes or the lines of a log, and it prints the one you choose for the next command to use.

With the shell lines added, Ctrl-T pastes a file you pick into the command you are typing. In zsh and bash, Alt-C also changes into a folder you pick.

ripgrep: search inside files

fzf finds files by name. ripgrep, run as rg, finds them by what is inside. It searches the current folder and everything below it, and prints each match with its file and line number:

rg "TODO: feed cat" finds the comment on line 42 of src/cat/feeder.ts.

It is fast on big projects because it searches files in parallel and skips three kinds of file by default: anything your .gitignore lists, hidden files and binary files. That keeps folders like node_modules and .git out of your results, and also explains most 'missing' matches. rg -uu turns the skipping off.

rg "TODO"           # every match
rg -i "todo"        # ignore case
rg -t py "TODO"     # only Python files
rg -F "a.b("        # plain text, not a regex

tldr: short, practical help

A man page lists every flag a command has, which is a lot to read when you only want the common case. tldr shows a handful of examples of a command's most common uses, each with a one-line description:

man tar fills the screen with every flag; tldr tar then shows a short list of common tar commands.

The pages come from the community tldr-pages project and cover Linux, macOS and Windows commands, such as tldr tar, tldr git commit or tldr winget. Windows has no man command, so tldr fills that gap there. The official client is installed as tlrc, you run it as tldr, and it keeps a copy of the pages on your machine: refresh it with tldr --update.

atuin: search your history

Your shell's history is a plain list of commands. atuin keeps it in a database instead and records, for each command, the folder it ran in, whether it worked (its exit code), how long it took and which machine ran it. Run atuin import auto once to bring in the history you already have.

Ctrl-R, and the up arrow, open a full-screen search. Pressing Ctrl-R again inside it switches between every command, this session, this machine and this folder. Inspecting a command shows everything atuin kept about it:

Ctrl-R opens atuin's history list; inspecting the ffmpeg command shows exit 0, took 4s, the ~/videos folder and the machine kitty@other-laptop.

Syncing between machines is optional and end-to-end encrypted, so one search can cover your laptop and your desktop, even on different systems. Without it, your history stays on your machine. To keep the up arrow for plain history, add --disable-up-arrow to atuin's line in your config file.

lazygit: Git in a terminal UI

lazygit shows a repository in panels: files, branches, commits and stashes, with the diff of whatever is selected. Run lazygit inside any Git repository, and each key you press runs a Git command:

Space stages or unstages the selected file.
c commits what is staged, after asking for a message.
P pushes and p pulls.
? lists every key for the panel you are in, and q quits.

Here Space stages a changed file and c commits it with a message:

In lazygit, Space stages tins.ts, c opens the commit box, a message is typed, and the files panel ends up empty.

lazygit only runs ordinary Git commands, so it is as safe as Git. It also shows each command as it runs, which teaches you the Git behind each key.

jq: read JSON

APIs answer in JSON, often on one long line. jq takes a filter and prints the part of the JSON it selects, indented and coloured. Here an API's orders come back as one wall of text, and one filter keeps only the tuna:

curl -s localhost:3000/orders prints one long line of JSON; piping it to jq -c '.[] | select(.fish=="tuna")' prints only the 3 tuna orders.

Filters read like a path through the data:

. is the whole input, and .name is one field.
.[] is every item in an array.
| passes each result to the next filter, as in the shell.
-r prints strings without their quotes, for output that feeds another command.

jq reads a file (jq '.name' data.json) or whatever is piped into it. In PowerShell 7.3 and later, filters work as written. The older Windows PowerShell 5.1 strips double quotes inside them, so write \"tuna\" there, and use curl.exe rather than curl.

Common mistakes

A config change does nothing: the shell reads the file only when it starts. Open a new terminal window.
'Command not found' on Windows straight after installing: open a new PowerShell window.
PowerShell says running scripts is disabled: run the Set-ExecutionPolicy line from the Windows install.
Ctrl-R opens the wrong search: move atuin's line below fzf's.
z can't find a folder: zoxide hasn't seen it yet, so cd into it once.

These tools are for typing at the terminal yourself. Scripts and CI jobs should keep using cd, grep, find and plain git, because the next machine may not have them installed.

Key takeaways

Homebrew installs all seven on macOS and Linux, and winget does on Windows.
zoxide, fzf and atuin also need lines in your shell's config file, with atuin after fzf.
zoxide and fzf get you to a folder or file in a few keystrokes, and ripgrep searches inside files.
tldr gives the common examples, and atuin makes your history searchable by folder and result.
lazygit runs Git from single keys, and jq pulls fields out of JSON.

Code

See it in code

Install and set up all seven on macOS or Linux

Shell

Installs every tool with one Homebrew command, then gives the three lines to paste into ~/.zshrc (zsh, the macOS default) or ~/.bashrc (bash, most Linux systems), in the order that gives atuin Ctrl-R. The loop prints 'missing' for any tool that didn't install. The comments list each tool's GitHub page.

# 1. Install all seven with Homebrew
brew install zoxide fzf ripgrep tlrc \
  atuin lazygit jq

# 2. Paste three lines at the END of your
#    config file, in this order.
# zsh, the macOS default (~/.zshrc):
source <(fzf --zsh)
eval "$(atuin init zsh)"
eval "$(zoxide init zsh)"

# bash, most Linux systems (~/.bashrc):
eval "$(fzf --bash)"
eval "$(atuin init bash)"
eval "$(zoxide init bash)"

# 3. Open a new terminal, then check
for t in zoxide fzf rg tldr atuin lazygit jq
do
  command -v "$t" >/dev/null || echo "missing: $t"
done

# Each tool's GitHub page:
# zoxide   github.com/ajeetdsouza/zoxide
# fzf      github.com/junegunn/fzf
# ripgrep  github.com/BurntSushi/ripgrep
# tldr     github.com/tldr-pages/tlrc
# atuin    github.com/atuinsh/atuin
# lazygit  github.com/jesseduffield/lazygit
# jq       github.com/jqlang/jq

Install and set up all seven on Windows

Shell

PowerShell only. Installs every tool with winget, adds the PSFzf module for fzf's key bindings, lets your profile run, and opens $PROFILE for the four setup lines. After opening a new window, the loop prints 'missing' for any tool PowerShell can't find.

# Run in PowerShell.
# 1. Install all seven with winget
$tools = 'ajeetdsouza.zoxide', 'junegunn.fzf',
  'BurntSushi.ripgrep.MSVC', 'tldr-pages.tlrc',
  'Atuinsh.Atuin', 'JesseDuffield.lazygit',
  'jqlang.jq'
foreach ($t in $tools) { winget install -e --id $t }

# 2. fzf's key bindings come from a module
Install-Module PSFzf -Scope CurrentUser

# 3. Let your profile run, then open it
Set-ExecutionPolicy -Scope CurrentUser RemoteSigned
if (!(Test-Path $PROFILE)) {
  New-Item -Path $PROFILE -ItemType File -Force
}
notepad $PROFILE

# 4. Paste these at the END of $PROFILE:
Import-Module PSFzf
Set-PsFzfOption -PSReadlineChordProvider 'Ctrl+t'
atuin init powershell | Out-String | Invoke-Expression
Invoke-Expression (& { (zoxide init powershell | Out-String) })

# 5. Open a new PowerShell window, then check
$cmds = 'zoxide', 'fzf', 'rg', 'tldr', 'atuin',
  'lazygit', 'jq'
foreach ($c in $cmds) {
  if (!(Get-Command $c -ErrorAction SilentlyContinue)) {
    "missing: $c"
  }
}

Jump between folders with zoxide

Shell

zoxide learns a folder the first time you cd into it. After that, z with part of the name jumps there from anywhere, zi lets you pick between matches, and zoxide query shows the scores. Swap in your own folders; the commands are the same in zsh, bash and PowerShell.

# Visit folders once with cd, so zoxide learns them
cd ~/projects/my-app
cd src
cd ~

# From anywhere, jump back with part of its name
z my-app

# Two words: a match for 'app', then 'src'
z app src

# Several matches? Pick one from a list
zi app

# Go back to the folder you were just in
z -

# See what zoxide has learnt, top scores first
zoxide query --list --score | head
# PowerShell: ... | Select-Object -First 10

Pick files, branches and processes with fzf

Shell

fzf filters whatever list it is given. These open a file in your editor, preview files while you choose, switch to a Git branch you pick, and pick a process: first in zsh and bash, then the PowerShell versions.

# zsh and bash
# Pick a file and open it in your editor
vim "$(fzf)"

# Preview each file's first lines as you choose
fzf --preview 'head -40 {}'

# Switch Git branch by picking from a list
branch=$(git branch --format='%(refname:short)' | fzf) \
  && git switch "$branch"

# Pick a process from the list
ps -ef | fzf

# PowerShell on Windows
notepad (fzf)
fzf --preview 'type {}'
$b = git branch --format='%(refname:short)' | fzf
if ($b) { git switch $b }
Get-Process | ForEach-Object Name | fzf

Search a codebase with ripgrep

Shell

Common rg searches: ignore case, one file type, plain text instead of a regex, context lines, skipping a folder and including hidden files. The last lines hand rg's matching files to fzf and open the one you pick.

# These work the same in zsh, bash and PowerShell.

# Every match, with file name and line number
rg "TODO"

# Ignore case, and only TypeScript files
rg -i "todo" -t ts

# Plain text, not a regex: ( and . are literal
rg -F 'user.name('

# Two lines of context around each match
rg -C 2 "throw new"

# Skip a folder
rg "TODO" -g '!tests/'

# Search hidden files too, like .env
rg --hidden "API_KEY"

# Pick a matching file with fzf and open it
vim "$(rg -l "TODO" | fzf)"     # zsh, bash
notepad (rg -l "TODO" | fzf)    # PowerShell

Look up commands with tldr

Shell

Shows the short pages for tar and git commit, finds pages about compressing files, reads a Windows or Linux page from any system and refreshes the pages stored on your machine.

# These work the same on every system.

# The common uses of a command
tldr tar

# Subcommands work too
tldr git commit

# Find pages about a topic
tldr --search compress

# Another system's page
tldr --platform windows winget
tldr --platform linux apt

# Refresh the pages stored on your machine
tldr --update

Import, search and sync history with atuin

Shell

Imports your existing shell history, then searches it by exit code and folder, shows your most used commands, and sets up optional encrypted sync. Replace YOUR_NAME and YOUR_EMAIL with your own; atuin asks for a password.

# These work the same on every system.

# Bring in the history your shell already has
atuin import auto

# Search: press Ctrl-R (or the up arrow), type,
# and press Ctrl-R again to switch the filter:
# global, host, session, directory

# The same search from the command line:
# git commands that worked, in this folder
atuin search --exit 0 --cwd . git

# Your most used commands
atuin stats

# Optional: sync between machines, even a Mac
# and a Windows PC
atuin register -u YOUR_NAME -e YOUR_EMAIL
atuin sync

Open lazygit and learn its first keys

Shell

Opens lazygit in the current repository or another one (swap in your own paths), adds a short lg alias for zsh, bash or PowerShell (run only the line for your shell), and lists the keys for staging, committing, pushing and getting help.

# Open lazygit in the repo you are in
cd ~/projects/my-app
lazygit

# Or open another repo, on its commit log
lazygit -p ~/projects/other-app log

# A short alias saves typing it each time
echo "alias lg='lazygit'" >> ~/.zshrc   # zsh
echo "alias lg='lazygit'" >> ~/.bashrc  # bash
Add-Content $PROFILE 'Set-Alias lg lazygit'  # PowerShell

# Keys inside lazygit, on every system:
#   Space    stage or unstage the file
#   a        stage every file
#   c        commit (type a message, Enter)
#   P / p    push / pull
#   ?        every key for this panel
#   q        quit

Read and filter JSON with jq

Shell

Runs jq on a small orders.json: pretty-printing, pulling out one field without quotes, keeping only the tuna orders, adding up prices, and reading a field from a public GitHub API response. The last lines are for the older Windows PowerShell 5.1.

# orders.json:
# [{"cat":"Mochi","fish":"tuna","price":4.5},
#  {"cat":"Biscuit","fish":"salmon","price":6},
#  {"cat":"Mochi","fish":"tuna","price":4.5},
#  {"cat":"Pepper","fish":"cod","price":3}]

# Pretty-print it
jq '.' orders.json

# One field from each item, without quotes
jq -r '.[].cat' orders.json
# Mochi Biscuit Mochi Pepper (one per line)

# Keep only the tuna orders
jq -c '.[] | select(.fish == "tuna")' orders.json

# Add up every price
jq 'map(.price) | add' orders.json
# 18

# Straight from an API
curl -s https://api.github.com/repos/jqlang/jq \
  | jq '{stars: .stargazers_count}'

# Windows PowerShell 5.1 strips inner double
# quotes, so escape them, and use curl.exe:
jq -c '.[] | select(.fish == \"tuna\")' orders.json
curl.exe -s https://api.github.com/repos/jqlang/jq |
  jq '.stargazers_count'

What should we explain next?

Got a concept you want explained with cats? Tell us.