How Wribble works
Wribble is a search engine with no search engine at its centre. There is no data centre full of servers crawling the web, no central index, and no company computer that sees your queries. Instead, the entire system runs inside ordinary web browsers and the connections between them. This page explains, in plain language, exactly how that is possible — and why it is a fundamentally different design from every mainstream search engine.
The problem with centralised search
A conventional search engine works by owning everything. It runs vast fleets of computers that continuously download the web, store a copy of it in a giant central index, and rank that index with secret algorithms. When you type a query, it travels to those computers, they decide what you see, and they keep a record of what you asked. This design has made web search incredibly powerful — but it has also concentrated enormous influence in a handful of companies. They decide which pages deserve attention, they shape what billions of people believe is true, and they build detailed profiles of everyone who searches. The index is private, the ranking is private, and you are the product being measured.
Wribble starts from the opposite premise: what if the index belonged to the people using it, the crawling were shared across thousands of devices, and no one — including us — could see what anyone searched? That is the idea behind decentralised search.
What "decentralised" actually means here
Decentralisation is a word that gets used loosely, so it is worth being precise. In Wribble, three things are decentralised that are normally centralised. First, the crawling — the work of visiting web pages and reading them — happens on users' own devices instead of on company servers. Second, the index — the searchable database of what those pages contain — is stored in each user's browser, not in a central warehouse. Third, the sharing of that index happens directly between users' browsers over encrypted connections, with no server in the middle relaying or recording anything.
The result is a search engine that has no single point of control and no single point of failure. There is nothing to subpoena, nothing to hack for a database of queries, and no algorithm operated in secret by a corporation. The system is the network of users itself.
Step one: your browser becomes a crawler
When you open Wribble and give permission, a small background program called a web worker starts running inside your browser. Its job is to politely visit public web pages, one at a time, and read them. It respects each website's robots.txt file — the standard way a site tells automated visitors what they may and may not access — and it identifies itself honestly rather than pretending to be a human. It keeps a respectful delay between requests so it never overloads anyone's website.
For each page it visits, the crawler extracts the meaningful parts: the title, the description, the headings, and the main body text. It throws away the navigation menus, advertisements, and scripts. What remains is a compact summary of what that page is actually about. This all happens on your computer, using a tiny fraction of its spare capacity, and the pages it reads are public pages that anyone could visit.
Step two: building the index inside your browser
Reading pages would be useless if you could not search them quickly, so Wribble organises what it reads into an inverted index — the same core data structure that every serious search engine uses. Rather than storing whole pages and scanning them one by one, an inverted index flips the relationship around: for every meaningful word, it keeps a list of which pages contain that word and how important the word is on each page. When you later search for "monsoon flooding", the engine does not read thousands of pages; it instantly looks up the short lists for "monsoon" and "flooding" and intersects them. This is what makes search feel instant even on a phone.
This index lives in a database built into your browser called IndexedDB. It persists between visits, so the index you build grows over time and is ready the moment you return. Crucially, it is your copy, stored on your device. You can export it, import it, or delete it entirely at any time from the "my index" page. No one else can read it unless you choose to share entries with peers.
Step three: finding other people, without a server
Here is the part that sounds impossible: how do two browsers, sitting on opposite sides of the world with no shared server, find each other and start talking directly? The answer is a browser technology called WebRTC, originally built for video calls, which lets two browsers open a direct, encrypted connection between themselves.
The only thing WebRTC cannot do alone is the very first introduction — the equivalent of two strangers needing someone to exchange phone numbers before they can call each other. Wribble solves this using public, open infrastructure called trackers, the same kind used by peer-to-peer file sharing for years. A tracker does one tiny job: it passes a connection request from one browser to another. It never sees your searches, never sees your index, and carries nothing but the brief, scrambled handshake that lets two browsers connect. Once that handshake is complete, the tracker is out of the picture entirely and the two browsers talk directly. If you prefer not to rely on public trackers at all, Wribble can use a small rendezvous server you run yourself — but even then, that server only brokers introductions and never touches your data.
Step four: sharing the index across the swarm
Once browsers are connected, they form what is called a swarm — a loose, ever-changing mesh of peers. Over their encrypted connections, peers trade index entries: small records containing a page's title, address, and a short snippet. Your browser receives entries that other people have crawled, and shares entries you have crawled, so everyone's reachable index grows far beyond what any single device could build alone. When you search, your query can also be sent directly to connected peers, who answer instantly from their own indexes. None of this passes through a central server, and none of it is logged anywhere.
This is why the network gets better as it grows. With ten users, the shared index is modest. With ten thousand, it becomes genuinely useful, because every person's crawling contributes to the whole. The system is designed so that participation and value rise together — the more people search, the more the index reflects what people actually look for.
Step five: ranking what you find
Finding pages that contain your words is only half of search; the harder half is putting the best ones first. Wribble ranks results using a well-established scoring method called BM25, which weighs how often your search words appear on a page against how common those words are across all pages, so a rare, specific match counts for more than a common one. On top of this, Wribble adds a freshness signal — recently crawled pages get a gentle boost, which matters for news-style searches — and a small bonus for pages from domains it has indexed deeply, as a rough measure of trust. Matches in a page's title count more than matches buried in the body. All of this scoring runs locally, in milliseconds, on your device.
Because the ranking code is part of the open application running in your browser, it is not a black box. There is no hidden algorithm tuned to favour advertisers, because there are no advertisers. What ranks first is simply what the scoring judges most relevant to your words.
Filling the gaps: live discovery
A brand-new user with an empty index would otherwise see nothing, so Wribble also queries a handful of free, openly accessible public sources at search time — an open encyclopedia, a global news archive, a community link archive, and a developer question archive. These return results instantly and are simultaneously fed into your crawler, so each search permanently broadens your own index around the things you care about. Over time, more and more of your results come from your own growing index rather than these live sources.
Why nothing reaches our servers
The strongest privacy claim Wribble makes is also the simplest to verify: during a search, zero bytes of your query travel to wribble.com. You can confirm this yourself by opening your browser's developer tools and watching the network activity while you search. The reason is structural, not a promise — the search happens entirely in JavaScript on your device, against your local index and your peer connections. We could not log your searches even if we wanted to, because they never arrive at any computer we control. There are no accounts, no tracking cookies, and no analytics. This is a different kind of privacy from "we promise not to look" — it is privacy by architecture, where looking is simply not possible.
The honest limitations
Decentralisation buys privacy and independence, but it does not magically match the raw scale of a company that has spent decades and billions indexing the entire web. A browser-built index is smaller, and some pages cannot be crawled directly from a browser because of technical restrictions. Wribble is not trying to pretend otherwise. What it offers instead is a genuinely different deal: a search engine that is private by design, owned by the people who use it, free of advertising and tracking, and impossible for any single party to control or shut down. For the topics you and your peers care about, it becomes good quickly — and it keeps getting better every time someone searches.