From first event
to production architecture.

1. 01Define

   Create Game.Inventory.ItemAdded with an Item Id and Quantity payload.

2. 02Listen

   Let UI, quests, audio, and analytics subscribe independently.

3. 03Publish

   Announce the event once when inventory accepts the item.

4. 04React

   Each eligible listener receives the same validated contract.

Define → Listen → Publish → React

How it works

1. 01Resolve

   The definition registry resolves the Game.Inventory.ItemAdded Gameplay Tag.

2. 02Validate

   The publication must carry the definition's exact reflected payload struct.

3. 03Plan

   Scope, audience, timing, and priority options resolve independently.

4. 04Admit

   Publication delivers now or is admitted to a bounded queue for later delivery.

5. 05Deliver

   An eligible subscription snapshot receives the payload and immutable context.

6. 06Report

   The result says delivered, queued, no subscribers, or names a specific rejection.

This complete local workflow requires no C++ and leaves you with a saved payload schema, validated definition, live listener, and inspectable publication result.

1. Create and save the payload.

   In the Content Browser choose Add > Blueprint > Structure. Name the Blueprint Struct ST_InventoryItemAdded, add Item Id (Name) and Quantity (Integer), then save it before assigning it to a definition.

2. Create the identity.

   In Gameplay Tags settings add Game.Inventory.ItemAdded. Rekall uses the Gameplay Tag as the stable runtime identity; the asset name and display name are not the identity.

3. Create and validate the definition.

   Choose Add > Data > Data Asset, select Rekall Event Definition, and set the tag, saved payload struct, display name, World scope, Immediate delivery, and schema version 1. Run Asset Actions > Validate Assets and fix every error.

4. Compile a catalog.

   Create another Data Asset, select Rekall Event Catalog, and add the definition under Definition Assets. Assign that catalog as Default Catalog in Project Settings > Game > Rekall Events. Each Game Instance compiles the complete catalog atomically; one invalid record leaves the registry unhealthy instead of partially registered.

5. Bind with the right lifetime.

   In an Actor Blueprint place Bind Inventory Item Added at Begin Play. Leaving World Context and Owner disconnected uses self. Read the exact ST_InventoryItemAdded payload on On Event. Store the subscription handle only if you must unbind early; owner destruction removes the listener safely.

6. Publish and inspect.

   In another Blueprint place Publish Inventory Item Added, construct the exact typed payload, and execute it. Inspect Result.Status, attempted/delivered/skipped counts, diagnostic code, sequence, and correlation ID—or branch with Is Publish Successful—before assuming a listener ran.

Define one reflected payload and stable Gameplay Tag, register their exact pairing before Game Instance initialization, then resolve, subscribe, publish, inspect, and clean up through the public typed API.

1. Add the runtime modules.

   Add Core and Gameplay Tags privately to the consuming game module. Use public dependencies only if your public headers expose their types.

PrivateDependencyModuleNames.AddRange(new[]
{
    "GameplayTags",
    "RekallEventsCore"
});

2. Declare the payload and tag.

   Put the reflected payload and native tag declaration in a header. The generated include remains last.

#pragma once

#include "CoreMinimal.h"
#include "NativeGameplayTags.h"
#include "InventoryEvents.generated.h"

UE_DECLARE_GAMEPLAY_TAG_EXTERN(TAG_Game_Inventory_ItemAdded);

USTRUCT(BlueprintType)
struct FInventoryItemAdded
{
    GENERATED_BODY()

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Inventory")
    FName ItemId;

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Inventory")
    int32 Quantity = 0;
};

3. Define the tag and register the definition.

   A native definition provider is an Unreal modular feature. Register it in module startup so each subsequently initialized Game Instance snapshots it, and unregister it before the provider is destroyed. Duplicate tags or a missing payload type make registry initialization fail atomically.

#include "Definitions/IRekallNativeDefinitionProvider.h"
#include "Features/IModularFeatures.h"
#include "InventoryEvents.h"
#include "Modules/ModuleManager.h"

UE_DEFINE_GAMEPLAY_TAG_COMMENT(
    TAG_Game_Inventory_ItemAdded,
    "Game.Inventory.ItemAdded",
    "A local inventory item was added.");

