Whether a UE4SS game is running and the UEBridge mod is answering. Reports the game found, mod version, permissions, round-trip time.

Run a Lua chunk inside the game on the game thread and return what it returns.

The full UE4SS Lua API is available (StaticFindObject, FindFirstOf, FindAllOf, RegisterHook, ForEachUObject, ...) plus the UEB helper table: UEB.resolve(ref), UEB.props(ref), UEB.funcs(ref), UEB.get(ref, name), UEB.set(ref, name, value), UEB.call(ref, fn, args), UEB.objects(class, limit), UEB.types(pattern, limit), UEB.console(cmd), UEB.world(), UEB.dump(kind), UEB.snapshot(ref, label), UEB.diff(ref, label), UEB.snapshots(), UEB.forget(label), UEB.subclasses(ref, limit, pattern), UEB.target(distance, channel, ref), UEB.watch(ref, names, label, interval_ms, every), UEB.hook(fnpath, label, max_args), UEB.events(since, label, limit, clear), UEB.streams(), UEB.unwatch(label). UEHelpers is in scope too. print() output is captured and returned alongside the result. Refused when the mod's settings.lua sets allow_eval = false; the other tools keep working.

Current world, player controller, pawn, game instance and game mode.

Resolve an object reference and return its full name, class and address.

Live (non-default) instances of a short class name, e.g. 'PlayerController'.

Loaded reflected types whose name matches a Lua pattern (empty = all). Walks GUObjectArray (~400 ms).

Every loaded class derived from a base class, Blueprint classes included.

ref is a class path ('/Script/Engine.PlayerController'); passing an object that is not a Class or BlueprintGeneratedClass raises. The base itself is excluded. pattern is an optional Lua pattern matched against the short name.

Returns {base, count, types}, where count is the number of matches before limit and each row is {name, kind, path, parent} with parent the immediate super class's short name. Rows are sorted by path. The engine keeps no reverse index, so this walks every UObject and tests IsChildOf: about 1.5 s on a large game.

What the player is looking at: a line trace from the camera along its forward vector.

