No tools found
Adjust your search query. Try searching for 'grep', 'rust', or 'process'.
The Modern CLI
Renaissance
The 1970s POSIX standard was built for teletypewriters. The modern developer ecosystem has abandoned aging C utilities for blazing-fast, concurrent, and beautifully designed tools written in Rust, Go, and Zig. Welcome to Unix Philosophy 2.0.
1. Files & Storage
The foundation of the shell is navigation and file manipulation. Traditional POSIX commands (ls, cd, rm) lack context awareness. Modern tools understand Git status, support Nerd Font icons, use advanced algorithms to predict where you want to go, and utilize multithreading for disk IO.
eza / lsd Replaces `ls`
Rust
Modern replacements for ls. They scale colors based on file age and size, automatically integrate with Git to show modified/untracked files, and output beautifully structured trees.
exa is unmaintained and effectively dead. eza is the active community fork. If you use Homebrew or Apt, ensure you install eza. Also, to see the Nerd Font icons, you must be using a terminal patched with a Nerd Font.
zoxide Replaces `cd`
Rust
A smarter cd command. It tracks the directories you visit using a "frecency" (frequency + recency) algorithm. Instead of typing cd src/components/ui/buttons, you just type z buttons.
If you have multiple folders named "project", type zi project. It integrates seamlessly with fzf to drop you into an interactive fuzzy-finder menu to pick the exact path.
Terminal File Managers (Replaces `ranger`, `tree`)
yazi
An insanely fast async file manager. It renders images, PDFs, and video thumbnails directly in the terminal using Kitty/Sixel graphics protocols.
broot
Replaces `tree`. In massive directories, `tree` scrolls off-screen. Broot creates a compact, interactive tree that fits perfectly on your display.
xplr
A hackable, keyboard-driven file explorer heavily inspired by Vim. It provides a minimal UI and relies on Lua scripts for deep customization.
rip (rm-improved) Replaces `rm`
Typing rm -rf is dangerous. Once it's gone, it's gone. rip replaces rm by moving files to your operating system's native Trash/Recycle Bin, allowing you to seamlessly restore them if you make a mistake.
2. Text & Search
The heart of Unix is text processing. Single-threaded `grep`, `find`, and `sed` struggle against modern NVMe SSDs and multi-core processors. These rewrites use extreme concurrency, memory mapping, and SIMD instructions to search gigabytes of code in milliseconds.
Benchmark: Searching the Linux Kernel Source (Lower is better)
rg (ripgrep)
Replaces grep. It is widely considered the fastest text-search tool in the world. It automatically respects your .gitignore rules, skips hidden files, and skips binary files by default.
Built by Andrew Gallant using Rust's highly optimized regex engine and SIMD parallelization.
fd
Replaces find. The syntax of traditional `find` is notoriously hostile. With `fd`, the defaults are sensible: it runs in parallel, ignores `.git`, and uses colored output automatically.
fzf (Go) and sk (Rust) are interactive Unix filters. They fundamentally change how you interact with the terminal. By piping any list into them, you get an interactive, real-time searchable menu.
bat (Replaces cat)
cat is for concatenating files. bat is a viewer. It brings IDE-level syntax highlighting to the terminal, shows Git diff markers in the gutter, and automatically pipes to a pager (like less) if the file is long.
Gotcha: If you pipe bat into another command (e.g. bat file.json | jq), the ANSI color codes will break the parser. Use bat --plain or just use cat for scripting.
sd & sad (Replaces sed)
sed requires escaping every slash (the "toothpick syndrome": s/\/usr\/bin/\/usr\/local\/bin/g). sd uses standard regex. sad goes a step further, providing an interactive terminal UI showing a diff of the text you are about to modify *before* you commit to it.
ast-grep (sg) (The Evolution of grep)
Regex is fundamentally broken for code because it doesn't understand context, nested brackets, or line breaks. ast-grep parses your code into an Abstract Syntax Tree (AST) (using Tree-sitter) and allows you to search structurally.
3. Data (JSON & CSV)
DevOps engineers spend half their lives parsing JSON outputs from AWS/Kubernetes CLI tools and fighting with comma-separated logs. These tools turn the terminal into a data warehouse.
jaq / gojq Replaces `jq`
jq is the absolute standard for JSON parsing, but it is written in aging C and can be slow on gigabyte-sized payloads. jaq (Rust) and gojq (Go) are drop-in replacements that execute the exact same syntax but run significantly faster.
jless
A dedicated, interactive Vim-style viewer explicitly designed for exploring huge JSON files. You can expand/collapse objects interactively with your keyboard instead of trying to write complex jq filters blindly.
qsv (The Ultimate CSV Tool)
Forked from the legendary xsv, qsv allows you to slice, search, join, and perform mathematical aggregations on massive CSV datasets at memory speeds. You can literally execute SQL joins on two CSV files directly in your terminal.
4. Git & Diffing
delta
A syntax-highlighting pager for git, diff, and grep output. Configure your .gitconfig to use delta as the core pager, and your git diff output will instantly look like GitHub's split-view syntax-highlighted UI.
difftastic
Traditional diffs compare text line-by-line. If you wrap a block of code in an if statement, standard git diff shows the whole block as modified because the indentation changed. difftastic compares the AST (syntax). It understands that the code logic didn't change, only the whitespace did.
Terminal Git UIs (gitui vs lazygit)
Memorizing obscure Git flags for staging specific hunks or interactive rebasing is tedious. Terminal UIs solve this.
5. System & Processes
Monitoring processes and system usage. Modern tools utilize Braille characters to draw high-resolution charts directly in the terminal, completely outclassing ancient ncurses tools.
bottom (btm)
Replaces top and htop. A highly customizable cross-platform graphical process monitor. It draws real-time line charts for CPU usage per core, memory, network bandwidth, and disk I/O.
Note: zenith is a similar alternative that retains historical data (zoomable charts) so you can see what spiked your CPU 5 minutes ago.
procs
Replaces ps. It offers colored output, a tree view of parent/child processes, and incredible Docker integration (it shows the container name next to the underlying host process).
dust & ncdu v2
Replaces du. dust (Rust) visualizes disk usage using an intuitive ASCII tree chart. ncdu v2 (rewritten from C to Zig) allows you to interactively navigate and delete massive hierarchies with zero memory overhead.
hyperfine
Replaces time. A world-class command-line benchmarking tool. It runs a command multiple times, performs statistical analysis, handles cache-clearing before runs, and exports the data to Markdown tables.
6. Network Protocols
| Tool | Replaces | Why it's better |
|---|---|---|
| xh / hurl | curl | xh provides friendly syntax for APIs and auto-formats JSON. hurl lets you write HTTP requests in plain text files for easy API testing and CI integration. |
| gping | ping | Instead of a scrolling wall of text, it draws a live, continuous line graph in your terminal showing latency spikes over time. |
| doggo (Go) | dig | A modern DNS client that outputs clean JSON/tables and natively supports DNS-over-HTTPS (DoH) and DNS-over-TLS. |
| trippy | traceroute / mtr | Combines ping and traceroute into a beautiful interactive dashboard to trace network pathways and detect packet loss. |
| bandwhich | iftop | Shows exactly which *processes* on your computer are hogging your network bandwidth, mapped by name and PID. |
Honorable Mention: miniserve (Rust)
Replaces the classic python -m http.server. It is insanely fast, supports TLS, basic auth, and crucially, allows you to upload files to your machine via a generated web UI.
miniserve --upload-files ./shared_folder
7. Shells, Envs & Multiplexers
Re-imagining the environment where all these commands execute.
nushell
A complete paradigm shift. Instead of piping raw text between commands, `nushell` pipes structured data (like SQL tables or JSON objects). This completely eliminates the need for complex `awk`, `sed`, and `cut` commands.
zellij
Replaces tmux. A modern multiplexer with built-in UI layout panes. You don't need a massive config file to split a window. It also supports WASM plugins.
atuin / mcfly
Replaces Ctrl+R shell history. Atuin syncs your history across all machines via an encrypted SQLite DB. McFly uses a local neural network to predict the command you want based on the current directory.
mise
Replaces asdf and nvm. A blazing fast polyglot version manager written in Rust. Switches Node/Python/Ruby versions instantly with zero shell lag.
8. Agentic Pipelines & AI Integration
The command line is the ultimate interface for Large Language Models. Instead of copying and pasting code from ChatGPT web interfaces, modern CLI tools pipe Unix streams directly into LLMs for autonomous summarization, error debugging, and code generation.
mods (Go)
Created by Charmbracelet. Pipe standard output directly into an LLM, utilizing Markdown formatting and terminal colors natively.
fabric (Go)
An advanced framework for piping Unix streams through pre-defined AI "patterns" (prompts) to instantly extract wisdom, write essays, or analyze code.