Features
Font data binding
Fonts can now be assigned to view model font properties with ViewModelInstance.setFont(propertyPath, font). Pass a FontAsset to replace the font or null to clear it. The property retains its own reference, so the font can be closed after assignment. Changes appear on the next state machine advance. (Change, Native support)
Experimental focus control
StateMachine now exposes focusNext(), focusPrevious(), and clearFocus(), plus focusState and hasFocusNodes flows, behind @ExperimentalRiveFocus. Hosts can call pollFocus() after advancing to refresh the observed state. Focusable containers can participate in traversal alongside their children. (Change, Traversal behavior)
This is the first half of focus integration, providing the APIs needed for host integration. Work on the second half is underway and will arrive in the next minor release, adding automatic keyboard event routing and focus polling to the Rive composable. In this release, hosts must handle those responsibilities themselves. Rive focus is separate from Android view, Compose, and TalkBack focus.
Native crash symbols
Native debug symbols are now published as a separate symbols ZIP, allowing native crash addresses to be resolved to useful stack traces while keeping the runtime library stripped. The artifact is app.rive:rive-android:11.13.0:native-symbols@zip and contains companions for all supported ABIs. It is downloaded only when explicitly requested. See the retrieval instructions. (Change)
Text and layout
Scripts can now access fonts, decode font bytes, and lay out styled text. The new text APIs expose shaped lines and glyphs for custom drawing and animation, including bidirectional text. (Change)
Layouts can also honor the unbounded-hug option configured in the Rive Editor, allowing hugged text and shapes to extend beyond size limits imposed by ancestor layouts. Existing content keeps its bounded behavior by default. (Change)
Scripted rendering
Scripts can read custom properties attached to drawables and use them to control color modulation or custom drawing. Instanced image-mesh drawing also allows many copies of a mesh to share a draw call while varying their transforms, opacity, and texture coordinates. (Change, Change)
With GPU Canvas enabled on Vulkan, context:gpuTarget() lets scripts draw GPU passes directly into Rive's render target beneath its normal content. The target cannot be sampled, and the first pass must clear or fully cover it. This direct-target path is not available on Android OpenGL. (Change)
Additive blending
This release supports the additive strength configured on Normal blending in the Rive Editor, including animated and data-bound strength. Authoring is currently available through the Editor's early-access feature. The Rive renderer supports the full 0–100% range. Legacy Android Canvas rendering uses full-strength additive blending. (Change)
Listener input values
Listener actions can now write the pointer position or movement delta that triggered them into view model properties, including through converters. This allows interactions configured in the Rive Editor to pass input values into data binding during Android playback. (Change)
Fixes
- OpenGL cleanup: Closing a rendering surface could leave EGL holding it after its Android backing objects were released, producing surface-disconnect and leaked-buffer warnings. Worker teardown could also issue GL cleanup calls after unbinding the context. Surface and GPU-resource destruction now happen with the appropriate context current. (Fix, Fix)
- Vulkan rendering: Surface rotation could produce stretched output, and unused triangle-buffer entries could cause device loss on Mali-G715 GPUs. Swapchain orientation and triangle-buffer padding now handle these cases. (Fix)
- Font fitting: Vertically trimmed text in a hug layout could shrink too far and reintroduce unwanted space. Fitting now accounts for the trim correctly. Extremely large or infinite font sizes also no longer leave the fitting search looping indefinitely. (Fix, Fix)
- Hidden content and input: Hidden nested artboards and component lists could intercept pointer hits intended for visible content. They now stay out of hit testing. Collapsed content also stops writing uncomputed values back through data binding. (Fix, Fix)
- Component lists: Scrolling to a row without a corresponding artboard could crash. Such rows now provide empty bounds. Virtualized lists also release focus-row nodes that previously leaked. (Fix, Fix)
- Inverse kinematics: An inactive or partially weighted IK constraint could overwrite rotation applied by another constraint on the same bone chain. IK now blends from the appropriate incoming pose. (Fix)
- Skinned fills: Bone-bound paths could disappear or fill incorrectly after mirroring, or when a rig loaded in a folded pose. Winding calculations now use the bind pose and handle small curved paths accurately. (Fix, Fix, Fix, Fix)
- Trimmed strokes: Trimming certain curves could produce stray hairlines, detached caps, or missing stroke segments. Trim calculations now preserve coincident control points. (Fix)
- Shape bounds: Local bounds could change incorrectly when a shape containing an offset path was rotated or scaled. Bounds now compose those transforms in the correct order. (Fix)
- Script view models: Repeated
context:viewModel()calls could create excessive wrapper objects and eventually stall playback. Wrappers are now reused and refreshed when the data context changes. (Fix) - Script return values: A converter or path-effect script returning an unexpected value could crash the runtime. Return types are now checked before use. Nested animations also release their binding resources before their artboard is destroyed, and scripted interpolators free their input objects. (Fix, Fix)
- Script pointer events: Node-script pointer handlers could report every event as
pointerEnter. They now report the event type corresponding to the handler. (Fix) - File-loading crashes: Missing view model references, cyclic instance graphs, or objects that failed import could cause invalid memory access or unbounded recursion. Loading now validates those references, handles cycles, and keeps failed objects alive until import resolution is complete. (Fix, Fix)
- GPU Canvas images and lifetime: Sampling a decoded image through
Image:view()could silently produce no output. Image resolution now follows the correct asset path, and resized or released canvases retain their backing resources until rendering has finished using them. (Fix, Fix) - GPU Canvas textures: Rendering into nonzero mip levels could use the wrong dimensions or synchronization range. Passes now use the selected mip level. Vulkan canvas sampling also refreshes image layouts correctly and respects the features enabled by the host. (Fix, Fix)
Performance
Idle state machines and component lists now skip transition searches and row updates that cannot change their output. Blend states avoid repeatedly writing intermediate values, and layout participants can settle instead of triggering a fresh layout calculation every frame. Layout animations and virtualized lists also perform less work during movement and scrolling. (Change, Change, Change)
Moving shapes and layouts now preserve reusable path geometry and tessellation. Bounds calculations avoid copying paths, and hidden shapes skip unnecessary effect work. Effects are refreshed when hidden paints become visible again. These changes reduce CPU work and allocations, particularly in complex rigs and scrolling scenes. (Change, Change, Change, Visibility handling)
Android now caches its decoded default system fallback font, avoiding repeated font loading and decoding during text shaping. This benefits both APIs. (Change)
Renderer changes reduce vertex-shader work for path drawing. (Change, Change)