Installation

Four steps, and the fourth is the one people skip.

1. Add the plugin

Copy EDInventory into your project's Plugins/ folder (or install it from Fab), then enable it in Edit → Plugins → EDInventory. Restart the editor when prompted.

Requirements:

• Unreal Engine 5.8
• Gameplay Abilities, which the plugin's .uplugin enables for you
• Mutable — optional. The equipment-Mutable module compiles itself out when the engine plugin is absent, so you can ignore it entirely.

2. Add the module dependency (C++ projects only)

Blueprint-only projects can skip this. In your module's Build.cs:

PrivateDependencyModuleNames.AddRange(new string[]
{
    "EDInventoryCore",

    // Add only what you use.
    "EDInventoryEquipment",
    "EDInventoryUI",
    "EDInventoryCrafting",
});

EDInventoryCore is the only one you always need. The feature modules are independent of each other.

What each module is

Module	Holds
Core	Items, containers, fragments, layouts, rules, transactions, saving, replication, GAS grants. Everything else is built on its public API
Equipment	Wearing and holding: slots, states, and the models on the body
Equipment · Mutable	Optional. Writes equipment into a Mutable Customizable Object; compiles itself out without the engine plugin
UI	View models and widget bases — grids, bars, cells, tooltips, drag and drop
Crafting · Trading · Loot · Usable · Weight · Durability	One feature each, and each one is a worked example of extending Core without touching it
Editor	Asset tooling: the item composer, the container designer, validation
Tests	Automation tests. Not shipped in a packaged game

The feature modules are deliberately small. That is the argument, not an accident: a whole feature in five files, using nothing the plugin does not offer you.

3. Make your items discoverable

Item definitions are primary assets, resolved by asset id at runtime — that is what an FEDItemRef holds, what a container entry holds, and what goes over the wire. If the Asset Manager does not know where they live, an entry cannot be turned back into a definition — items exist in containers but have no name, no icon and no size.

The framework loads every definition it can find when a world starts, which is why a loot roll, a vendor price and a crafting ingredient all resolve without stalling the server on disk. Turn that off with Project Settings → Game → EDInventory → Preload Item Definitions if your project has enough of them to care, and preload them yourself instead.

Open Project Settings → Game → Asset Manager and add a rule:

Field	Value
Primary Asset Type	EDItemDefinition
Asset Base Class	EDItemDefinition
Directories	wherever you keep item assets, e.g. /Game/Inventory/Items

The plugin also exposes Project Settings → Plugins → EDInventory → Item Definition Scan Paths, which registers the same folders on startup. Either mechanism works; setting both is harmless.

The symptom of skipping this

Items are picked up and counted correctly, but every slot shows a blank icon and a name like EDItemDefinition:DA_Apple. Nothing errors, because nothing is wrong at the container level — the definition simply cannot be resolved.

4. Declare your gameplay tags

The plugin ships only the roots: Inventory.Container, Inventory.Slot, Inventory.Category, Inventory.Rarity, Inventory.State. The concrete tags are your game's vocabulary, so you declare them.

Either add them under Project Settings → Gameplay Tags, or declare them natively in C++:

// YourGameTags.h
namespace YourGameTags
{
    YOURGAME_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Inventory_Container_Main);
    YOURGAME_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Inventory_Slot_Head);
}

// YourGameTags.cpp
namespace YourGameTags
{
    UE_DEFINE_GAMEPLAY_TAG_COMMENT(Inventory_Container_Main, "Inventory.Container.Main", "The main carried grid.");
    UE_DEFINE_GAMEPLAY_TAG_COMMENT(Inventory_Slot_Head, "Inventory.Slot.Head", "Head/helmet slot.");
}

Natives buy you compile-time-safe references. Pick one mechanism per tag and stay with it — a tag declared in both places works, but the comment you see in the editor comes from whichever the engine loaded first, which makes documentation drift silently.

Confirm it works

Drop a UEDContainerComponent on any actor, point it at a Container Definition, press Play, and open the gameplay debugger with the apostrophe key. The EDInventory category lists every container on the actor under the cursor and what is inside it.

It follows the actor chain rather than looking at that one actor: a Pawn also reports the containers on its Controller and PlayerState, and each line is labelled with the actor the container actually belongs to. Keeping the inventory on the PlayerState so it survives a respawn is a common and recommended arrangement, and it would otherwise read as an empty inventory.

If the category is missing, the plugin is not loaded. If the category is there and reports no containers, it names the actors it searched — the actor has none yet, because containers are built in BeginPlay on the authority.

Next

• Quick start — Blueprint
• Quick start — C++