Everything, in the order you need it.

Install

Download the installer from the download section and run it. It installs into your user folder — no administrator rights needed — and lets you choose the location, with Start-menu and desktop shortcuts.

There is also a portable build — a single .exe that installs nothing. It runs identically, but the in-app updater cannot replace a portable executable, so updates mean downloading again.

From source

Installing from GitHub with npm also registers the MCP server with the Claude CLI:

npm install -g github:alycoulibal2-sketch/Cadence-Animator
cadence-animator

Or clone and run it in place:

git clone https://github.com/alycoulibal2-sketch/Cadence-Animator
cd Cadence-Animator
npm install
npm start

Requirements

macOS and Linux builds do not exist today. Nothing in the app is inherently Windows-only — it is Electron — but no other platform has been built or tested, so no claim is made about them.

Connect Roblox Studio

Cadence talks to Studio over a local HTTP bridge on 127.0.0.1:35747. Nothing leaves your machine. You only do this once.

1. In Cadence, click the Studio offline chip in the title bar. It writes CadenceBridge.lua into your Roblox plugins folder for you.
2. Restart Roblox Studio.
3. In Studio, open Game Settings → Security and turn on Allow HTTP Requests.
4. On the new Cadence Animator toolbar tab in Studio, click Connect.

The chip in Cadence turns green and shows the name of the open place. If it does not, see troubleshooting.

The plugin adds two buttons on the Studio side as well:

• Send Selection — push a rig to Cadence without Cadence asking first.
• Sync Pose — re-read a rig's geometry after editing it with Studio's own Move/Rotate tools.

Your first animation

You do not need Studio for this. Nothing to set up, no project to create.

1. Add a rig. Press CtrlK and type R15, or use + Add in the title bar. R6, R15, Rthro and Rthro Slender are built in.
2. Turn on auto-key with A. Now every part you move records a keyframe at the playhead, instead of you having to remember to key it.
3. Pose it. Click a joint handle, then E to rotate or W to move. Hold Shift while dragging to snap to the rotation grid.
4. Move the playhead forward — drag it, or step with → — and pose again. That is the whole loop.
5. Watch it. Space plays, Tab toggles looping. Press N for onion skinning to see the frames around the current one.
6. Polish the timing. Click Curves in the transport bar and drag the bezier handles, or select keyframes and pick an easing style.

Getting rigs in

Five routes, in rough order of how often you will want them:

• Built in — R6 (7 parts, 6 joints), R15, Rthro and Rthro Slender (16 parts, 15 joints each). No Studio, no network.
• Your Roblox avatar — type a username. Cadence builds the real avatar live in Studio and pulls it in, textures and all.
• Whatever is selected in Studio — select the rig's Model in Explorer at any nesting depth and click once in Cadence.
• By asset ID — any Roblox model asset, inserted through Studio's own InsertService.
• From a file — .rbxm or .rbxmx, parsed directly by Cadence with no Studio involved.

UGC textures come across too, including SurfaceAppearance face textures, and R15 shirt/pants clothing is composited the way Roblox composites it.

You can also change a rig once it is in. Rigging tools in the Inspector creates, converts and deletes Motor6D joints and welds, guarding against joint cycles, a part driven by two motors at once, and driving the root part. New joints derive from the rig's rest pose, never from whatever pose is currently on screen — so adding a joint mid-animation cannot bake today's pose into the rig's geometry.

Posing and keyframes

The tools

• W move, E rotate, R cycles between them.
• Trackball for free rotation without picking an axis first.
• Scale resizes the whole rig proportionally — one uniform factor from any handle, the way Studio's Model scale behaves.
• Y switches the gizmo between local and world space. C toggles rotation-grid snapping, or hold Shift to snap only while dragging.

Keying

A toggles auto-key, which is how most people work. Otherwise S keys the current pose, Numpad + keys just the selected track, and G keys the rest pose on the selected track. Double-clicking a part in the viewport keys that part.

World-space tracks