class FMyGameModule final
    : public IModuleInterface
    , public IRekallNativeDefinitionProvider
{
public:
    virtual void StartupModule() override
    {
        IModularFeatures::Get().RegisterModularFeature(
            IRekallNativeDefinitionProvider::GetModularFeatureName(), this);
    }

    virtual void ShutdownModule() override
    {
        IModularFeatures::Get().UnregisterModularFeature(
            IRekallNativeDefinitionProvider::GetModularFeatureName(), this);
    }

    virtual void AppendDefinitions(
        TArray<FRekallEventDefinitionRecord>& OutRecords) const override
    {
        FRekallEventDefinitionRecord& Record = OutRecords.AddDefaulted_GetRef();
        Record.EventTag = TAG_Game_Inventory_ItemAdded;
        Record.PayloadStruct = FInventoryItemAdded::StaticStruct();
    }
};

IMPLEMENT_PRIMARY_GAME_MODULE(FMyGameModule, MyGame, "MyGame");

4. Resolve, subscribe, and publish.

   Declare FRekallScopedSubscription ItemAddedSubscription; as a native member of the listening object. Resolve against an explicit World Context Object, retain the move-only subscription for exactly the listener lifetime, and inspect the structured publish result.

#include "Events/RekallEvents.h"
#include "InventoryEvents.h"
#include "Listeners/RekallScopedSubscription.h"
#include "Subsystems/RekallEventWorldSubsystem.h"

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

    const TRekallEvent<FInventoryItemAdded> Event =
        Rekall::ResolveEvent<FInventoryItemAdded>(
            this, TAG_Game_Inventory_ItemAdded);
    if (!Event.IsValid())
    {
        return;
    }

    URekallEventWorldSubsystem* Events =
        GetWorld()->GetSubsystem<URekallEventWorldSubsystem>();
    ItemAddedSubscription = FRekallScopedSubscription(
        Events,
        Rekall::Subscribe(
            this,
            this,
            Event,
            [this](const FInventoryItemAdded& Payload,
                   const FRekallEventContext& Context)
            {
                ShowInventoryMessage(Payload.ItemId, Payload.Quantity);
            }));

    FInventoryItemAdded Payload;
    Payload.ItemId = TEXT("HealthPotion");
    Payload.Quantity = 2;
    const FRekallPublishResult Result =
        Rekall::Publish(this, this, Event, Payload);
    if (!Result.IsSuccess())
    {
        UE_LOG(LogTemp, Warning, TEXT("Rekall publish failed: %s"),
            *Result.DiagnosticCode.ToString());
    }
}

How it works

1. 01Scope

   Choose which local routing domain owns delivery: World, Game Instance, or a narrower local context.

2. 02Audience

   Choose which subscriptions qualify through a directed target or captured Gameplay Tag Query.

3. 03Timing

   Run now, on the next tick, or at Pre Physics, Post Physics, or End Frame.

4. 04Priority

   Order eligible callbacks or queued work; never jump ahead of the selected phase.

Keep the existing Gameplay Tag and exact payload schema. Network transport extends the same definition with an explicit allowlist and an owned endpoint; it does not create a second event identity or a global replicated catch-all.

1. Add the transport policy.

   Add one Rekall Network Policy Fragment to the existing definition. Choose the narrowest direction, set Reliable or Unreliable intentionally, and configure positive payload-byte and per-connection rate limits. Without this fragment, the definition remains local-only.

2. Decide whether clients may originate it.

   For Client to Server traffic, enable client origin explicitly. If gameplay ownership, team, inventory, or permission matters, name and register a server-side IRekallNetworkAuthorization rule. A missing named rule fails closed.

3. Install the owned endpoint.

   Add URekallNetworkEndpointComponent to the replicated PlayerController class used by the game. The PlayerController ownership chain makes Client-to-Server RPC admission meaningful; attaching the component to an arbitrary Actor is rejected.

4. Replace only the crossing publication.

   Leave local producers on Publish Event Name. Where transport is required, replace that node with the definition-backed Network Publish Event Name node so the concrete payload pin remains exact. The generic Publish Network Event node is the runtime-selected FInstancedStruct alternative.

5. Supply route-specific context.

   Server to Owner requires Target Owner. Server to Audience requires an explicit server-resolved PlayerController list; duplicates are removed. Parent Correlation Id joins this attempt to the originating Core event or Flow. Never trust sender, authority, or connection identity carried in a client packet.

