Skip to content

Timelines / Add Timeline / Play / Reverse / Finished

At a glance

Lives in: Blueprint editor / Add Timeline, backed by UTimelineComponent and FTimeline - Target: the Blueprint instance that owns the Timeline - Returns: no object reference; the Timeline node gives execution pins, a Direction value, and any track-value pins you authored - Fails by: producing no useful update, silently - Official docs: Timelines, Add Timeline, and Editing Timelines

The one-minute version

  • A Timeline is an authored curve player that belongs to the Blueprint instance that contains it. It stores its own playback position, direction, length, loop setting, play rate, and tracks.
  • Play continues from the current time. Play from Start jumps to the start and plays forward. Reverse continues backward from the current time. Reverse from End jumps to the end and plays backward.
  • Update fires while the Timeline advances. Use it to apply the current track values to a door, light, material, camera, or other animated property.
  • Finished fires when a non-looping Timeline reaches its natural end. It is not a Stop callback, and a looping Timeline usually never reaches Finished.
  • The output track pins are the values at the current Timeline time. The Timeline does not move your door, fade your material, or open your menu by itself; your Update graph applies the values.
  • Timelines are frame/tick driven. Normal Timelines stop advancing when their owning actor/component does not tick, is destroyed, or is paused without tick-while-paused setup.

What it actually does

A Timeline is a little playback state machine attached to the Blueprint object that owns it. You author one or more tracks in the Timeline editor:

Track type Output you usually use
Float alpha, door angle, light brightness, material parameter value
Vector location, scale, color-like grouped values
Linear Color color/opacity values
Event named execution points at authored times

At runtime, the Timeline remembers "where am I on the curve?" and updates that position as time advances.

pseudocode of the engine behavior - not engine source

Timeline Tick:
    if not playing:
        return

    move Position by DeltaSeconds * PlayRate * Direction
    clamp or wrap Position based on Length and Looping
    evaluate each track at Position
    run Update output and track value pins

    if non-looping playback reached an end:
        stop playback
        run Finished output

That means the Timeline is not the animation. The Timeline is the clock and curve values; your graph is still responsible for doing something with those values:

Timeline Update
-> Float Track "DoorAlpha"
-> Lerp Rotator ClosedRotation to OpenRotation using DoorAlpha
-> Set Relative Rotation on DoorMesh

The Timeline's state lives on that Blueprint instance. If you have five placed BP_Door actors, each door has its own Timeline playback position. If the door actor is destroyed or the level is replaced with Open Level, that Timeline state is gone with the actor.

What the pins mean

The default Timeline node has execution inputs, execution outputs, and generated track-value outputs.

Execution inputs

Input What it does Beginner trap
Play Start or resume forward playback from the current position. If the Timeline is already at the end, this does not rewind it.
Play from Start Set position to the start, then play forward. Repeated calls restart the motion, which can feel like a stutter if fired every frame.
Stop Stop playback at the current position. Stopping is not finishing; do not use Finished as your Stop cleanup.
Reverse Start or resume backward playback from the current position. If the Timeline is already at the start, there is nowhere to go.
Reverse from End Set position to the end, then play backward. Useful for closing a door from a known fully-open value.
Set New Time Jump the playback position to New Time. Jumping time is not the same as playing; your graph still decides whether playback continues.

Execution outputs

Output What it means
Update The Timeline evaluated for the current playback time. Read the track pins here and apply them.
Finished Non-looping playback reached the end while playing forward, or the beginning while reversing.
Direction The current playback direction, usually Forward or Backward.

Track pins

Every track you add creates an output pin named after that track. A float track named Alpha creates an Alpha float pin. A vector track creates a vector pin. Event tracks create named execution events at their keyed times.

Those values are not stored into your target property automatically. A float track called Brightness does not know which light to change until you wire:

Timeline Update
-> Brightness pin
-> Set Intensity on PointLightComponent

The pattern everyone actually uses

Use Timelines for short, authored, reversible runtime motion:

DoorTrigger BeginOverlap
-> filter Other Actor is the player
-> Timeline Play

DoorTrigger EndOverlap
-> Timeline Reverse

Timeline Update
-> Alpha track 0.0 to 1.0
-> Lerp Rotator ClosedRotation to OpenRotation
-> Set Relative Rotation DoorMesh

Timeline Finished
-> set DoorState to Open or Closed based on Direction

The state enum is not optional once the door has more than one rule:

Closed -> Play -> Opening
Opening -> Finished forward -> Open
Open -> Reverse -> Closing
Closing -> Finished backward -> Closed

That state lets you reject impossible requests, choose sounds correctly, and debug "the overlap fired, but the door did nothing" without guessing.

For a material fade:

BeginPlay
-> Create Dynamic Material Instance
-> store MID

