Double-buffer in UE5T

2026-01-12 13:06 UTC gpt-5-2 Open in ChatGPT ↗

You

I want to implement a double-buffer strategy in UE5T blueprints, for drawing onto a render target. How to swap the render targets?

ChatGPT

In Blueprints you don’t really “swap” a UTextureRenderTarget2D in-place. The usual double-buffer pattern is: keep two RT assets, and flip which one you write to vs which one you read from each frame (or each update). Practically, that means swapping references (variables) and updating the material parameter(s) that sample from the “previous” RT.

Here are the two common Blueprint-friendly ways.

Pattern A (recommended): Two variables + flip-flop (ping/pong)

1) Create and store two RTs

• Have RT_A and RT_B (either created as assets or Create Render Target 2D at runtime).
• In your actor/component, store:
  • RT_Ping (TextureRenderTarget2D reference)
  • RT_Pong (TextureRenderTarget2D reference)

Initialize:

• RT_Ping = RT_A
• RT_Pong = RT_B

2) Each update: draw “from Ping into Pong”

• Your draw material should have a parameter like PrevRT (Texture).
• Before drawing:
  • Set Texture Parameter Value on a MID used for drawing: PrevRT = RT_Ping
• Then draw into the other target:
  • Draw Material to Render Target (Target = RT_Pong, Material = your MID)

3) Swap references (the “swap”)

After the draw call, swap the variables:

Blueprint swap (no temp node required if you do it right):

• Temp = RT_Ping
• RT_Ping = RT_Pong
• RT_Pong = Temp

Now RT_Ping is the latest result (the one you just rendered), and next tick you’ll render into the other.

4) Update whoever displays it

If a mesh/UI material shows the “current” RT, point it to RT_Ping:

• Set Texture Parameter Value (e.g., CurrentRT = RT_Ping) on the display MID.

That’s the entire ping/pong.

---

Pattern B: Keep an index (0/1) and select targets

Instead of swapping references, store:

• BufferIndex (int 0 or 1)
• RT[0], RT[1] (two variables or an array)

Per update:

• ReadRT = RT[BufferIndex]
• WriteRT = RT[1 - BufferIndex]
• draw from ReadRT into WriteRT
• BufferIndex = 1 - BufferIndex

This avoids the temp variable swap nodes.

---

Important gotchas in UE5 Blueprints

You can’t read and write the same RT in one pass

If your draw material samples the render target that you’re currently drawing into, you’ll get feedback/undefined behavior. Double buffering prevents that: sample Ping, write Pong.

Update order matters

Do:

1. Set “PrevRT” param = Ping
2. Draw to Pong
3. Swap / flip index
4. Set “DisplayedRT” param = Ping (new current)

Clear once, not every tick (usually)

If you clear every tick you’ll lose accumulation. Clear both RTs on init, then only clear when you explicitly want to reset.

Use MIDs, not the base material

• Create a Dynamic Material Instance for the draw material.
• Create a Dynamic Material Instance for the display material (if separate). Then set texture parameters on the MID(s).

---

Minimal Blueprint pseudo-graph (Tick or custom “Step”)

Variables: RT_Ping, RT_Pong, DrawMID, DisplayMID

Step:

1. DrawMID -> SetTextureParameterValue("PrevRT", RT_Ping)
2. DrawMaterialToRenderTarget( RT_Pong, DrawMID )
3. Swap:
   • Temp = RT_Ping
   • RT_Ping = RT_Pong
   • RT_Pong = Temp
4. DisplayMID -> SetTextureParameterValue("CurrentRT", RT_Ping)

---

If you tell me what you’re using to draw (Canvas Render Target vs Draw Material to RT vs Niagara / SceneCapture) and how you’re displaying it (mesh material, UMG brush, etc.), I can map this to the exact nodes and the best place to run it (Tick vs Timer vs “on paint” event).

You

write me a GLSL version of InigoQuilez smoothmin for UE5

ChatGPT

Here’s the classic Inigo Quílez smooth min (“smin”) in GLSL, plus a couple variants you’ll see used in SDF work. UE5 doesn’t run GLSL directly, but this code drops cleanly into UE’s Custom material node with only minor syntax tweaks.

1) Polynomial smooth min (most common)

// k > 0 : smoothing radius (bigger = softer blend)
float smin(float a, float b, float k)
{
    float h = clamp(0.5 + 0.5*(b - a)/k, 0.0, 1.0);
    return mix(b, a, h) - k*h*(1.0 - h);
}

2) Exponential smooth min (softmax-style)

// k > 0 : sharpness (bigger = sharper, smaller = softer)
float sminExp(float a, float b, float k)
{
    return -log(exp(-k*a) + exp(-k*b)) / k;
}

3) Power smooth min

// k > 0 : power (bigger = closer to min, smaller = smoother)
float sminPow(float a, float b, float k)
{
    a = pow(a, k);
    b = pow(b, k);
    return pow((a*b)/(a+b), 1.0/k);
}

---

UE5 Material Custom Node notes (quick)

If you paste (1) into a UE Custom node:

• Replace clamp / mix with UE equivalents only if needed (UE supports clamp and lerp; mix usually works but lerp is safest).
• Use lerp(b, a, h) instead of mix(b, a, h).

UE-friendly version:

float smin(float a, float b, float k)
{
    float h = clamp(0.5 + 0.5*(b - a)/k, 0.0, 1.0);
    return lerp(b, a, h) - k*h*(1.0 - h);
}

If you tell me whether you’re doing SDFs in a material or compute-like drawing into a render target, I can show how to wire a, b, and k with UE nodes + a couple good defaults for k.

You

I want to be able to “fetch” a selection of actors in an array (UE5).

ChatGPT

In UE5 you generally don’t “fetch the editor selection” directly at runtime—the approach depends on where you want this (Editor vs Play) and why. Below are the correct patterns for each common case, starting with the most useful one.

---

Case 1 (Most common): Get currently selected actors in the Editor (Blueprint or C++)

⚠️ Important limitation

Blueprints cannot access the editor selection by default. You must use either:

• Editor Utility Blueprint / Editor Utility Widget, or
• C++ with editor-only code

---

✅ Option A: Editor Utility Widget (Blueprint-only, recommended)

Steps

1. Enable plugin

   • Edit → Plugins → Editor Scripting Utilities → Enable → Restart

2. Create

   • Editor Utility Widget (EUW)

3. In the EUW graph Use:

   • Get Selected Actors (Editor Utility node)

This returns:

Array<Actor>

You can:

• Store it in a variable
• Filter by class
• Push it into another asset, data table, or actor variable

Example Blueprint flow

Get Selected Actors
→ ForEachLoop
    → Cast / Filter
    → Add to Array

✔ Works only in-editor
✔ Perfect for tools, baking data, setup workflows

---

Case 2: Capture selection in-editor, then use it at runtime

If you want:

“Select actors → press a button → save that selection → use it later in PIE / game”

