Orca is a production-grade Electron desktop application that functions as an integrated development environment (IDE) and orchestrator for multiple AI coding agents (Claude Code, Codex, Gemini, etc.). It manages isolated worktrees (Git, SSH, WSL) as execution environments, provides a full-featured terminal emulator (xterm-based), a browser pane, rich markdown editing, and deep source control integration (GitHub, GitLab, Linear, Jira). The system is architected as a monorepo containing the Electron desktop app (main/renderer/preload), a React Native mobile companion, a Node.js CLI, and cloud services (relay, push) for mobile pairing and notifications. Communication between processes is handled through a strict, Zod-validated RPC contract, ensuring type safety across the wire. The codebase demonstrates exceptional engineering discipline with a massive test suite (Vitest, Playwright), extensive CI/CD pipelines, and a strong emphasis on platform compatibility (macOS, Windows, Linux, WSL, Wayland). It is actively maintained with daily releases and a clear focus on managing technical debt through explicit legacy compatibility shims and migration paths.
drawio-desktop is an Electron-based desktop application that wraps the core draw.io diagramming editor (included as a git submodule). It provides a fully offline diagramming experience with a security-first design: Content Security Policy prevents remote script execution, IPC is gated through contextBridge with sender validation, and file operations enforce path authorisation against symlink attacks. The application supports CLI-based batch export (PNG, PDF, SVG, HTML, XML) with a hand-rolled argument parser, per-window file watching, auto-update via electron-updater, and platform-specific builds for Windows (x64/arm64, MSI, NSIS, APPX), macOS (dmg, zip, Quick Look preview), and Linux (AppImage, deb, rpm, snap). The architecture is a monolithic Electron main process (src/main/electron.js) communicating with the renderer (drawio submodule) through a secure IPC bridge. The codebase demonstrates high craftsmanship in security-sensitive areas such as backup file writes using exclusive temp files and rename, CLI export symlink handling, and per-window file watch registry. It is actively maintained with recent commits and comprehensive CI/CD pipelines.
AnyType is a personal knowledge base application built with Electron, React, and TypeScript. It features a block-based system for creating and connecting information (text, databases, kanban, calendar, custom types) with offline-first storage and optional peer-to-peer synchronization. The application uses a modular architecture with a Go-based middleware (anytype-heart) communicating via gRPC, MobX for state management, and an extensive reusable UI component library. It includes browser extension support for web clipping and AI agent extensibility.
This repository is an unofficial, community-maintained Microsoft Teams desktop client for Linux (and cross-platform). It wraps the Microsoft Teams web application in an Electron shell, providing native desktop integration features that the web client lacks on Linux, such as system tray notifications, custom backgrounds, screen sharing with preview, WebAuthn/FIDO2 hardware security key support, MQTT integration for home automation, multi-account profiles with isolated sessions, and configurable themes. The architecture follows a typical Electron main/renderer process split with heavy use of IPC for communication. The main process manages windows, configuration, menus, tray, auto-updates, and integrates with system services (D-Bus for KDE/GNOME, Flatpak portals, Snap confinement). The renderer process uses preload scripts to inject browser tools that intercept WebRTC constraints, monitor DOM mutations, and patch Teams' internal React services for features like meeting start detection, speaking indicators, and token caching. The codebase is well-structured with a modular design, extensive unit and E2E tests, automated CI/CD pipelines, and formal architecture decision records (ADRs). It is actively maintained with frequent releases, responsive issue triage, and a strong focus on Linux compatibility, though it also supports Windows and macOS.
Insomnia is a comprehensive API client built on Electron that supports HTTP, WebSocket, Socket.IO, gRPC, and MCP protocols. It features a modular architecture with separate packages for the main application, data layer, CLI tool, analytics, and scripting environment. The application provides API design, debugging, testing, and collaboration capabilities through workspace/project organization, environment management, import/export functionality, cloud sync, Git integration, and a plugin system. Built with React and TypeScript, it uses NeDB for local data storage and implements sophisticated security measures for secret management and plugin sandboxing.
This is a cross-platform desktop media player/manager application built with Electron, Vue 3, and TypeScript. It aggregates content from various sources (local files, online sites, IPTV streams) and provides playback through multiple backends including VLC, xgplayer, and artplayer. The application features media library management, history tracking, favorites, live TV support, subtitle/danmaku functionality, proxy settings, cloud synchronization, AI integration, and a plugin/extension system. It includes laboratory tools for cryptographic operations, content analysis, and experimentation. The architecture separates main and renderer processes with Fastify-based internal APIs, uses Pinia for state management, and employs worker pools for CPU-intensive operations.
Mockoon is a multi-platform API mocking tool that runs mock servers locally or remotely. It is built as a monorepo with six npm packages: @mockoon/commons (shared models, migrations, OpenAPI converter), @mockoon/commons-server (core Express-based mock server engine with templating and response rules), @mockoon/app (Electron desktop application with an Angular renderer), @mockoon/cli (oclif-based command-line interface), @mockoon/cloud (cloud sync library), and the deprecated @mockoon/serverless wrapper. The architecture cleanly separates the core server logic from the delivery mechanisms. The MockoonServer class provides an HTTP/HTTPS server with a sophisticated response rule engine, a Handlebars templating system with over 100 custom helpers (including deep Faker.js integration), CRUD operations on data buckets, WebSocket support, proxy mode, and a full admin API. The desktop app uses a Redux-like state management pattern with RxJS, ensuring predictable and testable UI state transitions. The codebase demonstrates high craftsmanship in several areas. The ResponseRulesInterpreter is a self-contained DSL for matching HTTP requests to mock responses. The TemplateParser provides an extensible helper registration system. The data migration system in commons is a textbook example of handling schema evolution for JSON-based data models. The project is actively maintained with a robust CI/CD pipeline, though it carries some technical debt such as a deprecated serverless package and disabled strict TypeScript mode in the desktop app.
HiKid is an Electron desktop application designed for children in non-English-speaking countries to practice English speaking and listening. It features a local voice conversation pipeline where user speech is processed through SoX recording, local ASR/Qwen3-ASR-0.6B for speech-to-text, Ollama/LLM for response generation, and local TTS/kitten-tts-server for speech synthesis, all playing back through SoX. The application centers around an animated Kitten character that changes expression based on conversation state (idle, listening, thinking, speaking, interrupted). Key features include customizable AI configuration (name, system prompt, LLM parameters), speaking games with rule explanations, automatic dependency checking and model downloading, subtitle toggle for conversation text, and both press-and-hold and VAD voice activation modes. The architecture follows the standard electron-vite three-process structure with clear separation between main process (handling audio/Agent logic), preload script (IPC bridge), and renderer process (React SPA).
Bruno is a comprehensive API client and testing tool built with Electron, React, and Redux. It provides a full-featured interface for creating, sending, and analyzing HTTP/WebSocket/gRPC/GraphQL requests, similar to Postman but with an open-source core. The application features a modular architecture with separate packages for the GUI (bruno-app), Electron main process (bruno-electron), CLI (bruno-cli), request handling (bruno-requests), file storage (bruno-filestore), and shared utilities (bruno-common). Key capabilities include environment and variable management with secure secret handling, pre-request and test scripting using a custom BruJS runtime, collection organization and workspaces, import/export from formats like Postman, OpenAPI, and Insomnia, mock server functionality, and code generation from requests. The UI uses styled-components for theming with light/dark/system themes, and incorporates advanced features like AI-assisted request building and OpenAPI synchronization. The codebase demonstrates strong engineering practices with extensive unit and end-to-end testing, TypeScript throughout, and a clean separation of concerns between the main and renderer processes via IPC. Notable reusable components include a secure variable interpolation system, cross-platform detection utilities, persistent state hooks, and a worker-offloaded file format parser.
Logseq is a privacy-first, open-source knowledge management platform built as a monorepo containing an Electron desktop app, Capacitor-based mobile apps (iOS/Android), a web app, and a Node.js db-sync server. The codebase is predominantly ClojureScript (CLJS) with React/Rum for the UI, DataScript for the in-memory graph database, and SQLite (via better-sqlite3 and sqlite-wasm) for persistence. It uses shadow-cljs for CLJS compilation, webpack for JS bundling, and Tailwind CSS for styling. A separate OCaml-based CLI (logseq-cli) built with Melange provides graph inspection, sync, and CRUD operations against the same db-worker-node backend. The architecture separates concerns into deps/ subprojects (db, outliner, graph-parser, db-sync, common, publishing, shui) that are compiled as separate shadow-cljs targets and shared across Electron, browser, mobile, and CLI runtimes. The system has two graph types: file-based graphs (Markdown/Org) and DB graphs (SQLite-backed with DataScript in-memory querying). DB graphs enable real-time collaboration (RTC) via a Cloudflare Worker-based sync server (deps/db-sync) using WebSockets and D1 SQLite. The db-worker-node is a long-lived Node.js process that manages SQLite connections and sync state, communicating with the UI via a thread-api IPC mechanism. The outliner module handles block tree operations with structural invariants, while the graph-parser handles Markdown/Org parsing via mldoc. The publishing module generates static HTML sites from graphs. Key architectural patterns include: missionary for reactive async flows, promesa for promise composition, malli for schema validation, datascript for Datalog queries, and a component-based UI with Rum/React. The codebase has extensive test coverage via cljs.test, Playwright E2E tests (clj-e2e), and Python-based CLI E2E tests (cli-e2e). The repository is actively maintained with recent commits, 43k+ stars, and active issue triage, though the large monorepo complexity and multi-language surface (CLJS, OCaml, Swift, Kotlin, Python, JS) create maintenance challenges.
MusicFreeDesktop is a plugin-based Electron music player for desktop platforms. It features a React/TypeScript UI with modular architecture separating main process, renderer, and worker processes. Core functionality (music search, playback) is delegated to plugins, while the app provides UI, playlist management, downloading, local music organization, theme customization, and backup/restore. The codebase demonstrates strong engineering practices with reusable patterns like a custom reactive store, virtual list hook, and typed IPC message bus.
PiDeck is an open-source Electron desktop application that serves as a comprehensive workbench for AI coding agents, primarily wrapping the `pi` coding agent and the DeepSeek Harness (DSH) backend. It provides a rich session-centric chat workspace with features including multi-project management, Git integration, a built-in terminal, voice transcription, image generation, scheduled automation tasks, a desktop pet companion, and extensive configuration options. The application supports importing sessions from other tools like Claude, Codex, Cursor, and OpenCode, and offers a web service variant for remote access. Architecturally, PiDeck follows the standard Electron pattern with a main process (Node.js services, IPC handlers, filesystem operations), a preload script for secure IPC bridging, and a renderer process built with React 19, TypeScript, Jotai for state management, and Tailwind CSS v4 with shadcn/ui-style components. The codebase is organized into `src/main/` for backend services, `src/renderer/` for the UI, and `src/shared/` for cross-process types and utilities. Key entry points include the main process index, renderer bootstrap, and numerous IPC modules that validate inputs and delegate to domain services. Data flows center on session files stored in JSONL format (for pi) or compressed JSONL (for DSH), with model catalogs, usage statistics, and configuration persisted in user data directories. The application manages multiple backends through a unified session catalog, with runtime state synchronized via IPC events and Jotai atoms. External dependencies include the pi-coding-agent CLI, DSH runtime packages, node-pty for terminal emulation, whisper.cpp for local speech-to-text, and electron-updater for cross-platform updates. The codebase demonstrates strong engineering practices with extensive unit tests (node:test), Playwright E2E tests, pure-function modules extracted for testability, and consistent IPC boundary validation patterns.
SiYuan is a privacy-first, local-first personal knowledge management system with a block-based WYSIWYG editor, AI assistant integration, cloud sync, and a plugin ecosystem. It is architected as a Go kernel (Gin HTTP API + WebSocket) paired with a TypeScript/Electron frontend, supporting desktop (Windows, macOS, Linux), mobile (Android, iOS, HarmonyOS), and browser/Docker deployment. The kernel handles all data operations: block tree persistence as JSON `.sy` files, SQLite indexing with FTS5 and SQLCipher encryption, attribute-view databases (tables, galleries, kanban), backlink resolution, full-text search, and sync via multiple providers (SiYuan cloud, S3, WebDAV, LAN). The frontend provides a rich editing experience with Markdown, LaTeX, Mermaid, mind maps, PDF annotation, flashcards (FSRS), and an agent chat interface. External dependencies include the Lute Markdown parser, dejavu sync library, Pandoc for document conversion, and PDF.js for PDF rendering. The system exposes a comprehensive REST API with contract-based validation and auto-generated TypeScript types, enabling third-party integrations and a community marketplace for plugins, themes, and templates.
Presenton is an AI-powered presentation generation platform that allows users to create presentations from text prompts, document uploads, or template selections using multiple LLM and image providers. The application features a monorepo architecture with a FastAPI backend, Next.js frontend, and Electron desktop client. Key capabilities include AI-driven outline and slide generation, visual slide editing, document processing via LiteParse, export to PPTX/PDF formats, chat-based presentation refinement, and community template sharing. The system demonstrates strong engineering practices with modular service architecture, secure handling of sensitive data, and reusable components for configuration management, document conversion, and provider abstraction.
RohanKar Launcher is a desktop game launcher built with Electron that allows users to browse, download, install, and launch games from a curated Archive.org collection. The application features a polished UI with game library browsing, detailed game information panels, download management with progress tracking, game launching with executable detection, playtime tracking, favorites, collections organization, controller/gamepad support, Steam integration, and automatic updates. It uses SQLite for persistent storage and implements intelligent caching for thumbnails and efficient file system operations.
Upscayl is a cross-platform desktop application for AI-powered image upscaling, built with Electron and Next.js. It uses Real-ESRGAN models via the ncnn inference engine (Vulkan backend) to upscale images by 2x-4x. The application provides a rich UI with model selection, batch processing, double upscaling, custom model support, and extensive settings (GPU selection, tile size, TTA mode, metadata preservation). It also includes a cloud API (Upscayl Cloud) for server-side upscaling, documented via OpenAPI. The codebase is well-structured with clear separation between Electron main process and Next.js renderer, using Jotai for state management, Radix UI primitives, and a comprehensive localization system supporting 17 languages. While primarily an application, it contains pre-trained neural network model files (.param, .bin) that are research artifacts, giving it a hybrid character.
MindsHub Cowork is a platform superproject that orchestrates four independent submodules into a unified AI workspace for knowledge workers. The repository itself contains no application logic — it's a pure orchestration layer using git submodules (frontend: Electron/Vite app, backend/core_api: FastAPI server, backend/core_agent: Anton autonomous agent, backend/data-vault: data engine). The superproject provides a sophisticated developer workflow via its Makefile: per-developer branch selection through a gitignored dev.env, dual run paths (local source with hot-reload vs uv-tool-installed desktop server) that follow the same refs, deliberate pin management via 'make pin'/'make baseline', and a nuclear 'make flush' for complete environment reset. Submodules are configured with 'ignore = all' so branch work never pollutes the parent git status. The Docker setup uses multi-stage builds with uv for Python and nginx for the web SPA. The REST API (documented in docs/api.html) exposes conversations, projects, artifacts, schedules, files, connectors, memories, skills, scratchpads, and search — all backed by a local SQLite database. This is hybrid in that it manages both a desktop (Electron) and web (SPA) frontend against the same API, but the dominant character is application orchestration.
TriliumNext/Trilium is a full-stack, cross-platform hierarchical note-taking application with rich text editing, LLM integration, sync, encryption, and a plugin-based architecture. The monorepo contains a Node.js Express server (SQLite backend), a Preact/React SPA client, an Electron desktop wrapper, a standalone browser-SQLite-WASM build, and a Capacitor mobile app. The system manages notes as a tree with cloning, attributes, relations, and multiple content types (text, code, mind maps, canvases, spreadsheets, calendars, etc.). It provides custom CKEditor5 plugins for math, footnotes, mermaid diagrams, and AI assistance, as well as a full-featured LLM chat with tool execution and skill sheets. The codebase is well-tested with over 2000 spec files, uses modern TypeScript and pnpm workspaces, and includes comprehensive import/export (Evernote, OneNote, Obsidian, Notion, Google Keep, OPML, Markdown, HTML) and sync capabilities. Key architectural patterns include a provider abstraction for platform-specific services (crypto, zip, messaging, clipboard), a component-based widget system on the client, and a centralized entity cache (becca/froca) that is synchronized via WebSocket.
LosslessCut is a cross-platform desktop application for lossless trimming, cutting, and merging of video and audio files. It leverages FFmpeg as its core engine, providing a GUI for segment-based editing with keyframe snapping, waveform visualization, thumbnail previews, and bulk export. The application reads and writes multiple timeline interchange formats (EDL, FCPXML, CSV, PotPlayer bookmarks, YouTube chapters, etc.) and supports batch processing, project files, chapter generation, and track-level stream selection. The architecture follows the Electron pattern: a main process (Node.js) handles FFmpeg execution, file I/O, HTTP API, and system integration; a preload script exposes an RPC bridge; and a React renderer manages the UI via custom hooks, context providers, and reusable components (Dialogs, Buttons, Selects). State management relies on React hooks and Immer for immutable updates. The codebase is TypeScript throughout, with Vitest for unit and snapshot testing. Key entry points include the main process entry at `src/main/index.ts`, the renderer entry at `src/renderer/src/index.tsx`, and the FFmpeg wrapper at `src/main/ffmpeg.ts`. Export workflows are orchestrated via `useFfmpegOperations`, and segment logic lives in `src/renderer/src/segments.ts` and `src/renderer/src/edlFormats.ts`. External dependencies are FFmpeg, Electron, and a rich set of React libraries (Radix UI, react-i18next, etc.). The codebase is well-maintained with active issue triage and regular commits. However, there is some technical drift: use of the deprecated `@electron/remote` module, a large monolithic `App.tsx` component, and reliance on manually bundled FFmpeg binaries. Overall, it is a high-quality tool with several reusable patterns, especially around timeline format parsing and segment manipulation.
macintosh.js is a desktop application that emulates a 1991 Macintosh Quadra running Mac OS 8 using Electron and a WebAssembly port of the Basilisk II emulator. The architecture consists of three main components: the Electron main process handling application lifecycle and system IPC, the renderer process managing the UI and user input via canvas, and a WebWorker running the emulator core. Communication between threads uses SharedArrayBuffers and Atomics for synchronized access to video, audio, input, and ethernet data. The application provides virtual disk storage through a host folder mapping and basic ethernet networking via UDP broadcast for local AppleTalk communication.