What syncs

Loom’s reach is the point. The live link carries nearly your whole scene, 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
• 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

Two engines, one link

Loom is a Blender producer with two first-class consumers. The same wire drives both, so every capability lands in either editor. Unreal just uses the idiomatic target for each Unity concept.

Materials & shaders

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.
• Pin your own material. Override any Blender material or object with your own engine material, and it survives every resync.
• Textures done right. Content-deduped and packed into the engine map slots (metallic and gloss, normal and strength, occlusion), with HDR preserved.

Why it is fast

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.

Pixel-faithful, provably

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.

Preview to production

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

Control, safety & feel

• Selective sync. Stream a single collection or just the selection, and freeze a finished object so it stops updating while you iterate elsewhere.
• 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. Push transforms and selection back to Blender, or demand-bake an unsupported graph material to maps from the engine.
• Sync during Play mode. Live edits stream into a running session and survive the domain reload, with a clear in-play indicator.
• Zero-config on localhost, with a live HUD of throughput, queue depth, coalesced frames, and the heaviest object.

Compatibility

• Blender 4.2 or newer (developed against 5.1)
• Unity 2022.3 LTS or newer with the Universal Render Pipeline (URP)
• Unreal Engine 5.4 to 5.8, a C++ project, Win64
• Editor to editor on the same machine over loopback TCP (default 127.0.0.1:8787)