Steam Achievement Manager (SAM) is a desktop application for managing Steam game achievements and statistics. It consists of three main components: SAM.API (a C# wrapper for the Steam Web API), SAM.Game (the main achievement management UI), and SAM.Picker (a game selection utility). The application interfaces directly with the local Steam client via steamclient.dll to retrieve and modify user game data. The architecture cleanly separates the API interop layer from the presentation layer, with the API layer demonstrating sophisticated interop techniques including vtable parsing, function pointer caching, and safe string marshaling. The UI layer uses Windows Forms to provide an intuitive interface for viewing and modifying achievements and statistics.
Wabbajack is a mature .NET application for compiling and installing modlists for PC games, primarily Bethesda titles. It automates the entire modlist lifecycle: a compiler indexes a modded game folder, applies a stack of compilation steps (ignore rules, BSA decomposition, texture matching, patching), and produces a .wabbajack file containing only metadata and download instructions. An installer then runs preflight checks, downloads archives from Nexus Mods, Steam depots, Bethesda Creations, HTTP mirrors, and manual sources, verifies hashes, extracts files, and applies binary patches to reproduce the original mod setup without redistributing any assets. This is an application, not a data/research repository; the data-like components (VFS, hashing, caches) serve the application's file integrity and reproducibility needs. Architecturally it is a modular multi-project solution: a WPF desktop client (Wabbajack.App.Wpf), a System.CommandLine-based CLI (Wabbajack.CLI), and an Avalonia launcher. Core libraries provide a custom path abstraction, xxHash64 hashing, a SQLite-backed virtual file system for archive indexing, a rate limiter, a download dispatcher with pluggable downloaders, a preflight check framework, and Bethesda archive (BSA/BA2) readers/writers. Dependency injection is used throughout via per-module ServiceExtensions, and the codebase includes substantial test coverage across installer, compiler, downloader, VFS, and networking projects. External dependencies include the Nexus Mods API (OAuth2), Steam CDN/depot APIs, Bethesda's Creations API, GitHub releases for self-update, and bundled native tools (7-Zip, innoextract, texconv). The codebase is heavily Windows-oriented (WPF, P/Invoke, WMI, registry protocol handler), though some libraries are cross-platform. Maintenance is active with frequent releases, but technical drift is medium: several hardcoded API constants, reverse-engineered Steam/Bethesda endpoints, and legacy WPF UI patterns require ongoing upkeep.
This repository is a developer toolchain for creating custom node graph logic in Genshin Impact's UGC mode (Miliastra Wonderland). It compiles a subset of TypeScript into a binary GIA format (protobuf) and injects it into game map files (.gil). The system includes a CLI (gsts) for build/inject/watch, a multi-stage compiler (TS → GS intermediate → IR JSON → GIA), an injector that patches save files, and a comprehensive set of custom ESLint rules enforcing the supported TypeScript subset. It supports both server-side and client-side node graphs with two modes (classic and beyond), and provides extensive type definitions, bilingual support (Chinese/English), and auto-generated tests covering thousands of node combinations. The codebase demonstrates strong engineering practices: rigorous testing, type safety, i18n, and modular architecture. However, it depends heavily on reverse-engineered game data (node IDs, pin records, protobuf schemas) that must be updated with each game patch, and some components are tightly coupled to internal definitions.
Skyline is a homebrew application framework for the Nintendo Switch that enables runtime code hooking, plugin loading, and enhanced debugging capabilities. It primarily functions as a replacement for game executables (like Super Smash Bros Ultimate) that patches the game's memory to intercept function calls, load user plugins, and provide advanced logging. The architecture centers around three core systems: a sophisticated AArch64 inline hooking engine (And64InlineHook) that safely modifies executable code in memory, a flexible logging subsystem that can output to debugger, SD card, or TCP sockets simultaneously, and a plugin manager that loads and validates user-created Nintendo Relay Object (NRO) files. The framework initializes by setting up memory protections, installing hooks on critical system functions (like file mounting and abort handling), and then transferring control to the target game while maintaining the ability to intercept and modify its behavior. Key technical achievements include the inline hooker's ability to handle various ARM64 branch instructions through trampoline generation and cache management, the logger's thread-safe queue design supporting multiple output destinations, and the plugin system's secure loading process that validates cryptographic hashes before execution. The code demonstrates strong engineering practices with proper resource cleanup, error handling, and separation of concerns.
BepInEx is a plugin/modding framework for Unity (Mono and IL2CPP) and .NET games (XNA, FNA, MonoGame). It injects itself into a game process via Doorstop, runs a preloader that patches game assemblies, and then loads user-authored plugins through a chainloader. The framework provides a comprehensive infrastructure: thread-safe configuration (TOML-based), structured logging (console, disk, Unity log), assembly patching API, native detour abstraction (Dobby/Funchook), and interop generation for IL2CPP games (via Cpp2IL and Il2CppInterop). It supports Windows, Linux, and macOS (with limitations), and handles multiple Unity runtime variants and .NET Framework/Core. The architecture is modular: core libraries (`BepInEx.Core`, `BepInEx.Preloader.Core`) provide the base plugin contract, configuration, logging, and assembly scanning; runtime-specific projects (`BepInEx.Unity.Mono`, `BepInEx.Unity.IL2CPP`, `BepInEx.NET.*`) implement the platform-specific startup, patching, and integration. External dependencies include HarmonyX for runtime method patching, MonoMod for assembly manipulation, and SemanticVersioning for dependency resolution. While many components are tightly coupled to the game-modding domain, several subsystems—logging, configuration, topological sorting, native detours—are well-abstracted and potentially reusable in other C# host applications. The codebase shows signs of long-term evolution (deprecated methods, duplicated `KeyboardShortcut` classes, static singletons) but remains actively maintained with recent commits and responsive issue triage.
SilentPatch is a runtime patching system for Grand Theft Auto III, Vice City, and San Andreas that applies bug fixes, stability improvements, and enhancements via DLL injection. The architecture centers around a DirectDraw wrapper (DDraw.dll) that hooks into game processes and loads game-specific patches. Each game has a dedicated module (SilentPatchIII/VC/SA) containing version-specific fixes implemented through pattern scanning and memory hooking. Shared components handle cross-cutting concerns like input, rendering, and configuration. The system reads INI files to toggle features and uses a plugin-like architecture for extensibility (e.g., Special Vehicle Features). It does not alter game files on disk, instead modifying memory addresses at runtime to fix issues like widescreen support, crash bugs, and compatibility problems with other mods.
Fluorine-Manager is a Linux-native mod manager derived from Mod Organizer 2, designed to manage game modifications without altering the original game files. It employs a virtual file system (VFS) using FUSE to overlay mod files, enabling safe mod installation and conflict resolution. The application features a Qt-based GUI with extensive plugin architecture supporting Bethesda games (Skyrim, Fallout series) and non-Bethesda titles through Python and C++ plugins. Core functionality includes mod organization, load order management, BSA/BA2 archive handling, INI file manipulation, and integration with Nexus Mods and Steam/Proton for Windows game compatibility on Linux. The system follows a modular design with clear separation between core logic, game-specific implementations, and utility libraries.
AMAI (Advanced Melee Artificial Intelligence) is a comprehensive replacement for Warcraft III's built-in melee AI. It provides a modular, table-driven AI system with a job scheduler, per-race strategies, hero micro, harass logic, and a Commander interface allowing human players to command allied AI opponents via chat or dialogs. The repository includes build tooling (Perl preprocessor, batch scripts) to compile AI scripts for multiple game versions (ROC, TFT, Reforged), an Electron-based desktop installer for injecting AI into maps, and extensive localization in 10 languages. The codebase is primarily JASS (the game's scripting language) with a custom preprocessor (eJASS) that supports conditional compilation and table inclusion. While the core AI logic is tightly coupled to Warcraft III, several patterns (job scheduling, command registration, preprocessor) are reusable in other game modding contexts.
Everest is the primary mod loader and modding framework for the game Celeste. It is a standalone platform rather than a simple script loader: the MiniInstaller patches the game's .NET assemblies at install time using MonoMod, manages native libraries across Windows/Linux/macOS, and provides a full mod SDK. The core project is Celeste.Mod.mm, which contains MonoModRules (build-time patching logic), the Everest runtime (mod loading, dependency resolution, event dispatch), the Everest.Content asset pipeline (crawl/process/apply for textures, maps, dialog), and the Everest.Updater self-update system. Mods interact with the game through a clean event-based hook API (Everest.Events) and registries (e.g., StrawberryRegistry) rather than direct assembly patching. The repository is purely an application/framework; there is no data science, ML, or analytics content. The only data-like artifacts are TAS replay files used for CI validation, not for model training or analysis.
Cyber Engine Tweaks is a modding framework for Cyberpunk 2077 that injects a DLL into the game process to provide a Lua scripting environment, an ImGui-based overlay (console, TweakDB editor, settings, log viewer), and quality-of-life patches (disable vignette, disable boundary teleport, skip start menu). It hooks into D3D12 rendering and input systems, reverse-engineers the game's RTTI layer via RED4ext.SDK, and exposes game objects, functions, and the TweakDB to Lua scripts. Modders can place Lua scripts in a `mods` folder, which are executed in sandboxes with access to the full ImGui widget library (via sol_imgui) and SQLite databases (via lsqlite3). The architecture is monolithic—a single DLL orchestrates all subsystems (core initialization, hooking, scripting, overlay, reverse engineering, patching). External dependencies include LuaJIT, sol2, Dear ImGui, MinHook, spdlog, nlohmann/json, and TiltedPhoques library. The codebase is actively maintained but carries inherent drift risk due to hardcoded game offsets that must be updated per game patch.
FreeMote is a Windows-oriented .NET Framework 4.8 toolchain for reverse-engineering, decompiling, converting, rendering, and rebuilding E-mote (EMT) PSB game asset packages. It is primarily an application suite rather than a data/research project: five CLI tools (EmtConvert, PsbDecompile, PsBuild, EmtMake, FontBuilder-related commands) plus a WPF viewer provide user-facing workflows, while the core libraries FreeMote, FreeMote.Psb, and FreeMote.PsBuild implement binary parsing, encryption, plugin dispatch, compilation/decompilation, and platform conversion. The architecture is modular: FreeMote handles low-level container and crypto primitives, FreeMote.Psb provides the PSB object model and plugin interfaces, FreeMote.PsBuild handles JSON/PSB conversion and E-mote project generation, and FreeMote.Plugins supplies compressors, image/audio codecs, and shell handlers through MEF composition. The primary data flow is file-in/file-out: encrypted or shell-wrapped PSB containers are opened through FreeMount plugin composition, decrypted or unpacked into an in-memory PSB object graph, decompiled to JSON plus extracted resources, then optionally recompiled, re-encrypted, and packed back into shells. The reverse pipeline also supports building PSB from JSON, generating bitmap fonts, porting between Kirikiri/Windows/common/console specifications, converting motion PSB into MMO editor projects, and extracting textures/audio from archives. The code embodies deep reverse-engineering knowledge: PSB versions 1-4, trie-compressed name tables, XorShift128/MT19937 cipher handling, MDF/LZ4/Zlib shells, ASTC/BC7/DXT/TLG pixel formats, and console-specific texture swizzling. Although the repo contains research-grade format analysis, its dominant character is an application toolkit for game modding. It is actively maintained with CI packaging, tests, and a plugin ecosystem, but carries medium technical drift: legacy .NET Framework and System.Drawing dependencies, Direct3D9 interop in the viewer, reliance on external executables for some audio/image encoders, hard-coded platform heuristics, and a large monolithic Psb.cs with TODO debt. The most reusable assets are self-contained texture utilities and the generic plugin/composition pattern, not the tightly coupled PSB-specific pipeline components.
ReAPI is a C++ Metamod plugin module for AMX Mod X (AMXX) that extends Counter-Strike 1.6 server modding by bridging the ReGameDLL and ReHLDS APIs to Pawn scripting. It provides a comprehensive hook chain system, reflection-based member access to game internals, and message interception capabilities, enabling scripters to modify nearly every aspect of gameplay, from player spawning and weapon handling to round logic and engine events. The module also integrates optional companion mods (Reunion, VTC, Rechecker) for authentication, voice chat, and file consistency checks. The architecture is a classic Metamod plugin with AMXX module entry points, exposing hundreds of native functions (rh_* and rg_* namespaces) and forwards. The codebase demonstrates sophisticated patterns such as template-based hook registries, compile-time member offset tables with type safety, and generic container utilities. However, it is tightly coupled to specific versions of ReHLDS/ReGameDLL and the GoldSrc engine, with hardcoded offsets and manual parameter conversion in many hooks. The project is actively maintained with frequent commits and issue triage, but carries medium technical drift due to an aging toolchain (GCC 4.5.1 runtime, deprecated Windows SDK) and large monolithic source files.
DelvUI is a Dalamud plugin for Final Fantasy XIV that provides a fully customizable replacement for the default HUD. It is a monolithic plugin that uses ImGui for rendering and hooks into game memory via FFXIVClientStructs to read player/party/encounter state. The architecture is heavily event-driven and singleton-based, with a central ConfigurationManager and HudManager that coordinate all HUD elements. The plugin implements a sophisticated attribute-driven configuration system that auto-generates ImGui settings panels from plain C# objects, enabling deep customization of bars, nameplates, party frames, job gauges, status effects, and more. It integrates with several other plugins via IPC (Honorific, PetRenamer, WhosTalking, Wotsit) and includes low-level hooks for pull timers, ready checks, and input interception. The codebase reflects strong engineering in its config abstraction and bar-drawing utilities, but also exhibits significant maintenance debt from hardcoded game IDs, reflection-heavy design, and pervasive singleton use.