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
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
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
Turn signals into gameplay.
Compile event-driven orchestration into immutable, validated plans. Run them inside explicit instance, memory, iteration, history, and per-frame step budgets.
STARTEncounter
WAIT EVENTEnemy.DefeatedTimeout 30s
BRANCHEnemiesLeft == 0
PUBLISHWave.Cleared
ENDSuccess
BranchGateBounded 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
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.
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.