A node graph for the web.
A procedural engine built for the browser — where generative AI is a node in the graph rather than a panel bolted to the side, and where the output can be a real web page.
Ten families, each with one job.
You build by connecting nodes, and every node belongs to a family with its own colour and scope — so a graph stays readable at a glance, even someone else’s, even a year later. Pick one to see what it does.
The world
Cameras, lights, containers — the scene everything else lives in.
Cameras & lights
Set up the shot: perspective or orthographic cameras, lights that actually cast.
Sub-networks
Fold a chunk of graph into a single node other parts can reuse.
Instancing
Replicate one object across a grid, a surface, or the rows of a table.
Geometry
Build and modify shape — procedurally, so it stays editable.
Sources
Primitives, text, or your own model brought in and kept live.
Deformers
Bend, twist, noise, displace — as operations, not baked edits.
Scatter & clone
Distribute copies over a surface with control over every rule.
Textures & images
A full image chain — generate, composite, and feed it anywhere.
Generators
Noise, gradients, shapes, type and procedural pattern.
Compositing
Blend, mask, colour-correct and blur, in a chain you can re-order.
Feedback
Send a frame back into itself for trails, decay and simulation.
Materials
How a surface responds to light — driven by anything upstream.
Surface types
Physically based, unlit, toon, or your own shader.
Texture inputs
Wire any TOP into any channel: colour, roughness, normal, emission.
Live preview
See it on the object while you build it, not after a render.
Signals
Numbers over time — the family that makes things move.
Time & animation
Curves, oscillators, timers and sequencers.
Maths & filtering
Smooth, lag, remap and combine channels into new ones.
Drive anything
Any parameter in the graph can be wired to a channel.
Data & tables
Rows and text — how one graph becomes the whole set.
Tables
A market list, a product catalogue, a CSV, a block of JSON.
Fetch
Pull live data from an endpoint, on demand or on a schedule.
Drive the graph
Turn rows into variants, instances, labels and layouts.
Input
What the person on the other side does, as a first-class input.
Pointer & touch
Clicks, drags, hovers and multi-touch, wired straight in.
Keyboard & gamepad
Map any control to any parameter.
Hit-testing
Know precisely what someone is pointing at in a 3D scene.
AI inference
Generation as an operator, with real inputs and real outputs.
Generate
Image and video models as nodes fed by your own work.
Condition
Depth, edges, masks and references arrive as wires, not descriptions.
Language
Prompts, structured output and agents, inside the graph.
Logic
What the piece is doing now, and what makes it do something else.
State machines
Define the states a piece can be in and the moves between them.
Conditions
Transitions driven by data, input, or time.
Lifecycle hooks
Do something on enter, on exit, or on every tick.
The document
The page itself as part of the graph — not a container around it.
Real elements
Headings, text, buttons and forms — actual markup, not pictures of it.
Real styling
Genuine CSS, responsive by default, readable by a screen reader.
Embedded 3D
A viewport as an element inside the page, sized and placed like anything else.
A real engine, not a prompt chain.
The cook
Every frame, the graph recomputes — but only the parts whose inputs actually changed. That's what makes a graph interactive rather than a batch job you re-run and wait for.
Strictly typed wires
The engine refuses a connection between mismatched types instead of quietly coercing it. Conversion is something you ask for explicitly, with a converter node, so a graph can't silently do the wrong thing.
Parameters and expressions
Any parameter can be driven by an expression or wired from another node. A property and a same-named input are two faces of one value — wire it and the wire wins, unwire it and the property holds.
Nondestructive by design
The graph is the source of truth, not a stack of baked exports. Change something near the start and everything downstream updates — which is what makes build-once-generate-many possible at all.
Real-time, with physics
3D, motion and rigid-body physics run live in the browser. What you're editing is what the audience gets — not a preview of a render you'll wait for later.
Generation is an operator, not an add-on.
Most tools grew up without AI and bolted a panel on afterwards. This one was designed around it: MLOP is one of the ten families, with the same typed wires and the same per-frame cook as geometry or textures.
Fed by your own work
A generation node takes the model you built, the layout you composed, the palette from your brand system. You direct it with real things rather than describing them in a sentence and hoping.
Wired into what comes next
What it makes flows onward — a generated texture drives a real material on real geometry that ends up in a real page. Nothing is downloaded and carried across by hand.
The same graph does the same thing
Change one parameter upstream and everything downstream updates coherently, generated parts included. That is what makes a set of two hundred variants possible at all.
The difference between a panel and a node is the difference between a slot machine and art direction. Why AI is a node →
Two ways out of the same graph.
A graph can hand your team files, or it can be the thing your audience opens. Same engine — you choose.
Workflow
Runs, finishes, and hands you assets to place — every ratio, locale and cut.
- Who opens it
- You and your team
- Ships as
- Files
Scene
Is the thing itself — a page, a configurator, an installation someone uses.
- Who opens it
- Your audience
- Ships as
- A URL, an embed, an installation
A scene compiles to an ordinary web page.
Not a screenshot of one, and not a heavyweight canvas app. Export is a hybrid compile: a static semantic-HTML shell for fast first paint and search, plus a runtime tree-shaken to carry only the operator families your project actually used.
A project that never touches 3D ships with no 3D payload at all. The graph is the app's behaviour, interpreted at runtime — so the thing you send is small, fast and real.
Open a tab and build something.
Free to start, nothing to install. The engine explains itself faster than this page can.
Working with a team?
Tell us where to reach you and we'll set up a walkthrough.
No spam. A real reply from a human.