Runtime debug overlay

Assumes you have finished quick-start.

One section below is generated, not typed. § Rows is generated from the kit's own row list, one line per row in the order the panel draws them (the two Validator rows' source reads "the overlay's log sink"), and the two bitmasks in § Commands are computed from EUKOverlaySection's bit order. The page is checked against that list cell by cell, so the table and the panel cannot drift.

How to read the brackets. A bracket after a statement says how it is known and on which engine: [source-read 5.x] — read in that engine's source; [measured 5.x] — observed by the kit's own tests on that engine; [unverified] — not yet confirmed.

---

What it shows

A small text panel in one corner of each local player's screen that answers why did that interaction not happen? while you play: which object you are focused on and why it is or is not usable, what request is in flight, what the server decided and why, who holds a lock and where you are in its queue, and which UK-VAL rule lines this machine has logged. Most lines are one named, documented value from a getter the kit already ships; the Header rows come from engine calls, and the Validator rows are derived from this machine's log. The panel adds no replicated property and no RPC, and it only reads — it never changes the state it shows.

Turning it on. Two switches, both needed:

1. Tick Enable Debug Overlay — the setting bEnableDebugOverlay in Project Settings → Plugins → UK Interaction → Diagnostics. It is off by default; while it is off, UK.Overlay 1, UK.Overlay.Dump and UK.Overlay.Sections only log a line telling you to turn it on.
2. Open the console and type UK.Overlay 1 (UK.Overlay 0 hides it again). Or tick Show On Start in the same settings group (Overlay.bShowOnStart) to have the panel up from the first frame — the only way to catch a UK-VAL line logged at BeginPlay.

The panel never takes input: it cannot be clicked, focused or tabbed to, and it adds no key of its own. If you want a key, bind one in your project to the console command.

The one-frame lag. The panel refreshes at a fixed rate (Overlay.RefreshHz, default 10 per second) from a tickable object, and the engine ticks those objects before the late tick group the kit's detection runs in. So a refresh shows the previous frame's focus and detection — a one-frame lag that is invisible at ten refreshes a second, and the reason a value you just changed can appear one frame late. [source-read 5.6 / 5.7 / 5.8]

Where it exists. The overlay is its own module, UKInteractionDebug, loaded on game clients (a listen host included) and in the editor, in every build configuration except Shipping and Test. It is absent from Shipping and Test builds, from a dedicated server (no local player, so no panel), and from the Lite edition; in those the UK.Overlay commands do not exist.

Settings (Project Settings → Plugins → UK Interaction → Diagnostics → Overlay):

A hand-edited value outside its range is clamped when it is read.

Cost. The measured cost (c_snapshot, about 60–70 µs per refresh on the development machine the kit is measured on, standing in for reference hardware, at 10 refreshes a second) covers building the snapshot and its change check only. The on-screen part of a refresh — writing the panel's text and Slate's layout and paint — is not measured yet, and while a hold or a lock reservation is running the panel's timers change every refresh, so the text is rewritten every refresh during those moments. Averaged over frames, that snapshot cost is about 11 µs per frame at 10 refreshes a second and 60 fps, inside the kit's 20 µs per-frame budget for the panel. [measured 5.8, advisory] The panel is off by default, so none of this is paid until you turn it on.

Commands

While Enable Debug Overlay is off, only UK.Overlay 1, UK.Overlay.Dump and UK.Overlay.Sections log a line (telling you to turn it on) and do nothing else; UK.Overlay 0 logs nothing. A UK.Overlay value other than -1, 0 or 1 (for example UK.Overlay 5) logs a Warning whether the setting is on or off, and is read as -1.

While the game is paused, UK.Overlay 0 / UK.Overlay 1 take effect when it unpauses: the panel is refreshed by a tick that does not run while paused, so it keeps the last rows it drew. UK.Overlay.Dump works at any time and always reads the state now.

With every section on, the panel is taller than a 1080p screen at the default font size and clips at the bottom — which is where Lock and Validator sit. Two recipes trim it:

Triage — Header, Focus, Pending, Active, Events, Lock, Validator. Sized for a 1080p screen at FontSize 10 with every source present; if it still clips on yours, lower FontSize.

UK.Overlay.Sections 2675

Prompt — Header, Focus, Prompt, Input: for "why is there no prompt?".

UK.Overlay.Sections 387

Row grammar

Every row the panel shows is also one log line when you run UK.Overlay.Dump, in exactly this grammar — the panel and the dump carry the same text, byte for byte:

^UK-OVL ([A-Z][A-Za-z]+)\.([A-Za-z_][A-Za-z0-9_]*(?:\[[0-9]+\])?)=(.*)$

