CtrlF++

Inspiration

Have you ever opened a complex website and felt overwhelmed by the number of links, nested menus, subpages, and documents?

Whether it's a university portal, government website, or technical documentation, finding one specific piece of information can require navigating through an entire maze of resources.

The information is already there. The problem is finding it.

We wanted to reduce this cognitive overload. Users shouldn't have to understand an entire website's structure just to find one relevant piece of information.

That inspired us to build CtrlF++.

What it does

CtrlF++ is a privacy-first browser extension that makes complex websites easier to navigate through contextual, recursive information discovery.

Instead of searching only the current page, CtrlF++ uses the page you're already viewing as context to identify relevant links and explore connected resources.

It can:

Discover relevant resources: Identify links and connected pages worth exploring based on the current page's context.
Explore recursively: Follow relevant connections to discover information buried deeper within a website.
Search inside documents: Find relevant content in supported PDF, DOCX, and PPTX files.
Find information, not just pages: Use exact and semantic matching to locate relevant passages.
Show discovery provenance: Highlight matching content and show its original source and the path taken to discover it.
Keep users in control: Provide a read-only discovery experience that doesn't autonomously submit forms or take actions on websites.

Our goal is simple: reduce unnecessary navigation, minimize cognitive overload, and help people focus on the information that matters.

Privacy by design

We believe making information easier to discover shouldn't require sacrificing user privacy.

CtrlF++ processes extracted page and document content locally inside the browser extension. Semantic matching uses an on-device model rather than sending extracted content to external LLMs or AI services.

We also built a Privacy & Security panel to make the extension's behavior more transparent.

Users can inspect recorded extension network requests, see whether request bodies were used, and check whether recorded requests went to AI services.

Rather than asking users to blindly trust a privacy promise, we want to make the relevant evidence inspectable.

CtrlF++ is also read-only by design: it discovers and highlights information without autonomously interacting with websites on the user's behalf.

How we built it

We built CtrlF++ as a browser-native extension with a local-first processing architecture.

The discovery engine starts from the active page, examines its context and links, and explores relevant connected resources. It processes supported documents inside the extension and uses local semantic matching to identify relevant information.

The discovery interface presents matches alongside their source and exploration path, helping users understand not only what was found, but where it came from.

We also developed a privacy auditing layer that records selected extension network activity and exposes that information through the Privacy & Security panel.

Challenges we ran into

One of our biggest challenges was making recursive discovery useful rather than simply following every link on a website.

Exploring too many unrelated resources would create more cognitive overload instead of reducing it. We needed to make discovery context-guided, prioritize relevant connections, and keep exploration within defined boundaries.

Another challenge was supporting different resource types. Information doesn't live only in HTML pages; it can be buried inside PDFs, Word documents, and PowerPoint presentations. Making these resources searchable required handling different extraction and processing paths.

Privacy was another important engineering challenge. We wanted to build a transparent local-processing workflow while accurately communicating what our network monitoring could and could not observe.

Accomplishments that we're proud of

What we learned

We learned that making search more powerful isn't necessarily the same as making information easier to find.

A useful discovery experience must reduce the effort users spend navigating, make relevant information understandable, and preserve a clear connection to its original source.

We also learned that privacy needs to be considered throughout the architecture, not added as an afterthought.

With CtrlF++, we explored how contextual discovery, local processing, and transparent provenance can work together to make browsing complex websites less overwhelming.

What's next for CtrlF++

We want to make CtrlF++ useful across more information-heavy websites and resource types, improve discovery relevance, and continue strengthening the transparency and privacy guarantees of its local-first architecture.

Less navigating. Less cognitive overload. More discovering.

Don't just search the page. Discover the information behind it.