This repository is a community distribution and feature-extension framework for OpenAI's ChatGPT desktop application on Linux. It does not contain the core ChatGPT application itself; instead, it verifies, repackages, and patches the official signed upstream .deb package to produce customized builds for multiple Linux package formats (deb, RPM, pacman, AppImage, Nix, Gentoo ebuild). The system adds over 40 optional Linux-specific features—such as system tray integration, global dictation, computer-use automation (window management, accessibility, screenshots), desktop recording/replay, text-to-speech, proxy authentication, and UI tweaks—each gated behind a declarative feature manifest and applied via a sophisticated patch engine that modifies the Electron app bundle at build time. Architecturally, the project is a build/packaging/update framework. The core is a patch engine (scripts/patches/) that applies declarative descriptors to the upstream app.asar in phases (main-bundle, webview-asset, extracted-app). Features live under linux-features/ with standardized manifests (feature.json), patch scripts (patch.js), stage hooks, and tests. Performance-critical subsystems are implemented in Rust: a computer-use backend (window management, input simulation, accessibility tree), a record-replay backend (desktop session capture, timeline events, skill drafting), a text-to-speech MCP server, a global dictation helper, and a self-updating package manager daemon. The launcher (start.sh.template) orchestrates environment setup, feature hooks, and CLI dispatch. Key entry points include the installer (install.sh), the feature picker GUI (scripts/feature-picker.py), the patch runner (scripts/patches/runner.js), and the updater daemon (updater/src/main.rs). Data flows are primarily build-time: the upstream .deb is downloaded, verified via GPG/SHA256, extracted, patched, and repackaged. At runtime, features like computer-use and record-replay communicate with native Rust backends over MCP/JSON-RPC. The updater daemon runs as a systemd user service, polling signed APT metadata and performing transactional rebuilds with rollback support. External dependencies include the upstream OpenAI .deb package (the sole ground-truth source), Node.js for patching, Rust for native components, and various Linux system tools (systemd, D-Bus, GNOME Shell, X11/Wayland utilities, ydotool, wmctrl, xdotool, secret-tool). The build system uses Make, Docker for CI, and supports multiple package managers. The project is heavily dependent on the upstream bundle's minified JavaScript structure, which it manages through contract-based patching with drift detection.
plwm is an X11 dynamic tiling window manager written in Prolog. It features a modular architecture with separate Prolog modules for window management logic, layouts, menus, settings, and utilities, combined with C bindings to X11 libraries via SWI-Prolog's FFI. The system processes X11 events in a main event loop, manages window state through dynamic predicates, and provides multiple interaction methods including keyboard shortcuts, dmenu/rofi menus, and a scriptable command FIFO. Key entry points include the main Prolog file (src/plwm.pl), build system (Makefile), and installation script (tools/install.sh). External dependencies include X11 libraries (libX11, libXft, libXrandr) and SWI-Prolog.
bspwm is a tiling window manager for X11 that represents windows as leaves of a full binary tree. It uses a client-server architecture: the `bspwm` daemon manages windows and desktops, while the `bspc` command-line client communicates with it over a Unix domain socket. The daemon does not handle input directly; instead, an external helper like `sxhkd` invokes `bspc` to perform actions. Configuration is done via shell scripts (`bspwmrc`) that call `bspc` commands, and the state can be dumped to JSON for restoration. The project is written in C99 with XCB (X11 C Bindings) and supports EWMH/ICCCM standards, multi-monitor setups (RandR/Xinerama), a rule system for window matching, and event subscriptions for external tools like panels.
jgmenu is a lightweight, standalone X11 menu application written in C, designed for scripting, modding, and tweaking. It renders menus using Cairo and Pango, reading menu data from CSV files or piped commands. The architecture is modular: a core menu engine (src/jgmenu.c) handles event loops, drawing, and item management, while separate generators (jgmenu-apps, jgmenu-ob, jgmenu-lx, jgmenu-pmenu) produce CSV data from .desktop files, Openbox XML, or XDG menus. Configuration is via a jgmenurc file with 80+ options, and IPC via Unix sockets enables integration with tint2 and XFCE panels. The codebase demonstrates strong C engineering practices: banned unsafe functions, custom safe string buffers (sbuf), a generic linked list (list.h), a hashmap, and a CSV parser with triple-quote support. It includes a comprehensive test suite using a sharness-like framework and CI via GitHub Actions. While tightly coupled to X11, the utility modules are cleanly isolated and reusable in other C projects.
XLibre Xserver is a community-managed fork of the X.Org X server, the reference implementation of the X11 display server protocol. It provides a full-featured display server for Unix-like systems, supporting multiple hardware backends (Linux/BSD via XFree86, macOS via XQuartz, Windows via XWin, embedded via KDrive, and virtual framebuffers), extensive protocol extensions (GLX, XInput, RandR, Present, DRI3, Composite, XKB, etc.), and GPU-accelerated rendering through Glamor (OpenGL) and EXA. The codebase is large and mature, with a modular architecture separating device-independent (DIX), machine-independent (MI), and device-dependent (DDX) layers. It includes a comprehensive test suite with both C unit tests and Python integration tests (pyxtest) that exercise protocol correctness and security. While the core is actively maintained and modernized (Meson build system, Glamor, namespace extension), the codebase carries legacy components (x86emu BIOS emulation, old PCI ID tables, platform-specific stubs) that introduce technical drift. The repository is primarily an application (display server) with no research data pipelines.
Notion is an X11 window manager with tiling, tabbing, and floating layout capabilities. It features a modular architecture where core functionality resides in ioncore/ and extends via loadable modules (mod_tiling, mod_menu, mod_statusbar, etc.). Configuration and extensibility are driven by Lua scripts, allowing deep customization of key bindings, layouts, and status bar elements. The system handles X11 events, manages window geometry and focus, and provides session saving/restoring. Key components include a reference-counted object system (libtu/obj), Lua-C binding layer (libextl), hook system (libmainloop/hooks), and binding maps for contextual input handling. Despite its age, the codebase shows recent activity and maintains compatibility with modern X11 environments.
Weylus is a cross-platform application that turns tablets and smartphones into graphic tablets/touch screens for computers. It operates by running a local web server that serves a web page to the tablet's browser. The web page captures pointer, touch, stylus, keyboard, and wheel events via JavaScript PointerEvents and sends them over a WebSocket connection to the server. The server then simulates these input events on the host machine using platform-specific mechanisms: on Linux it uses the uinput kernel module for full stylus/touch/mouse/keyboard support; on macOS and Windows it falls back to the autopilot library for mouse/keyboard simulation and Windows-specific synthetic pointer injection for touch/pen. Simultaneously, Weylus captures the screen (or a selected window/monitor) using platform-native APIs: X11 shared memory (XShm) on Linux X11, PipeWire/GStreamer on Wayland, CoreGraphics on macOS, and DirectX via captrs on Windows. The captured frames are encoded into a fragmented MP4 H.264 video stream using a statically linked ffmpeg (libx264) with optional hardware acceleration (VAAPI, NVENC, VideoToolbox, MediaFoundation). The video stream is sent to the browser via the same WebSocket connection and played using the Media Source Extensions API. The application provides a GUI (built with FLTK) for configuration and a headless mode for automation. It supports access codes, custom input areas, and multiple simultaneous clients.
XCap is a cross-platform screen capture library written in Rust, supporting Linux (X11, Wayland), macOS, Windows, and HarmonyOS (OHOS). It provides a unified API for capturing images of monitors and windows, as well as video recording (currently work-in-progress). The library abstracts platform-specific implementations behind common `Monitor`, `Window`, and `VideoRecorder` structs, using native APIs such as XCB, PipeWire, CoreGraphics, AVFoundation, GDI, Windows Graphics Capture, and OHOS PixelMap. It is well-structured with clean error handling and modular platform modules, though some features like Wayland capture and window recording are still incomplete. The codebase demonstrates solid Rust engineering practices and is actively maintained.
Conky is a free, lightweight system monitor for X11, Wayland, and macOS that displays system information on the desktop or in alternative output modes (console, file, HTTP). It collects data from /proc, /sys, sysctl, and various APIs to report CPU, memory, disk, network, processes, sensors, audio players, mail, RSS, and more. The architecture is modular: data sources are registered as text objects with scan/print/free callbacks, output backends are selected at runtime (X11, Wayland, ncurses, console, file, HTTP), and Lua scripting provides configuration and extensibility via tolua++ generated bindings. A callback system handles periodic data fetching with deduplication and thread safety, and a priority queue supports top process sorting. The codebase is written in C++ with some C, uses CMake build system, and includes a comprehensive test suite using Catch2. It supports Linux, BSDs, Haiku, Solaris, and macOS with platform-specific backends. The project demonstrates several well-crafted reusable components: a generic priority queue, a callback system for periodic tasks, a typed configuration settings framework with Lua integration, a structured logging wrapper around spdlog, and a macro-generated X11 event variant pattern. These components exhibit non-obvious skill and can be extracted for use in other C++ projects. However, the codebase also shows signs of technical drift with bundled third-party libraries (Vc, tolua++, spdlog) that may lag behind upstream, and some platform-specific backends have incomplete implementations.
picom is an X11 compositor that provides desktop visual effects such as window shadows, fading, blur, rounded corners, and animations. It is a fork of Compton and serves as a lightweight compositing manager for X11 window managers. The system is built around a modular architecture with pluggable rendering backends (XRender and OpenGL), a damage-based incremental renderer, a window tree manager, and a custom animation scripting engine. Key entry points include the main session initialization in `src/picom.c`, the event loop driven by libev, and the backend initialization. Data flows begin with X11 events (e.g., window creation, property changes) processed by the event handler, which updates the window tree and triggers damage computation. The renderer then builds a list of backend commands from window layers, applies damage culling, and presents the final image via the selected backend. External dependencies include X11 libraries (xcb, xlib, xrender, xdamage, xcomposite, xpresent, xrandr), libconfig for configuration, libev for event handling, pixman for region operations, and optional OpenGL, dbus, and pcre2. The project is actively maintained with a comprehensive test suite and CI/CD pipelines.
feh is a lightweight, configurable X11 image viewer and cataloguer written in C. It provides multiple viewing modes: slideshow, index (montage), thumbnail browser, multiwindow, file list, and wallpaper setting. The application relies on Imlib2 for image loading and rendering, with optional support for libcurl (HTTP/HTTPS), libexif (EXIF metadata), Xinerama (multi-monitor), inotify (auto-reload), and libmagic (MIME detection). The codebase is modular, featuring reusable generic data structures (doubly linked list, hash table, Imlib2 wrapper) and a format specifier system for actions, captions, and titles. It is a mature, stable project with a long history (since 1999) and an extensive test suite using X11::GUITest. However, it shows signs of technical drift: manual memory management, legacy code comments, deprecated options, platform-specific conditionals, and reliance on external tools like dcraw and ImageMagick for certain image formats. The project is actively maintained with regular releases.
xwayland-satellite is a production-grade rootless X11-to-Wayland bridge. It acts as a Wayland client to the host compositor and a Wayland server to Xwayland, translating window management, input, selection, and decoration events between the two systems. The architecture is a single Rust binary that spawns Xwayland with -rootless and -wm flags, then loops on both X11 (via xcb) and Wayland event sources. Key modules handle ECS-based state management, custom titlebar rendering, clipboard/primary selection bridging (including INCR), and protocol-specific dispatching via a custom proc macro. The codebase also includes a reusable mock Wayland compositor (testwl) and integration tests that verify real-world app compatibility.
ClusterSSH is a Perl-based cluster administration tool that provides a graphical console (using Tk) to manage multiple SSH (or other protocol) sessions simultaneously. It allows users to define clusters via configuration files, expand hostnames using shell-style ranges, and replicate keystrokes from a master console to all connected terminal windows. The architecture is monolithic, centered around the App::ClusterSSH module, with distinct sub-modules handling configuration, cluster resolution, host parsing, and window management via X11::Protocol. It relies heavily on the X11 protocol for event injection into child xterm processes, making it tightly coupled to X11 environments but highly effective for its specific use case of synchronized cluster management.