Group 1 is the section, group 2 the key (for counter rows the field's own name; for every row, § Rows' source column gives the line), group 3 the value. The value may itself contain =, so split on the first = after the key. Examples:

UK-OVL Focus.target=BP_Door
UK-OVL Pending.hold_s=2.00
UK-OVL Protocol.RejectedByReason=OutOfRange=2;Locked=1
UK-OVL Lock.stats_Admitted=—

Rows

Twelve sections, always in this order. history[i] and last[i] stand for one row per kept line, oldest first.

What each section means

Header

Which machine this panel belongs to: the net mode (Standalone, ListenServer, Client), the local player's controller id, the pawn's role (Authority, AutonomousProxy, …), the kit version, the refresh rate and whether UK.Protocol.Profile is on (protocol.md § UK.Protocol.Profile). Read it first: every other row is a statement about this machine.

Focus

What the local interactor is focused on and what that object says about itself: its preset, its usability and state, the distance, the resolved prompt text, and the last reason a press was refused locally before anything was sent (Focus.denial, the reason On Interact Denied reported).

Which machine? On Interact Denied — Local machine.

Detection, Protocol, Pending, Active, Events

Detection is the interactor's detection counters, one row per field of FUKDetectionStats. Protocol is FUKProtocolStats: the client group on the player's own machine, the authority group on the server, and both on a listen host. Pending is the request this client has in flight and Active the interaction the server is running. Events is the last event on the interactor and on the focused object, each rendered the way events.md describes, followed by a short history (EventHistoryLines). The timing rows (…Microseconds) are filled only while UK.Protocol.Profile is on.

Prompt, Input

The sample prompt's counters and state — including bWidgetCreated / bWidgetOnScreen and the why-not line — and the input binding's state, both from the local player's own machine (prompt.md, input.md).

Lock

The focused object's lock (lock.md): the policy, the holder, the queue in order, your own place in it, the time left on a reservation, and — on the server only — the lock's counters, each keyed stats_<Field>. A client does not have the counters, so its panel shows — for every stats_ row, never 0.

Lock.my_position is 1-based: 1 is first in line, and 0 means you are not in the queue at all.

On a client, reservation_s is measured on the client's estimate of server time (AGameStateBase::GetServerWorldTimeSeconds()), which trails the server briefly; it can therefore read slightly above the lock's ReservationSeconds for a moment after a reservation starts. The server's own panel is exact. A client with no game state yet shows —.

Pickup

The pickup scheduler's counters. They exist on the server only, so a client's panel shows —.

Validator

The rule lines this machine has logged — count, then the last few (ValidatorHistoryLines) — with the same UK-VAL-NNN token the editor and the rest of these documents use, so you can search once.

The Validator row counts UK-VAL lines from the log of the machine the panel runs on. On a listen host that includes the authority-only checks (UK-VAL-026, -041, -101, -110 to -113). A remote client — of a listen or a dedicated server — never sees those; read them in the server's log. A dedicated server has no local player and therefore no panel. In PIE with Run Under One Process every instance shares one log, so a client window also counts the server's lines — that is PIE, not your shipped game.

The panel reads the log as it refreshes and does not wait for lines still being written, so it can trail the log by up to one refresh. UK.Overlay.Dump waits for the log first, so a dump is always current.

Placeholders

A row whose source does not exist on this machine shows — (an em dash): no lock component on the focused object, no authority, no focus, a pickup scheduler that is inactive on a client. A section whose source is missing shows its header with — in its first row — never a blank, and never a stale value left over from the last object you looked at. — means this machine does not know; 0 always means counted, and zero.

A section you turned off with EnabledSections is not drawn at all, so a hidden section and an empty one never look alike.

Known gaps

Recorded so you can read every claim on this page as narrowly as it was proven.

• Engine coverage. The overlay is written for every supported engine with no version gates. In one line: "supported on 5.6–5.8; multiplayer end-to-end suite run on all three". The session tests that drive the panel end to end have run on the engines that sentence names as run, and on no other.
• Nothing on the panel is pixel-tested. Every automated run is headless, so what is tested is the text — the same lines UK.Overlay.Dump writes. Font, colour, corner and opacity are not asserted by any test; the screenshot above is the on-screen record, taken in an editor session by hand.
• Whether the triage recipe fits a 1080p screen is derived, not measured. It is sized for it at the default font size and sits on the margin; FontSize is the lever if it clips.
• Split-screen. Two local players in one process each get their own panel and their own rows, which is tested. Where each panel lands inside its player's part of the screen has not been checked on screen.
• The on-screen part of a refresh is not measured — only the snapshot is (§ What it shows › Cost).
• Development builds only. The overlay is not in Shipping or Test builds, not on a dedicated server, and not in the Lite edition — by design, so it can never reach a player.