Glossary

A comprehensive reference of key terms used throughout the LERP course. Click any term to jump to its definition, and follow the "Learn more" links to dive deeper.

---

A

Artboard

The canvas in Rive where animations are created. Each Artboard can contain its own animations, state machines, and scripts. In Node scripts, you work with artboard instances via the Artboard<T> type.

-- Referencing another artboard as an input
export type MyScript = {
    component: Input<Artboard<Data.ComponentVM>?>,
}

Learn more: Dynamic Instantiation

---

advance()

A lifecycle function that runs every frame. Use it for animation updates, physics, timers, and any per-frame logic. Receives seconds (delta time since last frame).

function advance(self: MyScript, seconds: number): boolean
    self.timer += seconds
    return true  -- Return true to keep animating
end

Learn more: The Lifecycle

---

Animation

A timeline-based sequence of keyframes that animates properties over time. Animations are controlled by State Machines and can be blended together.

-- Animations are typically controlled via State Machine inputs
-- bound to ViewModel properties
local vm = context:viewModel()
if vm then
    local progress = vm:getNumber("progress")
    if progress then progress.value = 0.5 end  -- Control animation progress
end

Learn more: ViewModels

---

Array

A table with sequential integer keys starting at 1. Use ipairs() to iterate.

local inventory = {"sword", "shield", "potion"}

-- Access by index
print(inventory[1])  -- "sword"

-- Iterate in order
for i, item in ipairs(inventory) do
    print(`{i}: {item}`)
end