6. Validate before PIE.

   Run Asset Actions > Validate Assets on the definition and catalog. Confirm one policy fragment, an exact registered payload, a supported schema, positive limits, the intended direction, and any named authorization provider before diagnosing transport.

7. Exercise the topology in PIE.

   First test Standalone and confirm the structured result reports local publication without RPC serialization. Then use multiplayer PIE to test the listen host and a remote client, including the wrong-side rejection path. Finally run the project's dedicated server configuration and confirm endpoint registration, authorization, schema, bounds, recipient count, and Core republication behavior.

Admission sequence

1. Resolve the current game World, Game Instance registry, and registered PlayerController-owned endpoint.
2. Resolve the live Core definition and its single Network policy fragment.
3. Plan the route from net mode, caller authority, and declared direction.
4. Require pointer-exact local payload type, then encode within the positive byte bound and trusted schema signature.
5. On inbound client traffic, derive identity from the owning connection, consume per-connection/event rate budget, and run any named server authorization rule.
6. Publish locally on authority or deliver only to the resolved Owner, deduplicated Audience, or All endpoint set; return a structured Network result on every rejection.

Route matrix

Simple example

How it works

The existing Flow lifecycle screenshot contains only those six external lifecycle nodes and Unreal macro tunnels. The internal Flow Asset concepts are not extra entries in the 29-card node atlas.

Flow state model

1. Running

   Executing connected steps under the per-instance and World scheduler budgets.

2. Waiting

   Suspended for a Delay, Wait Event, Subflow, Parallel, or Race result.

3. Paused

   Explicitly stopped while remembering whether resume should restore Running or Waiting.

4. Completed

   Reached End successfully.

5. Cancelled

   Stopped explicitly, by owner loss, by teardown, or by a Cancel node.

6. Failed

   Stopped on a rejected publish, timeout, limit, missing extension, child failure, or other diagnostic.

Technical details

Resource budgets

Project Settings > Game > Rekall Flow configures World-wide active-instance, runtime-byte, step, and terminal-history bounds. Every terminal path cleans event subscriptions, timers, child Flows, and runtime instance data. Inspect status, current node, total steps, diagnostic code, and correlation before changing the asset.

How it works

Attempt Sequence

Identifies one logical Core publish attempt, including a permitted worker handoff.

Delivery Sequence

Orders work inside one local router and becomes nonzero only after router admission.

Correlation ID

Joins records that belong to the same causal chain.

Parent Correlation ID

Links a nested publication or transport attempt back to the Flow or event that caused it.

Technical details

Flow instances use their own correlation as parent when entering Core, and Network preserves the supplied parent. ExportJson writes a versioned text-only session; it never exports live UObject or FInstancedStruct references. Import supports offline filter/correlation analysis under current bounds. The default recorder holds at most 10,000 records and 8 MiB, evicts oldest records, drops oversized individual records, and reports drops without blocking gameplay.

All 29 showcased Blueprint nodes are grouped by authoring surface. Typed editor nodes compile into runtime calls; generic nodes remain data-driven; Network helpers enforce transport policy; Flow lifecycle nodes control compiled instances.

Atlas A · 8 nodes

Typed definition-backed nodes

Select a Rekall Event Definition in Details or place a definition-specific action such as Publish Inventory Item Added. The concrete payload pin is reconstructed from that definition and the editor-only K2 node compiles away to a packaged Core or Network runtime call.

Typed · Core

Publish Rekall Event

Publishes the selected definition with its concrete payload struct.

Key inputs

World context, sender, typed payload, event options

Outputs

Structured FRekallPublishResult

Use when

The event definition is known at authoring time.

Watch for

Definition defaults apply unless matching override flags are enabled; incompatible schema changes disconnect payload links.

Guide: publishing and listening

Typed · Core

Bind Rekall Event

Creates a persistent weak-owner subscription with an exact typed callback.

Key inputs

World context, owner, subscription options, optional scope override

Outputs

Then, On Event, subscription handle, typed payload, immutable context

Use when

A listener needs every matching publication during its lifetime.

Watch for

Store the handle for early unbind; owner destruction also removes delivery, and audience membership is captured at bind time.

Guide: publishing and listening

Typed · Core

Wait for Rekall Event

Suspends one execution path until delivery, timeout, cancellation, or invalidation.

