Fix: Unreal Widget Not Showing on Screen

Here is how to fix Unreal widget not showing on screen. You designed a HUD, a pause menu, or an inventory screen in the UMG editor, hit Play, and nothing appears. The viewport is empty. No errors, no warnings, just a missing widget. This is one of the most reported issues in Unreal UI development, and it usually comes down to one of four causes: forgetting to add the widget to the viewport, a visibility setting that hides it, a Z-order conflict, or an input mode that prevents interaction.

The Symptom

You created a Widget Blueprint in the UMG designer. It looks correct in the preview. You added logic to create and display it at runtime — either in your player controller, your HUD class, or your character Blueprint. When you play the game, the widget does not appear on screen.

Sometimes the widget partially appears: it takes up space (you can see other widgets shifting) but the content is invisible. Other times, the widget renders correctly but does not respond to mouse clicks or keyboard input. And in some cases, the widget shows in the editor preview but is completely absent in a packaged build.

Creating and Adding the Widget

The most common mistake is creating the widget without adding it to the viewport. CreateWidget allocates the widget in memory and initializes it, but it does not display it. You must call AddToViewport() separately.

// Correct: create then add to viewport
void AMyPlayerController::BeginPlay()
{
    Super::BeginPlay();

    if (!HUDWidgetClass)
    {
        UE_LOG(LogTemp, Error, TEXT("HUDWidgetClass is null - assign it in the Blueprint defaults"));
        return;
    }

    HUDWidget = CreateWidget<UMyHUDWidget>(this, HUDWidgetClass);
    if (HUDWidget)
    {
        HUDWidget->AddToViewport(0);
        UE_LOG(LogTemp, Log, TEXT("HUD widget added to viewport"));
    }
}

A second common mistake is trying to create the widget from the wrong context. CreateWidget requires a valid owning player controller or world context. If you call it from a class that has no world context (like a static utility function), the call returns null.

In Blueprints, the flow is the same: use the Create Widget node, set the Class, then connect the output to Add to Viewport. If you skip the Add to Viewport node, the widget exists but is invisible.

Visibility and Layout Settings

UMG widgets have a Visibility property that controls both rendering and hit testing. If the root panel of your widget is set to Collapsed or Hidden, the widget will not appear even though it is in the viewport.

The visibility values and their meanings:

Visible: The widget renders and accepts hit tests (mouse clicks). This is what you want for interactive UI.

SelfHitTestInvisible: The widget renders but does not accept direct hit tests. Child widgets can still be interactive. Use this for layout containers.

HitTestInvisible: The widget renders but neither it nor any of its children accept hit tests.

Hidden: The widget does not render but still occupies layout space. Other widgets arrange themselves as if it were there.

Collapsed: The widget does not render and does not occupy any space. It is as if the widget does not exist in the layout.

// Set visibility at runtime
void UMyHUDWidget::ShowHealthBar()
{
    if (HealthBarWidget)
    {
        HealthBarWidget->SetVisibility(ESlateVisibility::Visible);
    }
}

void UMyHUDWidget::HideHealthBar()
{
    if (HealthBarWidget)
    {
        // Use Collapsed, not Hidden, if you want other elements to reclaim the space
        HealthBarWidget->SetVisibility(ESlateVisibility::Collapsed);
    }
}

Another layout issue is the widget having zero size. If your root widget is a Canvas Panel and you placed child widgets outside its bounds, or if a Size Box has its dimensions set to zero, the widget technically exists in the viewport but has no visible area.

Z-Order and Widget Stacking

When you call AddToViewport(), you can pass a Z-order value. Widgets with higher Z-order values render on top of widgets with lower values. If your widget is behind another full-screen widget, it is hidden even though it is in the viewport.

// Z-order controls stacking
HUDWidget->AddToViewport(0);     // Background layer
MenuWidget->AddToViewport(10);   // Menu renders on top of HUD
TooltipWidget->AddToViewport(20); // Tooltips render on top of everything

If you add a full-screen black background widget at Z-order 100 and your HUD is at Z-order 0, the HUD is there but completely obscured. Check what other widgets are in the viewport using the Widget Reflector tool (Window → Developer Tools → Widget Reflector in the editor).

The Widget Reflector is the single most useful debugging tool for UMG. It shows every widget in the hierarchy, its visibility state, its size, and its position. If your widget is in the viewport but invisible, the Reflector will tell you why.

Input Mode Conflicts

Your widget might be visible but unresponsive. This happens when the player controller’s input mode does not include UI input. Unreal has three input modes:

Game Only: Input goes to the game. Widgets render but cannot be clicked or focused. The mouse cursor is hidden.

UI Only: Input goes to widgets. The game does not receive movement or action inputs. The mouse cursor is visible.

Game And UI: Both the game and widgets receive input. This is useful for HUD elements that need to be clickable while the player can still move.

// Show a menu and switch to UI input mode
void AMyPlayerController::OpenPauseMenu()
{
    if (!PauseMenuWidget)
    {
        PauseMenuWidget = CreateWidget<UMyPauseMenu>(this, PauseMenuClass);
    }

    PauseMenuWidget->AddToViewport(100);

    FInputModeUIOnly InputMode;
    InputMode.SetWidgetToFocus(PauseMenuWidget->TakeWidget());
    SetInputMode(InputMode);
    SetShowMouseCursor(true);
}

// Close the menu and return to game input
void AMyPlayerController::ClosePauseMenu()
{
    if (PauseMenuWidget)
    {
        PauseMenuWidget->RemoveFromParent();
    }

    FInputModeGameOnly InputMode;
    SetInputMode(InputMode);
    SetShowMouseCursor(false);
}

A subtle issue: if you call SetInputMode(FInputModeUIOnly) without specifying a widget to focus via SetWidgetToFocus, keyboard navigation may not work correctly even though mouse input does.

World Space Widgets

If you want a widget to appear in 3D space (a health bar above an enemy, a nameplate, an in-world interaction prompt), you should not use AddToViewport. Instead, use a Widget Component attached to the actor.

// Set up a world-space widget component in the actor constructor
AMyEnemy::AMyEnemy()
{
    HealthBarComponent = CreateDefaultSubobject<UWidgetComponent>(
        TEXT("HealthBar"));
    HealthBarComponent->SetupAttachment(GetRootComponent());
    HealthBarComponent->SetRelativeLocation(FVector(0.f, 0.f, 120.f));
    HealthBarComponent->SetWidgetSpace(EWidgetSpace::Screen);
    HealthBarComponent->SetDrawSize(FVector2D(200.f, 30.f));
}

void AMyEnemy::BeginPlay()
{
    Super::BeginPlay();

    if (HealthBarWidgetClass)
    {
        HealthBarComponent->SetWidgetClass(HealthBarWidgetClass);
    }
}

Common issues with Widget Components: the draw size is too small to see, the widget space is set to World but the widget faces away from the camera, or the component is hidden because the parent actor’s visibility is toggled off. For Screen space widgets, they always face the camera but may be culled if the actor is outside the view frustum.

Related Issues

If your widget appears but you cannot navigate it with a gamepad, see our guide on UMG widget focus not working with gamepad. If the widget is tied to an actor that is not spawning correctly, check Blueprint cast always failing for common reference issues.

Open the Widget Reflector before debugging anything else. It shows you what is actually in the viewport and why it is not visible.