RAV: Free Open-Source Tool for Rive Animation Workflows

Rive Animation Viewer (RAV) is a free, open-source desktop and web tool for inspecting, debugging, and exporting .riv animation files. Built for working Rive professionals — animators, developers, and AI agents — who need to look inside a file without standing up a project around it.

It runs on macOS (Apple Silicon + Intel), Windows, and the web. The desktop build is a Tauri shell with a Vite/JavaScript frontend and the official Rive runtime. Source: github.com/ivg-design/rive-animation-viewer.

Working in Rive professionally means constantly answering questions the editor can't show cleanly: what does this state machine look like at runtime? What ViewModel paths exist on this artboard? What inputs does this state machine actually accept? How does this animation render at fixed pixel dimensions on Windows vs macOS, in WebGL2 vs Canvas? Most of this requires spinning up a project, wiring the runtime, and writing scaffolding code just to see the file behave.

I wanted a tool I could drop a .riv file into and immediately see everything — VM tree, state machine inputs, runtime data, the animation playing in any fit/alignment configuration, snapshot exports of the controls — without leaving the inspector.

Cross-platform desktop and web app. Tauri (Rust) shell with custom window chrome, rounded corners on macOS and Windows, signed updater flow.

ViewModel inspector and runtime control panel. Browse the full VM tree of any .riv file, read live values, fire triggers, drive state machine inputs.

Snippet and Export Controls dialog. Generate canonical web instantiation code (CDN or local-package), pick which ViewModel and state-machine values get serialized, export a self-contained HTML demo with embedded runtime, animation, and selected controls — no build step required to share with a developer.

Native Rust MCP sidecar with 31 tools. Bundled as a binary so users don't need Node.js. One-click setup detects and configures Codex, Claude Code, and Claude Desktop. AI agents can open files, switch artboards, set ViewModel values, fire triggers, configure workspace, and generate instantiation snippets remotely.

Live JS console with REPL. Newest-first transcript, filter, search, copy, follow, with structured timestamps and level chrome.

Explicit canvas sizing model. Settings for AUTO vs FIXED, editable pixel dimensions, aspect-ratio locking, editor canvasSize honoring. Generated snippets and exported demos preserve the active sizing mode.

Editor live-source signaling. The runtime can be driven by either RAV's internal wiring or live-applied editor code; the title block indicates which is active.

The 2.0 release was a full architecture refactor: app boot moved into focused modules, MCP frontend bridge under a platform layer, runtime/export/session/console/editor code grouped by domain, with dependency-cruiser rules and an architecture budget enforcing the new structure in CI.

Subsequent releases (through 2.2.3) added Windows DWM rounded-corner integration, signed updater flow with merged manifests across Apple Silicon, Intel macOS, and Windows, regression guards on the Tauri/WKWebView scrollbar quirk that caused a macOS regression in 2.2.1, and an rav_set_canvas_size MCP tool that mirrors the canvas sizing model into the agent surface.

The MCP bridge has been hardened against fresh-stdio first-call edge cases, post-reload reconnects, Windows installer-blocked file locks, and Claude's newline-delimited JSON probe format alongside standard MCP framing.

Released and maintained at forge.mograph.life/apps/rav and on the GitHub releases page. Auto-updater flow lets desktop users move from one signed build to the next. The MCP sidecar is stable enough that I drive it daily from Claude Code as part of my own Rive work — including on the State Farm NBA All-Star Celebrity Game and the AT&T Live Arena projects.

RAV is the inspector layer of the same Rive scripting ecosystem that includes LERP (the course) and Rive Luau LSP (the VS Code extension). A practitioner can author scripts in VS Code with LSP autocomplete, debug them against a real .riv file in RAV, and learn the language in LERP.