Key inputs

World context, subscription options, timeout, optional scope override

Outputs

Completed, Timed Out, Cancelled, Invalid Context, Invalid Definition; wait handle; typed payload and context on Completed

Use when

A Blueprint sequence needs one matching event before continuing.

Watch for

Zero timeout is unlimited; only Completed owns a value, and a repeated latent UUID replaces the previous wait.

Guide: wait diagnostics

Typed · Core

Unbind Rekall Event

Removes the live subscription named by a stored handle.

Key inputs

World context, subscription handle

Outputs

Success boolean

Use when

A listener must stop before its owner is destroyed.

Watch for

The first live removal returns true; repeated, foreign-router, or stale handles return false safely.

Guide: listener cleanup

Typed · Core

Query Rekall Event Subscriptions

Returns active subscription metadata for the selected definition and routing domain.

Key inputs

World context, optional scope override

Outputs

Array of subscription information

Use when

Diagnostics, controlled gameplay inspection, or editor tooling needs live router state.

Watch for

The records are inspection snapshots, not mutation handles; query the same effective World or Game Instance domain used to bind.

Guide: listener diagnostics

Typed · Retention

Get Retained Rekall Event

Reads the retained stream for the definition and exposes its exact payload.

Key inputs

World context, scope, optional scope object, optional audience query

Outputs

Found/Not Found, full retained result, typed payload, original context

Use when

A late system needs the newest retained state without invoking a listener.

Watch for

Not Found also covers an absent or incompatible value; inspect Result to distinguish invalid scope or context.

Guide: retention and replay

Typed · Retention

Replay Retained Rekall Event

Delivers the selected retained stream to one existing subscription handle.

Key inputs

World context, retention selectors, live subscription handle

Outputs

Found/Not Found, retained result, typed payload and original context

Use when

Historical state should enter one listener through its normal callback path.

Watch for

The handle must belong to the same live router and be selected by the retention key; replay never republishes to everyone.

Guide: explicit retained replay

Typed · Network

Network Publish Rekall Event

Transports the selected definition through its allowlisted Network policy using an exact typed payload.

Key inputs

World context, sender, typed payload, target owner/audience players, parent correlation

Outputs

Network status, route, correlation, recipient count, diagnostic code

Use when

A known event must cross Client/Server authority boundaries.

Watch for

No silent fallback occurs for wrong direction, missing endpoint, schema mismatch, or serialization failure; absence of a Network policy means local-only.

Guide: secure network transport

Atlas B · 15 nodes

Generic Core and Network runtime nodes

Use this data-driven surface when the event is selected at runtime. Payloads are owning FInstancedStruct values, but the registered definition's exact struct identity still governs every publish, retained read, replay, and transport operation.

Runtime · Core

Publish Event

Publishes a runtime-selected event through Core after exact definition and payload validation.

Key inputs

World context, sender, Gameplay Tag, FInstancedStruct payload, options

Outputs

Structured publish result

Use when

The event identity or payload value is selected from data at runtime.

Watch for

Calls are game-thread-only; matching fields do not substitute for exact struct identity.

Guide: publishing and listening

Runtime · Core

Bind Event

Binds a dynamic callback that receives an owning generic payload and immutable context.

Key inputs

World context, owner, tag, callback, subscription options, optional scope override

Outputs

Subscription handle

Use when

Listeners are configured from runtime data instead of a fixed definition asset.

Watch for

The owner is weak and the returned payload must be broken as the definition's exact struct.

Guide: publishing and listening

Runtime · Core

Unbind Event

Removes a generic Core subscription from its live routing endpoint.

Key inputs

World context, subscription handle

Outputs

Removal success

Use when

A data-driven listener has an explicit end condition.

Watch for

Syntax-valid does not prove the router still owns the handle; stale or foreign handles return false.

Guide: listener cleanup

Runtime · Core

Query Subscriptions

Inspects active subscription records for one tag in the effective router.

Key inputs

World context, Gameplay Tag, optional scope override

Outputs

Array of active subscription information

Use when

You need live router evidence for diagnostics or tooling.

Watch for

This is the live-state check; Is Subscription Handle Valid only checks handle syntax.

Guide: listener diagnostics

Runtime · Retention

Get Retained Event

Returns the retained payload and original context for an exact retention key.

Key inputs

