Faugus Launcher is a Linux-native game launcher designed to run Windows games via compatibility layers (UMU-Launcher/Proton/Wine). It provides a modern GTK4/libadwaita GUI with multiple views (list, grid, covers, carrousel) for managing and launching games from sources like Steam, Epic, and others. The application handles game configuration, Proton version management, prefix handling, shortcut creation (desktop/appmenu/Steam), system tray integration, backup/restore of settings, and performance tool integration (MangoHud, GameMode, Lossless Scaling). Architecturally, it follows a modular Python structure with clear separation of concerns: launcher.py (main GUI), runner.py (game execution), config_manager.py (settings), proton_manager.py (Proton handling), backup.py (backup/restore), shortcut.py (shortcut creation), tray_sni.py (system tray), and various utility modules. Key entry points include the main launcher (launched via flatpak/AppImage/binary), the runner for game execution, and the tray daemon for background operation. Data flows involve storing game metadata in JSON files (games.json), configuring launch environments, and interacting with external services like SteamGridDB for art and GitHub for Proton/UMU updates. The application demonstrates strong engineering practices: atomic JSON writes to prevent corruption, proper GTK resource cleanup, background task handling, cross-platform path management for Flatpak/AppImage/native installs, and a configuration migration system. While it relies on external tools (mangohud, gamemoderun, icoextract) and online APIs (SteamGridDB, GitHub), it gracefully handles missing dependencies. The codebase is actively maintained with recent commits, CI/CD workflows for multiple packaging formats, and ongoing translation efforts.
Bottles is a desktop application for running Windows software on Linux by managing Wine/Proton 'bottles' — isolated Windows prefix environments. In production it creates, imports, configures, and deletes bottles, installs and manages Wine runners (Wine, Proton, Soda) and graphics components (DXVK, VKD3D, NVAPI, D7VK), applies step-based dependency manifests (DLLs, runtimes, registry keys, fonts), and launches Windows executables with per-bottle environment composition (sync modes, HDR, Wayland, gamescope, FSR, mangohud, sandboxing via bwrap/flatpak-spawn). It also integrates with the UMU launcher for running Proton games outside Steam, discovers Steam/Epic/Origin libraries, and tracks playtime in a local SQLite database with crash recovery and aggregation. The dominant character is unambiguously a desktop application, though it embeds a small data layer (playtime SQLite, EagleIntel community-intelligence SQLite, YAML catalog caches) that serves the app rather than constituting a research pipeline. The architecture is a classic backend/frontend split: a singleton Manager orchestrates sub-managers (component, dependency, installer, library, versioning, sandbox, playtime, backup, Eagle), while a GTK4/Adwaita frontend (views, windows, widgets, Blueprint .blp templates) and a companion CLI (bottles-cli) consume it. Loose coupling is achieved through a SignalManager/EventManager pub-sub bus, RunAsync threading helpers, and a standard Result return type. Catalogs for components, dependencies, and installers are fetched as YAML from remote repositories with local caching, offline fallback, and checksum validation; user settings live in GSettings; bottle configs are YAML dataclasses; versioning snapshots are delegated to an external FVS2 tool. A distinctive Eagle subsystem performs static analysis of Windows executables (pefile parsing, YARA rules, installer/ASAR extraction) and consults a bundled community-sourced SQLite database (ProtonDB/winetricks-derived) to recommend compatibility environment variables, DLL overrides, and launch flags. A Microsoft identity bridge implements the Soda OAuth 2.0/PKCE protocol over Unix sockets, with libsecret/cpak secret storage, enabling Microsoft account sign-in inside Wine. Engineering quality is strong: a large pytest suite covers backend managers, Wine wrappers, UMU, playtime integration, and frontend dialogs; the project uses ruff/mypy/pyright via pre-commit; CI builds Flatpak and cpak multi-arch (amd64/arm64) images and runs tests; localization spans 60+ languages. The repository is actively maintained with very recent commits, structured issue templates, and a dependabot-enabled pipeline with zero alerts. Principal drift risks are moderate: a deprecated Gtk.FileChooserNative call (vs Gtk.FileDialog), dual download implementations (pycurl for repos vs requests for Downloader), a vendored ValvePython vdf/vdict copy, hardcoded repository URLs pinned to commit hashes, and version-specific Wine/Proton workarounds that will age. The frontend is tightly coupled to Flatpak runtime resources, limiting its portability, but several backend components are cleanly isolated and genuinely reusable.
ProtonUp-Qt is a Linux desktop GUI built with PySide6/Qt6 for installing, updating, and removing Wine/Proton-based compatibility tools (GE-Proton, Proton-tkg, Wine builds, DXVK/VKD3D, SteamTinkerLaunch, Boxtron, Luxtorpeda, etc.) across Steam, Lutris, Heroic, Bottles, and custom launchers. Architecturally it is a client-side Qt application: the main window orchestrates background download/extraction jobs, a dynamic plugin loader (`ctloader.py`) discovers compatibility-tool modules under `resources/ctmods/`, and per-launcher adapters (`steamutil.py`, `lutrisutil.py`, `heroicutil.py`) read/write local game databases and config files. Release metadata is fetched from GitHub/GitLab/Codeberg REST APIs with rate-limit handling and optional user tokens. There is no server or data-processing component; external anti-cheat/compatibility datasets are only consumed to enrich the game-list dialog. The codebase demonstrates a credible plugin architecture, typed domain data in `datastructures.py`, and reusable network/download utilities. Maintenance is active, but the many tool-specific ctmods duplicate logic (fetch/install/extract), translations lag source strings, and the project depends on third-party release APIs and Steam's local formats, which makes some features inherently fragile.
ValveSoftware/Proton is a compatibility layer that enables Windows games to run on Linux via the Steam client. It integrates Wine, DXVK, vkd3d-proton, and other components to translate Windows API calls to Linux equivalents. The repository contains the build system (Makefile, Dockerfiles), the Steam client wrapper (lsteamclient) with auto-generated thunks for dozens of Steamworks SDK versions, the VR client wrapper (vrclient_x64) for OpenVR, and an OpenXR loader (wineopenxr). The codebase is heavily auto-generated from SDK headers, with manual implementations for complex interfaces. It is actively maintained by Valve and the community, with a focus on broad game compatibility. The architecture is a set of shared libraries loaded by Wine, not a standalone application.
This repository is a comprehensive, community-driven guide for optimizing gaming performance on Linux. It covers a wide range of topics from basic setup (distribution choice, GPU drivers) to advanced tweaks (kernel parameters, CPU cache topology, custom Wine/DXVK compilation, input lag benchmarking). The only executable code consists of two shell scripts that implement CPU core pinning using cpusets, which can be reused to isolate game processes to specific CPU cores for reduced cache contention. The guide is well-structured, frequently updated, and serves as a valuable reference for Linux gamers seeking performance improvements. It is not a software application but a documentation resource with minimal code.