CLI Tools That Replace GUI Apps

Quick Answer: Modern CLI tools that match or exceed their GUI counterparts — file management to system monitoring. Updated for 2026 with yazi, zoxide, Atuin, and more.

The terminal has had a renaissance. Modern CLI tools are not the cryptic, arcane commands of decades past. They are fast, beautiful (yes, terminal apps can be beautiful), and often more capable than their GUI counterparts. Here are CLI tools that genuinely replace GUI applications. For a wider catalog, see our roundup of the best CLI tools for developers, and pair them with a terminal multiplexer for persistent sessions.

File Management

yazi (Terminal File Manager)

Replaces: Finder, Nautilus, File Explorer

yazi is a blazing-fast terminal file manager written in Rust. It has rapidly become the go-to choice in 2026, surpassing ranger and lf in speed and features.

Why it works: - Async I/O — never blocks on large directories or network drives - Built-in image preview (Kitty, iTerm2, Sixel protocols) - Plugin system with a growing ecosystem - Tabs and split panes - Bulk rename with your editor - Themes and full customization via TOML config

Also consider: lf (simpler, POSIX-friendly) or ranger (Python, most plugins).

fd (Find Files)

Replaces: Find dialog in file managers

fd is a modern replacement for the find command. It is simpler, faster, and has sensible defaults.

# Find all Python files
fd -e py

# Find files containing "config" in the name
fd config

# Find and delete all .DS_Store files
fd -H .DS_Store -x rm

Why it is better: Ignores .gitignore patterns by default, uses regex, colorized output, and is 5-10x faster than find.

ripgrep (rg) — Search File Contents

Replaces: Search in Finder/IDE, grep

ripgrep searches file contents faster than anything else. It respects .gitignore, uses smart case sensitivity, and outputs results in a readable format.

# Search for a function name across a project
rg "fetchUserData"

# Search only TypeScript files
rg "interface User" -t ts

# Search with context (3 lines before and after)
rg "TODO" -C 3

Navigation and Shell

zoxide (Smarter cd)

Replaces: Typing long directory paths, GUI folder navigation

zoxide learns which directories you visit most and lets you jump to them with partial names. Think of it as autojump/z but faster (written in Rust) and smarter.

# Jump to most-visited directory matching "proj"
z proj

# Jump to a directory matching multiple keywords
z dev tools

# Interactive selection with fzf integration
zi proj

Why it is transformative: After a day of use, you never type a full path again. Works with bash, zsh, fish, nushell, and PowerShell.

Atuin (Shell History)

Replaces: Ctrl+R, shell history search

Atuin replaces your shell history with a SQLite database and provides a full-screen TUI for searching through it. Sync history across machines, search by directory, session, or time.

# Interactive history search (replaces Ctrl+R)
atuin search

# Search history for commands run in current directory
atuin search --cwd .

# Stats on your most-used commands
atuin stats

Why it matters: Shell history is one of the most underutilized developer tools. Atuin makes it searchable, syncable, and context-aware. Optional end-to-end encrypted sync between machines.

System Monitoring

btop (System Monitor)

Replaces: Activity Monitor, System Monitor, htop

btop is a gorgeous terminal system monitor. CPU usage, memory, disk I/O, network activity, and process management in a single view with mouse support.

Why it works: - Visual graphs for CPU, memory, network, and disk - Process management (sort, filter, kill) - Mouse support for a GUI-like experience - Themes and customization - Low resource usage itself - GPU monitoring support added in recent versions

Also consider: htop (simpler, available everywhere) or glances (Python, with web UI option).

duf (Disk Usage)

Replaces: Disk Utility's storage overview

duf shows disk usage in a clean, colorized table. Immediately see which drives are full and which have space. Written in Go, it replaces the standard df command with output that is actually readable.

# Show all mounted filesystems
duf

# Show only local disks (exclude network mounts)
duf --only local

# JSON output for scripting
duf --json

Why it is better than df: duf auto-detects your terminal width and adjusts column layout accordingly. It groups filesystems by type (local, network, special), shows usage bars with color-coding, and hides pseudo-filesystems that clutter df output. The JSON output mode makes it scriptable for monitoring dashboards or alerting scripts.

Also consider: dust (du replacement with visual tree output) for analyzing directory sizes rather than filesystem-level usage.

ncdu (Disk Space Analyzer)

Replaces: WinDirStat, Disk Inventory X, Baobab

ncdu scans directories and shows what is consuming space, with an interactive drill-down interface. It builds a cached index of directory sizes, then lets you navigate the tree to find the largest offenders.

# Scan and browse interactively
ncdu /home

# Scan a remote server, analyze locally
ssh server 'ncdu -o-' | ncdu -f-

# Exclude patterns
ncdu --exclude '.git' --exclude 'node_modules' /projects

