BlueprintTCP
TCP client for Unreal, from Blueprints

Overview

BlueprintTCP is a lightweight UE 4.27–5.0+ plugin that lets you connect to any TCP server and exchange data entirely from Blueprints (C++ is also supported). Place one BlueprintTCP Connection actor, call Connect, and send/receive arbitrary byte streams to game backends, IoT devices, chat servers, hardware bridges, or any TCP endpoint.

Each connection runs on its own background thread, so blocking socket I/O never stalls the game thread. Incoming data is marshalled back to the game thread and delivered through Blueprint events. One actor can manage many simultaneous connections, each addressed by a ConnectionId.

Requirements

Installation

1. Copy the BlueprintTCP folder into your project's Plugins/ directory.
2. C++ projects: right-click the .uproject → Generate Visual Studio project files, then build. Blueprint-only projects can launch the editor directly.
3. Open Edit → Plugins → Networking, confirm BlueprintTCP is enabled, and restart if prompted.

Quick Start (Blueprints)

1. Place the actor. Drag a BlueprintTCP Connection actor into the level (or Spawn Actor from Class). Keep a reference.
2. Connect. Call Connect with IP, port, and three bound events; store the output Connection Id.
3. Send. Use Send String for text, or build a byte array and call Send Data.
4. Receive. Your On Message Received event fires on the game thread; drain it with the Read nodes.
5. Clean up. Disconnect / Disconnect All (also auto-closed on EndPlay).

Event BeginPlay
 └─ Connect (Conn, "127.0.0.1", 7777, OnDisc, OnConn, OnMsg)  →  set ConnId

Event OnConn (ConnId)
 └─ Send String (Conn, ConnId, "HELLO\n")

Event OnMsg (ConnId, Message)
 ├─ Length = Read Int (Message)
 ├─ Text   = Read String (Message, Length)
 └─ Print String (Text)

API — Connection management

API — Events

Bind these when you call Connect. All fire on the game thread.

API — Sending

API — Building byte arrays (pure)

API — Reading received messages

Each Read node consumes bytes from the front of Message (passed by ref), so call them in your protocol's order.

Utility node pack

General-purpose networking utilities on UBlueprintTCPLibrary — available from Blueprints and C++.

Tunables (actor properties)

C++ Usage

Include BlueprintTCPConnection.h and use ABlueprintTCPConnection directly:

int32 ConnId = 0;
FBlueprintTCPDisconnectDelegate OnDisc; OnDisc.BindUFunction(this, FName("HandleDisconnected"));
FBlueprintTCPConnectDelegate    OnConn; OnConn.BindUFunction(this, FName("HandleConnected"));
FBlueprintTCPReceivedMessageDelegate OnMsg; OnMsg.BindUFunction(this, FName("HandleMessage"));

Connection->Connect(TEXT("127.0.0.1"), 7777, OnDisc, OnConn, OnMsg, ConnId);
Connection->SendString(ConnId, TEXT("ping\n"));

Add "Sockets" and "Networking" to your module dependencies if you touch the worker layer directly.

How It Works

Each Connect spins up an FBlueprintTCPWorker (FRunnable) on its own thread with an incrementing ConnectionId. The worker performs the blocking connect/receive; data moves between threads via lock-free single-producer/single-consumer queues (inbox worker→game, outbox game→worker). The actor's Tick drains the inbox and fires Blueprint events on the game thread.

Worker callbacks carry a TWeakObjectPtr back to the actor, so stopping PIE mid-connect (a blocking timeout) can never dereference freed memory.

Project Settings

Project Settings → Plugins → BlueprintTCP

Troubleshooting