# rust-search-extension, a search engine for Rust in the address bar

> This browser extension turns the address bar into a Rust search engine, covering the standard library docs, crates.io, built-in attributes, the compiler error index, the book and the Clippy lints, with an offline mode and a set of builtin commands. It is built with jsonnet, esbuild and a Rust macro compiler that compiles to WebAssembly.

**huhu/rust-search-extension** — 🦀 The ultimate search extension for Rust

- Repository: https://github.com/huhu/rust-search-extension
- Website: https://rust.extension.sh
- Stars: 1,271 · Forks: 59
- Language: JavaScript
- License: Apache-2.0
- Published: 2026-10-19 · Updated: 2026-10-19 · Language: en
- Canonical page: https://hysenlabs.com/projects/huhu-rust-search-extension

## One prefix in the address bar, and a space

The extension is triggered by typing the keyword rs into the address bar and pressing Space, which activates the search bar, and then typing any word and getting related search results instantly.

That single interaction is the whole idea, and it is the interaction every developer-tool extension is trying to own. The Rust ecosystem is spread across a surprising number of sites: the standard library documentation on docs.rust-lang.org, crates.io, the lib.rs alternative, the documentation of any third party crate on docs.rs, the compiler error index, the official book, the Clippy lint list, and the Caniuse.rs and RFC pages. A developer looking for the signature of a trait method is bouncing between those, and a search box that understands the word after rs is a better entry point than any of them.

The project description also points at a successor. Query.rs is described as the next generation search engine for Rust, at query.rs, and the extension site is at rust.extension.sh.

The extension is published on the Chrome Web Store, on Firefox as a Mozilla add-on, and on Microsoft Edge, with a version badge for Edge and a Chinese README alongside the English one. The Discord channel is linked for support, and the project publishes a changelog and a FAQ on its own site.

The audience is obvious and large: every Rust developer who has ever typed a fragment of a function name into a search engine and wished the results came from the standard library rather than from Stack Overflow.

## The catalogue of what it can search

The feature list is a catalogue of the Rust ecosystem's reference surfaces, and reading it is the fastest way to understand the scope.

On the language side, it searches primitive types and modules, structs, traits and enums, functions, methods and macros, and the built-in attributes. Those are the things the compiler documentation covers, and searching them from one box saves the round trip to the docs site and the search function that site provides.

On the toolchain side, it searches the nightly and rustc documentation, the compiler error index with error codes, the official book chapters, and the Cargo Clippy lints. The error index is the one worth highlighting, because when the compiler prints an error with a code, the code is the fastest route to the explanation, and the extension turns that code into a search.

On the ecosystem side, it searches crates on crates.io or on lib.rs, and it can search the documentation of any third party crate.

Then there are the two cross-cutting extras. Caniuse.rs and RFCs are searchable, which covers the platform support question and the design history question, and the extension claims to search the books generally, which includes the Rust book and the other official books.

The result is closer to a Rust specific search engine than to a documentation shortcut, and that is the difference between a tool you use once and a tool you keep in the omnibox permanently.

## Builtin commands, and what they are for

The extension has a set of builtin commands, and the list is worth reading because it shows what the extension does beyond searching.

The commands are given as colon-prefixed tokens: :yet, :book, :stable, :label, :tool, :mirror, :update and :history, among others. The names suggest the functions without defining them, and the documentation does not spell each one out, so the useful thing to note is the shape of the command surface.

:stable and :yet are almost certainly about which documentation set you are searching, since the extension can search the nightly and rustc docs and the distinction matters when you are chasing a feature that only exists on master. :book and :label look like shortcuts into the book and into GitHub issue or label navigation. :tool and :mirror suggest switching between official and community resources, and :update and :history are the extension's own housekeeping commands.

That colon prefix convention is a good one and it is the same convention the Rust search extension ecosystem generally uses, so a muscle memory for one of these tools transfers to the others.

It is also the convention that will bite you if a search term legitimately begins with a colon, though that is an edge case in a language whose identifiers cannot contain colons.

The docs.rs enhancements sit in the same category of feature. Rather than only linking out to a crate's documentation, the extension improves the pages it sends you to, displaying feature flags and showing a table of contents. The GitHub rust-lang release page gets a table of contents too, and the docs.rust-lang.org pages get all the since and issue labels turned into links. Those are small touches, and they are the difference between a link and a usable page.

## Offline mode depends on your local Rust documentation

The offline mode is the feature that requires a condition rather than a setting, and the condition is stated in the feature list itself: offline mode supported, search local Rust docs, with the command rustup docs --std in parentheses.

That parenthesised command is the entire mechanism. The local documentation that rustup installs is what the extension searches when the network is not available, so offline mode is not a bundled corpus shipped with the extension, it is a search over the documentation you already have on the machine.

For a developer on a plane or on a train, that is a genuinely useful behaviour, because the standard library documentation is exactly what you want when you are offline and cannot remember a signature. For a user without the local docs installed, offline mode has nothing to search and the feature is inert.

The same section of the feature list mentions support for import and export of your local data, which is the other half of the offline story. If you have a set of custom commands, custom shortcuts or settings, you can move them between machines, which matters for anyone who works on a laptop and a desktop or who reinstalls periodically.

