Modern Industrialization is a comprehensive tech mod for Minecraft (NeoForge) that introduces a progressive automation system. It adds hundreds of machines, multiblocks, pipes, energy networks, and a full nuclear reactor simulation, all driven by a data-driven material and recipe system. The mod features a component-based machine architecture where each block entity is composed of modular NBT-serializable components with client-server sync, a custom vendored Fabric Transfer API for fluid/item storage with transactional rollback, and a sophisticated pipe network manager for item, fluid, and energy transport. It includes extensive compatibility layers for KubeJS scripting, JEI/REI/EMI recipe viewing, AE2 integration, Jade tooltips, and Sodium/Embeddium performance optimizations. The codebase is large but well-structured, with procedural texture generation, runtime datagen, and a robust multiblock shape matching system. It demonstrates strong engineering practices in mod development, particularly in its component abstraction, network management, and transactional resource handling.
squaremap is a Minecraft server plugin/mod that renders live top-down world maps to a web interface, similar to Dynmap but with a minimalist design. It supports multiple server platforms (Paper, Fabric, NeoForge, Sponge) through a shared core module with platform-specific adapters, built using Gradle multi-module and a custom build-logic. The backend captures chunk snapshots via mixins/access transformers, renders them into PNG tiles using biome and block color data, and serves them via an embedded Undertow HTTP server. Tiles are generated asynchronously with a FIFO caching system, and the system provides commands for full/radius renders, pause/resume, and visibility controls. The web frontend is a Leaflet-based TypeScript app with player tracking, world selection, layer controls, and coordinate display. The project also exposes a public API for other plugins to add markers, layers, icons, and player managers. The architecture is cleanly separated into API, common, and platform-specific modules, with dependency injection (Guice) and standard libraries (Cloud command framework, Configurate, Adventure). It is actively maintained, with recent commits and support for bleeding-edge Minecraft versions, but the heavy reliance on internal Minecraft code and multiple platform-specific mixins introduces maintenance complexity and drift risk.
Controllable is a Minecraft Java Edition mod that adds native game controller support, enabling gameplay with Xbox, PlayStation, or other controllers. It features analog movement, context-sensitive button bindings, a radial menu for quick actions, a virtual cursor for menu navigation, and extensive configuration options. The mod supports both Fabric and NeoForge loaders through a clean platform abstraction layer, with shared core logic in the 'common' module and loader-specific implementations in 'fabric/' and 'neoforge/'. It integrates with popular mods like JEI, REI, and EMI via Mixins to ensure compatibility. The architecture emphasizes separation of concerns, with distinct systems for input handling, GUI, and configuration, demonstrating strong modular design and maintainability.
Figura is a Minecraft mod (client-side with optional server-side backend) that allows players to fully customize their avatar's appearance, animations, sounds, particles, and behavior using Lua scripting. The architecture is a multi-loader (Fabric, Forge, Quilt, NeoForge) client mod with a server-side plugin (Spigot) for avatar storage, permissions, and networking. The client-side core includes a Lua runtime (LuaJ) with a sandboxed API exposing over 30 modules (e.g., models, textures, sounds, events, keybinds, action wheel, networking, math). Avatars are defined by Blockbench models, Lua scripts, textures, and sounds, all packaged into NBT files. The rendering pipeline hooks into Minecraft's vanilla rendering via extensive mixins to replace player models, modify armor, cape, elytra, and nameplates. The server-side backend (Figura Server Bridge) provides avatar upload/download, user data, pings, and permission management via WebSocket or custom Minecraft packets. Key entry points include the `Avatar` class (lifecycle), `FiguraLuaRuntime` (script execution), `AvatarRenderer` (rendering), `PermissionManager` (access control), and `NetworkStuff` (backend communication). External dependencies include LuaJ, Gson, nv-websocket-client, and Minecraft's own libraries.
BetterModel is a high-performance, server-side Minecraft plugin and mod (Bukkit/Paper/Fabric) that renders custom 3D models from BlockBench (.bbmodel) files using Minecraft's display entities. It automatically generates resource packs, supports keyframe and Molang-driven animations, per-player model visibility, hitboxes, mounting, player skin integration, and third-party compatibility (MythicMobs, Citizens, SkinsRestorer). The architecture is modular with a clean API/implementation split, platform abstraction, and version-specific NMS modules for multiple Minecraft versions (1.21.4 through 26.3). The codebase demonstrates strong engineering practices in packet bundling, animation interpolation, concurrency utilities, and event-driven design. However, it suffers from significant code duplication across NMS versions, minimal test coverage, and heavy reliance on Minecraft internals via reflection, which introduces maintenance fragility. It is actively maintained with frequent updates and a responsive issue tracker.
FastBack is a Minecraft mod that provides fast, incremental world backups using Git. It stores backup snapshots as orphan branches in a Git repository embedded within the world save directory, enabling efficient storage of only changed files. The mod supports local backups, remote backups to any Git server or file system, automatic scheduling on shutdown or autosave, snapshot pruning with configurable retention policies (daily, fixed, GFS, all), and restoration of snapshots. It requires native git and git-lfs to be installed, with a fallback to JGit for legacy backups. The architecture is modular: a common module contains all backup logic (commands, repo management, config, logging, mixins), while Fabric and NeoForge loader-specific modules handle platform integration. The codebase demonstrates strong engineering practices with clean interfaces, robust error handling, comprehensive logging, and a well-designed retention policy system.
Veil is a client-side Minecraft modding library for Fabric and NeoForge that provides advanced rendering capabilities to mod developers. In production it implements a custom shader pipeline: GLSL preprocessing and injection into vanilla and Sodium shaders, dynamic buffer outputs for deferred-style rendering, JSON-defined shader programs, and a caching shader compiler. It also manages advanced framebuffers, post-processing pipelines (bloom, composite, first-person), custom render types, and GPU light renderers for point, area, spot, and directional lights. Beyond core rendering, Veil ships data-driven effects: the Quasar particle system with modular init/update/render/force modules, Flare shell-based effects with controller/modifier properties, Necromancer skeletal animation, and screen shake. It includes developer tooling such as ImGui inspectors, resource editors, and hot reload, plus a resource management layer that treats shaders, framebuffers, render types, and textures as first-class reloadable assets. The project is structured as a common API/impl core with separate Fabric and NeoForge loader modules, service-loaded event platforms, and codec-based resource serialization. This is not a data research repository; although it uses JSON assets and codec-driven definitions, it is fundamentally an application library for game rendering. The code is actively maintained on the 1.21 branch, with the main risks being the large mixin surface into Minecraft/Sodium/Iris internals and duplicated platform-specific compatibility code.
OneConfig is a modular, Compose-based configuration library for Minecraft mods, providing a unified API for config definitions, UI rendering, HUD management, keybind handling, event system, and notifications. It supports multiple Minecraft versions and mod loaders (Fabric, NeoForge) via a stonecutter-based build system and extensive mixin compatibility layers for third-party mod configs (e.g., YACL, ClothConfig, MoulConfig). The library features a custom Compose runtime (poly-compose) for Skia-accelerated UI, a tree-based config model with annotation-driven properties, and a service-loader-based platform abstraction. It is actively maintained with a large test suite covering config persistence, event validation, keybind codecs, and HUD migration.
JustEnoughItems (JEI) is a Minecraft mod that provides an in-game recipe viewer and ingredient browser. It is a client-side mod that integrates with both Fabric and NeoForge mod loaders via a common core library. The system's primary function is to display all available recipes, items, and fluids in a searchable overlay, allowing players to look up crafting, smelting, brewing, and other recipes. It also supports a plugin API (IModPlugin) that lets other mods register custom recipe categories, ingredient types, recipe transfer handlers, GUI handlers, and search prefixes. The codebase is organized into distinct modules: Common (shared logic, networking, configuration, and platform abstractions), Library (core implementations for recipe management, ingredient indexing, vanilla integrations, and runtime), Gui (client-side overlays, input handling, bookmarking, and search), and platform-specific modules for Fabric and NeoForge. The mod includes a sophisticated search engine with prefix-based tokens, an ingredient filter, a configurable overlay layout, ghost ingredient dragging, and a bookmark system. Recipe transfer to in-game crafting grids is handled via network packets with server-side permission checks. The codebase demonstrates strong architectural practices with clear API separation, extensive unit and game tests, and a flexible configuration framework. However, it exhibits significant platform duplication between Fabric and NeoForge implementations and carries deprecated API surfaces, indicating ongoing evolution.
Sodium Extra is a client-side Minecraft mod that extends the Sodium performance mod with additional graphical options, visual bug fixes, and performance tweaks. Architecturally, it is a mixin-heavy mod built with the Architectury multi-platform toolchain, supporting both Fabric and NeoForge loaders. It injects into Minecraft's rendering, fog, particle, GUI, and entity systems via over 50 mixin classes, controlled by a custom mixin configuration system (CaffeineConfig). Key entry points include `SodiumExtraClientMod` (initialization, config registration, debug HUD), `SodiumExtraMixinConfigPlugin` (runtime mixin filtering based on user options), and platform-specific initializers (`SodiumExtraFabricClientModInitializer`, `SodiumExtraNeoForgeClientMod`). External dependencies are Sodium (required), Minecraft, and optionally ModMenu and Greenlight (for server-authorised fog). The mod is best described as 'OptiFine's eye-candy options for Sodium', providing fine-grained toggles for animations, particles, fog, sky/clouds, biome colors, toasts, overlays, and many performance-related features. It is not a data or research project.
This repository is a multi-module Android application that functions as a cheat client for Minecraft Bedrock Edition. It intercepts and modifies network packets between the client and server using a custom relay/proxy (Lunaris) and a comprehensive implementation of the Bedrock protocol (CloudburstMC-derived). The app provides a graphical overlay (Pixie with ImGui) for toggling cheat modules such as flight, speed, killaura, ESP, and more. It also includes Microsoft/Xbox authentication, Discord Rich Presence, and an update check mechanism with native signature verification. Architecture: The project is organized into several Gradle modules: `app` (main Android app with Compose UI and cheat modules), `Protocol/bedrock-codec` (versioned Bedrock packet serializers), `Protocol/bedrock-connection` (Netty-based session management), `Network/transport-raknet` (custom RakNet UDP transport), `Lunaris` (relay/proxy for packet interception), `Pixie` (native C++ overlay with ImGui and Dobby hooking), `minecraft-msftauth` (Microsoft authentication), `lunarisrpc` (Discord RPC), and `animatedux` (Compose UI components). The app uses a packet interception pattern where cheat modules (subclasses of `Element`) override `beforePacketBound` to modify or cancel packets before they are sent to the server. Key entry points: `app` module's `MainActivity` or `LaunchActivity` (Android entry), `Pixie`'s `MuffinService` (overlay service), `Lunaris`'s `LuminaRelaySession` (relay logic), and the protocol codec builders (e.g., `Bedrock_v898`). Data flows: The app connects to a Bedrock server via RakNet, the relay intercepts packets, cheat modules modify them, and the modified packets are forwarded. The protocol library handles serialization/deserialization for dozens of protocol versions. External dependencies: Netty (network), OkHttp (HTTP), Firebase (analytics/crashlytics), Gson (JSON), fastutil (collections), Lombok (Java boilerplate), AndroidX Compose (UI), ImGui (native overlay), Dobby (native hooking), and various Android SDK components.
This repository (master branch) contains only documentation, assets, issue templates, and changelogs for the FancyMenu Minecraft mod. The actual source code is hosted in separate branches (as stated in the README). Without access to the source code, no architectural analysis, data flow, or component evaluation can be performed. The changelogs indicate a highly active, feature-rich mod with extensive customization capabilities for Minecraft menus, including elements, actions, placeholders, and listeners. The mod is licensed under a custom restrictive license (DSMSLv3.1). The repository is actively maintained with recent commits and open issue triage, but the lack of source code in the default branch prevents any meaningful code quality assessment.