What StreamBridge is - and isn't

StreamBridge consists of two parts: a Unity Editor package and a DCC plugin (Blender or 3ds Max). They open a persistent TCP connection and stream scene previews from your DCC into the Unity Editor.

What's actually streamed

• Meshes - vertices, indices, normals, UV0, vertex colors, multi-submesh layouts, smooth/flat shading
• Skinned meshes & animation - bone weights (up to 4 influences/vertex), skeletons, per-frame bone transforms
• Transforms - position, rotation, scale, with coordinate-system conversion
• Hierarchy - parent/child relationships, automatically mirrored.
• Visibility - optional hide/show sync
• Material slot routing - per-submesh material names, matched to existing Unity materials by name
• Object lifecycle - add, delete, rename are tracked

Requirements

Software

Operating systems

Render pipelines (Unity)

StreamBridge is pipeline-agnostic - synced objects use a standard MeshFilter + MeshRenderer, so the same workflow applies to all three pipelines.

How it works

StreamBridge uses a client-server model over TCP. Unity acts as the server; the DCC plugin is the client.

┌─────────────────┐    TCP · port 8190        ┌────────────────┐
│  Blender /      │  ────────────────────►    │  Unity Editor  │
│  3ds Max        │   mesh / skin / xforms    │  (server)      │
│  (client)       │                           │                │
└─────────────────┘                           └────────────────┘

• Wire format: FlatBuffers, optionally Zstd-compressed.
• Default port: 8190, bound to 127.0.0.1 only.
• LAN / cross-machine: toggle Listen on all interfaces on the Unity side, then connect to that machine's IP from the DCC.
• Update model: the DCC plugin observes its update graph (Blender depsgraph / 3ds Max change callbacks) and pushes deltas. Only what changed is sent.
• Coordinate conversion: Blender (Z-up, right-handed) and 3ds Max (Z-up, right-handed) are converted to Unity (Y-up, left-handed) automatically. A toggle lets you disable this if your scene is already in Unity-space.

Unity

The Unity package hosts the StreamBridge server and creates GameObjects from incoming data.

Install the package

StreamBridge is distributed through the Unity Asset Store.

StreamBridge window

The window has three areas: connection status, server settings, and a log.

Live preview & export

This is the single most important thing to understand about StreamBridge:

Recommended workflow

Material slot routing

StreamBridge does not send PBR data. What it sends per submesh is the material name. Unity looks for a material asset in your project with that name and assigns it to the slot. If no match is found, the slot falls back to the Default Material assigned on the StreamBridge Server GameObject (Inspector).

• Name your materials in the DCC to match the Unity asset names you've already authored.
• Your URP / HDRP shader graphs stay intact - only the assignment changes per update.

Receiving DCC exports in Unity

When you trigger a tagged export from the DCC, StreamBridge ships the file (FBX, OBJ, etc.) over the same connection and Unity writes it into your project. By default the file lands in Assets/StreamBridge/ and is reimported by Unity's standard FBX importer. You can take over that flow in two ways: a one-shot C# event subscription, or a reusable StreamBridgeImportHandler ScriptableObject routed via Project Settings → StreamBridge.

Option A - Subscribe to the file-transfer event

The StreamBridgeServer component exposes an event you can subscribe to from anywhere in your editor code. Useful for prototyping, logging, or one-off post-processing.

using UnityEngine;
using UnityEditor;
using StreamBridge.Unity;

[InitializeOnLoad]
static class StreamBridgeExportHook
{
    static StreamBridgeExportHook()
    {
        var server = Object.FindFirstObjectByType<StreamBridgeServer>();
        if (server == null) return;

        // fires after the file is written + AssetDatabase.ImportAsset()
        server.OnFileTransferReceived += (fileName, assetPath) =>
        {
            Debug.Log($"[StreamBridge] received {fileName} → {assetPath}");

            // e.g. drop the imported prefab into a scene root, run your own pass, etc.
            var asset = AssetDatabase.LoadAssetAtPath<GameObject>(assetPath);
            if (asset != null) PrefabUtility.InstantiatePrefab(asset);
        };
    }
}