Pattern

1. Use Editor Utility Widget
2. Fetch selection via Get Selected Actors
3. Save references into:
   • An actor placed in the level
   • A Data Asset
   • A Blueprint variable marked Instance Editable

Example

• EUW:
  • Button → Get Selected Actors
  • Assign to MyManagerActor.SelectedActors

Now at runtime:

You

you misunderstood. I want my blueprint to reference multiple actors (using some criterion, let’s say a Tag) and put them in an array available on runtime

ChatGPT

Got it — you want to collect actors at runtime based on a criterion (e.g., an Actor Tag) and store them in a Blueprint array.

Runtime: fetch actors by Tag into an array

Option A: Get All Actors With Tag (simplest)

In your Blueprint (Actor / Component / GameMode, etc.):

1. Event BeginPlay (or when you want to refresh)
2. Node: Get All Actors With Tag
   • Tag = YourTag (Name)
   • Outputs: Out Actors (Array of Actor)
3. Assign Out Actors to your array variable (e.g. TaggedActors)

That’s it.

Notes

• This uses Actor Tags (the “Tags” array on the Actor), not Gameplay Tags.
• Works in packaged builds.
• Fine for BeginPlay; avoid calling every Tick for performance.

---

Option B: Filter by class + tag (more precise)

If you only want specific types:

1. Get All Actors Of Class (e.g., BP_Enemy)
2. ForEachLoop
3. Actor Has Tag → Branch
4. If true → Add to your array

This avoids collecting unrelated actors that share the same tag.

---

Option C: Use Gameplay Tags (if you mean those)

If you’re using GameplayTags (via GameplayTagComponent / interface / ASC), you don’t get a “Get all actors with gameplay tag” node by default. Typical patterns are:

• Keep a registry (next option), or
• Use Get All Actors Of Class then query each actor’s gameplay tags.

---

Better scalable pattern: registry (fast, dynamic)

If actors can spawn/despawn and you need the array to stay correct:

1) Make a “Manager” (Subsystem or Actor)

Store TrackedActors : Array<Actor>.

2) On each relevant actor

On BeginPlay:

• If Actor Has Tag (YourTag) → Register with manager

On EndPlay:

• Unregister

This avoids expensive “scan the world” queries and stays up-to-date with spawns.

---

Practical tips

• Use BeginPlay scan for static worlds.
• If actors can spawn later, either:
  • Rescan on demand, or
  • Use a registry approach.
• After collecting, you often want:
  • Filter Invalid (remove nulls)
  • Sort (if order matters)
  • Store as Array of YourClass (cast once, then keep strongly typed refs)

---

If you tell me which “tag” you mean (Actor Tag vs Gameplay Tag) and whether actors can spawn during play, I’ll give you the best exact node graph for that scenario.

You

what’s the best strategy if:

1. I’m actually receiving just X,Y coordinates of real people tracked by cameras, and I need my blueprint to track those.
2. I don’t want to create/destroy, but rather use a fixed pool

ChatGPT

Best strategy: object pool of marker actors/components + an “ID → pool index” map + update loop. Don’t use tags/world scans at all.

Architecture

1) One manager owns everything

Create a BP_TrackerManager that receives the camera detections each frame (or at some rate). It maintains:

• Pool: Markers = Array of BP_PersonMarker (fixed size, spawned once)
• Free list: FreeIndices = Array (stack of available marker indices)
• Active map: IdToIndex = Map<int, int> (or Map<string,int>)
  (key = person tracking ID; value = pool index)
• LastSeen: IdToLastSeenTime = Map<int, float>
• Settings:
  • MaxPeople
  • LoseAfterSeconds (e.g. 0.5–2.0)
  • SmoothSpeed (optional)

If your upstream doesn’t provide a stable ID, generate one by simple nearest-neighbor association (still using the same pool); but if you can get an ID, everything becomes easy.

---

Pool setup (BeginPlay)

1. For i = 0 .. MaxPeople-1
   • SpawnActor BP_PersonMarker (or create components)
   • SetActorHiddenInGame(true) / SetActorEnableCollision(false)
   • Add to Markers
   • Push i into FreeIndices

That’s the only spawning you ever do.

---

Update step (called when a new list arrives)

Assume you receive an array of detections:

• Detections: array of structs like {Id, X, Y} (and maybe Confidence)

For each detection:

A) Allocate or reuse a marker

• If IdToIndex.Contains(Id):
  • Index = IdToIndex[Id]
• Else:
  • If FreeIndices not empty:
    • Index = Pop(FreeIndices)
    • IdToIndex.Add(Id, Index)
  • Else:
    • Pool exhausted → pick a policy:
      • Drop this detection
      • or Steal oldest (recommended): find ID with smallest LastSeen, release it, reuse its index

B) Update transform

Convert XY to world:

• If it’s a floor plane: World = Origin + X*AxisX + Y*AxisY
• Then:
  • Markers[Index] -> SetActorHiddenInGame(false)
  • Markers[Index] -> SetActorLocation(World)
    Optional smoothing:
  • VInterpTo(CurrentLocation, World, DeltaSeconds, SmoothSpeed) then set.

C) Stamp last seen

• IdToLastSeenTime[Id] = GetGameTimeInSeconds()

---

Cleanup step (hide / release missing people)

After processing all detections (or on a timer):

• Now = GetGameTimeInSeconds()
• For each (Id, LastSeen) in IdToLastSeenTime:
  • If Now - LastSeen > LoseAfterSeconds:
    • Index = IdToIndex[Id]
    • Hide marker: Markers[Index].SetActorHiddenInGame(true)
    • Remove from maps: IdToIndex.Remove(Id), IdToLastSeenTime.Remove(Id)
    • Return to pool: FreeIndices.Add(Index)

This gives you stable markers that “stick” to a person ID and disappear after a timeout.

---

Why this is the best fit for your constraints

• No create/destroy churn → fixed pool, constant memory.
• No expensive world queries (GetAllActors...) → O(N detections) updates.
• Handles people appearing/disappearing gracefully.
• Scales to many points and high update rates.
• Works for RenderTarget drawing too: each marker can draw to RT, or the manager draws all points.

---

Implementation notes in Blueprints

• Use a Struct for detection data: PersonDetection { Id (int), X (float), Y (float) }.
• Blueprint Map supports int→int, int→float, string→int, etc.
• “Pop from FreeIndices”:
  • LastIndex = FreeIndices.Length - 1
  • Index = FreeIndices[LastIndex]
  • RemoveIndex(LastIndex)

Steal-oldest policy (if pool full):

• Iterate IdToLastSeenTime keys, track min LastSeen.
• Release that ID (same as cleanup) and reuse its index.

---

Coordinate conversion (the part people trip on)

Pick one:

If XY is already in world units on a known plane

• World = PlaneOrigin + (PlaneRight * X) + (PlaneForward * Y)

If XY is normalized (0..1) in camera image space

You need a calibration mapping:

