🔍 Ripgrep Reference

Recursive search from the current directory. Skips .gitignore'd files, hidden files and binaries — which is why it sometimes "misses" things.

Smart case: insensitive until your pattern contains a capital letter. The best everyday default — alias it and stop thinking about -i.

Force case-insensitive, even when the pattern has capitals. Use when you know the casing in the codebase is inconsistent.

Whole words only. The fastest single way to cut noise when your term is a common substring.

Search one or more specific paths. Narrowing up front beats filtering the results afterwards.

Literal string, regex disabled. Reach for this any time the term has dots, brackets, parens or slashes in it.

Filenames only, one per line. This is the form you pipe into other commands.

The inverse of -l: files that do not contain the pattern. Good for auditing what is missing rather than what is there.

Restrict to a file type. Faster than an equivalent glob, because rg rejects files before opening them.

Repeat -t to include several types. Types are additive, not exclusive.

Exclude a type with -T. Use it to keep docs, lockfiles or fixtures out of code searches.

Glob when no built-in type fits, or when you need one precise set of extensions.

A leading ! negates the glob. This is how you exclude a directory, and it is the flag missing from most cheatsheets.

Restrict to a directory pattern at any depth in the tree.

One -u ignores .gitignore. Two also searches hidden files. Three also searches binaries. Add u's until the file turns up.

Include dotfiles and dot-directories while still honouring .gitignore. Short form is -. (a bare dot).

Bypass .gitignore but keep obeying .ignore and .rgignore. Lets you see build output without losing your own excludes.

Cap the recursion depth. A depth of 1 means the current directory only, no subdirectories.

List the files rg would search, with no pattern at all. Filter it with -t or -g rather than piping into grep.

^ anchors to the start of the line. Cheap, precise, and cuts out indented or commented occurrences.

$ anchors to the end of the line.

Alternation and grouping. Inside quotes you never need to escape the parens or the pipe.

Multiple independent patterns. Also the only way to search for a term that begins with a dash, which rg would otherwise read as a flag.

Invert: print the lines that do not match. Combine with a second rg to whittle noise down in stages.

-P switches to the PCRE2 engine. Lookahead and lookbehind do not exist in rg's default engine, so without -P these patterns error out.

Backreferences also need PCRE2. This one finds accidentally doubled words.

-U lets a match span lines, but . still stops at a newline until you add --multiline-dotall. Missing that second flag is why most multiline examples silently fail. Keep quantifiers lazy (.*?) or you will match the whole file.

Read patterns from a file, one per line. Pass - to take the list from stdin instead.

Three lines of context on both sides. The single most useful flag for actually understanding a hit.

-A is lines after, -B is lines before. Asymmetric context is what you want for stack traces and multi-line log entries.

rg drops colour and grouping the moment output is piped. -p forces the terminal formatting back on so less can render it.

Cap how much of a long line prints, so one minified file cannot flood the terminal. --max-columns-preview shows a truncated preview instead of suppressing the line entirely.

Newest files first — the only sensible order for logs. --sort does oldest first. Both force single-threaded searching, so use them on narrow scopes.

Flat file:line:text on every row instead of results grouped under filename headings. Easier to scan, and each line stands alone when pasted.

-I drops filenames, -N drops line numbers. What is left is clean text you can copy straight into something else.

Strip leading whitespace from each result line, so deeply indented code stops wrapping in your terminal.

Add column numbers, implying line numbers too. Needed by any tool that jumps to an exact position.

Counts matching LINES per file, not matches. A line with three hits still counts as one — this is the surprise behind most wrong totals.

Counts every match, including several on the same line. This is the number you actually meant when -c disappointed you.

List files with zero matches alongside the rest, so the report covers everything searched.

Print only the matched text rather than the whole line. Every extraction pipeline starts here.

-r rewrites output using capture groups; with -o you get the captured value on its own. Single-quote the replacement or your shell will eat $1 before rg sees it.

The frequency tally: extract, group, rank. This answers "which of these appears most", which no single rg flag does.

Preview a rewrite on stdout. rg never edits files — there is no in-place mode — so this is purely a dry run before you hand the job to sed.

JSON Lines output with byte offsets and submatch positions. Use this in scripts instead of parsing rg's human-readable text.

Append a summary: matches, matched lines, files with matches, files searched, elapsed time.

Repo-wide find and replace, the safe way. rg locates the files, sed makes the edit. -l0 and xargs -0 use NUL separators so paths with spaces do not break.

The shorter form of the same thing. Fine for tidy paths, but it will mangle filenames containing spaces — prefer the -l0 variant.

How many files a change would touch. The fastest way to size a refactor before starting it.

Open every matching file at once and work through them in one sitting.

Chain two searches to find files containing both patterns — an AND that a single regex cannot express across lines.

file:line:col:text with exactly one row per match, which is the shape vim's quickfix list and most editor pickers expect.

Pipe into fzf for interactive narrowing, with a preview pane to see each hit in place.

Search only the files you have changed. A quick pre-commit check that never touches the rest of the repo.

rg reads stdin, so it is a drop-in replacement for grep anywhere in a pipeline.

Search inside .gz, .bz2, .xz, .zst and .lz4 archives without unpacking them first.

--line-buffered is mandatory on a live stream. Without it rg buffers its output and you sit staring at nothing.

Narrow in stages instead of building one enormous regex. Easier to write, and easier to adjust when it over-matches.

-a treats binary files as text. By default rg stops at the first NUL byte and just warns you it found binary data.

Skip files above a size limit, so one stray database dump or 2 GB log cannot stall the whole search.

Treat \r\n as the line ending. Without it, $ never matches on Windows-format files because \r sits between your pattern and the line end.

Print every line but highlight the matches — reading the whole file with your search term lit up. -p keeps the colour alive through the pipe.

Run each file through a preprocessor before searching, which lets rg read PDFs, DOCX, or anything else it cannot parse natively. Your script takes the path as $1 and writes plain text to stdout.

Print the byte offset of each match, so you can seek straight to it with dd or tail -c.

The first thing to try when rg finds nothing you know is there. Disables .gitignore, hidden-file skipping and binary detection in one go.

Check the file is even in the search set before blaming your pattern. No output means rg is excluding it, not failing to match.

Shows exactly which ignore rule excluded a file and which file that rule came from. Ends the guessing.

Every built-in type name and the globs it covers. Check here instead of guessing what -t accepts.

Define your own type inline. Put the same string in your config file to keep it permanently.

Point rg at a config file of default flags, one per line, # for comments. This is where --smart-case and your standing excludes belong.

Unset the config for a single run. The way to find out whether one of your own defaults is causing the odd result.

Apply .gitignore rules even outside a git repository, which rg skips by default. Useful in extracted tarballs and scratch directories.

Use the fast default engine and fall back to PCRE2 automatically when the pattern needs it, so you stop having to remember -P.

rg's own help is long and searchable with rg. Usually faster than opening the man page.