u/kkamal_

Recently finished an Inventory & Crafting System built entirely in C++.

Features:

• Equipment Slots
• Inventory Grid
• Probability-Based Crafting
• Batch Crafting
• DataTable-Driven Items
• Event-Driven UI Updates
• Zero Tick Architecture

The goal was to keep everything modular and easy to integrate into existing UE5 projects.

Feedback is always welcome.

Hey r/unrealengine,

While working on a key remapping system with Enhanced Input, I ran into a UX issue that surprisingly isn't handled automatically.

A player can assign a key that's already bound to another action, which can easily lead to confusing input setups if you don't catch it.

To solve it, I implemented a simple conflict detection flow:

• When a player selects a new key, existing mappings are checked immediately
• If the key is already in use, a warning appears in the UI
• The conflicting action is highlighted
• The player can't confirm the change until the conflict is resolved

One thing I wanted to avoid was continuously checking for conflicts every frame. Instead, validation only runs when a remapping event occurs, so the UI stays completely event-driven.

It ended up being a lot cleaner than I expected once everything was wired into Enhanced Input.

Curious how everyone else handles key remapping in UE5.

• Do you block duplicate bindings?
• Automatically replace the old binding?
• Allow conflicts and let players decide?

Hey r/unrealengine,

One thing I've become obsessed with lately is eliminating unnecessary Tick usage.

While rebuilding my HUD framework, I realized almost every UI example I found was still polling values every frame:

• Health bars
• Mana bars
• XP bars
• Status indicators

Even when nothing had changed.

So I removed every Tick from the entire HUD system.

Instead, gameplay components broadcast Dynamic Multicast Delegates whenever data changes, and widgets simply react to those events.

DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(
    FOnHPChanged,
    float, CurrentValue,
    float, MaxValue
);

Result:

• Zero HUD Tick functions
• No timer-based polling
• Cleaner UI architecture
• Better separation between gameplay logic and presentation

Curious how others approach HUD updates in UE5.

Do you still poll values, use bindings, or go fully event-driven?

Hi r/gamedev,

I wanted to share a quick architectural breakdown of my recent hobby project. Like many of you, I always had performance concerns regarding heavy UI blueprints and unnecessary Ticking components cluttering the game thread.

To solve this, I decoupled everything and built a native C++ framework for HUD and Settings using a 100% event-driven pattern.

Key features I focused on:

- Zero Tick: Absolutely no CPU overhead on the game thread.

- DataAsset Integration: Easily customizable layout configs without touching the backend code.

- Gamepad Friendly: Fully responsive input layout ready out of the box.

If you have any questions about optimizing UE5 UI logic, setting up thread-safe architecture, or how this system works, feel free to drop a comment below. I'd love to answer them!

When updating a ListView in UE5, which approach do you prefer?

A) Handle everything in code — rebuild the array, reassign items, and call SetListItems to refresh the entire list.

😎 Let each entry handle its own update — use OnListItemObjectSet and broadcast changes via delegate from the entry (child) side.

I've been going back and forth on this.

A feels safer and more predictable, but there's a concern about GC pressure when the item count gets large, since SetListItems triggers entry pool recycling and UObject references may not get cleaned up at the right time.

B seems cleaner for complex entry states, but requires careful delegate management — you need to make sure RemoveDynamic is called properly before rebinding on each OnListItemObjectSet, otherwise you risk memory leaks from stale bindings.

Curious what the community prefers and why. Is there a cleaner pattern I'm missing?

Curious what the community thinks about this. Which do you prefer and why?