• simplest: map to a rectangle in world:
  • World = Origin + Right * (X - 0.5)*Width + Forward * (Y - 0.5)*Height
• better: use a homography / calibration matrix (can still be done in BP, but usually C++).

---

If you tell me:

• do you get a stable person ID from the tracker?
• are X,Y meters, pixels, or 0..1 normalized?
• do you want markers as Actors, Components, or purely “draw points to a RenderTarget”?

…I’ll tailor the exact Blueprint node flow (including the XY→World mapping) to your setup.

You

Create a dummy python script that sends 32 random walk positions within a radius via JSONRCP HTTP

ChatGPT

[Unsupported Content]

ChatGPT

[Unsupported Content]

ChatGPT

#!/usr/bin/env python3
"""
Dummy JSON-RPC-over-HTTP sender: 32 tracked people doing a bounded random walk.

Usage:
  python send_walk_jsonrpc.py --url http://127.0.0.1:8080/jsonrpc --fps 10 --radius 5.0
"""

import argparse
import json
import math
import random
import time
from typing import List, Dict, Any

try:
    import requests  # pip install requests
except ImportError:
    raise SystemExit("Missing dependency: requests. Install with: pip install requests")

def clamp_to_radius(x: float, y: float, radius: float) -> tuple[float, float]:
    """Clamp point to a circle of given radius (keeps direction, clamps magnitude)."""
    r2 = x * x + y * y
    if r2 <= radius * radius:
        return x, y
    r = math.sqrt(r2)
    s = radius / r
    return x * s, y * s

def init_positions(n: int, radius: float) -> List[Dict[str, float]]:
    """Initialize positions uniformly inside a circle."""
    pos = []
    for _ in range(n):
        # Uniform inside circle: r = sqrt(u)*R, theta uniform
        u = random.random()
        theta = random.random() * 2.0 * math.pi
        r = math.sqrt(u) * radius
        x = r * math.cos(theta)
        y = r * math.sin(theta)
        pos.append({"x": x, "y": y})
    return pos

def step_random_walk(pos: List[Dict[str, float]], radius: float, step_sigma: float) -> None:
    """One random-walk step with Gaussian noise, clamped to radius."""
    for p in pos:
        p["x"] += random.gauss(0.0, step_sigma)
        p["y"] += random.gauss(0.0, step_sigma)
        p["x"], p["y"] = clamp_to_radius(p["x"], p["y"], radius)

def make_jsonrpc_payload(method: str, params: Any, rpc_id: int) -> Dict[str, Any]:
    return {"jsonrpc": "2.0", "method": method, "params": params, "id": rpc_id}

def main() -> None:
    ap = argparse.ArgumentParser()
    ap.add_argument("--url", required=True, help="JSON-RPC HTTP endpoint, e.g. http://127.0.0.1:8080/jsonrpc")
    ap.add_argument("--method", default="updatePositions", help="JSON-RPC method name")
    ap.add_argument("--n", type=int, default=32, help="Number of tracked people")
    ap.add_argument("--radius", type=float, default=5.0, help="Bounding radius for walk (same units as your world)")
    ap.add_argument("--step", type=float, default=0.05, help="Random-walk step sigma per tick")
    ap.add_argument("--fps", type=float, default=10.0, help="Send rate")
    ap.add_argument("--timeout", type=float, default=2.0, help="HTTP timeout seconds")
    ap.add_argument("--seed", type=int, default=None, help="Random seed")
    ap.add_argument("--once", action="store_true", help="Send one payload and exit")
    args = ap.parse_args()

    if args.seed is not None:
        random.seed(args.seed)

    positions = init_positions(args.n, args.radius)

    session = requests.Session()
    rpc_id = 1
    dt = 1.0 / max(args.fps, 0.1)

    while True:
        step_random_walk(positions, args.radius, args.step)

        # Pack as an array of {id, x, y}. Add timestamp if you want.
        detections = [{"id": i, "x": p["x"], "y": p["y"]} for i, p in enumerate(positions)]
        params = {"points": detections, "radius": args.radius, "t": time.time()}

        payload = make_jsonrpc_payload(args.method, params, rpc_id)
        rpc_id += 1

        try:
            r = session.post(
                args.url,
                data=json.dumps(payload),
                headers={"Content-Type": "application/json"},
                timeout=args.timeout,
            )
            # Some servers return JSON-RPC response; print status + body snippet
            print(f"[{time.strftime('%H:%M:%S')}] POST {r.status_code} {r.text[:200]}")
        except requests.RequestException as e:
            print(f"[{time.strftime('%H:%M:%S')}] ERROR: {e}")

        if args.once:
            break

        time.sleep(dt)

if __name__ == "__main__":
    main()

If you tell me what your receiver expects (method name + params shape), I’ll adjust the JSON-RPC payload to match it exactly.

You

also draw them for debug purposes

ChatGPT

Here’s an updated dummy sender that also draws the 32 random-walk points live for debugging, while still sending them via JSON-RPC over HTTP.

It uses matplotlib in interactive mode.

---

Features added

• Live 2D scatter plot
• Fixed-radius circle drawn
• Stable IDs (0–31)
• Plot updates at the same rate as network sends

---

Full script (send + debug draw)

#!/usr/bin/env python3
"""
Dummy JSON-RPC-over-HTTP sender with live debug drawing.

- Sends 32 random-walk XY positions inside a radius
- Draws them in a matplotlib window
"""

import argparse
import json
import math
import random
import time
from typing import List, Dict, Any

import requests
import matplotlib.pyplot as plt

# ---------------------------
# Math helpers
# ---------------------------

def clamp_to_radius(x: float, y: float, radius: float):
    r2 = x * x + y * y
    if r2 <= radius * radius:
        return x, y
    r = math.sqrt(r2)
    s = radius / r
    return x * s, y * s

def init_positions(n: int, radius: float) -> List[Dict[str, float]]:
    pos = []
    for _ in range(n):
        u = random.random()
        theta = random.random() * 2.0 * math.pi
        r = math.sqrt(u) * radius
        pos.append({
            "x": r * math.cos(theta),
            "y": r * math.sin(theta)
        })
    return pos

def step_random_walk(pos, radius, step_sigma):
    for p in pos:
        p["x"] += random.gauss(0.0, step_sigma)
        p["y"] += random.gauss(0.0, step_sigma)
        p["x"], p["y"] = clamp_to_radius(p["x"], p["y"], radius)

# ---------------------------
# JSON-RPC
# ---------------------------

def make_jsonrpc_payload(method: str, params: Any, rpc_id: int):
    return {
        "jsonrpc": "2.0",
        "method": method,
        "params": params,
        "id": rpc_id
    }

# ---------------------------
# Debug drawing
# ---------------------------

