A game-agnostic CommonUI foundation (policy and layers, activatable widgets, dialogs, context menus, radial wheels, indicators, MVVM and touch) that ships working Blueprint assets so a fresh project boots with a complete UI stack.
Free · Foundation · Unreal Engine 5
Ship menus and HUDs on a complete CommonUI foundation. The boot assets are already built.
A game-agnostic CommonUI layer: one layout per local player with UI.Layer.*-keyed widget stacks, activatable widget and HUD bases, dialogs, context menus, radial wheels, MVVM base classes, world-space indicators, touch input and a performance readout. Every one ships as a working, pre-configured Blueprint, so you start from a running UI stack.
Why CrimsonUI
Everything a CommonUI front end needs, shipped as working, pre-configured assets you can use as-is, duplicate, or subclass.
Boots out of the box
The UI settings ship pre-filled: B_CrimsonUIPolicy is the default policy, its W_CrimsonOverallUILayout root layout registers a stack for every standard layer, and the dialog and context-menu defaults are already assigned. Enable the plugin, set the viewport client and input data, push the shipped W_CrimsonHUD_Layout. Done.
Policy & primary layout
One UCrimsonGameUIPolicy spawns one UCrimsonPrimaryGameLayout per local player, and widgets push onto UI.Layer.* tag-keyed stacks whose base tags ship with CrimsonUI. Local multiplayer is a policy setting (PrimaryOnly, SingleToggle, or Simultaneous for a full layout per split-screen player), and pushes are single-node Blueprint async actions.
Activatable widgets & HUD escape
UCrimsonActivatableWidget carries input-mode, mouse-capture, move/look-blocking and focus-restoration metadata that auto-applies on activation. The shipped W_CrimsonHUD_Layout already routes the Escape action to a pause menu and wires the controller-disconnect screen, and UCrimsonTaggedWidget shows or hides HUD elements from the player's ASC tags.
Dialogs & context menus
UCrimsonMessagingSubsystem shows Yes/No, OK and OK/Cancel dialogs from one Blueprint async node; the result fires exactly once, shown or not. UCrimsonContextMenuSubsystem pops cursor-, world- or wheel-anchored menus whose actions are gathered from the target, the same gather the server re-runs to validate the pick.
Wheels, authored or player-bound
UCrimsonRadialWheel selects by direction, not hover, so mouse and stick run one code path and sector art overlaps. Author options on an asset, or hand the wheel to the player: a binding is a provider tag plus an opaque payload, plain data to save anywhere.
MVVM, tabs, lists & drag-drop
UCrimsonViewModelBase / Screen / Entry expose the ULocalPlayer and a FieldNotify list-row index. Alongside them: tab lists with badge counts, list/tile views that pick a widget class per item type, drag-drop, countdown buttons, input-glyph buttons that follow the player's device, and a debounced search field.
Indicators, touch & perf stats
Pooled indicators project widgets onto world positions: five projection modes, clamp-to-screen and off-screen arrows. UCrimsonJoystickWidget and UCrimsonTouchRegion inject synthetic Enhanced Input, so a virtual stick fires the same UInputAction as a gamepad. Eighteen performance stats sample every frame into blocks and graphs, no wiring needed.
Controls that carry their own behaviour
UCrimsonAnalogSlider steps like an OS on a held key (one step, a pause, then an accelerating repeat) and tints its handle on focus, which FSliderStyle cannot. UCrimsonPoolBarWidget draws health, shield, barrier and damage/heal trail as one material, so layers never drift apart.
A closer look
Boot a working UI stack without building a single widget
Enable CrimsonUI, set the Crimson viewport client, assign the shipped Crimson_CommonUIInputData to CommonUI, and push the shipped HUD layout. Policy, root layout, dialogs and context menus are already assigned.
- Defaults live in Project Settings → Crimson → Crimson UI
- Keep your own game instance, local player and controller classes: any class works
- Blueprint projects never touch a
.uprojector a.Build.cs
Shipped content is a reference implementation, not filler
Every widget type has a complete, working Blueprint in the plugin's Content folder. Tick Show Plugin Content in the Content Browser to see them, then use them as-is, duplicate one as a starting point, or subclass to restyle.
- HUD layouts, a game menu, confirmation dialogs, button bases with styles, tab lists and a bound-action bar
- All three context-menu presentations, the radial wheel and the player-editable wheel with its binding picker
- Perf-stat blocks, a pool bar, slider materials and
Crimson_CommonUIInputDatawith Click/Back preset
A wheel the player fills in themselves
Ship an empty wheel and let the player decide what goes in it. Instanced action objects cannot round-trip through a save file, so a player's choice is stored as a two-field binding: a provider tag and an opaque payload CrimsonUI never looks inside.
- The live slice is rebuilt from the binding every time the wheel opens and never stored
- No save-system dependency of any kind: Get Save Data and Apply Save Data hand you plain data
- Applying it is server-authoritative
- Ability and item entries plus saving come with CrimsonCore; standalone, write a binding provider
None of it is authoritative, and the docs say so first
Nothing in CrimsonUI replicates, and a dedicated server creates no UI at all. So every widget event is an untrusted client request: route it through a validated Server_ RPC or a gameplay ability and let the authoritative result replicate back into the UI.
- Layouts, layers, pushes, dialogs and input configs are owning-client-only
- A radial action's
Executeruns on the client that chose it; it is not an authority boundary
Screenshots
Technical details
- Engine
- UE 5.8
- Tested platforms
- Windows
- Blueprint-ready
- Yes
- C++ required
- No
- Network replicated
- No
- Dependencies
- CommonUI, CommonInput, UMG, EnhancedInput, ModelViewViewModel, GameFeatures, ModularGameplay, GameplayAbilities
Frequently asked questions
Do I have to build all the widgets myself?
Do I need C++ to use it?
GetPrimaryGameLayout, the messaging subsystem's direct calls, the context-menu confirm interceptor), and the everyday paths have Blueprint equivalents: the push API on UCrimsonUIExtensions, the async push and confirmation nodes, and the Project Settings panel. For a Blueprint project, ticking the plugin in Edit → Plugins is the entire install.Does it depend on other Crimson plugins?
Is it free?
What do I still have to set up myself?
UI.Layer.* set; and the HUD push itself, from your PlayerController, GameMode or your own GameFeature action. The policy, root layout, dialogs and context menus are pre-assigned in Crimson UI settings, and your existing game instance and local player classes stay as they are. The plugin ships an asset for every piece; the work is pointing at them, not building them.Does it work for mobile and touch?
UCrimsonJoystickWidget and UCrimsonTouchRegion, inject synthetic Enhanced Input values through the standard injection API, so a virtual stick or button fires the same UInputAction your gamepad and keyboard do. Your gameplay code doesn't need to know touch exists, and nothing about the injection replicates; the server sees the resulting movement and abilities through the normal channels.Start from a working UI, not a blank canvas
Enable CrimsonUI, set the viewport client and input data, and push the shipped HUD layout; the policy, root layout, dialogs and context menus are already configured. Every asset is yours to open, duplicate, or subclass.
Ready for more? Add a premium system
Every premium system runs on its own, so add only the ones your game needs.
Layout-agnostic, fully replicated inventory with bags and containers.
- Pluggable Topology
- Runtime Constraints
- Scoped Containers
- No RPCs to Write
Replicated, GAS-native skill trees with a two-graph editor.
- Two-Graph Editor
- Material Splines
- Server-Authoritative
- Atomic Respec & Loadouts
Data-driven settings framework with a ready-made CommonUI screen.
- Data-Driven Options
- Zero-Glue Persistence
- CommonUI Screen
- Presets & Profiles
- Live Preview