Explainer · web search vs your disk
Google's index is 100 million gigabytes. It answers you in half a second.
That figure is real: Google says its index is well over 100 million gigabytes, tens of thousands of times larger than the 4 TB drive in your machine. Yet a web search returns in under half a second, while finding one file on that far smaller drive can take over a minute. The web isn't faster because it's smaller. It's faster because it was indexed ahead of time: crawled once, mapped, and then every search is a lookup. Your disk never got that layer. Here's the gap, measured on a 4.47-million-file machine.
TL;DR · the whole thing in five lines
Search engines feel instant because they index ahead of time. A search engine crawls the web once and maps it, so every query is a lookup, not a scan. The speed is the prep, not the web being small.
Your disk never got that layer. Windows Search indexes only a corner of the drive, so finding one file among 4.47M falls back to a full filesystem walk: about 67 seconds, median.
A full, always-fresh index turns that walk back into a lookup. The same filename search returns in 85 μs (139 μs median), roughly 480,000× faster than the Windows Search fallback, same drive, same query.
Contents, not just names. A content search that takes ripgrep 93.8 s returns in 7 to 9 ms (16 ms on the proof query, 58,625× across the set), while the whole engine idles near 44 MB.
It beats the web at freshness. A file you save is searchable in about 1 ms, current to the moment you hit save, the one thing even Google's crawl can't promise.
The mechanism, drawn
The web does the hard work early. Your disk does it every time.
One line splits the picture: the moment you type. Everything to its left is prepared in advance; everything to its right happens while you wait. A search engine moved crawling and indexing to the left, so the query itself is a tiny lookup. Your disk, by default, prepared nothing, so the whole scan lands on the right, on every single query.
Read across the line. The web crossed it carrying a finished map, so it only has to look one thing up. Your disk crossed it empty-handed, so it re-reads all 4.47 million files from scratch, and pays that cost again the next time you ask. Same line, two very different amounts of luggage.
The first anchor · Google
Crawl. Index. Look up.
A web search engine is three jobs, and only one of them happens while you wait.
Crawl. Automated programs start from pages they already know and follow every link, downloading each page and discovering new ones, around the clock, long before you ever search.
Index. All that text is organized into one giant lookup, like the index at the back of a book: for each word, which pages contain it, plus the signals used to rank them. Built ahead of time.
Look up. When you search, the engine doesn't visit the web. It looks your words up in the prebuilt index, ranks the matches, and returns them. The web itself is never read at query time.
The expensive parts (crawl and index) already happened. The search itself is a lookup in a table someone built for you earlier. That is the entire reason a 100-million-gigabyte corpus answers faster than the 4-terabyte drive under your desk: the size lives in the index, not in the query.
The second anchor · Windows Search
Your disk has an indexer: it just covers a corner.
Windows ships Windows Search, and it has the right idea: it builds an index. But by default that index covers only a limited set of locations (a few user folders, the Start menu, mail), not the whole drive, and not most of your code or documents. Ask for anything outside those locations and it does the slow-lane thing from the diagram above: it walks the filesystem.
On the test machine that fallback costs 67 seconds, median, to find one file among 4.47 million. The same lookup on a full, always-fresh index is 139 microseconds, about 480,000× faster, same drive, same query. Windows had the right idea and stopped at the doorstep.
| Google · the web | Windows Search · your disk | Your disk, indexed | |
|---|---|---|---|
| The corpus | 100M+ GB of pages | 4.47M files | 4.47M files |
| Index built ahead of time | Yes, the whole web | Partial, some folders | Yes, the whole machine |
| At query time it… | looks it up | looks up, then scans the rest | looks it up |
| Time to answer | < 0.5 s | 67 s (median) | 139 μs |
| Stays fresh | minutes to days behind | often behind your edits | ~1 ms after a save |
Methodology: Ryzen 9 9950X3D · 64 GB DDR5 · NVMe · Windows 11 · 4,470,000 files. Windows Search is the median of 20 filename queries; the indexed column is the same job on a prebuilt, always-fresh index (139 μs median; 85 μs single lookup). Web figures are Google's own published index size and its sub-second query times; the freshness rows describe how far behind each index can run.
The gap is the opportunity
Give your disk the top lane. And keep it fresher than the web.
Interlinked Files does for your whole machine exactly what a search engine does for the web: it keeps a live index of every file's name and contents, every repo, plus the roughly 90% of the disk that was never in git: configs, documents, downloads, the PDF with the answer. A search becomes a lookup, not a walk. Names come back in 85 μs, contents in 7 to 9 ms. On the proof query, a content search that takes ripgrep 93.8 seconds to scan returns in 16 ms, 58,625× across the five-query set.
And here is the twist the web can't match. Google's index is always a little behind, because re-crawling the whole web takes time. A file you save on your own machine is searchable in about a millisecond, under 30 ms even in the worst case. Same lookup speed as the web, but current to the moment you hit save.
THE SAME LOOKUP GOOGLE DOES FOR THE WEB, RUN ON YOUR MACHINE, AND KEPT FRESH TO THE MILLISECOND.
Common questions
The short answers.
Why is searching the web faster than searching my own computer?
Because the web is indexed ahead of time. A search engine crawls once and builds a word-to-pages map, so every query is a lookup; your disk has no such map by default, so it scans files while you wait, on every query.
Doesn't Windows already index my drive?
Windows Search has the right idea, but by default it covers only a corner (a few user folders, the Start menu, mail), not the whole drive or most of your code and documents. Ask for anything outside those and it walks the filesystem: about 67 seconds, median, to find one file among 4.47M.
How fast is a full, always-fresh index in practice?
On the test machine (a Ryzen 9 9950X3D with 4.47M files) a filename returns in 85 μs (139 μs median), roughly 480,000× faster than the Windows Search fallback. File contents return in 7 to 9 ms; a content search that takes ripgrep 93.8 s comes back in 16 ms.
Will it find a file I just saved?
Yes, and that is the part the web can't match. A file you save is searchable in about 1 millisecond, so results are current to the moment you hit save, not the minutes-to-days a web crawl runs behind.
What does it cost?
Everything (including the agent access that wires the index into Claude Code, Cursor, Copilot and the rest over MCP) is free forever, no card. Hosting starts at $5.99/mo.
Do this today
Put a search engine on your own disk.
Install once. One signed installer builds the map and auto-configures 19 AI clients: Claude Code, Cursor, Copilot, Codex, Windsurf, Cline and the rest. No JSON editing, no keys.
Let it index. Filename search works immediately; contents fill in behind it. At rest the whole engine sits near 44 MB, less than a browser tab.
Ask freely. Whole-machine when you don't know where something lives; scoped to a folder when you do. Either way it's a lookup, not a walk.
Trust it fresh. Every save is searchable in about a millisecond, so the answer is never yesterday's file, the one thing even Google can't promise.
Everything local is free forever, on all your devices, no card. Hosting starts at $5.99/mo. Download for Windows.