Any track can be flagged Unparented (world-space) in the Inspector. Its keys then store the part's origin-relative CFrame instead of a parent-relative motor transform, so copying those keys onto a rig with different limb lengths reproduces the same path through space rather than a parent-relative wobble. Toggling the flag re-derives every existing key exactly — switch back and forth as much as you like and the pose does not move. On export it is baked back to ordinary transforms, since Roblox's format has no such concept.

Inverse kinematics

Press T. Dragging the translate gizmo now moves a target that the limb chases, rather than the part itself — grab a hand and the elbow and shoulder follow.

• A cyclic-coordinate-descent solver works directly on the rig's own motor joints.
• The chain walks tip-first up three joints by default. Change it with IK chain length in the command palette; the setting is remembered.
• Each step's rotation is clamped, so a big drag eases toward the target instead of snapping or flipping.
• Results land in the normal auto-key and undo pipeline — nothing about an IK pose is special once it is keyed.

Easing and the curve editor

Thirteen styles — Linear, Constant, Sine, Back, Quad, Cubic, Quart, Quint, Sextic, Exponential, Circular, Bounce and Elastic — each in four directions (In, Out, InOut, OutIn). That is the same 52 combinations Moon Animator has, ported from its own engine and verified numerically identical.

Two of Moon's quirks are reproduced deliberately, not fixed: Exponential's In and OutIn variants end fractionally short of 1, and Back and Elastic default their parameters the way Moon's constructor does. Animations authored in Moon therefore behave the same here.

For anything a Roblox KeyframeSequence cannot express natively, Cadence bakes the curve into explicit per-frame keys on export — so what you see in the editor is what plays in game, rather than Roblox re-interpolating it differently.

Open the curve editor from Curves in the transport bar, or right-click a keyframe. Drag its handles for a custom bezier on any individual keyframe.

Timeline tools

• Group keyframes with CtrlG so they always move together; grouped keys get a gold ring.
• Mirror a rig's animation left-to-right with CtrlR — matching Left*/Right* track names and reflecting the transforms.
• Fill (ShiftK) bakes explicit keys across a range, optionally with random wiggle. Repeat, stretch and reverse work on a selection; offset shifts every frame in the project.
• Split a keyframe (M) or split at a stride (ShiftM).
• Play range confines playback to the section you are working on.
• Paste into selected item (ShiftCtrlV) retargets copied keys onto a different rig by track name.
• Edit selected keyframes (Numpad 7) sets values and easing on every selected keyframe at once.

There is also a quality checker. It sweeps an animation for rotation pops over 35° or position jumps over 3 studs in a single frame, joints that were never animated, non-orthonormal or degenerate transforms, and a held pose after the last keyframe.

Properties, actions and events

Rigs are not the only thing on the timeline. Cadence carries across Moon Animator's animatable-property registry in full: 67 Roblox classes, 12 value types, and 22 one-shot action types you fire on a single frame.

• Property tracks — animate a property of any supported instance over time, with the same easing engine as joints. Colour properties get a full colour picker.
• Action tracks — a one-shot event at a frame, rather than a value over time.
• Markers — named events on the timeline, each able to carry its own codeBegin and codeEnd Luau.
• Screen effects — vignette, letterbox, cover and subtitles, keyframeable like everything else.
• Cameras — position and field of view on their own tracks.
• Audio — MP3, WAV or OGG with a waveform to time against.

Exporting

Joint animation → Studio

Numpad 5, or Export → Straight into Studio. Cadence writes a KeyframeSequence into <rig>.AnimSaves.<name> — the same convention Roblox's Animation Editor and Moon Animator both use.

To turn that into an animation asset ID, open Studio's Animation Editor on the rig and use Import, then Export. No third-party tool can push directly to Roblox's asset servers; that step is Roblox's by design, not a gap in Cadence.

Cameras and properties → Luau

A KeyframeSequence has nowhere to put a camera move or an arbitrary property, so those export as a generated, self-contained Luau script instead — one baked row per frame with easing already applied, driven by RenderStepped or Heartbeat, with a BindableEvent to trigger it. Save it as .lua, as a droppable .rbxmx LocalScript, or straight to the clipboard.

Effects → Luau

VFX documents export the same way: one self-contained LocalScript with the curves pre-baked. Effects are not written into a KeyframeSequence — that format has no slot for them.

