CrimsonUIv1.0Coming to FabFree
Join the Discord

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 .uproject or 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_CommonUIInputData with 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 Execute runs on the client that chose it; it is not an authority boundary

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?
Not anymore. The plugin ships a working reference implementation: a pre-assigned UI policy and root layout, a fully wired HUD layout with escape menu and controller-disconnect screen, confirmation dialogs, all three context-menu presentations, a complete radial wheel and a player-editable one with its binding picker, button bases with CommonUI styles, tab lists, a bound-action bar, perf-stat blocks, a layered pool bar, slider materials, and preset CommonUI input data. Use them as-is to get running, then duplicate or subclass to make them yours.
Do I need C++ to use it?
No. The whole Quick Start, and every task page after it, has a Blueprint path. The policy, layouts, widget bases, dialogs, context menus, ViewModels, indicators, radial wheels and touch widgets are all subclassable in Blueprint, and the shipped assets are Blueprints you can open and study. A short list of accessors is C++-only (the UI manager's root-layout lookup, 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?
No. CrimsonUI builds and runs on its own with only engine plugins: CommonUI / CommonInput, UMG, Enhanced Input, ModelViewViewModel (MVVM), GameFeatures, ModularGameplay, and GameplayAbilities (for ASC tag reads). Cross-plugin extras come from CrimsonCore, the free integration layer from the Crimson Discord: chord modifier glyphs from CrimsonInput, ability and item wheel entries from CrimsonActionBar, wheel saving through CrimsonSaveSystem, and inventory and interaction context actions. Standalone, each has a public hook you can bind yourself.
Is it free?
Yes. CrimsonUI is free, so any project can start from a working CommonUI stack at no cost.
What do I still have to set up myself?
A few settings and one push: the Crimson viewport client class; the shipped CommonUI input data plus an input mapping context for its Click and Back actions; any layer tags beyond the native 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?
Yes. The Touch widgets, 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.