Ulauncher is a fast, keyboard-driven application launcher for Linux (X11/Wayland) written in Python with GTK3. It provides a global hotkey-activated search window that queries multiple sources: installed applications via .desktop files, a file browser with special path prefixes, a calculator, user-defined shortcuts (scripts/URLs), and a rich extension system. Extensions run as separate subprocesses and communicate via Unix sockets using a JSON-line IPC protocol, supporting installation from git URLs or local directories. The main process manages result buffering, keyword caching, query history, and a preferences window with theme selection, hotkey configuration, and extension management. Architecturally, Ulauncher is a single-process desktop application with a clear mode-based query routing engine. Key entry points include the CLI (`ulauncher` start/show/toggle, install/uninstall/upgrade/preview extensions) and the D-Bus-activated Gtk.Application. The codebase is highly modular with isolated utility modules (EventBus, Fallible, scheduling, subprocess utilities) that demonstrate non-trivial integration of Python patterns with the GLib event loop. The extension lifecycle is robust, with per-process state machines, error categorization, and atomic disk operations for installs/updates. The repository is actively maintained (recent commits, CI/CD pipelines, performance regression tracking, and architecture documentation). Dependencies are pinned via requirements.txt and setuptools. The code exhibits low technical drift: GTK3 is stable, deprecated APIs are isolated to compatibility layers, and the project explicitly manages backward compatibility with v2 extension API. The codebase is well-structured, with significant test coverage across all modes and utilities, making it a solid reference for integrating Python with GLib/GTK and building desktop application plugin systems.
Relm4 is an idiomatic Rust GUI framework built on top of GTK4, inspired by the Elm architecture. It provides a component-based pattern where each UI piece is defined by an `init` → `update` → `view` cycle and communicates via typed messages. The framework includes a declarative macro system (`view!`, `#[component]`, `menu!`) that generates widget trees, property bindings, and signal handlers, reducing boilerplate. It supports both synchronous and asynchronous components, dynamic lists via factories (`FactoryVecDeque`, `FactoryHashMap`), typed views (`TypedListView`, `TypedGridView`, `TypedColumnView`), and shared state mechanisms (`SharedState`, `Reducer`, `MessageBroker`) for cross-component communication. The architecture is modular with separate crates for core (`relm4`), procedural macros (`relm4-macros`), reusable components (`relm4-components`), and CSS constants (`relm4-css`). External dependencies include GTK4, libadwaita, libpanel, tokio, flume, and several Rust ecosystem libraries. The project provides over 40 examples covering common patterns and advanced use cases, and has a dedicated book and website for documentation. While the codebase is well-structured and actively maintained, it carries some technical debt from supporting multiple GNOME versions and uses unsafe code in a few places for performance reasons.
Wails is a Go framework for building cross-platform desktop applications using web frontends (HTML/CSS/JS). It provides a CLI tool for project scaffolding, development server, and building. The architecture consists of a Go backend that communicates with an embedded WebView via a binding system that auto-generates TypeScript/JavaScript wrappers for Go services. It supports Windows (WebView2), macOS (WebKit), Linux (GTK/WebKit), and mobile (iOS/Android). Key entry points include `application.New()` in v3 and `wails.Run()` in v2. External dependencies include the WebView2 runtime on Windows, WebKitGTK on Linux, Cocoa on macOS, and various system libraries. The repository contains both v2 (legacy) and v3 (current) versions, with v3 introducing a new binding generator, built-in task runner (`wake`), improved service lifecycle, and cross-platform scaffolding.
WiiUDownloader is a cross-platform desktop application written in Go that downloads Wii U games, updates, DLC, and demos directly from Nintendo's CDN servers. It is the primary open-source replacement for the abandoned Wii U USB Helper. The application provides a GTK3-based GUI (via gotk3) on all three major platforms, with a command-line core library. Key features include automatic decryption using embedded common keys and title keys derived from PBKDF2, resume-capable downloads with SHA-256 segment verification via a journal file, hash-tree validation for hashed content, FST/U8 archive extraction, and a queue-based batch download system. The architecture cleanly separates the core download/decryption logic (root package) from the GUI (cmd/WiiUDownloader), with reusable internal format parsers for TMD, FST, and U8. No title keys are required; the system generates tickets and certificates on the fly. The project is actively maintained, with recent commits and CI/CD pipelines producing Windows, macOS, and Linux builds.
GirCore is a comprehensive C# binding generator and runtime library for GObject-based native libraries (GTK, GStreamer, WebKit, Cairo, etc.). It reads GObject Introspection (GIR) XML files and produces strongly-typed C# bindings with P/Invoke declarations, SafeHandle memory management, and high-level managed APIs. The architecture consists of a generation pipeline (GirLoader parses GIR, GirModel defines an interface-based intermediate representation, Generator applies fixers and renders C# code via a modular converter system) and a set of runtime libraries (GLib, GObject, Gtk, etc.) that provide safe wrappers, signal handling, subclassing support, and platform abstraction. Key entry points include the GirTool CLI for regeneration, Module.Initialize() for library initialization, and Roslyn source generators/analyzers for GObject subclassing and GTK composite templates. The project is pre-1.0 but actively used by several desktop applications and the .NET MAUI Linux backend.
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.
gtklock is a GTK-based lockscreen for Wayland compositors. It locks the screen using the ext-session-lock protocol and authenticates users via PAM. The application creates a window for each monitor displaying a clock, date, and password entry. It supports features like idle hiding, multi-monitor focus following, and running custom commands on lock/unlock events. The architecture is modular, with a core GTK application loop, pluggable modules for extensibility, and isolated subsystems for authentication and configuration. The main entry point is in src/source.c, which initializes the GTK application, loads configuration and modules, and sets up event handlers for screen locking and unlocking.
DeaDBeeF is a cross-platform desktop music player with a modular plugin architecture. It supports a vast array of audio formats including MP3, AAC, FLAC, Ogg Vorbis, Opus, WavPack, Musepack, DTS, and numerous chiptune and video game music formats (SID, NSF, VGM, MOD, S3M, XM, IT, PSF, etc.) through bundled emulation libraries. The core player handles playlist management, metadata caching, replaygain, DSP chain processing, and streaming. Two native GUI implementations exist: a GTK2/GTK3 interface for Linux and a Cocoa interface for macOS, both offering full-featured playback controls, media library browsing, cover art display, and visualization (scope, spectrum analyzer). The player also includes a converter plugin, MPRIS integration, and extensive keyboard shortcut customization. The architecture is centered around a lightweight plugin API (DB_plugin_t) that decouples decoders, outputs, DSP effects, and UI components. The core library (libdeadbeef) provides threading, file I/O, configuration, and message passing. Plugins are loaded dynamically and register themselves via a factory pattern. The media library plugin uses SQLite for indexing and file system watchers (inotify on Linux) for automatic updates. Artwork is fetched from embedded tags and online services (Last.fm, MusicBrainz) with a local cache. The build system uses autotools, premake5, and Xcode projects, with Docker-based CI for Linux, macOS, and Windows. Key data flows include: file opening via VFS abstraction → decoder plugin → decoded audio blocks (ring buffer) → DSP chain → output plugin. Metadata flows from file tags through a caching layer to the UI and media library. The player supports CUE sheets, gapless playback, and crossfading. External dependencies include GTK2/GTK3, libcurl, libsamplerate, and various codec libraries (libmpg123, libmad, libvorbis, libFLAC, etc.), many of which are bundled as source for portability.
Clapper is a modern media player application designed for the GNOME desktop, built with GTK 4 and powered by GStreamer. It features a queue-based playback system supporting sequential, repeat, carousel, and shuffle modes, along with standard media controls like play/pause, seeking, volume adjustment, and fullscreen toggling. The application emphasizes usability with an adaptive interface, subtitle/audio track selection, playback speed control, and media information display showing technical details such as codecs and bitrates. The architecture consists of three main layers: a core library (`clapper`) handling playback logic, queue management, and extensibility via plugins; a GTK library (`clapper-gtk`) providing reusable widgets like video display, buffering indicators, and custom layouts; and the main application (`clapper-app`) assembling the user interface and integrating with the core. Extensibility is achieved through a libpeas-based plugin system for metadata extraction, playlist parsing, and reactive components, while optional features like MPRIS and a built-in web server for remote control are marked as deprecated in favor of the external enhancer ecosystem. Clapper demonstrates strong engineering practices with proper GObject encapsulation, thread-safe design using a custom `ClapperThreadedObject` base class, and adherence to GTK 4 patterns such as template-based widgets and action-driven UI. The project maintains active development with recent commits, comprehensive internationalization support, and integration with modern GNOME technologies like libadwaita, though it relies on evolving dependencies (GStreamer, GTK) and contains some deprecated components requiring ongoing maintenance.
LGI is a dynamic Lua binding to GObject-based libraries using gobject-introspection. It allows using GObject-based libraries directly from Lua. The repository contains the LGI package, which provides a way to define new properties on custom GObject subclasses implemented using LGI. It supports subclassing GObject and implementing virtual methods in Lua.
Foliate is a desktop e-book reader for GNOME/Linux, built with GTK4, Libadwaita, and GJS (GNOME JavaScript). It supports EPUB, Mobipocket, Kindle, FB2, CBZ, and PDF formats, using WebKitGTK to render book content via a custom JavaScript rendering engine (foliate-js). The application provides a full-featured reading experience with paginated and scrolled modes, customizable fonts and themes, annotations (highlights, notes, bookmarks), text-to-speech via Speech Dispatcher, OPDS catalog browsing, and dictionary/Wikipedia lookups. Architecture: The main entry point is src/main.js, which initializes the GJS application and loads the GResource-bundled source files. The core UI is defined in src/app.js (window creation, file handling) and src/book-viewer.js (reading view with sidebar, search, navbar, TTS). The library view (src/library.js) manages book collections and OPDS integration. Reading state (annotations, bookmarks, progress) is persisted per-book as JSON files in the user's data directory. The rendering pipeline lives in the WebView: src/reader/reader.js handles content display, CSS injection, and footnotes, while the foliate-js submodule parses e-book formats into a pageable model. External dependencies: GNOME platform (GTK 4.12, Libadwaita 1.8, WebKitGTK 6.0, GJS 1.82), Speech Dispatcher for TTS, Tracker (optional) for file indexing, and third-party APIs (Wiktionary, Wikipedia, Google Translate) for lookup tools. The build system uses Meson, with Flatpak and Snap packaging provided. Internationalization across 30+ languages is maintained via gettext PO files. Data flows: User opens a file → book is parsed by foliate-js into a structured document model → rendered in WebView → user interactions (scroll, search, annotate, bookmark) are communicated back to GJS via the WebView's async RPC pattern (exec/iter/provide) → state is persisted as JSON files. OPDS catalogs are fetched via HTTP and rendered in a separate WebView frontend (src/opds/main.html).
Live Photo Converter is a cross-platform application for processing Android Live Photos (MVIMG files). It provides a modern GTK4/LibAdwaita graphical interface, a set of command-line tools, and a shared library (`liblivephototools`) for creating, extracting, and repairing these files. The core operation involves appending an MP4 video to a JPEG image and managing the associated XMP metadata (Google's GCamera and Container namespaces). It also supports generating long exposure photos from video frames and copying metadata between images. The architecture is a well-structured monolith written in Vala and built with Meson. The core logic resides in a shared library, with CLI and GUI frontends linking against it. Video processing is handled by a clean strategy pattern, defaulting to an in-process GStreamer pipeline with an FFmpeg subprocess fallback. The build system is highly sophisticated, supporting Linux (Flatpak, Arch), Windows (MSYS2), macOS (Homebrew), and Android (experimental, via pixiewood). The codebase demonstrates strong software craftsmanship. It features clean abstractions (abstract base classes `LivePhoto`/`LiveMaker`), meticulous thread safety (GOnce, AtomicInt, AsyncQueue, Mutex), and well-encapsulated utility components. The `PipelineWatch` class for GStreamer error handling and the `Reporter` class for CLI output are particularly well-crafted and reusable. The primary weakness is the absence of a formal unit test suite, which prevents a higher quality score.
Collision is a desktop application for generating and verifying cryptographic hashes of files. Built with Crystal, GTK 4, and libadwaita, it provides a clean GUI interface to calculate MD5, SHA-1, SHA-256, SHA-512, Blake3, CRC32, and Adler32 hashes. The application features concurrent hash calculation using Crystal's fiber system, a Nautilus extension for file manager integration, and proper handling of Flatpak sandboxed environments. It follows a modular architecture with separate concerns for UI, core functionality, and application logic.
Packet is a GTK4/libadwaita desktop application for Linux that implements the Google Quick Share protocol, enabling wireless file transfer between Linux and Android devices. The application discovers nearby devices via Bluetooth and mDNS over Wi-Fi, and supports sending files, text, links, and Wi-Fi passwords. It integrates deeply with the GNOME desktop: a Nautilus plugin adds a "Send with Packet" context menu, a D-Bus API allows external control, and it can run in the background with a system tray icon. The codebase is written in Rust, using the `rqs_lib` library for the Quick Share protocol logic. The architecture follows a standard GtkApplication pattern with custom GLib object types for transfer state, asynchronous file operations using tokio, and a modular widget system for transfer cards. The code is well-structured overall, though the main window file is large and some FIXMEs indicate areas for improvement. The project has active maintenance, comprehensive localization (30+ languages), and a CI pipeline.
GNvim is a GTK4-based Neovim GUI written in Rust. It communicates with Neovim via the MessagePack-RPC protocol, providing a native desktop experience with features like floating windows, popup menus, tabline, cmdline, and smooth animations for cursor and scrolling. The architecture is a single Rust binary split into a workspace: the main `ui` crate contains the GTK4 frontend with custom widgets (e.g., Grid, GridBuffer, Cursor, Fixedz, Popupmenu, Shell), and the `nvim-rs` library crate provides a reusable, async RPC client for Neovim with auto-generated API bindings. The system's entry point is `ui/src/main.rs`, which registers resources and launches the GTK application. Data flows bidirectionally: Neovim sends UI events (redraw, options, notifications) as RPC messages, which are deserialized into Rust types and applied to the GTK widget tree; user input (keyboard, mouse) is captured by GTK event controllers and sent back to Neovim as RPC calls. The codebase is well-structured, modular, and follows modern Rust async patterns, with extensive use of GTK4's property system and custom layout managers for complex UI composition.
amsynth is a free and open-source analog modeling software synthesizer. It implements classic subtractive synthesis with dual oscillators, a resonant low-pass filter, ADSR envelopes, LFO, distortion, and reverb. The system is designed for real-time audio and MIDI processing, supporting polyphony, portamento, pitch bend, and microtonal tuning via Scala files. It can run as a standalone application using JACK, ALSA, or OSS audio drivers, or as a plugin in LV2, VST2, DSSI, and AudioUnit formats. The architecture separates the core synthesis engine (Synthesizer, VoiceAllocationUnit, VoiceBoard) from the GUI (JUCE-based with a skinnable control panel) and plugin wrappers, all sharing a common parameter system with observer pattern and value smoothing. The repository includes a large collection of preset banks, a configuration system, and internationalization support. External dependencies include JUCE for the GUI, freeverb for reverb, MTS-ESP for microtonal support, and NSM for session management.
This repository provides the elementary-xfce icon theme, a fork of the elementary icon set maintained for the Xfce desktop environment and compatible with other GTK-based desktops. It contains thousands of SVG icons organized by context (actions, apps, categories, devices, emblems, emotes, mimetypes, places, status) and size (16px to 128px plus scalable symbolic variants). The build pipeline converts SVGs to PNGs for fixed-size contexts using a custom C utility (svgtopng) and gdk-pixbuf, while preserving scalable SVGs for HiDPI support. The theme includes symlinks for backward compatibility with icon names dropped by upstream elementary. The repository also includes autotools-based build infrastructure, a pre-commit hook for SVG optimization, and GitHub Actions CI for symlink validation and theme packaging. The primary output is a set of icon files installed to the system's icon theme directory, consumed by the desktop environment's icon theme engine.
Astal is a collection of GObject-based libraries for building Wayland desktop shells and widgets on Linux. It provides reactive primitives (Variable, Binding) for declarative state management, along with wrappers for system services like NetworkManager, UPower, Bluetooth, MPRIS, audio (WirePlumber), system tray, and compositor-specific protocols (Hyprland, River, ext-workspace). The framework supports multiple frontend languages (GJS/TypeScript, Lua, Python) and both GTK3 and GTK4 via separate library targets. Examples demonstrate complete status bars and widget systems. The architecture is modular: core reactive abstractions live in `lang/gjs` and `lib/astal/io`, while domain-specific libraries under `lib/` expose GObject signals and properties for hardware and desktop services. Build system is Meson with Vala/C sources, GObject Introspection for bindings, and Nix flake for reproducible packaging. The documentation site uses VitePress. The project is actively maintained but in early development (v0.1.0 WIP). It shows strong engineering practice with well-structured reactive patterns and clean GObject usage, though there is duplication across language bindings and some deprecated APIs remain (e.g., AstalIO.Variable). The codebase is feature-rich and immediately usable for building custom Linux desktop environments.
gImageReader is a mature, feature-rich desktop application that serves as a graphical frontend to the Tesseract OCR engine. It allows users to import images, PDFs, and DjVu documents, perform optical character recognition (OCR) with automatic or manual layout detection, and export the recognized text as plain text, hOCR (HTML-based OCR), PDF, or ODT. The application also integrates with scanner hardware via SANE (Linux) and TWAIN (Windows) backends, supports batch processing, and includes a spell checker, find/replace, and a substitution manager for post-processing. It is written in C++ and provides two parallel user interfaces: one using GTK+3 (gtkmm) and another using Qt5/Qt6, sharing a common core library in the `common/` directory. The architecture is a classic desktop monolith with a clear separation between the UI layer (GTK or Qt) and the backend logic (OCR, file handling, export). The codebase is well-organized with dedicated modules for scanning, image display, recognition, output editing, and export. Notable design patterns include a CRTP-based settings system (`ConfigSettings`), a custom tree model for file lists, and a worker-thread pattern for background scanning and rendering. The project has been actively maintained for over a decade, with recent commits and a large user base, though the dual-frontend approach introduces code duplication and maintenance overhead. While the application is not a research project, it demonstrates solid software engineering practices for a desktop GUI application. The most reusable components are the isolated utility classes in the `common/` directory, such as the CCITT Fax4 encoder, paper size definitions, and language mapping tables. These can be extracted and reused in other document-processing or PDF-generation projects with minimal modification. The overall code quality is good, with some areas showing age (e.g., version compatibility macros, WIP proofreading widget) but still functional and well-tested by the community.
Pipe Viewer is a Perl-based YouTube client providing both a CLI (`pipe-viewer`) and a GTK3 GUI (`gtk-pipe-viewer`). It allows users to search, stream, download, and manage YouTube content including videos, playlists, channels, comments, and captions. The core library `WWW::PipeViewer` abstracts YouTube data extraction via direct web scraping (ytInitialData, protobuf) and the Invidious API, with yt-dlp as a fallback for streaming URLs and comments. The architecture separates network resilience, caching, and format handling into reusable Perl modules (`DiskCache`, `Proto`, `ParseJSON`, etc.), though the CLI and GUI scripts are monolithic and tightly coupled to the library. External dependencies include `mpv`/`vlc` for playback, `yt-dlp` for advanced extraction, and `ffmpeg` for conversion. The project is actively maintained but operates on fragile, unofficial YouTube interfaces, making it susceptible to upstream changes.