def setup_plot(radius: float):
    plt.ion()
    fig, ax = plt.subplots()
    ax.set_aspect("equal", adjustable="box")
    ax.set_xlim(-radius, radius)
    ax.set_ylim(-radius, radius)
    ax.set_title("Tracked People (Debug View)")
    ax.set_xlabel("X")
    ax.set_ylabel("Y")

    # Draw boundary circle
    circle = plt.Circle((0, 0), radius, color="gray", fill=False, linestyle="--")
    ax.add_patch(circle)

    scatter = ax.scatter([], [], c="red", s=40)
    return fig, ax, scatter

def update_plot(scatter, positions):
    xs = [p["x"] for p in positions]
    ys = [p["y"] for p in positions]
    scatter.set_offsets(list(zip(xs, ys)))
    plt.pause(0.001)

# ---------------------------
# Main loop
# ---------------------------

def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--url", required=True, help="JSON-RPC HTTP endpoint")
    ap.add_argument("--method", default="updatePositions")
    ap.add_argument("--n", type=int, default=32)
    ap.add_argument("--radius", type=float, default=5.0)
    ap.add_argument("--step", type=float, default=0.05)
    ap.add_argument("--fps", type=float, default=10.0)
    ap.add_argument("--seed", type=int, default=None)
    args = ap.parse_args()

    if args.seed is not None:
        random.seed(args.seed)

    positions = init_positions(args.n, args.radius)
    fig, ax, scatter = setup_plot(args.radius)

    session = requests.Session()
    rpc_id = 1
    dt = 1.0 / max(args.fps, 0.1)

    while True:
        step_random_walk(positions, args.radius, args.step)

        # Debug draw
        update_plot(scatter, positions)

        detections = [
            {"id": i, "x": p["x"], "y": p["y"]}
            for i, p in enumerate(positions)
        ]

        payload = make_jsonrpc_payload(
            args.method,
            {
                "points": detections,
                "radius": args.radius,
                "time": time.time()
            },
            rpc_id
        )
        rpc_id += 1

        try:
            r = session.post(
                args.url,
                json=payload,
                timeout=2.0
            )
            print(f"POST {r.status_code}")
        except requests.RequestException as e:
            print(f"ERROR: {e}")

        time.sleep(dt)

if __name__ == "__main__":
    main()

---

What this matches nicely in UE5

• XY plane visualization ↔ world floor plane
• Stable IDs ↔ your pool manager (Id → PoolIndex)
• Fixed radius ↔ calibrated capture area
• Constant send rate ↔ Tick / Timer update

---

Easy next upgrades (if you want)

• Color by ID (HSV palette)
• Draw velocity vectors
• Toggle lost IDs fading out
• Add confidence / Z value
• Dump frames to file for replay in UE

If you want, I can:

• Match the JSON exactly to your UE Blueprint parser
• Add UDP instead of HTTP
• Add nearest-neighbor ID assignment (if your tracker doesn’t provide IDs)
• Mirror UE world scale & origin precisely

Just say the word.

You

I am testing locally, what url to use

ChatGPT

Since you’re testing locally, the URL depends on what is receiving the JSON-RPC. Here are the correct, concrete options.

---

Most common local URLs

✅ If your receiver is running on the same machine

Use localhost or 127.0.0.1:

http://127.0.0.1:PORT/PATH

Examples:

http://127.0.0.1:8080/jsonrpc
http://localhost:3000/
http://127.0.0.1:5000/rpc

In your script:

python send_walk_jsonrpc.py --url http://127.0.0.1:8080/jsonrpc

---

What UE5 usually looks like

UE does not expose an HTTP server by default. One of these must be true:

Case A — You added an HTTP server plugin / C++ endpoint

Then use whatever port/path you bound in C++:

http://127.0.0.1:<YourPort>/<YourRoute>

Example:

http://127.0.0.1:7777/jsonrpc

---

Case B — You’re using a Blueprint HTTP listener plugin

Check the plugin docs, but typically:

http://127.0.0.1:8080/

(Some plugins hardcode 8080, 3000, or 5000.)

---

Case C — UE is the client, not the server

If UE is making HTTP requests outward, then your Python script must be the server.
In that case, this script is backwards — tell me and I’ll flip it.

---

Quick sanity test (very useful)

Before involving UE, verify something is listening:

1️⃣ Test with curl

curl -X POST http://127.0.0.1:8080/jsonrpc \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"ping","params":{},"id":1}'

• ✅ Response → server exists
• ❌ Connection refused → nothing is listening

---

Minimal Python JSON-RPC receiver (for testing)

If you want a quick local receiver to test against UE later:

from http.server import BaseHTTPRequestHandler, HTTPServer
import json

class Handler(BaseHTTPRequestHandler):
    def do_POST(self):
        length = int(self.headers.get("Content-Length", 0))
        body = self.rfile.read(length)
        print("Received:", body.decode())

        self.send_response(200)
        self.send_header("Content-Type", "application/json")
        self.end_headers()
        self.wfile.write(b'{"jsonrpc":"2.0","result":"ok","id":1}')

HTTPServer(("127.0.0.1", 8080), Handler).serve_forever()

Then your URL is:

http://127.0.0.1:8080

---

TL;DR (use this unless told otherwise)

http://127.0.0.1:8080/jsonrpc

If you want, tell me how UE is receiving the data (plugin name or C++), and I’ll give you the exact URL + port that matches it.

You

http listener plugins for Unreal ?

ChatGPT

Yes — Unreal does not ship with an HTTP listener/server enabled by default, so you need either a plugin or C++. Below is a clear, up-to-date landscape of the actual options people use in UE4/UE5, with pros/cons so you can pick correctly.

---

HTTP Listener / Server options for Unreal Engine (UE5)

🟢 BEST CHOICE (Blueprint-friendly): HTTP Server Plugin (Built-in, but C++-oriented)

✅ Unreal’s built-in HTTP Server module

This exists in-engine, but:

• It is C++ only
• Not exposed to Blueprints directly

Modules

• HttpServer
• Http
• Json
• JsonUtilities

Typical URL

http://127.0.0.1:8080/your_route

Example use

• Register routes
• Handle POST JSON
• Parse JSON-RPC
• Push data into game thread

➡️ Best long-term solution if you are okay writing a small C++ bridge and then exposing Blueprint events.

---

🟡 Blueprint-first Plugins (most common for prototyping)

1️⃣ VaRest (HTTP client only ❌)

⚠️ Not a listener

• Can SEND HTTP requests
• Cannot RECEIVE them
• Often misunderstood

❌ Not suitable for your use case

---

2️⃣ UEHttpServer / SimpleHttpServer plugins

Community plugins (varies by fork)

Common names:

• Simple HTTP Server
• UE4 HTTP Server
• UnrealHttpServer

Typical features:

• Blueprint events for POST/GET
• JSON parsing helpers
• Configurable port

Typical URL:

http://127.0.0.1:3000/

⚠️ Quality varies

• Some are UE4-only
• Some are abandoned
• Some don’t support UE5 threading correctly

✔️ OK for local tools
❌ Risky for production

