llms.txt
Compare with other sites' llms.txt files →# Rive
> Rive is an agent-native 2D and 3D engine for games, apps, and interactive UI. Build with your coding agent through the Rive CLI, or by hand with professional design and animation tools in the Rive Editor. Use Rive as your whole engine, or add it to the products you already have. Open-source runtimes, no royalties or runtime fees. The runtimes play Rive files natively on web, mobile, desktop, game engines, consoles, smart TVs, and cars.
Rive covers everything from small in-app moments, to in-game UI, to complete standalone experiences. Art, motion, and logic live in small, fast Rive files (`.riv`), and those files are what ship. Developers and agents don't rebuild the design in code. They load the file and bind data to it.
Products built with Rive reach over 2 billion users. Teams at Spotify, Duolingo, Disney, and Riot Games ship with Rive.
## Two ways to use Rive
### As your whole engine
Build the entire experience in Rive: a game, an in-car HMI or instrument cluster, a product configurator, or an interactive world. A Rive file can hold vector graphics, raster images, and 3D models with cameras, lights, and shaders in the same scene, plus state machines, data binding, responsive layouts, text, audio, and scripts. The Rive Renderer draws it, and it is light enough for an underpowered car GPU, so you can build experiences where you wouldn't run HTML or a full game engine. A game built this way reaches more than the browser: consoles, native mobile apps, and desktop, from the same Rive files. The C++ runtime publishes a game natively to iOS, Android, Windows, macOS, Linux, Steam and Steam Deck, and the web, and Rive provides runtimes for PlayStation 5, Xbox Series X, and Nintendo Switch on request. More: [Rive game engine](https://rive.app/games).
### Inside the products you already have
Rive drops into any web page, app, or game as one component. Add it to an existing React, iOS, Android, Flutter, Unity, or Unreal codebase for animated UI, onboarding, characters, data visualizations, game HUDs, or in-app moments. Your app drives the file through data binding (view models), and the same file runs on every platform you ship. Most products use Rive and HTML (or native UI) side by side.
## How to get started
1. Start with one prompt in your coding agent, for example: "Install the Rive CLI from rive.app/cli. Let's build an HMI instrument cluster for an electric car."
2. The agent installs the Rive CLI, creates a project, writes the scene in Rive Markup Language (RML), and opens the CLI preview window. The preview rebuilds every time the agent saves, and the agent checks its own work in it.
3. Keep directing it with notes, like you would give a designer: lighting, timing, layout, performance, polish.
4. Push the file to a Rive account and open it in the Rive Editor to draw, rig, and animate by hand. The agent pulls those changes and keeps going.
Works with Claude Code, Codex, Cursor, Hermes, OpenClaw, and any agent that can edit files and run shell commands on your computer. The CLI runs on macOS (Apple Silicon), Windows, and Linux. No account is needed to build and preview.
Tip for agents: most models learned before the Rive CLI existed. Read the CLI's built-in docs as you work, and name the specific Rive features you plan to use (state machines, data binding, layouts, GPU Canvas, scripting).
## Install the Rive CLI
- macOS and Linux: `curl -fsSL https://releases.rive.app/cli/install.sh | bash`
- macOS with Homebrew: `brew install --cask rive-app/tap/rive-cli`
- Windows (PowerShell): `irm https://releases.rive.app/cli/install.ps1 | iex`
Core commands:
- `rive create myproject`: scaffold a project (`rive.yaml`, `scene.rml`, `AGENTS.md`, `CLAUDE.md`). Agents should read `AGENTS.md` first: it says how to look things up and how to check your work.
- `rive myproject`: open the preview window, which rebuilds on every save. Leave it running in its own terminal.
- `rive docs`: the CLI's built-in documentation. New to Rive, start here.
- `rive samples`: pick a runnable example project and copy it.
- `rive schema <Type>` and `rive schema --search <term>`: look up the properties of any type in the Rive object model.
- `rive inspect`: print the resolved scene, to confirm what it actually contains.
- `rive myproject --verify`: check the project without writing a .riv. Exits 1 on errors.
- `rive myproject --screenshot`: build, render one frame headless, and write a PNG, so you can see what you made.
- `rive myproject --test`: run script tests headless. Exits 1 on failures, so a failing test fails the build.
- `rive myproject --publish`: write the signed .riv you ship. Needs `rive login`.
- `rive myproject --publish=web`: build, sign, and publish a web page you can share. Needs `rive login`.
- `rive login`, `rive push`, `rive pull`: sign in, send the project to a file in your Rive account, and bring down changes made in the Rive Editor.
- `rive doctor`: check the environment (version, sign-in, ports, project) when something doesn't work.
Work in stages instead of building everything at once: start with a wireframe, then add structure, content, motion, and detail. Layout and sizing problems are easier to catch early. After each change, run `--verify` and look at a screenshot.
## The Rive CLI
The CLI builds Rive files from Rive Markup Language, a plain-text format that agents can read and write.
- Check what you built: confirm a scene compiles, inspect what it contains, look up any type in the Rive object model, render frames without a window, and drive the scene with real or simulated input and data. Run the same checks in CI.
- Text you can diff: a project is a folder of plain text and assets, so it lives in Git or Perforce next to your app code, and every change reviews as a readable diff.
- Work offline: write, preview, verify, and test without a connection. Sign in to publish or to sync with the Rive Editor.
- Publishing compiles and signs your scripts, and runtimes refuse any script that isn't signed.
Links:
- [Rive for AI agents](https://rive.app/agents): The CLI, AnimaScript, and how to set up your agent.
- [Rive CLI overview](https://rive.app/docs/cli/overview.md): Create, preview, inspect, and publish Rive graphics from the command line.
- [Getting started](https://rive.app/docs/cli/getting-started.md): Install the CLI, create a project, and open the preview. Start here.
- [Working with AI agents](https://rive.app/docs/cli/agents.md): Pair the CLI with Claude Code, Cursor, or another agent.
- [Command reference](https://rive.app/docs/cli/reference/commands.md): Every Rive CLI command.
- [Project configuration](https://rive.app/docs/cli/reference/project-config.md): Project layout and settings.
- [Examples](https://rive.app/docs/cli/examples.md): Sample projects and headless rendering.
- [Rive Markup Language (RML)](https://rive.app/docs/runtimes/advanced-topic/rml.md): The text format that describes a Rive scene.
- [Downloads](https://rive.app/downloads): The Rive CLI and the Rive Editor desktop app.
## Ship the file in your app
Developers and agents add Rive to an app by loading the `.riv` file with a runtime and binding data to it. The app doesn't redraw the design in code.
- Artboards hold the scene. State machines hold the interactive logic. View models (data binding) are the interface between the file and your code: your app sets properties (numbers, strings, booleans, colors, enums, lists, triggers) and listens for changes. Prefer data binding over the older state machine inputs and events.
- On the web, use `@rive-app/webgl2` for most projects. It draws with the Rive Renderer, the same renderer as the Rive Editor, so everything renders the way it was designed. 3D and shaders (GPU Canvas) need `@rive-app/webgl2` 2.42.0 or later and `enableGPUCanvas: true`.
- Always name the state machine and set `autoBind: true`, then read and write properties through `viewModelInstance`.
- Before you target a platform, check which features each runtime supports.
```js
import { Rive } from "@rive-app/webgl2";
const r = new Rive({
src: "scene.riv",
canvas: document.getElementById("canvas"),
stateMachine: "State Machine 1",
autoplay: true,
autoBind: true,
onLoad: () => {
r.resizeDrawingSurfaceToCanvas();
r.viewModelInstance.number("speed").value = 88;
},
});
```
- `.riv` is the runtime file your app or game loads. `.rev` is the Rive Editor file (`rive myproject --publish --rev=<path>`, needs `rive login`).
- Free exports play a Rive splash screen. Exporting without it needs a paid plan.
- The runtimes are open source under the MIT license. The Rive Editor and the Rive CLI are Rive products with free plans.
Links:
- [Web runtime: getting started](https://rive.app/docs/runtimes/web/web-js.md)
- [Data binding on the web](https://rive.app/docs/runtimes/web/data-binding.md)
- [Canvas vs WebGL2](https://rive.app/docs/runtimes/web/canvas-vs-webgl.md)
- [GPU Canvas on the web](https://rive.app/docs/runtimes/web/gpu-canvas.md)
- [Feature support by runtime](https://rive.app/docs/feature-support.md)
- [Migrating from inputs and events to data binding](https://rive.app/docs/editor/data-binding/migration-guide.md)
- [Best practices](https://rive.app/docs/getting-started/best-practices.md)
## AnimaScript
AnimaScript is Rive's scripting language: TypeScript syntax, compiled to WebAssembly. Scripts your engineers can sign off on.
- Reviewed like your code: every script is a `.as` text file in your repo. Engineers, Copilot, or your own agent review it in a pull request, with the same approvals as everything else you ship.
- Signed: publishing signs your scripts. Runtimes refuse scripts that are unsigned or changed after signing.
- Sandboxed: scripts run in a WebAssembly sandbox and only reach the Rive APIs the runtime gives them. A bad pointer stops the script instead of touching your app's memory.
- Tested in CI: write tests next to your scripts and run them headless with `rive --test`.
- Near native speed: compiled ahead of time, AnimaScript decodes Draco meshes 8.7x faster than the previous scripting runtime. Existing scripts keep working.
Links:
- [AnimaScript introduction](https://rive.app/rasc/docs/introduction.html)
- [Execution lanes and benchmarks](https://rive.app/rasc/docs/execution-lanes.html)
- [AnimaScript compiler (rasc)](https://rive.app/rasc/index.html)
- [Scripting in a Rive file](https://rive.app/docs/scripting/getting-started.md): scripts for logic, procedural motion, custom drawing, layouts, converters, path effects, and transitions.
- [WGSL shaders](https://rive.app/docs/scripting/wgsl-shaders.md): Custom shaders rendered in Rive.
## The Rive Editor
The Rive Editor is where your team shapes the file by hand, with professional design and motion tools built for the format. It opens the same file your agent builds. There is a desktop app for macOS and Windows and a web editor that needs no install. Open the Editor at https://editor.rive.app.
- Rigging: bones and meshes for vector and raster art, with Auto Trace and Auto Weights.
- State machines: interactivity without code. Logic and animation live in the same file.
- Data binding: drive any property from live data in your app or game.
- Layouts: responsive UI that reflows to fit any screen.
- Text: crisp at any size and animated letter by letter. Text Follow Path sets text along any path.
- GPU Canvas: 3D models, cameras, lights, and shaders in the same scene as your vectors.
- Scripting: AnimaScript for logic, procedural motion, and custom drawing, right inside the file.
- Components and Libraries: build a part once and reuse it everywhere. Publish components, view models, and scripts once and use them across files.
- Scrolling: vertical, horizontal, or free scrolling with physics, for lists, carousels, and long pages.
- Joysticks: map timelines to a handle's X and Y, drag it to scrub a head turn or a look, then key the handle itself.
- N-Slicing: resize images and vector groups while corners and edges keep their shape.
- Vector Feathering: soft edges and glows on vector fills and strokes without the cost of a blur.
- Graph Editor: shape every ease by hand.
- Brush tools: draw freehand with varying width. Each stroke keeps its spine, so you can reshape it later.
- Accessibility: screen reader semantics, keyboard and gamepad focus, and reduced motion, authored in the file.
- Imports: SVG, Photoshop, and Adobe Animate (.fla) files. In a Flash import, symbols become artboards and frame labels become a state machine.
- Built-in AI Agent: ask it to write scripts, build layouts, and animate, inside the Editor.
Links:
- [Rive Editor](https://rive.app/editor)
- [All features](https://rive.app/features)
- [Editor docs: introduction](https://rive.app/docs/getting-started/introduction.md)
- [State machines](https://rive.app/docs/editor/state-machine/state-machine.md)
- [Data binding](https://rive.app/docs/editor/data-binding/overview.md)
- [Layouts](https://rive.app/docs/editor/layouts/layouts-overview.md)
- [Bones](https://rive.app/docs/editor/manipulating-shapes/bones.md) and [Meshes](https://rive.app/docs/editor/manipulating-shapes/meshes.md)
- [Joysticks](https://rive.app/docs/editor/manipulating-shapes/joysticks.md)
- [Libraries](https://rive.app/docs/editor/libraries.md)
- [Accessibility: semantics](https://rive.app/docs/editor/accessibility/semantics.md)
- [AI Agent](https://rive.app/docs/editor/ai-agent/ai-agent.md)
## Figma to Rive
A Figma file is always a mockup that someone has to translate into code. Point your coding agent at the Figma file, and it rebuilds the screens in Rive as a working app with interactive motion, reusable components, data binding, scrolling lists, and animated transitions. Agents read Figma files through Figma's MCP server and build the Rive file with the Rive CLI. Then open the file in the Rive Editor and keep designing the real product. Your Rive file becomes the source of truth for the product and for design: your team refines it in the Editor, and your agent ships that same file.
Agents can also start from SVG, Lottie, or your own code.
- [Figma to Rive](https://rive.app/figma-to-rive)
## Rive or HTML
Coding agents reach for HTML by default, and for many pages that's the right call. Most products use both.
Use Rive when:
- It has to run smoothly everywhere you ship: it plays natively on web, iOS, Android, desktop, game engines, consoles, TVs, and cars, drawn by the same runtime.
- You don't want a rewrite per platform: your agent edits the Rive files once, not separate web, Swift, and Kotlin code that drift apart.
- You'd otherwise combine many libraries: rendering, layout, text, animation, 3D, audio, and input are built into one engine, so your agent uses them instead of writing and maintaining its own.
- A lot moves at once: characters, layered vector animation, and interactive scenes that get heavy as DOM or SVG animation.
- It's a game that should reach more than the browser.
- Your team will refine it by hand, with a Graph Editor, timelines, bones and constraints, animation joysticks, and state machines.
- It needs what HTML can't do natively: rigging, constraints, N-slicing, text animation, and data binding, built into the format instead of hand-written code.
- The logic has to behave the same everywhere: state machines, data binding, and scripts in the file run on every Rive runtime.
- It has to stay small: compact files instead of video, image sequences, or a large JavaScript bundle.
- It needs to be accessible: screen reader semantics and keyboard and gamepad focus are authored in the file.
Use HTML when:
- It's mostly text, documents, or forms on the web.
- It needs to be found through search, like articles and docs.
- It's a simple web-only effect your agent can write in a few lines of CSS.
- It's standard web UI built from ordinary components: settings, menus, and tables.
- [Rive vs HTML](https://rive.app/rive-vs-html)
## Runtimes and platforms
Open-source runtimes play the same Rive file natively on every platform. The runtimes are MIT licensed: no royalties, no revenue share, no runtime fees. Rive also runs on consoles (PS5, Xbox, Switch), smart TVs, cars, and custom hardware.
- [Runtimes overview](https://rive.app/runtimes)
- [Getting started with the runtimes](https://rive.app/docs/runtimes/getting-started.md)
- [Web (JS/WASM)](https://rive.app/docs/runtimes/web/web-js.md)
- [React](https://rive.app/docs/runtimes/react/react.md)
- [React Native](https://rive.app/docs/runtimes/react-native/react-native.md)
- [Apple (iOS, macOS)](https://rive.app/docs/runtimes/apple/apple.md)
- [Android](https://rive.app/docs/runtimes/android/android.md)
- [Flutter](https://rive.app/docs/runtimes/flutter/flutter.md)
- [Unity](https://rive.app/docs/game-runtimes/unity/unity.md)
- [Unreal Engine](https://rive.app/docs/game-runtimes/unreal/unreal.md)
- [Defold](https://rive.app/docs/game-runtimes/defold.md)
- [C++](https://rive.app/docs/runtimes/cpp/overview.md)
- [Choosing a renderer](https://rive.app/docs/runtimes/choose-a-renderer/overview.md)
- [Rive Renderer](https://rive.app/renderer): Draws vector, raster, and 3D graphics on the GPU devices already have, with crisp text at any size. Open source under the MIT license.
- [.riv file format](https://rive.app/docs/runtimes/advanced-topic/format.md)
- [Rive on GitHub](https://github.com/rive-app)
Rive is also built into Framer, Webflow, and Wix Studio.
## Why teams choose Rive
Rive holds the design, code, and motion, and what you build is what ships.
- Faster time to market: designers, animators, developers, and agents all work in Rive, so there's no handoff and nothing to rebuild for each platform.
- Agent speed, artist control: your agent builds with the Rive CLI in hours instead of weeks. Then your team refines it by hand in the Rive Editor, with professional tools for rigging, timelines, state machines, and data binding.
- Lower cost: no revenue share, no runtime fees, no royalties, and MIT open-source runtimes. One engine covers every screen, from the car dashboard to the phone app, so there's one thing to build, review, and maintain.
- Higher quality: vector, raster, and 3D in one scene, drawn by the Rive Renderer.
- No translation, no handoff, no drift: change the file, and every platform gets the same change.
## Pricing
The Rive CLI is free to install, and you need no account to start. Building is free, and so are the runtimes. Free exports play a Rive splash screen. Exporting a file without the splash screen needs a paid plan.
- Free: Rive Editor, CLI with limits, AI Agent with limits, 3 collaborative files, exports with a splash screen.
- Cadet (up to 3 seats): everything in Free, plus exports without the splash screen and unlimited files.
- Voyager (up to 25 seats): everything in Cadet, plus Libraries, embed URL hosting, and the AI Agent with advanced models, monthly Agent credits, top-up credits, and your own Agent API key.
- Enterprise (organizations with $10M+ annual revenue): everything in Voyager, plus subteam workspaces, a custom S3 bucket, org-wide permissions, dedicated support, onboarding and training, custom runtimes for your own platforms or hardware, centralized billing, SSO, and SOC 2 Type II.
- [Pricing](https://rive.app/pricing): Current prices and plan details.
- [Enterprise](https://rive.app/enterprise)
## Common questions
- Do I need an account? No account is needed to install the CLI, build, and preview. Sign in to publish or export a file, to open it in the Rive Editor, or to go past the free usage limits.
- Can't my agent just write HTML, CSS, and JavaScript? It can, and for one simple web animation that won't change, that's often faster. Character rigging, constraints, N-slicing, joysticks, text animation, and data binding are native to Rive. In HTML you'd write and maintain them in code and keep them fast on every platform. In Rive they're part of the file, and the same file runs every