OpenScreen is a feature-rich, open-source desktop screen recording and video editing application built with Electron, React, and Pixi.js. It serves as a free alternative to Screen Studio, offering native screen capture on Windows (via Windows Graphics Capture, DirectShow, and WASAPI) and macOS (via ScreenCaptureKit and AVFoundation), with a browser-based fallback using getDisplayMedia. The application provides a complete post-production workflow including a timeline for zoom, trim, speed, annotation, and blur regions; automatic captioning using on-device Whisper (via Transformers.js); cursor overlay with smoothing, motion blur, and click bounce; webcam picture-in-picture with mask shapes; and export to MP4 (H.264 + AAC) and GIF with quality presets and a source-copy fast path. Architecturally, OpenScreen follows a multi-window Electron pattern with a main editor window, a floating HUD for recording controls, a source selector, and a countdown overlay. The renderer process communicates with the main process via a unified native bridge IPC channel, which exposes typed services for system, project, and cursor domains. Native capture is handled by platform-specific helper binaries (C++ for Windows, Swift for macOS) that stream video and cursor telemetry as JSON events. The editor uses Pixi.js for real-time compositing of video, webcam, cursor, annotations, and effects, with a spring-based physics system for smooth zoom and cursor transitions. The codebase demonstrates strong engineering practices with extensive unit and browser tests (Vitest + Playwright), internationalization across 12 locales, CI/CD pipelines for Windows, macOS, and Linux builds, and a Nix flake for reproducible development environments. However, the project is explicitly archived and no longer maintained; a community fork is recommended for continued development. The main editor component (VideoEditor.tsx) is notably large (~2000 lines), mixing state management, export logic, and UI, which presents a maintenance challenge. Despite this, many individual modules are well-isolated and reusable, particularly the export pipeline, cursor smoothing, captioning logic, and undo/redo hook.
ytDownloader is a cross-platform desktop application built with Electron that provides a graphical interface for downloading videos and audio from YouTube and hundreds of other sites using yt-dlp as the backend download engine. It features a comprehensive download manager supporting single downloads, playlists, and YouTube search, with options for format selection, quality, subtitles, compression, and output templates. The application manages its own yt-dlp and ffmpeg binaries, supports auto-updates, and includes a download history with JSON/CSV export, theming, internationalization (23+ languages), system tray integration, and a global hotkey for quick URL pasting. Architecture: The application follows a standard Electron architecture with a main process (main.js) handling window management, IPC handlers, auto-updater, system tray, and global hotkey. A preload script (preload.js) sets up a context bridge (electronAPI) that exposes filesystem operations, process spawning, clipboard access, and other OS services to the renderer. The renderer process consists of several JavaScript modules (src/index.js, src/playlist.js, src/compressor.js, src/preferences.js, src/history_ui.js, src/common.js) that handle specific views. Communication between renderer and main process occurs via Electron's IPC mechanism (ipcRenderer/ipcMain). User preferences are stored in localStorage and a JSON config file, while download history is persisted as JSON. Key entry points: main.js (Electron main process), preload.js (context bridge), html/index.html (single-page UI shell), src/renderer.js (main renderer logic with YtDownloaderApp class), src/index.js (homepage downloader), src/playlist.js (playlist downloader), src/compressor.js (video compressor), src/preferences.js (settings), src/history_ui.js (history view). External dependencies include yt-dlp (download engine), ffmpeg/ffprobe (media processing), Electron (framework), electron-builder (packaging), electron-updater (auto-updates), systeminformation (GPU detection), and SlimSelect (custom dropdowns). The application bundles these binaries or uses system-installed versions, with fallback mechanisms.
Min is a production desktop web browser built on Electron, focused on speed, minimal UI, and privacy. The repository contains the complete application: main-process window and view management, tab/task state, a plugin-driven search/address bar, session restore, download handling, reader mode, PDF viewing, content blocking, translation, and password-manager integrations. The dominant architecture is an Electron main/renderer split with IPC-driven communication, several hidden service pages (places, translation), and a custom module bundling pipeline for main, browser, and preload scripts. Although it embeds data-oriented components such as a history full-text search engine and a bookmark tag index, this is an application, not a data/research project; those components serve browser features rather than analytical workflows. The primary entry points are `main/main.js` for the Electron main process, `js/default.js` for browser UI initialization, and `index.html` for the renderer shell. Core data flows are local: browsing history and bookmarks are persisted through Dexie/IndexedDB in a hidden places service, full-text history search uses a custom BM25-style ranking implementation, and network requests are filtered by a modified ABP filter parser. External dependencies include Electron, Dexie, pdfjs-dist, Readability, drag-and-drop libraries, external CLI password managers, EasyList-style filter lists, the Public Suffix List, and Bergamot translation models. The searchbar plugin system and password-manager abstraction are the most notable architectural patterns. The codebase is actively maintained but shows medium technical drift: it relies on a custom concatenation-based build instead of a standard bundler, mixes legacy callbacks with modern async/await, vendors modified forks of third-party code, and contains Electron-version-specific workarounds. No automated test suite is present in the repository, and some platform-specific code is fragile across Electron upgrades. Overall it is a solid, working desktop application with several clean abstractions and a small number of genuinely reusable components, but it would benefit from test coverage and modernization.
Colanode is a local-first collaboration workspace platform designed for self-hosting. It provides real-time editing of rich-text documents, customizable databases (table, board, calendar views), threaded chats, file management, and user roles. The architecture is a monorepo with separate packages for core types, client-side local persistence and sync, CRDT conflict resolution, and a shared UI library. The server runs on Fastify with PostgreSQL and Redis, exposing REST APIs and WebSocket connections for real-time synchronization. All data mutations are first applied locally in SQLite (via Kysely) and then synced to the server, enabling offline-first operation. Clients include a web application (React, Vite, service worker), a desktop app (Electron), and an experimental mobile app (Expo). The editor is built on TipTap/ProseMirror with custom extensions for blocks, mentions, files, and database nodes. External dependencies include PostgreSQL (with pgvector extension for optional vector search), Redis (for rate limiting and job queues), object storage (local filesystem, S3, GCS, or Azure), and optional AI/LLM providers for semantic search and assistant features. Many AI features are commented out or in development, indicating an incomplete experimental layer. The codebase is actively maintained with CI/CD pipelines, Docker images, Helm charts, and automated tests for critical server and web components.
Free-NTFS-for-Mac is a macOS desktop utility that provides read-write access to NTFS-formatted drives using ntfs-3g and MacFUSE. It is implemented as an Electron application with a main process (Node.js) and a renderer (Chromium), offering a graphical interface for device detection, mounting, unmounting, ejecting, and resetting NTFS volumes. The application also includes a system tray mode, automatic mount on device insertion, password management via macOS Keychain, dependency checking (Homebrew, MacFUSE, ntfs-3g, fswatch), and multi-language support (English, Japanese, Chinese, German). The codebase is modular, with separate modules for device detection (event-driven via fswatch with fallback polling), mount operations, sudo execution, caching, and batch command execution. It also provides a set of shell scripts (ninja tools) for building, packaging, and installing dependencies. While the application is functionally complete and actively maintained, it exhibits some technical debt such as duplicate implementations, hardcoded paths, and reliance on system tools that may change across macOS versions.
Sleek is a cross-platform desktop application (Electron + React + TypeScript) that serves as a feature-rich todo.txt manager. It reads and writes todo.txt files, providing advanced filtering, sorting, grouping, and archiving capabilities. The application features a custom filter grammar (PEG.js) for complex queries, file watching for real-time updates, due-date notifications with badge support, and a Pomodoro timer integration. The user interface is built with Material-UI components, offering a clean, customizable experience with dark/light themes and color customization. Sleek supports 16+ languages and includes optional Matomo analytics, respecting user privacy by never collecting todo content.
pdf-to-printer is a small, focused Node.js/Electron library that prints PDFs and images to Windows printers by shelling out to a bundled SumatraPDF executable. The public API exposes three async functions: `print()`, `getPrinters()`, and `getDefaultPrinter()`. `print()` validates the target file, builds SumatraPDF command-line arguments from a typed options object (printer, pages, orientation, paper size, duplex, copies, etc.), and executes the binary via `child_process.execFile`. Printer discovery uses PowerShell's `Get-CimInstance Win32_Printer` and parses the formatted text output into structured `Printer` objects with device ID, name, and supported paper sizes. The code is TypeScript with strict mode, unit-tested with Jest, and bundled with webpack for UMD distribution. It is Windows-only by design and throws on other operating systems.
Streamlabs Desktop (formerly Streamlabs OBS) is a production-grade live-streaming desktop application for Windows and macOS built on Electron and the OBS Studio native library (obs-studio-node). In production it lets streamers compose multi-scene/source setups, manage audio, go live simultaneously to Twitch, YouTube, TikTok, Kick, Facebook and other platforms, run alert/widget overlays, record and replay, generate AI highlight clips, and control the app programmatically through an external JSON-RPC API (used by Stream Deck devices, mobile remotes, and third-party platform apps). The product layer also includes Ultra subscription gating, an overlay/widget store, onboarding flows, game-capture source management, and a managed updater with incremental rollout and A/B testing. Architecturally, the app spans multiple Electron processes (worker services layer, main UI, child windows) with a custom dependency-injection framework (@Inject, Service/StatefulService/PersistentStatefulService) and IPC proxies that let any window invoke services as if local. State is persisted through layered mechanisms: Vuex-backed mutations, localStorage-backed persistent services, and RealmObject documents for real-time data. The UI is a hybrid: a large legacy Vue 2 surface is being progressively replaced by React 17 with antd 4, bridged through component wrappers. Undo/redo is a genuine Command pattern (EditorCommandsService with combinable commands and a 500-entry history), and scene collections serialize through a versioned node/array-node tree with overlay import/export and migrations. Core data flows: OBS native events (stream/record status, scenes, sources, audio meters) flow from obs-studio-node into stateful services that reactively drive the UI; scene collections persist as JSON via the node serializer; widget settings are fetched and patched against the Streamlabs REST API; real-time alerts, safe-mode state, and user state for AI features arrive over WebSocket; platform auth uses OAuth/PKCE flows. The highlighter subsystem contains a notably crafted media pipeline (FFmpeg frame reading, WebGL transitions, audio crossfading, vertical export, companion-app installation) for automated clip generation. The codebase is large (~5000 files) and shows its age in places: Vue 2 (EOL), React 17, and antd 4 are several major versions behind; at least four state-management approaches coexist (Vuex, Zustand, Realm, localStorage); a global Services locator couples many modules; and scattered @ts-ignore comments and skipped tests indicate debt. Despite this, the DI/service layer, command pattern, node serialization framework, JSON-RPC protocol, metadata-driven form system, and several DSP/geometry utilities are cleanly designed and genuinely reusable, and the project is actively maintained with CI workflows, dependency automation via Renovate, and an extensive test suite spanning unit, integration, screenshot, and performance tests.
MTranServer is a high-performance, offline machine translation server that provides a REST API, web UI, and desktop Electron application. It leverages Mozilla's Bergamot (Marian NMT) engine compiled to WebAssembly for on-device translation, with no GPU required and average response times around 50ms. The server supports major world languages, language auto-detection via CLD2 (also compiled to WASM), and offers compatibility endpoints for popular browser translation plugins such as Immersive Translate, DeepL, Google Translate, and Kiss Translator. The architecture is a TypeScript/Node.js monolith using Express with tsoa for typed controllers and Swagger generation, a React frontend with shadcn/ui, and an Electron desktop wrapper. The system includes model auto-downloading, LRU caching, worker-per-language concurrency, and offline mode. The repository contains a large deprecated codebase (Go, Node.js v1, Rust, C++ versions) which is not actively used but remains in the source tree, potentially causing confusion. The active code is well-structured and follows modern TypeScript practices, though some vendored dependencies (CLD2, Bergamot) are old and have been compiled to WASM to mitigate drift.
MooTool is a cross-platform developer toolbox with over 30 utilities including JSON formatting, HTTP client, regex testing, encryption/decryption, color picker, diff viewer, QR code, cron expressions, translation, image processing, PDF manipulation, code runtime, and more. The repository contains three concurrent implementations: a legacy Java Swing desktop application (with FlatLaf theming and MyBatis/SQLite persistence), an Electron+React+TypeScript rewrite (using CodeMirror, pdf-lib, and native IPC bridges), and a Tauri 2 (Rust+React) version with additional native features like screen capture, system tray, and updater integration. A macOS native SwiftUI app is also provided as a preview. The architecture is modular per tool, with shared contracts across platforms, session tracking, operation history, and vault-based note storage with Git versioning. Key entry points include the Java MainFrame, the Electron main process (electron/main/index.ts), and the Tauri Rust backend commands. Data flows are entirely local (SQLite, file vault, settings JSON) with no cloud dependency except automated translation APIs and optional update checks. External dependencies include Java runtime, Git, protoc, Tesseract OCR, system keyring, and translation web services (Google, Bing).
Electron Packager is a command-line tool and programmable library for packaging Electron applications into platform-specific distributables (e.g., .app, .exe, .deb). It handles Electron binary downloading, app bundling, code signing, notarization, and cross-platform builds (Windows, macOS, Linux, Mac App Store). The architecture centers around a Packager class that orchestrates the process, delegating platform-specific steps to subclasses (macOS, Win32, Linux) and utilizing utilities for dependency pruning, file filtering, ASAR creation, and hook execution. It is actively maintained with a modern TypeScript toolchain and comprehensive test suite.
balenaEtcher is a cross-platform Electron desktop application for flashing OS images to SD cards, USB drives, and similar removable media. In production it provides a wizard-style UI where users select a source image (local file, URL, or an existing drive), choose a target drive, and flash with pre-write safety checks and post-write verification. The architecture is a three-process Electron app: the main process manages windows, menus, auto-updates, and IPC; the renderer runs a React/Redux UI built with TypeScript and styled-components; and a privileged Node.js sidecar process, packaged separately via pkg, performs drive scanning, image metadata extraction, and the actual flashing over a WebSocket connection. Core flashing operations are delegated to etcher-sdk, while OS-specific privilege elevation is handled through sudo on Linux/macOS and UAC on Windows.
Cerebro is an Electron-based desktop launcher application that provides a search interface (triggered by Ctrl+Space) for launching applications, web search, file navigation, calculations, and unit conversions. It features a two-renderer process architecture to maintain UI responsiveness during long-running tasks, a plugin system for extensibility, and uses Redux for state management. The application consists of a main process handling app lifecycle, a main renderer for the UI, and a background renderer for asynchronous plugin initialization and long tasks.
AntSword is an Electron-based desktop application for managing web shells on remote servers, primarily used by penetration testers and authorized security researchers. It provides a tabbed interface for shell management, file browsing, virtual terminal access, database querying, and plugin execution. The core engine in source/core generates HTTP requests from per-language templates (PHP, ASP, ASPX, JSP, etc.), applies configurable encoders/decoders for obfuscation, and parses responses using charset detection. Shell credentials and settings are persisted locally via nedb through modules/cache.js and modules/database.js.
Zui (formerly Brim) is an Electron-based desktop application for network security monitoring and data exploration. It provides a graphical interface to query and visualize data stored in a Zed/SuperDB lake, with a focus on Zeek and Suricata log analysis. The application supports importing packet captures (pcap), structured logs (Zeek TSV, NDJSON, CSV, Parquet), and offers a rich query editor (Monaco), histogram, table/inspector views, and export workflows. The codebase is a monorepo (Yarn workspaces, Nx) with packages for type definitions (`superdb-types`), a Node.js client (`superdb-node-client`), sample data, and an e2e test framework (`app-player`). The architecture follows a domain-driven pattern with handlers and operations, a Redux store with versioned state migrations, and a plugin system for extensibility. While the application is actively maintained and functionally rich, it exhibits some technical drift due to a mix of legacy and modern patterns, a large migration history, and tight coupling between core and plugins.
lx-music-desktop is a cross-platform Electron-based music player (Vue 3 + TypeScript) that aggregates multiple Chinese streaming services (NetEase, Tencent, Kugou, Kuwo, Migu, Baidu, Xiami). It provides music search, playback, playlist management, lyrics (including desktop lyric windows and karaoke-style font rendering), downloads with quality tiers, audio effects (EQ, convolution reverb, pitch shifting), cross-device synchronization over a custom WebSocket protocol, and an HTTP Open API for third-party control. The architecture spans three processes: main (Electron window/tray/IPC, SQLite persistence via better-sqlite3), renderer (Vue app with custom reactive stores and a plugin-based audio engine), and renderer-lyric (dedicated always-on-top lyric window). All built-in music sources were removed in v2.6.0 following a Tencent legal complaint; the app now relies entirely on user-supplied Music API scripts, introducing a sandboxed script runtime with security warnings. The repository is actively maintained (last commit 2026-09-19) but the project is in a transition phase—the maintainer has announced a successor project ('Any Listen'), and the codebase shows signs of legacy accumulation: extensive commented-out code, duplicated components (e.g., MusicSortModal), hardcoded API endpoints/signatures that break frequently, and a custom store implementation diverging from Vuex/Pinia. Despite this, the code is well-organized around provider SDK adapters, composable logic hooks, and a clear main/renderer IPC boundary, with several genuinely reusable patterns.
Koodo Reader is a cross-platform ebook reader application supporting a wide range of formats (EPUB, PDF, MOBI, AZW3, TXT, FB2, CBR/CBZ, MD, DOCX, HTML, etc.). It is built as an Electron desktop app with a React/TypeScript frontend and a separate Go HTTP server for OPDS catalog serving and KOReader sync. The application provides a full-featured reading experience including bookmarks, notes, highlights, text-to-speech (with multiple voice engines), translation and dictionary lookup (via built-in and custom plugins), OCR for scanned PDFs, and cloud sync/backup across many providers (WebDAV, S3, OneDrive, Google Drive, Dropbox, etc.). It also includes a library management system with shelves, tags, search, and import from local files, folders, URLs, and OPDS catalogs. The architecture is a monolith with a clear separation between the Electron main process (Node.js) and the renderer (React), plus an optional Go server for network-facing features. The codebase is large and feature-rich but shows signs of technical debt: widespread use of deprecated React lifecycle methods, heavy reliance on opaque minified libraries (kookit-extra), frequent `as any` type casts, and mixed Chinese/English comments. Despite these issues, the application is actively maintained and offers a robust set of features for ebook enthusiasts.
Rubick is a cross-platform desktop application built with Electron and Vue 3 that serves as an extensible productivity toolbox. Its core functionality includes a global shortcut-triggered launcher (Alt/Option+R) for quick access to applications, files, and folders, a plugin system that treats plugins as installable npm packages, and WebDAV-based cross-device data synchronization via PouchDB. The architecture features a main Electron process managing multiple renderer windows (main search interface, plugin market, detached plugin windows, and tutorial guide) with communication through IPC. Key dependencies include Vue 3, Ant Design UI library, PouchDB for local storage with WebDAV sync, and native modules for global hotkeys and file icons. The plugin system allows users to extend functionality through a built-in market, with plugins stored locally and loaded into isolated BrowserView instances for security.
modV is a desktop application for real-time audio-visual synthesis and effects processing. Built with Electron, Vue.js, and WebGL, it provides a modular environment where users can create chains of visual modules (2D, 3D, shader-based) that react to audio, MIDI, or user-defined parameters. The application features a dual-store Vuex architecture (main and worker processes) to keep the UI responsive while handling intensive graphics and audio processing in a background thread. Key capabilities include audio feature extraction via Meyda, MIDI input mapping, a plugin system for extensibility, and a preset system with seamless state switching. The project emphasizes real-time performance and flexibility for VJs, artists, and live visual performers.
PearPass Desktop is an Electron/React password manager with a local-first architecture: encrypted vaults are stored on-device and synchronized peer-to-peer through Pear Runtime, with no central cloud account. The renderer is a large React application handling vault/record CRUD (logins, credit cards, identities, notes, Wi-Fi, passphrases, custom fields), folders, favorites, TOTP authenticator codes, import/export from other password managers, and extensive settings. The Electron main process spawns a Bare-sidecar vault worklet, exposes a preload bridge, and coordinates secure native messaging with a browser extension. The repo also includes Flatpak/Snap/AppImage/MSIX packaging, an Appling installer, and a Playwright E2E suite. Security is taken seriously: there is an encrypted session handshake (X25519 ECDH, Ed25519 transcript signatures, secretbox, sequence numbers), a method registry separating public vs secure IPC methods, master-password verification, auto-lock, and platform-specific clipboard cleanup. The codebase has extensive Jest unit coverage and Playwright E2E coverage for every record type. However, much of the actual vault crypto and UI kit logic lives in internal @tetherto packages, making this repository primarily application glue around private dependencies. Maintainability is mixed. The README explicitly states development is paused, and there are signs of drift: mixed JS/TS, duplicated attachment/schema logic across many modal forms, a frozen legacy UI component tree, commented-out E2E tests, a likely bug in pairing-token hash construction, and feature stubs marked UNSUPPORTED. It remains a well-organized and functional password manager, but a significant refactor would be needed to fully modernize it.