rive

• Bumps to rive_native: 0.2.0-dev.1. Updates the Rive C++ runtime and renderer for the latest features, bug fixes, and performance improvements.
• GPU Canvas support at runtime, enabled through deferred rendering.

Fixes

• Resolved an Android performance regression caused by Flutter merging the UI and platform threads, which could block Flutter’s raster thread while Rive rendered. The new deferred renderer resolves this by recording frame N+1 (UI thread) while drawing frame N (separate rendering thread). Unblocking Flutter's UI and raster thread.
• The new deferred renderer resolves OpenGL context corruption that could occur when Rive competed with other native rendering solutions, such as Mapbox.
• Corrected the minimum Flutter version to 3.32.0 (Dart 3.8.0). It was declared as 3.28.0, so older Flutter versions resolved this package and then failed to compile. See #643.

Deferred rendering

The Rive Renderer (Factory.rive) now uses deferred rendering on native platforms, and it is the only native mode. Each frame is recorded on the UI thread as a compact command stream and replayed on a dedicated render thread, so GPU work no longer blocks the UI thread. This results in substantial performance improvements, especially on Android where this new approach resolves a latent isue (see Fixes above).

Resources made with Factory.rive (paths, paints, images, text) are lightweight recording proxies that resolve during replay. Rendering behavior and output are unchanged for typical RiveWidget / file-based usage; the changes below matter when migrating advanced integrations.

Migrating:

• All Rive calls stay on the calling (UI) thread. The command stream has a single writer per frame, so advancing or drawing from other threads is not supported.
• Breaking: removes Rive.batchAdvance and Rive.batchAdvanceAndRender (and the native batch worker). Their worker threads recorded into the command stream concurrently and corrupted it. Advance and draw each state machine on the calling thread instead.
• RenderTexturePainter.riveFactory names the factory the painted content was made with, so the texture attaches its recording session (a sessionless texture draws nothing on native). Defaults to Factory.rive override with the decoded file's File.riveFactory when content records elsewhere (on web this opts single-file content into the per-file session worker path), or with null when the session is managed manually.
• One artboard instance per texture: showing the same artboard instance in two widgets leaves the later one blank, with a debug message. Create an artboard instance per widget.
• Factory.rive on native resolves to the render context's recording session. file.riveFactory == Factory.rive still holds, and resources created directly on Factory.rive record and render correctly.
• Advanced session control (manual attach/detach via RenderTexture.useDeferredSession, pacing, thread stats) is available through package:rive_native/rive_deferred.dart.

• Bumps to rive_native: 0.1.11. Updates the Rive C++ runtime and renderer for the latest features, bug fixes, and performance improvements.
• Adds RenderResolution to control how a Factory.rive texture sizes its backing store: display() (default — layout × device pixel ratio × ancestor paint scale), layout({scale}) (layout × device pixel ratio, ignores ancestor transforms), and fixed(width, height) (explicit physical pixels). Available on RenderTexture.widget, RiveArtboardWidget, and RiveProceduralRenderingWidget.
• Web behavior change: RenderResolution.display() now accounts for ancestor transforms on web, matching native — an upscaled widget renders sharp instead of stretched. Pass RenderResolution.layout() for the previous behavior.
• Adds RiveNative.instance.releaseRenderResources() to release cached render resources (web: pooled textures and the probe context), recreated on demand. No-op on other platforms.
• Adds RiveNative.debugRenderTextureLogging (web): logs render-texture create/reuse/release with live WebGL context counts.

Fixes

