

UE UI Framework
UE5 Frontend UI Framework | Unreal Engine 5 | C++ & CommonUI
A production-ready UI system built on CommonUI, featuring dynamic options management, async widget loading, and persistent settings across game sessions.
Tech Stack: Unreal Engine 5 | C++17 | CommonUI | Enhanced Input | Property Path Reflection
Development Approach
I built this as a reusable framework after noticing most game UIs follow similar patterns - settings screens, confirmation dialogs, loading transitions. The core idea was separating data (what settings exist) from presentation (how they look) and behavior (how they respond).
Instead of hardcoding each setting, I use a registry pattern where adding new options only requires creating a data object. The system handles getters/setters automatically through property path reflection, eliminating boilerplate. Widget stacks use gameplay tags for organization, making it easy to push modals over menus or game HUDs without manual Z-order management.

System Architecture

Data Flow Pipeline
Key Technical Systems
-
Property Path Reflection for Settings:
-
Rather than manually writing getter/setter pairs for every option, I implemented a reflection helper that uses Unreal's PropertyPathHelpers. A macro converts function names to property paths at compile time:
-
-
-
The helper automatically handles type conversion between strings and native types (floats, enums, bools), then serializes to GameUserSettings. This cut down settings implementation time significantly - I can add a new volume slider in under 10 lines instead of 50+.
-
-
Async Widget Loading with Callback Pipeline
-
Loading widgets synchronously caused hitches when opening menus mid-gameplay. I built an async system using UAssetManager's StreamableManager that loads soft class references off the main thread:
-
-
-
The two-stage callback lets callers initialize widgets before they're visible (setting owner references, binding data) and handle post-activation logic (setting focus targets). This pattern eliminated visible pop-in and kept frame times consistent.
-
-
Edit Conditions with Dependency Tracking
-
Settings often depend on other settings - V-Sync only works in fullscreen, screen resolution is locked in borderless mode. I implemented an edit condition system where options can specify predicates and forced values:
-
-
-
When dependencies change, the system broadcasts events to UI entries which re-evaluate their editable state. If a condition fails and has a forced value, it automatically sets that value and marks itself dirty. This prevented invalid states like enabling V-Sync while in windowed mode.
-
Technical Challenges
-
Type-Safe Enum Handling: Initially used string lookups for enum values which caused runtime errors when values didn't match. Switched to template specialization on ListDataObject_StringEnum that uses StaticEnum<T>() for compile-time type checking and automatic name conversion.
-
Circular Dependency Updates: When "Overall Quality" preset changed, it needed to update individual quality settings (shadows, textures, etc.), but those settings also needed to update "Overall Quality" when manually changed. Implemented a modify reason enum (DirectlyModified vs DependencyModified) to break the cycle - dependency updates don't trigger further broadcasts.
-
Memory Management for Dynamic Options: The registry creates data objects that outlive individual widgets. Initially used raw pointers which led to stale references when widgets were destroyed. Switched to the delegate pattern where widgets bind to data object events and unbind in NativeOnEntryReleased(), using weak object pointers for safety.
What I Learned
Property path reflection is powerful but requires careful error handling - malformed paths fail silently at runtime. Adding compile-time checks through macros caught 90% of issues during development. The async widget pattern scales well - the same code handles both fast internal data and slow external asset loads with identical caller interfaces. Understanding the difference between data ownership (registry owns objects) and view lifecycle (widgets are transient) was key to preventing leaks and crashes. Edit conditions turned out more complex than expected - simple boolean checks evolved into a full predicate system with forced values and rich error messages, but the flexibility was worth it.