Rust For Command-Line Tools

The shell script grew up. Now it needs to be a real tool.

It started as twenty lines. Then it got a flag, then another, then a config
file, then error handling that no longer fit in a case statement. It is slow on
large inputs, it breaks when piped, it prints color into files that should not
have it, and nobody can install it without the right version of three other
things. You already know what it should be: a single fast binary that starts
instantly, behaves correctly in a pipe, and runs anywhere with nothing to
install alongside it.

This book teaches you to build exactly that, in Rust.

It is not a general Rust tutorial. It is about the specific craft of the
command-line environment - the parts that separate a script that technically
works from a tool people trust: exit codes that mean something, output that
knows whether it is talking to a terminal or a pipe, errors a user can act on,
and a binary that ships as one file with zero runtime dependencies.

WHO IT IS FOR

Two readers. If you have written a shell script that outgrew the shell, you are
here - no prior Rust needed, since each language feature is introduced when the
problem calls for it. And if you already know Rust but have only built web
services or embedded firmware, this book covers what the command line demands
that those environments never taught you: the signal model, terminal detection,
SIGPIPE, and graceful shutdown.

WHAT YOU WILL BE ABLE TO DO

- Parse arguments cleanly with clap, including subcommands and help
- Read from files, stdin, and streams without loading everything into memory
- Return exit codes and errors that scripts and users can act on
- Produce output that behaves: color on a terminal, plain text in a pipe
- Layer configuration correctly across flags, files, and the environment
- Show progress and spinners for long-running work
- Do filesystem work safely, respecting ignore files and temp directories
- Test CLI tools properly, including output snapshots
- Add concurrency for throughput with Rayon
- Handle signals, interrupts, and SIGPIPE for a clean shutdown
- Cut startup time and binary size, then package and distribute your tool

THE PAYOFF

Fifteen chapters build toward a capstone: sift, a fast search tool in the
spirit of grep and ripgrep - argument parsing, streaming input, parallel
search, terminal-aware output, and correct signal handling, assembled into one
polished binary you would actually put on your PATH. A companion download
provides a complete, testable Cargo project for every chapter.

Every chapter ends with a quiz, and every answer is explained in Appendix A.

WHY THIS BOOK

Most tutorials stop at "it compiles and prints the answer." Real tools live in
pipelines, get interrupted, run in scripts, and are installed by strangers.
This book is about everything that happens after it prints the answer - the
difference between a program and a tool.

PREREQUISITES

You are comfortable with the command line as a user - pipes, exit codes, why a
compiled tool beats a script. No prior Rust required.

Part of the RUST IN PRACTICE series from Waskey Press. Each volume stands
completely alone - no prior volume required.

Scroll up and start building tools people trust.