Rive graphics

A native Rive graphic stores exact .riv runtime bytes, one artboard, one state machine, and LIGR configuration. LIGR renders it through the native Rive runtime inside an isolated browser frame.

You can start in the dashboard Rive Graphics Builder or use the REST API. Both paths use the same backend preparation and create the same working graphic. Create, drop, and replace actions share this preparation and publication workflow.

Input	What LIGR does	Source archive
`.riv`	Inspects and stores the supplied runtime unchanged	Unavailable. Runtime revisions already preserve these bytes
`.rev`	Extracts the project and compiles a runtime	Exact uploaded file, with explicit retention
ZIP with `.riv` and assets	Inspects the unchanged runtime and stores supplied playback images	Complete original archive, with explicit retention
ZIP with `.rev`	Selects the editor file and compiles a runtime	Complete original archive, with explicit retention
Complete RML project ZIP	Validates `rive.yaml`, dependencies, and output, then compiles	Complete original project archive, with explicit retention

RML means Rive Markup Language. A lone .rml file is not a general project interchange format. A complete project contains rive.yaml and every referenced dependency.

ZIP sibling files must use the exact uniqueFilename reported by Rive. Duplicate matching filenames remain unresolved. LIGR does not guess a match from the display name.

Supplied playback images remain available when source retention is off. A runtime with missing external images can become a draft. Its metadata marks those images as unresolved. Resolve them through the builder’s image uploads or bindings before using the graphic on air. Known default image dimensions remain available even when the external image is missing.

Use these pages:

Page	What it covers
How it works	Runtime isolation, bindings, lifecycle, versions, and control-room updates
Import through REST	Executable upload, polling, selection, creation, publication, and setup calls
Source files	Consent, temporary processing, cleanup, and exact original downloads
Local RML project	The licensed scorebug project, pinned compiler, and verified LIGR configuration

Rive and the Rive CLI

Rive is a tool for interactive, real-time graphics. Designers build a graphic in the Rive editor. Rive exports it as a .riv runtime file or saves it as a .rev editor file.

The Rive CLI builds the same files in a terminal, without the editor. It reads RML, a text format for Rive scenes. It compiles RML to a .riv file and shows a live preview while you edit. Local RML project names the CLI version that LIGR tests with.

Build graphics with an AI agent

The Rive CLI works with a general AI agent from Anthropic (Claude), OpenAI (ChatGPT or Codex), or another provider. The agent writes the RML text. You make the graphic with prompts, not code.

Run rive create to start a project. It writes AGENTS.md and CLAUDE.md with instructions for the agent.
Describe the graphic to the agent, or give it a design image. The agent writes the scene in RML.
Watch the live preview. Tell the agent what to change.
Import the project into a theme. See Import through REST.
Bind the graphic to live match data and control variables. See How it works.

The result is a live overlay graphic. The score, the clock and the lineups update from the match. Operators show, hide and change the graphic from the control room.

Give the agent this documentation too. For AI agents lists the machine-readable pages and the rules an agent must follow.

Rive graphics and the Graphics SDK

Native Rive graphics do not implement the code-graphics ligr.gfx.v1 protocol. They do not use @ligrsystems/graphics-sdk or its browser createGraphic() function.

Browser SDK createGraphic() starts a code-graphic runtime listener in a web page. REST graphic creation stores a native Rive candidate in a theme.

Use the Graphics SDK for HTML, CSS, and JavaScript graphics. The SDK installation guides identify the matching package release. Native Rive imports do not require those packages.

Security boundaries

Browser expression functions and native runtime handles stay inside the isolated renderer. The application supplies selected runtime bytes and fetches permitted public resources without cookies or referrers.

Public image URLs can disclose renderer data through request URLs. The resource bridge executes in the browser and is not a server-side fetch proxy.

Theme-writing API keys are trusted authoring credentials. Static expression validation complements browser isolation and does not replace careful authoring.

Code graphics retain browser network access. Their module and font assets require anonymous CORS.