Rive
.riv · .rev
The most complete Rive MCP. Author runtime .riv and editor .rev from scratch — nearly every runtime type, shapes to state machines to scripting. Import and round-trip existing files.
Animation, from a sentence
Describe it.
Describe it.
Get an animation.
Polymation turns plain language into real, ready-to-ship animations — for the web, apps, and games. It's the most complete Rive toolkit, now with live 3D and conversion between formats. No design app. No account.
On your phone? Polymation runs on your computer, inside Claude Desktop or Claude Code. Send yourself the link and pick it up there.
Rive ✓
Spline 3D ✓
Rive ↔ Spline ✓
Lottie ✓
Figma ↔ Rive ✓
After Effects → ✓
Adobe Animate → ✓
live · walking
The same gamba: its 2D Rive animation (left), and the exact same art converted to a real 3D figure that walks in Spline (right) — its hand-drawn walk frames mapped onto a solid inflated 3D mesh, legs moving, rendering live in your browser.
One MCP, every animation format
Polymation authors each format from scratch — and bridges between them with an honest per-decision loss report. Every format below ships today.
Spline
.splinecode · .spline
Author Spline 3D scenes from scratch — geometry, materials, lights, cameras, groups, variables, and hover/press interactions — as runtime .splinecode and editable .spline.
Rive ↔ Spline
bidirectional
Convert both ways. 2D shapes become 3D meshes and back; text arrives as real Spline text, a custom vector path as a mesh extruded from its own outline, and groups keep their nesting and their motion. Every crossing ships a per-decision loss report (clean / reconstructed / dropped / needs-your-call) and a structural check of the file it wrote.
Lottie
.lottie · .json · bidirectional
Bring your Lottie library into Rive on any Rive plan — an editable file that opens in the Rive editor, with real vector paths, gradients, path morphs, and eased motion, not a baked recording. And export any Rive scene back to Lottie for web/iOS/Android players — a round trip keeps layer order, eased curves, stroke ends and gradient direction. Interactive dotLottie converts both ways: a dotLottie 2 package arrives with its animations, state machines and colour themes, and whatever Rive cannot express is named in the loss report. A Rive file can leave as one with its states, guards, transitions and pointer interactions. A folder or .zip of Lottie files converts in one call, and with the preview browser installed each file's fidelity is measured.
Figma
link in · .fig out · both directions
Paste a Figma link (with your Figma access token) and get a Rive file — real vector paths, gradients on their true axis, exact rotations, text and image fills. Prototype flows convert to actual interactivity: connected frames become a state machine with Smart Animate tweens on Figma's easing curves. Figma Motion timelines convert too, from a capture by Figma's own MCP server or Polymation's Figma plugin — keyframe tracks for position, rotation, scale, opacity, size and colour, with Figma's own easing curves; custom springs are simulated rather than approximated, and Figma's named spring presets get a close curve the report names. And it writes .fig from scratch, so a Rive, Lottie, Spline or After Effects file can come back the other way as a Figma document. Everything that can't survive is named in the loss report, never dropped in silence.
After Effects
.aep → every target
Open a real .aep — no After Effects licence, no plugin, no render — and get Rive, Lottie, Spline or Figma out. Solids, shapes, text and precomps arrive with their words, their layer kinds and their keyframes, at the composition's own frame rate. Conversion runs one way — nothing is converted into a .aep — but an existing project can be edited in place: change values, retime or add keyframes, animate a property that never was, duplicate or delete layers and compositions. Everything the file holds that Polymation does not model comes through untouched, so an unedited save reproduces the original byte for byte. Footage stays where After Effects left it — a project references media on disk rather than embedding it — and the report says so rather than shipping an empty frame.
Adobe Animate
.fla · XFL → Rive, Lottie, Figma, Spline
Open an Animate .fla (CS5 and later) or an unzipped XFL folder — no Animate install — and get Rive (.riv and editable .rev), Lottie, Figma or Spline. Into Rive and Lottie come vector shapes, symbols on their own clocks, classic and motion tweens with Animate's eases, shape tweens Animate saved a morph for, masks, bitmaps, static text and frame labels. In Rive, a timeline that stops itself plays once and holds, as it does in Animate. Figma and Spline get each moving object's start and end pose, joined by one tween. What cannot cross — ActionScript, button states, sounds, filters, blend modes, and a mask over moving artwork outside Lottie — is named in the loss report.
Everything You Need
205 MCP Tools
Shapes, text, images, bones, meshes, constraints, events, nested artboards, data binding, Luau script source, shader effects — plus a full animation toolkit and runtime validation. Your assistant is shown just three: one finds the right tool for a job, one runs it, and one sends us a problem report if you agree. So it carries about 2,400 tokens of tool definitions on every message instead of about 50,000.
Rive CLI Projects
Rive shipped a CLI that builds animation from text, and it imports only Rive's own files. Polymation writes what it takes from everything else: rive.yaml, the scene as RML markup, and every image and font as a real file. A converted Lottie, After Effects or Figma file arrives as something you can read, diff and edit by hand, and their compiler builds it into a .riv offline (a .rev needs a Rive login).
Works as an Agent Skill
Coding agents that use skills can pick Polymation up in one line: npx skills add paradoxsyn/rivemcp-releases. The skill tells the agent how to connect the server, to render and look at every file it makes, and how to read a conversion report before calling a file done.
Fidelity You Can Check
Conversions are measured in our test suite by rendering both sides and comparing them, not by counting what crossed — the Rive side with Rive's GPU runtime, the one apps draw with. Most land under 0.3% mean pixel difference from their source; the worst in the suite is 1.34%, on a fully rigged character. Those figures are asserted by tests on every build, so a regression fails the build instead of reaching you. A batch of Lottie files you convert is measured the same way, file by file, when the preview browser is installed. Spline and Figma output, which has no renderer here, gets a structural check.
Physics Engine
Gravity, bounce, wind, springs — baked to optimized keyframes at compile time.
Runtime .riv + Editor .rev
Export both formats from scratch — runtime .riv for your app, and editable .rev that opens right in the Rive editor. No Rive app required to write them.
Spline 3D + Rive↔Spline Conversion
Author Spline scenes from scratch — editable .spline and runtime .splinecode — and convert Rive↔Spline both ways. Every conversion ships an honest per-decision loss report: what came across clean, what was reconstructed, what needs your call.
Sprite & Character Pipeline
AI-generated art is rarely animation-ready. Slice a sprite sheet, remove a background that was never transparent, align frames that drift between them, cut a single character into named body parts or take the parts from a layered PSD's own layers — then assemble a flipbook, or a rigged character with bones, an idle loop and, where you ask, mesh bending for ears and tails. The image steps need the npm install, not the one-click extension.
Your Video Model, Animated
Make a short clip of a character on one flat background colour in Veo, Sora, Kling or any video model, and Polymation turns it into a looping Rive flipbook: it finds the stretch that loops best and says how seamless the loop is, removes that background colour and crops every frame alike. Using an image model instead? It writes the prompt, with a pose reference for every frame of a walk, run or jump. These tools call no AI model, and they need the npm install.
Scene Composer
Describe a scene in JSON — backgrounds, characters, particles, physics — and get a complete .riv file in one call.
Nearly Every Rive Type
Almost every concrete type in the latest Rive runtime is supported: shapes, bones, meshes, state machines, data binding, scripting. Not yet: layout grids, paint images, bitmap caches, scripted transitions, selection styles and a few newer text and asset types.
Inputs to Data Binding
Rive has deprecated state-machine inputs in favour of view models. Polymation moves a file across: its inputs, conditions, listeners, blend states and named text runs go onto a view model, with the matching code changes for Web, React, Android, iOS and Flutter. Anything it cannot move safely stays put and is listed. With the preview browser installed, it runs the old and new files side by side in the Rive runtime and holds back a file that behaves differently; without it, the report says the check did not run.
Standalone & Headless
No Rive app, no account, no AI credits. Runs unattended in CI, servers, and batch pipelines — Claude, Cursor, Windsurf, Cline, or any MCP client. A paid key is checked online when the server starts and keeps working offline once it has been checked on that computer; the free trial checks online before each export. Native binaries for macOS, Windows & Linux.
Animation Toolkit
Morph shapes, draw-on strokes, auto-rig outlines with skeletal bones, warp images with meshes, send objects along motion paths, build sprite flipbooks, and wire one-call hover / press / tap interactions.
Runtime Validation
Polymation loads and runs your file in the real Rive runtime — catching files that silently won't load, animations that render but never move, and broken state machines before you ship. Simulate inputs, lint, preview as GIF, and render an interaction frame by frame with inputs set and triggers fired when you choose. Nothing else can do this headlessly.
How Polymation compares
The format vendors — Rive, Spline, and others — ship their own MCPs, but each one lives inside that vendor's editor and drives it like a remote control: the app has to be open, you need a paid plan with AI credits, and a human confirms every change. Polymation writes the files itself — across formats, headless.
Polymation
Official vendor MCPs
Runs standalone
✓writes .riv / .rev / .splinecode directly
×needs the vendor's app open
Vendor account & AI credits
✓none needed
×paid plan + credits
Headless / CI / automation
✓fully unattended
×GUI + manual confirm
Cross-format
✓one MCP for Rive, Spline, Lottie, Figma & conversion
×one vendor, one format each
Output
✓portable runtime + editor files
live edits in the vendor's editor
MCP clients
✓Claude, Cursor, Windsurf, Cline…
the vendor's own client(s)
Platforms
✓macOS, Windows, Linux + npm
tied to the desktop app
Verify it actually works
✓loads & runs the file in the real runtime — validate, simulate state machines, lint
×eyeball it in the editor
Animation toolkit
✓morph, auto-rig, trim, motion paths, one-call interactions
manual, in the editor
Different tools for different jobs. The official ones are great if you already live in a single vendor's editor. Polymation is for everyone who wants animation files generated programmatically, offline, at scale, and across formats — in a build, a server, or a one-line prompt.
From Prompt to Animation
"Make a card with lorem ipsum text
that glows when you hover over
the card, highlights each word
as you hover, and twinkles like
a star"→
glow-card.riv
Hover over the card above!
State machine + text + sparkles
Verify, don't hope
It works before you ship it
Most generators hand you a file and cross their fingers. Polymation loads and actually runs every file in the real runtime — so a file that silently won't load, an animation that renders but never moves, or a dead state machine gets caught here, not in production. Nothing else does this headlessly.
load & run
Boots it for real
Loads the file in the actual Rive / Spline runtime. A silent load-failure — the kind that ships a blank canvas — becomes an error you see, with the reason.
simulate
Drives the logic
Fires triggers, sets inputs, and steps state machines frame by frame — then checks the transitions and animations actually happen, not just that they exist.
lint
Flags the traps
Catches the silent killers: bad object references, dead states, animations that render but never move, off-canvas shapes, missing required children.
preview
Shows the motion
Renders frames headlessly to a GIF so you — or your CI log, or a PR comment — can eyeball the animation without ever opening an editor.
Conversions use it too: the loss report tells you what changed, and on request the converted Rive file is loaded in the real runtime to confirm it still loads. You ship a known quantity.
Simple Pricing
$10/month
Full access to all 205 MCP tools
- All shape, style, and animation tools
- State machines and event system
- Physics engine and prefab library
- Scene composer (JSON to .riv)
- Runtime .riv + editor .rev export
- Conversion between Rive, Lottie, Spline and Figma, plus After Effects and Animate files
- Flipbooks from sprite sheets and video clips, rigs from images and PSDs
- Luau script source & shader effects
- Nearly every Rive runtime type
- One-command install via npm
- Cancel anytime
Want to try it first? Download free — 3 exports included, no account needed.
Frequently Asked Questions
What is MCP?
An open standard that lets AI assistants use external tools. Polymation plugs into any MCP client.
What animation formats does Polymation support?
Polymation is built to be one MCP for every animation format. Live today: Rive (.riv runtime + .rev editor), Spline (.splinecode + .spline), Lottie (.json + .lottie, including interactive dotLottie 2 packages with their state machines), and Figma (read from a Figma link; .fig written) — with bidirectional Rive↔Spline and Rive↔Lottie conversion, Figma → Rive including interactive prototypes and Motion timelines, After Effects (.aep) import to every target, and Adobe Animate (.fla) import to Rive, Lottie, Figma and Spline. Every format is authored from scratch — no vendor app required.
How is this different from the official vendor MCPs?
The format vendors' own MCPs — Rive's, Spline's, and others — are built into their desktop editors. Each requires that vendor's app open and running, a paid plan with AI credits, and a manual confirmation on every change; each remote-controls one live editor, one format at a time. Polymation is a standalone, multi-format codec: it writes .riv / .rev and .splinecode / .spline files directly — no app, no account, no credits, no human in the loop. That makes it the only option for fully automated, headless, cross-format generation in CI, servers, and batch pipelines.
Which AI clients work with it?
Claude Desktop, Cursor, Windsurf, Cline, and any other MCP-compatible client.
Do I need a Rive account?
No. Polymation generates .riv files directly. Preview them in the Rive editor or any Rive runtime. Two exceptions: a Luau script is compiled and signed by the Rive editor when it opens the .rev, and a shader effect is built with Rive's own CLI and needs a signed build (rive --publish, with a Rive account) before apps draw it.
What can it do?
Shapes, text, images, bones, meshes, IK constraints, skinning, keyframe animation, state machines, listeners, events, nested artboards, scroll containers, data binding, Luau script source, shader effects, physics simulation, and scene composition. It generates production-ready .riv and editable .rev files covering nearly every Rive runtime type. It also converts between formats, and turns sprite sheets, single frames and video clips into flipbooks, and images and layered PSDs into rigged characters.
Can it animate art from my own image or video model?
Yes, with the npm install (the one-click Claude Desktop extension can't run these tools). Make a short clip of a character on one flat background colour in Veo, Sora, Kling or any video model and Polymation turns it into a looping Rive flipbook: it finds the stretch that loops best and tells you how seamless the loop is, removes that background colour and crops every frame alike. For an image model it writes the prompt to use: a background colour your character barely uses, a pose reference for each frame of a walk, run, jump, idle, attack or wave (other motions get written steps), and what to do next. A layered PSD, from an artist or a layer-splitting tool, becomes a rigged character with each visible layer as a part. These tools call no AI model, so there are no AI credits to buy.
Can Polymation create Spline 3D scenes?
Yes. Polymation is a multi-format animation MCP — alongside Rive, it authors Spline 3D scenes from scratch: runtime .splinecode for web embeds and editable .spline that opens directly in the Spline editor. Geometry, materials, lights, cameras, groups, variables, and hover/press interactions are all generated programmatically — no Spline app or account needed.
Can it convert between Rive and Spline?
Yes — Rive↔Spline conversion both ways. Rive shapes and fills become Spline 3D meshes; Spline meshes become Rive 2D footprints with their materials. Because 2D↔3D is lossy by physics, every conversion ships an honest per-decision loss report and a structural check of the file it wrote — so you always know exactly what came across.
What is a "loss report"?
Cross-format conversion can't be lossless when formats express different things (a 2D vector rig vs. a 3D scene). Instead of silently dropping data, Polymation records every decision: what came across clean, what was reconstructed, what was dropped (and why), and what needs your call — with a confidence score on each. The report is the product: you get a known quantity, not a mystery file.
What can't it do?
It's not a replacement for artists. It builds animations programmatically from structured instructions — it won't draw original illustrations, paint textures, or design characters from scratch. Think of it as an animation engineer, not an illustrator. Pair it with art from an artist or from your own image or video model for the best results. More capabilities are actively in development.
Does Polymation collect data on how I use it?
Not in the background. On its own, Polymation never sends us your files, what you make or what you ask your assistant; it only checks your licence or trial. When a tool fails, or none fits the job, your assistant can offer to send us a problem report. It shows you the exact report first and is told to send it only if you say yes. A report can include your request in your own words if you choose, the searches your assistant tried, which tools it used and any error text. File paths and licence keys are removed, and so are email addresses unless you add one so we can reply. The privacy notice lists everything a report contains.
Can I cancel?
Anytime. Your key stays active until the end of the billing period.