Files

Projects are .cadence files. You can import an animation from a KeyframeSequence file, from a published Roblox animation ID, or from a rig's existing AnimSaves folder — which is how you bring Moon Animator work in.

VFX Studio

A separate window, opened from VFX Studio in the title bar. It has its own document, its own undo stack and its own autosave — nothing it does touches the animator's state until you deliberately send an effect over.

How an effect is built

An effect is a document of stacked layers, each with a clip window on a local timeline. Six layer types: emitter, shape, light, screen, shake and sound. Any property on any layer can be driven by a curve or an expression, and eight modifiers — noise, wind, pulse, flicker, orbit, fade in/out, gradient shift and glow boost — layer on top.

Sampling is a pure function of the frame number. There is no running simulation to fall out of sync, which is why you can scrub to frame 40 from anywhere and get identical output every time, and why the animator can render any frame on demand.

Three ways to start

• Sketch it — draw the effect. Paint five layers on one canvas (shape, colour, density, motion, energy) and Cadence composes about thirty complete effects from low-level primitives, each fully editable. Compositions are assembled fresh every time rather than picked off a shelf of finished effects.
• The library — 25 multi-layer archetypes across 6 colour themes and 3 scales, plus 396 single-emitter particle presets to use as ingredients.
• From scratch — an empty document and the layer inspector.

Diagnostics

A validation pass with stable identifiers flags problems in an effect, marks which ones are safe to auto-fix, reports performance concerns, and shows per-layer badges for how faithfully each layer survives the trip to Roblox.

The visual node editor alongside the inspector is early: eight node types covering create, appearance, motion, physics, timing and output. The layer inspector is the complete path.

Procedural engine

A third way to author an effect, next to hand-built layers and the v1 node graph. Start one from Presets → Start a Procedural Effect. It opens on a small working effect rather than an empty canvas, and every node in that starting graph is a primitive you can take apart.

A procedural effect is its own document. It does not compile down to a layer-based effect, because a layer-based effect can only express its six layer types and eight modifiers — so the timeline's track column and the layer inspector are empty while one is open, and the panel tells you what is driving the effect instead.

The idea

Effects are composed from small operations rather than chosen and adjusted. That is why there is no “colour over lifetime” control anywhere: you wire a particle's normalised age into a gradient and into colour, and the same three nodes give you size over lifetime, opacity over distance or emission over speed.

The pattern repeats. Forces are vector fields, so gravity is a constant direction and turbulence is curl noise, and combining them is an Add. Colliders are distance fields, so one collider node handles a plane, a sphere, a capsule, and anything you built by combining them — the surface to bounce off is worked out from the field itself. Emitters take any geometry at all, so particles can be born from a shape nobody anticipated.

How you edit one

On the canvas, in VFX Studio — press Nodes, or Open the node graph in the inspector. Every node in the catalogue is in the add palette, which is search-first because a nested menu over 389 types is a worse tool than a text box: type swirl and Curl Noise comes up. Sockets are coloured by type and light up while you drag a wire to show what will accept it, values are edited in place, and a node group opens so you can see what it is made of.

Claude edits the same graph through the same model — it is a second pair of hands, not a privileged one. Anything it builds opens on the canvas as the actual nodes that produced it, and anything you change there it reads back immediately. Ask for what you want — “make the smoke swirl more and fade to blue” — rather than for particular nodes, and take over by hand whenever you would rather place them yourself. It can also pull in a ready-made node group (Curl Motion, Fire Turbulence, Soft Glow, Radial Burst, Dissolve and others), each of which is a composition of primitives you can open up and take apart.

The inspector shows what the effect is doing while you work: node and connection counts, how many elements the current frame actually drew, and any warnings.

Fields, textures and volumes

A field is a value that varies over space, time, a surface or a particle, and it is evaluated wherever it is asked. A texture and a volume grid are fixed grids, evaluated once. Both exist because blurring, edge detection and dilation need neighbouring values, and a continuous field has no neighbours. Rasterize and Bake To Volume are the visible moments a field becomes pixels or voxels — separate nodes on purpose, so you can see where the resolution was fixed rather than discovering it partway down a chain.

