Skip to content


Switch branches/tags

Latest commit

Create a backend for RenderFont that uses Apple's CoreText, so we don't have to include a copy of HarfBuzz (~750K).

Had to (re)discover that Apple tries to 'help' when a font as an optical-size variation axis (opsz). In this case, Apple auto-sets the axis value to the font's pointsize... even if the caller didn't want that. Since we want to have our fonts at a huge size (to keep precision), this code has to...

1. Determine if the font has a opsz axis
2. If so, use that axis' default value for the font's pointsize, and
3.    set the font's xform to account for that (resulting in the expected large size)

db49cdfaa Implement RenderFont using CoreText

Git stats


Failed to load latest commit information.

Build Status Test Status Discord badge Twitter handle


Android runtime for Rive

Further runtime documentation can be found in Rive's help center.

Create and ship interactive animations to any platform

Rive is a real-time interactive design and animation tool. Use our collaborative editor to create motion graphics that respond to different states and user inputs. Then load your animations into apps, games, and websites with our lightweight open-source runtimes.

Beta Release

This is the Android runtime for Rive, currently in beta. The api is subject to change as we continue to improve it. Please file issues and PRs for anything busted, missing, or just wrong.

Version 2 Release Notes

This update introduces a new setup for managing your own render loop.
RiveDrawable has now been renamed RiveArtboardRenderer and it is no longer an Android Drawable. An example on how to drive your own loop is still available in LowLevelActivity.kt.

RiveAnimationView has the same API as the previous version and will still work as before.


To add Rive in your project, include the following in your dependencies :

implementation 'app.rive:rive-android:x.x.x'

Initializing Rive

Rive needs to initialize its runtime when your app starts.

It can be done via an initializer that does this for you automatically. The initialization provider can be set up directly in your app's manifest file:

    <meta-data android:name="app.rive.runtime.kotlin.RiveInitializer"
      android:value="androidx.startup" />

Otherwise this can be achieved by calling the initializer in your code:


You'll need the add a dependency for Jetpack Startup:

dependencies {
    implementation "androidx.startup:startup-runtime:1.1.0"

If you want to initialize Rive yourself, this can also be done in code:



The simplest way to get a rive animation into your application is to include it as part of a layout. The following will include the rive file loaded from the raw resources location, and auto play its first animation.

        app:riveResource="@raw/off_road_car_blog" />


The animation view can be further customized as part of specifying layout attributes.

fit can be specified to determine how the animation should be resized to fit its container. The available choices are FILL , CONTAIN , COVER , FIT_WIDTH , FIT_HEIGHT , NONE , SCALE_DOWN

alignment informs how it should be aligned within the container. The available choices are TOP_LEFT , TOP_CENTER , TOP_RIGHT , CENTER_LEFT , CENTER , CENTER_RIGHT , BOTTOM_LEFT , BOTTOM_CENTER , BOTTOM_RIGHT .


Or = Fit.FILL
animationView.alignment = Alignment.CENTER

Playback controls

Animations can be controlled in many ways, by default loading a RiveAnimationView with a resource file will autoplay the first animation on the first artboard. The artboard and animation can be specified.

                app:riveResource="@raw/artboard_animations" />


    artboardName = "Square",
    animationName = "rollaround",
    autoplay = true

furthermore animations can be controlled later too:

To play an animation named rollaround."rollaround")

multiple animations can play at the same time, and additional animations can be added at any time"bouncing", "windshield_wipers"))

When playing animations, the Loop Mode and direction of the animations can also be set per animation."bouncing", "windshield_wipers"), Loop.ONE_SHOT, Direction.Backwards)

Similarly animations can be paused, or stopped, either all at the same time, or one by one.

animationView.stop(listOf("bouncing", "windshield_wipers"))
animationView.pause(listOf("bouncing", "windshield_wipers"))


