ULTIMATE MOD KIT

The whole modding pipeline: players subscribe and mods load, modders press Package and the mod ships.

Most modding solutions hand you one third of the problem. A Workshop wrapper uploads files but has no idea how to load them back. A mod browser lists mods but leaves packaging to a command line the modder has never seen. This covers the whole road.

Installation

"AdditionalPluginDirectories": [ "Mods" ],

The loader is a Game Instance subsystem, so it is already alive. With Auto Discover On Startup on, it finds mods and mounts the ones the player enabled last session before your first level loads.

Building the mod browser

Everything is exposed to Blueprints. In a UMG widget:

Closing the crash guard

The loader writes a breadcrumb before mounting and clears it on a clean shutdown. A breadcrumb found at start-up quarantines the mods it names, so a broken mod can never lock a player out of their own game.

Once your game reaches a point that proves it survived start-up, call Mark Session Healthy. The end of your first level load is the usual place.

Anatomy of a mod

A mod is a plugin folder in the game's Mods directory. Nothing else is required.

Mods/
  MyFirstMod/
    MyFirstMod.uplugin
    Content/
      BP_Something.uasset

The descriptor needs both flags below. Without them the folder is found, reported, and never loads, because its content is not reachable.

{
    "FileVersion": 3,
    "VersionName": "1.0.0",
    "FriendlyName": "My First Mod",
    "CreatedBy": "Your name",
    "ExplicitlyLoaded": true,
    "CanContainContent": true,
    "ModApiVersion": 1,
    "Modules": []
}

Editing a mod

A mod is a plugin marked ExplicitlyLoaded, so nothing mounts it on its own, not the running game and not the editor. Until it is mounted, the Content Browser has nowhere to put its assets.

Tools > Ultimate Mod Kit > Open Mod For Editing takes care of that, and /<ModName>/ appears under plugin content. A mod made with New Mod is already mounted; reach for this after restarting the editor, or for a mod you got from somebody else.

Adding a level

A mod can carry its own levels. Create the map inside the mod's content root (/<ModName>/Maps/..., not /Game/...) and it is cooked and mounted with everything else.

Levels are worth one extra thought about what they reference, because nothing in the base game ever points at a mod's map, and what the map points at decides how big the mod becomes.

Load order and dependencies

"UMKLoadOrder": 50,
"UMKRequiredMods": [ "SomeLibraryMod" ],
"UMKTags": [ "Creature", "Hardcore" ]

Lower load order goes first. A mod whose required mods are not active is quarantined rather than loaded into a state it cannot handle.

Packaging a mod

Loose assets are for working. A mod other people can install has to be cooked, and this is the step most modding setups leave to the modder.

Tools > Ultimate Mod Kit > Package Mod > your mod cooks it as DLC on top of the game's base release and writes the result next to the mod, under Saved.

Nothing else is required of you. Two settings the cooker and the loader disagree about are switched around the cook and switched back afterwards, including when the cook fails.

Publishing to the Steam Workshop

Tools > Ultimate Mod Kit > Upload Mod To Steam Workshop > your mod.

Title, description and tags are read from the mod's .uplugin, so a descriptor that is filled in correctly never has to be retyped into a web form. A preview.png or preview.jpg in the mod folder becomes the Workshop thumbnail. Steam refuses previews above 1 MB.

The first upload creates the Workshop item and records its id in workshop.json, next to the mod. Every upload afterwards updates that same item, and the menu shows (update) beside a mod that has one.

What actually goes up is assembled for you: the descriptor and the cooked archives, in the same layout an installed mod has. Uploading the staged folder as it comes out of the cooker would give every subscriber a mod with no descriptor, which their game then refuses.

What you need

• Steam running and signed in.
• Your game's App ID with the Workshop enabled in Steamworks.
• Steam App ID Override filled in under Project Settings. The editor is not launched by Steam, so Steam cannot work out which game is publishing.
• The Workshop legal agreement accepted on your account. Until it is, items exist but stay hidden, and the kit tells you so rather than reporting a success nobody can see.

The base game release

A mod is cooked as DLC on top of a snapshot of your shipped game, so the cooker knows which assets already exist and leaves them out of the mod.

Run Tools > Ultimate Mod Kit > Create Base Game Release once per public build, and keep the version name stable.

Mod API version

Your game declares which mod API it serves. Each mod declares what it was built against.

• A mod from the future is refused with a message a player can read.
• An older mod loads with a warning, or is refused too when Reject Older Api Versions is set.

Raise Mod API Version whenever you break the events or actions mods bind to. Leave it at 1 until you do.

Multiplayer

On the client, call Get Mod Set Fingerprint and send the result with your join request. On the server, compare it against its own. If they differ, refuse the connection and show Get Mod Set Details, so the player learns which mod they are missing instead of reading the word "incompatible".

Custom mod sources

Local folders and the Steam Workshop both sit behind one interface. To add your own, derive from UUMKModProvider, implement DiscoverMods, and register it from OnRegisterProviders(). That hook is how the Steam module contributes the Workshop without the core ever knowing that Steam exists.

Blueprint nodes worth knowing

Settings

Project Settings > Game > Ultimate Mod Kit. Everything lives in DefaultGame.ini.

Troubleshooting