The design is worth noting as a whole. The extension is thin about content and thick about integration: it does not ship the documentation, it points at the documentation you already have, and it fixes up the pages it sends you to.

## Building it: jsonnet, esbuild, make targets and a Rust wasm module

The build is unusual enough to be worth walking through, because a browser extension with a Rust component and a jsonnet manifest is not a typical JavaScript project.

The contribution instructions start by saying that jsonnet is required before getting started, with a pointer to the jsonnet README.

```bash
git clone --recursive https://github.com/huhu/rust-search-extension
cd rust-search-extension

npm install -g esbuild web-ext

make chrome
make firefox
make edge
```

The three make targets are the Chrome, the Firefox and the Edge build respectively.

The clone is recursive because the repository has submodules, and the npm install pulls in esbuild and web-ext, the Firefox extension tooling. The three make targets produce the three browser builds, and the packaging step is a separate command with the browser name as its argument.

```bash
make pack chrome

make pack firefox

make pack edge
```

The Makefile shows what the build actually is. It includes core/extension.mk and build.mk, and it has three interesting targets. The manage target builds the management page css and html by running a Rust program with cargo run inside the manage directory, with an assert target that checks the output exists and tells you to run make manage if it does not. The bundle target runs esbuild on content-script-bundle.js, bundling and minifying it with the global name rse, targeting es2015, and writing into the extension directory. The macro-railroad target builds a WebAssembly module, extension/wasm/macro-railroad.wasm, together with its JavaScript wrapper.

That last target is the interesting one, because it explains the repository layout. A Rust source directory sits at the top level, a macro-railroad directory holds the Rust code that compiles to WebAssembly, and the content script bundle is JavaScript that loads the wasm module. A wasm component inside a browser extension is not decoration, and the name suggests it is the part that turns Rust macro syntax into something you can search for, which is the kind of problem that a JavaScript parser handles badly and a Rust one handles well.

## Two licence files, a nightly release line, and a static site

The licensing is dual, and it is handled by having two files in the repository root, LICENSE-MIT and LICENSE-APACHE, with badges for both, while the project description gives Apache-2.0 as the licence. The same pattern appears in the file listing, where the two licence files sit next to each other at the top level. A dual licensed project offers the choice to the consumer, and the practical rule is that you pick the one whose obligations suit you.

The release history tells a different story from the tag dates. The most recent release is a nightly, nightly-2026-10-15-e205f85, dated 2026-10-15, which is the same day as the last push, and the tagged releases are v2.0.0 from 2024-10-16 and v1.13.0 from 2024-02-14. So the project ships continuous nightly builds for the extension stores and has not cut a numbered release since 2024.

That is a reasonable arrangement for a browser extension, where the store handles updates and users want the newest version, and it also means the version number in the store listing tells you very little about the age of the code.

The rest of the repository shows a project with a website attached. There is a docs directory, a vercel.json, an assets directory with the rustacean image and the demonstration animation, a scripts directory, and a core directory that the Makefile includes from. The site at rust.extension.sh hosts the changelog, the FAQ and the download links, so the repository and the site are maintained together.

The sponsorship credits are worth a mention too, since they are part of what keeps a browser extension in the stores: the project thanks two named sponsors, and a Discord badge sits alongside them.

## Conclusion

Adopt this extension if you write Rust daily and keep bouncing between the standard library docs, crates.io, the error index and the book, because the extension puts all of them behind one prefix and one keystroke. Do not adopt it if you only occasionally need the documentation, since the browser's own search plus the correct URL is enough, and do not expect it to work offline unless you have the local Rust documentation installed. Before you install, note that the extension is published separately for Chrome, Firefox and Edge, and that the project ships both MIT and Apache-2.0 licence files, so read the one covering the part you use.

## FAQ

### How do I activate the Rust search extension?

Type the keyword rs in the address bar and press Space to activate the search bar, then enter any word and the extension responds with related search results instantly. The extension is published for Chrome, Firefox and Microsoft Edge.

### What can the rust-search-extension search?

Primitive types and modules, structs, traits and enums, functions, methods and macros, builtin attributes, the nightly and rustc documentation, crates on crates.io or lib.rs, the documentation of any third party crate, the compiler error index by error code, the official book chapters, the Cargo Clippy lints, Caniuse.rs and RFCs.

### Does the extension work offline?

Yes, offline mode is supported and searches the local Rust documentation installed with rustup, using rustup docs --std. You also can import and export your local data.

### How do I build the extension from source?

Install jsonnet, clone the repository recursively, install esbuild and web-ext with npm, then use `make chrome`, `make firefox` or `make edge`. To produce packages, use `make pack` followed by the browser name.

### What licence is the rust-search-extension released under?

It is dual licensed, with both a LICENSE-MIT and a LICENSE-APACHE file in the repository and badges for each, while the project description gives Apache-2.0. The project ships nightly releases, with the latest dated 2026-10-15.

## Sources

- [huhu/rust-search-extension on GitHub](https://github.com/huhu/rust-search-extension)
- [License: Apache-2.0](https://github.com/huhu/rust-search-extension/blob/master/LICENSE)
- [Project website](https://rust.extension.sh)
- [README](https://github.com/huhu/rust-search-extension/blob/master/README.md)
- [Releases](https://github.com/huhu/rust-search-extension/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/huhu-rust-search-extension