This repository is a comprehensive data dump of Grand Theft Auto V (GTA V) game assets, structured as a reference library for modding, scripting, and reverse engineering. It contains no executable application logic; instead, it provides thousands of JSON, INI, and TXT files detailing internal game constants, entity flags, vehicle definitions, pedestrian data, weapon configurations, and precise spatial coordinates for world objects. The data is extracted from the RAGE engine binaries and enhanced with community research, specifically targeting version v3717.0 (Online 1.72). It serves as a critical resource for FiveM server administrators, mod developers, and game analysts who need to understand the game's internal data structures without access to the source code. The repository is organized into logical categories: core entity lists (vehicles, peds, weapons), world object placement data (objectslocations/), audio event mappings, and rendering/animation flags. While the data itself is static and version-locked, the structure is highly consistent, using standard JSON schemas for spatial data (Position/Rotation) and flat arrays for enumerations. The primary value lies in the 'Data Truth Layer'—the ground truth of internal game names and hashes that are otherwise undocumented. However, the data is inherently volatile; any official game patch that alters internal hashes or map geometry will invalidate specific entries, requiring regeneration of the dumps. For AI agents and engineers, this repository is a high-fidelity knowledge base for GTA V modding. It is not a tool to be run, but a dataset to be consumed. The quality is exceptional for a community-maintained data dump, with consistent naming conventions and comprehensive coverage of game systems. The lack of code means there is no technical debt in terms of software engineering, but there is significant drift risk regarding game version compatibility.
ReVanced Manager is an Android application that applies custom patches to Android APKs using the ReVanced Patcher engine. It provides a user interface for downloading patch bundles, selecting and configuring patches, patching applications (including a background patcher service), signing the resulting APKs, and installing them. The app is built with modern Android technologies: Jetpack Compose for UI, Room for local persistence, Koin for dependency injection, Ktor for networking, and WorkManager for background tasks. It follows an MVVM architecture with a repository pattern and supports root-based installation via Magisk modules. The application manages a complex state of patch selections, downloaded apps, installed apps, and options through a Room database with schema migrations. It includes a downloader plugin system for acquiring APK files from various sources, automatic update checks for the manager itself, patches, and downloaders, and extensive localization support via Crowdin.
Mindustry is a production-ready tower defense / real-time strategy game with factory automation, built in Java using the custom Arc game framework. The codebase implements a full game loop: real-time simulation of blocks (conveyors, turrets, drills, reactors, logic processors), units with AI and abilities, procedural planet generation, multiplayer networking, a map editor, and a campaign progression system. The architecture is heavily modular: an entity-component system (ECS) provides composable unit behaviors; annotation processors (@Struct, @Remote, @EntityDef, @Load) generate serialization, network packets, and texture loading code at compile time; a block hierarchy with drawer, consumer, and ability interfaces enables data-driven content; and a versioned save system supports long‑running campaigns. The project includes dedicated tooling (icon conversion, map fixer, script binding generator) and supports modding via jar/zip loading and JavaScript scripting (Rhino). It targets desktop (SDL/Steam), Android, iOS, and headless server platforms through Gradle multi-module builds.
REPENTOGON is a comprehensive modding framework for the game The Binding of Isaac: Repentance. It extends the game's Lua API with hundreds of new functions, provides low-level hooking and assembly patching capabilities, integrates ImGui for developer tools, and adds features like custom item pools, save syncing, virtual room management, and achievement tracking. The architecture is a hybrid of a C++ DLL that injects into the game process and a set of Lua scripts that run in the game's Lua environment. Key entry points include the DLL main (dllmain.cpp) which initializes hooks and patches, and the Lua registration system (LuaInit.cpp) which exposes new classes and callbacks. The framework relies on reverse-engineered game structures, signature scanning, and runtime code modification to achieve deep integration. External dependencies include the game itself, Lua 5.4, ImGui, and several bundled libraries (glad, rapidxml, rapidjson, mINI). The codebase is large and actively maintained, with a strong focus on modder extensibility and bug fixing.
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.
UndertaleModTool is a comprehensive, open-source modding and reverse-engineering tool for GameMaker games, specifically Undertale and Deltarune. It provides a full suite of functionality: reading/writing GameMaker data files (.win, .unx, etc.) with byte-for-byte accuracy, decompiling GML VM bytecode back into human-readable GameMaker Language (GML), compiling modified GML back into bytecode, and editing all game assets (sprites, sounds, rooms, code, textures, shaders, fonts, etc.) through a Windows-only WPF GUI or a cross-platform CLI. The tool also includes a project system for exporting/importing assets as JSON and PNG, a built-in C# scripting engine for automation, and game-specific definitions that tailor decompilation and modding to Undertale and Deltarune. The architecture is a classic library-plus-front-end pattern: the core library `UndertaleModLib` handles all binary serialization, decompilation, compilation, and project management. The GUI application `UndertaleModTool` and CLI `UndertaleModCli` are thin layers that use this library. The library itself is heavily version-aware, supporting multiple GameMaker versions (GMS1, GMS2, 2022-2024) with hundreds of conditional checks. The decompiler integrates with the external `Underanalyzer` submodule for advanced GML compilation and decompilation. A large collection of built-in C# scripts covers common modding tasks (resource export/import, technical utilities, game-specific modifications). While primarily an application, the repository also serves as a living document of GameMaker's internal data format—a significant reverse-engineering effort. The code is rich with comments explaining undocumented structures, version differences, and workarounds for engine bugs. This hybrid nature makes it both a practical modding tool and a valuable research resource for understanding GameMaker internals.
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.
UAssetGUI is a Windows Forms desktop application for low-level examination and modification of Unreal Engine game assets. It allows users to open, edit, and save .uasset, .umap, .pak, and .utoc files, with JSON export/import, C# scripting via embedded Roslyn, property mappings for unversioned assets, and full theming and localization. The architecture is a monolithic GUI built on .NET 10 preview, relying on the UAssetAPI submodule for serialization. Key entry points are Program.Main and Form1 (the main editor window). The application targets modders and researchers who need to inspect or alter binary asset data directly. It includes custom controls, a plugin-like script system using collectible assembly load contexts, and supports container file extraction/repacking via native binaries. The codebase is well-structured for its niche but tightly coupled to Windows Forms and the UAssetAPI ecosystem.
OpenMod is a .NET-based plugin framework designed for extensibility across game servers and applications. It provides core services including dependency injection, event handling, command processing, permission systems, user management, and configuration management. The framework features a modular architecture with platform-specific adapters for games like Unturned and Rust, enabling developers to create plugins that extend functionality without modifying the core. The system uses an event-driven approach for loose coupling and supports self-updating via NuGet package management. While primarily focused on game server modding, the core abstractions are general enough to apply to other extensible application scenarios.
This repository is a Spanish localization data package for the mobile game Umamusume: Pretty Derby, designed to be used with the Hachimi modding tool. It contains over 11,000 JSON files under `localized_data/` that provide translated dialogue for story scenes, home screen interactions, race commentary, and song lyrics. The data follows a consistent schema (`no_wrap`, `text_block_list` with `name`, `text`, optional `choice_data_list` and `color_text_info_list`), making it easy to parse and integrate. The only executable code is `gen_index.py`, a utility that walks the git tree and generates a JSON index with Blake3 hashes for file integrity verification, used by Hachimi to fetch updates. The repository also includes configuration files (`config.json`, `config_android.json`) for the modding tool and a GitHub Actions workflow (`release.yml`) that automatically builds and deploys the index on pushes to main. While not a traditional data research project, the repo represents a well-organized, version-controlled dataset for game localization, with a clear pipeline for distribution. The translation quality appears consistent, though the large number of files and presence of some duplicate entries suggest manual maintenance overhead. The `gen_index.py` script is a self-contained, reusable component for generating file indexes with cryptographic hashes, applicable to any mod or asset pack project.
This repository contains the source code for the Poseidon game engine, which powers the remastered version of Arma: Cold War Assault (CWR). It is a large, monolithic C++20 codebase with a modular subsystem architecture covering graphics (OpenGL 3.3), audio (OpenAL), networking (UDP with custom transport), input (SDL), AI, world simulation, UI, and asset management. The engine supports dedicated servers, modding via PBO archives, and a scripting language (SQF/SQS). The repository also includes a suite of CLI tools (PBO packing, image conversion, model inspection, etc.), a Blender addon for importing P3D models, and Rust components for a master server and test harness (Trident). Extensive unit tests (Catch2) and fuzz harnesses are provided. The codebase is a locked snapshot with no active development, but it demonstrates high craftsmanship in areas like custom containers, memory management, and network protocol design. However, it suffers from technical debt including heavy use of preprocessor macros, global state, and platform-specific conditionals.
BD2ModManager is a Tauri + Vue 3 + TypeScript desktop application for managing mods for the game BD2 (Brown Dust 2). It is primarily an application, not a data/research repository, though it consumes static game data and remote CSV/JSON assets. The app provides mod lifecycle management (install, delete, sync/unsync, rename, update author, refresh), profile management, GitHub-based mod installation, and an integrated updater. The frontend is built with Vue 3 and Pinia, using Vue Router for navigation and composables for reusable logic; the backend is a Rust/Tauri shell that handles filesystem operations, symlinks, and the updater.
This repository is a reimplementation of the Deus Ex: Human Revolution Director's Cut (DXHRDC) game engine, created through manual decompilation and cleanup of the original binary, supplemented with debug information from a leaked Tomb Raider (2013) build (same engine family). It is not a matching decompilation and lacks automated resynchronization with the original binary. The engine requires original game assets (BIGFILE.* files) to run and provides core systems for rendering (DirectX 11 abstraction), audio (FMOD-based), animation (animation graph), game logic (object management, AI, player systems), input, UI (Scaleform via ImGui), resource management, and world streaming. The architecture is modular but monolithic, with a central game loop in cdcGameShell/MainG2.cpp. While the code shows evidence of structured design (interfaces, resource management, job system), it contains numerous TODOs, HACKs, and incomplete implementations, indicating ongoing work. Dependencies include DirectX 11 (or dxvk-native for Linux), FMOD, Dear ImGui, and miniz. The project is actively maintained with recent commits.
This is the Source SDK 2013, Valve's official modding SDK for Half-Life 2, Half-Life 2: Deathmatch, and Team Fortress 2. It provides the full game engine source code, including client and server DLLs, map compilation tools (vbsp, vrad, vvis), distributed processing (VMPI), and a comprehensive set of game entities, AI behaviors, rendering shaders, and UI frameworks. The codebase is a large C++ monolith with heavy use of preprocessor conditionals to support multiple game mods (HL2, HL2MP, TF2, SDK) and platform targets (Windows, Linux, Xbox 360). It includes a NextBot AI framework with behavior trees, a VGUI2 UI system, a material system with shader fallbacks for legacy DirectX levels, and a replay system. However, the repository is effectively a historical snapshot: many proprietary systems are stubbed out, third-party libraries (protobuf 2.6.1, LZMA) are outdated, and the code shows signs of bitrot with deprecated APIs and dead code paths. It is not actively maintained and would require significant modernization for use in new projects.