Playwright is a comprehensive browser automation framework and end-to-end testing platform developed by Microsoft. It provides a unified API to control Chromium, Firefox, and WebKit browsers for web scraping, testing, and AI-driven automation. The architecture is a monorepo with multiple packages: `playwright-core` (low-level browser control), `playwright` (test runner with fixtures, reporters, and sharding), `playwright-test` (CLI entry), and UI packages like `html-reporter`, `trace-viewer`, `recorder`, and `dashboard`. Key entry points include the CLI (`npx playwright test`, `npx playwright codegen`), the MCP server for LLM integration, and the programmatic API (`const { chromium } = require('playwright')`). Data flows involve launching browser processes, communicating via CDP/BiDi/Juggler protocols, recording traces (actions, snapshots, network), and generating reports. External dependencies include Node.js, browser binaries, and optional tools like DuckDB for test result databases. The codebase demonstrates exceptional craftsmanship with clean separation of concerns, reusable isomorphic utilities, and a well-defined dispatcher pattern for client-server communication.
uBlock Origin is a high-performance, wide-spectrum content blocker implemented as a browser extension for Chromium, Firefox, Edge, Opera, and Thunderbird. The architecture is a multi-platform browser extension with a core filtering engine (static network filtering, cosmetic filtering, scriptlet injection) written in highly optimized JavaScript with WebAssembly acceleration (custom HNTrie/BidiTrie compressed tries, LZ4 block codec, public suffix list). The MV2 variant uses webRequestBlocking for real-time request interception, while the MV3 variant (uBO Lite) uses declarativeNetRequest with offscreen documents for filter compilation. A standalone npm package (@gorhill/ubo-core) exposes the static network filtering engine for programmatic use outside the browser. The codebase demonstrates exceptional craftsmanship in its filtering engines: the static network filtering parser and matcher handle the full EasyList syntax plus extensive uBO-specific extensions (replace=, urlskip=, ipaddress=, header=, csp=, permissions=, etc.). The HNTrieContainer implements a compressed trie specialized for right-to-left hostname matching with both JS and WASM implementations. The cosmetic filtering engine supports procedural selectors, scriptlet injection with 50+ scriptlets, and HTML filtering. The s14e-serializer provides efficient binary serialization with LZ4 compression for fast engine state snapshots. Differential updates for filter lists minimize bandwidth. The code is meticulously optimized for CPU and memory efficiency, which is critical for a content blocker processing every network request.
Puppeteer is a high-level Node.js library for browser automation, primarily targeting Chrome/Chromium and Firefox. It provides a rich API to control browsers programmatically via the Chrome DevTools Protocol (CDP) and WebDriver BiDi, supporting both headless and headed modes. The library is organized as a monorepo with multiple packages: `puppeteer` (full library with browser management), `puppeteer-core` (core automation API without browser download), `@puppeteer/browsers` (browser download and CLI), `@puppeteer/ng-schematics` (Angular integration), and a test server. The architecture features abstract API classes (Page, Browser, ElementHandle) with separate CDP and BiDi implementations, a custom event system, and extensive use of TypeScript generics and resource management patterns. Puppeteer is widely used for end-to-end testing, web scraping, and automation tasks, with a strong emphasis on cross-browser compatibility and modern web platform features.
Etaoin is a pure Clojure library that implements the W3C WebDriver protocol for automating major browsers (Chrome, Firefox, Safari, Edge). It provides a comprehensive, idiomatic Clojure API for browser control—navigation, element interaction, JavaScript execution, screenshots, shadow DOM, and more—without requiring Selenium or Java interop. The library also includes a Selenium IDE (.side) file executor, Chrome DevTools performance log parsing, and a rich macro DSL for resource management (with-driver, with-wait, with-postmortem). Internally, it uses multimethod dispatch to handle browser-specific quirks, a generic polling mechanism for waits, and a composable action builder for complex input sequences. The codebase is well-structured, extensively tested across multiple browsers and runtimes (JVM Clojure and Babashka), and provides clj-kondo hooks for linting its macros. It is primarily a library for integration into other projects (UI testing, web scraping, automation), but also offers a CLI entry point for running IDE scripts.
This repository is the source code for the Zen Browser, a Firefox-based desktop browser focused on productivity and customization. The codebase is a heavily modified Firefox fork that adds custom features such as workspaces (called Spaces), visual page boosts (duotone color filters), split-view tabs, glance previews, tab folders, compact mode, live folders, and a device sync system for workspace/folder/tab state. The architecture is a monolithic browser application built on top of the Gecko engine, with custom C++ XPCOM components for platform-specific functionality (e.g., native window dragging, mouse tracking for compact mode, color filter backend using Oklab color space) and JavaScript modules for the UI layer. The project includes an extensive test suite covering session restore, sync engines, shell integration, and pixel-level boost validation. It relies on upstream Firefox source code (patched via .patch files) and external services like Firefox Sync and Remote Settings. The codebase demonstrates strong engineering with well-organized custom modules, reusable test infrastructure, and a focus on state persistence and synchronization, though it carries the inherent complexity and coupling of a browser fork.
ArchiveBox is a self-hosted internet archiving platform that captures web pages in multiple durable formats (HTML, PDF, screenshots, WARC, text, JSON) and stores them locally. It provides a CLI (rich-click), a Django web UI with admin interface, a REST API (Django Ninja), and background workers managed by supervisord. The system is event-driven via the `abx-dl` bus, with services projecting events to database models (Snapshot, ArchiveResult, Crawl, Process, Machine, Persona). Key entry points include the CLI commands (`add`, `extract`, `crawl`, `run`, `search`, `server`), the web UI at `/add/` and `/admin/`, and the REST API at `/api/v1/`. External dependencies include Python 3.13+, Django 6.1, SQLite/PostgreSQL, Chromium, wget, yt-dlp, and various Node.js tools (puppeteer, single-file-cli). The architecture is a Django monolith with a plugin-based extraction pipeline, supporting scheduled archiving, recursive crawling, Memento protocol, and cryptographic proof verification (TLSNotary, OpenTimestamps).
The Obsidian Web Clipper is a browser extension that enables users to clip web content and save it as markdown notes in their Obsidian vault. It features a modular architecture with background scripts, content scripts, popup UI, and settings pages, plus a CLI component. The extension provides highlighting, reader mode, template-based formatting with variables and filters, AI-powered content processing, and cross-browser support for Chrome, Firefox, and Safari. Data flows from user interaction through the popup UI to content scripts that extract and process webpage data, which is then formatted via a template engine and saved to Obsidian. The system relies on webextension-polyfill for cross-browser compatibility, defuddle for content extraction, and various UI libraries for functionality.
Ember Inspector is a browser extension (Chrome, Firefox, Opera, bookmarklet) that provides a rich debugging interface for Ember.js applications. It injects the `ember-debug` library into the target page, which collects runtime information about components, routes, data (Ember Data), promises, render performance, deprecations, and object internals. The inspector UI is an Ember.js application that communicates with the injected debug library via a message-passing port abstraction, using adapters specific to each browser environment. The codebase is a monorepo with four packages: `ember-debug` (injected debug library), `ember-inspector` (UI), and two test apps (classic and vite). It is actively maintained by the Ember core team, with CI/CD pipelines, extensive tests, and automated release planning. Architecture: The system is split into two halves. The `ember-debug` package uses a `Port` class for event-driven messaging and adapters (Chrome, Firefox, WebSocket, bookmarklet) to bridge the injected script to the extension's background page or devtools panel. The `ember-inspector` package is a full Ember app that renders tabs (Component Tree, Route Tree, Data, Promises, Deprecations, Render Performance, Info) and features an Object Inspector for drilling into property values and editing them. The UI uses a schema-based list rendering pattern, debounced search, and resizable/draggable columns. The object inspector handles both classic Ember objects and modern Glimmer components, including computed properties, tracked properties, getters, and services. Despite reliance on private Ember APIs and version-specific code paths, the codebase demonstrates strong engineering practices, with modular components that are potentially reusable (e.g., port messaging, adapter pattern, resizable columns, property display component).
This repository is an application: an MCP (Model Context Protocol) server paired with a Firefox browser extension that gives AI assistants like Claude Desktop read and management access to a user's real browser. The MCP server exposes nine tools over stdio — open/close/list/reorder/group tabs, search browsing history, extract a page's text and links, find/highlight text in a tab, and capture screenshots. Unlike generic web-automation MCP servers, it deliberately cannot click, modify pages, or run arbitrary scripts; page content access requires per-domain user consent and screenshots require per-tab authorization via Firefox's activeTab mechanism. Architecturally this is an Nx monorepo with three packages: mcp-server (Node 22, @modelcontextprotocol/sdk), firefox-extension (Manifest V2 WebExtension), and common (shared typed message protocol). The server communicates with the AI client over MCP stdio and with the extension over a loopback-only WebSocket (127.0.0.1 and ::1 on port 8089, or 0.0.0.0 in container mode). Every message is HMAC-SHA256 signed with a shared secret the extension generates; the extension connects outbound, so no inbound socket is exposed in the browser. Requests are matched to responses by correlation ID with timeouts, and the extension replies with resources (tabs, history, content, screenshots) over the same channel. The code is security-conscious and well-crafted: the dual-loopback binding handles IPv4/IPv6 localhost resolution differences, a capture-consent module mirrors the browser's activeTab grant lifetime to fail fast with actionable errors, the extension ships no runtime third-party dependencies, and it includes per-tool enable/disable toggles, a domain deny list, and a bounded in-browser audit log. The extension message handler has a solid Jest test suite covering consent revocation, denied domains, and disabled tools; the MCP server itself lacks unit tests. Minor debt: an unused, deprecated 'readline' npm dependency in mcp-server/package.json, an Nx version mismatch between root (22.x) and the subproject (20.x), and a few non-null assertions in the WebSocket layer. The repo is actively maintained with recent commits, a release workflow that builds DXT packages, and current dependency versions (TypeScript 5.8, Jest 30, MCP SDK 1.x, ws 8.x), so technical drift is low.
This repository contains the ToS;DR browser extension (Manifest V3) for Chrome, Firefox, and Edge. It downloads a local database of website service ratings from the ToS;DR API, then detects which service a visited domain corresponds to by progressively reducing the hostname. When a match is found, it updates the toolbar icon with the service's grade (A–E) and enables the popup to show detailed summaries of terms-of-service points. The popup also fetches live service details from the API if needed. The codebase is written entirely in TypeScript with strict type checking, uses Vite for building, and includes CI/CD workflows for linting, type-checking, and creating release artifacts. The architecture is a standard single-page browser extension with a background script (or background page for Firefox), popup UI, and settings page. No test suite is present, but the code is well-organized and modular.
Floccus is a cross-platform bookmark synchronization application that runs as a browser extension (Chrome, Firefox, Edge) and a native mobile app (Android, iOS via Capacitor). Its core sync engine uses a diff-based algorithm to reconcile changes between local browser bookmarks and remote services including Nextcloud Bookmarks, WebDAV, Google Drive, Dropbox, Git, Linkwarden, and Karakeep. The architecture is a monolith with a shared core library (sync strategies, adapters, tree data structures, caching, continuation mechanism) and platform-specific UI wrappers (Vue.js options page for the extension, Vue + Vuetify for the mobile app). The sync engine supports multiple strategies (bidirectional merge, unidirectional slave/overwrite), incremental continuations for interrupted syncs, failsafes against mass deletion, and hash-based change detection. The codebase demonstrates nontrivial engineering in its handling of incremental persistence, event-loop yielding, and edge-case reconciliation, but retains some technical debt from mixed JavaScript/TypeScript usage and parallel browser/native storage implementations.
Floorp is a Firefox-based browser that extends Gecko with a comprehensive feature layer including workspaces, split-view tiling, panel sidebar, PWA/SSB management, mouse gestures, keyboard shortcuts, command palette, tab stacks, design theming, private containers, external browser integration, notes, profile manager, and more. The architecture is hybrid: chrome components are built with SolidJS and injected via a custom loader into Firefox's XUL, while settings, new tab, notes, welcome wizard, and profile manager pages are standalone React/Vite web applications served within the browser. Configuration is stored in Firefox preferences with io-ts runtime validation, and cross-process communication uses a birpc bridge. The build system is Deno-based, orchestrating Vite builds, Firefox runtime patching, and platform-specific packaging (macOS App Shim in C++, Windows Tauri stub installer). The codebase demonstrates strong engineering practices with extensive test coverage (colocated browser tests, unit tests, integration tests), clean reactive state management patterns, and well-structured feature modules. However, it carries technical debt from multiple legacy migration paths, duplicated UI components across page apps, and tight coupling to Firefox internal APIs that require version-specific workarounds.
chrome-remote-interface is a well-crafted Node.js library that provides a clean, dynamic API for interacting with the Chrome DevTools Protocol (CDP). It connects to a remote debugging endpoint (e.g., Chrome with --remote-debugging-port), fetches the full protocol descriptor dynamically, and generates typed JavaScript methods and events for every domain, command, and notification. The library supports callback and Promise patterns, includes a comprehensive CLI with an interactive REPL, and works across multiple implementations (Chrome, Node.js, Edge, Firefox, etc.). It does not bundle a browser; instead, it focuses on low-level protocol access, making it a foundational tool for browser automation, debugging, and custom DevTools clients.
Helium is a Python library that provides a higher-level, more intuitive API for browser automation, built on top of Selenium. It simplifies common web automation tasks such as clicking buttons, filling forms, handling alerts, switching windows, and dragging elements by allowing developers to reference page elements by their visible labels rather than low-level CSS selectors or XPath expressions. Under the hood, Helium translates each high-level command into Selenium calls, managing implicit waits, iframe traversal, and window focus automatically. The library is designed for both interactive use (e.g., testing) and scripting (e.g., web scraping), and it seamlessly integrates with raw Selenium for advanced use cases. The architecture follows a layered pattern: a public API module (`helium/__init__.py`) exposes functions and GUI element classes; an implementation layer (`helium/_impl/__init__.py`) contains the core logic including element location via XPath construction, frame iteration, and error handling; and utility modules provide geometry, string, and system helpers. The codebase is well-organized with clear separation between API and implementation, though the main implementation file is large and tightly coupled. The library is actively used (over 8,300 stars) and though maintenance is low-effort, it remains functional with recent Selenium compatibility.
FirefoxCSS-Store is a static community catalog for discovering and sharing Firefox userChrome.css themes. It is built with Astro 7, TypeScript 6, and Zod 4. The site renders a gallery of published themes with search, tag filtering, and sorting, and generates detail pages and a /themes.json API endpoint. The repository includes a comprehensive set of automation scripts for theme submissions (issue-form → candidate PR → approval), monthly repository audits, and stats refresh. Theme entries are validated with a strict Zod schema. The codebase is well-maintained, uses modern tooling, and has active CI/CD via GitHub Actions. It is primarily an application (static site generator + automation workflows) rather than a data pipeline.
Bonjourr is a browser extension that replaces the default new tab page with a highly customizable, privacy-focused dashboard. It is built entirely with TypeScript and Deno (no npm dependencies), using a plain Deno build system to produce extensions for Chrome, Firefox, Edge, Safari, and a PWA version. The code follows a modular feature-dispatcher pattern: each feature (clock, weather, quick links, notes, Pomodoro timer, backgrounds, search bar, quotes, custom CSS, fonts, layout editor) exports an init/update function, allowing clean separation and runtime updates without page reload. A unified storage layer (`storage.ts`) abstracts over `chrome.storage.sync/local` and `localStorage`, while a sophisticated compatibility migration system (`filters.ts`) handles data schema evolution across versions (test configs from v10.0.0 to v20.4.2 confirm backward compatibility). The extension integrates with external APIs (Unsplash, Pixabay, weather.bonjourr.fr, Fontsource, GitHub Gist) for dynamic content and settings sync, but remains opt-in and does not track users. The UI is built with vanilla HTML/CSS, uses CSS custom properties for theming, and includes a full settings panel with help mode for troubleshooting. Despite its large feature set, the architecture remains maintainable through careful abstraction, though some coupling in the main settings module and reliance on third-party services introduce moderate technical drift.
This repository is a comprehensive, curated collection of step-by-step privacy configuration guides for a wide range of software, services, and operating systems (e.g., browsers, messaging apps, social media, Windows, Android, macOS). It is purely documentation—no executable code, APIs, or data pipelines. The content is organized into Markdown files under 'Privacy Settings' and 'Extensions Settings', with a central README serving as an index. The guides are consistently formatted, include notes and tips, and are actively maintained with regular updates reflecting the latest stable versions. While not a software application, it serves as a high-quality reference for users seeking to harden privacy settings across their digital footprint.
This repository is a collection of over 60 simple, installable WebExtension examples, primarily maintained by Mozilla. The codebase is not a single application but a set of independent browser extensions, each in its own directory, demonstrating specific WebExtensions APIs such as tabs, storage, webRequest, menus, and declarativeNetRequest. The examples cover both Manifest V2 and V3, with patterns for background scripts, content scripts, popups, sidebars, and options pages. The repository also includes a shared examples.json metadata file with schema validation, ESLint configuration, and a GitHub Actions workflow for linting and validation. The practical value lies in being a reference and starting point for developers building browser extensions, rather than a production-ready deployable system.
This repository contains the source code for SimpRead (简悦), a browser extension for Chrome and Firefox that provides an immersive reading mode, focus mode, annotation, and later-reading capabilities. The extension extracts article content from web pages, applies customizable typography and themes, and supports exporting to numerous services including Markdown, PDF, EPUB, Kindle, email, and cloud storage (Dropbox, WebDAV, Notion, Evernote, etc.). It includes a rules-based site adaptation engine (defined in `website_list.json`) to handle hundreds of specific websites, a plugin system for user-installed scripts, and a notice/focus system to manage reading sessions. The architecture follows a typical browser extension pattern: a background script (`background.js`) manages storage, OAuth, context menus, and cross-tab communication; content scripts (`contentscripts.js`) inject reading and focus modes into pages; and multiple options pages (`options/`) provide configuration, custom CSS, site management, and notice center. The UI is built with React 0.14.8 and a custom Material Design UI kit (`mduikit`), with heavy use of jQuery for DOM manipulation. State is managed through a central storage service (`storage.js`) that provides reactive reads/writes and versioned migration. External integrations are implemented as service classes with OAuth flows, and a message-action pattern coordinates between isolated script contexts. The codebase demonstrates a strong feature set but suffers from significant technical debt: very old dependencies (webpack 1, React 0.14), deprecated lifecycle patterns, extensive global DOM manipulation mixed with React, hardcoded CDN links and provider secrets, and comments indicating hacky browser workarounds. The site adaptation rule set is large but fragile, relying on exact CSS selectors and inline JavaScript that break when websites change. Despite these issues, the project provides a wealth of reusable patterns, particularly in its custom UI components, notification system, and storage abstraction.
SingleFileZ is a browser extension (Chrome/Firefox/Edge) and CLI tool that saves complete web pages as self-extracting HTML/ZIP polyglot files. The core output format embeds a ZIP archive containing all page resources (HTML, CSS, images, fonts, frames) inside an HTML wrapper with a JavaScript bootstrap that extracts and displays the page without external dependencies. The extension offers extensive configuration including multiple profiles, URL-based auto-save rules, cloud uploads (Google Drive, Dropbox, GitHub, WebDAV), an annotation editor for notes/highlights/cut operations, batch saving, and file name templating. Architecturally, the project is a multi-browser extension with background scripts orchestrating page capture, content scripts handling in-page UI and resource collection, and a task queue for managing parallel saves. It relies heavily on message passing between contexts and includes custom infrastructure: a binary serialization format (YABSON) for efficient data transfer, a full ZIP read/write library with support for encryption and streaming, and a fork of Mozilla's Readability.js for article extraction. The CLI component uses Docker to run headlessly, delegating to the `single-filez-cli` npm package. The codebase is large and feature-rich but shows signs of maintainability strain: core modules are distributed as minified build artifacts in `lib/`, the README states SingleFileZ has been merged into its parent project SingleFile (suggesting this repo is superseded), and it relies on Manifest v2 which is being phased out by browsers. The custom polyfills and browser-specific workarounds add complexity. Despite this, several components (YABSON serialization, the ZIP library, cloud upload abstractions) are well-isolated and could be reused independently with minimal modification.