Benchmarks · Apr 9 2026 · 7 min
5.6 ms.
Not 328 seconds.
ripgrep is the crown jewel of content search. SIMD-accelerated, aggressively parallel, the best implementation of a bad idea. On 446,000 code files, a full search averages 328 seconds.
TL;DR
The short version, in five lines.
Content search runs off a prebuilt index, not a filesystem walk: answers land in 1 to 10 ms. One real query that costs ripgrep 93.8 s returns in 16 ms, or 58,625× faster.
The index stays live: a file edit is searchable in ~1 ms, and the engine sits at ~44 MB idle. Index speed with a walker's freshness.
For agents the gap compounds. A real task that took an agent 6m57s across 71 tool calls collapses to 16 ms in one call, roughly 7,200,000× less wall time.
Search-token overhead drops from ~58% to ~0%, so an agent can verify every callsite and import instead of rationing two or three grep runs.
Everything local is free forever: the app, whole-machine search, MCP, no card. Hosting starts at $5.99/mo.
Interlinked Files
446K files indexed · one lookup
ripgrep
446K files walked · 58,625× slower
The content-search table
Four tools, the same 446K code files.
Content search means “find the files that contain this literal string”, not “find a file named X.” The index has to know what's inside every file.
| Tool | Wall clock | Multiplier | Method |
|---|---|---|---|
| Interlinked content search | 5.6 ms | 1× | Pre-built sparse ngram index |
| VS Code find-in-files | ~180 s | ~32,000× | ripgrep under the hood, workspace-scoped |
| ripgrep (rg) | 328.3 s | 58,625× | SIMD + parallel walk, respects .gitignore |
| grep -r | ~460 s (est.) | ~82,000× | No SIMD, no parallelism, no .gitignore |
What ripgrep does right
A masterclass in walking fast.
If you're going to walk the filesystem (and for a long time there was no other option), ripgrep is how you do it. SIMD instructions compare 16 or 32 bytes at a time instead of one. The walk parallelizes across every core. Files are memory-mapped instead of read in chunks. Binary detection skips non-text in two bytes.
Together these optimizations make ripgrep 4 to 10× faster than plain grep. On a small repo, ripgrep is how you set a gold standard.
On 446,000 files, ripgrep takes 328 seconds because no amount of per-byte optimization can compensate for opening, reading, and closing 446,000 files. The syscall cost of walking the tree is the floor, and it's measured in minutes.
ripgrep vs grep
faster: SIMD + parallel + mmap
Still requires
open → read → close syscall cycles
Why an index wins here too
The walk happens once, when nobody's waiting.
A filename index remembers every path on the drive (a few hundred megabytes, easy to hold in memory). A content index remembers every token in every code file, then answers “which files contain this string?” in single-digit milliseconds. The data structure is larger, more complex, more expensive to maintain.
The payoff is dramatic. Take one real query, same corpus: what costs ripgrep 93.8 seconds becomes a single index lookup. The engine consults its inverted structure, finds the matching files, returns the answer. 16 milliseconds, including deserialization and IPC.
The real cost
What 328 seconds actually costs a developer.
It's not a subtle speedup. It's the difference between a tool a human uses dozens of times a day and a tool a human dreads opening.
10 searches per day on 446K files
ripgrep
328 s × 10 queries = 3,283 s
Interlinked
5.6 ms × 10 queries = 56 ms
55 minutes of waiting becomes 56 milliseconds. The developer never breaks flow.
Cheap questions are a different workflow than expensive questions.
Make the query 58,625× cheaper and the strategy changes.What this unlocks for agents
“Which file imports this symbol?” A free question.
The real prize isn't speed for its own sake. It's that indexed content search lets agents ask questions they weren't willing to ask before.
Ratio
faster than ripgrep
Files indexed
code + docs
Query time
literal string search
Throughput
queries per core
On a 328-second per-query budget, an agent trying to refactor a codebase asks two or three questions and then stops. It can't afford to be exploratory. On a 5.6-millisecond budget, the same agent can ask thousands of questions per session. It checks every callsite. It verifies every import. It asks speculative questions (“does any file mention this constant?”) and gets an answer fast enough to discard the ones that don't help.
Make the query cost five orders of magnitude lower, and the agent's entire strategy changes. That's not an optimization. It's a different tool.
The agent budget
What an agent can do in 60 seconds.
| Tool | Queries in 60s | Exploration depth | Strategy |
|---|---|---|---|
| Interlinked content search | ~10,700 | Every callsite, every import, speculative | Exhaustive: ask everything, discard what doesn’t help |
| ripgrep | 0.18 | Barely one query | Conservative: can’t afford to be wrong |
| grep -r | 0.13 | Less than one query | Barely functional at this scale |
10,700 queries vs 0.18 queries in the same 60 seconds. An agent with indexed search doesn't guess. It verifies. It explores every branch. It finds the answer or proves there isn't one, all before a walker finishes its first pass.
Same files. Same queries. Same machine.
The work was already done. That's the whole trick.
Common questions
The questions that come next.
Isn’t this just ripgrep with a cache?
No. ripgrep opens and reads every file on every query; Interlinked answers from a prebuilt inverted index that was populated in the background. That's why a search taking ripgrep 93.8 s returns in 16 ms, and typical content queries land in 1 to 10 ms.
Doesn’t an index go stale the moment I edit a file?
No. It is kept live. A file change becomes searchable in about 1 ms, so results reflect the disk as it is now, not a nightly snapshot. You get index speed with a walker's freshness.
What does it cost in memory?
Roughly 44 MB at idle. It keeps only the structures it needs to answer instantly, and otherwise stays out of the way.
Why does this matter more for an AI agent than for me?
Agents pay for every query in tokens and wall time. A real task that took an agent 6m57s across 71 tool calls collapsed to 16 ms in one call (about 7,200,000× less wall time) while search dropped from ~58% of tokens to ~0%.
What does it cost, and is there a free version?
Everything (the app plus the MCP server your AI tools call) is free forever, no card. Hosting your projects starts at $5.99/mo.