Because if you want it to work right, you need to wrap it up!

Fabric & Quilt → NeoForge compatibility layer for Minecraft 1.21.11+

Insanity Wrapper is a compatibility layer and mod loader framework built on NeoForge. It currently enables Fabric and Quilt mods to run on NeoForge for Minecraft 1.21.11 and beyond, but it's designed as a foundation for supporting multiple modding ecosystems.

The project bridges the gap between different modding frameworks, enabling developers and players to use mods from various ecosystems in a unified NeoForge environment. The Insanity Loader can be extended to support additional modding frameworks and APIs beyond Fabric and Quilt.

Insanity Wrapper consists of three core components working together:

The Insanity Loader is the foundation—a custom mod loader built on NeoForge that can support multiple modding ecosystems. Currently, it provides Fabric compatibility through shims, but it's designed to expand beyond that.

A custom mod loader built on top of NeoForge that extends modding capabilities beyond what NeoForge provides out of the box. It implements a custom shimmed Fabric Loader API (not the actual Fabric Loader) as one of its features, but also adds its own functionality:

• Query mod loading status (FabricLoader.getInstance().isModLoaded())
• Access game directories (getConfigDir(), getGameDir())
• Use entrypoints (ModInitializer, ClientModInitializer, etc.)
• Load Access Wideners (automatically converted to Access Transformers at runtime)
• Access mod metadata and version information
• Extended functionality - Additional APIs and utilities beyond Fabric compatibility
• Future expansion - Designed to support other modding ecosystems and frameworks

Note: The Fabric Loader API implementation here is a custom shim built from scratch. It's not derived from or related to the actual Fabric Loader—it just provides compatible interfaces so Fabric mods can run on NeoForge.

Custom-built shim implementations that mimic the Fabric API surface while routing calls to NeoForge equivalents. These are not the actual Fabric API—they're manually created compatibility layers:

Handles bytecode transformation and compatibility patching:

• Remaps imports from net.fabricmc.* to shim classes
• Handles Mixin loading and configuration
• Transforms Fabric-specific constructs
• Applies compatibility patches for known issues

Insanity_Wrapper/
├── src/
│   ├── mod/                      # Mod-side code
│   │   ├── java/
│   │   │   ├── dev/insanitywrapper/
│   │   │   │   ├── InsanityWrapper.java
│   │   │   │   ├── loader/
│   │   │   │   ├── mixin/
│   │   │   │   └── compat/
│   │   │   └── net/fabricmc/     # Fabric API shims
│   │   └── resources/
│   │       ├── insanity_wrapper.mixins.json
│   │       ├── META-INF/
│   │       │   ├── neoforge.mods.toml
│   │       │   └── accesstransformer.cfg
│   │       └── assets/
│   │
│   └── service/                  # Service-side code (transformers)
│       └── java/
│           └── dev/insanitywrapper/
│               ├── service/
│               ├── remapper/
│               ├── patch/
│               ├── compat/
│               └── accesswidener/
│
├── build.gradle
├── gradle.properties
├── settings.gradle
└── README.md

1. Scans the mods folder for Fabric mods (fabric.mod.json)
2. Parses mod metadata, dependencies, and entrypoints
3. Converts Access Wideners to Access Transformers
4. Registers mods with NeoForge's mod system

1. Remaps imports from net.fabricmc.* to our shim classes
2. Handles Mixin loading and configuration (NeoForge already supports Mixin!)
3. Transforms Fabric-specific constructs to NeoForge equivalents
4. Applies compatibility patches for known issues

1. Invokes Fabric entrypoints at appropriate NeoForge lifecycle events
2. Bridges Fabric API events to NeoForge events
3. Translates networking packets between protocols
4. Manages mod state and lifecycle

These are custom-built shim implementations, not the actual Fabric API. Each one provides the interface Fabric mods expect while routing to NeoForge under the hood.

• fabric-api-base - Base utilities and interfaces
• fabric-lifecycle-events-v1 - Lifecycle event hooks
• fabric-key-binding-api-v1 - Keybinding registration
• fabric-command-api-v2 - Command registration
• fabric-networking-api-v1 - Network packet handling

• fabric-resource-loader-v0 - Resource loading
• fabric-registry-sync-v0 - Registry synchronization
• fabric-rendering-v1 - Rendering utilities
• fabric-data-generation-api-v1 - Data generation

• fabric-transfer-api-v1 - Item/fluid transfer
• fabric-biome-api-v1 - Biome customization
• fabric-dimension-api-v1 - Dimension utilities
• fabric-block-api-v1 - Block utilities
• fabric-item-api-v1 - Item utilities

1. Install NeoForge

   • Download NeoForge for Minecraft 1.21.11 from neoforged.net
   • Run the installer and select your game directory

2. Install Insanity Wrapper

   • Download the latest release from the Releases page
   • Place the JAR file in your mods folder