• Windows: fixed a crash or hang when disposing a render texture with a frame in flight, such as closing the app under load or the desktop going to sleep. The fence wait thread could outlive teardown and either touch a destroyed texture registrar or block shutdown indefinitely (see core runtime issue #86).
• Texture allocations under display and layout are capped at 4096 logical pixels per axis (aspect preserved), preventing runaway allocations under large ancestor scales.
• Web: canvas backing stores are clamped to the GPU's maximum render-target size.
• Web: render textures release their WebGL contexts on dispose (bounded reuse pool), browser-evicted contexts are purged instead of reused, and the MSAA probe context is released at startup — fixes context-limit exhaustion and permanently blank widgets.
• Changing RiveWidget.drawOrder / SharedTextureView.drawOrder on a mounted widget now restacks the shared-texture painters. Equal drawOrders stack in widget-tree order.

• Bumps to rive_native: 0.1.10. Updates the Rive C++ runtime and renderer for the latest features, bug fixes, and performance improvements.

Fixes

• Fixed a "RenderBox was not laid out" crash that could occur when a RiveWidget (Factory.rive) was painted during certain transitions. See https://github.com/rive-app/rive-flutter/issues/642.
• Rive Renderer (Factory.rive) rendering issues on Linux with later versions of Flutter (3.38+, see Flutter issue 182998)
• Various Rive scripting fixes and updates, notably:
  • Updated Luau to 0.728
  • Fixed the Lua Data global not being initialized, which left view model constructors such as Data.MyViewModel.new() unavailable to scripts

• Bumps to rive_native: 0.1.9. Updates the Rive C++ runtime and renderer for the latest features, bug fixes, and performance improvements.

Fixes

• Touch and stylus pointer up (and cancel) now also dispatch a pointer exit, so listeners receive a Pointer Exit when a finger or pen lifts. This keeps enter/exit symmetric on mobile and matches other Rive runtimes. Mouse and trackpad pointers are unaffected, their exit still comes from the pointer leaving the artboard/widget.
• Fixed a crash when using desktop_multi_window on Windows with MicroProfile GPU init

Changes

• RiveWidgetController now advances and applies the state machine with zero elapsed time after pointer down/up events. This ensures intermediate state, such as a view model property set on pointer down, is processed immediately, even when a pointer down and up occur within the same frame. Set it to false to opt out.
• Dropped the experimental tag from shared texture usage.

• Bumps to rive_native: 0.1.8. Updates the Rive C++ runtime and renderer for the latest features, bug fixes, and performance improvements.

Fixes

• Fixed Rive widgets blurring (Factory.rive) during parent rotation/skew animations.
• Fixed RivePanel painters never settling when multiple painters shared the same texture. Each painter previously owned its own ticker and the shared paint pass would re-call advance on settled siblings, accidentally reviving them. SharedRenderTexture now owns a single ticker that stops when every painter reports settled and restarts on new painters or wake notifications.
• Fixed shared-texture rendering for rotated, skewed, or mirrored RiveWidgets. The widget→panel transform now reaches the texture as a full 2D affine instead of being flattened to its scale diagonal, so the texture content matches how the Texture widget composites.
• Fixed RiveWidget swallowing controller swaps on a stable element (no Key) when drawing into a shared texture. The wrapping painter was bound to the original controller on first build and never rebuilt, so the new controller's state machine wasn't driving the on-screen artboard and disposing the old controller crashed at the native boundary.
• Improved RiveWidget and RivePanel (Factory.rive) flickering. The texture is reused and scaled during a resize and recreated at the new size once it settles.
• Fixed shared-texture (RivePanel) content not redrawing on a window resize that didn't change a child's size (e.g. a vertical resize of a fixed-width grid) — it previously only updated after an unrelated repaint.

Changes

• Deprecated RenderTexture.onTextureChanged in favour of addTextureChangedListener / removeTextureChangedListener, which allow multiple painters to share a single texture.
• Added RiveNativeRenderBox.textureResizeInterval to tune how often the texture is recreated while resizing.

• Bumps to rive_native: 0.1.7. Updates the Rive C++ runtime and renderer for the latest features, bug fixes, and performance improvements.

Breaking Changes

• Expose audio events through the Dart API. Event is a sealed class and EventType gains an audio value, so exhaustive switch statements over either now require a new AudioRuntimeEvent / EventType.audio arm.
• State machine event listeners now receive AudioRuntimeEvents alongside GeneralEvent and OpenUrlEvent. Listeners that branch on event type with non-exhaustive if/is checks will see the new type pass through unhandled.

Shared Texture API (Experimental)

• Add SharedRenderTexture.create() to construct a user-owned shared texture independent of the RivePanel lookup. Place it in the tree with the new RiveSurface widget and attach painters by passing the same instance to RiveWidget.sharedTexture. This lets a single native texture be shared across RiveWidgets that aren't ancestor/descendant of each other — siblings, separate subtrees, or across routes (e.g. via a Provider/Riverpod).
• Add RiveSurface widget that renders the native surface of a SharedRenderTexture anywhere in the tree. Wrapped in IgnorePointer by default; set ignorePointer: false to route pointer events to the texture widget.
• Add RiveWidget.sharedTexture parameter to draw into an explicit SharedRenderTexture, bypassing the ancestor-based RivePanel lookup. Takes precedence over useSharedTexture when both are set.
• SharedRenderTexture gained dispose() and isDisposed. Instances created via SharedRenderTexture.create() own their underlying native texture and must be disposed by the caller; instances constructed with an external texture are not affected.

Fixes

• Fixed an issue where setState on an ancestor of a RivePanel (or RiveSharedTexture) would allocate a new SharedRenderTexture wrapper on every rebuild, dirtying every descendant RiveWidget and detaching their painters from the previous wrapper. The wrapper instance is now stable across ancestor rebuilds, and RiveSharedTexture.updateShouldNotify compares by identity.
• Fixed an iOS "carousel flash" where a stale post-frame paint callback queued before the last painter detached could fire afterwards with an empty painter list and momentarily blank the shared texture. The paint pass now no-ops when there are no painters.
• Fixed an issue where a RiveWidget drawing into a RivePanel shared texture could render at the wrong size when an ancestor Transform.scale animated. The shared-texture path now reads the live local-to-panel transform on every paint instead of relying on a cached scale that composited ancestors (RepaintBoundary, Opacity layers, PageView's internal slots) could leave stale.
• Fixed a Windows crash in the rive_native removeTexture method channel handler when the texture id arrived as int32_t rather than int64_t. Most commonly seen when dragging the app window between displays with different DPI settings, or when rapidly creating/disposing render textures.

• Bumps to rive_native: 0.1.6. Updates the Rive C++ runtime and renderer for the latest features, bug fixes, and performance improvements.

Fixes

• Fixed 623 - Explicitly nil Metal ivars in dealloc to prevent use-after-free on teardown

• Bumps to rive_native: 0.1.5. Updates the Rive C++ runtime and renderer for the latest features, bug fixes, and performance improvements.
• Add optional viewModelInstance parameter to File.artboardToBind, allowing a ViewModelInstance to be bound to a BindableArtboard. When provided, the view model instance is set on the artboard property in the core runtime.

• Bumps to rive_native: 0.1.4. Updates the Rive C++ runtime and renderer for the latest features, bug fixes, and performance improvements.

Fixes

• Fixed an issue where RivePanel intercepted all pointer events. Hit testing now respects each RiveWidget's configured hitTestBehavior.

Build & Platform Updates

• Rive Renderer support for Linux
• Linux is now fully supported. Known issue: arm64 builds are not yet included; for now, build manually: https://rive.app/docs/runtimes/flutter/rive-native#building-rive-native
• Fixes a build issue where scripting build files were missing. We previously did not include the scripting folder, which is now required by other build files.
• Fixed a build issue when running ``dart run rive_native:setup --build`.
• Resolves dart run rive_native:setup concurrency issue rive-flutter#609. Downloads now use a unique temporary directory to support concurrent CLI runners.

• Bumps to rive_native: 0.1.3. Updates the Rive C++ runtime and renderer for the latest features, bug fixes, and performance improvements.

Build & Platform Updates

• Adds Swift Package Manager support. Resolves issue 557

• Bumps to rive_native: 0.1.2. Updates the Rive C++ runtime and renderer for the latest features, bug fixes, and performance improvements.
• Updated the minimum Flutter version to 3.28.0. The Android platform code requires the new onSurfaceCleanup and onSurfaceAvailable methods, see SurfaceProducer.
• Add enumType string getter to ViewModelInstanceEnum which returns the name of the enum (not the property name).
• Add valueStream<T> to data binding properties that are observable (implementations of ViewModelInstanceObservableValue), which returns a Stream<T>. For example:

ViewModelInstanceNumber? numberProperty = viewModelInstance!.number('age');
Stream<double> stream = numberProperty!.valueStream;

Fixes

• Fixed iOS/macOS build issues when using custom schemes and flavors. See issue 594.

• Adds runtime Rive Scripting support.
• Bumps to rive_native: 0.1.1. Updates the Rive C++ runtime and renderer for the latest features, bug fixes, and performance improvements.

Fixes

• Fixed 585 - missing artboard DataType enum.

Major release, see the updated docs and migration guide:

• https://rive.app/docs/runtimes/flutter/flutter
• https://rive.app/docs/runtimes/flutter/migration-guide#version-0-14-0

Bumps to rive_native: 0.1.0. Updates the Rive C++ runtime and renderer for the latest features, bug fixes, and performance improvements.

Fixes

• Fixed Android build issues in certain environments. See issue 555. Build commands are now executed from Gradle instead of CMakeLists, and the setup process automatically skips rive_native:setup if the required libraries are already downloaded.
• Fixed 570 - setState called after dispose. Add cancellation checks to prevent stale state updates.

Build & Platform Updates

• Android: Added support for skipping automated setup by setting rive.native.skipSetup=true in your app's gradle.properties. When enabled, you must manually run dart run rive_native:setup --verbose --clean --platform android to download the required libraries.

• Marks methods to access text runs and state machine inputs as deprecated. While this functionality won't be removed in the near future, we encourage adoption of data binding to future-proof your Rive usage.
• Bumps to rive_native: 0.0.17. Updates the Rive C++ runtime and renderer for the latest features, bug fixes, and performance improvements.

Fixes

• Improved library loading and error message. See issue 566
• Fixed layout issues that occurred on first render when using Fit.layout by correcting the order of artboard resizing and advancing calls. Added a new RiveArtboardLayoutMixin that provides common layout options for painters, including fit mode, alignment, and scale factor controls.
• Resolves an issue where under some conditions the graphic may not restart the animation ticker. Adds a isTickerActive to RivePainter.
• Fixed a lifetime issue with FileAssets when the owning Rive File is destroyed.
• Only send textureFrameAvailable on main (platform) thread (iOS and macOS). This likely resolves crashes observed during Flutter engine teardown when using Factory.rive.

Bumps to rive_native: 0.0.16. Updates the Rive C++ runtime and renderer for the latest features, bug fixes, and performance improvements.

Fixes

• Fixes rendering issues on certain Android devices.
• Resolves an issue where under some conditions the graphic may not restart the animation ticker. Adds a isTickerActive to RivePainter.
• Ensure a Rive graphic is in the correct starting state (matching the Rive Editor play mode not design mode)

Build & Platform Updates

• Bump minimum supported dependency for Flutter to 3.27.0 and Dart to 3.6.0

Bumps to rive_native: 0.0.15. Updates the Rive C++ runtime and renderer for the latest features, bug fixes, and performance improvements.

Fixes

• Fixed 556. getTransformTo can return a negative width and height scale resulting in a texture creation with a negative width/height.
• Fixed 561 Flutter web not initializing.

Bumps to rive_native: 0.0.14. Updates the Rive C++ runtime and renderer for the latest features, bug fixes, and performance improvements.

Fixes

• Graphics memory leak on Android when using the Rive Renderer.

Bumps to rive_native: 0.0.13. Updates the Rive C++ runtime and renderer for the latest features, bug fixes, and performance improvements.

• Added multi-touch support

Fixes

• Fixed 544, which resulted in settled graphics not being visible after backgrounding the app when using Factory.rive.
• Fixed 529, an assertion/crash on Windows debug builds when accessing front() on an empty vector.
• Fixed an issue where graphics would not update after layout when using the Flutter renderer.

Build & Platform Updates

• Included pdb symbol files for rive_native on Windows to assist in debugging native errors.

Bumps to rive_native: 0.0.12. Updates the Rive C++ runtime and renderer for the latest features, bug fixes, and performance improvements.

• Added multi-touch support
• Reduced the number of texture allocations made when resizing widgets using Factory.rive, improving memory efficiency and performance.
• Enhanced painting and texture creation behavior when resizing widgets or windows with Factory.rive, resulting in smoother widget resizing.
• Better aligned the native and web implementations to ensure consistent behavior across all platforms.

Fixes

• Fixed an issue where RivePanel would not render anything after resizing if all graphics are settled.
• Resolved issue #498 where Fit.scaleDown was not working correctly with Factory.rive.
• Resolved an issue where upscaling Rive widget transforms resulted in blurry textures when using Factory.rive.
• Fixed layout problems that occurred when certain Fit modes were used and the user switched to a different DPI screen.
• Fixed 487 - automatically advances/paints a graphic when updating any view model property or any state machine input.
• Fixed instances where pointer exit was not working

Bumps to rive_native: 0.0.11. Updates the Rive C++ runtime and renderer for the latest features, bug fixes, and performance improvements.

Fixes

• Fixed a crash in preCommitCallback for iOS and macOS.

Build & Platform Updates

• Builds the native iOS and macOS libraries with Xcode 16.1 (bumped up from 15.4)

Bumps to rive_native: 0.0.10

• Updates the Rive C++ runtime and renderer for the latest features, bug fixes, and performance improvements.

Features

• Added [RivePanel] - a shared texture to draw multiple RiveWidgets to. This can have a big performance benefit when using Factory.rive. Read more here and here .
• Expose localBounds on Component.

Fixes

• Fixed 496 - playback now properly resumes during pointer interactions, preventing graphics from appearing frozen when users interact with them.
• Fixes an issue where graphics might settle (pause) too soon, by forcing an advance when the elapsedSeconds is zero.
• Fixes a potential crash in Android when a native pointer is no longer valid
• Fixed a crash when shutting down on Windows
• Fixed deleting the wrong texture from the wrong WebGL context

Bumps to rive_native: 0.0.9

• Updates the Rive C++ runtime and renderer for the latest features, bug fixes, and performance improvements.

Fixes

• Add missing pointerExit event logic.
• Fixed 507 - Tests fail on Linux and Windows as native libs are not discoverable.
• Fixed incorrect key forwarding to child widgets.

Bumps to rive_native: 0.0.8

• Updates the Rive C++ runtime and renderer for the latest features, bug fixes, and performance improvements.

• Expose width and height getters for ImageAsset. See issue 501. This is only exposed to support older workflows. We now recommend using Data Binding images. You can also alternatively expose the width and height of the component through data binding and listen to changes.

Fixes

• Fixed a memory leak when listening to Rive Events that had Audio events. See issue 494
• Fixed a memory issue on WASM where large .riv files could invalidate our backing TypedArray views. This fix recreates these views if they are detached. See: https://github.com/emscripten-core/emscripten/issues/7294

Bumps to rive_native: 0.0.7

• Updates the Rive C++ runtime and renderer for the latest features, bug fixes, and performance improvements.

Fixes

• Fixed running out of GL contexts by recycling HTML canvases
• Fixed an issue on Web (Rive Renderer) where certain graphics would settle (pause) too soon when exiting a settled state.
• Fixed an issue where the state machine would settle/pause too soon when resizing the widget (or native window) and when re entering from a backgrounded state (Android). See issue 496
• Fixed an issue where nothing is drawn on the first frame when active is false in RiveWidgetController. See issue 495

Build & Platform Updates

• Linux: Initial Linux support (Flutter renderer).
• Fixed testing libraries not available when using rive_native as a Pub package. rive_native now copies the native libraries to the local app build directory.

Bumps to rive_native: 0.0.6

• Updates the Rive C++ runtime and renderer for the latest features, bug fixes, and performance improvements.

Fixes

• A dual mutex deadlock on iOS/macOS during window/texture resizing under certain conditions.
• An issue where the Rive Renderer requests a repaint on a disposed render object.

Fixes

• Fixed a crash on iOS for the Flutter renderer on cleanup.

This is a significant update for Rive Flutter. We've completely removed all of the Dart code that was used for the Rive runtime and replaced it with our underlying C++ Runtime.

This has resulted in significant changes to the underlying API.

Please see the migration guide, Rive Flutter documentation, and the updated example app for more information.

The core runtime code is now in rive_native. This release uses v0.0.4 of that package.

What's New in 0.14.0

This release of Rive Flutter adds:

• The Rive Renderer
• Support for Data Binding
• Support for Layouts
• Support for Scrolling
• Support for N-Slicing
• Support for Vector Feathering
• All other features added to Rive that did not make it to the previous versions of Rive Flutter
• Includes the latest fixes and improvements for the Rive C++ runtime
• Adds prebuilt libraries, with the ability to build manually. See the rive_native package for more information
• Removes the rive_common package and replaces it with rive_native

Now that Rive Flutter makes use of the core Rive C++ runtime, you can expect new Rive features to be supported sooner for Rive Flutter.

Note: All your Rive graphics will still look and function the same as they did before.

• Fix: Windows/Linux building. Undefined symbol hb_style_get_value, see issue 437

• Adds the isTouchScrollEnabled property to RiveAnimation and Rive widgets. When true allows scrolling behavior to occur on Rive widgets when a touch/drag action is performed on touch-enabled devices. Defaults to false, which means Rive will "absorb" the pointer down event and a scroll cannot be triggered if the touch occurred within a Rive Listener area. Setting to true will impact Rive's capability to handle multiple gestures simultaneously.
• Bump to latest rive_common, v0.4.14.

• Bump to latest rive_common, v0.4.13. Resolves issues building rive_common downstream.

• Expose speedMultiplier on the RiveAnimation and Rive widgets. With this you can adjust the playback speed of an animation or state machine. Thanks tguerin for the contribution. See 423

• Avoid audio init on empty assets. See PR 431.

• Fix audio crashing iOS
• Add new text resizing and layout features. Resolves 422.

• Reduce audio polling and unneeded runtime calculations around audio. Resolves issue 411

• Update Android minSdkVersion from 16 to 19
• Update kotlin_version from '1.6.10' to '1.7.10'
• Specify the Android NDK version Rive should use by setting rive.ndk.version in gradle.properties. For example: rive.ndk.version=26.3.11579264. See issue 398.
• Expand supported web package range to web: ">=0.5.1 <2.0.0". Resolves issues 413 and 415.
• Fix iOS audio issue, see 416
• Various other fixes and improvements to support new Editor features

• Fix 410 Rive not compatible with Flutter web.

• Add applyWorkaroundToRiveOnOldAndroidVersions. Experimental workaround when loading native libraries on Android 6 (see this issue). The method should be called before using any Rive APIs.

• Fix 408 and 409, Rive never reaching a settled state when the widget is not visible (paint method not called).

• Preparation for data binding (databinding, data binding data context, databinding add boolean).
• Layout fixes and improvements (animations for layouts, layout UX fixes).
• Android example project fix.

• Add key property to Rive widget.
• Nested linear animations report events up to parent artboards. Previously, only nested state machines could report events so that listeners in parent artboards could listen for them.

• Add getComponentWhereOrNull on Artboard, to find a component that matches the given predicate. This can be used instead of forEachComponent as it allows exiting early.

• Add getBoolInput(name, path), getTriggerInput(name, path), and getNumberInput(name, path) on Artboard to set nested inputs (inputs on nested artboards), see the documentation.

• Migrates to dart:js_interop and package:web APIs.
• DEPRECATED: RiveFile.initializeText - use RiveFile.initialize instead. This now initializes the Rive audio, text, and layout engine. Call await RiveFile.initialize() before doing RiveFile.import. RiveFile.asset, RiveFile.network, and RiveFile.file will call initialize automatically if it has not been initialized. Alternatively, you can also call unawaited(RiveFile.initialize()); in the main method on app start to make the first graphic load faster.

• Fixed an issue with TickerMode value not pausing a Rive graphic. Thanks to 'jaggernod' for the contribution.
• Bump rive_common to pick up the Privacy manifest for iOS & macOS runtimes

• DEPRECATED: Extension and Type enum on FileAsset. You can create a custom maintained version, see example: https://gist.github.com/HayesGordon/5d37d3fb26f54b2c231760c2c8685963
• BREAKING: Removal of previously deprecated methods assetResolver on RiveFile.network and class NetworkAssetResolver
• Add Audio out-of-band, with examples.
• Support for asset audio volume.
• Fixed an issue with audio decoder in web build.
• Adds play()/pause() and isPlaying to an Artboard. This completely stops the artboard from playing (including nested artboards) and stops/starts the animation ticker. Pausing an artboard can be used to reduce resources used for Rive graphics that aren't visible on screen.
• Adds getBoolInput, getTriggerInput, getNumberInput, and triggerInput on StateMachineController to easily retrieve state machine inputs and fire triggers. This can be used instead of findInput and findSMI, to easily retrieve an SMIBool, SMINumber, and SMITrigger to manipulate a Rive state machine.

• Fixed an issue causing crashes on 32 bit devices

• Adds support for Audio.
• Object Generator adds the ability to override built-in objects with custom objects.
• Fix [355] to ensure the Rive render object is attached before handling pointer events.

• Adds behavior argument to RiveAnimation and Rive. An enum RiveHitTestBehavior specifies how to handle hit testing on an animation. Default is RiveHitTestBehavior.opaque - consuming all hit events for the artboard bounds.
• Collapsed nested artboards don't listen to pointer events anymore
• Constraints pointing to collapsed targets are not applied

• Support for Nested Inputs and Nested Events. See the docs on Nested Artboards.

• Fixes an issue when importing interpolators.
• Increase HTTP dependency range.

• Elastic easing.

• BREAKING: Changes to assetLoader in RiveFile. See the Rive docs on Loading Assets for updated examples.

• Timeline based events with new example showing how to play audio when an event fires.
• More events examples: open url, star rating.

• Updates to text engine to support newer version of clang on Windows.

• New event system! Listen to events reported by a StateMachine via StateMachineController.addEventListener.
• Fixes an issue with animations not playing back correctly when a work area is defined.

• Refactor how hit testing is performed in RiveAnimation and Rive widgets. Pointer events (listeners) can now be enabled on the Rive widget by setting enablePointerEvents to true (default is false).
• Change in how animations advance when using RiveAnimation and Rive widgets. Now using Ticker, which will allow Rive animations to respect timeDilation and TickerMode. Resolves 187, 254, 307, and 328
• Support for line spacing.

• Initializes Rive's text engine only when necessary when calling any of RiveFile.asset, RiveFile.network, or RiveFile.file.
• You'll need to manually call RiveFile.initializeText when calling RiveFile.import directly to use text features. You can optionally only call this if you know the file needs the text engine, or you can determine if it needs it by calling RiveFile.needsTextRuntime.

• Fixes a memory leak in the text engine.

• Fixes an issue with text clipping when baseline is aligned to origin.