holoscreen_device: Holographic Displays in Your Island

Overview

The holoscreen_device is a purely visual prop-like device that renders a holographic screen in your island. Out of the box it can display a clock face or a selection of curated images — great for sci-fi control rooms, countdown lobbies, security-monitor walls, or atmospheric set dressing.

Because holoscreen_device inherits from creative_device_base and exposes no Verse-callable methods or events, you cannot drive its content from code. What you can do is:

• Reference it as an @editable field so Verse knows which placed holoscreen to talk about in the future.
• Pair it with other devices (trigger pads, capture areas, timers) to build sequences around it — e.g., power it on visually by enabling a surrounding prop or lighting rig at the same moment your Verse logic fires.
• Use it as a landmark anchor: read its transform via the inherited GetTransform helpers if you need to position other objects relative to the screen.

Reach for holoscreen_device when you want an in-world display that runs itself and you just need Verse to orchestrate the context around it.

API Reference

holoscreen_device

Used to create a holographic screen that displays a clock or other curated images.

Full public surface, resolved verbatim from the live Epic digest (Fortnite.digest.verse).

holoscreen_device<public> := class<concrete><final>(creative_device_base):

Walkthrough

Scenario — Security Room Reveal: A player steps on a pressure plate outside a vault. The lights flicker (a cinematic sequence device fires), and a holoscreen on the wall activates to show the clock — signalling the vault timer has started. A HUD message confirms the event to the player.

Because holoscreen_device has no Verse API surface, the Verse device's job is to coordinate the surrounding devices. The holoscreen itself is configured in the UEFN editor (set its display to Clock mode). Verse enables a cinematic_sequence_device and shows a HUD message when the trigger fires.

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Conversations }

# Localised message helper — `message` params require a localised value.
vault_activated_text<localizes>(S : string) : message = "{S}"

vault_reveal_device := class(creative_device):

    # The pressure plate the player steps on.
    @editable
    TriggerPlate : trigger_device = trigger_device{}

    # The holoscreen placed on the vault wall.
    # No Verse methods to call on it — we reference it so the editor
    # wires this script to the correct placed instance.
    @editable
    VaultScreen : holoscreen_device = holoscreen_device{}

    # A cinematic sequence that flickers the lights.
    @editable
    LightFlicker : cinematic_sequence_device = cinematic_sequence_device{}

    # A HUD message device to notify the player.
    @editable
    StatusHUD : hud_message_device = hud_message_device{}

    # Called when the game starts.
    OnBegin<override>()<suspends> : void =
        # Subscribe to the trigger plate — handler fires when a player steps on it.
        TriggerPlate.TriggeredEvent.Subscribe(OnPlateTriggered)

    # Handler: player stepped on the pressure plate.
    OnPlateTriggered(Agent : ?agent) : void =
        # Fire the light-flicker cinematic.
        LightFlicker.Play()

        # Show the vault-activated message to whoever triggered the plate.
        if (A := Agent?):
            StatusHUD.Show(A)

        # The holoscreen is already running its clock display — no API call
        # needed. In the editor, set Holoscreen Display Mode to "Clock" so
        # it shows the live time the moment the scene loads.
        # Future Epic API additions may expose Enable/Disable here.

Line-by-line explanation:

Common patterns

Pattern 1 — Toggle a holoscreen's surrounding light rig on player arrival

Use a capture_area_device to detect when a player enters the room, then enable a customizable_light_device that illuminates the holoscreen. The holoscreen itself needs no code.

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }

holoscreen_room_lighting_device := class(creative_device):

    # The holoscreen on the wall — referenced for editor wiring only.
    @editable
    RoomScreen : holoscreen_device = holoscreen_device{}

    # Capture area covering the room entrance.
    @editable
    RoomEntrance : capture_area_device = capture_area_device{}

    # A light device that illuminates the holoscreen.
    @editable
    ScreenLight : customizable_light_device = customizable_light_device{}

    OnBegin<override>()<suspends> : void =
        RoomEntrance.AgentEntersEvent.Subscribe(OnAgentEnters)
        RoomEntrance.AgentLeavesEvent.Subscribe(OnAgentLeaves)

    OnAgentEnters(Agent : agent) : void =
        # Light up the holoscreen when someone enters.
        ScreenLight.TurnOn()

    OnAgentLeaves(Agent : agent) : void =
        # Dim the light when the room is empty.
        ScreenLight.TurnOff()