Mixing goes further than just playing multiple animations at the same time, animations can use a mix factor between 0 and 1, to allow multiple animations effects to blend together. The high level views do not expose this currently. but you can wrap your own render loop around the core libraries. The advance function is where you can specify a mix factor


The rive android runtimes allow listener registration, take a look at the events section in the rive player for an example of how this works.

val listener = object : Listener {
    override fun notifyPlay(animation: LinearAnimationInstance) {
        // Do something

    override fun notifyPause(animation: LinearAnimationInstance) {
        // Do something

    override fun notifyStop(animation: LinearAnimationInstance) {
        // Do something

    override fun notifyLoop(animation: LinearAnimationInstance) {
        // Do something

F. A. Q.

Does animation play order matter?

Yes, animations are applied in order. Animations animate a property of a shape from one position to another. If multiple animations are playing that are setting the same property on the same shape, only the last applied change will be visible.

The way past this and into some pretty cool effects will take you to mixing, where multiple animations are applied partially. RiveAnimationView does not provide options to set mixing values though, so to take advantage of this, you will need to run your own render loop. You can still use the core parts of this library to interact with Rive files though!

Project Layout


This is the main module of our android library, you can find a useful RiveAnimationView or RiveArtboardRenderer in the app.rive.runtime.kotlin namespace. The underlying C++ runtimes is mapped to objects in the app.rive.runtime.kotlin.core namespace. These allow more fine grained control for more complex animation loops. Our high level views are simply built on top of this.


Multiple sample activities can be found here, this can be a useful reference for getting started with using the runtimes.

/cpp && /submodules

The runtimes are built on top of our C++ runtimes. these are included as a submodule in /submodules. The /cpp folder contains the C++ side of our bindings into android.


Run the sample app

If you need the prebuilt .so files, do the following:

cd cpp
cd ..
  • In Android Studio, make sure you select "Project" in the upper-left corner, not "Android".
  • Select "app" as your target in the middle popup-menu. This is a folder inside runtime_android..." : Project:runtime_android:app
  • Now pick run (the triangle in the middle of the top window).

Updating rive-cpp

The runtime here should be updated to point to the latest rive-cpp submodule when that repo has new commits merged in. This ensures the rive-android runtime is up-to-date with its underlying native code layer to pull in latest patches, features, and more. Follow the steps below to update this submodule:

  1. Pull in the latest commmits from rive-cpp, at the root level:
git submodule update --recursive
# Or git submodule update --init --recursive if you just pulled down the project
cd submodules/rive-cpp
git checkout origin/master
cd ../..
  1. At this point you should see a Git diff of the submodule pointing to the latest commit on master from rive-cpp.
git add .
  1. The Android NDK builds .so files for different architectures.
    The current NDK version we're using is stored in .ndk_version (How to install a specific NDK version)
    We also need to rebuild new .so files (located in /kotlin/src/main/jniLibs/) when pulling in latest changes from rive-cpp:
cd cpp/
# Builds .so files for each architecture
# Note: You may need to install a few dependencies for this script to run

# Add NDK_PATH variable to your .zshenv
NDK_VERSION=$(tr <.ndk_version -d " \t\n\r")
echo 'export NDK_PATH=~/Library/Android/sdk/ndk/${NDK_VERSION}' >> ~/.zshenv
source ~/.zshenv

# Ninja - brew install ninja
# Premake5 - Need to add to your path
# After the script above completes successfully, you should see 4 new .so files, so let's add them
git add .
  1. Run the test suite
  • open in Android Studio
  • select Project, not Android, in the upper-left corner
  • right-click on kotlin/src/androidTest
  • "Run 'All Tests'"
  1. Commit the submodule updates / new .so files to a branch, and submit a PR to master

Updating Dokka docs

To update the documentation, run the rive-android:kotlin [dokkaGfm] task. And then replace the contents of docs with the newly generated output

rm -rf docs/gfm
mv kotlin/build/dokka/gfm docs

(autogenerated) API documentation can be found here