How to Mod Minecraft with Universal Modder

Use Universal Modder to investigate your Minecraft installation, choose the matching loader, and make one small change you can verify in a practice world. For a first Java mod, this guide uses a single Fabric block: a short path from an agent plan to source code, a built JAR and an observable result.

If you already have an error, jump to version mismatch or mod not loading.

Can Universal Modder mod Minecraft?

Yes. Universal Modder's knowledge base has six working Minecraft projects across several game versions and loaders. Universal Modder supplies the investigation and development workflow, while Fabric, Forge or NeoForge supplies the game's mod interface. Read the Minecraft playbook on GitHub or browse the Minecraft field notes for each project's exact versions.

For a block, item or entity, start with the appropriate loader API. Larger examples can require another game's process, native code or a local asset conversion step; save those for after your first block works. The Minecraft in GTA V example explains one of those more complex routes.

Java or Bedrock

Java Edition can load Java mods through a matching loader. Fabric, Forge and NeoForge are distinct development routes: choose the one required by the actual project or modpack. A Fabric JAR is not a package for another loader. Fabric's installation guide explains the edition, loader and game-version checks.

Bedrock Edition uses behavior packs, resource packs and a separate scripting interface. Start from Minecraft Creator documentation if that is your edition. The Java exercise below does not produce a Bedrock Add-on.

A server plugin is another route again. State whether the feature belongs in a local world, on a server you administer or in client rendering before asking the agent to choose tools. This page's practice workflow is single-player.

If you are choosing between a block and a new item in another game, compare Terraria's C# tModLoader workflow with the Java route below. The game guide directory also includes editor-based first projects if you prefer to start with a map or scenario instead of a compiled mod.

What you need

Complete Universal Modder installation for your agent, and confirm um --help works in the environment that agent uses. Have your own Minecraft Java installation, Git, a suitable JDK, dependency download access and a workspace for the mod source.

Record the launcher, exact profile and its Game Directory. Keep a separate practice instance and create a new world there. Before editing an existing instance, close the game and preserve its saves and configuration. The general tutorial explains the plan, log and backup workflow.

This first project needs no generated art, fal key or prebuilt download. The exercise references the base game's gold-block texture by name.

Version conditions

The first-block exercise deliberately fixes a small reproducible source group. Use exactly these versions for the exercise; other Minecraft releases need their own matching group.

The pinned template properties provide the game, loader and API versions. Its Loom snapshot property is replaced with the published 1.15.5 in the exercise. Fabric's 1.21.11 setup documentation calls for JDK 21. Keep the entire group together, including mappings and resource formats.

Step-by-step

1. Investigate the real installation

Run these in your agent's terminal environment:

um kb search "Minecraft"
um scan "Minecraft"

Open relevant notes and compare their versions with yours. Minecraft may not appear in store discovery, and the scan can identify the launcher executable instead of the Java game. If necessary, run um scan "PATH_TO_YOUR_MINECRAFT_INSTANCE" with the actual path, then confirm edition, version, loader and runtime from the profile and logs yourself.

2. Write a plan before changing files

Give the agent the fixed version table and this prompt:

Use game-recon and mod-any-game for my Minecraft Java practice instance.
Confirm the launcher profile, game directory, loader, game version,
Gradle JVM and game runtime. Search the Minecraft field notes.
Plan only one Fabric block named Signal Block, ID modid:signal_block.
Use the fixed 1.21.11 exercise and official Mojang mappings.
Write MODDING_PLAN.md with source files, dependencies, backup locations,
a removal procedure, and the exact obtain/place/name/appearance checks.
Keep unresolved facts visible; do not alter my normal worlds.

Record intended work in MODDING_PLAN.md; put commands, changed files and actual results in MODLOG.md. The game-recon skill on GitHub describes this workflow.

3. Prepare the practice instance and source

Use the loader selected by the plan. For the fixed exercise, follow the pinned source and Java checks, then the Fabric practice-profile steps. Loader and Fabric API are separate dependencies. A third-party launcher has its own instance management; identify its directory before copying anything.

Use the backup command reference for an existing save folder, replacing the path and snapshot name with yours. Keep the backup outside the changed directory and record how to restore it. Starting in a new practice world keeps early code changes away from a world you care about.

4. Implement one block and inspect the build

Ask the agent to follow the exercise's registration and resource files. Review its diff against the agreed namespace and mappings before building. Do not run parallel Gradle builds in the same project.

After a successful build, inspect the ordinary JAR. A source archive or -sources.jar is not the runtime mod. If the build fails, preserve the first useful error and fix that stage; do not install an older artifact just because one exists in build/libs.

5. Verify the result in Minecraft

With the correct Fabric profile, open a new Creative practice world. Obtain modid:signal_block, place it, check its name and appearance, then inspect the same instance's logs/latest.log. The full verification checklist includes the optional Survival drop check.

Record what you actually observed. A build, metadata entry or title screen only verifies one stage. If the agent cannot observe the game, have it leave the game checks pending for you rather than calling the feature tested.

Example prompts for Minecraft

Adjust the version and path only after choosing a coherent development environment.

Review the first change:

