Gameplay publishes once
Event.Combat.DamageApplied
One immutable payload contract, one correlation identity, one structured result.
Unreal Engine 5.8 · Code Plugin
From the makers of Rekall UE
One event platform.
Every gameplay system.
Define an event once. Publish and listen from Blueprint or C++. Route it locally, across authority boundaries, into retained state, through bounded gameplay flows, and across a single correlated diagnostic timeline.
Blueprint + C++Standalone + NetworkBounded by design
EVENT
Damage.
Applied
Applied
FDamagePayload
BLUEPRINTOn Damage AppliedExact struct pin
NETWORKServer → AudienceAuthority checked
FLOWCombat ReactionWait → Branch
RETENTIONLatest Per AudienceReplay ready
INSIGHTSCorrelation 7D3ADelivered · 4
3Runtime modules
3Network modes
112Automated checks
1Typed contract
The platform
Events should connect systems.
Not couple them.
Rekall turns a simple global-event principle into a production architecture: definitions are compiled, payloads are exact, delivery is bounded, network intent is explicit, and every stage can be observed.
REKALL SIGNAL BUS
World listeners
Immediate or scheduled phases
Game Instance
Survives World replacement
Network route
Authority-aware endpoints
Flow runtime
Resume bounded orchestration
Retained state
Query or explicit replay
Insights
Correlated delivery evidence
The plugin in one minute
What is Rekall Global Events?
It lets one gameplay system announce that something happened without needing direct references to every system that may react. Each event has a stable name and an exact data shape.
- 01Define
Name the event and describe its exact payload.
- 02Listen
Let interested systems subscribe independently.
- 03Publish
Announce the event once when gameplay accepts it.
- 04React
Every eligible listener receives the same validated contract.
Define → Listen → Publish → React
From first event to production
Define it once.
Follow it everywhere.
- 01Payload struct
Model the exact data listeners receive.
- 02Event definition
Choose identity, delivery, retention, trace, and Network policy.
- 03Catalog
Compile definitions atomically into the runtime registry.
- 04Typed nodes
Publish, bind, wait, query, and replay with concrete pins.
- 05Intentional route
Select scope, schedule, audience, and authority boundary.
- 06Gameplay Flow
Resume bounded orchestration from the same signal.
- 07Correlated evidence
Inspect Core, Network, and Flow in one timeline.
Project glue
Every system carries its own adapters, conventions, and inspection path.Definition-backed contracts
One declared event carries its payload, routing intent, and diagnostic evidence across the systems that use it.Plugin map
Start with the contract.
Extend when the job changes.
Network, Flow, and Insights extend Core rather than replacing it.
Core
Structured local events and listeners; the foundation.
Network
Policy-controlled transport for selected definitions.
Flow
Reusable multi-step gameplay sequences that publish and wait for events.
Insights
Editor inspection and correlated diagnosis.
Blueprint-first authoring
Design the contract.
The nodes follow.
Create a Blueprint Struct, point a Rekall Event Definition Data Asset at it, add the definition to a catalog, and use event-specific nodes with the exact payload type.
- Publish, Bind, Wait, Query, and Replay nodes
- Compile-time schema drift diagnostics
- No generic byte blobs or unsafe casts
- Generic Instanced Struct API when runtime selection is intentional
Actor Target
float Damage
GameplayTag DamageType
→
Tag Event.Combat.Damage
Payload ST_DamageApplied
Delivery Immediate
Execute
Damage Applied
Result
On Event
Damage Applied
Context
Blueprint node atlas
Concrete pins.
Deliberate operations.
29 showcased Blueprint nodes make the definition visible in the graph. Inputs and Outputs are Unreal macro scaffolding, not additional Rekall nodes.
Use concrete pins to make the producer and listener agree without a project-specific adapter layer.
Explore every node →
Choose scope, schedule, audience, and retained-state behavior where gameplay needs it.
Explore every node →
Control compiled Flow lifecycles from Blueprint while keeping instance state and execution limits visible.
Explore every node →Mixed Blueprint / C++ teams
Different workflows.
The same event.
const FDamageApplied Payload{
.Target = Target,
.Damage = 42.0f
};
DamageApplied.Publish(World, Payload);ONE
CONTRACT
CONTRACT
ON DAMAGE APPLIEDDamage Applied ●Context ●
TargetDamage: 42.0Damage Type
Delivery control
Publish with intent.
Every route is explicit, validated, and bounded. Definition defaults make common behavior effortless; per-publication overrides make exceptions honest.
Scope
World-local delivery or Game Instance continuity across World replacement.
Schedule
Immediate, Next Tick, Pre Physics, Post Physics, or End Frame with stable priority ordering.
Audience
Broadcast, directed owner, local player, or gameplay-tag-query audience selection.
Retention
Keep latest, latest per audience, query explicitly, or replay to a live subscription.
Lifetime
Weak owners, call limits, move-only native handles, component cleanup, and safe mutation snapshots.
Worker handoff
Certified POD payloads enter through a bounded arbitrary-thread queue and resolve on the game thread.
DEDICATEDLISTENSTANDALONE
AUTHORITYSERVERLive definition + policy
OWNED ENDPOINTCLIENT 01Schema ready
OWNED ENDPOINTCLIENT 02Audience: Squad.A
OWNED ENDPOINTCLIENT 03Late join replay
✓
ADMISSIONAuthenticated · Contract valid · Within budget
Secure event transport
Networking that does not trust the caller.
Client-originated events enter through player-owned endpoints. The server resolves the live Core definition, applies the Network policy, checks direction, schema, rate and byte budgets, then republishes locally with authoritative context.
- Standalone bypass with the same contract checks
- Client → Server, Server → Owner, Audience, or All
- Reliable and unreliable transport policy
- Bounded late-join state for Server-to-All events
- Reconnect, teardown, and World replacement cleanup
Rekall Flow
What is Rekall Flow?
A Flow is a reusable gameplay sequence saved as an asset. Connect steps such as Publish, Wait Event, Delay, a named Condition or Action, Branch for an authored boolean, and End; start the asset for an owner; then let it advance, wait, pause, complete, fail, or be cancelled.
Its compiled plans run inside explicit instance, memory, iteration, history, and per-frame step budgets.
STARTStart
PUBLISHTutorial Started
WAIT EVENTKey Added
INVOKE CONDITIONHas Key
ACTIONOpen Door
ENDEnd
Wait Event wakes on the pickup tag. Invoke Condition calls the registered Has Key condition and chooses its success or false edge. Nodes in the asset describe the sequence; Start / Pause / Resume / Cancel / Get Info / Query control running instances from ordinary Blueprint graphs.
Branch (authored boolean)GateBounded RepeatSubflowParallelRaceDelayWait EventPublishSet / Compare VariableAction / ConditionEnd / Cancel
Rekall Insights
Follow one event through everything.
Accepted, queued, retained, networked, replayed, delivered, skipped, and Flow-transition records meet in one bounded timeline. Attempt and delivery identities make causality navigable.
- Event, network, and Flow record filters
- Correlation and parent-correlation navigation
- Opt-in, policy-controlled payload capture
- Disabled hot path avoids formatting work
- Unreal Trace channel plus modular sink API
ACCEPTEDDamage.AppliedWorld · Immediate
NETWORKServer → Audience2 endpoints
RETAINEDLatestPerAudienceSquad.A
FLOWCombatReactionWait → Branch
DELIVERED4 listeners0 skipped
Where the contract pays off
Less glue between systems.
More signal in the work.
Inventory and UI state
Producer: an inventory component publishes a typed item-state payload. Contract: the definition retains the latest value for its audience. Consumers: HUD, quick-slot, and menu widgets bind or replay it. Rekall removes the project glue that would otherwise synchronize each view.
Quest and encounter orchestration
Producer: gameplay publishes an objective or enemy-defeated event. Contract: its exact payload is available to Wait and Flow. Consumers: encounter logic, objectives, and reward steps resume from the same signal, rather than custom callbacks between every stage.
Server-authoritative combat
Producer: a player-owned endpoint submits a combat intent. Contract: the definition's Network policy checks authority, schema, and budgets before the selected audience route. Consumers: server systems and approved clients receive the authoritative event without bespoke replication glue.
Cross-system diagnosis
Producer: any gameplay system publishes an event with a correlation. Contract: Core, Network, and Flow preserve that identity. Consumers: engineers and QA inspect the live timeline to follow delivery, retention, and orchestration instead of reconstructing a path from scattered logs.
Built for production pressure
Power is useful.
Boundaries make it shippable.
Memory is accounted
Queues, retained entries, audience queries, snapshots, Flow instances, late-join state, and trace records all have explicit limits.
UObjects stay alive
Deferred, retained, replayed, traced, and in-flight payloads participate in GC across every arbitrary callback boundary.
Mutation is deterministic
Subscription snapshots freeze membership. Reentrant sinks and providers are revalidated. Removed handles do not revive.
Failures are structured
Blueprint and C++ callers get explicit status, diagnostic code, counts, attempt identity, and correlation—not ambiguous booleans.
Runtime stays clean
Core, Network, and Flow ship as the runtime package. Editor nodes, Insights UI, tests, and QA definitions stay out of game receipts.
Definitions are authoritative
Data Assets compile into one validated registry. Defaults apply predictably and schema drift is rejected instead of coerced.
YOUR GAME→REKALL CORE←NETWORK+FLOWOptional editor and Insights modules never enter runtime dependencies.
Where it fits
A shared language for the whole team.
Blueprint developers
Author exact events visually and use typed nodes without learning a C++ event bus.
Systems programmers
Use typed native facades, scoped RAII subscriptions, worker handoff, and extension interfaces.
Multiplayer engineers
Keep transport policy explicit and server-authoritative across listen and dedicated deployments.
Technical designers & QA
Validate assets before cook and follow one correlation through routing, network, Flow, and replay.
Questions
Before you wire
the first event.
Can events be defined entirely in Blueprint?+
Yes. Create a Blueprint Struct payload, a Rekall Event Definition Data Asset, and add it to a catalog. Definition-specific nodes expose that exact struct for publishing, listening, waiting, retained queries, replay, and network publication.
Does it work without multiplayer?+
Yes. Core is a complete standalone local event platform. The Network module adds policy-driven transport when needed, and its standalone path bypasses RPCs while retaining contract validation.
Can Blueprint and C++ use the same event?+
Yes. Both surfaces resolve the same compiled definition and exact payload contract. Teams can choose the authoring environment that fits each system without building adapters.
Will global events become an unbounded message dump?+
The system is designed against that failure mode. Queues, retained state, thread handoff, network caches, trace capture, and Flow execution use explicit item, byte, step, or history budgets.
What ships in a game build?+
The installed customer plugin contains Core, Network, Flow, Editor, and Insights. Game, Client, and Server runtime receipts include Core plus the runtime features used by the project; Editor, Insights, automation tests, QA tags, and docs-test modules are excluded.
Choose the right boundary
When another Unreal system is the better fit.
Rekall is deliberate about where it belongs. Use the tool that matches the ownership, replication, or decision problem in front of you.
| Need | Start with | Why |
|---|---|---|
| One object must synchronously command another | Direct call | The dependency is intentional. |
| One owner exposes a callback to known observers | Delegate or interface | Local ownership is already clear. |
| Authoritative gameplay state must reach clients | Replicated property or RPC | Unreal replication owns gameplay truth. |
| Loosely coupled structured gameplay notification | Rekall Core | Many systems react to one exact event contract. |
| Selected event must cross authority boundaries | Rekall Network | Explicit policy and server admission are required. |
| Multi-step event-driven sequence | Rekall Flow | The sequence should be data-authored and inspectable. |
| AI/state decision model | StateTree or Behavior Tree | Decision/state semantics are the primary problem. |
Gameplay Message Subsystem is also a valid alternative for projects already standardized around its message model.
Buyer guide
See the route before
you build around it.
Start with the mental model, build one event, choose the right mechanism, then follow Flow, node, and packaging paths as your project needs them.
Launch pricing
Build around signals.
Ship without the coupling.
For individual developers and qualifying teams under Fab’s Personal tier.
For studios and teams qualifying for Fab’s Professional tier.
Version 1.0.0 for UE 5.8 · Win64 Editor, Game, Shipping cook, and standalone/listen/dedicated runtime modes verified.