A volume grid is also a cache: bake an expensive noise chain once, then sample it per particle for a fraction of the cost.

Simulation and scrubbing

Particles are simulated rather than computed from a formula, which is what makes forces, drag and collisions possible. Scrubbing stays exact anyway: the solver keeps checkpoints and replays from the nearest one, so a frame looks identical whether you played into it or jumped backwards onto it.

Exporting to Roblox

Roblox decides what runs natively inside Roblox. It does not decide what Cadence can author. So the exporter classifies every render pass and says which it is, before you save anything:

• Native — a real ParticleEmitter. Colour gradients and size curves become genuine ColorSequences and NumberSequences. As with any Roblox emitter this is a statistical match: Roblox rolls its own per-particle randomness, so individual particles differ while the effect reads the same.
• Converted — a Beam or a PointLight, with its values baked per frame.
• Baked — motion Roblox cannot reproduce, such as curl noise or collisions, recorded frame by frame and replayed. Correct, but a recording: it plays back identically every time.
• Unsupported — refused, with the reason. A mesh cannot be built at runtime in Roblox, so exporting one as several hundred Parts would look wrong and run badly; it says so rather than doing it.

Procedural effects cannot be sent to the animator's timeline yet — that holds layer-based effects. Lua export works.

What is not built

Up to 0.10.0 there was no fluid or pyro solver, no volumetric rendering and no mesh editing, so genuinely simulated fire and raymarched clouds were out of reach. Those shipped in 0.11.0 — see what the engine gained. Still absent: liquids with a free surface, which need a different solver, and GPU compute, so a large simulation is a bake rather than real time.

Where a capability is missing the node for it is missing too. The type system refuses to register a node against a subsystem that does not exist, so there is no control that appears to work and quietly does nothing.

What the engine gained

Six things the procedural engine could not do at 0.10.0 shipped in 0.11.0. Neighbours, events, fire and smoke are part of the Pro simulation pack; the Effect Sheet, mesh editing and zones are free.

Neighbours: flocking, keep apart, liquid pressure

Until now a force field was evaluated at a point and knew only about that point. The particle solver now keeps a spatial hash and hands every field a neighbour query, so a force can look at the particles around it. Three forces use it:

• Flock — Reynolds’ three rules: do not crowd your neighbours (keep apart, stronger the closer they get inside a personal-space radius), fly the way they fly (match velocity) and stay near the group (stay together). Each rule has its own weight, so zeroing two of them gives a pure separation or a pure gathering force, and the total is clamped so a dense crowd cannot explode.
• Keep Apart — the separation rule on its own, for debris that should not pile up.
• Liquid Pressure — particles resist being squeezed together and drag on each other, which is what makes a stream of them puddle and slosh rather than pass through itself.

They are ordinary vector fields, so they add to gravity, wind and curl noise with an Add node, and their weights can themselves vary per particle. Four reads go with them — Neighbour Count, Crowding, Nearest Neighbour and Neighbours’ Velocity — so a look can depend on how packed the particles are: brighter in a crowd, larger when alone.

The neighbourhood is a snapshot taken at the start of each substep, so every particle sees the same picture whatever order they are processed in, and scrubbing stays exact. Roblox particles cannot see each other, so on export this motion is baked per frame.

Events and sub-emission

A Simulate node now reports everything that happens inside it as an event stream: births, deaths, collisions, a trigger when a condition you write becomes true for a particle (age above a value, speed below one, position past a line), and an interval tick every N seconds per particle.

• Particle Events filters that stream to one kind, optionally keeping only a share of it — a chance of 0.3 keeps roughly a third, decided per event and per frame so it replays identically.
• An Emitter has a new Spawn from events input, with particles per event and inherit velocity. Feed it deaths for sparks on impact; feed it an interval of 0.05 s with inheritance set low for a trail behind every particle.

Events are recorded per frame on the parent simulation and a child reads that history, so a child never runs inside the parent’s step loop and a frame looks the same whether you played into it or jumped to it. Roblox has no sub-emission; child particles are baked per frame on export.

Also landed, documented when it ships