Why it beats GUI alternatives: ncdu works over SSH, which means you can analyze disk usage on remote servers without installing a GUI tool or transferring data. The remote scan piping trick above is particularly powerful — the server does the scanning, your local machine does the display. Press d to delete files directly from the interface, g to toggle between graph, percentage, and raw size views. ncdu 2.x (rewritten in Zig) scans significantly faster than the original C version.

Text and Data Processing

jq (JSON Processor)

Replaces: JSON viewers, online JSON formatters

jq is a command-line JSON processor. Format, filter, transform, and query JSON data.

# Pretty-print JSON
cat data.json | jq .

# Extract specific fields
cat users.json | jq '.[] | {name, email}'

# Filter by condition
cat orders.json | jq '.[] | select(.total > 100)'

Why it is essential: Every developer deals with JSON. jq makes it manipulable from the command line, in scripts, and in pipelines.

bat (File Viewer)

Replaces: cat, text file viewers

bat is cat with syntax highlighting, line numbers, and Git integration. It shows file contents the way your IDE would display them.

bat src/main.rs

Features: Syntax highlighting for hundreds of languages, line numbers, Git diff markers in the margin, automatic paging for long files.

fzf (Fuzzy Finder)

Replaces: Spotlight, Alfred, file search dialogs

fzf is a general-purpose fuzzy finder. Pipe any list into it and fuzzy-search through it interactively.

# Find and open a file
vim $(fzf)

# Search command history
history | fzf

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

Why it is transformative: Once you start using fzf, you pipe everything through it. Git branches, docker containers, SSH hosts, bookmarks — anything that is a list becomes instantly searchable.

Network Tools

doggo (DNS Client)

Replaces: Online DNS lookup tools

doggo is a modern DNS client written in Go with colorized output and support for DNS-over-HTTPS (DoH) and DNS-over-TLS (DoT). It makes DNS debugging fast and visually clear without needing to decode the wall of text that dig produces.

# Query multiple record types at once
doggo example.com A AAAA MX

# Use DNS-over-HTTPS for encrypted queries
doggo example.com --nameserver https://dns.google/dns-query

# Query a specific nameserver
doggo example.com @8.8.8.8

# JSON output for scripting
doggo example.com --json

Why it beats dig: dig output is dense and designed for DNS administrators. doggo formats results in a clean, colorized table that developers can read at a glance. It also supports modern encrypted DNS protocols out of the box, which matters when debugging DNS resolution issues behind corporate proxies or VPNs. The JSON output mode integrates cleanly with jq for automated checks.

Also consider: dig (standard, available everywhere) or q (minimal, fast DNS client written in Rust).

bandwhich (Bandwidth Monitor)

Replaces: Network monitoring GUIs, Little Snitch's bandwidth view

bandwhich shows which processes are using network bandwidth in real time, broken down by process, connection, and remote address. Written in Rust for minimal overhead.

sudo bandwhich

Why it works: - Three views: by process, by connection, by remote address - Real-time bandwidth graphs per process - Identifies which application is eating your bandwidth (Docker pulls, background updates, rogue processes) - Requires sudo for packet sniffing — shows all traffic, not just what one process reports - Cross-platform (macOS, Linux)

Best for: Debugging slow connections, identifying bandwidth-hungry processes, and understanding what your machine is doing on the network. Pairs well with doggo for DNS diagnostics.

Git

lazygit

Replaces: GitKraken, Sourcetree, Tower (for terminal users)

lazygit is a terminal UI for Git that makes complex Git operations visual and fast. Stage hunks, interactive rebase, cherry-pick, and resolve conflicts — all with keyboard shortcuts.

Why it works: - Visual staging of individual hunks and lines - Interactive rebase with single-keypress actions - Conflict resolution with a visual diff - Runs everywhere (including over SSH) - Custom commands let you extend with shell scripts

See our dedicated article on Git GUI clients for a deeper comparison.

tig

Replaces: git log viewers, GitHub commit browser

tig is a text-mode interface for Git that turns git log into an interactive, navigable viewer. Browse commit history, diffs, blame output, and refs in a scrollable ncurses interface with vim-style keybindings.

tig                   # Browse commit log
tig blame file.txt    # Interactive blame
tig stash             # Browse stash entries
tig refs              # Browse branches and tags
tig -- path/to/file   # History for a specific file

Why it complements lazygit: While lazygit is better for performing Git operations (staging, rebasing, cherry-picking), tig excels at reading Git history. Its blame view is faster to navigate than GitHub's web UI, and the file history view lets you trace how a specific file evolved across commits. tig also works over SSH on remote servers where you cannot run a full TUI like lazygit. Use tig for investigation, lazygit for action.

Productivity

taskwarrior (Task Management)

Replaces: Todoist, Things, Reminders

taskwarrior manages tasks from the command line with powerful filtering, tagging, and reporting.

task add "Fix login bug" project:backend priority:H
task project:backend list
task 1 done

