EventHub
Project-wide event bus for Blueprints and C++

Overview

EventHub is a project-wide publish/subscribe event bus. Any Blueprint or C++ object can emit an event and any other object can listen for it, without either side holding a reference to the other. It works across actors, components, widgets and sub-levels, which makes cross-Blueprint communication simple and keeps systems decoupled.

• Addressing: a Domain + Event string pair (for example global.default / ScoreChanged) or a GameplayTag. Tag and string forms interoperate.
• Wildcard payload: emit one value of any type - int, float, bool, byte, string, name, struct or object. Wrap arrays and maps in a struct.
• Pinned events are replayed to listeners that bind after the emit, so an event can carry state such as "level ready".
• Four ways to receive: a function bound by name, a wildcard delegate, a receiver component, or a C++ lambda.
• Type checking: a listener whose function does not take the emitted type is skipped with a descriptive warning in the log; other listeners still receive the event.
• Automatic cleanup of listeners whose objects were destroyed and of every event of a world when that world ends.
• Ready-made receiver components for Bool, Float, Int, Object, Rotator, String, Transform and Vector payloads.

Requirements

Installation

1. Copy the EventHub folder into your project's Plugins/ folder (create it if needed), or install the plugin to the engine from Fab.
2. Open the project. For a C++ project, let the editor build the module or build it from your IDE.
3. Enable EventHub in Edit > Plugins (category Programming) and restart the editor.
4. C++ only: add "EventHub" to PublicDependencyModuleNames in your module's Build.cs (add "GameplayTags" as well if you use tag-based calls).

Quick start

Blueprint

1. In the receiving Blueprint, create a custom event (or function) with one input of the type you will send, for example OnScoreChanged with an Integer input named Score.
2. On Event BeginPlay, call EHBind Event with Domain global.default, Event ScoreChanged and Receiving Function OnScoreChanged.
3. In the emitting Blueprint, call EHEmit Event One Param with the same Domain and Event and connect an integer to Parameter Data.
4. On Event EndPlay of the receiver, call EHUnbind All Events For Context (or EHUnbind Event).

For events without data use EHEmit Event and a receiving event with no inputs. Tick Pinned on the emit to replay the event to listeners that bind later.

C++

#include "EHHandler.h"

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

    // Listen with a typed lambda
    FEHEventContext Listen;
    Listen.Domain = TEXT("global.default");
    Listen.Event = TEXT("ScoreChanged");
    Listen.WorldContext = this;
    ScoreListenerId = FEHHandler::DefaultHandler()->AddLambdaListenerInt(Listen, [](int32 Score)
    {
        UE_LOG(LogTemp, Log, TEXT("Score is now %d"), Score);
    });
}

void AMyActor::AddScore()
{
    // Emit an int32 payload
    FEHEmitContext Emit;
    Emit.Domain = TEXT("global.default");
    Emit.Event = TEXT("ScoreChanged");
    Emit.WorldContext = this;
    Emit.bPinned = false;
    FEHHandler::DefaultHandler()->EmitEvent(Emit, 42);
}

void AMyActor::EndPlay(const EEndPlayReason::Type EndPlayReason)
{
    FEHEventContext Listen;
    Listen.Domain = TEXT("global.default");
    Listen.Event = TEXT("ScoreChanged");
    Listen.WorldContext = this;
    FEHHandler::DefaultHandler()->RemoveLambdaListener(Listen, ScoreListenerId);   // FString ScoreListenerId member
    Super::EndPlay(EndPlayReason);
}

Concepts

Domain and Event

Every event is identified by a Domain (a channel, default global.default) and an Event name. Listeners only receive events with exactly the same pair.

GameplayTags

Tag-based nodes split the tag at its last dot: Game.Player.Died becomes domain Game.Player and event Died. A tag without a dot uses domain global.default. A tag emit therefore reaches string-based listeners of the same pair and the other way round. To Domain and Event (GameplayTag) shows the split.

Payload

One value of any Blueprint type. The receiving function must take exactly one parameter of the same type (or none for events without data). Arrays, maps and sets cannot be emitted directly; wrap them in a struct. Struct types are validated by default (see Set EHOptions).

Pinning

An event emitted with Pinned keeps its last value: listeners that bind later receive it immediately when they bind. Use EHUnpin Event to stop replaying it. To pin a different value, unpin the old one first.

Lifetime

Listeners are tracked per world. When a world ends, all of its events and listeners are removed (a hidden helper actor, AEHWorldListenerActor, is spawned per world for this). Listeners whose objects are destroyed are removed when they are found stale. In the editor, all events are cleared when a Play-In-Editor session starts.

Emitting events

Category EventHub. All emit nodes take a world context automatically.

Binding and unbinding

All bind and unbind nodes can be found by searching for eventhub, listen or stoplisten.

Wildcard conversions

Category Utilities > EventHub. Used with delegate bindings and with LastReceivedProperty of the receiver component. Each returns true when the stored value has the requested type (except the plain string conversion). Most of them are auto-cast nodes: dragging a Wildcard Property pin onto a typed input inserts them automatically.

Options

Receiver components

UEHBaseReceiverComponent (Blueprintable, spawnable from Add Component, class group Utility) binds itself on BeginPlay and unbinds on EndPlay.

C++ API

Include EHHandler.h and use the global handler FEHHandler::DefaultHandler(). Emits take an FEHEmitContext (Domain, Event, WorldContext, bPinned); listeners take an FEHEventContext (Domain, Event, WorldContext).

Content

Plugin content (enable Show Plugin Content in the Content Browser view options).

The eight receiver components live in GenericComponentReceivers and derive from EHBaseReceiverComponent. Add one to an actor, set Bind Settings (Domain and Event) and bind to its On ... Received dispatcher. EHMacroLibrary lives in Macros.

Troubleshooting

Credits

© 2026 Alpha XP — alphaxp.net · Support: support@alphaxp.net. Built and verified for Unreal Engine 4.27 and 5.8.