Two larger pieces are in the engine as well and get their own sections here with the release that carries them: the Effect Sheet — every effect as a sheet of things you can see, every value with a “how does it vary?” menu and a live thumbnail, handles on the stage, nodes kept underneath — and a grid fluid solver with a volume renderer for smoke, fire and clouds, baked to flipbooks for Roblox.

Fire, smoke and clouds — a real gas simulation

Simulate Smoke & Fire is a grid fluid solver (semi-Lagrangian advection, buoyancy, vorticity confinement, a pressure projection) with combustion: fuel above an ignition temperature burns into heat and soot, and the heat lifts the plume. Cloud bakes a lumpy, drifting volume. The Volume Renderer draws either as see-through gas — density absorbs, heat glows through a colour table, one light with self-shadowing — and the Effect Sheet offers both as Fire & smoke and A cloud. Preview resolutions are 16³–64³ on the CPU with checkpointed scrubbing.

Roblox cannot render volumes; on export a volume pass is baked to an 8×8 flipbook sheet, the way Roblox fire and smoke are made by hand, and the export offers the PNG to save and upload.

Mesh editing with real connectivity

A new Mesh category: Merge By Distance, Flip Faces, Extrude Faces (region or individual, with top and side selections out), Inset Faces, Subdivide Mesh (Loop smoothing), Smooth Mesh, Mesh Islands, Separate Geometry, Delete Faces, Duplicate Elements, SDF To Mesh (marching tetrahedra — metaballs are a smooth union of spheres fed to it), Volume To Mesh, Mesh To SDF (angle-weighted pseudonormals, so the sign is right at corners), Mesh Boolean through distance fields, Curve To Mesh (a twist-free sweep with per-point radius and custom profiles), Fill Curve, Trim Curve, Fillet Curve, Bezier Curve, Spiral, Star, Icosphere and Attribute Statistics. Everything stays a point table plus a face table; each operation derives the adjacency it needs.

Repeat and simulation zones

Every node group now has two settings: Repeat runs the group N times, feeding each output back into the input of the same name (a recursive subdivision, a growth step applied ten times); Carry over frames makes each frame start from the previous frame’s outputs — a simulation zone for anything the particle solver does not cover. Scrubbing replays from the nearest checkpoint, and each replayed frame sees its own time.

The Effect Sheet

The procedural inspector is now a sheet: every drawn thing, its properties, and for each one a how does it vary menu (over life, over time, by height, by speed, by crowding, noise…) with live thumbnails rendered by the real engine. Handles on the stage move emitters, directions and radii; a hero-particle strip shows one particle’s life. It is a lossless view of the same graph the node editor shows — nothing is approximated, and Show as nodes is the same object.

Claude and MCP

Cadence ships a Model Context Protocol server exposing 207 tools — 141 for the animator, including the animation-intelligence layer that 0.14.0 added, 30 for VFX Studio and 36 for the procedural engine. Claude can add rigs, set exact keyframe values, solve IK, edit curves, build effects, run the quality checker and export to Studio.

The procedural tools are structured graph APIs rather than UI automation: Claude reads the node catalogue, describes a node's exact sockets and units before using it, wires the graph, then verifies. pnx_verify_range exists because a single-frame check is the commonest false positive there is — an effect can be valid at frame 0 and empty by frame 40. Everything it reports is technical validity; nothing claims to judge whether an effect looks right.

Connecting it

If you installed the packaged app: click ✨ Claude Control in the title bar. Cadence registers itself with the Claude CLI, pointing at its own executable.

If you installed from npm, registration already happened. To do it by hand:

claude mcp add cadence-animator -- node <install-path>/mcp-server/index.js

The MCP server holds no state of its own. Every call is an HTTP request to 127.0.0.1:35748 on the running app — which is why Cadence has to be open for any of it to work.

The two tools that matter most

• render_frame — scrubs to a frame and returns a real screenshot of the viewport as an image. This is what lets Claude check its own posing instead of assuming the numbers looked right.
• validate_animation — the same quality heuristics the app uses, exposed as a tool, so quality checks happen without a human having to ask for them.

Every write tool returns a fresh read-back of what changed, so a caller never has to assume a mutation landed.