StartFade
-> Timeline Play from Start

Timeline Update
-> Opacity track
-> Set Scalar Parameter Value on MID

Do not create the Dynamic Material Instance inside Update. Create it once, store it, then drive the scalar each update.

Finished is not every cleanup event

Finished means playback reached a natural end on a non-looping Timeline. It does not mean:

  • "the actor is about to be destroyed";
  • "Stop was called";
  • "the level is about to change";
  • "the Timeline looped once";
  • "the door is open enough for gameplay";
  • "the target property accepted the value."

If you need cleanup when the actor dies, use the actor/component lifetime path. If you need cleanup when an interaction is canceled, run that cleanup from the cancel path. If you need a loop-count event, model it yourself with an event track or state variable.

This distinction matters for reversible interactions. A closing door can reach Finished at the start of the Timeline, not at the visual "open" end. If the cleanup depends on whether the door is now open or closed, branch on Direction or on your own state:

Timeline Finished
-> Switch on Timeline Direction
   Forward:  Set DoorState Open
   Backward: Set DoorState Closed

When it fails (and what failure does)

A Timeline has no Failed execution pin and no Boolean return. Most failures are "nothing useful happens."

Symptom Likely cause
Update never fires You never called Play/Play from Start/Reverse, the owning actor is not ticking, the Timeline is stopped, the game is paused, or the actor was destroyed.
Update fires but the object does not move The track value is not wired to the right target, the wrong component is being moved, the property is overwritten elsewhere, or the Timeline has no useful keys.
Motion restarts over and over Play from Start is being called repeatedly, often from Tick, Triggered input, or an overlap that repeats.
Finished never fires The Timeline is looping, stopped manually, never played, repeatedly restarted, or the actor/world stopped ticking before it reached the end.
Reverse does nothing Playback is already at the beginning, or you meant Reverse from End.
Door works in one placed instance but not another The second actor has different component references, default values, collision triggers, or Timeline length/keys.
It breaks after Open Level The actor that owned the Timeline was destroyed with the old world.

Failure does not print a guaranteed warning, run a hidden branch, reset your state enum, or repair your target reference. Debug the input that starts playback, then watch the Timeline's current value and the target property you set from Update.

Pause, Delta Seconds, and actor lifetime

Timelines advance from tick-time data. You do not feed them Delta Seconds in Blueprint; the engine advances the Timeline during the owning component/actor tick path.

That has three beginner consequences:

  1. Pause matters. A normal gameplay Timeline stops advancing while the game world is paused, unless the owner/component is configured to tick while paused.
  2. Lifetime matters. Destroying the owner destroys the Timeline state. A delayed Finished pin will not run later from a destroyed actor.
  3. Frame rate is not your curve shape. The Timeline samples the authored curve at the current playback time. You do not need to multiply the track value by Delta Seconds.

If you need a callback after a delay, use a timer or Delay. If you need an authored curve sampled over time, use a Timeline. If you need to keep a manager alive across Open Level, the Timeline cannot live inside an actor that is recreated by travel.

What Timelines do not do

  • They do not create an actor, component, material instance, sound, or widget.
  • They do not automatically apply track values to a property.
  • They do not replicate their playback state as a gameplay rule.
  • They do not run in the background thread.
  • They do not keep running after the owning actor is destroyed.
  • They do not survive full map travel.
  • They do not make a paused world keep animating without tick-while-paused setup.
  • They do not replace a state variable when the animated thing has gameplay states such as Closed, Opening, Open, and Closing.
  • They do not guarantee Finished when you call Stop or repeatedly restart playback.

Lookalikes - which one do I want?

Tool Use when Avoid when
Timeline You need authored values over time: door motion, fades, charge curves, camera offsets, light intensity. You only need a delayed callback or repeating tick.
Delay One execution should resume later in the same latent graph. You need cancel/replace handles, loops, or an authored curve.
Set Timer by Event You need a delayed or repeating callback that you can clear by handle. You need per-frame curve values.
Tick The behavior genuinely needs custom per-frame logic with current world state. You can express the change as a short authored curve or scheduled callback.
Lerp You already have an alpha and need the value between A and B. You expect Lerp to remember time or play by itself.
FInterp To / VInterp To You want "move toward the target smoothly" every frame, usually with no fixed end time. You need a specific authored curve and reliable finish moment.
Level Sequence You need cinematic or multi-actor authored sequencing. You only need one actor's simple gameplay curve.
Animation Montage You need skeletal animation actions, sections, slots, and montage callbacks. You are moving gameplay components or scalar parameters outside the animation system.

Rule of thumb: Timeline is the Blueprint-friendly "curve over time" tool. Timer is the callback scheduler. Lerp is math. Tick is the escape hatch when the current world state must be re-evaluated every frame.

Going deeper