World context, tag/scope/scope-object/audience retention key

Outputs

Retained status and event snapshot

Use when

Runtime-selected state must be queried without triggering a callback.

Watch for

Queued events become visible to retention only at their delivery phase; expiry and byte/entry limits still apply.

Guide: retention keys and timing

Runtime · Retention

Replay Retained Event

Replays one retained snapshot to one active subscription.

Key inputs

World context, retention key, subscription handle

Outputs

Found, Not Found, Invalid Handle, Invalid Scope, or Invalid Context plus event snapshot

Use when

Existing listener logic should consume retained state explicitly.

Watch for

The key and handle must belong to the same router; this does not broadcast historical traffic.

Guide: explicit retained replay

Runtime · Result

Is Publish Successful

Classifies a Core publish result for a compact Blueprint branch.

Key inputs

FRekallPublishResult

Outputs

True for Delivered, Queued, Transported, or No Subscribers

Use when

A graph needs success/failure control flow before detailed inspection.

Watch for

Success does not always mean a callback already ran; Queued is accepted work and No Subscribers delivered to nobody.

Guide: structured result diagnostics

Runtime · Handle

Is Subscription Handle Valid

Checks whether both identifiers encoded in a subscription handle are present.

Key inputs

Subscription handle

Outputs

Syntax-valid boolean

Use when

You need to reject an empty/default handle cheaply.

Watch for

This is syntax-only—not proof of a live listener. Use Query Subscriptions against the correct router for liveness.

Guide: handle and router lifetime

Runtime · Result

Is Retained Event Found

Branches on whether a retained result contains a found snapshot.

Key inputs

FRekallRetainedEventResult

Outputs

Found boolean

Use when

A graph only needs a simple found/not-found decision.

Watch for

Inspect the full status when Invalid Handle, Invalid Scope, or Invalid Context must be distinguished from ordinary absence.

Guide: retained result states

Runtime · Latent

Wait for Event

Creates one generic latent subscription and resumes through an explicit terminal branch.

Key inputs

World context, tag, subscription options, timeout, scope override

Outputs

Completed, Timed Out, Cancelled, Invalid Context, Invalid Definition; wait handle; generic payload and context

Use when

Data-driven logic needs one event or a bounded wait.

Watch for

Only Completed contains a payload. Replay may complete during creation; every terminal path removes the subscription exactly once.

Guide: wait diagnostics

Runtime · Latent

Cancel Wait for Event

Cancels the pending latent action identified by a wait handle.

Key inputs

World context, wait handle

Outputs

Cancellation success

Use when

Another graph or lifecycle transition must stop a wait.

Watch for

Cancellation succeeds once; repeated, completed, timed-out, or stale handles return false.

Guide: wait cancellation

Runtime · Handle

Is Wait Handle Valid

Checks whether the handle still names its original callback target and wait identity.

Key inputs

Wait handle

Outputs

Syntax/target-valid boolean

Use when

You need to reject an empty handle or dead callback target.

Watch for

It does not query the latent manager and does not prove the wait is still pending; cancellation is the authoritative operation.

Guide: wait state evidence

Runtime · Network

Publish Network Event

Publishes a runtime-selected event through the Network coordinator and its definition policy.

Key inputs

World context, sender, tag, generic payload, target owner/audience, parent correlation

Outputs

Network publish result with status, route, correlation, recipients, and code

Use when

Both the network event and payload are selected dynamically.

Watch for

Exact schema, caller side, endpoint ownership, payload bounds, rate limits, and authorization all fail closed.

Guide: network admission and routes

Runtime · Network

Is Network Publish Successful

Classifies the structured Network result for concise control flow.

Key inputs

FRekallNetworkPublishResult

Outputs

True for Published Locally or Transported

Use when

A graph needs a first-pass network success branch.

Watch for

Still inspect Route, Recipient Count, and Diagnostic Code; transported acceptance is not evidence of a remote gameplay reaction.

Guide: network result evidence

Runtime · Network endpoint

Send to Server

Sends an already encoded Network packet through a PlayerController-owned endpoint's reliable or unreliable Server RPC.

Key inputs

Network packet, reliability flag

Outputs

No structured return; server admission is tracked by the endpoint

Use when

Low-level native/advanced tooling already has a validated encoded packet.

Watch for

