feat(ore): scripts render GPU passes into our render target (#14436) cf39effc4d * feat(ore): scripts render GPU passes into Rive's render target under its content * fix(ore): utf8 dash in the target GM wrapper * feat(ore): scripts render into our Metal target and top down GL texture targets * feat(ore): our iOS, Flutter Metal, Android Vulkan, recorder and cli hosts expose their target * fix(ore): leave the Vulkan host target an attachment after a pass, and add its goldens * feat(ore): our Windows Flutter host exposes its target to scripts * feat(ore): our Unreal host exposes its render target to scripts * fix(scripting): move GPUTarget off the userdata tag Text now uses * test(ore): target gm goldens for web, android, iossim and streamer lanes * refactor(ore): share target descriptions across hosts and drop the lazy target claims * fix(ore): release the target after each frame, skip a resized one, refuse sampling it and keep its view while hidden * fix(scripting): report stale target views and share one target object per script * perf(ore): leave the D3D12 target a render target across script passes * test(ore): run the target parity family, cover a failed wrap and expose the Android Vulkan target * fix(renderer): skip the D3D12 target transition when Ore already left it a render target * fix(ore): free the D3D12 host target wrap on release so the host can resize its swapchain * fix(scripting): stop leaking the target view when a target pass raises a Lua error * fix(rive_native): acquire the Windows swapchain texture before Ore replays so both draw into it * test(unreal): expose the gm window's target so the target gm draws through Ore * test(unreal): keep the gm window's target hidden until preserve works on our Unreal gm lane * test(ore): overshoot the target GM fallback so a short edge cannot blend the last frame * test(ore): android vulkan target goldens now that the lane draws through Ore * fix(ore): clear a target resized since a script drew into it * fix(evi): read window size and format safely off the render thread and keep srgb targets hidden * fix(ore): expose the current back buffer from the d3d12 fiddle * fix(scripting): keep the AS pass desc intact, hold the target from init, and match Luau and AS on hidden and stale targets * fix(scripting): drop the target view rcp before a pass can raise, and regenerate the wasm host stubs * docs(scripting): read the target view each frame since a kept one errors after a resize * chore(rasc_site): rebuild the repl Co-authored-by: Luigi Rosso <luigi-rosso@users.noreply.github.com>
Rive's C++ runtime — the lowest-level Rive runtime. Loads .riv files, advances state machines and animations, and draws via the abstract Renderer interface. The built-in GPU renderer (RiveRenderer) has RenderContextImpl backends for Metal, Vulkan, D3D11, D3D12, and OpenGL/WebGL.
Rive's Apple, Android, Flutter, Unity, Unreal, and web runtimes all wrap this library.
Features:
.riv files.Artboard::advance.Renderer interface for hooking up an external vector renderer.xcode-select --install).apt install clang).premake5 on first run. On Windows, install Git for Windows and during setup pick “Use Git and optional Unix tools from the Command Prompt” so that sh.exe ends up on PATH.The build is driven by premake5 wrapped by a helper script:
build/build_rive.sh — macOS / Linux (bash) / Windows (MinGW).build/build_rive.ps1 — a PowerShell convenience wrapper for Windows; it shells out to the bash script, so a bash environment (Git for Windows / MinGW, see Prerequisites) must still be on PATH.The helper self-installs the pinned premake version on first run and dispatches to the right build system for your platform (gmake2 on macOS/Linux, MSBuild on Windows). It must be run from a directory that contains a premake5.lua — typically tests/, which builds the core library, the GPU renderer, and the player sample app.
git clone https://github.com/rive-app/rive-runtime.git cd rive-runtime/tests ../build/build_rive.sh release
git clone https://github.com/rive-app/rive-runtime.git cd rive-runtime\tests ..\build\build_rive.ps1 release
(On Windows, substitute build_rive.ps1 for build_rive.sh.)
build_rive.sh (no args) — debug build for the host.build_rive.sh release clean — clean then build release.build_rive.sh ninja release — use Ninja instead of make/MSBuild.build_rive.sh ios release — cross-compile for iOS.build_rive.sh android release — cross-compile for Android (defaults to arm64).build_rive.sh ninja release wasm — cross-compile for WebAssembly.build_rive.sh --toolset=msc release (Windows) — build with MSVC's cl.exe instead of clang-cl. The build supports both toolchains; the lua warning suppressions cover MSVC too.See the comment header at the top of build/build_rive.sh for the complete flag reference.
Artifacts land in out/<config>/ relative to the directory you built from (typically tests/). The config directory encodes any OS/arch flags you passed:
out/release, out/debug — host build.out/ios_release, out/android_arm64_release, out/wasm_release — cross-compile builds.| Artifact | Description |
|---|---|
librive.a / rive.lib | Core runtime library. |
librive_pls_renderer.a / rive_pls_renderer.lib | GPU renderer. |
player / player.exe | Sample app — loads and renders a .riv file. |
out/<config>/goldens, out/<config>/gms, out/<config>/bench | Test harness binaries (regression, golden-image, benchmarking). |
librive_decoders.a, librive_harfbuzz.a, … | Supporting libraries. |
The runtime's primary form of testing is golden testing — rendering known scenes and diffing the output against checked-in reference images via the goldens and gms test harness binaries (built into out/<config>/goldens and out/<config>/gms). See tests/ for how to run and rebaseline goldens.
Unit tests are secondary and use the Catch2 framework. From the repo root:
cd tests/unit_tests ./test.sh
Unit tests live in tests/unit_tests/runtime/ (core runtime) and tests/unit_tests/renderer/ (renderer). To add a test, create an xxx_test.cpp file in the appropriate directory — the harness picks it up automatically.
rive-runtime uses clang-format.
brew install clang-format.clang-format.exe alongside clang-cl.exe at C:\Program Files\Microsoft Visual Studio\2022\<edition>\VC\Tools\Llvm\x64\bin\. You can also install LLVM standalone from llvm.org or via winget install LLVM.LLVM.apt install clang-format).To run the tests under macOS's built-in leaks tool:
cd tests/unit_tests ./test.sh memory
This wraps the test binary with leaks --atExit, which ships with macOS — no install required. The memory flag is ignored on Linux and Windows.
To inspect generated assembly per cpp file, install the Disassembly Explorer VSCode extension. A disassemble task is provided in .vscode/tasks.json. The underlying gen assembly task invokes clang++ directly, so it needs clang++ on PATH — works out of the box on macOS (Xcode CLI tools) and most Linux distros, but not on a default Windows + VS install (which provides clang-cl.exe, not clang++.exe).
Reach the task from Tasks: Run Task, or bind a key in keybindings.json:
[ { "key": "cmd+d", "command": "workbench.action.tasks.runTask", "args": "disassemble" } ]