Phone companion

Click 📱 Mobile and Cadence starts a small local server and a temporary Cloudflare tunnel, then shows a QR code. Open it on your phone and you get a real three.js viewport — the actual rig, not a screenshot stream — that you can orbit and scrub.

• Access is gated by a pairing token carried in the URL fragment.
• There is a view-only toggle, and commands from the phone are limited to a small allowlist.
• The tunnel is temporary and needs no Cloudflare account. Restarting the app gives a new address; closing it ends access.
• It is off unless you turn it on.

Keyboard shortcuts

Cadence matches Moon Animator 2's keybinds deliberately, so muscle memory carries over. Press ? in the app for this same sheet, or CtrlK for the command palette — which has all 117 commands, including the ones with no shortcut.

Autosave and recovery

There is no “save before you close or you lose your work” in Cadence. Every change is written to disk within about a second, and the last ten generations are kept as rolling backups alongside it. Writes are atomic — a crash mid-write cannot leave a half-written project.

• Reopening the app resumes the project you were in, with no dialog.
• Restore an autosave… in the command palette switches to any past project, and can delete one for good if you want it gone.
• Closing the window waits for the final write to finish before the process exits.

Updating

The installed build checks the project's GitHub releases a few seconds after launch, and whenever you run Check for updates from the command palette. If a newer version exists a chip appears in the title bar: click it to download, then click again (or confirm the dialog) to install and restart.

• Nothing downloads or installs on its own. Both steps are explicit clicks.
• A background check that fails stays silent rather than interrupting you with an error.
• Only the installed build can update in place. The portable .exe has nothing for the updater to replace, so grab a new one from the download page.

Plans and your licence key

The animator and VFX Studio are free, forever, under MIT. The paid plans — Pro and Studio, plus a one-time Founders option for the first 100 — are for Cadence AI, and they are opening soon together with it. Nothing can be bought yet.

Bought Pro before the new plans? You’re a Founder: Pro forever, nothing to renew, and your key keeps working. Today a key unlocks the procedural simulation pack (flocking, keep apart, liquid pressure, sub-emission, fire and smoke, clouds, the volume renderer), Roblox export of any procedural effect, and the Pro badge.

Entering a key

1. Pro is the same download as Free. Install Cadence, or keep the copy you have.
2. Open the command palette (Ctrl K) and run Cadence Pro: enter your key; paste the key together with the email you paid with. The features switch on in that copy immediately.
3. The key belongs to the email used at checkout, and works on any PC you use. The app checks it with Cadence’s licence server when you enter it and about once a week after, and keeps working offline in between.

Lost or unsure

• The account page checks an email and key pair and shows its plan.
• The key was shown on the thank-you page after checkout; it isn’t emailed. Keep the Stripe receipt: it is the proof this key belongs to. Lost the key? Write to [SUPPORT EMAIL] from the purchase email and it is re-sent.
• Refunds are 14 days, no questions asked.

Troubleshooting

Windows blocked the installer

Expected — the builds are not code-signed. More info → Run anyway. Verify the SHA-256 from the download page first if you prefer.

The Studio chip stays red

Work through these in order:

• Is Allow HTTP Requests on in Game Settings → Security? It is per-place, so a different place needs it again.
• Did you restart Studio after the plugin was installed?
• Did you click Connect on the Cadence toolbar tab in Studio?
• Is another copy of Cadence already running? Only one process can hold port 35747. Check the tray and Task Manager.

A part is a plain box, or flat grey

Its mesh or texture failed to fetch and it is showing a placeholder. Cadence raises a notification when this happens. Usually a network hiccup — reload the rig. A few Roblox assets require an authenticated session and cannot be fetched by any third-party tool; for those, Cadence substitutes the closest built-in shape and leaves the real meshId untouched, so exports are unaffected.

Claude cannot see Cadence

Cadence must be running — the MCP server is a thin client for the live app, not a standalone process. Then check the registration with:

claude mcp list

Something else is wrong

The app writes a log next to its settings, at %APPDATA%\Cadence Animator\debug.log. Launch with --devtools to open developer tools on start. Issues with that log attached are much easier to fix: report one here.