Pattern 2 — Sequence multiple holoscreens with a timer

Cycle through three holoscreens (each showing a different curated image, configured in the editor) by enabling and disabling their surrounding prop frames on a timer loop. Because holoscreen_device has no enable/disable API, we control visibility via companion customizable_light_device spotlights — one per screen.

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }

holoscreen_sequencer_device := class(creative_device):

    # Three holoscreens — editor-configured with different images.
    @editable
    Screen1 : holoscreen_device = holoscreen_device{}
    @editable
    Screen2 : holoscreen_device = holoscreen_device{}
    @editable
    Screen3 : holoscreen_device = holoscreen_device{}

    # Spotlights that highlight each screen in turn.
    @editable
    Light1 : customizable_light_device = customizable_light_device{}
    @editable
    Light2 : customizable_light_device = customizable_light_device{}
    @editable
    Light3 : customizable_light_device = customizable_light_device{}

    # How long each screen stays highlighted (seconds).
    @editable
    DisplayDuration : float = 3.0

    OnBegin<override>()<suspends> : void =
        # Start all lights off.
        Light1.TurnOff()
        Light2.TurnOff()
        Light3.TurnOff()

        # Loop forever, cycling spotlight focus across the three screens.
        loop:
            Light1.TurnOn()
            Sleep(DisplayDuration)
            Light1.TurnOff()

            Light2.TurnOn()
            Sleep(DisplayDuration)
            Light2.TurnOff()

            Light3.TurnOn()
            Sleep(DisplayDuration)
            Light3.TurnOff()

Pattern 3 — Show a HUD message when a player looks at (approaches) the holoscreen

A trigger volume placed in front of the holoscreen acts as a "proximity sensor". When triggered, show a localised message explaining what the screen displays.

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Conversations }

screen_info_text<localizes>(S : string) : message = "{S}"

holoscreen_info_device := class(creative_device):

    # The holoscreen being described.
    @editable
    InfoScreen : holoscreen_device = holoscreen_device{}

    # Trigger volume placed directly in front of the holoscreen.
    @editable
    ProximityTrigger : trigger_device = trigger_device{}

    # HUD message device to surface the description.
    @editable
    InfoHUD : hud_message_device = hud_message_device{}

    OnBegin<override>()<suspends> : void =
        ProximityTrigger.TriggeredEvent.Subscribe(OnPlayerApproaches)

    OnPlayerApproaches(Agent : ?agent) : void =
        if (A := Agent?):
            # Show a contextual message to the player near the screen.
            InfoHUD.Show(A)

Gotchas

1. holoscreen_device has no Verse API — and that's intentional

The device's entire behaviour (which image or clock to display, refresh rate, size) is configured in the UEFN Details panel, not in code. Don't search for Enable(), SetImage(), or Show() — they don't exist on this type. All Verse can do is hold a reference to the placed instance.

2. You still need the @editable field

Even though you never call a method on VaultScreen, declaring it as @editable is what tells UEFN to let you assign the placed holoscreen in the Details panel. Without the field, the editor has no slot to wire the device into your script.

3. trigger_device.TriggeredEvent delivers ?agent, not agent

The event signature is listenable(?agent). Your handler must be (Agent : ?agent) and you must unwrap with if (A := Agent?): before calling any agent-typed API (like hud_message_device.Show(A)). Forgetting the unwrap is a compile error.

4. message params are not raw strings

If you pass text to a hud_message_device or any message-typed parameter, you cannot pass a plain string. Declare a localised helper:

MyText<localizes>(S : string) : message = "{S}"

Then call MyText("Vault timer started!"). There is no StringToMessage function.

5. Sleep() requires a float, not an int

Verse does not auto-convert int to float. Write Sleep(3.0), not Sleep(3), or you'll get a type-mismatch compile error.

6. Content is editor-only — test in-game

The holoscreen's displayed image or clock is only visible when the island is running (Play-in-Editor or published). In the UEFN viewport it may appear blank or show a placeholder. Always do a full PIE run to verify the display looks correct.