-- Get length
print(#inventory)  -- 3

Learn more: Tables

---

B

Bezier Curve

A smooth curve defined by control points. Used for path drawing and easing functions.

path:moveTo(Vector.xy(0, 0))
path:cubicTo(
    Vector.xy(50, 0),    -- First control point
    Vector.xy(50, 100),  -- Second control point
    Vector.xy(100, 100)  -- End point
)

Learn more: Procedural Graphics

---

Boolean

A type with only two values: true or false. Used for conditions and flags.

local isActive = true
local hasKey = false

if isActive and not hasKey then
    print("Active but no key")
end

Learn more: Data Types

---

C

Callback

A function passed as an argument to be called later, often in response to events.

-- Listener callback
scoreProp:addListener(function()
    print("Score changed!")
end)

-- Timer callback pattern
local function after(seconds, callback)
    -- Call callback after delay
end

Learn more: Functions

---

Chaining

Calling multiple methods in sequence by returning self from each method.

local builder = PathBuilder.new()
builder
    :moveTo(0, 0)
    :lineTo(100, 0)
    :lineTo(100, 100)
    :close()

Learn more: Self & Methods

---

Closure

A function that captures variables from its surrounding scope (called upvalues). This allows the inner function to "remember" state even after the outer function returns.

local function makeCounter()
    local count = 0  -- Captured by the closure
    return function()
        count += 1
        return count
    end
end

local counter = makeCounter()
print(counter())  -- 1
print(counter())  -- 2

Learn more: Functions & Closures

---

Color

Rive's RGBA color type for styling fills and strokes.

-- Create colors
local red = Color.rgba(255, 0, 0, 255)
local blue = Color.rgb(0, 0, 255)
local transparent = Color.rgba(255, 255, 255, 128)

-- Access components
print(Color.red(red), Color.green(red), Color.blue(red), Color.alpha(red))

Learn more: Core Types

---

Colon Syntax

Method call syntax that automatically passes the table as the first argument (self).

-- These are equivalent:
player:takeDamage(10)       -- Colon syntax
player.takeDamage(player, 10)  -- Dot syntax

-- Use colon for instance methods
function Player:takeDamage(amount)
    self.health -= amount
end

Learn more: Self & Methods

---

Compound Assignment

Shorthand operators that combine assignment with an operation: +=, -=, *=, /=, //=, %=, ^=, ..=

local score = 100
score += 50   -- Same as: score = score + 50
score *= 2    -- Same as: score = score * 2

Learn more: Variables & Operators

---

Context

The runtime context object passed to Node scripts, providing access to the ViewModel and other runtime features.

function init(self: MyScript, context: Context): boolean
    local vm = context:viewModel()
    if vm then
        self.scoreProp = vm:getNumber("score")
    end
    return true
end

Learn more: ViewModels

---

D

Data Binding

The system that connects ViewModel properties to visual elements or script values. Changes propagate automatically.

-- ViewModel property bound to text in Rive Editor
-- Script can read/write the bound value
local nameProp = vm:getString("playerName")
nameProp.value = "Hero"  -- Updates the bound text automatically

Learn more: ViewModels

---

Delta Time

The time elapsed since the last frame, passed as seconds to advance(). Essential for frame-rate-independent animations.

function advance(self: MyScript, seconds: number): boolean
    -- Move at constant speed regardless of frame rate
    self.position += self.speed * seconds
    return true
end

Learn more: The Lifecycle

---

draw()

A lifecycle function for rendering. Called on canvas repaint (not necessarily every frame). Must not modify state or rebuild paths—keep it lightweight.

function draw(self: MyScript, renderer: Renderer)
    renderer:drawPath(self.path, self.paint)
end

Learn more: Drawing API

---

Dictionary

A table with string keys. Use pairs() to iterate.

local player = {
    name = "Hero",
    level = 5,
    class = "Warrior",
}

-- Access by key
print(player.name)    -- "Hero"
print(player["level"]) -- 5

-- Iterate (order not guaranteed)
for key, value in pairs(player) do
    print(`{key}: {value}`)
end

Learn more: Tables

---

Dot Syntax

Property or method access syntax. For methods, you must pass self explicitly.

-- Property access
local x = player.health

-- Method call (must pass self)
player.takeDamage(player, 10)

-- Prefer colon syntax for methods:
player:takeDamage(10)

Learn more: Self & Methods

---

E

Easing

A function that controls animation timing, making movements feel natural.

-- Common easing functions
local function easeInOut(t: number): number
    return t < 0.5
        and 2 * t * t
        or 1 - (-2 * t + 2)^2 / 2
end

local function easeOutBounce(t: number): number
    if t < 1/2.75 then
        return 7.5625 * t * t
    elseif t < 2/2.75 then
        t -= 1.5/2.75
        return 7.5625 * t * t + 0.75
    end
    -- ...
end

Learn more: Procedural Graphics

---

Event

A signal that something happened, often from user interaction or animation.

-- For pointer events in Node scripts
function pointerDown(self: MyScript, event: PointerEvent)
    local pos = event.position
    print("Pointer down at:", pos.x, pos.y)
end

-- For ViewModel triggers, use addListener
function init(self: MyScript, context: Context): boolean
    local vm = context:viewModel()
    if vm then
        local trigger = vm:getTrigger("buttonClicked")
        if trigger then
            trigger:addListener(function()
                print("Button was clicked!")
            end)
        end
    end
    return true
end

Learn more: Listener Protocol

---

export type

Declares the type of your script instance (self). Required when using --!strict mode.

export type MyScript = {
    count: number,
    name: string,
    active: boolean,
}

Learn more: Type System Introduction

---

F

Fill Rule

Determines how the interior of complex paths is filled. Common rules: nonZero (default) and evenOdd.

local paint = Paint.with({
    style = "fill",
    color = Color.rgb(255, 0, 0),
    fillRule = "evenOdd",  -- Alternating fill for overlapping paths
})

Learn more: Core Types

---

Function Type

A type annotation for functions, specifying parameters and return type.

-- Function type syntax: (params) -> returnType
type Callback = () -> ()
type Predicate = (number) -> boolean
type Transform = (number, number) -> (number, number)

-- In type definitions
export type MyScript = {
    onComplete: Callback,
    isValid: Predicate,
}

Learn more: Custom Types

---

Factory Function

The function returned at the end of every Node script that creates new instances. Returns Node<YourType>.

return function(): Node<MyScript>
    return {
        init = init,
        advance = advance,
        draw = draw,
        count = 0,           -- Default value
        name = "Player",     -- Default value
        active = late(),     -- Set in init
    }
end

Learn more: Node Protocol

---

G

Generic

A type parameter that allows types and functions to work with multiple data types while maintaining type safety. Written with angle brackets: <T>.

-- Node<T> is a generic - T is your script type
-- Input<T> is a generic - T is the input value type

export type MyScript = {
    speed: Input<number>,      -- Input generic
    label: Input<string>,      -- Input generic
}

Learn more: Generics

---

Gradient

A color gradient for Paint objects. Supports linear and radial gradients.

local gradient = Gradient.linear(
    Vector.xy(0, 0),      -- Start point
    Vector.xy(100, 0),    -- End point
    {
        { offset = 0, color = Color.rgb(255, 0, 0) },
        { offset = 1, color = Color.rgb(0, 0, 255) },
    }
)

Learn more: Paint & Styling

---

I

init()

A lifecycle function that runs once when the script starts. Use it for setup, creating paths/paints, and initializing state. Must return true to indicate success.

function init(self: MyScript): boolean
    self.path = Path.new()
    self.paint = Paint.with({ style = "fill", color = Color.rgb(255, 0, 0) })
    return true
end

Learn more: The Lifecycle

---

Input

An editor-exposed value declared as Input<T>. In this course, you read it directly (e.g., self.speed).

export type MyScript = {
    speed: Input<number>,
    label: Input<string>,
    enabled: Input<boolean>,
}

function init(self: MyScript): boolean
    print(self.speed)  -- Read the input value
    return true
end

return function(): Node<MyScript>
    return {
        init = init,
        draw = draw,
        speed = 10,       -- Default value
        label = "Hello",  -- Default value
        enabled = true,   -- Default value
    }
end

Learn more: Inputs & Data Binding

---

Inheritance

Creating a new class based on an existing one, reusing its properties and methods.

-- Parent class
local Shape = {}
Shape.__index = Shape

function Shape.new(x, y)
    return setmetatable({ x = x, y = y }, Shape)
end

-- Child class
local Circle = setmetatable({}, { __index = Shape })
Circle.__index = Circle

function Circle.new(x, y, radius)
    local self = Shape.new(x, y)
    self.radius = radius
    return setmetatable(self, Circle)
end

Learn more: Inheritance

---

Intersection Type

Combines multiple types with &. The result has all properties from both types.

type Drawable = { draw: (Drawable, Renderer) -> () }
type Movable = { move: (Movable, number, number) -> () }
type Sprite = Drawable & Movable  -- Has both draw AND move

Learn more: Advanced Types

---

ipairs

An iterator for arrays that yields index-value pairs in order (1, 2, 3...).

local items = {"sword", "shield", "potion"}
for i, item in ipairs(items) do
    print(`{i}: {item}`)
end

Learn more: Tables

---

K

Keyframe

A specific point in time that defines a property's value in an Animation. The animation system interpolates between keyframes to create smooth transitions.

Learn more: Animation

---

L

Layer

In Rive State Machines, layers allow multiple animations to play simultaneously. Each layer can have its own states and transitions, enabling complex animation blending.

Learn more: State Machine

---

Lerp

Short for Linear intERPolation. A fundamental technique for smoothly transitioning between two values.

-- Linear interpolation: blend from a to b by factor t
local function lerp(a: number, b: number, t: number): number
    return a + (b - a) * t
end

-- Examples
lerp(0, 100, 0)    -- 0 (start)
lerp(0, 100, 0.5)  -- 50 (middle)
lerp(0, 100, 1)    -- 100 (end)

Learn more: Procedural Graphics

---

Listener

A Callback function registered to respond when a value changes or an event occurs.

-- Add listener to ViewModel property
local scoreProp = vm:getNumber("score")
scoreProp:addListener(function()
    print(`Score is now: {scoreProp.value}`)
end)

-- Listeners fire whenever the value changes
scoreProp.value = 100  -- Triggers: "Score is now: 100"

Learn more: ViewModels

---

Local Variable

A variable declared with the local keyword, scoped to the current block. Always prefer local over globals.

local x = 10        -- Local to this scope
local y, z = 1, 2   -- Multiple declarations

do
    local inner = 5  -- Only visible in this block
end
-- inner is not accessible here

Learn more: Variables & Operators

---

Loop

Control structures for repeated execution. Luau has for, while, and repeat-until loops.

-- Numeric for loop
for i = 1, 5 do
    print(i)  -- 1, 2, 3, 4, 5
end

-- Iterator for loop
for i, item in ipairs(items) do
    print(item)
end

-- While loop
while condition do
    -- runs while condition is true
end

-- Repeat-until loop
repeat
    -- runs at least once
until condition

Learn more: Control Flow

---

late()

A type-safe placeholder for properties that will be set in init() rather than in the factory function. Recommended (not required) for Path, Paint, and computed values when using --!strict mode.

export type MyScript = {
    path: Path,
    paint: Paint,
    computed: number,
}

return function(): Node<MyScript>
    return {
        init = init,
        draw = draw,
        path = late(),      -- Type-safe placeholder for init()
        paint = late(),     -- Type-safe placeholder for init()
        computed = late(),  -- Type-safe placeholder for init()
    }
end

Note: nil also works at runtime, but late() provides type safety in strict mode.

Learn more: The late() Initializer

---

Lifecycle

The sequence of functions Rive calls on your script: init → update → advance → draw.

Function	When Called	Purpose
init	Once at start	Setup, create objects
update	When inputs change	React to Input changes
advance	Every animation frame	Animation, physics
draw	On canvas repaint	Rendering (pure, no state changes)

Learn more: The Lifecycle

---

M

Mat2D

A 2D transformation matrix for translation, rotation, scale, and skew.

-- Create transforms
local translate = Mat2D.withTranslation(100, 50)
local rotate = Mat2D.withRotation(math.pi / 4)  -- 45 degrees
local scale = Mat2D.withScale(2, 2)

-- Combine transforms
local combined = translate * rotate

-- Apply to renderer
renderer:transform(combined)

Learn more: Transforms & Renderer

---

Metatable

A table that defines special behavior for another table, such as how it responds to operators or property access. Set with setmetatable().

local mt = {
    __index = function(tbl, key)
        return "default"
    end
}
local t = setmetatable({}, mt)
print(t.anything)  -- "default"

Learn more: Metatables

---

Metamethod

A function in a metatable that defines special behavior. Common metamethods:

Metamethod	Triggered By
__index	Reading missing keys
__newindex	Writing missing keys
__add	The + operator
__tostring	Converting to string
__call	Calling as a function

Learn more: The __index Metamethod

---

Module

A reusable chunk of code that can be imported with require(). In Rive, Util Protocol scripts are modules.

-- math_utils.lua (Util Script)
local MathUtils = {}

function MathUtils.clamp(value: number, min: number, max: number): number
    return math.max(min, math.min(max, value))
end

return MathUtils

-- In another script
local MathUtils = require("math_utils")
local clamped = MathUtils.clamp(150, 0, 100)  -- 100

Learn more: Util Scripts

---

N

Nested Artboard

An Artboard instance placed inside another artboard. Allows reusable components with their own animations and scripts.

export type MyScript = {
    -- Reference to a nested artboard's ViewModel
    component: Input<Artboard<Data.ButtonVM>?>,
}

function init(self: MyScript): boolean
    if self.component then
        -- Access the nested artboard's ViewModel
        local vm = self.component:viewModel()
    end
    return true
end

Learn more: Dynamic Instantiation

---

nil

Luau's value representing "nothing" or "no value". Variables are nil by default, and setting a table key to nil removes it.

local x          -- x is nil
local y = nil    -- Explicit nil

local t = { a = 1 }
t.a = nil        -- Removes key 'a'

-- Check for nil
if value == nil then
    print("Value is nil")
end

-- Shorthand (nil is falsy)
if not value then
    print("Value is nil or false")
end

Learn more: Data Types

---

Node Protocol

The primary Rive script type that attaches to scene nodes. Implements lifecycle functions (init, advance, draw) and can perform custom rendering.

--!strict
export type MyScript = {}

function init(self: MyScript): boolean
    return true
end

function draw(self: MyScript, renderer: Renderer)
end

return function(): Node<MyScript>
    return { init = init, draw = draw }
end

Learn more: Node Protocol

---

O

Optional Type

A type that can be nil, denoted with ?. Use for values that might not exist.

export type MyScript = {
    target: Node?,        -- Might be nil
    backup: string?,      -- Might be nil
}

-- Must check before using
if self.target then
    -- Safe to use self.target here
end

Learn more: Custom Types

---

P

pairs

An iterator for tables that yields key-value pairs. Works with any table (arrays, dictionaries, mixed). Order is not guaranteed.

local player = { name = "Hero", level = 5, class = "Warrior" }

for key, value in pairs(player) do
    print(`{key}: {value}`)
end
-- Output (order may vary):
-- name: Hero
-- level: 5
-- class: Warrior

Learn more: Tables

---

Paint

Rive's styling object for fills and strokes. Controls color, stroke width, cap style, and more.

-- Fill paint
local fill = Paint.with({
    style = "fill",
    color = Color.rgb(255, 0, 0),
})

-- Stroke paint
local stroke = Paint.with({
    style = "stroke",
    thickness = 3,
    color = Color.rgb(0, 0, 255),
    cap = "round",
    join = "round",
})

Learn more: Core Types

---

Path

Rive's vector path type for creating custom shapes.

local path = Path.new()
path:moveTo(Vector.xy(0, 0))
path:lineTo(Vector.xy(100, 0))
path:lineTo(Vector.xy(100, 100))
path:lineTo(Vector.xy(0, 100))
path:close()

Learn more: Core Types

---

PointerEvent

Event data for pointer interactions (mouse, touch).

function pointerDown(self: MyScript, event: PointerEvent)
    print(`Pointer at: {event.position.x}, {event.position.y}`)
    event:hit()  -- Consume the event
end

Learn more: Game Logic & Pointer Events

---

Property

A mutable ViewModel property. Can be read, written, and listened to.

-- Get property from ViewModel
local scoreProp = vm:getNumber("score")

-- Read value
local score = scoreProp.value

-- Write value
scoreProp.value = score + 10

-- Listen for changes
scoreProp:addListener(function()
    print(`Score changed to: {scoreProp.value}`)
end)

Learn more: ViewModels

---

R

require

Imports a Module by name. In Rive, use require() to load Util Protocol scripts.

-- Import a utility module
local MathUtils = require("math_utils")
local Colors = require("colors")

-- Use the imported module
local clamped = MathUtils.clamp(150, 0, 100)
local primary = Colors.primary

Learn more: Util Scripts

---

Return

The keyword that exits a function and optionally provides a value. Luau functions can return multiple values.

-- Single return
local function double(x: number): number
    return x * 2
end

-- Multiple returns
local function minMax(a: number, b: number): (number, number)
    if a < b then
        return a, b
    else
        return b, a
    end
end

local min, max = minMax(5, 3)  -- min=3, max=5

-- Early return for guard clauses
local function process(data: Data?)
    if not data then return end  -- Exit early
    -- Process data...
end

Learn more: Functions

---

Renderer

The drawing context provided to draw() for custom rendering. Works like a State Machine with save/restore.

function draw(self: MyScript, renderer: Renderer)
    renderer:save()                           -- Save state
    renderer:transform(Mat2D.withTranslation(50, 50))
    renderer:drawPath(self.path, self.paint)
    renderer:restore()                        -- Restore state
end

Learn more: Drawing API

---

S

self

The script instance. Contains your persistent state and is passed to all lifecycle functions.

function init(self: MyScript): boolean
    self.count = 0            -- Store state on self
    return true
end

function advance(self: MyScript, seconds: number): boolean
    self.count += 1           -- Access state from self
    return true
end

Learn more: Self & Methods

---

Scope

The region of code where a variable is visible and accessible. Luau has block scope—variables exist only within their declaring block.

local global = "visible everywhere"

if true then
    local inner = "only in this block"
    print(global)  -- Works
    print(inner)   -- Works
end

print(global)      -- Works
-- print(inner)    -- Error: inner is out of scope

Learn more: Variables & Operators

---

State Machine

Rive's logic layer that controls which animations play and when. State Machines contain inputs (Boolean, Number, Trigger), layers, states, and transitions with conditions. Scripts can interact with State Machines through ViewModel data binding.

-- Scripts don't directly access State Machines
-- Instead, bind ViewModel properties to State Machine inputs
-- Then read/write those properties from scripts

local vm = context:viewModel()
if vm then
    -- This ViewModel property is bound to a State Machine input
    local health = vm:getNumber("health")
    if health then health.value = 75 end
end

Learn more: ViewModel Integration

---

Strict Mode

Enabled with --!strict, this mode activates Luau's type checker. Strongly recommended for Rive scripts to catch errors early.

--!strict  -- Recommended near top of file

export type MyScript = {
    count: number,  -- Type required
}

Learn more: Strict Mode

---

String Interpolation

Luau's syntax for embedding expressions inside strings using backticks and curly braces.

local name = "Hero"
local level = 5
local damage = 12.5

-- Interpolate variables
print(`Welcome, {name}!`)           -- Welcome, Hero!

-- Interpolate expressions
print(`Level {level} ({level * 10} XP)`)  -- Level 5 (50 XP)

-- Format numbers
print(`Damage: {damage:.1f}`)        -- Damage: 12.5

Learn more: Data Types

---

T

Table

Luau's only data structure—a versatile container that can be an Array, Dictionary, or both.

-- Array (sequential integer keys)
local items = {"sword", "shield", "potion"}

-- Dictionary (string keys)
local player = { name = "Hero", level = 5 }

-- Mixed (both)
local mixed = {
    [1] = "first",
    name = "example",
}

-- Nested tables
local game = {
    player = { x = 0, y = 0 },
    enemies = { { x = 10, y = 5 }, { x = 20, y = 15 } },
}

Learn more: Tables

---

Truthiness

How values behave in boolean contexts. In Luau, only false and nil are falsy—everything else is truthy (including 0 and "").

-- Falsy values (only these two)
if not false then print("false is falsy") end
if not nil then print("nil is falsy") end

-- Truthy values (everything else)
if 0 then print("0 is truthy!") end
if "" then print("empty string is truthy!") end
if {} then print("empty table is truthy!") end

-- Common pattern: nil check
local name = getData() or "default"  -- Use "default" if getData() returns nil

Learn more: Control Flow

---

Trigger

A ViewModel trigger that fires events without storing a value.

-- Get trigger from ViewModel
local clickTrigger = vm:getTrigger("onClick")

-- Fire the trigger
clickTrigger:fire()

-- Listen for trigger fires
clickTrigger:addListener(function()
    print("Trigger fired!")
end)

Learn more: ViewModels

---

Type Alias

A name for a type, created with the type keyword.

type Position = { x: number, y: number }
type State = "idle" | "walking" | "running"
type Callback = (number) -> ()

Learn more: Custom Types

---

Type Guard

A runtime check that narrows a variable's type. Used to safely access properties of union or optional types.

-- Using typeof
local function describe(value: string | number): string
    if typeof(value) == "string" then
        return `String: {value}`  -- value is string here
    else
        return `Number: {value}`  -- value is number here
    end
end

-- Nil check narrows optional types
local function greet(name: string?)
    if name then
        print(`Hello, {name}!`)  -- name is string here
    end
end

Learn more: Advanced Types

---

Type Narrowing

The process where the type checker automatically restricts a variable's type based on control flow (if statements, Type Guards).

local value: string | number = getData()

-- Before check: value is string | number
if typeof(value) == "string" then
    -- Narrowed: value is string
    print(value:upper())
else
    -- Narrowed: value is number
    print(value * 2)
end

Learn more: Advanced Types

---

U

Union Type

A type that can be one of several types, using |.

type State = "idle" | "walking" | "running"
type Result = number | string | nil

Learn more: Custom Types

---

update()

A lifecycle function that runs when input values change. Use it to react to editor changes or runtime data binding updates.

function update(self: MyScript)
    -- Called when any Input<T> value changes
    self.path:reset()
    self.rebuildPath()
end

Learn more: The Lifecycle

---

Upvalue

A variable from an outer scope that is captured by a closure.

local multiplier = 2  -- This becomes an upvalue

local function double(x)
    return x * multiplier  -- Captures 'multiplier'
end

Learn more: Functions & Closures

---

Util Protocol

A Rive script type for creating reusable modules. Cannot draw or have lifecycle functions—just exports values and functions.

--!strict

local MathUtils = {}

function MathUtils.clamp(value: number, min: number, max: number): number
    return math.max(min, math.min(max, value))
end

function MathUtils.lerp(a: number, b: number, t: number): number
    return a + (b - a) * t
end

return MathUtils

Learn more: Util Scripts

---

V

Vector

Rive's 2D vector type (alias: Vec2D). Used for positions, directions, and sizes.

-- Create vectors
local pos = Vector.xy(100, 50)
local zero = Vector.origin()

-- Operations
local sum = pos + Vector.xy(10, 20)
local scaled = pos * 2
local length = pos:length()
local normalized = pos:normalized()

Learn more: Core Types

---

ViewModel

Rive's data binding container that allows properties to be shared between scripts, state machines, and external code.

function init(self: MyScript, context: Context): boolean
    local vm = context:viewModel()
    if vm then
        self.scoreProp = vm:getNumber("score")
        self.nameProp = vm:getString("playerName")
    end
    return true
end

Learn more: ViewModels

---

Quick Reference Index

Category	Terms
Lifecycle	init, update, advance, draw, Lifecycle
Types	export type, Generic, Union Type, Optional Type, Intersection Type, Type Alias, Type Guard, Type Narrowing
Data	Input, Property, ViewModel, Trigger, late(), Data Binding, Listener
Drawing	Path, Paint, Renderer, Color, Gradient, Mat2D, Vector
OOP	Metatable, Metamethod, Closure, self, Upvalue, Inheritance, Chaining
Script Types	Node Protocol, Util Protocol, Factory Function, Module, require
Tables	Table, Array, Dictionary, pairs, ipairs
Language	Local Variable, Scope, Loop, Return, nil, Boolean, Truthiness, String Interpolation, Compound Assignment
Animation	Animation, Keyframe, State Machine, Layer, Lerp, Easing, Artboard, Nested Artboard
Syntax	Colon Syntax, Dot Syntax, Strict Mode

Next Steps

• Continue to Welcome to LERP
• Refresh syntax in Quick Reference