Normal gameplay should prefer Publish Network Event. Attaching an endpoint to an arbitrary Actor is rejected; a packet never chooses its own trusted reflected type.

Guide: endpoints and server admission

Atlas C · 6 nodes

Flow lifecycle nodes

These convenience functions resolve the current World and control compiled Flow instances. They are distinct from the Publish, Wait Event, Delay, Branch, Repeat, Subflow, Parallel, Race, Gate, Action, Condition, Cancel, and End nodes authored inside a Rekall Flow Asset.

Flow · Lifecycle

Start Rekall Flow

Compiles/starts the supplied Flow Asset as a World-owned runtime instance.

Key inputs

World context, weak owner, Flow Asset

Outputs

Flow handle

Use when

A data-authored sequence should begin for a concrete owner.

Watch for

Authority mismatch, invalid asset, active-instance limit, or runtime-byte admission returns an invalid handle; Flow state is not implicitly replicated.

Guide: Flow authority and admission

Flow · Lifecycle

Pause Rekall Flow

Pauses a live instance and propagates the pause through its active child tree.

Key inputs

World context, Flow handle

Outputs

Success boolean

Use when

A gameplay pause or modal state must freeze orchestration.

Watch for

The handle belongs to one World; completed, cancelled, failed, unknown, or foreign handles cannot be paused.

Guide: Flow lifecycle

Flow · Lifecycle

Resume Rekall Flow

Restores a paused instance and children to their pre-pause running or waiting state.

Key inputs

World context, Flow handle

Outputs

Success boolean

Use when

The condition that paused the Flow has ended.

Watch for

Resume only paused live instances; World budgets still limit work when execution continues.

Guide: Flow lifecycle

Flow · Lifecycle

Cancel Rekall Flow

Cancels an instance, its active children, waits, timers, and extension-owned work.

Key inputs

World context, Flow handle

Outputs

Success boolean

Use when

An encounter, tutorial, UI journey, or owner ends early.

Watch for

Cancellation wins during reentrant callbacks and records bounded terminal state; repeated cancellation returns false.

Guide: cancellation and cleanup

Flow · Diagnostics

Get Rekall Flow Info

Returns the current or recently terminal snapshot for one Flow handle.

Key inputs

World context, Flow handle

Outputs

Status, current node, total steps, diagnostic code, correlation ID

Use when

UI, diagnostics, or gameplay needs one instance's state.

Watch for

Terminal history is configurable per World and defaults to 256 entries; an expired/unknown handle reports Failed with no diagnostic.

Guide: Flow diagnostics and budgets

Flow · Diagnostics

Query Rekall Flows

Lists active and bounded recently terminal Flow instance snapshots in the current World.

Key inputs

World context

Outputs

Array of Flow instance information

Use when

A debug surface or coordinator needs a World-wide lifecycle view.

Watch for

The array is an inspection snapshot, not mutable runtime state; terminal entries age out of the bounded history.

Guide: Flow inspection

Start with the structured status, stable diagnostic code, registry errors, or Flow/Network instance record. Change configuration only after the failing stage is identified.

The installed customer plugin contains exactly five customer modules. Unreal then excludes uncooked/editor diagnostics from packaged Game, Client, or Server runtime receipts.

Core has no dependency on Network, Flow, Insights, Slate, BlueprintGraph, KismetCompiler, or UnrealEd. Network and Flow depend one-way on Core. Typed nodes compile into runtime calls, so packaged bytecode does not require their K2 classes. Automation tests, QA tags, docs-test modules, BlueprintGraph, KismetCompiler, and UnrealEd are not customer runtime dependencies.

Legal Publisher: Rekall Software Solutions / Marius Myburg. Purchase tiers, current pricing, and Fab availability are stated on the product page; this guide does not expand those commercial boundaries.

Treat release readiness as a set of observable contracts. Record the asset, topology, build, and diagnostic evidence for each item instead of relying on a successful editor-only play session.

1. Validate definitions and catalogsContract

   Run asset validation, resolve every catalog entry, reject duplicate tags, and confirm each definition names one exact reflected payload struct and intended policy metadata. Re-run after tag, schema, or catalog changes. Review definitions and payloads.

2. Prove listener cleanupLifetime

   Store subscription and wait handles, exercise early unbind/cancel paths, destroy owners, and verify stale or foreign-router handles fail safely without keeping Worlds alive. Review publishing and listening.