Option B - Define an import handler

Subclass StreamBridgeImportHandler to control where files land and what happens after import. Assign it once under Project Settings → StreamBridge - either as the project default or mapped to a specific export tag from the DCC.

using UnityEngine;
using UnityEditor;
using StreamBridge.Unity;

[CreateAssetMenu(menuName = "StreamBridge/Buildings Import Handler")]
public class BuildingsImportHandler : StreamBridgeImportHandler
{
    // Tell StreamBridge where to save the incoming file.
    public override string GetTargetPath(string fileName, string objectName)
    {
        return $"Assets/Buildings/{objectName}/{fileName}";
    }

    // Called after the file has been written and reimported by Unity.
    public override void OnPostImport(string assetPath, string tag, string objectName)
    {
        // 1) Tweak ModelImporter settings on the fresh import
        var importer = AssetImporter.GetAtPath(assetPath) as ModelImporter;
        if (importer != null)
        {
            importer.importLights = false;
            importer.importCameras = false;
            importer.SaveAndReimport();
        }

        // 2) Hand off to your existing project pipeline
        MyStudio.AssetPipeline.RegisterBuilding(assetPath, objectName);
    }
}

1. Save the script anywhere under Assets/.
2. Right-click in the Project window → Create → StreamBridge → Buildings Import Handler. A .asset appears.
3. Open Project Settings → StreamBridge. Either set it as the Default Import Handler, or add a tagged entry mapping (for example) the tag Buildings to this asset.
4. In the DCC, export with that tag - the file routes through your handler, hits your own importer pipeline, and Unity sees a fully-processed asset.

Render pipelines

No pipeline-specific setup is required. Synced GameObjects use standard MeshFilter + MeshRenderer / SkinnedMeshRenderer components and pick up whichever pipeline is active in your project. When you first create the server, StreamBridge auto-generates a default material using the best shader for your project (URP Lit → HDRP Lit → Standard fallback) and assigns it to the server's Default Material field automatically.

Settings reference

These settings live on the StreamBridge Server GameObject's Inspector (created in your scene by Window → StreamBridge → Create Server). The Window → StreamBridge editor panel itself only shows status and Start/Stop/Clear buttons.

Blender

The StreamBridge add-on for Blender ships as a standard .zip add-on. It supports Blender 4.2+ through 5.0+ on Windows and macOS.

Install the add-on

The Blender add-on is bundled with the Unity package - there's no separate download. The Unity-side installer copies the add-on into Blender's user folder and picks the right native module for your Blender version automatically.

[StreamBridge] Addon registered successfully

Panel overview

Workflow

What's synced from Blender

Limitations

• Materials - only the material name is sent. No Principled BSDF parameters, no textures, no shader nodes.
• Shape keys / blend shapes - not synced.
• UV1 (lightmap UVs) - not synced; protocol has a slot but the exporter doesn't populate it yet.
• Particle systems - only baked particle meshes are seen.
• Modifiers - sent at the current viewport-evaluated level (e.g. Subdivision Surface uses your viewport level, not render level).
• Lights / cameras - only their transforms sync. Color, intensity, type, FOV, clipping etc. do not.

3ds Max

The StreamBridge plugin for 3ds Max mirrors the Blender feature set. Supports 3ds Max 2023+ on Windows.

Install the plugin

The 3ds Max plugin is bundled with the Unity package - there's no separate installer download. The Unity-side installer copies the plugin scripts into your 3ds Max user folder.

Workflow

What's synced from 3ds Max

Limitations

• Materials - only the material name is sent. Physical Material / Standard / V-Ray / Corona / Arnold parameters and texture maps are not synced.
• Forest Pack / RailClone - scattered instances appear as their baked output meshes only.
• XRef Scenes - XRef'd objects must be merged into the main scene before they can be synced.
• Lights / cameras - transforms only. IES profiles, intensity, color, FOV, etc. do not transfer.
• Modifiers - sent as the evaluated mesh at the current stack output.

Network setup

StreamBridge supports same-machine, LAN, and VPN setups.

Same machine (default)

