Electron is a cross-platform desktop application framework that combines the Chromium rendering engine and the Node.js runtime into a single binary. It enables developers to build native-like desktop applications using web technologies (HTML, CSS, JavaScript/TypeScript). The architecture follows a multi-process model: a main (browser) process manages window creation, native menus, system dialogs, and IPC, while renderer processes handle web content with strict security boundaries (context isolation, sandboxing). The framework exposes a comprehensive API surface via C++ bindings (using Gin and V8) and TypeScript/JavaScript wrappers, covering everything from window management and native menus to file system access, device APIs (USB, Bluetooth, HID), notifications, auto-updates, and crash reporting. Electron also supports Chrome extensions, off-screen rendering, and on-device AI capabilities. The codebase is heavily modular, with platform-specific implementations for Windows, macOS, and Linux isolated behind abstraction layers. Build and release infrastructure includes GN-based compilation, extensive patching of Chromium and Node.js, and CI pipelines for testing across all platforms. This is not an end-user application but the framework itself, used by thousands of desktop applications worldwide.
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.
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 implements an MCP (Model Context Protocol) server that exposes Chrome DevTools capabilities as tools for AI coding assistants. In production, it launches a headless or headed Chrome browser via Puppeteer, connects to the DevTools frontend SDK, and provides over 50 tools covering navigation, input automation, network inspection, performance tracing, heap snapshot analysis, CSS inspection, accessibility auditing (via Lighthouse), PWA management, and extension debugging. The architecture is a Node.js server that runs either as a long-lived daemon (Unix socket IPC) or as a CLI tool, with a configuration pipeline supporting CLI flags, config files, and environment variables. Key entry points are `src/bin/chrome-devtools-mcp.ts` (MCP server) and `src/bin/chrome-devtools.ts` (standalone CLI). Data flows involve collecting console messages, network requests, and DevTools issues per page via `PageCollector`, processing performance traces via `ChunkedTraceParser` and `PerformanceTrace`, and formatting results through specialized formatters (`ConsoleFormatter`, `CssFormatter`, `HeapSnapshotFormatter`, etc.) that support both text and structured JSON output. External dependencies include Puppeteer for browser control, the DevTools frontend SDK for advanced features (heap snapshots, stack traces), Lighthouse for audits, and a telemetry system (Clearcut) for usage statistics.
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.
This repository is a community-driven collection of Linux command documentation in Chinese, presented as a static website. It includes a build system (scripts/build.mjs) that reads Markdown files from the command/ directory, generates a JSON index (dist/data.json), compiles Stylus to CSS, renders EJS templates to HTML, and produces a deployable static site. The project also generates offline documentation in Dash docset format (scripts/dash.mjs) and publishes an npm package (linux-command) containing the command index. The site is deployed to GitHub Pages, Vercel, Netlify, and as a Docker image. The architecture is a static site generator with a client-side search widget, dark mode, and copy-to-clipboard functionality. It is not a traditional application but a documentation platform with a well-structured build pipeline and multiple distribution channels.
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 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.
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.
This is a desktop application built with Go and the Fyne GUI framework that manages updates for portable Chrome installations and Chrome++ (a Chrome enhancement tool). It provides a graphical interface to check for the latest Chrome versions across stable, beta, dev, and canary branches, download them using a multi-threaded downloader with resume support, and extract 7z archives. It also supports updating Chrome++ from GitHub releases, system tray integration with auto-update scheduling, proxy configuration, and localization (English/Chinese). The application communicates with Google's Omaha update protocol (via XML requests to tools.google.com) and a custom web service (chrome.noki.eu.org) to fetch version information. The codebase demonstrates solid engineering practices including data binding, concurrent downloads, and a clean i18n system using embedded TOML files.
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.
ChromiumHtmlToPdf is a .NET library and CLI tool that converts HTML to PDF (and PNG) using headless Google Chrome or Microsoft Edge via the Chrome DevTools Protocol (CDP). The core library (ChromiumHtmlToPdfLib) provides a managed C# API with synchronous and asynchronous methods for conversion, supporting extensive configuration of page settings, headers/footers, margins, paper size, JavaScript execution, and file caching. The console application (ChromiumHtmlToPdfConsole) wraps this library into a command-line tool with over 50 options, enabling batch conversions, multi-threading, and integration into scripts or CI/CD pipelines. The architecture is a two-project solution: a netstandard2.0/2.1 library and a .NET 8 console app packaged as a dotnet tool. Key entry points include the Converter class (ConvertToPdf/ConvertToImage methods) and the console's Program.cs. External dependencies are limited to a Chromium-based browser (Chrome/Edge) installed on the system, plus NuGet packages for JSON serialization, logging abstractions, and image processing (AngleSharp, Magick.NET). The codebase demonstrates solid engineering with reusable components like a file-backed cache, CDP protocol models, and pluggable loggers, but suffers from minor technical debt such as deprecated BinaryFormatter usage, disabled certificate validation in HTTP helpers, and version drift between projects. No automated tests exist, increasing regression risk for a process-heavy library.
Botright is a Python library built on Playwright that provides advanced browser automation with stealth features to evade bot detection. It includes proxy management, fingerprint spoofing using real browser profiles (chrome-fingerprints), human-like mouse movements, and CAPTCHA solving for hCaptcha, reCAPTCHA, and Geetest (though Geetest support is currently disabled). The library wraps Playwright's API with a custom layer that intercepts browser events, modifies user agent, platform, and other fingerprinting vectors, and injects anti-detection scripts. It supports both headless and headed modes, proxy rotation, and response caching. The codebase is well-structured but has commented-out modules indicating incomplete transitions (e.g., Geetest).
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.
InfoSpider is a Windows-only desktop application that aggregates personal data from over 20 online services (e.g., GitHub, JD, Taobao, Alipay, Zhihu, Bilibili) using Selenium-based browser automation and a companion Chrome extension. The user launches a wxPython GUI, selects a data source, logs in via an automated Chrome window, and the tool scrapes orders, bills, contacts, posts, and other personal information, saving it as JSON files. Some spiders also generate HTML charts (word clouds, time-series plots) from the scraped data. The repository includes a separate, experimental PyTorch LSTM model for stock price prediction in `tests/DeepAnalysis/`, which is not integrated into the main tool. The codebase is a monolithic collection of spider scripts with a simple GUI wrapper, relying on outdated library versions (Selenium 3.141.0, pandas 1.0.1) and brittle automation patterns (hardcoded selectors, sleep-based waits). It has not seen active development since 2020 and carries significant technical drift and maintenance risks.