IoTPulse
Realtime pub/sub with AWS IoT Core

Overview

IoTPulse gives Unreal Engine 4.27 and 5.8 games a managed realtime message bus without running servers: lobby chat, live events, presence, spectator feeds, remote configuration and companion apps all become MQTT topics on AWS IoT Core. Messages, connection events and results always arrive on the game thread.

• Connect: MQTT 5 over a secure WebSocket (port 443), the handshake signed with AWS Signature V4 using the player's credentials.
• Connect With Certificate: X.509 client certificate (mutual TLS) for kiosks and other fixed devices.
• Publish, Subscribe with + / # wildcards, QoS 0 and 1, retained messages, last will, MQTT 5 request / response (response topic, correlation data) and user properties.
• Automatic reconnect with exponential back-off; subscriptions are renewed when the broker lost the session.
• Device shadows over HTTPS: Get Shadow, Update Shadow (reported or desired state, optimistic locking), Delete Shadow; realtime shadow updates over MQTT with Make Shadow Topic.
• Publish (HTTPS) for one-off messages without a connection.
• Amazon Cognito identity pools for guests and signed-in players; static keys and the default AWS chain for development and servers.

Requirements

Installation

1. Install IoTPulse from Fab into your engine, or copy the IoTPulse folder into your project's Plugins folder.
2. Enable IoTPulse in Edit > Plugins and restart the editor.
3. Open Project Settings > Plugins > IoTPulse and set Region, Identity Pool Id and IoT Data Endpoint.
4. C++ only: add PublicDependencyModuleNames.Add("IoTPulse"); to your Build.cs.

Setting up AWS

1. Find your account's IoT data endpoint: AWS IoT console > Settings > Device data endpoint, or aws iot describe-endpoint --endpoint-type iot:Data-ATS. It looks like a1b2c3d4e5f6g7-ats.iot.us-east-1.amazonaws.com; paste it into IoT Data Endpoint.
2. In Amazon Cognito create an identity pool. Enable guest access if players may connect before signing in, and add your identity providers (for example a Cognito user pool).
3. Edit the IAM role the pool gives to players (authenticated and/or guest). The example lets each player connect only with their own identity id as client id, use topics under mygame/ and the shadows of things named mygame-*:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": "iot:Connect",
      "Resource": "arn:aws:iot:us-east-1:123456789012:client/${cognito-identity.amazonaws.com:sub}"
    },
    {
      "Effect": "Allow",
      "Action": ["iot:Publish", "iot:Receive"],
      "Resource": [
        "arn:aws:iot:us-east-1:123456789012:topic/mygame/*",
        "arn:aws:iot:us-east-1:123456789012:topic/$aws/things/mygame-*/shadow/*"
      ]
    },
    {
      "Effect": "Allow",
      "Action": "iot:Subscribe",
      "Resource": [
        "arn:aws:iot:us-east-1:123456789012:topicfilter/mygame/*",
        "arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/mygame-*/shadow/*"
      ]
    },
    {
      "Effect": "Allow",
      "Action": ["iot:GetThingShadow", "iot:UpdateThingShadow", "iot:DeleteThingShadow"],
      "Resource": "arn:aws:iot:us-east-1:123456789012:thing/mygame-*"
    }
  ]
}

Connect leaves the client id empty by default, which makes it the player's identity id - exactly what ${cognito-identity.amazonaws.com:sub} expands to. The same variable keeps per-player topics private, for example topic/mygame/players/${cognito-identity.amazonaws.com:sub}/*. Publish uses topic/ resources, Subscribe uses topicfilter/ resources (the filter exactly as written, wildcards included), Receive is checked for every delivered message.

Certificates (Connect With Certificate)

For kiosks and venue machines register the device as a thing in AWS IoT, create a certificate, attach an IoT policy to it and copy the certificate and private key (PEM) to the device. The client id is usually the thing name. Never put a device key into a game that players download.

Quick start

Lobby chat

1. On Begin Play call Connect (defaults are fine). From On Connected store Connection in a variable.
2. Bind On Message of the connection to a custom event and call Subscribe with mygame/lobby/42/chat.
3. To send, call Publish on the connection: Topic mygame/lobby/42/chat, Payload {"from":"Ana","text":"gg"}.
4. In the On Message event read Message > Payload (and Topic to tell channels apart; Topic Matches Filter helps with wildcards).
5. On End Play call Disconnect.

Presence with a last will

Set Options > Will Topic to mygame/presence/<player>, Will Payload to {"online":false} and Will Retain on, then publish {"online":true} with Retain after connecting. If the game crashes or loses the network, AWS IoT Core publishes the will for you; a normal Disconnect does not.

Latent nodes

All latent nodes run in the background, can be stopped with Cancel on their return value and fire exactly one final pin on the game thread.

Connection object

UIoTPulseConnection is returned by Connect. While it runs, the game instance keeps it alive; it is closed automatically when the game instance shuts down (end of Play In Editor, quitting). One object = one connection: after it stopped, call Connect again.

Functions

Device shadows

A shadow is a small JSON document that AWS IoT Core stores per thing: state.reported (what is), state.desired (what should be) and state.delta (the difference). Games use them for lobby state, server status boards, persistent room settings or companion-app controls.

1. Create a thing (for example mygame-lobby42) in the AWS IoT console, or let your backend create one per room.
2. Update Shadow with Document {"players":3,"map":"dunes"} writes state.reported. Set a field to null to remove it; Document null clears the section.
3. Get Shadow returns the whole document plus Reported, Desired and Delta as JSON strings, and the Version for optimistic locking.
4. Realtime: Subscribe to Make Shadow Topic with Topic = update/documents (every change) or update/delta (desired changes for a device).

Credentials

C++ API

// Build.cs: PublicDependencyModuleNames.Add("IoTPulse");
#include "IoTPulseAsyncActions.h"
#include "IoTPulseConnection.h"

UIoTPulseConnectAction* Action = UIoTPulseConnectAction::Connect(this, FIoTPulseConnectOptions(), FString());
Action->OnConnected.AddDynamic(this, &AMyActor::HandleConnected);   // (UIoTPulseConnection*, const FIoTPulseError&)
Action->Activate();

void AMyActor::HandleConnected(UIoTPulseConnection* Connection, const FIoTPulseError& Error)
{
    Mqtt = Connection;                                         // UPROPERTY() UIoTPulseConnection* Mqtt;
    Mqtt->OnMessage.AddDynamic(this, &AMyActor::HandleMessage);
    Mqtt->Subscribe(TEXT("mygame/lobby/42/chat"));
    Mqtt->PublishWithCallback(TEXT("mygame/lobby/42/chat"), TEXT("{\"text\":\"hi\"}"), EIoTPulseQoS::AtLeastOnce,
        false, TArray<uint8>(), FString(), FString(),
        [](bool bOk, const FIoTPulseError& Result) { /* game thread */ });
}

Every latent node class (UIoTPulseGetShadowAction, ...) can be created through its static factory function; bind the delegates, then call Activate().

Types

Settings

Project Settings > Plugins > IoTPulse (saved to DefaultGame.ini). HTTPS requests use changes at once, MQTT connections with the next Connect.

Troubleshooting

Credits

© 2026 Alpha XP — alphaxp.net · Support: support@alphaxp.net. Includes the AWS SDK for C++ and the AWS Common Runtime (Apache License 2.0). Built for Unreal Engine 4.27 and 5.8.