Machina is a node-based procedural system with a core written in Rust. Model, scatter, fracture, erode, build roads and simulate in a graph — then run that same graph wherever the core runs. Unity is a first-class host: the editor, and every player build.
What it is
Most procedural tooling bakes to a mesh and stops at the editor door. Machina's graph is data, and the thing that evaluates it is a portable engine — so the graph keeps working after you press build.
A graph serializes, diffs and version-controls like any other asset, and loads at runtime like any other asset. Evaluation is incremental and keyed by content rather than by dirty flags: change a parameter and only what actually depends on it re-cooks — and an edit that changes nothing cooks nothing at all.
One engine, one stable C interface, every host. Unity is the first host and gets the full integration — but the same core runs inside a native application, on a server, or in the browser, and a graph authored in one runs unchanged in the others. Geometry is shared with the host in place, never copied across a boundary.
The same graph produces the same bytes — on every machine, on every platform, on every run. Caches can be trusted, builds are reproducible, and a simulation replays exactly rather than approximately.
Unity — a first-class host
A .machina graph is a plain JSON file with a ScriptedImporter — it gets a GUID on
its .meta, diffs in git, and reimports when anything edits it. Drop a
MachinaController on a GameObject, point it at the graph, and the cook runs in the
editor and in play mode alike; a MachinaRenderer beside it draws the result through
the scriptable render pipeline. Nothing is baked to a mesh asset unless you ask.
Graphs cook on a background thread, so a heavy network never stalls the editor or the frame. Only what changed is recomputed, an unchanged result costs nothing, and edits — undo included — are picked up the way Unity expects.
A node editor window, scene-view handles for curves, and per-node wireframe overlays that show exactly what the renderer sees. Every node's parameters, ranges, defaults and menus come from the engine itself, so the inspector is always right.
MachinaInputBinding feeds named graph inputs from your scene: MeshFilters,
Textures, Materials, Transforms, and plain floats, ints, colours and strings. Meshes and
skeletons enter through UnityMeshInput and SkeletonInput.
MachinaInput turns keys and the pointer into channels, so a graph can be
interactive — a crowd that walks where you click.
A graph declares as many outputs as it likes. MachinaLayerBinder materialises them:
world-space layers become child renderers, data layers become script-visible flows with a
changed event, and screen-space outputs draw HUD geometry. Packed instances render as
instances — RenderMeshInstanced by default, indirect with structured buffers
when you opt in.
MachinaTime is the playbar: one global frame drives every controller, each with its own offset and scale, the way a DOP network offsets time. Simulations step play-every-frame and restore from checkpoints when you scrub, with memory bounded by a horizon — a session can run for hours.
An engine update swaps in while Unity stays open — no restart, no lost scene. A version handshake means a mismatched engine is refused outright rather than running degraded.
The library
The vocabulary is Houdini's — a technical artist is productive on day one — and every node is described by the engine itself, so parameters, ranges, defaults and menus are always in step with what the core does.
Primitives, curves, text and points to start from — or real map data.
Change what the mesh is — subdivide, remesh, reduce, bevel, boolean, clip, sweep, carve and resample.
Move points without touching topology — bend, taper, lattice, project onto terrain, smooth, and noise.
Instance geometry onto points as packed prims, fracture it, cluster the pieces and move them as units.
Curves become a road network — crossings stitched, grades limited, junctions and roundabouts built, terrain conformed, furniture deformed along the path.
The data layer — create, promote, transfer, map and visualize per-element values; build groups; lay out UVs and assign materials.
Heightfields as a first-class type — thermal and hydraulic erosion, masking, terracing, flattening under roads with a batter ramp, and mesh conversion.
Implicit surfaces and voxels — blend, boolean and voxelize signed distance fields, then mesh them back out.
2D layout into 3D massing — split a block into lots, extrude floors, cap roofs, offset outlines.
Solvers, constraint sets and forces as ordinary nodes — grains, cloth, inflatables, rigid bodies and glued fracture.
Skeletons in, posed geometry out — capture, bone deformation, rig posing, and ragdolls configured from pieces.
An escape hatch with no ceiling — a per-element snippet compiled to bytecode, over geometry or over volumes.
Graph plumbing — switches, loops, subgraphs with promoted parameters, tables, and bridges to Unity meshes and other graphs.
Faber
Faber is Machina's wrangle: a small C-like snippet that runs once for every point, vertex or primitive — or once for the whole geometry when you need a single answer.
A snippet compiles to a compact register-based bytecode — fixed-width instructions with attribute access specialized down to a bank and a slot before it ever runs. That bytecode is what every host executes, so the snippet you wrote in the editor behaves identically in a shipped build. Above a threshold it fans out across cores; below it, the parallel machinery would cost more than it saves, so it doesn't.
f@ i@ v@// ripple the surface, then colour by height
@P.y += sin(@P.x * 4 + @time) * 0.25;
v@Cd = vec3(1, @P.y, 0);
i@tag = @P.y > 0;
// @ptnum, @numpt, @time, @frame are always in scope
f@seed = rand(@ptnum);The compiler and the virtual machine both live in the core — a snippet compiles to the same bytes on every host, so what you wrote in the editor is exactly what runs in the shipped build.
Motus
Each solver is an ordinary node that cooks. Motus is everything underneath them — the time model, the cached state that carries forward, the forces, and the shims that keep an engine choice from ever reaching your graph. A new solver type is a node and a shim, not a second framework bolted alongside the first.
A position-based solver in which a material is a set of constraints — distance, bend, pressure — rather than a framework of its own. Adding a material adds constraints, not another engine to keep in sync with the first.
The rigid-body layer, over pieces — collision shapes from convex hull, box, sphere or convex decomposition, plus constraint glue. Fracture a shape upstream and the solver inherits both the pieces and the bonds between them.
Sim state lives in cached lanes keyed to the graph above it: change a parameter upstream and the lane drops and re-simulates from its start frame. Forces — uniform, wind, vortex, attract, drag — are nodes, readable by any solver that sits on the framework.
Under the hood
A single engine, written in Rust, behind a single stable interface. Hosts integrate once; everything the engine learns afterwards — a new node family, a new solver — reaches every host without a second integration.
Determinism is engineered, not assumed: every operation on a cook path is platform-independent down to the last bit, so a result computed on a build machine, an artist's laptop and a player's device is identical — and a cached result is a result.
The node library follows Houdini's semantics on purpose, and every deliberate difference is documented. Artists bring their knowledge with them; pipelines that already speak Houdini find the same words meaning the same things.
Every bundled example graph has its output frozen as a reference. An engine change that moves a single vertex on a flagship scene fails a test before it reaches a release — so an update is a known quantity, not a gamble.
Geometry lives once. The host reads the engine's buffers in place — in the browser the engine shares Unity's own memory — so a large scene is not paid for twice, every cook.
Watch
Recordings of real sessions — the graph being built, cooked and changed. Nothing on this page simulates Machina; this is the only place you see its output, and it is the output.
Recordings are being put together. They will appear here — meanwhile the channel is at youtube.com/@binaryego.
Until then, the 35 bundled graphs are the demo: open Roads, drag a control point, and watch the junction, the terrain cut and the guardrails follow.