3. Add Fabric/Quilt Mods

   • Download your favorite Fabric or Quilt mods (1.21.11 compatible)
   • Place them in the mods folder alongside Insanity Wrapper
   • Launch Minecraft!

The Insanity Wrapper provides the Insanity Loader API—a set of custom shim implementations that allow Fabric mods to work on NeoForge. These shims are not the Fabric API; they're standalone implementations that:

1. Provide Fabric-compatible interfaces - Mods compiled against Fabric can import and use these classes
2. Route to NeoForge internals - Under the hood, calls are translated to NeoForge equivalents
3. Are completely custom - Built from scratch specifically for this compatibility layer

Think of it like this: A Fabric mod imports net.fabricmc.fabric.api.event.lifecycle.v1.ServerLifecycleEvents. That class exists in our shims, but it's our own implementation that hooks into NeoForge's event system, not the actual Fabric API.

Currently, Insanity Wrapper is distributed through GitHub Releases. To use it in your project:

1. Download the JAR from Releases
2. Add it to your local repository or build classpath
3. Reference it in your build.gradle:

dependencies {
    // For Insanity Loader API shims
    implementation(files("libs/insanity-wrapper-1.0.0+1.21.11.jar"))
}

A Maven repository will be available in the future.

# Clone the repository
git clone https://github.com/InsanityLabs/Wrapper.git
cd Wrapper

# Build the project
./gradlew build

# The compiled JAR will be in build/libs/

1. Clone the repository
2. Run ./gradlew genSources to generate decompiled sources
3. Open in your IDE (IntelliJ IDEA recommended)
4. Run ./gradlew runClient to test in-game

• Mixins: Fully supported (NeoForge has native Mixin support)
• Access Wideners: Automatically converted to Access Transformers at runtime
• Fabric-specific mods: Most work out of the box; some may need compatibility patches
• Mod Interactions: Fabric mods can interact with NeoForge mods through the event bus
• Networking: Fabric networking is translated to NeoForge's payload system

• Some advanced Fabric API features may not be fully implemented yet
• Mods relying on Fabric-specific internals may require patches
• Performance may vary depending on mod complexity

Have a mod you'd like to see supported? You can:

• Open a GitHub Issue with the mod name and details
• Join our Discord and ask in the support channel

We actively work on compatibility for requested mods!

We welcome contributions! Areas where help is needed:

• Insanity Loader API Shims - Help implement missing shim modules. These are custom implementations that provide Fabric-compatible interfaces while routing to NeoForge. Not the actual Fabric API—just our own compatibility layer.
• Compatibility Testing - Test mods and report compatibility issues
• Documentation - Improve guides and API documentation
• Bug Fixes - Fix compatibility issues and edge cases
• Performance - Optimize transformation and runtime performance

1. Fork the repository
2. Create a feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'Add amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request

Please ensure your code follows the project's style guidelines and includes appropriate tests.

Important: This project is licensed under CSL-V1.0, which has specific restrictions:

• No Unauthorized Ports - You may not create or distribute unofficial ports of Insanity Wrapper to other mod loaders or Minecraft versions without explicit written permission
• No Source Redistribution - The source code cannot be redistributed, modified, or used as a foundation for derivative projects
• Contributions Only - Contributions are limited to pull requests merged into the official repository
• Enforcement - Unofficial ports and unauthorized distributions will be taken down

For details on what is and isn't permitted, see the full LICENSE file. If you're interested in creating an official port or have questions about licensing, contact the maintainers.

• Primer - Minecraft 1.21.10 → 1.21.11 migration guide (by @ChampionAsh5357, licensed under CC-BY 4.0)
• Contributing Guide - How to contribute to the project
• API Documentation - Detailed API reference and guides (Wiki)

Found a bug? Please report it on the Issues page with:

• Minecraft version
• NeoForge version
• Insanity Wrapper version
• List of mods installed
• Crash log (if applicable)
• Steps to reproduce

This project is licensed under the CSL-V1.0 (Clopen Source License).

Important Note: The Fabric API shims in this project are custom implementations created from scratch. They are not derived from or contain code from the official Fabric API. They simply provide compatible interfaces that route to NeoForge equivalents.

For full license details, see LICENSE.

• Inspired by Sinytra Connector and Forgified Fabric API
• The Fabric Team for creating an amazing modding ecosystem
• The NeoForge Team for continuing Forge's legacy
• Moulberry for the motivation to port Flashback (the main mod supported by this wrapper)
• Community Contributors for testing and feedback

• Discord - Join our community for support, discussion, and mod requests
• GitHub Issues - Report bugs and request features
• GitHub Discussions - Ask questions and share ideas

"Wrapping Fabric mods for NeoForge? That's insanity!"
"Exactly." 🤪

Last Updated: January 2026
Minecraft Version: 1.21.11
NeoForge Version: 21.11.17-beta