Review this Signal Block diff against the pinned Fabric 1.21.11 template.
Check official Mojang class names, registry keys, the main initializer,
modid:signal_block, items/ definitions and singular loot_table/ paths.
Explain each changed file and list build and game checks still unrun.

Diagnose a failure:

Read this instance's latest.log and my recorded versions.
Identify the first failed stage: dependency, initialization, registration,
resource lookup or game behavior. Quote the relevant actual error.
Propose the smallest fix and repeat the failed check in the same instance.
Preserve unrelated mods, dependencies and saves.

Plan the next feature:

After my first block passes the recorded checks, propose one crafting recipe.
Use this project's existing Minecraft version and data format.
List inputs, output ID, recipe file and an in-game verification step.
Keep new mechanics and generated artwork out of this change.

The prompt library includes more planning, debugging and recovery templates.

Mods people built for Minecraft

All six projects below are working builds, each tied to its own game version and loader. Study them for technique; none is a drop-in download for your instance.

The Minecraft in GTA V case study has Minecraft in the other role: a live game composited into GTA V. Its newer Java and Fabric versions do not replace this page's 1.21.11 exercise conditions. Keep locally derived game assets out of shared packages.

Version mismatch

For Incompatible mods found!, identify the dependency named by the loader and compare its required and installed versions. For UnsupportedClassVersionError, inspect the actual exception and the Java process that emitted it. Changing Minecraft's version alone does not diagnose both problems.

Record edition, profile, Game Directory, Minecraft, loader, API and failed stage. For the first-block project, compare all of them with version conditions. In its root directory on Windows:

java --version
javac --version
.\gradlew.bat --version

On macOS or Linux:

java --version
javac --version
./gradlew --version

The fixed exercise expects JDK 21 and wrapper 9.3.0. An IDE can select a different Gradle JVM, and the launcher can select a different game runtime. Check the process at the failed stage. Java 21 class files have major version 65; Java 17 supports up to 61 (see the Java VM specification). Use those numbers only when they match the actual exception.

For a missing dependency, obtain the named package for the intended game and loader. Close the game before moving JARs, keep one intended experiment JAR and retain shared dependencies needed by other mods. Do not replace a Fabric package with a Forge or NeoForge download.

For missing Java classes or methods during compilation, check mappings and source version. This exercise uses loom.officialMojangMappings(); Yarn examples can use different names. Updating a loader does not translate the code. Likewise, replacing manifest dependency ranges with wildcards does not make incompatible code work.

Repeat the failed build or launch in the same practice environment after the specific fix. Once the original error is gone, continue with the block checks. Keep earlier projects on their recorded versions unless you are deliberately performing and verifying a port.

Mod not loading

Treat this as a symptom and identify its stage. First confirm the selected Fabric profile and its actual Game Directory. Read that instance's mods folder, logs/latest.log and, if present, crash-reports. A normal launcher profile may use a different directory from a development client.

For this exercise, the packages are your freshly built modid-1.0.0.jar and Fabric API 0.141.3+1.21.11. The unedited external template has no Signal Block. A source checkout, ZIP, sources JAR or development artifact is not the ordinary runtime package.

From the source project root, inspect your artifact with the JDK tool:

jar tf build/libs/modid-1.0.0.jar

Check for fabric.mod.json, com/example/SignalBlocks.class and the expected resource files. In the source, the manifest's main entrypoint remains com.example.ExampleMod, and its existing onInitialize method calls SignalBlocks.initialize() once. If the loader names a dependency failure, fix that version problem first.

In your own cheats-enabled practice world, try:

/give @s modid:signal_block

An unknown ID means that registration is not available there. Check the instance, artifact, entrypoint and namespace before attempting a resource reload. A separate Mod Menu is not required; the block should also be in Creative's Building Blocks tab for the exercise.

If the block exists but looks or reads incorrectly, inspect assets/modid/blockstates, models/block, items and lang inside the JAR. The 1.21.11 item definition belongs under items/; an old models/item/ file alone is not the equivalent. For a Survival drop problem, inspect data/modid/loot_table/blocks/signal_block.json, with singular loot_table. Creative breaking normally gives no drop. The versioned Fabric block documentation explains these registration and resource stages.

Close the game before moving duplicate experiment JARs outside mods. For an unexplained crash, retain its time, versions, failed stage and first useful cause. Remove only this experiment and check a new practice world; preserve unrelated mods and dependencies. Then repeat the original obtain/place/name/appearance checks. Avoid turning a missing resource into a blanket deletion of the instance.

Unknown conditions

If edition, version, loader or runtime is still unknown, leave the implementation step pending. Record the missing facts in the plan and use the actual launcher settings and logs to resolve them. A scan of the game name or a matching knowledge-base title is not enough. Installation requirements and the compatibility FAQ explain the broader checks.

Recovery

Exit the game before removing this experiment's JAR. Keep shared dependencies, source and change records. A world containing custom blocks can lose content if its mod disappears. For an important world, restore its pre-change backup with the original versions and environment; do not use that world to test removal. The exercise's uninstall steps keep this limited to the practice instance.

Keep logs locally. If you choose to share one through a support channel, remove personal paths and credentials first.