DevilutionX is a modern C++ source port of the 1996 action role-playing game Diablo and its Hellfire expansion. It is a monolithic game engine that reimplements the original game's logic, rendering, audio, and networking from scratch, requiring the original game data files (DIABDAT.MPQ or spawn.mpq) to run. The architecture is highly cross-platform, targeting modern desktops (Windows, Linux, macOS), consoles (PS4, PS5, Switch, Xbox, Vita, 3DS), retro platforms (Amiga, DOS), and embedded devices (Miyoo Mini, OpenDingux), all managed through a sophisticated CMake build system. The codebase is data-driven, loading game content (monsters, items, spells, levels) from tab-separated value (TSV) files and original MPQ archives. It features a robust Lua scripting engine for modding, a comprehensive input abstraction layer supporting keyboard, mouse, gamepad, and touch, and a modular networking stack supporting TCP and ZeroTier P2P multiplayer. The project maintains an extensive test suite using GoogleTest and GoogleBenchmark, including deterministic dungeon generation tests and performance benchmarks. While the codebase exhibits tight coupling inherent to game engine development and carries significant platform-specific conditional compilation (#ifdef sprawl), it contains several high-quality, isolated utility components that are safely reusable. These include a robust INI parser, a fixed-capacity static vector, endian-safe I/O helpers, an A* pathfinding implementation, and a KD-tree for color quantization. The code is written in modern C++ (C++17/20 style) with pervasive use of std::expected for error handling, demonstrating strong engineering practices despite the complexity of its domain.
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.
mkosi is a command-line tool for building customized, bootable OS images. It wraps distribution package managers (dnf, apt, pacman, zypper, apk) and deeply integrates with systemd components (systemd-nspawn, systemd-repart, systemd-boot, systemd-vmspawn, ukify) to produce disk images, containers, unified kernel images, initrds, and extension images. The tool supports multiple output formats (disk, tar, cpio, uki, esp, sysext, confext, portable, oci, directory, addon) and can generate images for a wide range of Linux distributions including Fedora, Debian, Ubuntu, Arch, CentOS, openSUSE, and more. The architecture is a modular Python application with a central build pipeline orchestrated in mkosi/__init__.py. Configuration is handled via layered INI-style files with conditional [Match]/[Assert] sections, allowing complex multi-image builds. A sandbox abstraction (sandbox.py) isolates tool execution using Linux namespaces, mounts, and seccomp filters. Distribution-specific installers are registered via a class registry pattern in mkosi/distribution/__init__.py. The tool also provides standalone subcommands: mkosi-initrd, mkosi-addon, mkosi-sandbox, each with its own entry point. Key features include incremental caching, SecureBoot signing, verity and TPM support, kernel-install integration, tools tree for reproducible builds, and a comprehensive manifest generation. The codebase is well-structured with clear separation between configuration, sandboxing, package management, and image creation. It has extensive tests (pytest with integration markers) and active CI.
This repository provides a collection of shell scripts to automate the setup and management of an IPsec VPN server on Linux. It supports multiple VPN protocols (IPsec/L2TP, IPsec/XAuth, IKEv2) and a wide range of Linux distributions including Ubuntu, Debian, CentOS, Rocky Linux, AlmaLinux, Oracle Linux, and Alpine Linux. The main entry point is `vpnsetup.sh`, which detects the OS and runs the appropriate installer. The project also includes helper scripts for user management, IKEv2 certificate handling, upgrades, and uninstallation. Additionally, it offers an Azure ARM template for cloud deployment. The code is well-structured with OS-specific installers, common bash utility functions, and extensive documentation in multiple languages. It is a mature, widely-used DevOps tool for system administrators.
Jitsi Meet is an open-source video conferencing platform that provides real-time communication with features such as HD audio/video, screen sharing, chat, polls, breakout rooms, recording, live streaming, virtual backgrounds, and end-to-end encryption. The architecture is client-server: the web and mobile clients (React/React Native) communicate via XMPP (Prosody server) for signaling and WebRTC for media, with optional server-side components like Jitsi Videobridge and Jicofo for scalable conferencing. The codebase is organized into feature modules under `react/features/`, each with its own Redux actions, reducers, middleware, and platform-specific UI components (web vs. native). Key entry points include `app.js` for the web app, `react/index.native.js` for mobile, and native SDKs for iOS and Android. External dependencies include Prosody, Jitsi Videobridge, Jicofo, and various third-party services (Google, Microsoft, Dropbox, Amplitude). The project also includes server-side Prosody plugins (Lua) for authentication, room management, and monitoring, as well as a comprehensive test suite using WebDriverIO and custom load testing frameworks.
Gopeed is a high-performance, cross-platform download manager written in Go with a Flutter frontend. It supports HTTP/HTTPS, BitTorrent, Magnet links, ed2k, and HLS streaming protocols. The backend provides a REST API, CLI, and an MCP server for AI agent integration. The frontend is a full-featured Flutter app for desktop (Windows, macOS, Linux), mobile (Android, iOS), and web. Key features include multi-connection downloads with slow-start and work-stealing, a JavaScript extension system (goja) with polyfills for fetch, XHR, Blob, and streams, archive extraction (zip, 7z, rar), webhook/script notifications, and browser impersonation via TLS fingerprinting. The architecture is modular: protocol-specific fetchers implement a common interface, the download engine manages task lifecycle and persistence (BoltDB), and the UI communicates via RPC or FFI. The codebase is well-tested with extensive integration tests and includes a legacy Flutter UI (ui/flutter_old) alongside the current one, indicating an ongoing migration from GetX to Riverpod.
This Chef cookbook provides custom resources for managing APT (Advanced Package Tool) configuration on Debian-family Linux distributions (Debian 12+, Ubuntu 22.04+). It is a resource-first cookbook, meaning it does not ship recipes or attribute-driven configuration; instead, users declare resources like `apt_config`, `apt_cacher_client`, `apt_cacher_ng`, and `apt_unattended_upgrades` in their wrapper cookbooks. The cookbook handles base APT update behavior, dpkg options, proxy configuration for apt-cacher clients, installation and configuration of the apt-cacher-ng caching proxy server, and unattended-upgrades setup including debconf preseeding. It relies on Chef Infra Client >= 15.3 and the underlying APT system; no external cookbook dependencies are required. The architecture is a set of Chef custom resources (in `resources/`) backed by ERB templates (in `templates/`) and a small library module (in `libraries/`). Each resource encapsulates idempotent actions: creating or deleting configuration files, installing or removing packages, and managing services. The cookbook includes comprehensive ChefSpec unit tests and InSpec integration tests, with CI/CD via GitHub Actions and Test Kitchen with Dokken. It follows modern Chef patterns (unified_mode, action_class, lazy property defaults) and is actively maintained by the Sous Chefs community. Key entry points are the four custom resources. Typical data flows: a user declares a resource in a recipe; Chef converges by writing templates to `/etc/apt/apt.conf.d/`, installing packages (e.g., `apt-cacher-ng`, `unattended-upgrades`), and managing services. The `apt_config` resource also sets up periodic `apt_update` runs and creates helper directories for preseeding. The cookbook does not expose any API endpoints or CLI tools; it is purely a configuration management library for Chef.
vlc-bittorrent is a VLC media player plugin that enables direct streaming of .torrent files and magnet links. It integrates libtorrent-rasterbar to handle the BitTorrent protocol, providing three VLC submodules: a stream_directory module to list torrent contents as a virtual directory, a stream_extractor module to stream individual files with on-demand piece downloading and priority-based piece selection, and an access module to resolve magnet URIs by downloading metadata from peers. The plugin manages a single libtorrent session shared across multiple torrents, handles asynchronous alerts via a dedicated thread, and supports interruptible I/O compatible with VLC's blocking read model. It includes a comprehensive test suite with TAP output and deterministic expected results.
This repository is a Bash-based server provisioning tool that converts a bare Debian 13 (Trixie) VPS into a dedicated Nextcloud High-Performance Backend (HPB) server. It installs and wires together the full Talk/HPB stack: nextcloud-spreed-signaling (built from source or from Debian packages), NATS message bus, coturn TURN/STUN server, Janus WebRTC gateway, and Collabora Online (CODE) for document editing, all fronted by an Nginx reverse proxy with Let's Encrypt certificates (separate RSA and ECDSA chains), UFW firewall, unattended-upgrades, and msmtp for email notifications. The output is a secrets file containing the Talk app credentials, TURN credentials, and per-Nextcloud-domain shared secrets that an administrator pastes into the Nextcloud Talk/Office settings. It supports multiple Nextcloud domains and can run fully unattended via a settings.sh file or interactively through whiptail dialogs. Architecturally it is a monolithic orchestrator (setup-nextcloud-hpb.sh) that loads settings, renders placeholder-based config templates from data/ into a temporary directory, then sources modular install_* functions from src/setup-{ufw,collabora,signaling,nginx,certbot,unattendedupgrades,msmtp}.sh. The configuration files under data/ are upstream service configs (Janus, coturn, signaling-server, nginx, coolwsd) with <PLACEHOLDER> tokens substituted via sed/perl. The design shows real operational craftsmanship: a dry-run mode is threaded through every step, deploy_file() uses SHA-256 checksums to make deployments idempotent, external IP detection has fallback endpoints, and secrets are written to a 0640 file while being masked in logs. The most reusable components are isolated shell patterns rather than whole modules: the checksum-based deploy_file() and perl-based replace_placeholder_in_files() functions in the main script (placeholder substitution that survives arbitrary password characters), the Certbot rate-limit/staging-certificate handling in src/setup-certbot.sh, and the version-marker + .deb cache build system for Janus in src/setup-signaling.sh. These patterns can be lifted into other provisioning projects. Caveats: the code has no tests, relies heavily on global variables shared across sourced modules, and contains a few real defects — the dry-run dialog always sets DRY_RUN=true when the setting is left empty, and the SSH-disable check compares the literal string 'DISABLE_SSH_SERVER' instead of the variable, so that feature never activates. Several commented-out legacy blocks remain. Despite this, the project is actively maintained (release 1.3.6, July 2026) and targets the current Debian release.
This repository is a large collection of Bash scripts that automate the deployment, configuration, and update of self-hosted services on Proxmox VE, primarily through LXC containers and VMs. It is a provisioning and automation framework rather than a runtime application: each ct/*.sh script declares resource variables (CPU, RAM, disk, OS template) and an optional update_script(), while install/*.sh scripts run inside an existing container to install a specific application. Usage is typically a one-line curl command executed as root on the Proxmox host, after which the script creates a container/VM, installs dependencies, generates credentials, writes systemd units or OpenRC init scripts, and configures databases and reverse proxies. The architecture is layered: hundreds of app-specific scripts wrap a smaller set of shared Bash function libraries in the misc/ directory (build.func, install.func, vm-core.func, core.func, error_handler.func). These shared functions handle common operations such as fetching GitHub releases, setting up language runtimes, creating databases, backing up configs before updates, and standardizing error handling. Update flows generally stop the service, back up configuration/data, fetch the latest release, restore the backup, run migrations, and restart the service. This consistency is the project's main strength and makes adding a new container recipe relatively straightforward. Weaknesses are typical of a large community-driven shell-script collection: no unit tests, heavy reliance on third-party installers fetched via curl|bash, some hardcoded versions, and external dependencies on GitHub release asset names and remote core-library URLs. Many scripts assume Debian/Ubuntu or Alpine bases and run as root with no signature verification. Despite these risks, the codebase is actively maintained, consistently formatted, and the shared function libraries are practical examples of reusable Bash abstractions for Proxmox automation.
PVE-Tools is a comprehensive, interactive Bash administration toolkit for Proxmox VE 9.x (Debian 13 Trixie). It provides a menu-driven CLI that wraps native PVE commands (qm, pct, pvesm, etc.) to automate common hypervisor management tasks: system optimization, APT mirror switching, kernel/GRUB management, GPU passthrough (NVIDIA, AMD, Intel SR-IOV/GVT-g), VM/container backup/restore/clone/migration, host networking (bridge, bond, VLAN, IPv6, firewall), storage (Ceph, LVM, mount), security auditing and CVE mitigation, and third-party tool integration (FastPVE, CoolerControl, IT87 drivers). The tool is distributed as a single assembled script built from modular source files (lib/ + src/modules/) via build.sh, and can be installed as a system command or run directly. It features a two-tier confirmation system for high-risk actions, marker-based config block management for idempotent edits, and automatic backups under /var/backups/pve-tools/. The UI is primarily Chinese with a branded ASCII banner and community channels built in.
This repository contains a single bash script (`wireguard-install.sh`) that serves as an interactive installer and manager for a WireGuard VPN server on Linux. It automates the full lifecycle: detecting the OS (Ubuntu, Debian, AlmaLinux, Rocky Linux, CentOS, Fedora), installing WireGuard (or BoringTun for containerized environments), configuring firewall rules (firewalld or iptables), enabling IP forwarding, generating server and client configurations, and providing a menu to add/remove clients or uninstall. The script is designed to be run as a one-liner and handles many edge cases such as NAT detection, multiple IP addresses, and containerized kernels lacking the WireGuard module. It is a mature, battle-tested tool with thousands of stars and no open issues, but it is a monolithic script with no modular components or tests, limiting reusability beyond its intended purpose.
This is a single-file Bash script that performs a comprehensive security and performance audit of a Linux VPS. It checks SSH configuration, firewall status, intrusion prevention systems (Fail2ban/CrowdSec), failed login attempts, system updates, running services, open ports, disk/memory/CPU usage, sudo logging, password policy, and SUID files. The script outputs color-coded PASS/WARN/FAIL results to the console and writes a detailed timestamped report to a file. It is designed for Ubuntu/Debian-based systems and requires root or sudo privileges. The architecture is a monolithic Bash script with no external dependencies beyond standard Linux utilities and optional tools like UFW, Fail2ban, and Docker. The code is well-structured with configurable thresholds and file paths, demonstrating solid Bash scripting practices. However, it is not designed for reuse as a library; it is a standalone tool.
Radiotray-NG is an internet radio player for Linux that runs in the system tray. It allows users to select and play configured radio stations, displays stream metadata, shows notifications, and provides control via system tray menu, media keys, or DBus. The application features a modular architecture with separate components for bookmarks management, configuration, event handling, playback (using GStreamer), playlist format handling, notifications, and GUI (with AppIndicator or ncurses fallback). It includes a bookmark editor GUI and supports sleep timer functionality.
This repository is a comprehensive build system and distribution for Armbian, a lightweight Linux distribution for ARM devices, specifically targeting Amlogic, Rockchip, and Allwinner SoCs used in TV boxes and single-board computers. It provides scripts and GitHub Actions workflows to build custom Armbian images, compile kernels, and manage system software. The architecture is based on a layered filesystem overlay pattern: common-files (shared across all devices), platform-files (per-SoC family), and different-files (per-board overrides), allowing flexible device-specific customization. Key entry points include the `rebuild` script for local image building, GitHub Actions workflows for CI, and a suite of `armbian-*` command-line tools for end-user system management (install, update, kernel management, software center). The project includes a software center with dozens of pre-configured Docker, desktop, and service applications, and extensive device support documented in a model database and per-board boot configurations. While the codebase is functional and widely used, it exhibits high duplication across board-specific files, contains binary device tree blobs without accompanying source, and has several hardcoded paths and vendor-specific dependencies that increase maintenance burden.
Daijin is a container management tool designed for Android devices running Termux. It provides a menu-driven interface to create, run, remove, and manage Linux containers using either the ruri backend (a lightweight container implementation) or proot (a chroot alternative). The application orchestrates container lifecycle operations by integrating with submodules rurima (for running Docker/LXC images without Docker/LXC) and rootfstool (for obtaining container rootfs from mirrors). Key functionalities include downloading container images, setting up container environments with proper permissions and networking, managing container configurations, and providing launch mechanisms. The architecture is monolithic with modular shell scripts handling specific operations, all built as a Debian package for Termux deployment.
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.
This repository provides a deprecated Docker image for running Starlette applications with Uvicorn managed by Gunicorn. The image includes auto-tuning of worker processes based on CPU cores. However, the project is explicitly deprecated in favor of using Uvicorn with the `--workers` option directly, as the need for Gunicorn as a process manager has been eliminated by recent Uvicorn features. The repository contains Dockerfiles for Python 3.10 and 3.11 (slim and non-slim) that build upon the `tiangolo/uvicorn-gunicorn` base image, and installs Starlette. It includes a minimal example application and tests to verify the image behavior.