---

3️⃣ Socket-based plugins (alternative, often better)

For real-time tracking data, HTTP is often not ideal.

Better options:

• UDP Socket plugins
• OSC plugins
• WebSocket plugins

Examples:

• UE OSC (very popular, Blueprint-ready)
• WebSocket Networking Plugin
• UDP Messaging Plugin (built-in)

➡️ These avoid request/response overhead and are much smoother for streaming XY data.

---

🟢 STRONGLY RECOMMENDED FOR YOUR USE CASE

Since you are:

• Streaming 32 XY points
• At frame-rate or near real-time
• Locally
• With stable IDs
• Feeding a pool manager

🔥 Use WebSockets or UDP, not HTTP

Why HTTP is suboptimal

• Request/response overhead
• Latency spikes
• No built-in push model
• Harder to sync with Tick

---

Recommended stack (tested & sane)

OPTION A — WebSocket (best balance)

• Plugin: WebSocket Networking (Epic-supported)
• Python: websockets or websocket-client
• UE Blueprint receives continuous messages

URL:

ws://127.0.0.1:8765

---

OPTION B — OSC (fastest Blueprint workflow)

• Plugin: UE OSC
• Python: python-osc
• Extremely common in tracking / media art

Address example:

/people/32

Payload:

[id, x, y]

---

OPTION C — UDP Messaging (raw but fast)

• Built into UE
• Requires more setup
• Very low latency

---

If you must use HTTP + JSON-RPC (cleanest way)

Best-practice setup

1. Tiny C++ HTTP server
2. Expose:

   UFUNCTION(BlueprintImplementableEvent)
   void OnJsonRpc(const FString& Method, const FString& ParamsJson);

3. Route JSON-RPC → Blueprint manager

I can give you a copy-paste UE5 C++ HTTP listener in ~40 lines if you want.

---

TL;DR Recommendation Matrix

Need	Best Choice
Blueprint-only	OSC / WebSocket plugin
Low latency streaming	UDP / OSC
JSON-RPC spec	C++ HttpServer
Quick prototype	Community HTTP plugin
Production-safe	C++ HttpServer or WebSocket

---

My recommendation for your setup

Switch to WebSocket or OSC unless JSON-RPC is a hard requirement.
You’ll get smoother motion, less jitter, and simpler Blueprint graphs.

If you want:

• a Python WebSocket sender
• a Python OSC sender
• or a UE5 C++ HTTP listener template

say which one and I’ll give you a drop-in solution.

You

i am using the official HTTP Blueprints plugin

ChatGPT

Perfect — that clarifies things 👍
The official HTTP Blueprints plugin is client-only. This is the key point.

---

⚠️ Important limitation (straight answer)

HTTP Blueprints (Epic / official)
❌ Cannot listen for incoming HTTP requests
✅ Can send HTTP requests outward only

So with that plugin Unreal cannot be the HTTP server.

That means:

• Your Python script cannot POST into UE
• UE must instead poll or request data from Python
• OR you must change transport (WebSocket / OSC / UDP)
• OR add a small C++ HTTP server

---

What your options are now (ranked)

---

✅ Option 1 — Flip the direction (simplest, Blueprint-only)

Make Python the server, UE the client.

Architecture

UE5 (HTTP Blueprints) ──GET/POST──> Python HTTP server

How it works

• Python runs a tiny HTTP server
• UE periodically calls GET /positions
• Python returns latest XY data as JSON
• UE parses JSON and updates pool

Python server (minimal)

from http.server import BaseHTTPRequestHandler, HTTPServer
import json
import time

latest = {"points": [], "time": time.time()}

class Handler(BaseHTTPRequestHandler):
    def do_GET(self):
        if self.path != "/positions":
            self.send_response(404)
            self.end_headers()
            return

        self.send_response(200)
        self.send_header("Content-Type", "application/json")
        self.end_headers()
        self.wfile.write(json.dumps(latest).encode())

def run():
    HTTPServer(("127.0.0.1", 8080), Handler).serve_forever()

# elsewhere in your script:
# update `latest` every frame

UE Blueprint:

• HTTP GET → http://127.0.0.1:8080/positions
• Timer (e.g. 10–30 Hz)
• Parse JSON → update manager

✔ No C++
✔ Works with official plugin
❌ Polling, not push

---

⚠️ Option 2 — C++ HTTP server (clean but not Blueprint-only)

Use Unreal’s HttpServer module and forward to Blueprint.

✔ Push model
✔ True JSON-RPC
❌ Requires C++

---

✅ Option 3 — Switch transport (recommended for tracking)

If you can change protocol:

Best fits your use case

• WebSocket plugin
• OSC plugin
• UDP Messaging

All support push and Blueprint receive events.

---

Why Epic’s HTTP Blueprints plugin is client-only

Unreal’s HTTP stack (FHttpModule) is:

• Designed for REST APIs
• Outgoing requests only
• No socket listener
• No routing / threading guarantees

So Epic deliberately did not expose a listener in Blueprint.

---

What I recommend for your setup

Given:

• Local testing
• 32 tracked people
• Fixed pool
• Near-real-time updates
• Blueprint-heavy project

Best → Worst

1. WebSocket plugin
2. OSC plugin
3. UE polling Python HTTP server
4. C++ HttpServer
5. ❌ Forcing HTTP push into UE Blueprints

---

If you want, next I can:

• Rewrite your Python script as an HTTP server instead of client
• Give the exact Blueprint graph for polling + parsing
• Convert everything to WebSockets (Python + UE)
• Provide a drop-in C++ HTTP listener that fires Blueprint events

Just tell me which path you want to take.

You

ok, let

ChatGPT

Looks like your message got cut off 🙂

Let me know which path you want to take, and I’ll continue with concrete, copy-pasteable steps:

Pick one:

1. Polling setup
   UE (HTTP Blueprints) → GET from a Python HTTP server
   → I’ll give you:

   • Python server version of your random-walk script
   • Exact UE Blueprint nodes for polling + parsing

2. WebSocket setup (recommended)
   Push updates from Python → UE in real time
   → I’ll give you:

   • Python WebSocket sender
   • UE plugin + Blueprint receive graph

3. OSC setup (very common for tracking)
   → Python OSC sender + UE OSC Blueprint graph

4. C++ HTTP listener
   → Minimal UE5 C++ code + Blueprint event hook

Just reply with 1, 2, 3, or 4 👍

You

ok let’s do an OSC version. adapt the python script for OSC and suggest the best UE plugin

ChatGPT

[Unsupported Content]

ChatGPT

[Unsupported Content]

ChatGPT

[Unsupported Content]

ChatGPT

Here’s an OSC (UDP) version of the script that:

• simulates 32 random-walk points inside a radius
• sends them as OSC (recommended: one OSC bundle per tick, 32 messages)
• draws them live in a matplotlib debug window

And then I’ll suggest the best UE plugin options.

---

Python OSC sender + live debug draw

