Work in progress

Godot documentation is being updated to reflect the latest changes in version 4.0. Some documentation pages may still state outdated information. This banner will tell you if you're reading one of such pages.

The contents of this page are up to date. If you can still find outdated information, please open an issue.


Inherits: RefCounted < Object

Lightweight object used for general-purpose animation via script, using Tweeners.


Tweens are mostly useful for animations requiring a numerical property to be interpolated over a range of values. The name tween comes from in-betweening, an animation technique where you specify keyframes and the computer interpolates the frames that appear between them. Animating something with a Tween is called tweening.

Tween is more suited than AnimationPlayer for animations where you don't know the final values in advance. For example, interpolating a dynamically-chosen camera zoom value is best done with a Tween; it would be difficult to do the same thing with an AnimationPlayer node. Tweens are also more light-weight than AnimationPlayer, so they are very much suited for simple animations or general tasks that don't require visual tweaking provided by the editor. They can be used in a fire-and-forget manner for some logic that normally would be done by code. You can e.g. make something shoot periodically by using a looped CallbackTweener with a delay.

A Tween can be created by using either SceneTree.create_tween or Node.create_tween. Tweens created manually (i.e. by using are invalid and can't be used for tweening values.

A tween animation is created by adding Tweeners to the Tween object, using tween_property, tween_interval, tween_callback or tween_method:

var tween = get_tree().create_tween()
tween.tween_property($Sprite, "modulate", Color.RED, 1)
tween.tween_property($Sprite, "scale", Vector2(), 1)

This sequence will make the $Sprite node turn red, then shrink, before finally calling Node.queue_free to free the sprite. Tweeners are executed one after another by default. This behavior can be changed using parallel and set_parallel.

When a Tweener is created with one of the tween_* methods, a chained method call can be used to tweak the properties of this Tweener. For example, if you want to set a different transition type in the above example, you can use set_trans:

var tween = get_tree().create_tween()
tween.tween_property($Sprite, "modulate", Color.RED, 1).set_trans(Tween.TRANS_SINE)
tween.tween_property($Sprite, "scale", Vector2(), 1).set_trans(Tween.TRANS_BOUNCE)

Most of the Tween methods can be chained this way too. In the following example the Tween is bound to the running script's node and a default transition is set for its Tweeners:

var tween = get_tree().create_tween().bind_node(self).set_trans(Tween.TRANS_ELASTIC)
tween.tween_property($Sprite, "modulate", Color.RED, 1)
tween.tween_property($Sprite, "scale", Vector2(), 1)

Another interesting use for Tweens is animating arbitrary sets of objects:

var tween = create_tween()
for sprite in get_children():
    tween.tween_property(sprite, "position", Vector2(0, 0), 1)

In the example above, all children of a node are moved one after another to position (0, 0).

You should avoid using more than one Tween per object's property. If two or more tweens animate one property at the same time, the last one created will take priority and assign the final value. If you want to interrupt and restart an animation, consider assigning the Tween to a variable:

var tween
func animate():
    if tween:
        tween.kill() # Abort the previous animation.
    tween = create_tween()

Some Tweeners use transitions and eases. The first accepts a TransitionType constant, and refers to the way the timing of the animation is handled (see for some examples). The second accepts an EaseType constant, and controls where the trans_type is applied to the interpolation (in the beginning, the end, or both). If you don't know which transition and easing to pick, you can try different TransitionType constants with EASE_IN_OUT, and use the one that looks best.

Tween easing and transition types cheatsheet

Note: All Tweens will automatically start by default. To prevent a Tween from autostarting, you can call stop immediately after it is created.

Note: Tweens are processing after all of nodes in the current frame, i.e. after Node._process or Node._physics_process (depending on TweenProcessMode).



bind_node ( Node node )


chain ( )


custom_step ( float delta )


get_total_elapsed_time ( ) const


interpolate_value ( Variant initial_value, Variant delta_value, float elapsed_time, float duration, TransitionType trans_type, EaseType ease_type ) static


is_running ( )


is_valid ( )


kill ( )


parallel ( )


pause ( )


play ( )


set_ease ( EaseType ease )


set_loops ( int loops=0 )


set_parallel ( bool parallel=true )


set_pause_mode ( TweenPauseMode mode )


set_process_mode ( TweenProcessMode mode )


set_speed_scale ( float speed )


set_trans ( TransitionType trans )


stop ( )


tween_callback ( Callable callback )


tween_interval ( float time )


tween_method ( Callable method, Variant from, Variant to, float duration )


tween_property ( Object object, NodePath property, Variant final_val, float duration )


finished ( )

Emitted when the Tween has finished all tweening. Never emitted when the Tween is set to infinite looping (see set_loops).

Note: The Tween is removed (invalidated) in the next processing frame after this signal is emitted. Calling stop inside the signal callback will prevent the Tween from being removed.

loop_finished ( int loop_count )

Emitted when a full loop is complete (see set_loops), providing the loop index. This signal is not emitted after the final loop, use finished instead for this case.

step_finished ( int idx )

Emitted when one step of the Tween is complete, providing the step index. One step is either a single Tweener or a group of Tweeners running in parallel.


enum TweenProcessMode:


The Tween updates during the physics frame.

TweenProcessMode TWEEN_PROCESS_IDLE = 1

The Tween updates during the idle frame.

enum TweenPauseMode:

TweenPauseMode TWEEN_PAUSE_BOUND = 0

If the Tween has a bound node, it will process when that node can process (see Node.process_mode). Otherwise it's the same as TWEEN_PAUSE_STOP.

TweenPauseMode TWEEN_PAUSE_STOP = 1

If SceneTree is paused, the Tween will also pause.


The Tween will process regardless of whether SceneTree is paused.

enum TransitionType:

TransitionType TRANS_LINEAR = 0

The animation is interpolated linearly.

TransitionType TRANS_SINE = 1

The animation is interpolated using a sine function.

TransitionType TRANS_QUINT = 2

The animation is interpolated with a quintic (to the power of 5) function.

TransitionType TRANS_QUART = 3

The animation is interpolated with a quartic (to the power of 4) function.

TransitionType TRANS_QUAD = 4

The animation is interpolated with a quadratic (to the power of 2) function.

TransitionType TRANS_EXPO = 5

The animation is interpolated with an exponential (to the power of x) function.

TransitionType TRANS_ELASTIC = 6

The animation is interpolated with elasticity, wiggling around the edges.

TransitionType TRANS_CUBIC = 7

The animation is interpolated with a cubic (to the power of 3) function.

TransitionType TRANS_CIRC = 8

The animation is interpolated with a function using square roots.

TransitionType TRANS_BOUNCE = 9

The animation is interpolated by bouncing at the end.

TransitionType TRANS_BACK = 10

The animation is interpolated backing out at ends.

enum EaseType:

EaseType EASE_IN = 0

The interpolation starts slowly and speeds up towards the end.

EaseType EASE_OUT = 1

The interpolation starts quickly and slows down towards the end.

EaseType EASE_IN_OUT = 2

A combination of EASE_IN and EASE_OUT. The interpolation is slowest at both ends.

EaseType EASE_OUT_IN = 3

A combination of EASE_IN and EASE_OUT. The interpolation is fastest at both ends.

Method Descriptions

Tween bind_node ( Node node )

Binds this Tween with the given node. Tweens are processed directly by the SceneTree, so they run independently of the animated nodes. When you bind a Node with the Tween, the Tween will halt the animation when the object is not inside tree and the Tween will be automatically killed when the bound object is freed. Also TWEEN_PAUSE_BOUND will make the pausing behavior dependent on the bound node.

For a shorter way to create and bind a Tween, you can use Node.create_tween.

Tween chain ( )

Used to chain two Tweeners after set_parallel is called with true.

var tween = create_tween().set_parallel(true)
tween.tween_property(...) # Will run parallelly with above.
tween.chain().tween_property(...) # Will run after two above are finished.

bool custom_step ( float delta )

Processes the Tween by the given delta value, in seconds. This is mostly useful for manual control when the Tween is paused. It can also be used to end the Tween animation immediately, by setting delta longer than the whole duration of the Tween animation.

Returns true if the Tween still has Tweeners that haven't finished.

Note: The Tween will become invalid in the next processing frame after its animation finishes. Calling stop after performing custom_step instead keeps and resets the Tween.

float get_total_elapsed_time ( ) const

Returns the total time in seconds the Tween has been animating (i.e. the time since it started, not counting pauses etc.). The time is affected by set_speed_scale, and stop will reset it to 0.

Note: As it results from accumulating frame deltas, the time returned after the Tween has finished animating will be slightly greater than the actual Tween duration.

Variant interpolate_value ( Variant initial_value, Variant delta_value, float elapsed_time, float duration, TransitionType trans_type, EaseType ease_type ) static

This method can be used for manual interpolation of a value, when you don't want Tween to do animating for you. It's similar to @GlobalScope.lerp, but with support for custom transition and easing.

initial_value is the starting value of the interpolation.

delta_value is the change of the value in the interpolation, i.e. it's equal to final_value - initial_value.

elapsed_time is the time in seconds that passed after the interpolation started and it's used to control the position of the interpolation. E.g. when it's equal to half of the duration, the interpolated value will be halfway between initial and final values. This value can also be greater than duration or lower than 0, which will extrapolate the value.

duration is the total time of the interpolation.

Note: If duration is equal to 0, the method will always return the final value, regardless of elapsed_time provided.

bool is_running ( )

Returns whether the Tween is currently running, i.e. it wasn't paused and it's not finished.

bool is_valid ( )

Returns whether the Tween is valid. A valid Tween is a Tween contained by the scene tree (i.e. the array from SceneTree.get_processed_tweens will contain this Tween). A Tween might become invalid when it has finished tweening, is killed, or when created with Invalid Tweens can't have Tweeners appended.

void kill ( )

Aborts all tweening operations and invalidates the Tween.

Tween parallel ( )

Makes the next Tweener run parallelly to the previous one.


var tween = create_tween()

All Tweeners in the example will run at the same time.

You can make the Tween parallel by default by using set_parallel.

void pause ( )

Pauses the tweening. The animation can be resumed by using play.

void play ( )

Resumes a paused or stopped Tween.

Tween set_ease ( EaseType ease )

Sets the default ease type for PropertyTweeners and MethodTweeners animated by this Tween.

If not specified, the default value is EASE_IN_OUT.

Tween set_loops ( int loops=0 )

Sets the number of times the tweening sequence will be repeated, i.e. set_loops(2) will run the animation twice.

Calling this method without arguments will make the Tween run infinitely, until either it is killed with kill, the Tween's bound node is freed, or all the animated objects have been freed (which makes further animation impossible).

Warning: Make sure to always add some duration/delay when using infinite loops. To prevent the game freezing, 0-duration looped animations (e.g. a single CallbackTweener with no delay) are stopped after a small number of loops, which may produce unexpected results. If a Tween's lifetime depends on some node, always use bind_node.

Tween set_parallel ( bool parallel=true )

If parallel is true, the Tweeners appended after this method will by default run simultaneously, as opposed to sequentially.

Tween set_pause_mode ( TweenPauseMode mode )

Determines the behavior of the Tween when the SceneTree is paused. Check TweenPauseMode for options.

Default value is TWEEN_PAUSE_BOUND.

Tween set_process_mode ( TweenProcessMode mode )

Determines whether the Tween should run during idle frame (see Node._process) or physics frame (see Node._physics_process.

Default value is TWEEN_PROCESS_IDLE.

Tween set_speed_scale ( float speed )

Scales the speed of tweening. This affects all Tweeners and their delays.

Tween set_trans ( TransitionType trans )

Sets the default transition type for PropertyTweeners and MethodTweeners animated by this Tween.

If not specified, the default value is TRANS_LINEAR.

void stop ( )

Stops the tweening and resets the Tween to its initial state. This will not remove any appended Tweeners.

CallbackTweener tween_callback ( Callable callback )

Creates and appends a CallbackTweener. This method can be used to call an arbitrary method in any object. Use Callable.bind to bind additional arguments for the call.

Example: Object that keeps shooting every 1 second:

var tween = get_tree().create_tween().set_loops()

Example: Turning a sprite red and then blue, with 2 second delay:

var tween = get_tree().create_tween()

IntervalTweener tween_interval ( float time )

Creates and appends an IntervalTweener. This method can be used to create delays in the tween animation, as an alternative to using the delay in other Tweeners, or when there's no animation (in which case the Tween acts as a timer). time is the length of the interval, in seconds.

Example: Creating an interval in code execution:

# ... some code
await create_tween().tween_interval(2).finished
# ... more code

Example: Creating an object that moves back and forth and jumps every few seconds:

var tween = create_tween().set_loops()
tween.tween_property($Sprite, "position:x", 200.0, 1).as_relative()
tween.tween_property($Sprite, "position:x", -200.0, 1).as_relative()

MethodTweener tween_method ( Callable method, Variant from, Variant to, float duration )

Creates and appends a MethodTweener. This method is similar to a combination of tween_callback and tween_property. It calls a method over time with a tweened value provided as an argument. The value is tweened between from and to over the time specified by duration, in seconds. Use Callable.bind to bind additional arguments for the call. You can use MethodTweener.set_ease and MethodTweener.set_trans to tweak the easing and transition of the value or MethodTweener.set_delay to delay the tweening.

Example: Making a 3D object look from one point to another point:

var tween = create_tween()
tween.tween_method(look_at.bind(Vector3.UP), Vector3(-1, 0, -1), Vector3(1, 0, -1), 1) # The look_at() method takes up vector as second argument.

Example: Setting the text of a Label, using an intermediate method and after a delay:

func _ready():
    var tween = create_tween()
    tween.tween_method(set_label_text, 0, 10, 1).set_delay(1)

func set_label_text(value: int):
    $Label.text = "Counting " + str(value)