distance is in centimetres (the engine's unit), default 5000. channel is a trace channel: 0 = Visibility, 1 = Camera. ref traces from that actor's own location and forward vector instead of the camera, which is how you ask what an NPC faces.

Returns {hit} alone on a miss, otherwise {hit, actor, actor_class, component, component_class, distance, impact_point, impact_normal, bone, phys_material, materials}. actor is the hit component's owner; materials are the component's material full names (first 32) when it exposes GetMaterials. Read-only: it works with allow_writes = false.

Sample properties on a timer and record an event whenever a value changes. Read-only.

names is one property name or a list. every=True records every sample instead of only changes. Read the results with poll_events; nothing is pushed.

interval_ms is clamped to at least 100 and defaults to 250. A pass that looks the object up costs roughly 10 to 25 ms of game-thread time on a game without object hash tables, so keep watches few and slow (250 ms or more).

The object is held between passes and rechecked with IsValid() on each one; a lookup happens only when it is gone or a read failed, so the watch follows a reference such as 'first:PlayerController' across respawns without paying a scan per pass. {kind: "stream", event: "resumed"} is recorded when the watch adopts a different object (by address) after the previous one stopped being valid or was lost, with the baseline reset so the first sample on the new object is not reported as a change; the same object coming back after a blip records nothing. If the reference stops resolving (usually a map transition) it records one {kind: "stream", event: "lost"} row and keeps retrying at a slow cadence. Only stop_stream ends a watch.

Labels are unique: reusing one raises. Stop a watch with stop_stream.

Record every call of a UFunction, with its parameters. Counts as a write.

function is a UFunction path ('/Script/Engine.PlayerController:ClientRestart'). max_args caps how many parameters are copied per call (default 8). Read the calls with poll_events.

The callback copies parameters and the calling object's name and does nothing else. A native hook registers cleanly, but an eval that then CALLS the hooked function crashed the game with an access violation, so read hook output through poll_events and do not call a hooked function from eval_lua in the same session.

Hooking intercepts game code, so it is refused when allow_writes = false. Stop a hook with stop_stream, which unregisters it.

Drain events recorded by watches and hooks. Read-only.

since is a sequence number, exclusive: pass back the next from the previous call to get only what is new. label filters to one stream. clear=True drops the returned rows.

Returns {events, next, dropped, buffered}. Each row is {seq, t, label, kind} plus, for a watch, {path, before, after}, and for a hook, {fn, self, args}. The buffer holds 2000 events across all streams; dropped counts what the cap evicted before you read it.

Watches and hooks currently running: {label, kind, target, interval_ms, events, started, active, lost}. Read-only.

Stop one watch or hook by label, or all of them with label="*". Unregisters a hook.

Every reflected property of an object with its current value. Use on CDOs and live actors.

pattern is an optional Lua pattern matched against the property name, e.g. "^Camera" or "Speed"; one pawn can be 300 properties, so filtering is usually what you want.

include_super defaults to False. SoftObjectProperty values are skipped (reading one has crashed a game inside UE4SS's own property reader, which no Lua pcall can catch).

Walk an object's reflected properties and keep the result in the game under label. Read-only.

The same walk as inspect_object, kept for diff_object. include_super and pattern are stored with the snapshot so the diff re-walks the same set. Reusing a label replaces the snapshot.

Returns {label, path, count, taken}, where taken is a wall-clock timestamp (os.time() in the game, whole seconds since the epoch). Snapshots live in the game process: they survive a UEB.reload() but not a game restart.

Re-walk an object and report what changed since the snapshot stored under label. Read-only.

ref defaults to the reference the snapshot was taken with; pass one to compare a different object against the stored walk.

Returns {label, path, changed, added, removed, same}, where same is the number of top-level properties with no changed, added or removed rows, and each changed row is {path, before, after} with a dotted path into the property ("Mesh.RelativeLocation.X", "Inventory[3].Count"). Object-valued properties compare by their path, not their address, so an unchanged object diffs empty. If the reference now resolves to a different object the old path comes back as stored_path and the diff still runs.

Each of the three lists holds at most 500 rows; truncated counts the rows dropped per list when exceeded.

update=True replaces the snapshot with this walk after diffing, for a rolling diff. An unknown label raises and names the ones that exist.

Snapshots currently held in the game: label, object path, taken (a wall-clock timestamp in whole seconds), property count. Read-only.

Drop one stored snapshot, or all of them with label="*". Read-only; frees memory in the game process.

Re-read settings.lua and re-run the UEBridge mod in place; no game restart.

Read-only: touches only the mod's own settings, so it works with allow_eval = false and allow_writes = false and is the recovery path after eval was turned off. Returns the settings now in effect (poll_ms, allow_eval, allow_writes) and the new generation number.

Every reflected UFunction callable on an object, across its class chain.

Read one property of an object. An unknown property name raises rather than returning junk.

Write one property of an object (number, bool or string).

Returns {previous, current}. Writes are never undone, so previous is what you restore from if the write turns out to be wrong. An unknown property name raises instead of silently doing nothing. Refused when the mod's settings.lua sets allow_writes = false.

Run several bridge operations in ONE round trip and return a result per call.

A round trip costs a poll interval plus latency against single-digit ms of actual work, so a sequence of small calls is nearly all waiting. Each entry is a dict with an "op" key:

{"op": "world"} {"op": "reload"} {"op": "find", "ref": ...} {"op": "get", "ref": ..., "name": ...} {"op": "set", "ref": ..., "name": ..., "value": ...} {"op": "call", "ref": ..., "function": ..., "args": [...]} {"op": "props", "ref": ..., "include_super": bool, "read_soft": bool, "pattern": str} {"op": "funcs", "ref": ...} {"op": "snapshot", "ref": ..., "label": str, "include_super": bool, "pattern": str} {"op": "diff", "label": str, "ref": ... (optional), "update": bool} {"op": "snapshots"} {"op": "forget", "label": str} {"op": "objects", "class_name": ..., "limit": int} {"op": "types", "pattern": ..., "limit": int} {"op": "subclasses", "ref": , "limit": int, "pattern": str} {"op": "target", "distance": num, "channel": int, "ref": ... (optional)} {"op": "watch", "ref": ..., "names": [str], "label": str, "interval_ms": int, "every": bool} {"op": "hook", "function": , "label": str, "max_args": int} {"op": "events", "since": int, "label": str, "limit": int, "clear": bool} {"op": "streams"} {"op": "unwatch", "label": str} {"op": "console", "command": ...} {"op": "dump", "kind": ...}

Each result is {op, ok, result} or {op, ok: false, error}. One failing call does not abandon the rest, so a batch is safe to use for exploration.

Call a UFunction on an object with positional JSON args and return its result. Refused when allow_writes = false.

Execute a console command in the running world. Output is not captured. Refused when allow_writes = false.

Trigger a UE4SS dumper: usmap, jmap, uht, cxx, actors, objects, static_meshes. Output lands in the ue4ss directory; jmap and uht take minutes.