StreamBridge
Edit in Blender. It's already in Unity.
StreamBridge is a live mesh-sync system I designed, built, and shipped solo: a C++ networking core with a custom binary protocol, a native Unity plugin, and a Blender add-on - so artists see their changes in-engine the moment they make them.
Wirewolf Design is the two-person studio I co-founded in 2026 to build game-oriented tools. StreamBridge is one of its products - designed, built and shipped solo: protocol design, C++ core, Unity plugin, Blender add-on, build system and distribution.
The traditional DCC-to-engine loop is slow by design: export an FBX, switch to Unity, import, wait, check, repeat. StreamBridge replaces that loop with a persistent TCP link. The Unity editor runs a native server; Blender and 3ds Max push mesh, transform, hierarchy, and skeleton updates as you work, and they appear in the scene in real time - geometry, UVs, vertex colors, materials-by-submesh, and skinned meshes with live bone transforms.
re-import → fix materials →
repeat
Everything between the two applications is built from scratch in C++: a compact 16-byte wire header with CRC32 integrity checks, FlatBuffers-serialized payloads with optional Zstd compression, and a threading model designed around one hard constraint - game engines only allow scene changes on the main thread. A dedicated network thread receives and validates messages into a bounded queue; the engine drains it once per frame. The same core is consumed from three languages: C# in Unity through a C API, and Python in Blender through a pybind11 module that handles the GIL correctly in both directions.
The unglamorous parts got the most care: automatic conversion between Blender's Z-up right-handed space and Unity's Y-up left-handed space (including triangle winding and inverse bind poses), defensive validation of every byte that arrives over the network, and a build that ships native modules for three Blender Python versions across Windows and macOS.
#pragma pack(push, 1) // no padding: layout == wire bytes
struct MessageHeader {
uint32_t magic; // 0x53425247 'SBRG'
uint16_t version;
uint8_t messageType;
uint8_t compressionType;
uint32_t payloadSize;
uint32_t checksum; // CRC32 of the payload
};
#pragma pack(pop)
static_assert(sizeof(MessageHeader) == 16, "MessageHeader must be 16 bytes");POLLS PER FRAME
16-byte packed header (magic · version · type · compression · size · CRC32) enforced by a compile-time static_assert; FlatBuffers payloads, optional Zstd, versioned for forward compatibility.
Network thread → mutex-guarded bounded queue → per-frame Poll() on the engine's main thread. Backpressure caps (message count and total bytes) mean a runaway sender gets disconnected instead of eating memory.
The C++ library is consumed from C# via a hand-written C API (opaque handles, explicit ownership, crash containment at the DLL boundary) and from Python via pybind11 (GIL released around blocking calls, reacquired for callbacks).
Z-up right-handed to Y-up left-handed done properly: axis swap, triangle-winding flip for the handedness change, quaternion component remap, and change-of-basis on inverse bind pose matrices.
Skeleton streaming with per-vertex bone weights (up to 4 influences), so rigged characters deform in Unity while being posed in the DCC.
Payload bounds checked before allocation, decompression output capped (zip-bomb guard), FlatBuffers verifier plus semantic checks (triangle indices validated against vertex count), and loopback-only binding by default.
Launched on the Unity Asset Store in 2026 under the Wirewolf Design brand, for Windows and macOS - with a build that ships native modules for three Blender Python versions.