This repository contains raygui, an immediate-mode GUI library for the raylib game programming library. It is written entirely in C as a single header file (src/raygui.h). The library provides over 25 controls (buttons, sliders, text boxes, list views, color pickers, etc.) designed specifically for building development tools, debug overlays, and editors. The architecture follows an immediate-mode pattern where controls are drawn and return their state every frame, with no retained state managed by the library, making it highly predictable and easy to integrate into existing game loops. A powerful styling system allows complete customization of colors, fonts, and metrics, with over 20 pre-built themes provided in the styles/ directory. The library also includes a built-in icon system with 256+ 16x16 icons. While tightly coupled to raylib by default, a standalone mode (RAYGUI_STANDALONE) allows it to be adapted to any graphics library by implementing a small set of backend functions. The examples directory contains several high-quality, reusable custom widgets (curve editor, property list, file dialog) that demonstrate how to extend the library. The codebase is mature, well-documented, and actively maintained, representing a high standard of C library craftsmanship within its domain.
Clash Verge Rev is a cross-platform desktop proxy management GUI built with Tauri 2 (Rust backend) and React 19 (TypeScript frontend). It serves as the control interface for the mihomo (Clash Meta) proxy core, enabling users to manage proxy subscriptions, switch proxy groups, toggle system proxy and TUN mode, view real-time traffic and connection details, and configure advanced settings like DNS overrides, script enhancements, and backup to WebDAV. The architecture is modular: a Rust backend handles core lifecycle, config management (using a unique 'Draft' transactional pattern), system integration (tray, hotkeys, auto-launch), and IPC with a privileged service on Windows. The frontend uses MUI, SWR, and virtual lists for a responsive UI with drag-and-drop profile/group editing, a built-in Monaco editor for YAML/JS configs, and real-time WebSocket-based data visualization. The repository also includes a Rust workspace with several crates (media unlock checker, i18n, logging, signal handling, rate limiter, system info plugin) that could be extracted and reused in other Tauri applications.
DBeaver is a universal database management tool and SQL client, built as a desktop application on the Eclipse RCP (OSGi plugin) framework. It provides a rich graphical interface for connecting to over 100 database systems via JDBC/ODBC drivers, including relational databases (MySQL, PostgreSQL, Oracle, SQL Server, SQLite, etc.), cloud databases (BigQuery, Athena, Snowflake), and NoSQL systems (MongoDB, Cassandra) in commercial editions. The application offers a full suite of database development features: a multi-tab SQL editor with syntax highlighting, code completion, and execution plan visualization; a data editor with grid, form, and GIS geometry views; ER diagram designer; data export/import wizards supporting CSV, JSON, XML, SQL, Markdown, and Excel; dashboard widgets for query-based monitoring; and an integrated AI assistant (OpenAI, Copilot) for natural language query generation and schema analysis. The architecture follows a strict model/UI separation enforced by OSGi plugin boundaries. The core model plugin (`org.jkiss.dbeaver.model`) defines interfaces for database objects, data values, execution contexts, and security, which are implemented by database-specific extension plugins (`org.jkiss.dbeaver.ext.*`). UI plugins (`org.jkiss.dbeaver.ui.*`) provide editors, navigators, and dialogs, while data transfer, debugging, and AI features are isolated in their own plugins. This design allows the model layer to be reused in the web-based CloudBeaver product. Key entry points include the `DBeaverApplication` class for startup, the `SQLEditor` for query editing, and the `DataTransferWizard` for import/export. External dependencies include the Eclipse RCP framework, JDBC drivers, ANTLR4 for SQL grammar parsing, JSQLParser for SQL analysis, and various third-party libraries for SSH tunneling, AWS SDK, and AI API communication. Data flows center around database connections: users configure data sources via connection wizards, execute SQL queries through the editor, and view results in data grids or export pipelines. The data transfer subsystem implements a producer/consumer pattern with pluggable transformers and serializers, supporting streaming for large datasets. The AI integration uses a provider abstraction to interface with different LLM APIs, generating SQL from natural language and providing schema-aware context. The repository also includes a CLI tool (`dbvr`) for CI/CD automation and a headless test platform. While the community edition is fully open-source, commercial versions add NoSQL support, additional AI providers, and premium features, with some code paths guarded by feature flags.
Trayscale is an unofficial GTK4/Libadwaita desktop GUI for the Tailscale VPN daemon, targeting Linux (no official Linux GUI exists). It provides a system tray status icon, a full Libadwaita window for managing peers, exit nodes, Mullvad exit nodes, Taildrop file transfers, profiles, and connection state. The architecture is a single Go binary using gotk4 bindings to GTK4 and Libadwaita. It communicates with the local tailscaled via Tailscale's local API and IPN bus watcher for real-time status updates. The codebase demonstrates solid Go engineering: clean separation of concerns (tsutil client layer, UI layer, tray, datatypes), use of modern Go features (generics, iterators, slices, maps), and comprehensive tests for the core polling and search logic. While not a reusable library, several internal packages (peersearch, autosave, listmodels) are well-isolated and could be extracted.
Sniffnet is a cross-platform desktop GUI application for real-time network traffic monitoring and analysis, written in Rust using the Iced framework. It captures packets via pcap (live or from PCAP files) and also supports IPFIX flow collection over UDP. The application parses Ethernet, IP, TCP/UDP, ICMP, IGMP, ARP, and VLAN headers using a dedicated packet-parser library. It enriches captured traffic with geolocation (MaxMind GeoLite2 and IPinfo MMDB databases), ASN lookups, service identification (from a port-to-service map derived from nmap-services), and local process identification (via the listeners crate). The GUI provides multiple pages: an overview with live traffic charts and donut charts, an inspect page with a filterable and sortable connection table, a notifications page for alerts (thresholds, favorites, IP blacklists), and settings pages for themes, filters, and export. The application supports 25 languages, custom themes, and thumbnail mode for minimal monitoring. It is packaged for Linux (deb, rpm, AppImage), macOS (dmg), and Windows (msi), with CI/CD pipelines for cross-compilation and code signing.
WePush is a Java application monorepo with two coexisting generations of a multi-channel bulk messaging system. The legacy `src/main` tree is a Swing desktop client that manages accounts, message templates, recipient lists, tasks, and run history, and sends via WeChat (official accounts, mini programs, WeCom), SMS vendors, email, HTTP, DingTalk/Feishu bots, and carrier SMS protocols (CMPP/SMGP/SGIP/SMPP). It persists to SQLite through MyBatis and generates UI with IntelliJ GUI Designer forms. The `next/` tree is a modular, distributed push orchestration platform: a Spring Boot control plane (REST + gRPC), remote agents connected via an mTLS gRPC stream, a provider SPI with built-in HTTP, Aliyun SMS, SMTP, WeChat, and bot providers, and pluggable signed PF4J plugins for carrier protocols. It adds multi-tenant workspaces, secret envelope encryption, artifact storage (local/S3), audience streaming import, run state machines with idempotency and retry, schedule management, a React/Vite web UI, an Electron desktop shell, and a Java SDK. Persistence is SQLite for standalone mode or PostgreSQL for server mode, with Flyway migrations and JDBC repositories. The Next codebase is well-architected with core-api/engine/provider-spi/service/domain/infrastructure separation, ADRs, architecture tests, integration tests, CI, and installers. However, the repository as a whole carries the legacy desktop codebase in parallel, duplicating several domain concepts and retaining generated UI code and older dependencies. This split and the aging legacy portions are the main sources of technical debt.
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.
Cocoa-Way is a macOS-native Wayland compositor that runs Linux GUI applications inside container runtimes (Apple Container, Docker, OrbStack, or via SSH/Waypipe) and renders them to macOS windows using Metal. The core architecture consists of a Rust binary that serves as both a desktop compositor (single window with tiled layout) and a rootless mode that maps each xdg-toplevel to a native macOS window. It features bidirectional clipboard relay (text and PNG, up to 64 MiB), CoreAudio forwarding, a control API over Unix sockets, and an optional MCP server for AI-assisted diagnostics and onboarding. The project demonstrates high craftsmanship in its Metal renderer with texture caching and damage-coalescing, as well as in its container session management, which handles multiple runtime backends and complex lifecycle orchestration. The codebase is well-structured but contains a few monolithic files (e.g., main.rs, container_mode.rs) that handle a large amount of state and UI logic.
tui-realm is a Rust library/framework for building terminal user interfaces (TUIs) using a component-based, event-driven architecture. It is not a standalone application but a reusable framework that wraps ratatui (formerly tui-rs) and provides an Application loop, Component/AppComponent traits, a Model/Update/View pattern, and a subscription system for routing events between components. The monorepo is organized as a Cargo workspace containing the core `tuirealm` crate, a `tuirealm_derive` procedural macro crate, a standard library of reusable components (`tui-realm-stdlib`: Input, Label, List, Table, etc.), and optional integration crates `tui-realm-textarea` and `tui-realm-treeview`. The framework is designed to reduce boilerplate by centralizing focus management, event routing, and state handling in the Application/View layer, while allowing developers to define custom components and event sources via Ports and Subscriptions.
Appsmith is a comprehensive low-code application development platform that enables users to build internal tools, dashboards, and admin panels via a visual editor. The architecture consists of a React/TypeScript frontend (SPA) for the IDE and a Java Spring Boot backend (WebFlux) for business logic and data persistence. It features a robust plugin system for connecting to diverse datasources (SQL, NoSQL, SaaS, AI) and deep Git integration for version control and CI/CD workflows. The system is containerized for deployment and supports both Community and Enterprise editions through feature-flagged code paths.
Psst is a native desktop Spotify client written in Rust, designed as a fast, lightweight alternative to the official Electron-based client. It implements the proprietary Spotify session protocol (Shannon cipher, Diffie-Hellman key exchange, Mercury messaging) to stream audio directly, bypassing the Web API for playback. The application is structured as a workspace with three crates: `psst-core` (session management, audio pipeline, caching, Last.fm scrobbling), `psst-gui` (Druid-based GUI with controllers, widgets, and Web API integration), and `psst-cli` (simple command-line player). The GUI features a full browsing experience (home, search, library, artist/album/playlist/show details, lyrics, recommendations, credits) with async data loading via a Promise pattern and remote image caching. The audio pipeline includes decryption, decoding (symphonia), resampling, normalization, and output via cpal or cubeb. Authentication uses OAuth2 with PKCE and supports user-provided Spotify Client IDs. The project is actively developed with rolling releases and cross-platform builds (Windows, macOS, Linux).
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).
Praat is a cross-platform desktop application for phonetic analysis, speech manipulation, and linguistic research. It provides a rich GUI with interactive editors for viewing and editing sounds, spectrograms, pitch, formants, text annotations, and more. The core architecture is a monolithic C++ application built on a custom object system (Thing/oo_* macros) with automatic serialization, a comprehensive preferences framework, and a scriptable interface. The codebase bundles many external libraries (GSL, eSpeak, FLAC, Opus, LAME, PortAudio, WhisperCPP, etc.) for numerical computing, audio I/O, speech synthesis, and machine learning. It includes modules for linear predictive coding (LPC), cepstral analysis, neural networks (FFNet), optimality theory grammar, multidimensional scaling, and EEG/ERP processing. While the code is well-structured and domain-specific, the heavy reliance on external libraries, custom object system, and platform-specific ifdefs introduce maintenance complexity and moderate technical drift.
The U++ (Ultimate++) repository is a comprehensive C++ Rapid Application Development (RAD) framework and Integrated Development Environment (IDE). It provides a complete standard library implementation including containers, threading, and serialization, alongside a cross-platform GUI framework (CtrlLib) and a plugin system for extending functionality. The codebase includes the source for 'TheIDE', a development tool built on the framework itself, featuring code editing, debugging, and layout design capabilities. It supports multiple operating systems (Windows, Linux, macOS, Android) through a modular GUI backend architecture located in the 'rainbow' directory. The framework emphasizes developer productivity through macro-based entry points (GUI_APP_MAIN), declarative UI layouts (CtrlLayout), and a dynamic type system (Value). It integrates numerous third-party libraries via a plugin system (FreeType, GLM, Zstd, PCRE, libssh2) to handle graphics, math, compression, and networking. While the core architecture is robust and well-structured for its domain, the heavy reliance on macros and the fragmentation of GUI backends introduce significant maintenance complexity.
Flameshot is a powerful cross-platform screenshot application written in C++ with Qt. It provides a GUI for capturing screen regions, annotating with various tools (arrows, circles, text, pixelation, etc.), and saving or uploading images to Imgur or other services. The architecture includes a command-line interface for scripting, a background daemon for system tray and global shortcuts, and a DBus interface for desktop integration. Internally, it is a monolithic desktop app with a modular tool system (each annotation tool is a separate class) and a config system with validation. The codebase is well-structured but carries platform-specific workarounds (Wayland, Windows registry hacks) and some legacy code, leading to medium technical drift. It is actively maintained with recent commits, though translations show signs of staleness.
ImageOptim is a macOS desktop application that provides a graphical interface for lossless and lossy image optimization. It bundles over a dozen external optimization tools (e.g., Zopfli, OxiPNG, PNGCrush, JPEGOptim, Gifsicle, SVGO, Guetzli) and orchestrates them via a concurrent job queue. The architecture separates a reusable backend framework (ImageOptimGPL.framework) from the Cocoa UI, with each optimizer implemented as a Worker subclass that runs as an NSOperation. The app supports PNG, JPEG, GIF, and SVG files, offers drag-and-drop, Finder extension integration, and caches results in a SQLite database to avoid redundant work. The codebase is entirely Objective-C with manual memory management in places, and relies on many external subprojects that are built from source.
This repository is the official collection of Godot Engine demo projects, maintained by the Godot Foundation. It contains hundreds of self-contained, runnable demo projects that showcase specific engine features across 2D, 3D, audio, GUI, networking, XR, mobile, compute shaders, and editor plugins. Each demo is a standalone Godot project with its own project.godot, scenes, scripts, and assets. The repository serves as both a learning resource for developers and a testbed for engine capabilities. While not a single application, it demonstrates a wide range of game development patterns and engine APIs. Notable highlights include a generic state machine implementation, a 2.5D node system, a virtual joystick for touch input, a custom logger with UI integration, and a JSON-driven dialogue system. The codebase is actively maintained with recent commits, low technical drift, and consistent use of modern Godot 4.x APIs.
Koharu is a desktop application for manga/comic translation, built with Rust (Tauri) and a React/TypeScript frontend. It provides an end-to-end pipeline: page import, AI-based layout detection, speech bubble segmentation, OCR (multiple models including Manga OCR, PP-OCRv6, Baberu OCR), text translation (local LLMs via llama.cpp and 13+ remote providers), inpainting (LaMa, AOT, FLUX.2 Klein, RORem mixed), and typesetting with CJK/RTL support. The application features a WebGPU canvas editor, project management with undo/redo, PSD export, and an AI agent (Codex) for natural-language editing. The architecture is modular: a scene graph document model (koharu-scene), content-addressed blob storage (koharu-storage), a pipeline orchestrator (koharu-pipeline), and a hardware abstraction layer (koharu-runtime) for CUDA/ROCm/Vulkan/Metal. The frontend uses a custom UI component library (packages/ui) built on @base-ui/react. While the codebase is well-structured and actively maintained, it has technical drift risks from pinned git dependencies, multiple ML model ports that must stay synchronized with upstream, and platform-specific runtime packages.
FRP Manager is a Windows desktop application that provides a graphical interface for managing FRP (Fast Reverse Proxy) client configurations. It allows users to create, edit, launch, stop, and monitor multiple FRP proxy configurations, supporting both legacy INI and modern TOML formats. The application can run as a standard GUI or as a Windows service, with real-time status updates via IPC between the GUI and the service process. It includes features such as quick-add proxy presets (SSH, RDP, FTP, etc.), import/export via file, URL, or clipboard, NAT type discovery, master password protection, and multi-language support (6 languages). The installer is a native Windows bootstrapper that extracts an MSI and handles service lifecycle during upgrades. The architecture is monolithic: the main entry point in `cmd/frpmgr/main.go` decides whether to launch the GUI or run as a service. The UI layer uses the `lxn/walk` library (a custom fork) for native Win32 controls, organized into pages (configuration, log, preferences, about). The service layer wraps the official `fatedier/frp` client library and manages Windows service installation, start/stop, and configuration reload. IPC is implemented via named pipes for status updates. Configuration parsing and validation are handled in the `pkg/config` package, with conversion between INI and TOML. The project also includes a comprehensive i18n system using `gotext`, a set of reusable validators, and utility functions for file operations, string manipulation, and reflection-based config pruning. External dependencies include the FRP library (`fatedier/frp` v0.71.0), the forked `lxn/walk` GUI library, Windows API bindings (`golang.org/x/sys/windows`, `github.com/Microsoft/go-winio`), and WiX Toolset for the installer. The build process requires Go 1.25, MinGW, Node.js, and Windows SDK. The codebase is well-structured with clear separation of concerns, though it is tightly coupled to Windows and the forked walk library, limiting portability. Test coverage is present for core packages (config, validators, utilities) but sparse for UI and service components.
UAssetGUI is a Windows Forms desktop application for low-level examination and modification of Unreal Engine game assets. It allows users to open, edit, and save .uasset, .umap, .pak, and .utoc files, with JSON export/import, C# scripting via embedded Roslyn, property mappings for unversioned assets, and full theming and localization. The architecture is a monolithic GUI built on .NET 10 preview, relying on the UAssetAPI submodule for serialization. Key entry points are Program.Main and Form1 (the main editor window). The application targets modders and researchers who need to inspect or alter binary asset data directly. It includes custom controls, a plugin-like script system using collectible assembly load contexts, and supports container file extraction/repacking via native binaries. The codebase is well-structured for its niche but tightly coupled to Windows Forms and the UAssetAPI ecosystem.