Nubu Motion: a motion design editor in your browser
Nubu Motion is a motion design editor built into Nubu: design and animate in the browser, then publish templates that render every variant.
Nubu Team··9 minute read
Nubu Motion is here: a motion design editor built into Nubu that runs entirely in your browser. You design and animate real compositions with layers, text and shapes, give them keyframes, physics and scripts, then publish the result as a template. From there Nubu treats it like any other template: campaign data flows in, and finished, reviewed, deliverable video comes out.
Until now the design half of that pipeline lived in After Effects. Templates were .aep projects your motion designers exported, and Nubu took over from upload onwards. That workflow is not going anywhere. What changes today is that a template no longer has to start in another application: you can open a blank composition inside Nubu, build the animation, and hand it to the same rendering, review and delivery machinery, without a plugin or an export step in between.
This is a launch post about our own product, so read it with that in mind. Everything below is shown rather than asserted: the screenshots are the real editor, and every video clip is a 1080p render produced by the engine itself from the worked examples in our scripting docs.
Nubu Motion is a motion design editor inside Nubu, the creative automation platform. It gives you a composition canvas, a keyframe timeline with a graph editor, a physics and particle system, a scripting engine, and a publishing step that turns a finished composition into a renderable template. Because it runs in the browser, there is nothing to install and no render plugin to manage: the same organisation that holds your campaigns, assets and approvals now holds your motion design work too.
The editor is organised around a handful of surfaces:
Surface
What it gives you
Canvas
Compositions and precomps with layers, text, shapes and media
Timeline
Keyframes with easing, colour-coded layers, a full graph editor
Effects
Blurs, glows, distortion, cloners, physics and particles
Scripts
A panel and IDE for scripts that drive properties with code
Dynamic fields
Mark text, colours and media as swappable template fields
Publish
Turn the composition into a template Nubu renders at scale
The rest of this post walks through those surfaces in order, ending with the part we care about most: what happens after you press Publish.
Animation in Nubu Motion works the way motion designers expect. Layers get keyframes on position, scale, rotation, opacity and every other animatable property; the timeline shows each layer as a colour-coded bar you can twirl open into per-property lanes.
Easing is not an afterthought. The graph editor shows value and speed curves with draggable handles, so a bounce, an overshoot or a slow settle is something you shape by hand rather than pick from a preset list.
Keyframes and scripts share the same clock, so you can mix approaches freely: keyframe the broad move, then let a script add the detail on top.
Nubu Motion has a physics system built into the effects stack: rigid bodies, colliders, deformables, forces and local gravity, plus a particle system with emitters. You set the simulation up as properties on ordinary layers and scrub it in the timeline like any other animation. There is no separate simulation window: the bodies fall, collide and settle on the same canvas you design on.
Physics parameters are ordinary animatable properties, which means keyframes and scripts can drive them like everything else. A gust that rises at a chosen frame, an emitter whose rate follows a slider, gravity that switches on when a layer appears: they are all the same mechanism, documented in the effects property family.
Some motion is easier to describe as a rule than to keyframe by hand: follow that layer, drift gently, count down, fade with distance. In Nubu Motion those rules are scripts, written in modern JavaScript, living in a Scripts panel with a floating IDE that gives you completions, live evaluation and lint as you type.
A script is a tiny module. It declares the properties it drives, and the engine calls its frame() function once for every frame it shows:
That one wiggle call is enough for the classic organic drift:
The docs' wiggle example, rendered by the engine at 1080p
The scripting surface is documented end to end: 112 members, 684 property patterns and 128 worked, machine-verified examples. If you have written After Effects expressions, most of your instincts transfer; if you have not, the quick start assumes no expression experience at all. The full tree lives at the scripting reference.
A script is not limited to one property. Declare several outputs and write to each with set(), and a single file becomes the choreography for an entire composition, as in this render where every crate sinks at its own weight while all of them dim together:
One script, several outputs: the docs' project script example
Scripts can also read expression controls, so the everyday pattern is a rig layer holding sliders, checkboxes and colours that a script consults every frame. The controls are the surface people touch; the script is the wiring underneath. How outputs, scheduling and controls fit together is covered in project scripts.
Style is drivable too, not just movement. Fill colours, stroke widths, text properties and effect parameters all take script values, like this swatch melting through a colour cycle:
A scripted fill colour, cycling on the engine's deterministic clock
Scripted motion is only useful if it renders the same everywhere, so determinism is engineered in rather than hoped for. Randomness is seeded: wiggle, random and noise derive their numbers from the document, the script and the frame, so scrubbing in the editor, replaying tomorrow and rendering on the farm all see identical values. Scripts cannot reach the network, the file system or the wall clock. A runaway loop is stopped by budget and reported as a typed status on the script, never a freeze; the frame still draws. The full reasoning lives in the determinism and random and noise pages.
There is exactly one script runtime, embedded in the editor and in the render farm alike, with the same budgets and the same seeded randomness. The frame you scrub is the frame that renders.
Text layers carry animators: per-character and per-range treatments with selectors you can sweep across a line, so type animates letter by letter rather than as one solid block. Selector ranges and animator values are properties like any other, which means keyframes and scripts can drive a reveal, a cascade or a wave through the text.
A text animator reveal driven across the line, from the docs' animator example
The animator property family, with every selector member, is documented in animator properties.
A composition becomes a template the moment you say which parts are allowed to change. In the Dynamic Fields panel you mark text, colours and media as fields: the headline, the supporting line, a card colour, a packshot. Everything you do not mark stays exactly as designed.
Fields are the contract between design and automation. The designer decides what may move; the campaign supplies the values; the render fills them in. It is the same idea Nubu has always applied to After Effects templates, now available without leaving the browser. How templates and their swappable slots work is covered in the templates guide.
Publish a Nubu Motion composition and it becomes a template in your organisation, and from that point Nubu renders every variant from it, exactly like any other template. Campaign flows feed it: Market, Language and Version nodes create the variant dimensions, a CSV node pipes spreadsheet columns in at up to 5,000 rows, If/Else nodes route rows, and AI nodes translate or generate copy on your own provider keys. One flow can build hundreds of creatives from one published composition.
The guarantees that apply to every Nubu render apply here unchanged:
Traceability. Every render records who created it, the template and version, the exact inputs and per-state timestamps.
Versioned outputs. Renders are never overwritten; republishing a template versions it instead of breaking campaigns that use it.
Review before anything ships. Creatives land in a review drawer with comments and timecode links, and nothing publishes itself.
Delivery on your terms. Approved creatives push to Meta Ads and Google Ads as paused ads in your own ad account, or download as ZIP exports for everything else.
Not for work you build in Nubu Motion: compositions are designed, animated and rendered entirely without it. Your existing After Effects templates keep working exactly as before, and uploading a .aep still makes every composition in the project an automatable output. The two kinds of template sit side by side in the same campaigns, so teams can adopt Motion gradually rather than migrate.
No. The canvas, timeline, graph editor, physics and dynamic fields are fully visual, and you can publish templates without writing a line of code. Scripting is there when a rule is easier than keyframes, and the quick start assumes no expression experience: seven small builds, each starting from an empty project.
The render does not break. Every script failure is one of fifteen typed error codes carried on the script's status with a message; the failing script's outputs fall back to their base values for that frame, the frame still draws, and the next frame evaluates afresh. Budgets fence runaway work the same way on every machine. The complete contract is in error codes.
Plenty of tools can make a rectangle move. The reason Nubu Motion exists is what happens afterwards: the composition you design becomes a template, the template joins your campaigns, and the same pipeline that renders, reviews and delivers the rest of your advertising takes it from there, traceably and at scale.
If you already use Nubu, Motion is in your workspace now: open the Motion section and start a project, or explore what the editor can do. If you are new, sign up and try it, with plans in plain numbers on pricing.
Start with the scripting quick start if you want the rules-driven side, or just draw something and give it a keyframe. Make it move, then make it many.