No configuration. Host localhost, port 8190. The Unity server binds to 127.0.0.1 only, so the port is not exposed to the rest of your network - safe by default.

Different machines (LAN)

VPN / remote

Works the same way over a VPN - use the Unity machine's VPN-assigned IP.

Troubleshooting

"Cannot connect" / connection refused

• Make sure you clicked Start Server in Unity first.
• Unity must be in Edit Mode - the server pauses in Play Mode.
• Host and port in the DCC must match Unity. Default is localhost / 8190.
• Connecting from another machine? Confirm Listen on all interfaces is on and the firewall allows TCP 8190 inbound.

Sync is slow / DCC is laggy

• Switch Sync Mode from Responsive to Performance and raise the batch interval (start at 500 ms, increase if needed).
• Hide objects you're not actively editing - they're skipped from sync.
• Very high-poly meshes (above a few million verts) will be noticeable on every edit. Iterate at a lower subdivision level and crank it up before exporting.

Materials look wrong in Unity

Material assignment is by name match. If the slot uses the Default Material:

• Make sure a Unity material with the same name as the DCC material slot exists somewhere in the project.
• When you first create the server via Window → StreamBridge → Create Server, StreamBridge auto-generates Assets/StreamBridge/DefaultMaterial.mat using the best shader for your active pipeline (URP Lit → HDRP Lit → Standard fallback) and assigns it to the Default Material field on the StreamBridge Server GameObject's Inspector.
• If you've switched render pipelines since the server was created, the auto-generated material may now use the wrong shader. Either swap its shader, delete Assets/StreamBridge/DefaultMaterial.mat and re-create the server, or point the Default Material field at any material of your own.
• StreamBridge does not transfer PBR values, textures, or shader nodes - that's expected behaviour, not a bug.

Objects appear at the wrong scale

• In Blender, apply object scale (Ctrl+A → Scale) before syncing.
• In 3ds Max, reset XForm if scale has been non-uniformly transformed.
• Make sure your DCC scene units roughly match your Unity scene units - Unity assumes 1 unit = 1 metre.

3ds Max installer fails

• Close every 3ds Max instance before running the installer.
• Antivirus software occasionally blocks plugin writes - temporarily exclude the install folder if needed.

Colors look different in Unity vs. the exported FBX

If vertex colors or material tints look correct in your DCC and in the FBX you exported, but the live preview from StreamBridge looks washed-out, too dark, or shifted in the opposite direction - this is most likely an open bug with sRGB ↔ linear color-space conversion on the live-sync path. Exported files go through Unity's importer, which handles the conversion; the live stream path doesn't always match that behaviour.

Still stuck?

Pop into the StreamBridge Discord first - other users (and I) hang out there, and most setup hiccups get sorted in a few messages without needing a ticket.

If Discord doesn't crack it, open a bug report with: Unity version, DCC version, OS, what you did, what happened, and the contents of the StreamBridge log panel.

FAQ

Is it a one-time purchase or a subscription?

One-time purchase on the Unity Asset Store. All future updates within the major version are included.

Does it work in Play Mode?

No. The server only runs in Edit Mode. Entering Play Mode pauses the sync; exiting resumes it.

Can multiple artists connect at once?

One DCC client per Unity instance at a time.

Will my custom shaders work?

Yes - StreamBridge doesn't touch shaders. It assigns Unity materials to mesh slots by name, so whatever shader those materials use stays in place.

Does it sync textures or PBR maps?

No. Only the material name is sent. Authoring the look stays on the Unity side; iteration on geometry/skinning stays on the DCC side.

Does it work on Linux?

No. Windows and macOS only.

Changelog

v1.0.0 - May 2026

• Initial public release.
• Blender 4.2+ support (Python 3.11 / 3.12 / 3.13 modules).
• 3ds Max 2023+ support.
• Unity 6 (6000.0+) - render-pipeline-agnostic.
• Mesh sync: vertices, normals, UV0, vertex colors, multi-submesh.
• Skinned-mesh and animation streaming.
• Object lifecycle (add / delete / rename).
• Material slot routing by name match.
• Responsive and Performance sync modes.
• "Listen on all interfaces" toggle for cross-machine setups.