NextChat is a production-grade, multi-provider AI chat client built as a Next.js web application with an optional Tauri desktop wrapper. It supports 15+ LLM providers (OpenAI, Anthropic, Google, Baidu, DeepSeek, etc.) through a unified API abstraction layer, and provides a rich chat interface with streaming responses, markdown rendering, code folding, image upload, TTS, real-time voice chat, and Stable Diffusion image generation. The application is designed for self-hosting (Docker, Vercel, manual) and emphasizes privacy by storing all chat data locally in IndexedDB/localStorage, with optional cloud sync via WebDAV or UpStash Redis. Architecturally, NextChat is a monolith with client-side state management using Zustand (with IndexedDB persistence), serverless API routes for proxying LLM requests, and a React component library. It includes a plugin system for OpenAPI-based function calling, MCP (Model Context Protocol) integration for external tool execution, and a prompt/mask system for reusable system instructions. The codebase is well-structured with reusable patterns like generic store factories, UI components, and streaming utilities, though it exhibits significant duplication across provider integrations and some features (e.g., Tencent, SD) appear less maintained.
OpenTeams is a multi-agent AI coding assistant platform that enables users to collaborate with multiple AI coding agents (Claude Code, Codex, Gemini CLI, etc.) in a single shared session. The system provides a local-first desktop application built with Tauri (Rust backend + React/TypeScript frontend), a standalone CLI tool (`openteams-cli`) written in TypeScript with Bun, and a web frontend. The backend is an Axum HTTP server in Rust with SQLite persistence managed via SQLx, supporting chat sessions, workflow orchestration, source control integration, approval systems, and a skill registry. The architecture is modular: a `crates` workspace separates database models, services, executors, deployment, and utilities, while the CLI uses Effect-TS for dependency injection and includes a TUI built with SolidJS. In production, the system orchestrates AI agents through the Agent Client Protocol (ACP) and provider-specific SDKs, managing execution processes, worktrees, and chat message queues. Key data flows include: user input → chat runner → agent execution (with tool calls, file edits, git operations) → event streaming back to frontend/CLI. The platform integrates with GitHub for PR review, issue tracking, and work item management, and supports custom MCP servers and skill plugins. External dependencies include SQLite, Tauri, Bun, various AI provider APIs (Anthropic, OpenAI, Gemini, Copilot), and GitHub CLI for certain operations.
LiveSplit One is a cross-platform speedrun timer application, the successor to the classic LiveSplit timer. It runs as a Progressive Web App and as a Tauri desktop application, targeting Windows, Linux, and macOS. The core timing logic is compiled to WebAssembly via the 'livesplit-core' Rust library, while the UI is built with React 19, TypeScript, and Vite. The application provides a rich set of features for speedrunners: highly customizable split timers, real-time comparisons, layout editor with drag-and-drop, integrated leaderboards from Speedrun.com, global hotkeys (desktop only), always-on-top mode, WebSocket server for remote control, and support for multiple timekeeping methods (real time vs game time). Data persistence is handled via IndexedDB in the browser and the filesystem in Tauri. The codebase is well-structured with a clear separation between core logic (WASM), UI components, and platform-specific code, though some central components like 'LiveSplit.tsx' are large and could benefit from further decomposition.
LessAI is a Tauri 2 desktop application for AI-assisted document rewriting. It supports importing documents in plain text, Markdown, LaTeX, DOCX, and PDF formats, segmenting them into rewrite units, and sending them to an OpenAI-compatible LLM for rewriting. The system provides a workbench view with a side-by-side editor and review panel, enabling users to view diff hunks, accept/reject suggestions, and finalize writeback to the original file. For complex formats like DOCX and PDF, a slot-based model preserves locked placeholders (e.g., tables, images, hyperlinks) while allowing editable text regions to be rewritten. The application includes a web demo mode for plain text only, a full settings UI for provider configuration, and an in-app update mechanism. The architecture is a monolith split between a Rust backend (Tauri commands, document adapters, rewrite pipeline) and a React/TypeScript frontend with custom hooks, progressive rendering, and a slot-based structured editor. The codebase is well-structured with extensive unit tests, roundtrip test fixtures, and CI/CD pipelines for cross-platform bundles.
This repository contains a desktop application for managing Nintendo Switch emulators, built with Tauri (Rust backend) and Vue 3 (frontend). It supports installing, updating, and configuring multiple emulators including Yuzu, Ryujinx, Eden, and Citron. The application provides features for firmware management, key installation, cheat code management, save backup/restore, and a self-update mechanism. The backend uses a layered architecture with commands, services, repositories, and models, while the frontend uses Vuetify 3 components and Pinia state management. The download subsystem is particularly notable, featuring a unified DownloadManager trait with two implementations: one using the native Rust bytehaul library and one using the aria2 external tool as fallback on Windows. The code also includes sophisticated network utilities with DNS-over-HTTPS resolver, GitHub API circuit breaker, mirror fallback chain, and adaptive parallelism. Configuration is persisted atomically with debounced saves, and progress is broadcast to the frontend via a typed event system. The codebase demonstrates good engineering practices with clear separation of concerns, error handling via typed AppError/AppResult, extensive test infrastructure (though many tests are marked ignored as they require network access), and platform-specific handling for Windows, macOS, and Linux. However, the UI is entirely in Chinese, and some external dependencies (CDN URLs, emulator project APIs) may require ongoing maintenance.
ReadAny is a full-featured, cross-platform e-book reader application with deep AI integration. It supports reading EPUB, PDF, MOBI, FB2, and other formats via the modified foliate-js engine, and provides text-to-speech, annotations, reading statistics, and cross-device sync (WebDAV, S3, LAN). The AI subsystem offers chat with RAG (semantic search over book content), context-aware tools, and execution of user-defined skills. The application follows a local-first architecture with robust offline capabilities and optional cloud sync. The codebase is structured as a pnpm monorepo with four main packages: 'core' (shared business logic, types, stores, AI, RAG, sync, stats, TTS), 'app' (Tauri desktop client with React+shadcn UI), 'app-expo' (Expo/React Native mobile client), and 'cli' (agent integration via MCP and managed shims). The application exhibits high craftsmanship in its platform abstraction layer, persistent store pattern, and hybrid search engine. However, there is significant platform-driven code duplication (desktop vs. mobile UI components) and a complex dependency graph with multiple patched packages, indicating some architectural debt.
Kiro Account Manager is a Tauri-v2 desktop application (Rust + React/TypeScript) that manages multiple Kiro IDE accounts with smart switching, quota monitoring, token refresh, and machine-ID rotation to avoid multi-account association. It also ships a fully featured local HTTP gateway (Kiro2API) that exposes managed accounts via OpenAI Chat Completions, OpenAI Responses, and Anthropic Messages APIs, with load balancing, model mapping, prompt filtering, response caching, and streaming. Additionally, the app provides a configuration surface for Kiro IDE settings, MCP servers, custom agents, skills, steering rules, hooks, and powers. It supports multiple authentication providers (Google, GitHub, AWS Builder ID, IAM Identity Center) and integrates with the Kiro CLI SQLite database for account import. The architecture follows a clean separation—Rust backend handles all business logic via Tauri IPC commands, while the React frontend uses Radix-based UI components and context-based state management. Despite its broad feature set, the codebase demonstrates professional engineering practices with extensive testing in both Rust and TypeScript, though some modules are monolithic and contain hardcoded constants tied to Kiro-specific APIs.
Koharu is a desktop application for manga and comic translation, built with a Rust backend (Tauri) and a React/TypeScript frontend. It orchestrates a multi-stage ML pipeline: page import, layout detection (YOLO, RT-DETR), speech bubble segmentation, OCR (PP-OCR, Manga OCR), translation (local LLMs via llama.cpp or cloud APIs), and inpainting (LaMa, FLUX.2, AOT-GAN). The system includes a custom deep learning framework (`koharu-torch`) with inference-only ports of common vision models, a scene graph for versioned project state, and a WebGPU/WASM canvas for interactive editing. The application supports multiple hardware backends (CUDA, ROCm, Vulkan, Metal) and can run entirely offline. Architecturally, the project is a monorepo with over 30 Rust crates and two JavaScript packages. The backend is organized around clearly separated concerns: model inference (`koharu-ml`), pipeline orchestration (`koharu-pipeline`), project state (`koharu-scene`), persistent storage (`koharu-storage`), and rendering (`koharu-renderer`/`koharu-rasterizer`). The frontend provides an editor with panels for page management, canvas, inspection, and an AI agent panel that uses OpenAI's Codex protocol for tool-driven project editing. The translation subsystem abstracts over local and remote providers with a common prompt and schema interface. While the primary purpose is an application, the ML model implementations are notable for their fidelity to upstream Python references, including exact preprocessing (LetterBox padding, pixel normalization) and postprocessing (NMS, mask decoding). This makes the repository valuable as a reference for Rust ports of computer vision models. However, the codebase is tightly coupled to specific model architectures and pinned revisions, limiting direct reuse without significant adaptation. The UI component library (`packages/ui`) and several backend abstractions (e.g., configuration, storage format, runtime dependency graph) are designed for reusability and could be extracted with minimal effort.
This repository is the monorepo for Cherry Markdown, a rich, extensible WYSIWYG markdown editor library developed by Tencent. The core package (`packages/cherry-markdown`) provides a modular parsing engine with a plugin-based syntax hook system, a comprehensive toolbar, streaming rendering for AI chat, and support for diagrams (Mermaid, PlantUML, ECharts), math (KaTeX/MathJax), tables, and code blocks. The repository also includes a desktop client built with Tauri (Vue 3 + Pinia + Rust) that adds file management, local versioning, and native integrations; a VS Code extension; a WeChat Mini Program renderer; and various example applications. The architecture is well-structured with clear separation of concerns (engine, previewer, editor, toolbar, addons), extensive unit tests, and a consistent event-driven pattern. While the core library is JavaScript with JSDoc types, the client and plugins are TypeScript. Some technical drift exists due to vendored third-party assets (e.g., drawio library), a partially implemented Milkdown adapter, and a few deprecated code paths. Overall, this is a mature, actively maintained editor framework with high reusability in its hook system, utility classes, and composable patterns.
This is a feature-rich desktop application built with Tauri v2 and Svelte v3 that generates procedural lo-fi music in real-time using Tone.js. It offers a complete music creation experience with chord progression generation, drum sequencing, and ambient sound effects (rain, thunder, jungle, campfire). Beyond audio, it includes productivity tools like a Pomodoro timer, focus task management, and a system tray with mini-player mode. The application is local-first, storing user preferences (volumes, backgrounds, locale) in browser storage and custom background images in IndexedDB. It supports 7 languages and provides extensive keyboard shortcuts. The architecture is monolithic with a Rust backend handling native window management (custom title bar, mini-mode, tray) and a Svelte frontend managing the audio engine and UI state. The audio engine is particularly well-crafted, implementing music theory concepts (scales, intervals, chord weights) programmatically.
Kanri is an offline-first Kanban board desktop application built with Tauri (Rust backend) and Nuxt (Vue 3 frontend). It manages boards, columns, and cards with rich features including drag-and-drop, tags, due dates, subtasks, rich text descriptions, custom backgrounds, and multiple themes (dark, light, Catppuccin, custom). Data is persisted locally via Tauri's plugin-store as a single JSON file, with no cloud dependency. The application supports importing from Trello, KanbanElectron, GitHub Projects, and Kanri's own format, as well as full/partial export. It includes a sidebar for pinned boards, keyboard shortcuts, zoom adjustments, and a comprehensive settings page. The architecture is a monolith: the frontend runs in a WebView, communicating with the Rust backend via Tauri commands for file system access, dialogs, window state, and autostart. State management uses Pinia stores with debounced auto-save. The project is in maintenance mode, accepting only small fixes and no AI-generated contributions.
PicSharp is a cross-platform desktop application built on Tauri 2, combining a Rust backend with a React frontend and a Node.js sidecar service. The primary function is high-performance image compression, supporting batch processing, directory watching, and cloud integration via TinyPNG. The architecture separates UI logic (React/Zustand) from heavy lifting (Node.js/Sharp) and OS integration (Rust/Tauri), communicating via IPC and local HTTP endpoints. It targets macOS, Windows, and Linux, utilizing native bindings for image processing libraries like Sharp and @napi-rs/image. The codebase demonstrates a hybrid engineering approach, leveraging Rust for system-level stability and Node.js for ecosystem flexibility in image manipulation. Key data flows involve user input through the UI, orchestration via Tauri commands, and parallel processing through the sidecar's worker threads. Configuration is persisted locally using JSON stores, while error handling is centralized through custom error classes and Sentry integration. Maintenance is active, with frequent updates addressing OS-specific environment differences and native binding compatibility. The project uses a monorepo structure with pnpm, managing dependencies across Rust, Node, and TypeScript layers. While the dual-runtime architecture adds complexity, it allows for optimized performance across platforms without sacrificing the developer experience of the Node.js ecosystem.
SteamDepotDownloaderGUI is a Tauri v2 desktop application that provides a graphical interface for DepotDownloader, a CLI tool for downloading specific versions (manifests) of Steam games. The app allows users to input Steam credentials (or download anonymously), app/depot/manifest IDs, and an output directory. The Rust backend downloads the DepotDownloader binary from GitHub, extracts it, and spawns it as a child process via a pseudo-terminal (PTY), streaming output to an xterm.js terminal component in the Preact frontend. The frontend also includes a clipboard parser that extracts identifiers from SteamDB's copy format, auto-filling the form. The architecture is a standard monolithic desktop app with clear separation between Rust backend (Tauri commands) and Preact frontend, communicating via Tauri's invoke system. Settings for output directory naming and mobile authentication are managed through a context. The code is well-organized, with reusable input components and a clean PTY abstraction, though testing is minimal beyond a single URL validation test.
Talkio is a local-first desktop (Windows/macOS/Linux via Tauri 2) and Android application for multi-AI group chat. Unlike a conventional ChatGPT wrapper, it orchestrates conversations where multiple AI models — OpenAI Chat Completions, OpenAI Responses, Anthropic Messages, plus DeepSeek/Groq/Ollama via compatible endpoints — converse together in one thread, each bound to a configurable persona/identity with its own system prompt and model selection. Core features include streaming SSE generation, an MCP (Model Context Protocol) client with both stdio subprocess (desktop) and custom streamable-HTTP transports, a tool-call loop supporting iterative tool execution, automatic conversation context compression, chat branching/regeneration, file attachment parsing (PDF/Word/Excel/images), and export to Markdown/PDF. All data is local: conversations persist in SQLite via the Tauri SQL plugin, while providers, identities, MCP servers, and settings live in localStorage.
Spacedrive is a cross-platform file manager and virtual distributed file system (VDFS) that unifies files across devices and cloud storage into a single, searchable library. The core engine is written in Rust and provides indexing, media processing (thumbnails, OCR, speech-to-text), P2P sync with conflict resolution, volume detection, file operations, and an extensible WASM plugin system. The codebase is a large monorepo with multiple frontends: a Tauri desktop app, React Native mobile app, CLI, and web interface, all communicating with a daemon process via a typed RPC protocol. The architecture follows CQRS/DDD patterns with auto-generated TypeScript types and a job/task system for background work.
Memospot is a desktop application that bundles the Memos note-taking service as a self-contained Tauri v2 wrapper. It manages the Memos server as a sidecar process, provides a SvelteKit frontend for settings and interaction, and handles configuration persistence, database migrations, window state, keyboard shortcuts, and auto-updates. The architecture is a Rust backend with a web frontend, using a Rust workspace with multiple crates for config, dialogs, sidecar management, port picking, and homedir resolution. The frontend is built with SvelteKit, Tailwind CSS, and uses Paraglide for i18n. The build system includes GitHub Actions CI/CD, Docker-based builds, and installers for Windows (NSIS/WiX), Linux (deb, AppImage, Flatpak), and macOS. The codebase demonstrates solid engineering practices with clean abstractions and reusable utility crates, though it has some pinned dependencies and complex CI workflows.
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).
Wisp is a local-first, real-time meeting transcription desktop application built with Rust and SvelteKit, using Tauri v2 for cross-platform deployment (macOS Apple Silicon, Windows x64). It captures microphone and system audio, runs on-device automatic speech recognition (ASR) using multiple engines (whisper.cpp, sherpa-onnx, Apple Speech), provides live speaker-diarized transcripts with timestamps, and supports offline semantic search via local ONNX embedding models. The architecture is modular, with pluggable traits for audio sources, ASR engines, denoisers, echo cancellers, and model stores. It also offers optional cloud transcription (OpenAI, Gemini, Groq, etc.) and AI assist features. Although primarily an application, it integrates significant data engineering patterns for streaming audio processing, feature extraction (VAD, diarization), and on-device model management.
Entropic is a local-first desktop AI workspace built with Tauri and React. It provides a full desktop environment including chat with an AI agent, file management (Finder), web browsing, office document editing (OnlyOffice integration), voice control, task board with cron jobs, and an integration marketplace (OAuth for Google, Outlook, Slack, etc.). The application runs a sandboxed runtime (OpenClaw) inside Docker/Colima on macOS/Linux or WSL2 on Windows, ensuring secure execution of agent actions. Communication with the agent gateway happens via WebSocket with structured RPC frames. The system supports two modes: local API keys (user provides LLM keys) and managed proxy mode with hosted authentication and billing via Supabase/Stripe. The architecture is a monolith with separate microservices for browser automation (Playwright) and skill scanning (Cisco AI Defense). The frontend uses React 18, TypeScript, Vite 5, and Tailwind CSS 4, while the backend is Rust with Tauri v2 plugins for deep-link, updater, store, stronghold, and shell access. The codebase demonstrates strong engineering practices with reusable hooks for audio recording/transcription, a custom markdown renderer with workspace link support, and a resilient WebSocket client. However, some components are monolithic (Chat.tsx ~4000 lines, Files.tsx ~3000 lines) and there are hardcoded model lists and pricing that may drift over time.
ChatGPT-web is a Svelte 5 single-page application (with a Tauri desktop wrapper) that provides a configurable chat interface for multiple large language model (LLM) providers, including OpenAI, Anthropic, xAI, Google Gemini, Mistral, APIpie, OpenRouter, OrcaRouter, and custom endpoints. The system handles streaming and non-streaming chat completions, image generation, token counting, pricing estimation, chat profiles with system prompt injection, and export/import of conversations. All chat history and settings are stored client-side in localStorage and IndexedDB, making it a private, self-contained frontend. The architecture is a client-only SPA with no backend; it relies entirely on browser fetch calls to provider APIs. The codebase demonstrates a clear separation of concerns between UI components (Svelte), state management (local storage stores), provider abstractions (provider definitions, request classes), and utility modules (token counting, image caching, settings schema). However, it shows signs of organic growth with tight coupling between modules, frequent `any` type casts, and comments referencing desired refactors. The bundled prompts CSV from the awesome-chatgpt-prompts project serves as a built-in prompt library. The project is suitable for developers wanting a customizable, private, multi-provider chat frontend, but reusing individual components requires careful extraction due to internal dependencies.