Loom

Loom’s reach is the point. The live link carries nearly your whole scene, and the authoring state around it, and everything here lands in whichever editor you open.

• 9 Blender object types: mesh, curve, text, surface, metaball, armature, light, camera, empty
• All 1 to 8 UV channels plus RGBA vertex colours, with 32-bit indices for big meshes
• Armatures and shape keys, with live pose and blendshape weights
• 4 light types, perspective and orthographic cameras with depth of field
• World HDRI and fog
• Collection, geometry-node and particle instancing, with linked-duplicate dedup
• Prefab-reference placement: a key on an object or on its mesh data spawns your real prefab or Blueprint from a registry in either engine
• Greybox → final replacement, driven from Blender or from either editor
• A Tracked Objects list that says exactly what is streaming, with Exclude and Include
• Boolean cutters and SNAP_ / SOCKET_ marker empties skipped automatically
• A four-page “How replacement works” explainer, the same pages in all three applications
• Principled materials with content-deduped textures
• 20+ shader nodes transpiled to real URP shaders, all 19 Mix blend modes
• Live colliders, LOD groups, and game-ready layer, tag and static routing
• Attach points: sockets and plugs with a shared tag, snapped in Blender and carried to both engines, and generators that make collider proxies and LOD chains for you
• Rigid bodies: Blender’s Rigid Body settings become a real physics body in either engine, measured against Blender’s own simulation
• A tile test that places copies of a kit piece around it to check its seams under the engine’s lighting, left out of every bake
• A one-command headless bake, blender -c loom_bake, from a .blend to a prefab or Blueprint for CI, with no editors open

Block a level out in Blender, then swap the stand-ins for your real prefabs or Blueprints. Assign from Set Prefab Key… in the Blender N-panel, or from REPLACE GREYBOX in the Unity or Unreal window. Every assignment is written into the .blend and Ctrl+Z there undoes it, so a level half-replaced on Friday is the same level on Monday, after both applications have restarted. The editor asks Blender to write; nothing is kept in a session-only map.

Loom is a Blender producer with two first-class consumers. Both parse the same bytes, wire protocol v40, and the same golden fixtures, so every capability lands in either editor. Unreal just uses the idiomatic target for each Unity concept.

Most live bridges stop at geometry. Loom transpiles Blender shader node graphs into real, compiled shaders, a URP .shader in Unity and ported HLSL inside a LoomLit material in Unreal, not a flat approximation. The procedural nodes are ported from Blender 5.1’s own source, so a generated shader reproduces Blender’s look rather than guessing at it.

• Real compiled shaders, not a preview hack. Generated shaders support Forward and Deferred, shadows, depth prepass, and SSAO.
• Faithful fallback. An unsupported graph degrades to an accurate Principled material, and an offline pre-flight scan names the node before you ever connect.
• Bake to texture when a graph is out of reach. Opt in per material and Cycles bakes it to maps that stream as ordinary textures.
• Pin your own material. Override any Blender material or object with your own engine material, and it survives every resync.
• Stylized and toon materials keep their textures. A non-Principled graph has no PBR factors to translate, so rather than fake the look Loom transfers the material’s named textures for your own toon shader to use.
• Textures done right. Content-deduped and packed into the engine map slots (metallic and gloss, normal and strength, occlusion), with HDR preserved.

Loom sends GPU-ready bytes and only what changed. Nothing is serialized to text or written to disk on the sync path.

• Direct binary link. Raw float32 and uint32 buffers go straight from Blender’s numpy into the engine. No JSON, no relay, no disk.
• Only what changed. Moving an object sends a 40-byte transform packet. Sculpting and animating stream positions only, never the whole scene.
• Non-blocking. Socket I/O runs on a worker thread, so neither editor stutters.
• Self-healing. It survives script recompiles and disconnects, and reconnecting re-syncs the whole scene.

Breadth only matters if the result is correct. Loom is built so the look matches and stays matched.

• Ported from source, not eyeballed. Procedural textures and all 19 Mix modes are translated from Blender 5.1’s own shader source, down to the exact Perlin and PCG hash.
• One wire, three implementations, proven byte-identical. The Python producer and the C# and C++ consumers are checked against the same golden wire-byte fixtures.
• Tested end to end with editors closed. Headless Blender and Unity suites drive the real serialize, socket, rebuild and bake path in CI, including a full .blend to .prefab build.

The live preview is not a dead end. It graduates into real project assets.

• Scope. A first connect streams just your selection, with a live count of what will sync and what is excluded, so you never dump a complex scene by surprise. Whole scene and Collection are one click away.
• The tracked set. Under Selected only, selecting an object tracks it: it keeps streaming while deselected, survives a reconnect or a Blender relaunch, and leaves the editor only when you Untrack it. Exclude and Include work in any scope. With Track the whole model, on by default, a click takes the object’s whole parent tree, so clicking a character’s hair sends the whole character, and Exclude leaves one piece behind. When nothing would sync yet, Blender asks What do you want to send? with one-click whole-scene and collection buttons.
• Tracked Objects. A list of what is actually streaming, filtered by Streaming, Excluded, Blockouts or All, with per-row select, freeze, exclude and untrack. The counts say how many; this says which, which is the question you actually ask when the number looks wrong.
• Scaffolding stays out. Boolean cutters and SNAP_ / SOCKET_ marker empties are skipped automatically, and the per-object status names the pref that undoes the skip.
• One-way by default, with hand-edit protection. A nudge to a synced object in the engine is paused, not overwritten, until you release it.
• Opt-in two-way edits, on Blender’s terms. Push transforms and selection back, or demand-bake an unsupported graph material to maps from the engine. Accept property edits from the editor is a Blender pref, only Loom’s own authoring properties are ever written, never geometry, and each write pushes an undo step.
• Name where it lands. Synced objects sit under a Root object in Unity or a Root actor in Unreal, and the whole tree can go to another open, saved Target scene or a loaded Target level.
• Per-object state at a glance. A status dot on Unity’s Hierarchy row and a Loom.Paused tag on the Unreal actor. Right-click the dot in Unity for Pause Loom sync (protect from Blender) or Resume Loom sync, without opening the window; in Unreal, select the actors and press Pause selected in the Loom tab.
• Colour blocking. Pin one Global Material and turn on Override all synced materials to see the level rather than the materials. Prefab references keep their own, and a bake always uses the real ones.
• Sync during Play mode. Live edits stream into a running session and survive the domain reload, with a clear in-play indicator.
• Stand-ins you won’t lose by surprise. The objects Loom places are live previews, not saved with the scene, and after a disconnect both editors say so in a banner, with Bake Scene…, Clear Synced Objects and Keep for now.
• English and Korean. The Blender add-on, both editor windows and the in-app guide speak both, and the editors follow Blender’s language across the link.
• Pause streaming. Pause, beside Disconnect, keeps the connection but holds every change, and Resume sends what changed. Both editors say that Blender has paused, so a still viewport is never a mystery.
• Zero-config on localhost, with Connecting, Reconnecting and Waiting for the editor… status and a live HUD of throughput, queue depth, coalesced frames, and the heaviest object.

• Blender 5.0 or newer (tested on 5.0, 5.1 and 5.2)
• Unity 2021.3 LTS or newer, developed against Unity 6
• Unreal Engine 5.6 (developed, built and tested against 5.6; other 5.x untested), a C++ project, Win64
• Render pipeline: URP in Unity (the generated shaders require it), and the standard UE Material in Unreal, a per-material Custom-HLSL master in an editor build
• Editor to editor on the same machine over loopback TCP (default 127.0.0.1:8787)
• Wire protocol v40, the same bytes on both consumers