Fallen Lib
If you have ever tried to build a complex Minecraft mod, you know that the line between clever and chaotic can be razor-thin. You spend hours writing boilerplate code, wrestling with bytecode, and hoping that your patches do not break when another mod sneezes. That is where Fallen Lib steps in. This small but mighty developer utility library is designed to take the pain out of low-level modding, giving you a clean, delegating API for patching classes and a set of runtime tools that make your life significantly easier.
Fallen Lib is not a content mod. It does not add new blocks, mobs, or dimensions. Instead, it is a foundation—a toolkit for developers who want to extend Minecraft in ways that Forge alone cannot handle. It is currently used in the development of Fallen Gems & Affixes, but its APIs are built to be reusable across many projects. If you are a modder, this is the kind of library you keep in your back pocket for when things get tricky.
Why Developers Need Fallen Lib for Minecraft
Minecraft modding has evolved. Gone are the days when a simple @EventHandler was enough. Modern mods often need to hook into core systems, modify existing classes, and adjust runtime behavior without breaking the game. Fallen Lib for Minecraft provides two primary tools to help you do exactly that: FallenPatch and FallenInserter. Together, they form a powerful system for injecting your code into vanilla or modded classes with precision.
FallenPatch: A Delegating API for Class Modification
FallenPatch is the heart of the library. It offers a delegating API that allows you to patch mod classes—or even all subclasses of a given class—without writing repetitive, fragile bytecode manipulation routines. This is a game-changer when you want to extend the behavior of an existing mod without rewriting it from scratch.
To use FallenPatch, you implement the IFallenPatch interface and annotate your class with @FallenPatch. The annotation takes parameters like priority, targets, and inserters. For example, you can target an exact class or a superclass, and the library will handle the rest. The apply method gives you direct access to the ClassNode, allowing you to insert hooks exactly where you need them.
Here is a quick look at how the structure works:
- Implement
IFallenPatchand provide a constructor that acceptsIFallenPatchCtorContext. - Use
@FallenPatchto declare your targets and priority. - In the
applymethod, usePatchUtil.insertMethodHook()to place your code. - Register your patch in an
xxx.fallen.jsonfile in your resource root.
This approach significantly reduces repeated patches when extending mod behavior. Instead of writing a dozen different mixins for every edge case, you write one clean patch that covers all subclasses.
FallenInserter: Clean Hook Methods
FallenInserter works hand-in-hand with FallenPatch. It allows you to define static methods that act as hooks. You annotate them with @FallenInserter and specify the type: InserterType.STANDARD or InserterType.STANDARD_VOID. The STANDARD type is invoked after the target method and can replace the return value if you set the replaceReturn flag. The STANDARD_VOID type is for methods that do not return anything.
Each hook receives an IInserterContext which gives you access to the receiver (this) and the return object. You also get an Object[] args array containing all parameters of the original method. This makes it incredibly easy to inspect and modify behavior at runtime without cluttering your code with low-level ASM instructions.
RuntimeUtility: Making Life Easier
Beyond patching, Fallen Lib includes some handy runtime utilities. The ObjectModifierFactory is a standout. It copies an object, modifies its numeric fields, and uses cache and field name filters to avoid unnecessary processing. This is mainly used for runtime adjustments without modifying the original object—perfect for balance tweaks or dynamic scaling.
Another useful feature is the Delegated Mixin Connector Registry (available above version 1.3.2). This service-like registry allows you to test in IDEA with conditionally loaded mixin configs. You simply implement the official IMixinConnector class in your mod, then reference it in a JSON config file. It is a clean way to manage complex mixin setups without breaking your development environment.
Apotheosis Addon Support
If you use the Apotheosis mod, Fallen Lib has an extra treat. You can register extra gem bonuses in Apotheosis 1.20.1 using a datapack, just like in 1.21.1. The structure is straightforward: place your JSON files in resources/namespace/extra_gem_bonuses/. This bridges a version gap and lets you use modern features on older versions.
How to Install Fallen Lib
Installing Fallen Lib is straightforward, but it depends on what you are doing. For normal gameplay or distribution, you use the standard JAR file. For development, you will want to add it to your Gradle workspace.
Here is how to install it in your development environment:
- Add the Maven repository to your
build.gradle. - Include the
fallen-lib:coreandfallen-lib:runtimedependencies. - Sync your project and start coding.
If you prefer a simpler route, you can download Fallen Lib from the Additional Files section of the project page. Just grab the normal JAR and drop it into your mods folder. It is compatible with the latest Minecraft versions and Forge loaders, so you do not need to worry about version conflicts.
Supported Versions and Loaders
Fallen Lib is built for Minecraft 1.20.1 and works exclusively with the Forge mod loader. This is a deliberate choice, as the library relies on Forge's coremod and patching infrastructure. If you are running a Forge server or client, you are good to go. The library is lightweight and does not add any gameplay content, so it will not affect your world or performance.
For developers, the Gradle repositories are straightforward to set up. The API is stable enough for production use, though the author notes that APIs may still change as development continues. That said, the core functionality—FallenPatch, FallenInserter, and RuntimeUtility—is solid and well-documented.
Streamlining Your Modding Workflow
One of the best ways to get started with Fallen Lib is to use a launcher that handles version compatibility and mod management for you. The foxygame.net launcher, for instance, offers a one-click install experience for Fallen Lib, so you can skip the manual setup and jump straight into testing your patches. Its add-on catalog makes it easy to find and manage the library alongside your other mods, and the launcher automatically checks for updates, ensuring you always have the latest version without lifting a finger.
When you are ready to start a new project, the question of how to install Fallen Lib becomes a non-issue. Whether you are using a launcher or doing it manually, the process is quick and painless. The library is designed to be unobtrusive, so you can focus on what matters: writing great mods.
Final Thoughts
Fallen Lib is not for everyone. If you are a player looking for new content, this library will not interest you. But if you are a developer who has ever cursed at a stack trace or spent hours debugging a mixin, Fallen Lib is a breath of fresh air. It provides the tools you need to patch classes cleanly, manage runtime behavior, and extend mods without the usual headaches.
The project has reached a usable state, and while the APIs may evolve, the current version is more than capable of handling serious modding tasks. Whether you are building a gem system like Fallen Gems & Affixes or just need a reliable way to hook into existing code, Fallen Lib for Minecraft is worth a serious look. Download Fallen Lib today and see how much smoother your development process can be.