fabric

Essential hooks for modding with Fabric.

2,591

447

2,591

184

View on GitHub

Top Related Projects

MinecraftForge

7,150

Modifications to the Minecraft base files to assist in compatibility between mods. New Discord: https://discord.minecraftforge.net/

Paper

10,924

The most widely used, high performance Minecraft server that aims to fix gameplay and mechanics inconsistencies

Quick Overview

Fabric is a lightweight, modular modding toolchain for Minecraft. It provides a set of tools and APIs that allow developers to create mods for Minecraft without modifying the game's source code directly. Fabric aims to be more flexible and easier to update than traditional modding frameworks.

Pros

Lightweight and modular design, allowing for better performance and compatibility
Frequent updates, keeping up with new Minecraft versions quickly
Extensive API that provides access to many game systems
Strong community support and growing ecosystem of mods

Cons

Smaller mod ecosystem compared to older, more established modding frameworks
Steeper learning curve for developers new to modding
Some advanced features may require more complex implementation compared to other modding frameworks

Code Examples

Registering a new block:

public class ExampleMod implements ModInitializer {
    public static final Block EXAMPLE_BLOCK = new Block(FabricBlockSettings.of(Material.METAL).strength(4.0f));

    @Override
    public void onInitialize() {
        Registry.register(Registry.BLOCK, new Identifier("examplemod", "example_block"), EXAMPLE_BLOCK);
    }
}

Adding a custom item:

public class ExampleMod implements ModInitializer {
    public static final Item CUSTOM_ITEM = new Item(new FabricItemSettings().group(ItemGroup.MISC));

    @Override
    public void onInitialize() {
        Registry.register(Registry.ITEM, new Identifier("examplemod", "custom_item"), CUSTOM_ITEM);
    }
}

Creating a custom entity:

public class CustomEntity extends Entity {
    public CustomEntity(EntityType<? extends CustomEntity> entityType, World world) {
        super(entityType, world);
    }

    @Override
    protected void initDataTracker() {
        // Initialize entity data
    }

    @Override
    public void readCustomDataFromNbt(NbtCompound nbt) {
        // Read entity data from NBT
    }

    @Override
    public void writeCustomDataToNbt(NbtCompound nbt) {
        // Write entity data to NBT
    }
}

Getting Started

Set up a development environment:
- Install Java Development Kit (JDK) 17 or later
- Download and install an IDE (e.g., IntelliJ IDEA or Eclipse)
Create a new Fabric mod project:
- Use the Fabric example mod template or Fabric mod generator
Add the Fabric API dependency to your build.gradle file:

dependencies {
    modImplementation "net.fabricmc.fabric-api:fabric-api:${project.fabric_version}"
}

Implement the ModInitializer interface in your main mod class:

public class ExampleMod implements ModInitializer {
    @Override
    public void onInitialize() {
        // Mod initialization code here
    }
}

Run the game using the Fabric launcher to test your mod

Competitor Comparisons

MinecraftForge

7,150

Modifications to the Minecraft base files to assist in compatibility between mods. New Discord: https://discord.minecraftforge.net/

Pros of MinecraftForge

Larger community and more extensive mod ecosystem
Better compatibility with older Minecraft versions
More comprehensive documentation and tutorials

Cons of MinecraftForge

Slower update cycle for new Minecraft versions
More complex setup and development process
Heavier performance impact on the base game

Code Comparison

Fabric example:

@Mod("examplemod")
public class ExampleMod implements ModInitializer {
    @Override
    public void onInitialize() {
        // Mod initialization code
    }
}

Forge example:

@Mod("examplemod")
public class ExampleMod {
    public ExampleMod() {
        // Constructor-based initialization
        FMLJavaModLoadingContext.get().getModEventBus().addListener(this::setup);
    }

    private void setup(final FMLCommonSetupEvent event) {
        // Mod setup code
    }
}

Summary

Fabric and MinecraftForge are both popular modding platforms for Minecraft. Forge offers a more established ecosystem and better backwards compatibility, while Fabric provides a lighter, more modern approach with faster updates for new Minecraft versions. The choice between the two often depends on specific project requirements and personal preferences.

Paper

10,924

