Tangram is a GNOME desktop application written in JavaScript (GJS) that functions as a specialized browser for managing web applications as persistent, sandboxed tabs. It uses GTK4, Libadwaita, and WebKitGTK to render each tab independently, with per-tab settings (name, URL, user agent, notification priority) stored via GSettings. The application provides a tab overview (Adw.TabOverview), navigation controls, and integrates with the GNOME notification system. It is packaged as a Flatpak and supports translations via Weblate. The codebase is well-structured, modular, and follows modern GNOME development practices, with unit tests for URL utilities and web app metadata extraction.
CheatReader is a Flutter-based desktop ebook reader designed for low-distraction reading. It provides a floating, always-on-top window that supports single-line and multi-line reading modes, transparency, a boss key for quick hide/restore, system tray integration, and app disguise (icon/name change). The application imports local files in multiple formats (txt, epub, html, md, fb2, docx, pdf) via text extraction, never modifying the source. It features a bookshelf with reading progress tracking, customizable keyboard shortcuts, auto page-turn, full-text search, and a control panel for all settings. The architecture is a standard Flutter app with platform-specific abstractions for window management, file import, and startup behavior, targeting Windows, macOS, and Linux. The codebase is well-tested, localized in English and Chinese, and uses a spec-driven development process (OpenSpec). While the main reader surface widget is large (~2600 lines), the overall structure demonstrates solid engineering with reusable patterns for platform abstraction, settings persistence, and text extraction.
Episteme is a modern, cross-platform e-book and document reader built with Kotlin Multiplatform and Compose Multiplatform. It supports a wide array of formats including EPUB, PDF, MOBI, audiobooks (M4B), FB2, DOCX, ODT, PPTX, and comic archives (CBZ/CBR). The app offers a rich reading experience with paginated and vertical scroll modes, text-to-speech, ink and text annotations, OPDS catalog browsing, cloud sync via Google Drive and Firestore, AI-powered summarization, and extensive customization (themes, fonts, brightness). The codebase is organized into a shared module containing core business logic, models, and policies, with platform-specific implementations for Android (native Compose, Room, WorkManager), iOS (Swift), and Desktop (Compose Desktop, Swing interop). The architecture follows a clean separation of concerns with expect/actual abstractions for platform services, making it a strong example of production-ready KMP application design.
Bazzite is a custom Fedora Atomic (Silverblue/Kinoite) operating system image optimized for gaming on desktops, handheld PCs (Steam Deck, ROG Ally, etc.), and HTPCs. It provides a SteamOS-like experience with pre-installed gaming tools (MangoHud, vkBasalt, OBS VkCapture), hardware support (OGC kernel, HDR/VRR, DisplayLink, per-device audio profiles), and a suite of system management utilities. The repository is not a traditional application but a build system for generating container images and ISOs. The architecture is container-native: images are built via Containerfile and GitHub Actions, with modular overlays for different variants (desktop, deck, nvidia) and desktop environments (GNOME, KDE). Key components include a justfile recipe library for user-facing configuration (ujust), systemd services, udev rules, RPM spec files with patches for upstream packages (BlueZ, UPower, Xwayland, MangoHud), and hardware detection scripts. The build process is fully automated via CI/CD, with image signing and attestation. The project is actively maintained with a large community and extensive hardware support.
NW.js is a desktop application runtime that integrates Chromium and Node.js, enabling developers to build native desktop applications using web technologies (HTML, CSS, JavaScript). The codebase functions as a hybrid framework where web content can access native OS APIs and Node.js modules can be loaded directly into the browser context. It operates on a multi-process architecture typical of Chromium-based projects, with distinct browser, renderer, and utility processes. The system relies heavily on upstream Chromium and Node.js versions, requiring constant synchronization to maintain compatibility and security. It supports cross-platform deployment (Windows, macOS, Linux) with platform-specific implementations for UI components, file dialogs, and system integration.
AltSnap is a native Windows desktop utility that lets users move, resize, and manage windows by holding Alt and dragging with the mouse. In production it runs as a tray application and loads a companion hooks.dll into its own process; that DLL installs low-level keyboard and mouse hooks, detects Alt+click/drag gestures, and manipulates window placement through Win32 APIs. It also implements Aero-style snapping, configurable snap layouts/zones, blacklists, global hotkeys, MDI handling, a large action system assignable to mouse buttons/titlebar clicks, and an optional elevation path. The project deliberately avoids DLL injection into other processes; instead, input is captured via WH_KEYBOARD_LL/WH_MOUSE_LL and heavy window movement is offloaded to a worker thread to keep the hooks responsive.
WinDynamicDesktop is a Windows desktop application that replicates the macOS Mojave Dynamic Desktop feature, automatically changing the desktop wallpaper based on the time of day. Built with WinForms and .NET, it determines sunrise/sunset times using the device's location (via Windows location service or a geocoding API) and supports multiple monitors, lock screen synchronization, theme importing (from ZIP, JSON, or .ddw files), and localized translations across 50+ languages. The architecture includes a platform abstraction layer (DesktopHelper/UwpHelper for standard and UWP deployments), COM wrappers for wallpaper and power settings, SkiaSharp-based theme preview rendering, and an event-driven scheduler that responds to system events. It also features a PowerShell scripting interface for advanced customization, automatic updates via GitHub releases, and a config migration system for backward compatibility. The codebase is well-structured with clear separation of concerns, though it relies on external APIs (LocationIQ, POEditor) and Windows-specific COM interfaces, which introduce maintenance risk. The repository includes unit tests (sunrise calculations, system integration), CI/CD pipelines, and packaging scripts for installer and store distribution.
This repository provides flutter-webrtc, a Flutter plugin that wraps native WebRTC SDKs (Android, iOS, maccOS, Windowws, Linux, embedded Linux, and Web) to enable real-time audio/video communication, screen shaning, data channels, and end-to-end encryption. The architecture follows a common Dart interface with platform-specific implementations using method channels, event channels, and texture registries. Key entry points include the Dart factory classes (RTCFactoryNative/Web) and native plugin handlers (FlutterWebRTCPlugin on each platform). The plugin exposes a comprehensive WebRTC API including getUseMedia, peer connections, tranceivers, simulcast, stats, and E2EE via frame cryptors. It is actively maintained with regular commits and issue triage, but exhibits code duplication across platforms and some fragile patterns (reflection, monoilithic method handlers).
Turms is a production-grade, open-source instant messaging engine designed for 100K to 10M concurrent users. The system follows a microservices architecture with two core Java/Spring Boot servers: turms-gateway (handles client connections, authentication, session management, and push) and turms-service (implements business logic for messaging, groups, users, conversations, storage, and admin API). Both servers are built on a reactive stack (Project Reactor, Netty) for non-blocking I/O and high throughput. The platform includes a Vue.js admin UI (turms-admin), multiple client SDKs (JavaScript, Kotlin, Swift, Dart, C++), a Flutter chat demo, and a plugin system for extensibility (anti-spam, push notifications, MinIO storage, Rasa chatbot, LiveKit conferencing). Data is stored in MongoDB (sharded), Redis (session, blocklist, sequence IDs), and optionally Elasticsearch for full-text search. The codebase demonstrates strong engineering practices: custom RPC codecs for cluster communication, a property metadata framework for configuration validation, thread-safe rate limiting, and a well-defined plugin extension point system. While primarily an application, it includes an AI serving module (PaddleOCR) for content moderation, but this is a minor component. The repository is actively maintained with frequent commits, comprehensive CI/CD pipelines, and Terraform deployment scripts.
This repository provides a GNOME Nautilus (Files) extension that allows users to define custom context menu actions, replacing the defunct 'filemanager-actions' project. The extension is implemented in Python using nautilus-python and GObject introspection, supporting two modes of command interpolation (v1 legacy and v2 improved), shell and native tokenization, and extensive filtering based on file type, mimetype, path patterns, permissions, and custom conditions. A graphical configurator is provided as a local web application served by a Python HTTP server, featuring a JSON Schema-driven UI built on a forked json-editor with Ace code editor integration, running entirely locally with no external network calls. Architecturally, the system consists of two main components: the Nautilus extension (Python) and the configurator (Python HTTP server + HTML/JS frontend). The extension hooks into Nautilus via the MenuProvider interface, loads configuration from a JSON file, builds menu items recursively with filtering, and executes commands via subprocess. The configurator is a standalone HTTP server that serves the UI, reads/writes the config file, and can restart Nautilus. Communication between the two is file-based (config.json), with the extension polling for changes every 30 seconds. Key reusable components include a tokenizer for shell and native command lines with context-aware escaping, a placeholder expansion engine with singular/plural support, a config loading and normalization pipeline with validation, and a UI model transformation pattern for schema-driven interfaces. The code is well-structured but lacks automated tests and relies on vendored third-party JavaScript libraries.
This repository is a Kotlin Multiplatform (KMP) library collection designed for rendering rich text and Markdown within Compose applications on Android and Desktop. It consists of several modular artifacts: `richtext-ui` (core UI composables), `richtext-markdown` (AST-based rendering), `richtext-commonmark` (CommonMark parser integration), and theme-specific wrappers (`richtext-ui-material`, `richtext-ui-material3`). The architecture relies on a custom Abstract Syntax Tree (AST) representation of Markdown content, which is traversed recursively to emit Compose composables. While the codebase demonstrates strong engineering practices, particularly in handling deep nesting and large documents, the README explicitly warns that the project is experimental, lacks tests, and has an unclear roadmap. This makes it suitable for prototyping or internal tools but potentially risky for production-critical applications without significant validation.
WPFDevelopers is a comprehensive WPF custom control library (NuGet package `WPFDevelopers`) that provides ~50+ themed UI controls, styles, effects, window chrome customization, system tray integration, screen capture, charts, loading indicators, and utility helpers. It also includes a demo application showcasing each control. The library targets a wide range of .NET versions (4.0 through 10.0) and integrates Win32 interop for advanced shell features. While containing some vendored code (Microsoft Expression Blend SDK) and occasional duplication, the library demonstrates solid engineering practices with reusable controls, attached behaviors, and a consistent theming infrastructure. It is actively maintained with CI builds for multiple frameworks.
Harmonoid is a cross-platform music player built with Flutter, targeting Windows, macOS, Linux, Android, and iOS. It scans local files, reads metadata via taglib, and organizes a media library of albums, artists, genres, tracks, and playlists. Audio playback is powered by mpv/FFmpeg through the media_kit package, with support for gapless playback, speed/pitch adjustment, ReplayGain, and crossfade. The app integrates Last.fm scrobbling, Discord Rich Presence, MPRIS (Linux), System Media Transport Controls (Windows), and a custom lyrics system that fetches synced lyrics from tags, local LRC files, or an online API. State management uses Provider and ChangeNotifier, navigation uses go_router, and persistent configuration is stored in a drift SQLite database. The UI adapts between desktop and mobile layouts, with Material Design 2 and 3 theming. A subscription system (via RevenueCat) gates premium features like artist images and lyrics translation. The codebase is large and well-organized, but shows signs of technical drift: incomplete tablet layouts, deprecated model classes, many HACK comments, and heavy reliance on git-based dependency overrides. Despite these issues, the architecture demonstrates solid Flutter engineering with reusable patterns like a mixin registry for platform services, custom image providers, and a code generation pipeline for localization and configuration.
Linphone Desktop is a production-grade, cross-platform SIP softphone built on the Linphone C++ SDK and wrapped in a Qt6/QML user interface. It delivers audio/video calls, instant messaging (including group chat, file transfer, reactions, and ephemeral messages), conference scheduling, call recording, and presence management across Windows, macOS, and Linux. The architecture follows a strict MVVM split: model classes run on the Linphone SDK thread and expose Qt signals, while GUI-facing 'Core' classes live on the main thread and communicate with models via a custom SafeConnection template that enforces thread affinity. QML views bind directly to these cores, with list proxies (e.g., ListProxy, SortFilterProxy) providing paginated, filterable models for contact lists, call history, and chat logs. The codebase also integrates advanced features like OIDC/OAuth authentication, LDAP/CardDAV address book sync, end-to-end encryption (LIME/DTLS/SRTP), and system-level integrations (toast notifications, tray icons, screen-sharing, autostart) with per-platform backends. The repository is actively maintained with a modern build system (CMake), comprehensive GitLab CI pipelines (Linux, macOS, Windows, Squish GUI tests), and a substantial localization effort (multiple .ts files).
MPC-QT is a desktop media player application that replicates the interface and functionality of Media Player Classic (MPC-HC) using Qt6 and libmpv. It supports local files, discs, network streams, and web videos (via yt-dlp), with advanced playback controls, playlist management, subtitle handling, hardware decoding, and HDR tone mapping. The architecture is a monolithic Qt Widgets GUI with a separation between the UI (MainWindow, SettingsWindow, PlaylistWindow), playback orchestration (PlaybackManager), mpv integration (MpvObject), and cross-platform abstractions (screensaver, device manager). IPC mechanisms include a JSON socket, HTTP server (MPC-HC compatible), and MPRIS D-Bus. The codebase is feature-rich but shows signs of technical debt: large files, manual memory management, hardcoded indices in settings, and incomplete localization. It is actively maintained with CI/CD pipelines for Linux and Windows, but translation files have many unfinished or vanished strings.
NodeGui is a Node.js native addon that wraps the Qt framework to enable building native, cross-platform desktop applications using JavaScript or TypeScript. The architecture consists of two layers: TypeScript wrapper classes (under `src/lib/`) that provide a developer-friendly API, and C++ N-API (node-addon-api) wrappers (under `src/cpp/`) that directly interface with Qt widgets, layouts, and core types. A custom Node.js fork called Qode merges the Qt event loop with Node's event loop, and Facebook's Yoga library provides CSS Flexbox layout integration. The project exposes over 100 Qt widgets, including buttons, dialogs, tables, trees, text editors, menus, system tray, and clipboard, along with a comprehensive set of Qt enums and signal/event handling. The build system uses CMake with reusable modules for Qt, Napi, and Qode support, and the project includes a Docusaurus documentation site with API references and development guides.
This repository is a comprehensive collection of over 1000 Python GUI example applications and tutorials, spanning multiple frameworks: PyQt5, PyQt6, PySide2, PySide6, Tkinter, Kivy, DearPyGui, Flet, NiceGUI, and Streamlit. It serves as an educational resource for developers learning desktop GUI programming, with step-by-step tutorials and full demo applications like calculators, media players, web browsers, games (Minesweeper, Solitaire), paint programs, and data-driven apps (weather, currency, crypto). The codebase is organized by framework, with each framework containing tutorials, demos, and reusable custom widgets. While the examples are functional and well-documented, the repository suffers from massive duplication across Qt bindings (identical logic replicated four times with minor API adaptations), some deprecated API usage (e.g., QWebEnginePage.NavigationType in Qt6, fixer.io API endpoints), and occasional cross-binding import errors. The most valuable parts are the self-contained custom widgets in the widgets/ directories, which demonstrate clean signal-based design and can be extracted into other Qt projects with minimal modification.