Install deps

pip install python-osc matplotlib

Script: send_walk_osc.py

#!/usr/bin/env python3
"""
Send 32 random-walk positions via OSC (UDP) + live debug drawing.

Default message format (per person, bundled):
  /person  <int id> <float x> <float y>

You can change the address with --address.

Usage:
  python send_walk_osc.py --ip 127.0.0.1 --port 8000 --fps 30 --radius 5
"""

import argparse
import math
import random
import time
from typing import List, Dict, Tuple

from pythonosc.udp_client import SimpleUDPClient
from pythonosc.osc_bundle_builder import OscBundleBuilder, IMMEDIATELY
from pythonosc.osc_message_builder import OscMessageBuilder

import matplotlib.pyplot as plt

def clamp_to_radius(x: float, y: float, radius: float) -> Tuple[float, float]:
    r2 = x * x + y * y
    if r2 <= radius * radius:
        return x, y
    r = math.sqrt(r2)
    s = radius / r
    return x * s, y * s

def init_positions(n: int, radius: float) -> List[Dict[str, float]]:
    pos = []
    for _ in range(n):
        u = random.random()
        theta = random.random() * 2.0 * math.pi
        r = math.sqrt(u) * radius
        pos.append({"x": r * math.cos(theta), "y": r * math.sin(theta)})
    return pos

def step_random_walk(pos: List[Dict[str, float]], radius: float, step_sigma: float) -> None:
    for p in pos:
        p["x"] += random.gauss(0.0, step_sigma)
        p["y"] += random.gauss(0.0, step_sigma)
        p["x"], p["y"] = clamp_to_radius(p["x"], p["y"], radius)

def setup_plot(radius: float):
    plt.ion()
    fig, ax = plt.subplots()
    ax.set_aspect("equal", adjustable="box")
    ax.set_xlim(-radius, radius)
    ax.set_ylim(-radius, radius)
    ax.set_title("OSC Random Walk Debug")
    ax.set_xlabel("X")
    ax.set_ylabel("Y")
    circle = plt.Circle((0, 0), radius, fill=False, linestyle="--")
    ax.add_patch(circle)
    scatter = ax.scatter([], [])
    return scatter

def update_plot(scatter, positions):
    xs = [p["x"] for p in positions]
    ys = [p["y"] for p in positions]
    scatter.set_offsets(list(zip(xs, ys)))
    plt.pause(0.001)

def send_bundle_per_person(client: SimpleUDPClient, address: str, positions, tstamp: float):
    """
    Sends one bundle containing 32 messages:
      /person id x y
    """
    bundle = OscBundleBuilder(IMMEDIATELY)
    for i, p in enumerate(positions):
        msg = OscMessageBuilder(address=address)
        msg.add_arg(int(i))          # id
        msg.add_arg(float(p["x"]))   # x
        msg.add_arg(float(p["y"]))   # y
        # optionally add timestamp:
        # msg.add_arg(float(tstamp))
        bundle.add_content(msg.build())
    client.send(bundle.build())

def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--ip", default="127.0.0.1", help="Destination IP (UE machine IP).")
    ap.add_argument("--port", type=int, default=8000, help="Destination port (UE OSC receive port).")
    ap.add_argument("--address", default="/person", help="OSC address pattern.")
    ap.add_argument("--n", type=int, default=32)
    ap.add_argument("--radius", type=float, default=5.0)
    ap.add_argument("--step", type=float, default=0.05)
    ap.add_argument("--fps", type=float, default=30.0)
    ap.add_argument("--seed", type=int, default=None)
    args = ap.parse_args()

    if args.seed is not None:
        random.seed(args.seed)

    positions = init_positions(args.n, args.radius)
    scatter = setup_plot(args.radius)

    client = SimpleUDPClient(args.ip, args.port)

    dt = 1.0 / max(args.fps, 0.1)
    while True:
        t = time.time()

        step_random_walk(positions, args.radius, args.step)
        update_plot(scatter, positions)

        send_bundle_per_person(client, args.address, positions, t)

        time.sleep(dt)

if __name__ == "__main__":
    main()

---

Best UE plugin to receive OSC in Blueprint

Option 1 (start here): Epic’s built-in “OSC” plugin

• It’s shipped with UE under Engine\Plugins\Runtime\OSC and has Blueprint APIs for send/receive. citeturn0search14turn0search3
• This is the “official” path and easiest to enable (Edit → Plugins → search OSC).

Localhost note: some users report issues in UE 5.5 receiving on 127.0.0.1; workaround is to use your machine’s IPv4 address instead of localhost. citeturn0search4

Option 2 (if you hit reliability issues): UE-OSC (monsieurgustav)

• Widely used community plugin, explicitly supports UE4/UE5 and Blueprints. citeturn0search0turn0search2
• Multiple devs report it as a “rock solid” fallback when the in-house plugin misbehaves. citeturn0search5

My recommendation:

• Try Epic OSC plugin first (because it’s built-in and maintained by Epic). citeturn0search3
• If you’re on UE 5.5+ and localhost reception is flaky, switch to IPv4 (or jump to UE-OSC).

---

Quick UE setup (works with the script)

• Enable OSC plugin
• Create an OSC Server / Receiver (Blueprint nodes depend on plugin)
• Set Receive Port = 8000
• Bind to messages with address /person
• Each message gives: id, x, y (float)

Run:

python send_walk_osc.py --ip 127.0.0.1 --port 8000 --fps 30 --radius 5

If you tell me whether you’re using Epic OSC or UE-OSC, I’ll give you the exact Blueprint node chain to:

• create/bind the server
• parse /person id x y
• feed it into your fixed pool manager (Id→Index map + timeout)

You

WARNING:root:Could not identify content type of dgram b’points\x00\x00,iff\x00\x00\x00\x00\x00\x00\x00\x17?\xfd[\xf3\xc0OA\x1f’

ChatGPT

[Unsupported Content]

ChatGPT

[Unsupported Content]

ChatGPT

That warning is coming from python-osc’s packet parser, and the giveaway is in your datagram:

b'points\x00\x00,iff\x00\x00...'

In OSC, the address pattern must start with a leading “/”. When it doesn’t (e.g. "points" instead of "/points"), python-osc often can’t recognize the packet as a valid OSC Message/Bundle and logs exactly that warning.

Fix

Use an address like:

• "/points" or "/person" (recommended)

If you’re sending one message for all points

Use:

/points

If you’re sending one message per person

Use:

/person

---

Update your Python sender (one-line fix)

If you were using --address points, change it to:

python send_walk_osc.py --address /person
# or
python send_walk_osc.py --address /points

And in code, you can harden it:

address = args.address
if not address.startswith("/"):
    address = "/" + address

---

If you still get issues: avoid bundles (some receivers are picky)

Some Unreal OSC setups/plugins handle messages more reliably than bundles. If you suspect that, send 32 individual messages instead of bundling:

for i, p in enumerate(positions):
    client.send_message("/person", [i, float(p["x"]), float(p["y"])])

(That’s slower than a bundle, but great for debugging.)

---

UE side note

Both Epic’s OSC plugin and UE-OSC conventions expect addresses starting with / as well, so matching that will keep everything consistent.

If you paste the UE receive settings (port + whether it expects bundle or message), I’ll tell you which of the two send modes (bundle vs individual) is the best match.

You

How to receive / parse the incoming bunmdle in unreal blueprints

ChatGPT

[Unsupported Content]

ChatGPT

[Unsupported Content]

ChatGPT

[Unsupported Content]

ChatGPT

If you’re using Epic’s built-in OSC plugin, the Blueprint flow for bundles is:

1. Create an OSC Server
2. Bind an event to “On OSC Bundle Received”
3. Extract messages from the bundle
4. For each message: read Address + typed args (int/float/etc.)

Epic’s docs confirm the key BP nodes: OnOsc(Bundle/Message)Received and Get (Bundles/Messages) From Bundle, plus typed “Get Integer/Float/String at Index” from an OSC Message. citeturn1view0

---

1) Create + Listen (BeginPlay)

