User interface

Arc is the one UI framework behind the editor and the game. ArcUI is the game-UI layer on top of it, the UMG to Arc's Slate.

Last updated Oct 26, 2026Edit this pageVersion 1.0.0

Mowo has one UI framework. Arc draws every panel of Mowo Editor and every menu and HUD in a shipped game. ArcUI is the game-UI layer built on top of Arc. If you know Unreal, Arc plays the role of Slate and ArcUI plays the role of UMG.

This section covers both halves: how Arc lays out, styles and routes input to widgets, how ArcUI turns a .ui asset into a live screen, the designer you author those assets in, the player settings screens that ship with the engine, and how game text is localized.

Two layers, one widget set

  1. arc-style.json tokens
  2. Arc widgets (C++)
  3. ArcUI factory
  4. .ui screen
  5. Screen stack overlay
Arc supplies widgets and style; ArcUI builds screens from assets and mounts them over the game view.
LayerModuleWhat you use it for
ArcMowoEngine.Arc (namespace Arcf)C++ widgets, layout, focus, input routing, text, docking, the style set. The editor is written directly against it.
ArcUIMowoEngine.ArcUIGame screens as assets: the .ui format, .theme themes, the widget factory, data bindings, animations, the screen stack, world-space widgets and the settings, rebind and lobby screens.

Arc's public dependencies are SDL3 and MDF; its font and render back ends are private. ArcUI sits above Arc and the ECS component tier and depends on the Visual Scripting module, so a screen can call graphs.

Engine note

Because the editor and the game share one widget set, a widget in a game HUD is the same class the editor uses in its panels. FArcWidgetFactory builds .ui nodes into real Arcf widgets such as ATextBlock, AButton and ASlider, not into a separate game-only tree FArcWidgetFactory.

How a game screen gets on screen

  1. Author the screen

    Create a .ui asset with More > Arc Widget in the Content Browser and lay it out in the ArcUI Designer. The asset stores a widget tree, bindings, events, animations, and an optional theme and controller class.

  2. Mount it

    Attach an ArcUI component (fields asset, z_order, visible, auto_focus) to an entity, or push the screen from code with PushScreen(assetPath, zOrder, modal) ArcUIComponent CArcUIScreenStack::PushScreen. For a widget in the 3D world, such as a nameplate, use an ArcUIWorldWidget component instead ArcUIWorldWidgetComponent.

  3. Let the stack run it

    CArcUIScreenStack builds the tree, composites every screen into one overlay, re-resolves bindings every tick, routes widget events and drives gamepad focus CArcUIScreenStack.

Details are on ArcUI screens.

Mowo Editor in Play mode with the test project's ArcUiOverlay scene: the HUD.ui overlay drawn over the 3D viewport, showing a health bar and text in the top-left corner
An ArcUI screen mounted over the game view in Play-In-Editor.

Where to go next

Current limits

  • A screen stack keeps one controller instance per class, keyed by class name, so two screens with the same controller class share its variables. MUIStatics talks to a single process-wide active stack.

Engine sources

This page describes behavior implemented in these files of the engine repository, checked against commit 5922e6e5e.

  • Engine/Source/Runtime/ArcUI/Public/ArcUI/CArcUIScreenStack.h
  • Engine/Source/Runtime/ArcUI/Public/ArcUI/FArcWidgetFactory.h
  • Engine/Source/Runtime/ArcUI/Public/ArcUI/ECS/Components/ArcUIComponent.h
  • Engine/Source/Runtime/ArcUI/Public/ArcUI/ECS/Components/ArcUIWorldWidgetComponent.h

Page feedback

Was this page helpful?