Why it works for developers: Tasks live in plain text, sync with taskserver, and integrate with your terminal workflow. No context switching to a separate app.

calcurse (Calendar)

Replaces: Basic calendar apps

calcurse is a terminal calendar and scheduling application with an ncurses interface. View daily, weekly, and monthly calendars with appointments and todos.

Why it works: - Day, week, and month views with vim-style keybindings - Recurring appointments and todo priorities - Import/export iCalendar (.ics) format for syncing with Google Calendar or Apple Calendar - Configurable notifications and reminders - Data stored in plain text — easy to version control or sync with Git

calcurse          # Launch the TUI
calcurse --import meeting.ics  # Import calendar events
calcurse -Q --format-apt "%S - %m\n"  # Print today's appointments

Best for: Developers who want basic calendar management without leaving the terminal. Not a full replacement for shared team calendars, but excellent for personal scheduling.

pass (Password Manager)

Replaces: 1Password, LastPass (for terminal users)

pass stores passwords in GPG-encrypted files organized in a directory structure. Each password lives in its own .gpg file, and the directory tree acts as the category system. Combined with pass-otp, it handles two-factor authentication codes too.

# Retrieve a password (copies to clipboard for 45s)
pass -c email/gmail

# Generate a 20-character password
pass generate social/twitter 20

# Show OTP code
pass otp show email/gmail

# Sync passwords across machines via Git
pass git push

Why developers choose it: The entire password store is a Git repo of GPG-encrypted files — you control the encryption keys, the storage location, and the sync mechanism. No vendor lock-in, no subscription fees, no cloud trust required. Browser integration is available through browserpass. The trade-off is real: initial GPG setup is non-trivial, and sharing passwords with non-technical team members is impractical. pass is for developers who want full control, not for teams that need shared vaults.

CLI vs GUI: When to Use Which

Getting Started

Do not install everything at once. Start with four high-impact tools:

1. fzf — fuzzy finding changes how you interact with the terminal
2. ripgrep — faster search means you search more, which means you find things faster
3. bat — drop-in cat replacement that makes reading files pleasant
4. zoxide — never type a full path again after a day of use

Install them:

# macOS
brew install fzf ripgrep bat zoxide

# Ubuntu/Debian
sudo apt install fzf ripgrep bat
# zoxide: install via cargo or the install script
curl -sSfL https://raw.githubusercontent.com/ajeetdsouza/zoxide/main/install.sh | sh

Use them for a week. Then add the next tier: yazi, fd, jq, btop, Atuin, and lazygit. Build your terminal toolkit gradually based on what you actually use.

FAQ

What are the best CLI tools to install first?

Start with four high-impact tools: fzf (fuzzy finder for interactive search), ripgrep (fastest file content search), bat (cat replacement with syntax highlighting), and zoxide (smart directory jumping that learns your habits). Install all four with brew install fzf ripgrep bat zoxide on macOS. Use them for a week before adding more tools.

Can CLI tools really replace GUI applications?

For many developer tasks, yes. Modern CLI tools like yazi (file management), lazygit (Git operations), btop (system monitoring), and jq (JSON processing) match or exceed their GUI counterparts in speed, composability, and scriptability. They also work over SSH, have zero startup time, and can be piped together. However, some tasks like image editing or complex GUI workflows are still better served by graphical applications.

What is the best terminal file manager in 2026?

yazi is the best terminal file manager in 2026. Written in Rust, it features async I/O that never blocks on large directories, built-in image preview support (Kitty, iTerm2, Sixel), a plugin system, tabs, split panes, and bulk rename. It has surpassed ranger and lf in speed and features. Install with brew install yazi on macOS.

Is lazygit better than GitKraken or Sourcetree?

lazygit is better for developers comfortable in the terminal. It offers visual hunk staging, interactive rebase, conflict resolution, and cherry-picking — all with keyboard shortcuts and zero startup time. It also works over SSH, which GUI clients cannot do. However, GitKraken and Sourcetree offer richer visualizations and are easier to learn for Git beginners.

How do I get started with CLI tools on macOS?

Install Homebrew first (brew.sh), then run brew install fzf ripgrep bat zoxide to get the four highest-impact CLI tools. Add zoxide to your shell config (echo 'eval "$(zoxide init zsh)"' >> ~/.zshrc), then use z instead of cd to jump between directories. Use them for a week before adding more tools like yazi, fd, btop, and lazygit.

The Bottom Line

Modern CLI tools are not about eschewing GUIs for ideology. They are faster, more composable (pipe them together), scriptable, and work over SSH. A developer who is fluent with these tools navigates codebases, manages systems, and processes data faster than one clicking through GUI applications. For a broader look at tools that boost developer output, see our best developer productivity tools roundup.

The terminal is not a relic. It is a power tool that keeps getting sharper. And if you are spending all day at the keyboard, a good ergonomic keyboard makes the experience significantly more comfortable.