Nondestructive object-oriented operators doing lots of excellent stuff.
That is the name, and it is also the design: every operation stays an object you can go back and change, and nothing is ever flattened. Ten families of operators, plus the systems that cut across all ten.
Panels you arrange, and a graph that shows its work.
The workspace is a tree of dockable panes — split one, drag another to an edge, close what you are not using. Two graphs open side by side, a viewer next to the network that feeds it, the sequencer along the bottom while you work.
The network
Where you build. Nodes, wires, subgraphs you descend into, and split panes so two levels of the same project are open at once.
The viewer
The rendered result, and the place you interact with it — drag a transform gizmo, aim a light, pull a field's extents, or type directly onto rendered text.
Parameters
Everything on the selected node, with expressions, keys and bindings all reachable from the same row. Select several nodes and edit them together.
The sequencer
A dockable dope sheet and curve editor over the whole project, with a transport, a range and a frame rate.
The content browser
Browse what you can start from and what you have already made — Recipes, the Cookbook, and the assets in your project — and bring one into the graph without leaving the tab.
Every node draws its own output
An image node shows its actual pixels. A geometry node shows a lit render of the mesh at that point in the chain. A signal node is a rolling scope with the numbers on it, a table is a grid that reveals more rows as you zoom, a material has a shaderball. Which is why somebody else's graph is legible on sight.
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.
Build shape procedurally, and keep it editable.
Eleven primitives, GLB and glTF import, and a deformer stack that never bakes. Every operation stays a node you can go back and change.
Deformers that stack
Bend, twist, noise and displace as live operations rather than baked edits. Reorder them, retune the first one, and everything downstream re-cooks.
Bevel, extrude, fracture
True edge bevel and fillet on arbitrary meshes. Face extrude with inset, twist and hole-punching. Voronoi fracture, with per-shard transforms and one flag to make every shard a rigid body.
MoGraph, properly
A Cloner with five modes including copy-to-points and copy-to-faces, and a reorderable effector stack — Plain, Random, Time, Formula and Pose.
Fields you drag in the viewport
Five falloff shapes with gizmos and draggable extents, tinting the points they influence so you can see the falloff rather than guess at a number.
Particles
A live 50,000-particle simulation as an operator, with four recipes to start from.
The geometry spreadsheet
Point, primitive and detail tabs with the real per-vertex data behind whatever you are looking at. Attributes, groups, a wrangle, UV projection.
A full 2D toolkit, on the GPU, in the same graph.
47 image operators, and the chain stays GPU-resident — no copy back to the CPU between steps — and its output is a texture the 3D scene, the materials and the page can all read without an export step.
27 blend modes
A layer stack that grows as you add to it, with the blend modes you already know. Levels with a live histogram computed off the real pixels, and per-channel bezier tone curves.
Your installed fonts
Text reads the fonts actually installed on your machine — not a web-safe list. Font, a scrubbable size, bold, italic, colour, alignment and spacing.
Type edited on the image
Double-click the render in the viewer and type onto the glyphs with a real caret and selection, at the right size. Put the caret between two letters and Alt+arrow kerns that pair — and the kerning survives editing the text.
MoGraph in 2D
A cloner and a five-effector stack on the image chain, not only in 3D — so a grid of tiles, a scattered pattern or a field-driven layout is the same gesture in both places, in one instanced GPU pass.
Feedback loops
Send a frame back into itself with a decay loop you author, for trails, accumulation and simulation.
Type that shatters
Break a headline into per-character glyphs and drive them with an effector: staggered reveals that stay exact when you scrub, rather than forty layers timed by hand.
Materials you wire, not presets you pick.
16 material operators. Physically based, unlit, toon, or your own shader.
Thirteen map slots
Wire any image chain into colour, roughness, normal, emission and nine others. The texture updates as the chain does, with no bake step in between.
The physical set
Clearcoat, sheen, iridescence and transmission, per-group and per-piece assignment, and a GLB's baked materials exploded into editable nodes.
Or write the shader
A shader material node when you want the actual GLSL, sitting in the same graph as everything else.
A timeline made for motion.
Professional grade, and built for the job: a dockable dope sheet and f-curve editor, weighted bezier tangents, per-key easing, pre- and post-infinity behaviours, a master transport with a range and a frame rate, and a diamond on every parameter that keys it.
Keyframe anything
Not just transforms. A shader parameter, a light's intensity, a physics value, a material colour, the text in a headline, the mode in a dropdown. If it's a parameter, it takes keys.
Dope sheet and curves
Drag keys in time, marquee-select across tracks, and drag weighted bezier tangents in the curve editor. Break and equalise handles; switch between normalised and stacked views.
Retime by dragging
Alt-drag a selection to squash or stretch a whole move. Reverse a move and the eases reverse with it. Two keys and cycle-with-offset gives you motion that never stops.
Cut cameras like an editor
A camera-cut track: drop a cut, pick a camera, drag the clip to move it and drag its edges to trim. Switching cameras is an edit, not a rewiring.
Reusable shots
A Shot is a self-contained sub-timeline with its own tracks and range. Place it as a clip with an in-point and a speed, drop the same one into two sequences, double-click to open it and change it in both.
Tracks that fire events
Drop a named marker on an event track and crossing it fires an event a state machine picks up — so a reveal starts at frame 240 because you put it at frame 240.
Cameras, lights and physics you author.
26 scene operators. The physics is a solver you direct, not a checkbox you tick — which is the difference between a piece that reacts and a loop with a trigger on it.
Cameras with real depth of field
Perspective or orthographic, with an on-canvas gizmo — drag the frustum, the clip planes, the iris. Orbit, DCC-style or WASD fly controllers, and a director node that cuts or blends between several cameras.
Lights that cast
Point, spot, directional and ambient with real shadows, and an interactive gizmo for aim, cone angle and range. HDRI image-based lighting with an environment you can rotate.
Rigid bodies
One flag turns any geometry into a rigid body. Fracture a mesh and every shard becomes one, so a thing falls apart the way it would.
Forces you can aim
Impulse, torque, wind and divergence-free turbulence — and any of them can be weighted by a field, so the force applies where you put it rather than everywhere.
Joints and motors
Fixed, ball, hinge and slider constraints, with velocity and position motors. A door that swings, an arm that drives, a chain that hangs.
The Replicator
A table's rows spawn real duplicate nodes, each cooking independently, named by prefix and index. Not instances of one thing — N actual nodes you can reach individually.
Motion that doesn't need keys.
18 channel operators, cooked before expressions so a value is ready by the time anything reads it. Named multichannel signals travel on one wire.
Oscillators and curves
Six LFO waveforms with accumulated phase, and a bezier response editor for shaping any signal by hand.
Envelopes and timing
A full ADSR envelope with pulse, plus lag and filter smoothing, timers, hold, count and limit.
A scope on every node
Every signal node draws a live oscilloscope on its own body. Hover for values, drag a channel row straight onto any parameter, or sample an image, table or geometry into channels.
A spreadsheet in the graph, and a socket next to it.
Markets, prices, copy, launch times — the variable half of most work is a table, so it is a table here, editable in place.
Real editable tables
Type into cells in the graph. Select, merge, substitute, switch and convert as operators, so a table is something you process rather than something you paste — and a cell drags onto a parameter like anything else.
Call any web API
An HTTP node fetches from any endpoint and a WebSocket node holds a live connection. A feed is an input to the graph like touch or time.
It keeps running once shared
Data operators go on working in a shared or performed page, so a board reading a live feed keeps reading it.
Input is a wire, not a callback.
Interaction is authored in the same place as the visuals, wired into what it drives — so there is no bridge layer between the part that senses and the part that draws.
Pointer, keyboard, scroll
Position, press, click, hold and drag pulses, wheel and velocity. Scroll with draggable trigger markers for scrollytelling, on-node key capture, gamepads as channels and screen zones as triggers.
Hit-test in 3D
Click and hover real geometry by raycast, with the hit point and the surface normal as outputs — so you know precisely what someone is pointing at.
Camera, hands, pose and face
A webcam as a live texture feeding the image chain, the materials and the ML nodes. 21 hand landmarks with pinch channels, 33-point pose, a 478-point face mesh with blendshapes, and segmentation masks — all as wires.
Draw the logic, then watch it run.
A real state machine as a node you descend into. States have no pins — you wire them from the border, and the transitions are derived from the wires, so you change the behaviour by moving one.
States without pins
You wire states from the border and the transitions are derived from the wires, so you change the behaviour by moving one rather than by editing a table of rules.
Conditions from a blackboard
A typed data store with nine types, addressable by name, and a condition editor that autocompletes from it. Transitions driven by data, input or time.
You can see it running
The active state carries a blue ring, dwell shows as a progress bar, and a wire fattens as its condition approaches firing. Debugging is watching, not logging.
Five hooks per state
On enter, on cycle, on exit, and at the start and end of a transition. Inline callbacks, one-shot triggers, minimum dwell and priority.
Transport on the node
Running, stop and reset pills you click on the machine itself. Drop any scene node onto a machine to drive it by name.
Eight projects to start from
Ready-made state machines in the Cookbook, including two solvable Rubik's Cubes — worth opening before you build one from nothing.
Drag a value onto the thing it should drive.
Any parameter can hold an expression instead of a value, and any node can be reached by a hierarchical path. But most of the time you never type one — you drag.
The pickwhip
Grab any parameter and drag it onto any node. A line follows your cursor, the target lights up, and on release you choose what drives what. Hold Alt and it binds the other way round. Drag from the sidebar, from a control on a node, from a live channel on a scope, or from a cell in a table.
Bindings are visible
A dashed gold line runs from the driver to the exact parameter row it drives, across split panes and into subgraphs. It goes red if it breaks. You can cut it with the wire cutter, like any other wire — because that is what it is.
Linked clones
Alt+Shift-drag a node to duplicate it with every parameter bound back to the master. Change the master, and every clone follows.
Paths that survive a rename
Reference a node with op() and a path. Rename it and every reference retargets, across both graphs and every subgraph.
Per-axis, and on keys
Put an expression on one axis of a vector and leave the others alone. On a keyed parameter, read value, time, a specific key(n) or the velocity at a time.
Sandboxed by default
Expressions run in a sandbox, so opening a scene somebody sent you cannot execute their JavaScript. Broken bindings are flagged, and circular references are caught rather than hung on.
The page is part of the graph.
A layout box is a node, with real CSS behind it — not a canvas pretending to be a page. Which is why a scene can be a page somebody browses rather than a picture of one.
Genuine CSS
A live DOM runtime with a generated stylesheet — one readable class per node. Responsive by default, and readable by a screen reader.
Bind content by dragging
Drag a table onto a text box and it becomes the text. Drag an image chain onto a box and it becomes live media inside the layout. Build the hierarchy in the interior outliner when that beats wiring it.
Design tokens
Type, colour, spacing and grid as tokens the whole document reads, and a real CSS node with automatic scoping when you want to write it yourself.
Open one and pull the wires apart.
Free to start, nothing to install. Every Recipe in the app is a working graph you can take to pieces.
The feature you looked for and couldn't find
This page is long, and there are still gaps in it. Tell us what you scanned it for — the absence you noticed is a better brief than anything we'd write ourselves.
No spam. A real reply from a human.