The most widely used, high performance Minecraft server that aims to fix gameplay and mechanics inconsistencies

Pros of Paper

Better performance and optimization for large servers
More extensive plugin ecosystem and compatibility
Advanced configuration options for fine-tuning server behavior

Cons of Paper

Less mod support compared to Fabric
Potentially more complex setup and configuration process
May introduce changes that affect vanilla gameplay mechanics

Code Comparison

Paper (server.properties):

view-distance=10
simulation-distance=6
max-players=100
spawn-protection=16

Fabric (fabric.mod.json):

{
  "schemaVersion": 1,
  "id": "examplemod",
  "version": "${version}",
  "name": "Example Mod",
  "description": "This is an example mod for Fabric."
}

Paper focuses on server-side optimizations and configuration, while Fabric emphasizes mod development and client-side modifications. Paper's code typically involves server configuration files, whereas Fabric's code centers around mod metadata and development.

Both projects aim to enhance Minecraft, but with different approaches: Paper improves server performance and functionality, while Fabric provides a flexible modding platform for both client and server.

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

Fabric API

Essential hooks for modding with Fabric.

Fabric API is the library for essential hooks and interoperability mechanisms for Fabric mods. Examples include:

Exposing functionality that is useful but difficult to access for many mods such as particles, biomes and dimensions
Adding events, hooks and APIs to improve interoperability between mods.
Essential features such as registry synchronization and adding information to crash reports.
An advanced rendering API designed for compatibility with optimization mods and graphics overhaul mods.

Also check out Fabric Loader, the (mostly) version-independent mod loader that powers Fabric. Fabric API is a mod like any other Fabric mod which requires Fabric Loader to be installed.

For support and discussion for both developers and users, visit the Fabric Discord server.

Using Fabric API to play with mods

Make sure you have installed fabric loader first. More information about installing Fabric Loader can be found here.

To use Fabric API, download it from CurseForge, GitHub Releases or Modrinth.

The downloaded jar file should be placed in your mods folder.

Using Fabric API to develop mods

To set up a Fabric development environment, check out the Fabric example mod and follow the instructions there. The example mod already depends on Fabric API.

To include the full Fabric API with all modules in the development environment, add the following to your dependencies block in the gradle buildscript:

Groovy DSL

modImplementation "net.fabricmc.fabric-api:fabric-api:FABRIC_API_VERSION"

Kotlin DSL

modImplementation("net.fabricmc.fabric-api:fabric-api:FABRIC_API_VERSION")

Alternatively, modules from Fabric API can be specified individually as shown below (including module jar to your mod jar):

Groovy DSL

// Make a collection of all api modules we wish to use
Set<String> apiModules = [
    "fabric-api-base",
    "fabric-command-api-v1",
    "fabric-lifecycle-events-v1",
    "fabric-networking-api-v1"
]

// Add each module as a dependency
apiModules.forEach {
    include(modImplementation(fabricApi.module(it, FABRIC_API_VERSION)))
}

Kotlin DSL

// Make a set of all api modules we wish to use
setOf(
    "fabric-api-base",
    "fabric-command-api-v1",
    "fabric-lifecycle-events-v1",
    "fabric-networking-api-v1"
).forEach {
    // Add each module as a dependency
    modImplementation(fabricApi.module(it, FABRIC_API_VERSION))
}

Instead of hardcoding version constants all over the build script, Gradle properties may be used to replace these constants. Properties are defined in the gradle.properties file at the root of a project. More information is available here.

Contributing

See something Fabric API doesn't support, a bug or something that may be useful? We welcome contributions to improve Fabric API. Make sure to read the development guidelines.

Modules

Fabric API is designed to be modular for ease of updating. This also has the advantage of splitting up the codebase into smaller chunks.

Each module contains its own README.md* explaining the module's purpose and additional info on using the module.

* The README for each module is being worked on; not every module has a README at the moment

Top Related Projects

MinecraftForge

7,150

Modifications to the Minecraft base files to assist in compatibility between mods. New Discord: https://discord.minecraftforge.net/

Paper

10,924

The most widely used, high performance Minecraft server that aims to fix gameplay and mechanics inconsistencies

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot