Frappe Books is a full-featured, offline-first desktop accounting and inventory management application built with Electron, Vue 3, and a custom ORM framework (fyo) on top of SQLite. It supports double-entry bookkeeping, invoicing (Sales/Purchase/Returns), payment processing, stock management (batches, serial numbers, FIFO valuation), Point of Sale (classic and modern layouts), financial reports (Balance Sheet, P&L, Trial Balance, General Ledger, GST reports), loyalty programs, pricing rules, coupon codes, and multi-currency. The architecture is schema-driven: JSON schema files define document structures, and model classes add business logic via formulas, validations, and lifecycle hooks. The backend runs in the Electron main process and exposes IPC APIs for file operations, database access, and auto-updates. The frontend is a reactive Vue 3 SPA with a comprehensive component library. Regional support (India, Switzerland) is implemented through model overrides and schema extensions. The codebase demonstrates strong engineering practices with a layered architecture, but the custom framework introduces some coupling. It is actively maintained with CI/CD, automated tests, and regular patches.
Zulip Desktop is an Electron-based desktop client for the Zulip team chat platform. It wraps the Zulip web application in a native window, providing multi-organization support via tabbed webviews, desktop notifications, tray/dock integration, spellcheck, and automatic updates. The architecture follows a standard Electron pattern with a main process (app/main/index.ts) managing windows, IPC, and system integrations, and a renderer process (app/renderer/js/main.ts) handling the UI, tab management, and settings pages. Communication between processes is facilitated by a strongly typed IPC system (typed-ipc.ts) that defines all channels and ensures type safety. The application persists user preferences and server configurations via JSON files (settings.json, domain.json) with Zod schema validation, and supports enterprise deployment through a global configuration file. External dependencies include Electron, electron-builder for packaging, electron-updater for auto-updates, Sentry for error reporting, and i18next for internationalization. The codebase is well-structured with clear separation of concerns, reusable component patterns, and comprehensive build pipelines for Windows, macOS, and Linux.
Tabby (formerly Terminus) is a cross-platform terminal emulator built with Electron and Angular 15. It serves as a modern replacement for terminal applications like Windows conhost, PowerShell ISE, PuTTY, macOS Terminal, and iTerm. The application provides integrated SSH, Telnet, and serial clients, local shell support (cmd, PowerShell, WSL, bash, etc.), split panes with drag-and-drop, a fully customizable hotkey system, themes, and an encrypted vault for credentials. The architecture is a monorepo of Angular modules (tabby-core, tabby-terminal, tabby-ssh, etc.) that communicate through dependency injection providers. A plugin system allows third-party packages to extend functionality via well-defined abstract classes (HotkeyProvider, ProfileProvider, TerminalDecorator, etc.). The web variant (tabby-web) provides a browser-based SSH/Telnet client but lags behind the desktop version. The codebase is mature with extensive i18n support, CI/CD pipelines, and community contributions, but shows some drift with Angular 15 being several versions behind current and some legacy naming (terminus- prefix).
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.
This repository contains the official IVPN desktop client, a multi-platform VPN application supporting Windows, macOS, and Linux. It is composed of three main components: a privileged Go daemon that manages VPN connections (OpenVPN, WireGuard, V2Ray), firewall (kill switch), DNS (including DNSCrypt-proxy for DoH), split tunneling, and WiFi trusted networks; a Go CLI for command-line control; and an Electron/Vue.js UI for graphical interaction. The daemon and clients communicate over a local TCP JSON protocol with authentication and event push. The codebase demonstrates strong engineering practices: platform abstraction via build tags, a custom ICMP ping library, a reusable logger, a type-safe IPC client library documented for third-party integration, and Windows WFP wrappers for firewall and split tunneling. Build scripts and native projects (Windows kernel driver, macOS helpers) handle cross-platform packaging and signing.
OpenCowork is a desktop AI agent application built with Electron, React, and TypeScript. It enables users to automate tasks through natural language interactions, supporting browser automation (via Playwright), local command execution, image processing, and integration with messaging platforms like Feishu. The application features a modular architecture with separate main and renderer processes, communicating via IPC. Core functionality includes task orchestration, skill-based workflow reuse, scheduling, memory management, and MCP (Model Context Protocol) integration for extensibility. The system emphasizes local-first operation, user control, and reliable execution with fallback mechanisms for unstable automation scenarios.
Image MetaHub is a local-first Electron desktop application for organizing, browsing, and re-generating AI-generated images. It indexes media files in place (no uploads, no moving files) and extracts structured metadata — prompts, models, LoRAs, samplers, seeds, workflows — from 15+ generators including ComfyUI, A1111, InvokeAI, Midjourney, DALL-E, Fooocus, and Adobe Firefly (via C2PA/JUMBF/CBOR parsing). Beyond images it handles video, audio, and 3D model metadata. The app provides tagging, collections, automation rules, ratings, analytics, image comparison with pixel-level diffing, lineage/provenance tracking, and integration with local ComfyUI/A1111 instances for re-generation and upscaling. Pro features (visual search, clustering, batch export) are gated by an offline license system with a 7-day trial and Stripe billing.
Chatbox is a cross-platform desktop AI chat client (Windows/macOS/Linux) built with Electron, React, and TypeScript. It supports 30+ AI providers (OpenAI, Claude, Gemini, DeepSeek, Ollama, etc.) via a unified provider registry and model abstraction layer. The application features agent mode with tool use, sandboxed code execution, MCP server integration, knowledge base RAG, web search, image generation, and a skills marketplace. It uses a hexagonal architecture with ports/adapters in a core package (`@chatbox/core`) that is host-agnostic, and React bindings in `@chatbox/react`. The renderer uses TanStack Router, Zustand/Jotai for state, and Mantine/MUI for UI. The main process handles IPC, OAuth flows, file system sandbox, and analytics. The codebase is large and well-tested (Vitest unit tests, integration tests, contract tests) with a focus on offline-first, local storage, and cross-platform compatibility (desktop, web, mobile via Capacitor). The application is actively maintained with a commercial 'Pro' version that shares code with this open-source Community Edition. Notable engineering patterns include a clean port/adapter separation, in-memory test doubles for all repositories, a session write coordinator that serializes updates and cancels stale queries, a draft tokenization system with web workers, and a provider registry that allows dynamic model discovery. The codebase has some technical debt: multiple UI libraries, legacy migration paths, and commented-out code, but overall demonstrates strong craftsmanship and reusability of its core abstractions.
This repository is the source code for 'Enjoy App', a cross-platform desktop application built with Electron, React, and TypeScript. Its primary function is English language learning, specifically focusing on pronunciation training, shadowing practice, and AI-assisted conversation. The application integrates local speech-to-text (Whisper/Echogarden) and text-to-speech engines alongside cloud-based LLMs (OpenAI, Azure) for chat and translation features. It employs a local-first architecture using SQLite (Sequelize ORM) for data persistence, with synchronization capabilities to a remote backend for backup and community features. The architecture follows a standard Electron pattern with a Main process handling native features, database operations, and media processing (FFmpeg, Echogarden), and a Renderer process serving the React UI. State management is handled via a combination of React Context Providers and custom Redux-like reducers. The codebase includes extensive AI command handlers for tasks like translation, summarization, and pronunciation assessment. While the application is feature-rich and well-structured, it carries significant coupling in media state management and relies heavily on external API contracts for core functionality.
PicGo is a mature, cross-platform Electron desktop application for image uploading, primarily targeted at content creators and developers. Its core workflow allows users to upload images via drag-and-drop, clipboard, file picker, or global hotkey, and automatically copies the resulting URL (in Markdown, HTML, or custom format) to the clipboard. The application supports multiple image hosting providers (e.g., GitHub, SM.MS, Qiniu, Alibaba OSS, Tencent COS, Imgur, S3, WebDAV) via a flexible plugin architecture. A built-in HTTP server enables integration with third-party tools. The renderer is built with React, TypeScript, TanStack Router, Zustand for state management, and a comprehensive UI component library (shadcn/ui style). The main process handles IPC, window management, system tray, global shortcuts, file operations, and a plugin lifecycle. PicGo Cloud integration provides user accounts, configuration sync (with optional E2E encryption), cloud album storage, and usage analytics. The codebase includes extensive internationalization (5 languages), a robust test suite (Vitest), and automated CI/CD for multi-platform builds. While the project has some technical debt (incomplete Vue migration, numerous TODO comments, patched dependencies), it demonstrates strong engineering practices, modular architecture, and a well-documented plugin ecosystem.
Responsively App is an Electron-based desktop application for responsive web development testing. It allows developers to preview a website across multiple device simulators simultaneously (phones, tablets, laptops) with synchronized interactions such as scrolling, clicking, and form input mirroring via BrowserSync. The application includes a built-in MCP (Model Context Protocol) server that exposes automation tools (navigate, screenshot, click, read_page) for AI coding agents like Claude Code and Cursor. It also provides design overlays, color blindness simulation, ruler/guide systems, and screenshot capture. The codebase is structured as a monorepo with three packages: the desktop app (Electron + React + Redux), a browser extension (Manifest V3) to open URLs in the app, and an MCP CLI package published to npm. The architecture follows a main-process/renderer split with IPC communication, extensive E2E tests (Playwright), and a device frame system with pixel-accurate bezel artwork generated from upstream sources.
RedisInsight is a full-stack graphical user interface for managing and interacting with Redis databases. It is built as an Electron desktop application with a React frontend (utilizing styled-components and a custom component library) and a NestJS backend that communicates with Redis instances. The application covers a wide range of Redis features: key-value browser with support for all data types (strings, hashes, lists, sets, sorted sets, streams, JSON, arrays, vector sets), a workbench with a Monaco-based query editor, CLI, pub/sub, slow log, profiler, database analysis with optimization recommendations, cloud integration (Redis Cloud, Azure Cache, Redis Enterprise), Redis Data Integration (RDI) pipeline management, and an AI assistant. The architecture is modular with clear separation of concerns, using repository and strategy patterns extensively. The codebase includes comprehensive CI/CD, end-to-end Playwright tests, and a plugin system for custom visualizations.
Ueli is a cross-platform keystroke launcher built with Electron, TypeScript, and React (Fluent UI). It provides a hotkey-triggered search window that aggregates search results from a modular extension system. Over 20 built-in extensions enable application and file searching, web search, calculator, color conversion, currency conversion, password generation, text processing, and more. The architecture follows a clean separation of concerns: the main process handles OS-specific operations (window management, tray icon, autostart, file icon extraction), a preload script enforces secure IPC via contextBridge, and the renderer provides a responsive React UI. Extensions implement a common contract and are loaded dynamically via a module registry. The codebase is well-tested (vitest), employs dependency injection, and includes localization in 7 languages. While the project is actively maintained and demonstrates solid engineering practices, some platform-specific components (e.g., Linux file searcher) are incomplete or stubbed, and the large extension surface introduces maintenance overhead.
This is a large, production-grade collaborative crafting companion for Final Fantasy XIV, consisting of an Angular web application (with SSR) and an Electron desktop client, plus a NestJS API and Firebase backend. The primary functionality includes crafting list management with tree-based ingredient breakdown, a full crafting rotation simulator, gearset planning with stat calculations and materia optimization, real-time gathering alarms based on Eorzea time and weather, marketboard price tracking via Universalis, inventory capture and optimization, fishing data and cooperative fishing train tool, commission board for player-to-player crafting services, free company workshop and airship/submarine management, island sanctuary workshop optimization, and a crowd-sourced data reporting system (Allagan Reports) for fish/hookset/bite times and desynthesis results. The codebase demonstrates advanced Angular/NgRx patterns, extensive use of RxJS for reactive data flows, a sophisticated lazy data loading system for game data extracted from the FFXIV client, and tight desktop integration via Electron IPC and packet capture. While there are some legacy patterns and a large feature surface that introduces maintenance complexity, the architecture is well-separated into libraries, the core data abstraction (LazyDataFacade, FirestoreRelationalStorage, base dialog components) is highly reusable, and the project remains actively developed with a large user and contributor community.
Zulip is a production-grade, open-source team chat application built as a Django monolith with a real-time Tornado event server. The backend uses Django ORM with PostgreSQL, RabbitMQ for async queue processing (email, push notifications, URL previews), Memcached/Redis for caching and rate limiting, and a custom typed-endpoint decorator pattern for API validation. The frontend is a mix of legacy jQuery/Handlebars and modern TypeScript with Zod schemas, Webpack bundling, and extensive UI components for chat composition, streams, topics, user groups, and settings. The system exposes a REST API (used by mobile and desktop clients), webhook ingestion for 50+ third-party services, and a full billing/support subsystem via Stripe. The architecture is a single monolithic Django application with separate Tornado process for real-time push, alongside queue workers and cron-like management commands. Key entry points include the Django WSGI server, Tornado event server, management commands (e.g., manage.py), and webhook view functions. External dependencies include PostgreSQL, RabbitMQ, Redis, Memcached, Stripe, pgroonga (full-text search), pyvips (image processing), and numerous npm packages.
Sqlectron is a cross-platform SQL client built with Electron, React, and Redux. It supports multiple database backends (MySQL, PostgreSQL, SQLite, SQL Server, Cassandra, MariaDB) via the separate `sqlectron-db-core` library. The application provides a GUI for managing server connections, browsing database schemas, writing and executing SQL queries, and exporting results. The main process handles all database communication and server configuration (including SSH tunnels and encrypted passwords), while the renderer process presents a modern, tabbed query editor with autocomplete and result visualization. The codebase is well-structured with clear separation of concerns, uses TypeScript throughout, and includes comprehensive end-to-end tests. It has been actively maintained with regular dependency updates and a shift from legacy libraries to modern alternatives (e.g., CodeMirror, Tailwind CSS, Radix UI).
Nextron is a CLI tool and scaffolding system that integrates Next.js with Electron for building cross-platform desktop applications using web technologies. It provides a streamlined development experience by orchestrating Next.js dev server, webpack bundling for Electron main and preload scripts, and optional production packaging with electron-builder. The repository contains the core library (CLI, build helpers, webpack configurations) and a rich set of example projects demonstrating integrations with UI frameworks (Ant Design, Chakra UI, Material UI, Tailwind CSS, Emotion, i18next) and features like window state persistence, static export, and custom build options. The architecture is monolithic, centered around a command-line interface with `dev` and `build` commands, and the codebase shows disciplined engineering with TypeScript, ESLint, Prettier, and lefthook. While primarily a development tool, its examples serve as practical templates for Electron+Next.js application patterns.
This repository repackages Anthropic's official Claude Desktop Linux .deb with a comprehensive set of Linux-native enhancements and community features. It applies 48 surgical JavaScript patches (compiled from Nim sources) to the minified Electron bundle, adding custom theme engine with 97 bundled dual light/dark palettes, multi-profile isolation, Quick Entry global hotkey, Computer Use desktop automation backends (X11, wlroots, GNOME, KWin portals), and an in-app Extra settings panel for themes, feature flags, and third-party inference configuration. The project produces packages for Arch (pacman), Debian/Ubuntu (APT), Fedora/RHEL (RPM), NixOS (flake), and AppImage, with automated CI that polls upstream every 2 hours, validates patch integrity, and publishes signed repositories. The architecture is a patch overlay on a third-party Electron desktop app. Patches are organized into three groups: linux (31 patches, always-on), core (7 patches, infrastructure), and community (10 patches, opt-in). A Nim-based build system compiles each patch into a native binary that performs regex-based transformations on the minified JS, with strict idempotency checks that fail the build if any pattern doesn't match. The patching system also handles upstream code-split chunks and concatenates/splits them as needed. The theme engine injects CSS custom properties via Electron's insertCSS, supports live reload via file watcher, and includes a full browser UI (theme picker SPA) with search, keyboard navigation, and wallpaper-driven generation via matugen. While the codebase demonstrates high engineering craftsmanship—consistent IPC validation, atomic config writes, robust fallback chains for Computer Use backends, and a reproducible build workflow with byte-identical artifact checks—it is tightly coupled to a single upstream app's minified bundle shape and DOM structure. The 48 patches are a significant maintenance burden that must be re-validated on every upstream release. However, the project is actively maintained, with automated CI catching most regressions, and several patterns (spinner injector, theme engine, config utilities) could be extracted for reuse in other Electron or web applications.
MarkText is a cross-platform desktop markdown editor (Electron + Vue 3) powered by the Muya WYSIWYG engine. It provides real-time rendering of CommonMark, GFM, and extended syntax including KaTeX math, mermaid/plantuml diagrams, footnotes, tables, task lists, and 30+ themes. The monorepo contains four packages: `desktop` (Electron shell with IPC, preferences, spellcheck, export), `muya` (TypeScript core editor with block-based state, snabbdom rendering, undo/redo via ot-json1, clipboard, and floating UI components), `muyajs` (legacy JavaScript engine, still present for partial feature parity), and `website` (Next.js documentation site). The architecture follows a block tree pattern where each block type (paragraph, heading, list, table, etc.) is a subclass with consistent parent/content interfaces. Communication between the Electron main and renderer processes uses typed IPC channels. The codebase demonstrates strong software engineering practices with extensive unit and e2e test coverage (Playwright, Vitest), reproducible builds (pnpm monorepo), and a focus on regression testing for edge cases. However, the ongoing migration from the legacy `muyajs` engine to the new `muya` engine introduces some code duplication and technical drift, and some modules retain prototype-style JavaScript alongside modern TypeScript classes.
Project AIRI is a comprehensive multi-platform AI agent and virtual character platform. It functions as a desktop application (Electron), web interface (Vue.js), and mobile client (Capacitor), centered around an LLM-powered 'brain' that controls 3D avatars (Live2D, VRM, Spine) and interacts with the physical world via computer automation (MCP) and gaming bots (Minecraft). The system integrates speech-to-text, text-to-speech, and vision processing to create a conversational agent capable of real-time interaction. It features a robust backend server (Hono/PostgreSQL) for authentication, billing (Flux currency), and provider routing, alongside a plugin system allowing third-party extensions to inject functionality. Architecturally, it is a large monorepo managed by pnpm and Turbo, separating concerns into apps, packages, services, and plugins. The codebase demonstrates significant engineering effort in managing complex state across Electron IPC, WebSocket communication, and local-first data synchronization. It implements custom concurrency ledgers for billing, GPU resource coordination for model inference, and sandboxed execution environments for AI planning tasks. The system is actively developed with frequent commits and a large plugin ecosystem, though it relies heavily on bleeding-edge dependencies and beta libraries. The platform solves the problem of creating autonomous virtual characters with agency, moving beyond simple chatbots to agents that can control computers, play games, and maintain persistent memory. It exposes a standardized provider registry for AI models and a plugin SDK for extensibility. While the architecture is sophisticated, the reliance on rapidly evolving AI standards (MCP, LLM APIs) and bleeding-edge Node.js versions introduces technical debt and maintenance overhead.