TidGi-Desktop is a cross-platform Electron application that integrates TiddlyWiki (a personal wiki) with AI agent capabilities, Git synchronization, and modern desktop features. It allows users to manage multiple workspaces (folder-based or single-file HTML wikis), sync with Git remotes, and interact with AI agents for chat, tool execution, and knowledge management. The architecture is Electron multi-process with main process, renderer processes (multiple windows), and a utility process for wiki worker. Services are wired via Inversify DI container and communicate via typed IPC (electron-ipc-cat). Key entry points include src/main.ts (Electron main), src/renderer.tsx (React renderer), src/services/agentInstance/ (AI agent lifecycle), src/services/wiki/ (wiki management), and src/services/git/ (Git operations). External dependencies include TiddlyWiki, Git (via dugite), SQLite (TypeORM), various AI SDKs (OpenAI, Anthropic, etc.), OAuth providers, and system-level integrations. The codebase is well-structured with a service-oriented architecture, extensive test coverage (unit, E2E, BDD), and a rich preference system driven by Zod schemas. It demonstrates high craftsmanship in areas like AI prompt concatenation, tool registration, and file system watching, though some modules are tightly coupled to the application's domain.
ReNative (rnv) is a cross-platform development CLI tool and framework that enables building applications for mobile (iOS, Android), web, TV (Tizen, webOS, Fire TV, Android TV, tvOS), desktop (macOS, Windows, Linux, Electron), wearables, and consoles from a single codebase. The system uses a monorepo architecture with modular packages: a core library (`@rnv/core`) providing configuration merging, plugin management, template injection, and task orchestration; platform-specific engines (`@rnv/engine-rn`, `@rnv/engine-rn-electron`, `@rnv/engine-rn-next`, etc.) that define build logic and native project templates; SDK packages (`@rnv/sdk-android`, `@rnv/sdk-apple`, `@rnv/sdk-tizen`, etc.) for platform-specific tooling like device management and code generation; and a CLI entry point (`rnv`) that dispatches commands to registered tasks. The primary data flow involves reading hierarchical configuration files (`renative.json`, `appConfigs/`), merging them with plugin definitions and engine defaults, injecting placeholders into platform templates (e.g., AndroidManifest.xml, Xcode project files, Webpack configs), and then invoking native build tools (Gradle, Xcode, Webpack, etc.) to produce deployable artifacts. External dependencies include React Native, Electron, Next.js, Webpack, and platform SDKs (Android SDK, Xcode, Tizen SDK, webOS SDK). The framework also includes a telemetry module, Docker integration, and a build hooks system for custom pre/post-publish scripts.
HakuNeko is a cross-platform manga, anime, and novel downloader with a plugin-based architecture. It scrapes content from hundreds of websites using a decorator-driven pattern that allows declarative extraction of manga, chapters, and pages. The application supports multiple frontends (Svelte-based Classic and Fluent-core), desktop runtimes (Electron and NW.js), and includes features like bookmark management, download queues, image descrambling, DRM decryption, and anti-scraping evasion. The core engine provides reusable abstractions for task pooling, rate limiting, storage, and platform-specific IPC. While the codebase is large and actively maintained, it shows signs of technical drift through legacy stubs, hardcoded secrets, and fragile anti-scraping logic that requires constant updates as target websites change.
Electron Router DOM is a library that facilitates the integration of react-router-dom with Electron applications, enabling window-based routing where each Electron window can have its own routing configuration. The library handles the complexities of loading URLs in development versus files in production, provides type-safe APIs for passing data between main and renderer processes via query parameters, and abstracts away the low-level Electron window management details. It follows a clean architecture with clear separation between main process utilities (registerRoute function) and renderer process components (Router component), supported by shared TypeScript types and utility functions. The library is designed to improve developer experience by eliminating manual management of Electron's loadURL and loadFile methods while maintaining compatibility with react-router-dom's routing patterns.
Prompt Optimizer is a multi-platform AI prompt optimization tool that helps users craft better prompts for large language models (LLMs) and image generation models. The system supports web (Vue 3 + Naive UI), desktop (Electron), Chrome extension, MCP server, and Docker deployment via a pnpm monorepo. Core workflows include system/user prompt optimization, evaluation with structured compare (pair-judge, synthesis), image generation (text2image, image2image, multi-image), variable extraction/value generation, a template system with 40+ built-in bilingual (zh/en) templates, and smart favorites with resource-aware asset management. The architecture cleanly separates framework-agnostic core services (LLM adapters, evaluation, storage, template processing) from UI composables and Electron proxies, using adapter, registry, and factory patterns extensively. A notable strength is the comprehensive test infrastructure spanning unit (Vitest), integration (real LLM API helpers gated by environment flags), and E2E (Playwright with VCR record/replay). Weaknesses include significant template duplication (bilingual files maintained separately), IPC fragility between Electron main/renderer, provider adapter maintenance overhead (16+ text adapters, 6+ image adapters), and some dead/deprecated code paths carrying legacy migration layers.
MQTTX is a cross-platform MQTT 5.0 client tool developed by EMQ, available as a desktop application (Electron + Vue), a web application (Vue), and a command-line interface (Node.js). It allows users to connect to MQTT brokers, publish and subscribe to topics, inspect messages, and manage connections with support for MQTT 5.0 features, TLS, WebSocket, and various payload formats (JSON, Base64, Hex, CBOR, MsgPack, Protobuf, Avro). It also includes an AI Copilot for MQTT assistance, a dashboard with real-time widgets, and scripting capabilities for payload transformation. The desktop app uses Electron with Vue 2, Element UI, TypeORM with SQLite for persistence, and MQTT.js for MQTT protocol. The web app shares many Vue components but uses lowdb/LocalStorage. The CLI is a separate Node.js package with its own test suite. The codebase is organized into shared utilities, database services, Vue components, and AI integration modules. Key entry points include src/background.ts (Electron main process), src/main.ts (render process), cli/bin/index.js (CLI), and web/src/main.ts (web app). Data flows involve MQTT connection lifecycle, message buffering via RxJS, payload conversion pipelines, and database persistence for messages, subscriptions, and settings. External dependencies include MQTT.js for MQTT protocol, TypeORM for database ORM, Electron for desktop, Vue 2 and Element UI for UI, Monaco Editor for code editing, ECharts for charts, and various AI SDKs (OpenAI, Anthropic, etc.) for the Copilot feature. The project also includes custom patches for third-party libraries (Monaco clipboard, MCP SDK, Azure SDK). The CLI depends on commander, chalk, and @faker-js/faker for simulation. While primarily an application, MQTTX includes data-oriented features such as message history querying with SQL recursive CTEs, topic tree persistence, data export/import in multiple formats, and IoT data simulation scenarios. These elements serve the application's debugging and testing purpose but demonstrate data engineering patterns.
NovelForge is an AI-assisted long-form novel writing desktop application built with Electron, Vue 3, and FastAPI. It provides a card-based content management system where each story element (characters, scenes, chapters, items, concepts) is stored as typed cards with JSON Schema validation. The core differentiator is a custom workflow engine that uses a code-style DSL with marker comments (`#@node`) to define automation flows, supporting triggers, async execution, pause/resume, and streaming SSE progress. AI integration is deep: configurable LLM providers (OpenAI, Google, Anthropic, Qwen), structured generation via instruction streams (LLM outputs JSON instructions that the frontend executes incrementally), memory extraction from text into cards and a knowledge graph (dual backend: SQLModel or Neo4j), and a context assembly system with a rich template language. The frontend features a dynamic form renderer from JSON Schema, an inspiration assistant with tool-calling agents, a workflow agent that can autonomously edit workflow code via patches, and a chapter editor with AI continuation, polish, and review. The system is designed for professional novelists and supports full project lifecycles from tags and outlines to chapter drafts and quality reviews. The architecture is a typical two-tier application: the backend exposes RESTful APIs and SSE streams; the frontend is a single-page Vue 3 app bundled as an Electron desktop application (with web compatibility via mock). Notable engineering strengths include the workflow node registration pattern, the expression evaluator with safe eval, the memory extractor registry, and the dynamic form system—all of which are cleanly abstracted and potentially reusable across projects. The codebase is actively maintained, with regular commits, well-organized modules, and comprehensive bootstrap initialization for built-in prompts and card types. However, some features are experimental (workflow agent auto-patching), the custom DSL is format-sensitive, and the heavy reliance on LangChain may introduce version lock-in.
This repository is a TypeScript-based web library designed for browser screenshot capture and annotation. It functions as a plugin that initializes a DOM overlay, captures screen content via multiple strategies (WebRTC, html2canvas, DOM rendering), and provides a rich annotation interface for drawing shapes, text, and cropping. The architecture is monolithic, bundling into UMD, ESM, and CommonJS formats via Rollup, and utilizes MobX for reactive state management across canvas elements and UI components. The system relies on a core entry point in `src/main.ts` which exports the `ScreenShot` class. Data flows from the source manager selecting a capture strategy, rendering to an HTML5 Canvas, and then managing user interactions through a centralized store system. External dependencies include `html2canvas` for DOM capture, `nanoid` for ID generation, and `mobx` for state. The codebase includes comprehensive unit testing via Jest and E2E testing via Playwright, indicating a focus on reliability. While the library is well-structured with clear separation of concerns between application logic, canvas features, and shared utilities, it is tightly coupled to the browser environment and specific canvas element types. The presence of a `TEST_IMPROVEMENT_PLAN.md` suggests ongoing refinement of test coverage, but the core architecture remains stable and functional for its intended domain of web-based screenshot tools.
Steam Achievement Notifier (SAN) is a feature-rich Electron desktop application that monitors Steam and RetroAchievements unlock events and displays highly customizable on-screen notifications. It leverages the Steamworks API for real-time achievement tracking without requiring an API key, and integrates with RetroAchievements via emulator log file parsing. The application provides extensive customisation – multiple notification presets (consoles, Steam Deck, custom), per-type themes (colors, fonts, icons, glow, masks, positions), screenshot overlays, streaming overlays for OBS, Discord webhook posting, game completion timer, and a diagnostics troubleshooter. Architecture is multi-process: a main process handles window management and IPC, a renderer process displays the settings/customiser UI, a worker process continuously polls Steam for game state and achievements, and a RetroAchievements worker monitors emulator logs. Communication is event-driven with well-defined IPC channels. The project includes Rust native modules for keypress simulation, HDR screenshot capture, and high-performance process watchers, bundled as precompiled binaries. The codebase is actively maintained with regular releases, comprehensive localization (25+ languages), and detailed inline documentation (tooltips). While architecturally sound with clean separation of concerns, some modules (e.g., sanhelper.ts) are monolithic and tightly coupled to the application's config and UI, which may hinder isolated reuse. The translation files are large and duplicative, requiring coordinated updates across languages.
This repository is an AI-powered stock research platform that combines a full-stack application (FastAPI backend, React/TypeScript frontend, Electron desktop app) with extensive data/research capabilities. It ingests market data from over a dozen providers (Tushare, yfinance, AkShare, etc.) with priority-based fallback chains, performs AI analysis via LiteLLM (supporting multiple LLM providers), and generates structured research reports, decision signals, and backtesting results. The platform supports multi-agent discussions, strategy screening, portfolio management, alerts, and multi-channel notifications (WeChat, Feishu, Telegram, email, etc.). It covers 13 international markets with trading calendars and market phase detection. The architecture is a monolith with modular services, using SQLite per-workspace isolation. While primarily an application, it has strong data/research characteristics including a screening engine derived from AlphaSift, decision signal lifecycle with outcome tracking, and skill opinion weight calibration. The codebase is well-structured with extensive tests, CI/CD, and reusable patterns like the data fetcher base class and notification sender template.
PlumeLens (鉴翎) is a local bird photo analysis and culling workstation for bird photographers. It uses on-device ML models—YOLOv26l for detection, a custom 11-keypoint pose estimator, CLIPIQA+/HyperIQA for quality assessment, and DINOv3 with LoRA adapters for species classification—to process photos without any cloud upload. The system scans user photo directories (read-only), performs detection, pose estimation, quality scoring, and species identification, then presents a grading interface (reject/record/usable/select) with manual review and species override capabilities. Export supports JPG/RAW with XMP sidecars, and a geographic archive module visualizes species sightings on an interactive map with conservation status. The architecture is a desktop application split into an Electron+React frontend and a Python FastAPI backend. The backend runs as a subprocess managed by Electron, communicating via REST APIs and Server-Sent Events for progress. The ML pipeline is orchestrated in `engine/pipeline/manager.py` with ONNX Runtime and PyTorch inferences. The frontend uses React 19, TanStack Query, Zustand, and a virtualized grid for handling large photo sets. The application is packaged for macOS (arm64) via electron-builder and PyInstaller. While the primary delivery is a desktop application, the repository also contains extensive model training scripts, evaluation frameworks (`evals/`), and dataset preparation utilities, making it a hybrid project with significant research and data engineering components. Model integrity is enforced via SHA-256 manifest verification at startup, and all inference is deterministic with versioned pipeline hashes to invalidate caches on updates.
OysterWorkflow is an open-core desktop application (Electron + React) that records a user's computer activity via Screenpipe (screen, audio, UI events), then uses multi-stage LLM calls to extract reusable, structured 'skills' (workflow graphs) that AI agents (Codex, Claude, Hermes) can execute. The system provides a full lifecycle: capture → ingest → normalize → segment → LLM-based workflow discovery → skill extraction → workflow graph generation → quality evaluation → installation into agent skill directories → execution via MCP or Hermes CLI. It also includes a cloud sync layer (Supabase), a marketplace (ClawHub), and a local runtime HTTP server for the UI. Architecturally, it is a hybrid monolith with clear module boundaries: a desktop shell (Electron main process), a local runtime server (Express), a CLI (commander), a React UI (Vite + React Flow), and a product state layer (SQLite-backed with cloud sync). The codebase is TypeScript-first, ESM-only, and heavily tested (200+ test files). It demonstrates strong engineering practices: atomic file I/O, bounded child process management, immutable revision control for workflow graphs, and a sophisticated prompt registry with versioned inheritance. While primarily an application, it contains a significant data pipeline component (ingest → normalize → segment → LLM extraction) that could be considered a research-grade feature engineering system. The repo is actively maintained with frequent commits, CI, and issue triage. Notable risks include heavy sidecar bundling (Screenpipe, Hermes, ffmpeg), rapid prompt set version churn, and a mixed licensing model (Apache 2.0 open core + PolyForm Noncommercial for product code).
BetterDiscord is a client modification for Discord that injects into the Electron app to provide a plugin and theme system, custom CSS editor, addon store, updater, and developer tools. The architecture is a monolith within the Discord client, structured as three packages: injector (main process), preload, and renderer. Key entry points include the main process (`src/electron/main/index.ts`), preload script (`src/electron/preload/index.ts`), and renderer initialization (`src/betterdiscord/index.ts`). Data flows involve IPC between main and renderer, webpack module interception for patching Discord's React components, file system access for addons and settings, and GitHub API for updates. External dependencies include Electron, React, Monaco Editor, lucide-react, and react-spring. The codebase is well-structured with TypeScript, has tests, and exposes a comprehensive API (`BdApi`) for plugin developers. However, it heavily relies on Discord's internal webpack modules and hardcoded module IDs, making it brittle and requiring frequent updates as Discord changes. The project is actively maintained with recent commits and responsive issue triage.
This repository is a boilerplate for building desktop applications using Electron, Vue 3, and Vite. It provides a pre-configured setup that includes a main process (handling application lifecycle and window creation), a preload script (securely exposing Electron and Node.js APIs to the renderer via contextBridge), and a renderer process (built with Vue and Vite). The project includes demos showing inter-process communication (IPC) and direct Node.js usage in the renderer. The architecture follows the standard Electron model, with the main process managing the application lifecycle and the renderer process running the Vue application. Vite is used as the build tool for all processes (main, preload, and renderer), leveraging vite-plugin-electron to handle Electron-specific build configurations such as sourcemaps, minification, and dependency externalization. The preload script exemplifies best practices by using contextBridge to expose only the necessary IPC methods, avoiding the security risks of enabling nodeIntegration or disabling contextIsolation. While the project is relatively simple and serves as a starting point, it contains several reusable patterns and configurations. Notably, the Vite configuration (vite.config.ts) demonstrates a non-obvious but effective way to set up Vite for Electron builds, including separate configurations for the main and preload processes. The preload script also contains reusable DOM utility functions (domReady and safeDOM) and a secure pattern for exposing Electron APIs. Overall, the boilerplate is well-structured, adheres to modern Electron and Vue practices, and provides a solid foundation for building Electron applications with Vue and Vite.
Antigravity Manager is an Electron desktop application that serves as a multi-account manager and local API proxy gateway for AI models (Google Gemini, Claude, OpenAI-compatible). It allows users to pool multiple Google Cloud accounts, automatically rotates between them based on real-time quota and rate limits, and exposes a local proxy server that translates between OpenAI, Anthropic, and Gemini API protocols. The application handles OAuth token lifecycle, credential storage across OS keychains and encrypted files, and includes a React UI for account management, quota monitoring, and configuration. Architecturally, the app is a monolith with three major layers: an Electron main process that bootstraps a NestJS server (Fastify), a React renderer with TanStack Router and shadcn/ui, and a Python CLI for headless account operations. The proxy gateway is the most complex module, with controllers for OpenAI chat completions, Anthropic messages, Gemini models, batch jobs, file uploads, and WebSocket-based Responses API. Credential management is handled through a multi-provider master key system with migration paths, atomic file writes, and SQLite persistence via Drizzle ORM. The codebase also includes device identity profile manipulation (fingerprint spoofing) gated by environment variables, and binary patching of the agy CLI executable. The codebase demonstrates strong engineering practices with extensive Vitest unit tests (250+ test files), Playwright e2e tests, Zod schema validation at IPC boundaries, and structured error handling. However, it also carries risks: hardcoded model aliases and Google API endpoints, fragile binary patching logic, and a large surface area of credential storage strategies that may drift as OS APIs evolve. The repo is actively maintained with frequent commits and CI pipelines, but the complex fallback chains and security-sensitive code require careful ongoing maintenance.
Witsy is a feature-rich desktop AI assistant built with Electron and Vue 3. It operates as a Bring-Your-Own-Keys (BYOK) client, aggregating dozens of LLM providers (OpenAI, Anthropic, Google, Ollama, etc.) into a unified chat, agent, and automation platform. The architecture follows a standard Electron main/renderer process split, communicating via IPC, with a Vue 3 frontend and a Node.js backend. Beyond basic chat, Witsy provides a sophisticated agent system supporting multi-step workflows, A2A communication, scheduling, and webhooks. It includes a full RAG pipeline (document ingestion, chunking, embedding, vector search), a plugin system for tools (MCP, code execution, web browsing, image generation), and extensive voice capabilities (STT/TTS with multiple providers). Data is persisted locally as JSON files within workspaces, with a vector database for semantic memory and document retrieval. A key differentiator is its automation layer, which can control the desktop (text selection, pasting, app detection) via platform-specific automators (macOS, Windows, nut-js). It exposes a local HTTP API and a CLI for external integration. The MCP (Model Context Protocol) client allows it to connect to a vast ecosystem of third-party tools. While primarily an application, it contains significant data engineering components (RAG pipeline, memory manager, deep research orchestrator) that are tightly integrated into the app's workflow. The codebase is well-structured with a strong emphasis on testing, though its massive feature surface and reliance on external APIs introduce inherent complexity and maintenance challenges.
Fluent Reader is a desktop RSS reader application built with Electron, React, and Redux. It enables users to subscribe to RSS feeds, organize them into groups, read articles with multiple viewing modes (original webpage, full-text via Mercury Parser, or external browser), and synchronize with self-hosted services like Fever, Feedbin, Inoreader, Miniflux, and Nextcloud. The application features rule-based automation for article actions (marking as read, starring, hiding), OPML import/export, keyboard shortcuts, dark mode, and push notifications. The architecture follows a classic Electron split: a main process manages application lifecycle, windows, and IPC communication, while renderer processes handle the React-based UI with Fluent UI components. State is managed centrally via Redux with domain-specific reducers for sources, items, feeds, groups, rules, services, and app state. Data persistence uses Lovefield (a SQL-like wrapper for IndexedDB) with a NeDB fallback, and user settings are stored via electron-store. Key entry points include src/electron.ts (main process), src/index.tsx (renderer root), and src/preload.ts (context bridge for secure main-renderer communication). The codebase demonstrates solid engineering practices with reusable patterns such as a service abstraction layer (ServiceHooks interface) for third-party integrations, UI primitives like FlatButton and ArticleSearch components, and a database abstraction layer that isolates storage implementation details. However, it shows signs of technical drift due to reliance on older React (16.13.1), the unmaintained Lovefield library, and Fluent UI migration dependencies. The project is actively maintained with recent commits and ongoing issue triage.
ColorTxt (彩读) is a cross-platform desktop ebook reader built with Electron, Vue 3, and Monaco Editor. It focuses on reading local text/ebook files (TXT, EPUB, PDF, MOBI, FB2, CHM) with an extensive feature set: AI-powered reading assistant (chat, RAG, mindmap, wordcloud, character card generation), multi-engine text-to-speech (Edge, MiniMax, DashScope, MiMo, Volcengine, Windows SAPI), dictionary lookup supporting multiple formats (StarDict, MDict, Babylon, DICT), a book source engine fully compatible with Legado (阅读) for searching and downloading web novels, WebDAV sync for cross-device backup, and deep customization of reading appearance (themes, fonts, line spacing, backgrounds, reading ruler, pomodoro timer). The architecture follows a standard Electron pattern: a main process handles I/O, AI, TTS, networking, and IPC, while separate renderer processes (main reader, find-book, stealth reader) are Vue 3 SPAs communicating via typed IPC through a preload bridge. The codebase is large and feature-rich, demonstrating solid engineering practices (composable patterns, shared type libraries, clean IPC design) but also carries maintenance complexity from the Legado compatibility layer, numerous third-party API integrations, and platform-specific hacks for stealth mode and native modules.
Jumble is a full-featured Nostr client for exploring relay feeds and engaging with the nostr social protocol. It is built as a Progressive Web App (PWA) with an optional Electron desktop wrapper, offering a rich set of features including notes, reactions, zaps, encrypted direct messages (NIP-17/NIP-4e), relay management, custom emoji packs, long-form articles, polls, media upload (Blossom/NIP-96), and translation services. The architecture is a React 18 + TypeScript single-page application with Vite as the build tool, using state management via React Context and service singletons with IndexedDB/localStorage persistence. The desktop variant adds native secret storage, auto-updater, and a custom media server. The codebase demonstrates high craftsmanship in areas such as relay connection management (SmartPool/ElectronPool with retry and health checks), an LRU-based caching abstraction (BoundedMap), a robust content parser, and a well-structured draft event creation pipeline. However, it also exhibits some monolithic services and tight coupling across providers, which limits modular reuse. Overall, it is a mature, production-grade implementation of a decentralized social media client with active development and a broad feature surface.
node-rcedit is a thin Node.js wrapper around the `rcedit` Windows binary (from electron/rcedit) that modifies metadata of Windows executables (`.exe` files). It provides a single async function `rcedit(exePath, options)` that constructs CLI arguments for the underlying binary and spawns it using `cross-spawn-windows-exe`, which handles Wine on non-Windows platforms. The library supports setting version strings, file/product versions, icons, requested execution levels, application manifests, and resource strings. It is primarily used in the Electron ecosystem for build-time customization of Windows executables. The codebase is minimal, well-structured, and thoroughly tested with Mocha, including cross-platform CI (macOS, Linux, Windows). TypeScript declarations are provided for type safety. The repository is actively maintained with semantic release, dependabot, and modern tooling (Yarn 4, Node 22).