BeginPlay →

• Create OSC Server (OSCManager)
  • Set Listen IP (often "0.0.0.0" to accept any local interface)
  • Set Port (must match Python, e.g. 8000)
• (Optional) Set Allowlist Clients Enabled = false (or add your sender IP)
• Listen

Tip: if localhost is flaky, send to your machine’s LAN IP and allowlist that IP. The plugin supports allowlisting. citeturn1view0

---

2) Bind the Bundle event

From the server object:

• Bind Event to On OSC Bundle Received

Create a Custom Event like:

• OnBundleReceived(Bundle) (parameter type: OSC Bundle)

(There’s also On OSC Message Received, but you specifically want bundles.)

---

3) Unpack the bundle into messages

Inside OnBundleReceived(Bundle):

• Get Messages From Bundle → returns Array of OSC Messages
• Get Bundles From Bundle → returns Array of OSC Bundles (nested bundles)

Handle nested bundles (recommended)

OSC bundles can contain other bundles. citeturn1view0
So do:

• For each Message in Get Messages From Bundle → parse it
• For each SubBundle in Get Bundles From Bundle → call the same function/event recursively (or loop)

---

4) Parse each OSC Message

For each Msg:

• Get OSC Address (or “Get Address from Message” depending on node naming)
  Compare to your address pattern, e.g. "/person".

Then read arguments by index with the typed getters:

For your Python bundle that sends: /person <int id> <float x> <float y>

Use:

• Get Integer at Index (Msg, Index = 0) → Id
• Get Float at Index (Msg, Index = 1) → X
• Get Float at Index (Msg, Index = 2) → Y

Those “Add/Get Integer/Float/String at Index” message functions are part of the plugin’s Blueprint API. citeturn1view0

---

Practical Blueprint shape (pseudo-graph)

BeginPlay

• Create OSC Server → Listen
• Bind Event to On OSC Bundle Received (→ OnBundleReceived)

OnBundleReceived(Bundle)

• Messages = Get Messages From Bundle(Bundle)
• ForEach(Messages):
  • Addr = Get OSC Address(Message)
  • If Addr == “/person”:
    • Id = Get Integer at Index(Message, 0)
    • X = Get Float at Index(Message, 1)
    • Y = Get Float at Index(Message, 2)
    • → call your manager: UpdatePerson(Id, X, Y)
• SubBundles = Get Bundles From Bundle(Bundle)
• ForEach(SubBundles):
  • OnBundleReceived(SubBundle) (recurse)

---

Common gotcha: bundle event fires but message array is empty

Some engine versions / senders have had bundle parsing issues (symptom: bundle received, but Get Messages From Bundle returns 0). People have hit this historically. citeturn0search0turn0search10

If you see that:

• First try sending plain messages (no bundle) from Python (32 /person messages per tick).
• Or switch to UE-OSC (monsieurgustav), which many people use specifically for robust BP OSC I/O. citeturn0search1

---

Easiest “works everywhere” alternative (if bundles fight you)

Change Python to not bundle:

for i, p in enumerate(positions):
    client.send_message("/person", [i, float(p["x"]), float(p["y"])])

Then in UE:

• Bind On OSC Message Received
• Parse exactly the same way (address + typed args)
• No bundle unpacking required

---

If you tell me which plugin you’re on (Epic OSC vs UE-OSC) and your UE version, I’ll map this to the exact node names you’ll see in the palette (they differ slightly).

You

LogOSC: Warning: Outer object not set. OSCServer may be garbage collected if not referenced. LogOSC: Display: OSCServer ‘OSCServer_AoEgzE1ynEdl4O-Uyzqceg’ started LogOSC: Error: OSCServer currently ‘OSCServer_AoEgzE1ynEdl4O-Uyzqceg’ currently listening to endpoint ‘192.168.1.72’. Failed to start new service prior to calling stop.

and then crash:

Unhandled Exception: EXCEPTION_ACCESS_VIOLATION reading address 0x0000000000000000

0x0000013b7f0fe6bc UnrealEditor-OSC.dll!UnknownFunction [] 0x0000013b7f1041b6 UnrealEditor-OSC.dll!UnknownFunction [] 0x0000013b7f0feaad UnrealEditor-OSC.dll!UnknownFunction [] 0x00007ffbe8338c3e UnrealEditor-Core.dll!UnknownFunction [] 0x00007ffbe837b4ec UnrealEditor-Core.dll!UnknownFunction [] 0x00007ff724b08ce4 UnrealEditor.exe!UnknownFunction [] 0x00007ff724b257ac UnrealEditor.exe!UnknownFunction [] 0x00007ff724b2589a UnrealEditor.exe!UnknownFunction [] 0x00007ff724b29114 UnrealEditor.exe!UnknownFunction [] 0x00007ff724b3bd04 UnrealEditor.exe!UnknownFunction [] 0x00007ff724b3f0ba UnrealEditor.exe!UnknownFunction [] 0x00007ffc23b87374 KERNEL32.DLL!UnknownFunction []

ChatGPT

[Unsupported Content]

ChatGPT

[Unsupported Content]

ChatGPT

[Unsupported Content]

ChatGPT

Those logs point to two separate problems that together can absolutely lead to the crash you’re seeing:

1. Your OSCServer UObject is being created without a safe “Outer” / without a strong reference, so it can be GC’d or end up in a bad lifetime state (“Outer object not set…”). citeturn0search0turn0search2
2. You are starting a new OSC service while the previous one is still listening (“Failed to start new service prior to calling stop.”). That typically happens when you call Create/Start more than once (BeginPlay firing twice, Construction Script, re-initialization, or pressing Play in PIE with multiple worlds). citeturn0search2

Below is the most robust Blueprint pattern to stop both issues.

---

Fix the lifetime/GC warning (Outer + strong reference)

