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.
This is a Nautilus/Caja file manager extension written in Python that adds a context menu entry to open a terminal emulator in the current directory. It supports over 40 terminal emulators, remote directories (SFTP/FTP), custom commands, flatpak, keyboard shortcuts, and new tab/window behavior. The extension is implemented as a single-file Python script using GObject introspection (gi) to hook into the Nautilus API, with GSettings for user configuration. It provides localized strings via gettext translations. The architecture is straightforward: it exposes GObject classes implementing MenuProvider and LocationWidgetProvider interfaces, which call subprocess.Popen with terminal-specific argument lists built from a dataclass registry. Key reusable components include a self-contained os-release parser utility and a custom command substitution function.
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.
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).
Tiling Shell is a GNOME Shell extension that provides advanced, customizable window tiling and management. It replaces the default window snapping with a flexible layout system where users can define custom tile arrangements (via a built-in editor or JSON files), use snap assist for precise placement, enable edge tiling with multiple modes (default, adaptive, granular), and auto-tile new windows. The extension also adds a panel indicator, keyboard shortcuts, window border customization with dynamic corner radius detection, and a window suggestions feature that proposes layouts after tiling. The architecture follows a manager pattern: per-monitor subsystems (TilingManager, ResizeManager, WindowBorderManager, RaiseTogetherManager) are created and destroyed by the main extension lifecycle. Communication is event-driven via GObject signals, with a central GlobalState singleton and a Settings wrapper around GSettings. The codebase is written in TypeScript, compiled for GJS, and supports GNOME Shell versions 42–50 on both X11 and Wayland. It includes a complex build pipeline that produces separate outputs for modern and legacy GNOME versions, along with full internationalization (10+ languages). While the extension is actively maintained and feature-rich, it relies heavily on private GNOME Shell APIs and contains version-specific workarounds, which introduces maintenance risk as the shell evolves.
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.
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.
Guake is a drop-down terminal emulator for the GNOME desktop environment, inspired by the Quake game terminal. It provides a fast, keyboard-driven terminal that slides down from the top of the screen with a single keystroke (default F12). The application is built with Python 3, GTK3, and VTE (Virtual Terminal Emulator), and uses GSettings for configuration, D-Bus for remote control, and Glade for UI layout. It supports tabs, split terminals, customizable color palettes, background images, transparency, session save/restore, workspace-aware tab sets, and extensive keyboard shortcuts. The architecture is modular, with separate modules for preferences, keybindings, terminal management, and utilities, though some files (e.g., guake_app.py, prefs.py) are large and tightly coupled. The codebase shows signs of technical debt such as deprecated GTK APIs, Python 2 compatibility remnants, and partial Wayland support, but remains actively maintained with a comprehensive CI pipeline and regular releases.
dconf2nix is a CLI tool and Haskell library that converts GNOME dconf configuration files into Nix expressions for use with Home Manager's dconf.settings option. It parses the GVariant text format using Parsec combinators, supporting a wide range of dconf value types (booleans, integers, floats, strings, byte strings, tuples, lists, variants, dictionaries, typed values, and JSON). The parser is comprehensive and handles edge cases such as hexadecimal and octal integers, scientific notation, Unicode escapes, and nested structures. The rendered output uses Home Manager's lib.hm.gvariant constructor functions to produce valid Nix code. The architecture cleanly separates parsing (DConf module), data model (DConf.Data), and Nix rendering (Nix module), with a small CLI entry point. The codebase is well-tested with 20+ test cases covering various dconf input patterns and their expected Nix output.
WhiteSur-icon-theme is a popular Linux desktop icon theme that replicates the macOS Big Sur aesthetic. The repository consists of thousands of hand-crafted SVG icons organized into standard icon theme categories (actions, apps, devices, etc.) and a single Bash install script (`install.sh`). The script copies icons to the user's local icon directory or system-wide, optionally installing alternative, bold, or KDE Plasma variants, and runs `gtk-update-icon-cache`. There are no application components, tests, or CI/CD pipelines; the project is purely a design asset distribution with a minimal functional entry point. The icons are the product, and the install script is the delivery mechanism. The theme is actively maintained with frequent updates and broad community support.
SparkleShare is a cross-platform desktop file synchronization application that uses Git as its backend, similar to a self-hosted Dropbox. It provides a system-tray-based GUI for Linux (GTK+), macOS (Cocoa), and Windows (WPF), allowing users to sync folders with remote Git repositories via SSH. The application supports encryption (AES-256-CBC), Git LFS for large files, and real-time sync signals via a centralized announcement service. The core sync logic is implemented in the shared 'Sparkles' library, with platform-specific controllers and UIs. The codebase is written in C# using Mono/Xamarin and targets .NET 4.5. The project has been in maintenance mode since its last release in November 2020, with the author seeking sponsors. The architecture is a monolith with a shared core and platform-specific frontends, but the technology stack is aging (GTK+2, WebKit, jQuery 1.6.1) and the build system is fragmented (meson + legacy .csproj). There is minimal test coverage and several abandoned features (e.g., listener layer). Despite these issues, the core sync engine and SSH abstraction demonstrate reasonable engineering for its era.