Comparisons · measured July 2026 · 7 min
ripgrep vs grep: what actually changed.
If you search code for a living, you've met both. grep has been walking Unix filesystems since 1973; ripgrep arrived in 2016 and quietly became the default inside editors, CI, and half the terminals on your team. It is faster. Genuinely, measurably. This is the honest accounting of what ripgrep improved, what it left alone, and the one wall neither can climb: on a big enough drive, both still walk the disk on every single query.
What ripgrep improved
A better walker. Not a different idea.
ripgrep earned its reputation. Where grep -r crawls a directory tree on one thread, ripgrep fans the walk out across every core. It respects your .gitignore, skips hidden and binary files by default, speaks Unicode without you setting a locale, and uses a finite-automata regex engine that can't blow up into catastrophic backtracking. On a real project tree, that stack of wins makes it several times faster than grep at the same recursive search.
One honest caveat, because it matters: on a single file or a piped stream, grep is still a tight loop of C that often ties or beats ripgrep. grep isn't obsolete: it was built for one file, and it's superb at one file. ripgrep's advantage shows up the moment you point it at a whole tree.
Read top-to-bottom: the ledger is every place ripgrep pulls ahead of grep. The axis below is what those wins buy you on one content query across 4.47M files: a faster walk, still under the same ceiling. Ryzen 9 9950X3D · 64 GB DDR5 · NVMe · Windows 11.
The shared ceiling, measured
Every optimization made the walk faster. None of them skipped it.
ripgrep is the best walker there is. On our 4.47-million-file volume, one content query still took it 93.8 seconds, because parallelism and skipping can shrink the walk, but the walk is still open-read-close, once per file, on every query. A purpose-built index answered the same query in 16 milliseconds; across the five-query content set the gap averaged 58,625×.
| The tool | What it does per query | One content query | vs Interlinked |
|---|---|---|---|
| Interlinked content search | reads a live index, opens no files | 16 ms | 1× (baseline) |
| ripgrep (rg) | parallel walk: open → scan → close, skips ignored + binary | 93.8 s | 58,625× |
| VS Code find-in-files | ripgrep under the hood, scoped to the open folder | one folder | not measured |
| grep -r | single-thread walk: open → scan → close everything | slower still | not measured |
Same machine, same 4.47M-file NTFS volume: Ryzen 9 9950X3D · 64 GB DDR5 · NVMe · Windows 11. ripgrep with default settings (.gitignore respected). The 93.8 s figure is one query in a five-query content set; across the set the gap averaged 58,625×. Interlinked content search runs 7 to 9 ms typical, 16 ms for an exact phrase. grep's recursive walk wasn't timed: it does the same open-read-close with fewer tricks, so it can only land slower.
Why the wall exists
The walk is O(every file). An index is O(the answer).
Here is the shape both tools share. To answer “which files contain this string,” a walker must visit the files (open, read, scan, close) and there is no answer until it has visited enough of them. The cost scales with the size of the disk, not the size of your question. Double the files and you double the walk, every query, forever. ripgrep's parallelism divides that cost across cores; its filters trim which files count. Both are real wins. Neither changes the exponent.
A purpose-built engine does the walk exactly once, in the background, when nobody is waiting, then keeps a live index that updates as files change, so a saved edit is searchable again in about a millisecond. At query time there is no tree to crawl and no file to open. The engine consults the index and returns the matches. The walk already happened. That is the whole difference.
What changes when the walk is already done
Do the walk once. Bill every query zero.
An index sounds heavy until you measure it. It stays fresh without a re-scan, sits quietly in the background, and costs a rounding error of your drive, while turning every content query from a minutes-long walk into a lookup you don't notice.
What your agent actually runs
VS Code's search is ripgrep. So is your agent's.
When you hit find-in-files in VS Code, you're running ripgrep, scoped to your open folder, which is why it feels fast in a small repo and stalls on a big one. Your coding agent has it worse: it shells out to raw ripgrep or grep machine-wide, on every question it can't answer from memory. The ceiling that caps ripgrep caps them both, and an agent hits it dozens of times per turn.
The filename median across 20 queries was 139 µs; the best single lookup, 2 µs. Make the query cost five to seven orders of magnitude lower and the agent stops rationing questions: it verifies every callsite, checks every import, and asks the speculative ones it used to skip. The same live index also carries short notes agents leave on files, so the next agent reads what the last one learned. Same tools. A floor that answers first.
Give your tools the floor they stand on
Keep grep. Keep ripgrep.
Install once. One signed installer wires up 19 AI clients: Claude Code, Cursor, Copilot, Codex, Windsurf, Zed and the rest. No JSON to edit.
Keep your tools. grep and ripgrep stay exactly where they are. The index just answers first: machine-wide, in the microsecond range, on the queries a walk would spend minutes on.
Let it stay fresh. Save a file and it’s searchable again in about a millisecond. At rest the whole engine sits around 44 MB and the index takes under 1% of the drive.
Everything local is free forever, on all your devices, no card. Hosting starts at $5.99/mo. Download for Windows.