3. Review scope, audience, and delivery timingDelivery

   For each production event, document its effective router, eligible listeners, immediate or queued phase, and priority. Stress reentrant publishers and verify phase-sensitive reactions in the intended World and Local Player domains. Review routing and timing.

4. Set and pressure-test bounded workBudgets

   Exercise queue capacity and per-tick work limits, retention entry/byte/expiry bounds, Flow step/instance/child/lifetime/byte budgets, and trace record/byte bounds. Confirm overflow, eviction, timeout, and terminal outcomes remain diagnostic rather than silent.

5. Lock Network policy and test every topologyAuthority

   Allowlist only intended definitions and directions, then test Standalone, remote client, Listen Server host, and Dedicated Server behavior. Cover endpoint ownership, server authorization, exact schema, rate/byte limits, recipients, rejection evidence, and the late-join boundary. Review Network admission and routes.

6. Exclude editor-only modules from runtime receiptsBuild

   Inspect staged receipts and dependency logs: RekallEventsEditor, RekallEventsInsights, BlueprintGraph, KismetCompiler, UnrealEd, tests, and QA modules must not enter customer runtime targets. Review module boundaries.

7. Smoke-test packaged Game, Client, and Server targetsRuntime

   For every target the project claims to support, launch an actual packaged build and verify registry readiness, one typed and generic local publication, queued delivery, retained query/replay, intentionally used Network routes, and intentionally used Flow starts. Do not infer Client/Server support from Editor PIE. Review the qualified release boundary.

8. Review Insights payload and privacy policyEvidence

   Confirm capture mode, sampling, payload opt-in, record/byte budgets, export handling, and who may inspect or share text snapshots. Verify metadata-only Network records and dropped-record diagnostics without making gameplay depend on the editor observer. Review capture and privacy gates.

Short definitions for the terms used throughout the guide. Follow a term to the chapter that owns its full contract.

Event

A named fact that happened, carried as one validated envelope through the local delivery lifecycle.

Definition

The registered contract that combines stable tag identity, one exact payload struct, and default policy metadata.

Gameplay Tag

The stable runtime identity of an event, such as Game.Inventory.ItemAdded; the asset name is not that identity.

Payload

The owning structured value carried by an event; its reflected struct must exactly match the live definition.

Publisher

The system that announces an event without needing direct references to every reacting system.

Subscription

A live registration that selects an event and delivery options for one independently owned reaction.

Listener

The callback target that reacts when a matching accepted event reaches its subscription.

Handle

An opaque identity used to control or inspect the exact subscription, wait, or Flow instance that created it.

Scope

The local routing domain—World, Game Instance, Local Player, or another supported domain—that owns delivery.

Audience

Audience is one of five local routing scopes. It selects subscribers whose captured Gameplay Tags satisfy the publication's audience query; an empty query or mixed Local Player or Directed selectors are rejected as InvalidScope.

Delivery timing

When accepted callbacks run: immediately, on the next tick, or in an intentional tick phase.

Retention

Core retention is a bounded local cache: Latest replaces the value for one retention key, RecentHistory keeps a bounded ordered recent sequence, and LatestPerAudience keeps the latest value per exact Audience query. It is separate from Network's bounded ServerToAll late-join packet cache and is not authoritative replicated state.

Replay

An explicit delivery of one retained snapshot to one selected live subscription; it is not a new publication.

Router

The live local service for a scope that owns subscriptions, delivery queues, and retained entries.

Schema

The exact reflected payload-struct identity and version expected by a definition and checked again at transport boundaries.

Endpoint

The PlayerController-owned Network component through which an allowed client or server route is requested.

Admission

For client-origin traffic, the client-origin endpoint receives the packet, then the server derives trusted identity and validates policy, schema, rate, bytes, and authorization before trusted Core republication. Outbound routes perform their checks before send.

Correlation ID

The identifier that joins one attempt with its Core, optional Network, and Flow outcomes; a parent ID preserves the calling chain.

Flow Asset

The reusable saved data asset that authors indexed nodes, connections, variables, authority mode, and budgets.

Flow Instance

One live run of a Flow Asset with its own owner, handle, current node, variables, state, diagnostics, and correlation.

Terminal history

The bounded per-World record of completed, cancelled, and failed Flow instances kept for later query and diagnosis.