Do this in Blueprints

• Create a member variable: OSCServerRef (type: OSCServer)
• When you call Create OSC Server, plug:
  • Outer = Self (or Get Game Instance is also fine)
  • Return Value → Set OSCServerRef immediately

Why: storing the return value in a BP member variable prevents GC from nuking the server object (this exact advice is repeated by users who had the warning). citeturn0search12turn0search0

Do NOT keep the return value only in a local variable / wire chain.

---

Fix the “already listening” error (don’t start twice)

That error means you are attempting to bind to the same endpoint again while it’s still active. citeturn0search2

Common causes

• You put Create/Start in Construction Script (bad: runs a lot)
• You call it from Tick or a repeating Timer
• PIE launches multiple instances / you re-enter the level and re-run BeginPlay
• You’re creating a second OSC server without stopping the first

Blueprint strategy

Only create/start once, and explicitly stop on shutdown.

On BeginPlay:

1. Branch (IsValid(OSCServerRef))

   • False → create & start
   • True → do nothing (already set up)

2. Create OSC Server (Outer = Self)

3. Set OSCServerRef

4. OSCServerRef -> Start Listening (or equivalent node)

On EndPlay (Event EndPlay):

• Branch (IsValid(OSCServerRef))
  • OSCServerRef -> Stop Listening
  • (optional) OSCServerRef = None

This prevents the “start new service prior to calling stop” path.

---

Bind address tip (avoid binding to a specific NIC while testing)

Your log says it’s listening on a specific IP: 192.168.1.72.

For local/dev, bind to:

• Listen Address: 0.0.0.0 (all interfaces)

Then from Python you can send to either:

• 127.0.0.1 (same machine), or
• 192.168.1.72 (LAN)

Binding to 0.0.0.0 avoids edge cases when the active adapter changes.

---

Receiving/parsing bundles safely in Blueprint

Once the server is stable:

1. Bind On OSC Bundle Received event (on OSCServerRef)
2. In the handler:
   • Get Messages From Bundle → ForEach → parse each message
   • Get Bundles From Bundle → ForEach → parse recursively (nested bundles are allowed) citeturn0search0

For your payload /person (id int, x float, y float):

• Address == "/person"
• Arg0: Get Int
• Arg1: Get Float
• Arg2: Get Float

---

If you still crash (realistic possibility)

Some UE versions have been flaky with bundle handling. If:

• bundle callback fires, but message arrays are weird/empty, or
• you still hit OSC.dll crashes

Two pragmatic workarounds:

1. Stop using bundles: send 32 individual /person messages per tick (UE receives via “On OSC Message Received”). This is the most compatibility-friendly mode.
2. Switch to UE-OSC (monsieurgustav) (community plugin). Many teams use it specifically because it’s been reliable for OSC I/O in Blueprint-heavy pipelines. citeturn0search4turn0search12

---

Quick checklist (will stop 90% of these crashes)

• ✅ Create/Start only in BeginPlay (not Construction Script, not Tick)
• ✅ Store server in a BP member variable
• ✅ Provide Outer = Self / GameInstance
• ✅ Bind 0.0.0.0 during dev
• ✅ Stop listening on EndPlay
• ✅ Don’t create a “new” server if one already exists

---

If you paste (or describe) where you’re calling Create OSC Server (BeginPlay vs Construction Script vs somewhere else) and whether you’re in PIE with multiple clients, I can tell you exactly why it’s starting twice in your project and how to guard it with one Branch node.

You

Whats the right way to parse for this:

def send_bundle_per_person(client: SimpleUDPClient, address: str, positions, tstamp: float): """ Sends one bundle containing 32 messages: /person id x y """ bundle = OscBundleBuilder(IMMEDIATELY) for i, p in enumerate(positions): msg = OscMessageBuilder(address=address) msg.add_arg(int(i)) # id msg.add_arg(float(p[“x”])) # x msg.add_arg(float(p[“y”])) # y # optionally add timestamp: # msg.add_arg(float(tstamp)) bundle.add_content(msg.build()) client.send(bundle.build())

ChatGPT

[Unsupported Content]

ChatGPT

[Unsupported Content]

ChatGPT

Given that Python is sending one OSC bundle with 32 OSC messages, and each message is:

/person   [ int id, float x, float y ]

…the “right way” in Unreal Blueprints is:

1. Receive the bundle
2. Extract the messages array
3. For each message:
   • check Address == “/person”
   • read args by index with typed getters
4. Pass (Id, X, Y) into your runtime tracker/pool manager

---

Blueprint parsing flow (Epic OSC plugin)

A) Bind the bundle event

• On BeginPlay:
  • Create OSC Server (store in a variable so it doesn’t get GC’d)
  • Start Listening
  • Bind Event to “On OSC Bundle Received”

Your event should look like:

• Event OnOscBundleReceived(Bundle)

B) Inside OnOscBundleReceived(Bundle)

1. Get Messages From Bundle

• Node: Get Messages From Bundle
• Input: Bundle
• Output: Messages (Array of OSC Message)

2. ForEachLoop over Messages

Inside loop for each Msg:

3. Get Address

• Node: Get OSC Address (or “Get Address from OSC Message”)
• If Address == "/person" then parse args.

4. Read args with typed getters Because you sent int, float, float, do:

• Id = Get Int (Msg, Index 0)
• X = Get Float (Msg, Index 1)
• Y = Get Float (Msg, Index 2)

5. Call your manager/pool update function:

• UpdatePerson(Id, X, Y) (your own function)

That’s the correct parse.

---

Nested bundles (optional but “correct”)

OSC bundles can contain other bundles. So if you want to be fully robust:

• SubBundles = Get Bundles From Bundle(Bundle)
• ForEach SubBundle: call the same parsing function/event again on that sub-bundle.

Your Python bundle as written is flat, so you can ignore this unless you change senders later.

---

Common gotchas specific to your sender

1) Address must match exactly

Your Python passes address in:

msg = OscMessageBuilder(address=address)

Make sure you’re sending "/person" (leading slash). Unreal comparisons should also use "/person".

2) Types must match getters

You are adding:

msg.add_arg(int(i))        # int32
msg.add_arg(float(x))      # float32
msg.add_arg(float(y))      # float32

So in UE:

• Index 0 → Int
• Index 1 → Float
• Index 2 → Float

If you ever enable timestamp, then:

• Index 3 → Float (time)

---

If bundle parsing is unreliable in your UE version

Some setups behave better with non-bundled messages. The parsing becomes even simpler:

Python:

client.send_message("/person", [i, float(x), float(y)])

UE:

• Bind On OSC Message Received
• Parse exactly the same way (address + args)

If your bundle event fires but messages don’t unpack correctly, this is the quickest workaround.

---

If you tell me whether you’re using Epic OSC nodes named “Get OSC Address / Get Float at Index” etc. (or share a screenshot of your node palette), I can translate this into the exact node names you have in your editor.