Complete rewrite of Tweens

* Tweens were changed from Node to RefCounted. New API is inspired by DOTween.
* Tweens are created and managed by SceneTree, similar to SceneTreeTimer, which makes them ultra cheap to use a lot.
* Animating with Tweens is done by creating sequences of Tweeners. You create them from code and they autostart by default (fire-and-forget).
* There are 4 Tweeners that cover the former Tween functionality: PropertyTweener, IntervalTweener, CallbackTweener and MethodTweener.
* The methods were simplified a lot. Long argument lists are replaced with chained calls on Tweens and Tweeners.
* Tweeners by default execute in sequence, so it's easy to create complex chained animations.
* You can bind a Tween to a node. Tween will be removed automatically when the bound node is freed.

16 files changed, 1309 insertions, 1915 deletions

diff --git a/doc/classes/CallbackTweener.xml b/doc/classes/CallbackTweener.xml
new file mode 100644
index 0000000000..8ac285c3df
--- /dev/null
+++ b/doc/classes/CallbackTweener.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<class name="CallbackTweener" inherits="Tweener" version="4.0">
+	<brief_description>
+		Calls the specified method after optional delay.
+	</brief_description>
+	<description>
+		[CallbackTweener] is used to call a method in a tweening sequence. See [method Tween.tween_callback] for more usage information.
+		[b]Note:[/b] [method Tween.tween_callback] is the only correct way to create [CallbackTweener]. Any [CallbackTweener] created manually will not function correctly.
+	</description>
+	<tutorials>
+	</tutorials>
+	<methods>
+		<method name="set_delay">
+			<return type="CallbackTweener">
+			</return>
+			<argument index="0" name="delay" type="float">
+			</argument>
+			<description>
+				Makes the callback call delayed by given time in seconds. Example:
+				[codeblock]
+				var tween = get_tree().create_tween()
+				tween.tween_callback(queue_free).set_delay(2) #this will call queue_free() after 2 seconds
+				[/codeblock]
+			</description>
+		</method>
+	</methods>
+	<constants>
+	</constants>
+</class>
diff --git a/doc/classes/IntervalTweener.xml b/doc/classes/IntervalTweener.xml
new file mode 100644
index 0000000000..1c59003c70
--- /dev/null
+++ b/doc/classes/IntervalTweener.xml
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<class name="IntervalTweener" inherits="Tweener" version="4.0">
+	<brief_description>
+		Creates an idle interval in a [Tween] animation.
+	</brief_description>
+	<description>
+		[IntervalTweener] is used to make delays in a tweening sequence. See [method Tween.tween_interval] for more usage information.
+		[b]Note:[/b] [method Tween.tween_interval] is the only correct way to create [IntervalTweener]. Any [IntervalTweener] created manually will not function correctly.
+	</description>
+	<tutorials>
+	</tutorials>
+	<methods>
+	</methods>
+	<constants>
+	</constants>
+</class>
diff --git a/doc/classes/MethodTweener.xml b/doc/classes/MethodTweener.xml
new file mode 100644
index 0000000000..42b91abf93
--- /dev/null
+++ b/doc/classes/MethodTweener.xml
@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<class name="MethodTweener" inherits="Tweener" version="4.0">
+	<brief_description>
+		Interpolates an abstract value and supplies it to a method called over time.
+	</brief_description>
+	<description>
+		[MethodTweener] is similar to a combination of [CallbackTweener] and [PropertyTweener]. It calls a method providing an interpolated value as a paramater. See [method Tween.tween_method] for more usage information.
+		[b]Note:[/b] [method Tween.tween_method] is the only correct way to create [MethodTweener]. Any [MethodTweener] created manually will not function correctly.
+	</description>
+	<tutorials>
+	</tutorials>
+	<methods>
+		<method name="set_delay">
+			<return type="MethodTweener">
+			</return>
+			<argument index="0" name="delay" type="float">
+			</argument>
+			<description>
+				Sets the time in seconds after which the [MethodTweener] will start interpolating. By default there's no delay.
+			</description>
+		</method>
+		<method name="set_ease">
+			<return type="MethodTweener">
+			</return>
+			<argument index="0" name="ease" type="int" enum="Tween.EaseType">
+			</argument>
+			<description>
+				Sets the type of used easing from [enum Tween.EaseType]. If not set, the default easing is used from the [Tween] that contains this Tweener.
+			</description>
+		</method>
+		<method name="set_trans">
+			<return type="MethodTweener">
+			</return>
+			<argument index="0" name="trans" type="int" enum="Tween.TransitionType">
+			</argument>
+			<description>
+				Sets the type of used transition from [enum Tween.TransitionType]. If not set, the default transition is used from the [Tween] that contains this Tweener.
+			</description>
+		</method>
+	</methods>
+	<constants>
+	</constants>
+</class>
diff --git a/doc/classes/Node.xml b/doc/classes/Node.xml
index 1300351e47..659b3bd39c 100644
--- a/doc/classes/Node.xml
+++ b/doc/classes/Node.xml
@@ -182,6 +182,16 @@
 				Returns [code]true[/code] if the node can process while the scene tree is paused (see [member process_mode]). Always returns [code]true[/code] if the scene tree is not paused, and [code]false[/code] if the node is not in the tree.
 			</description>
 		</method>
+		<method name="create_tween">
+			<return type="Tween">
+			</return>
+			<description>
+				Creates a new [Tween] and binds it to this node. This is equivalent of doing:
+				[codeblock]
+				get_tree().create_tween().bind_node(self)
+				[/codeblock]
+			</description>
+		</method>
 		<method name="duplicate" qualifiers="const">
 			<return type="Node">
 			</return>
diff --git a/doc/classes/PropertyTweener.xml b/doc/classes/PropertyTweener.xml
new file mode 100644
index 0000000000..1e77bb33c6
--- /dev/null
+++ b/doc/classes/PropertyTweener.xml
@@ -0,0 +1,78 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<class name="PropertyTweener" inherits="Tweener" version="4.0">
+	<brief_description>
+		Interpolates an [Object]'s property over time.
+	</brief_description>
+	<description>
+		[PropertyTweener] is used to interpolate a property in an object. See [method Tween.tween_property] for more usage information.
+		[b]Note:[/b] [method Tween.tween_property] is the only correct way to create [PropertyTweener]. Any [PropertyTweener] created manually will not function correctly.
+	</description>
+	<tutorials>
+	</tutorials>
+	<methods>
+		<method name="as_relative">
+			<return type="PropertyTweener">
+			</return>
+			<description>
+				When called, the final value will be used as a relative value instead. Example:
+				[codeblock]
+				var tween = get_tree().create_tween()
+				tween.tween_property(self, "position", Vector2.RIGHT * 100, 1).as_relative() #the node will move by 100 pixels to the right
+				[/codeblock]
+			</description>
+		</method>
+		<method name="from">
+			<return type="PropertyTweener">
+			</return>
+			<argument index="0" name="value" type="Variant">
+			</argument>
+			<description>
+				Sets a custom initial value to the [PropertyTweener]. Example:
+				[codeblock]
+				var tween = get_tree().create_tween()
+				tween.tween_property(self, "position", Vector2(200, 100), 1).from(Vector2(100, 100) #this will move the node from position (100, 100) to (200, 100)
+				[/codeblock]
+			</description>
+		</method>
+		<method name="from_current">
+			<return type="PropertyTweener">
+			</return>
+			<description>
+				Makes the [PropertyTweener] use the current property value (i.e. at the time of creating this [PropertyTweener]) as a starting point. This is equivalent of using [method from] with the current value. These two calls will do the same:
+				[codeblock]
+				tween.tween_property(self, "position", Vector2(200, 100), 1).from(position)
+				tween.tween_property(self, "position", Vector2(200, 100), 1).from_current()
+				[/codeblock]
+			</description>
+		</method>
+		<method name="set_delay">
+			<return type="PropertyTweener">
+			</return>
+			<argument index="0" name="delay" type="float">
+			</argument>
+			<description>
+				Sets the time in seconds after which the [PropertyTweener] will start interpolating. By default there's no delay.
+			</description>
+		</method>
+		<method name="set_ease">
+			<return type="PropertyTweener">
+			</return>
+			<argument index="0" name="ease" type="int" enum="Tween.EaseType">
+			</argument>
+			<description>
+				Sets the type of used easing from [enum Tween.EaseType]. If not set, the default easing is used from the [Tween] that contains this Tweener.
+			</description>
+		</method>
+		<method name="set_trans">
+			<return type="PropertyTweener">
+			</return>
+			<argument index="0" name="trans" type="int" enum="Tween.TransitionType">
+			</argument>
+			<description>
+				Sets the type of used transition from [enum Tween.TransitionType]. If not set, the default transition is used from the [Tween] that contains this Tweener.
+			</description>
+		</method>
+	</methods>
+	<constants>
+	</constants>
+</class>
diff --git a/doc/classes/SceneTree.xml b/doc/classes/SceneTree.xml
index 7a15153fc2..d327e8cbca 100644
--- a/doc/classes/SceneTree.xml
+++ b/doc/classes/SceneTree.xml
@@ -90,6 +90,13 @@
 				The timer will be automatically freed after its time elapses.
 			</description>
 		</method>
+		<method name="create_tween">
+			<return type="Tween">
+			</return>
+			<description>
+				Creates and returns a new [Tween].
+			</description>
+		</method>
 		<method name="get_first_node_in_group">
 			<return type="Node">
 			</return>
@@ -135,6 +142,13 @@
 				Returns a list of all nodes assigned to the given group.
 			</description>
 		</method>
+		<method name="get_processed_tweens">
+			<return type="Array">
+			</return>
+			<description>
+				Returns an array of currently exising [Tween]s in the [SceneTree] (both running and paused).
+			</description>
+		</method>
 		<method name="get_rpc_sender_id" qualifiers="const">
 			<return type="int">
 			</return>
diff --git a/doc/classes/Tween.xml b/doc/classes/Tween.xml
index 00cca40093..ed193b9f7e 100644
--- a/doc/classes/Tween.xml
+++ b/doc/classes/Tween.xml
@@ -1,453 +1,398 @@
 <?xml version="1.0" encoding="UTF-8" ?>
-<class name="Tween" inherits="Node" version="4.0">
+<class name="Tween" inherits="RefCounted" version="4.0">
 	<brief_description>
-		Smoothly animates a node's properties over time.
+		Lightweight object used for general-purpose animation via script, using [Tweener]s.
 	</brief_description>
 	<description>
-		Tweens are useful for animations requiring a numerical property to be interpolated over a range of values. The name [i]tween[/i] comes from [i]in-betweening[/i], an animation technique where you specify [i]keyframes[/i] and the computer interpolates the frames that appear between them.
-		[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] node; it would be difficult to do the same thing with an [AnimationPlayer] node.
-		Here is a brief usage example that makes a 2D node move smoothly between two positions:
-		[codeblocks]
-		[gdscript]
-		var tween = get_node("Tween")
-		tween.interpolate_property($Node2D, "position",
-		        Vector2(0, 0), Vector2(100, 100), 1,
-		        Tween.TRANS_LINEAR, Tween.EASE_IN_OUT)
-		tween.start()
-		[/gdscript]
-		[csharp]
-		var tween = GetNode&lt;Tween&gt;("Tween");
-		tween.InterpolateProperty(GetNode&lt;Node2D&gt;("Node2D"), "position",
-		    new Vector2(0, 0), new Vector2(100, 100), 1,
-		    Tween.TransitionType.Linear, Tween.EaseType.InOut);
-		tween.Start();
-		[/csharp]
-		[/codeblocks]
-		Many methods require a property name, such as [code]"position"[/code] above. You can find the correct property name by hovering over the property in the Inspector. You can also provide the components of a property directly by using [code]"property:component"[/code] (e.g. [code]position:x[/code]), where it would only apply to that particular component.
-		Many of the methods accept [code]trans_type[/code] and [code]ease_type[/code]. The first accepts an [enum TransitionType] constant, and refers to the way the timing of the animation is handled (see [url=https://easings.net/]easings.net[/url] for some examples). The second accepts an [enum EaseType] constant, and controls where the [code]trans_type[/code] 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 [enum TransitionType] constants with [constant EASE_IN_OUT], and use the one that looks best.
+		Tweens are mostly useful for animations requiring a numerical property to be interpolated over a range of values. The name [i]tween[/i] comes from [i]in-betweening[/i], an animation technique where you specify [i]keyframes[/i] and the computer interpolates the frames that appear between them.
+		[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 [method SceneTree.create_tween] or [method Node.create_tween]. [Tween]s created manually (i.e. by using [code]Tween.new()[/code]) are invalid. They can't be used for tweening values, but you can do manual interpolation with [method interpolate_value].
+		A [Tween] animation is composed of a sequence of [Tweener]s, which by default are executed one after another. You can create a sequence by appending [Tweener]s to the [Tween]. Animating something with a [Tweener] is called tweening. Example tweening sequence looks like this:
+		[codeblock]
+		var tween = get_tree().create_tween()
+		tween.tween_property($Sprite, "modulate", Color.red, 1)
+		tween.tween_property($Sprite, "scale", Vector2(), 1)
+		tween.tween_callback($Sprite.queue_free)
+		[/codeblock]
+		This sequence will make the [code]$Sprite[/code] node turn red, then shrink and finally the [method Node.queue_free] is called to remove the sprite. See methods [method tween_property], [method tween_interval], [method tween_callback] and [method tween_method] for more usage information.
+		When a [Tweener] is created with one of the [code]tween_*[/code] methods, a chained method call can be used to tweak the properties of this [Tweener]. For example, if you want to set different transition type in the above example, you can do:
+		[codeblock]
+		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)
+		tween.tween_callback($Sprite.queue_free)
+		[/codeblock]
+		Most of the [Tween] methods can be chained this way too. In this example the [Tween] is bound and have set a default transition:
+		[codeblock]
+		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)
+		tween.tween_callback($Sprite.queue_free)
+		[/codeblock]
+		Another interesting use for [Tween]s is animating arbitrary set of objects:
+		[codeblock]
+		var tween = create_tween()
+		for sprite in get_children():
+		    tween.tween_property(sprite, "position", Vector2(), 1)
+		[/codeblock]
+		In the example above, all children of a node are moved one after another to position (0, 0).
+		Some [Tweener]s use transitions and eases. The first accepts an [enum TransitionType] constant, and refers to the way the timing of the animation is handled (see [url=https://easings.net/]easings.net[/url] for some examples). The second accepts an [enum EaseType] constant, and controls where the [code]trans_type[/code] 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 [enum TransitionType] constants with [constant EASE_IN_OUT], and use the one that looks best.
 		[url=https://raw.githubusercontent.com/godotengine/godot-docs/master/img/tween_cheatsheet.png]Tween easing and transition types cheatsheet[/url]
+		[b]Note:[/b] All [Tween]s will automatically start by default. To prevent a [Tween] from autostarting, you can call [method stop] immediately after it was created.
 	</description>
 	<tutorials>
 	</tutorials>
 	<methods>
-		<method name="follow_method">
-			<return type="void">
+		<method name="bind_node">
+			<return type="Tween">
 			</return>
-			<argument index="0" name="object" type="Object">
-			</argument>
-			<argument index="1" name="method" type="StringName">
-			</argument>
-			<argument index="2" name="initial_val" type="Variant">
-			</argument>
-			<argument index="3" name="target" type="Object">
-			</argument>
-			<argument index="4" name="target_method" type="StringName">
-			</argument>
-			<argument index="5" name="duration" type="float">
-			</argument>
-			<argument index="6" name="trans_type" type="int" enum="Tween.TransitionType" default="0">
-			</argument>
-			<argument index="7" name="ease_type" type="int" enum="Tween.EaseType" default="2">
-			</argument>
-			<argument index="8" name="delay" type="float" default="0">
+			<argument index="0" name="node" type="Node">
 			</argument>
 			<description>
-				Follows [code]method[/code] of [code]object[/code] and applies the returned value on [code]target_method[/code] of [code]target[/code], beginning from [code]initial_val[/code] for [code]duration[/code] seconds, [code]delay[/code] later. Methods are called with consecutive values.
-				Use [enum TransitionType] for [code]trans_type[/code] and [enum EaseType] for [code]ease_type[/code] parameters. These values control the timing and direction of the interpolation. See the class description for more information.
+				Binds this [Tween] with the given [code]node[/code]. [Tween]s 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 [constant 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 [method Node.create_tween].
 			</description>
 		</method>
-		<method name="follow_property">
-			<return type="void">
+		<method name="chain">
+			<return type="Tween">
 			</return>
-			<argument index="0" name="object" type="Object">
-			</argument>
-			<argument index="1" name="property" type="NodePath">
-			</argument>
-			<argument index="2" name="initial_val" type="Variant">
-			</argument>
-			<argument index="3" name="target" type="Object">
-			</argument>
-			<argument index="4" name="target_property" type="NodePath">
-			</argument>
-			<argument index="5" name="duration" type="float">
-			</argument>
-			<argument index="6" name="trans_type" type="int" enum="Tween.TransitionType" default="0">
-			</argument>
-			<argument index="7" name="ease_type" type="int" enum="Tween.EaseType" default="2">
-			</argument>
-			<argument index="8" name="delay" type="float" default="0">
-			</argument>
 			<description>
-				Follows [code]property[/code] of [code]object[/code] and applies it on [code]target_property[/code] of [code]target[/code], beginning from [code]initial_val[/code] for [code]duration[/code] seconds, [code]delay[/code] seconds later.
-				Use [enum TransitionType] for [code]trans_type[/code] and [enum EaseType] for [code]ease_type[/code] parameters. These values control the timing and direction of the interpolation. See the class description for more information.
+				Used to chain two [Tweener]s after [method set_parallel] is called with [code]true[/code].
+				[codeblock]
+				var tween = create_tween().set_parallel(true)
+				tween.tween_property(...)
+				tween.tween_property(...) #will run parallelly with above
+				tween.chain().tween_property(...) #will run after two above are finished
+				[/codeblock]
 			</description>
 		</method>
-		<method name="get_runtime" qualifiers="const">
-			<return type="float">
+		<method name="custom_step">
+			<return type="bool">
 			</return>
+			<argument index="0" name="delta" type="float">
+			</argument>
 			<description>
-				Returns the total time needed for all tweens to end. If you have two tweens, one lasting 10 seconds and the other 20 seconds, it would return 20 seconds, as by that time all tweens would have finished.
+				Processes the [Tween] by given [code]delta[/code] value, in seconds. Mostly useful when the [Tween] is paused, for controlling it manually.
+				Returns [code]true[/code] if the [Tween] still has [Tweener]s that haven't finished.
+				[b]Note:[/b] The [Tween] will become invalid after finished, but you can call [method stop] after the step, to keep it and reset.
+				[b]Note:[/b] [method custom_step] will process only one step of the [Tween]. If the [code]delta[/code] is greater than the remaining time, the excessive time will not have any effect.
 			</description>
 		</method>
-		<method name="interpolate_callback">
-			<return type="void">
+		<method name="interpolate_value">
+			<return type="Variant">
 			</return>
-			<argument index="0" name="object" type="Object">
-			</argument>
-			<argument index="1" name="duration" type="float">
+			<argument index="0" name="trans_type" type="Variant">
 			</argument>
-			<argument index="2" name="callback" type="String">
+			<argument index="1" name="ease_type" type="Variant">
 			</argument>
-			<argument index="3" name="arg1" type="Variant" default="null">
+			<argument index="2" name="elapsed_time" type="float">
 			</argument>
-			<argument index="4" name="arg2" type="Variant" default="null">
+			<argument index="3" name="initial_value" type="float">
 			</argument>
-			<argument index="5" name="arg3" type="Variant" default="null">
+			<argument index="4" name="delta_value" type="int" enum="Tween.TransitionType">
 			</argument>
-			<argument index="6" name="arg4" type="Variant" default="null">
-			</argument>
-			<argument index="7" name="arg5" type="Variant" default="null">
+			<argument index="5" name="duration" type="int" enum="Tween.EaseType">
 			</argument>
 			<description>
-				Calls [code]callback[/code] of [code]object[/code] after [code]duration[/code]. [code]arg1[/code]-[code]arg5[/code] are arguments to be passed to the callback.
+				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 [method @GlobalScope.lerp], but with support for custom transition and easing.
+				[code]elapsed_time[/code] is the time in seconds that passed after the interping started and it's used to control the position of the interpolation. E.g. when it's equal to half of the [code]duration[/code], the interpolated value will be halfway between initial and final values. This value can also be greater than [code]duration[/code] or lower than 0, which will extrapolate the value.
+				[code]initial_value[/code] is the starting value of the interpolation.
+				[code]delta_value[/code] is the change of the value in the interpolation, i.e. it's equal to [code]final_value - initial_value[/code].
+				[code]duration[/code] is the total time of the interpolation.
 			</description>
 		</method>
-		<method name="interpolate_deferred_callback">
-			<return type="void">
+		<method name="is_running">
+			<return type="bool">
 			</return>
-			<argument index="0" name="object" type="Object">
-			</argument>
-			<argument index="1" name="duration" type="float">
-			</argument>
-			<argument index="2" name="callback" type="String">
-			</argument>
-			<argument index="3" name="arg1" type="Variant" default="null">
-			</argument>
-			<argument index="4" name="arg2" type="Variant" default="null">
-			</argument>
-			<argument index="5" name="arg3" type="Variant" default="null">
-			</argument>
-			<argument index="6" name="arg4" type="Variant" default="null">
-			</argument>
-			<argument index="7" name="arg5" type="Variant" default="null">
-			</argument>
 			<description>
-				Calls [code]callback[/code] of [code]object[/code] after [code]duration[/code] on the main thread (similar to [method Object.call_deferred]). [code]arg1[/code]-[code]arg5[/code] are arguments to be passed to the callback.
+				Returns whether the [Tween] is currently running, i.e. it wasn't paused and it's not finished.
 			</description>
 		</method>
-		<method name="interpolate_method">
-			<return type="void">
+		<method name="is_valid">
+			<return type="bool">
 			</return>
-			<argument index="0" name="object" type="Object">
-			</argument>
-			<argument index="1" name="method" type="StringName">
-			</argument>
-			<argument index="2" name="initial_val" type="Variant">
-			</argument>
-			<argument index="3" name="final_val" type="Variant">
-			</argument>
-			<argument index="4" name="duration" type="float">
-			</argument>
-			<argument index="5" name="trans_type" type="int" enum="Tween.TransitionType" default="0">
-			</argument>
-			<argument index="6" name="ease_type" type="int" enum="Tween.EaseType" default="2">
-			</argument>
-			<argument index="7" name="delay" type="float" default="0">
-			</argument>
 			<description>
-				Animates [code]method[/code] of [code]object[/code] from [code]initial_val[/code] to [code]final_val[/code] for [code]duration[/code] seconds, [code]delay[/code] seconds later. Methods are called with consecutive values.
-				Use [enum TransitionType] for [code]trans_type[/code] and [enum EaseType] for [code]ease_type[/code] parameters. These values control the timing and direction of the interpolation. See the class description for more information.
+				Returns whether the [Tween] is valid. A valid [Tween] is a [Tween] contained by the scene tree (i.e. the array from [method SceneTree.get_processed_tweens] will contain this [Tween]). [Tween] might become invalid when it has finished tweening or was killed, also when created with [code]Tween.new()[/code]. Invalid [Tween] can't have [Tweener]s appended, because it can't animate them. You can however still use [method interpolate_value].
 			</description>
 		</method>
-		<method name="interpolate_property">
+		<method name="kill">
 			<return type="void">
 			</return>
-			<argument index="0" name="object" type="Object">
-			</argument>
-			<argument index="1" name="property" type="NodePath">
-			</argument>
-			<argument index="2" name="initial_val" type="Variant">
-			</argument>
-			<argument index="3" name="final_val" type="Variant">
-			</argument>
-			<argument index="4" name="duration" type="float">
-			</argument>
-			<argument index="5" name="trans_type" type="int" enum="Tween.TransitionType" default="0">
-			</argument>
-			<argument index="6" name="ease_type" type="int" enum="Tween.EaseType" default="2">
-			</argument>
-			<argument index="7" name="delay" type="float" default="0">
-			</argument>
 			<description>
-				Animates [code]property[/code] of [code]object[/code] from [code]initial_val[/code] to [code]final_val[/code] for [code]duration[/code] seconds, [code]delay[/code] seconds later. Setting the initial value to [code]null[/code] uses the current value of the property.
-				Use [enum TransitionType] for [code]trans_type[/code] and [enum EaseType] for [code]ease_type[/code] parameters. These values control the timing and direction of the interpolation. See the class description for more information.
+				Aborts all tweening operations and invalidates the [Tween].
 			</description>
 		</method>
-		<method name="is_active" qualifiers="const">
-			<return type="bool">
+		<method name="parallel">
+			<return type="Tween">
 			</return>
 			<description>
-				Returns [code]true[/code] if any tweens are currently running.
-				[b]Note:[/b] This method doesn't consider tweens that have ended.
+				Makes the next [Tweener] run parallely to the previous one. Example:
+				[codeblock]
+				var tween = create_tween()
+				tween.tween_property(...)
+				tween.parallel().tween_property(...)
+				tween.parallel().tween_property(...)
+				[/codeblock]
+				All [Tweener]s in the example will run at the same time.
+				You can make the [Tween] parallel by default by using [method set_parallel].
 			</description>
 		</method>
-		<method name="remove">
+		<method name="pause">
 			<return type="void">
 			</return>
-			<argument index="0" name="object" type="Object">
-			</argument>
-			<argument index="1" name="key" type="StringName" default="&quot;&quot;">
-			</argument>
 			<description>
-				Stops animation and removes a tween, given its object and property/method pair. By default, all tweens are removed, unless [code]key[/code] is specified.
+				Pauses the tweening. The animation can be resumed by using [method play].
 			</description>
 		</method>
-		<method name="remove_all">
+		<method name="play">
 			<return type="void">
 			</return>
 			<description>
-				Stops animation and removes all tweens.
+				Resumes a paused or stopped [Tween].
 			</description>
 		</method>
-		<method name="reset">
-			<return type="void">
+		<method name="set_ease">
+			<return type="Tween">
 			</return>
-			<argument index="0" name="object" type="Object">
-			</argument>
-			<argument index="1" name="key" type="StringName" default="&quot;&quot;">
+			<argument index="0" name="ease" type="int" enum="Tween.EaseType">
 			</argument>
 			<description>
-				Resets a tween to its initial value (the one given, not the one before the tween), given its object and property/method pair. By default, all tweens are removed, unless [code]key[/code] is specified.
+				Sets the default ease type for [PropertyTweener]s and [MethodTweener]s animated by this [Tween].
 			</description>
 		</method>
-		<method name="reset_all">
-			<return type="void">
+		<method name="set_loops">
+			<return type="Tween">
 			</return>
+			<argument index="0" name="loops" type="int" default="0">
+			</argument>
 			<description>
-				Resets all tweens to their initial values (the ones given, not those before the tween).
+				Sets the number of times the tweening sequence will be repeated, i.e. [code]set_loops(2)[/code] will run the animation twice.
+				Calling this method without arguments will make the [Tween] run infinitely, until it is either killed by [method kill] or by freeing bound node, or all the animated objects have been freed (which makes further animation impossible).
 			</description>
 		</method>
-		<method name="resume">
-			<return type="void">
+		<method name="set_parallel">
+			<return type="Tween">
 			</return>
-			<argument index="0" name="object" type="Object">
-			</argument>
-			<argument index="1" name="key" type="StringName" default="&quot;&quot;">
+			<argument index="0" name="parallel" type="bool" default="true">
 			</argument>
 			<description>
-				Continues animating a stopped tween, given its object and property/method pair. By default, all tweens are resumed, unless [code]key[/code] is specified.
+				If [code]parallel[/code] is [code]true[/code], the [Tweener]s appended after this method will by default run simultanously, as opposed to sequentially.
 			</description>
 		</method>
-		<method name="resume_all">
-			<return type="void">
+		<method name="set_pause_mode">
+			<return type="Tween">
 			</return>
+			<argument index="0" name="mode" type="int" enum="Tween.TweenPauseMode">
+			</argument>
 			<description>
-				Continues animating all stopped tweens.
+				Determines the behavior of the [Tween] when the [SceneTree] is paused. Check [enum TweenPauseMode] for options.
+				Default value is [constant TWEEN_PAUSE_BOUND].
 			</description>
 		</method>
-		<method name="seek">
-			<return type="void">
+		<method name="set_process_mode">
+			<return type="Tween">
 			</return>
-			<argument index="0" name="time" type="float">
+			<argument index="0" name="mode" type="int" enum="Tween.TweenProcessMode">
 			</argument>
 			<description>
-				Sets the interpolation to the given [code]time[/code] in seconds.
+				Determines whether the [Tween] should run during idle frame (see [method Node._process]) or physics frame (see [method Node._physics_process].
+				Default value is [constant TWEEN_PROCESS_IDLE].
 			</description>
 		</method>
-		<method name="set_active">
-			<return type="void">
+		<method name="set_speed_scale">
+			<return type="Tween">
 			</return>
-			<argument index="0" name="active" type="bool">
+			<argument index="0" name="speed" type="float">
 			</argument>
 			<description>
-				Activates/deactivates the tween. See also [method stop_all] and [method resume_all].
+				Scales the speed of tweening. This affects all [Tweener]s and their delays.
 			</description>
 		</method>
-		<method name="start">
-			<return type="void">
+		<method name="set_trans">
+			<return type="Tween">
 			</return>
+			<argument index="0" name="trans" type="int" enum="Tween.TransitionType">
+			</argument>
 			<description>
-				Starts the tween. You can define animations both before and after this.
+				Sets the default transition type for [PropertyTweener]s and [MethodTweener]s animated by this [Tween].
 			</description>
 		</method>
 		<method name="stop">
 			<return type="void">
 			</return>
-			<argument index="0" name="object" type="Object">
-			</argument>
-			<argument index="1" name="key" type="StringName" default="&quot;&quot;">
-			</argument>
 			<description>
-				Stops a tween, given its object and property/method pair. By default, all tweens are stopped, unless [code]key[/code] is specified.
+				Stops the tweening and resets the [Tween] to its initial state. This will not remove any appended [Tweener]s.
 			</description>
 		</method>
-		<method name="stop_all">
-			<return type="void">
+		<method name="tween_callback">
+			<return type="CallbackTweener">
 			</return>
+			<argument index="0" name="callback" type="Callable">
+			</argument>
 			<description>
-				Stops animating all tweens.
+				Creates and appends a [CallbackTweener]. This method can be used to call an arbitrary method in any object. Use [method Callable.bind] to bind additional arguments for the call.
+				Example: object that keeps shooting every 1 second.
+				[codeblock]
+				var tween = get_tree().create_tween().set_loops()
+				tween.tween_callback(shoot).set_delay(1)
+				[/codeblock]
+				Example: turning a sprite red and then blue, with 2 second delay.
+				[codeblock]
+				var tween = get_tree().create_tween()
+				tween.tween_callback($Sprite.set_modulate.bind(Color.red)).set_delay(2)
+				tween.tween_callback($Sprite.set_modulate.bind(Color.blue)).set_delay(2)
+				[/codeblock]
 			</description>
 		</method>
-		<method name="targeting_method">
-			<return type="void">
+		<method name="tween_interval">
+			<return type="IntervalTweener">
 			</return>
-			<argument index="0" name="object" type="Object">
-			</argument>
-			<argument index="1" name="method" type="StringName">
-			</argument>
-			<argument index="2" name="initial" type="Object">
-			</argument>
-			<argument index="3" name="initial_method" type="StringName">
-			</argument>
-			<argument index="4" name="final_val" type="Variant">
+			<argument index="0" name="time" type="float">
 			</argument>
-			<argument index="5" name="duration" type="float">
+			<description>
+				Creates and appends an [IntervalTweener]. This method can be used to create delays in the tween animation, as an alternative for using the delay in other [Tweener]s or when there's no animation (in which case the [Tween] acts as a timer). [code]time[/code] is the length of the interval, in seconds.
+				Example: creating an interval in code execution.
+				[codeblock]
+				#... some code
+				var tween = create_tween()
+				tween.tween_interval(2)
+				await tween.finished
+				#... more code
+				[/codeblock]
+				Example: creating an object that moves back and forth and jumps every few seconds.
+				[codeblock]
+				var tween = create_tween().set_loops()
+				tween.tween_property("position:x", 200, 1).as_relative()
+				tween.tween_callback(jump)
+				tween.tween_interval(2)
+				tween.tween_property("position:x", -200, 1).as_relative()
+				tween.tween_callback(jump)
+				tween.tween_interval(2)
+				[/codeblock]
+			</description>
+		</method>
+		<method name="tween_method">
+			<return type="MethodTweener">
+			</return>
+			<argument index="0" name="method" type="Callable">
 			</argument>
-			<argument index="6" name="trans_type" type="int" enum="Tween.TransitionType" default="0">
+			<argument index="1" name="from" type="float">
 			</argument>
-			<argument index="7" name="ease_type" type="int" enum="Tween.EaseType" default="2">
+			<argument index="2" name="to" type="float">
 			</argument>
-			<argument index="8" name="delay" type="float" default="0">
+			<argument index="3" name="duration" type="float">
 			</argument>
 			<description>
-				Animates [code]method[/code] of [code]object[/code] from the value returned by [code]initial_method[/code] to [code]final_val[/code] for [code]duration[/code] seconds, [code]delay[/code] seconds later. Methods are animated by calling them with consecutive values.
-				Use [enum TransitionType] for [code]trans_type[/code] and [enum EaseType] for [code]ease_type[/code] parameters. These values control the timing and direction of the interpolation. See the class description for more information.
+				Creates and appends a [MethodTweener]. This method is similar to a combination of [method tween_callback] and [method tween_property]. It calls a method over time with a tweened value provided as an argument. The value is tweened between [code]from[/code] and [code]to[/code] over the time specified by [code]duration[/code], in seconds. Use [method Callable.bind] to bind additional arguments for the call. You can use [method MethodTweener.set_ease] and [method MethodTweener.set_trans] to tweak the easing and transition of the value or [method MethodTweener.set_delay] to delay the tweening.
+				Example: making a 3D object look from one point to another point.
+				[codeblock]
+				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
+				[/codeblock]
+				Example: setting a text of a [Label], using an intermediate method and after a delay.
+				[codeblock]
+				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)
+				[/codeblock]
 			</description>
 		</method>
-		<method name="targeting_property">
-			<return type="void">
+		<method name="tween_property">
+			<return type="PropertyTweener">
 			</return>
 			<argument index="0" name="object" type="Object">
 			</argument>
 			<argument index="1" name="property" type="NodePath">
 			</argument>
-			<argument index="2" name="initial" type="Object">
-			</argument>
-			<argument index="3" name="initial_val" type="NodePath">
-			</argument>
-			<argument index="4" name="final_val" type="Variant">
+			<argument index="2" name="final_val" type="Variant">
 			</argument>
-			<argument index="5" name="duration" type="float">
+			<argument index="3" name="duration" type="float">
 			</argument>
-			<argument index="6" name="trans_type" type="int" enum="Tween.TransitionType" default="0">
-			</argument>
-			<argument index="7" name="ease_type" type="int" enum="Tween.EaseType" default="2">
-			</argument>
-			<argument index="8" name="delay" type="float" default="0">
-			</argument>
-			<description>
-				Animates [code]property[/code] of [code]object[/code] from the current value of the [code]initial_val[/code] property of [code]initial[/code] to [code]final_val[/code] for [code]duration[/code] seconds, [code]delay[/code] seconds later.
-				Use [enum TransitionType] for [code]trans_type[/code] and [enum EaseType] for [code]ease_type[/code] parameters. These values control the timing and direction of the interpolation. See the class description for more information.
-			</description>
-		</method>
-		<method name="tell" qualifiers="const">
-			<return type="float">
-			</return>
 			<description>
-				Returns the current time of the tween.
+				Creates and appends a [PropertyTweener]. This method tweens a [code]property[/code] of an [code]object[/code] between an initial value and [code]final_val[/code] in a span of time equal to [code]duration[/code], in seconds. The initial value by default is a value at the time the tweening of the [PropertyTweener] start. For example:
+				[codeblock]
+				var tween = create_tween()
+				tween.tween_property($Sprite, "position", Vector2(100, 200)
+				tween.tween_property($Sprite, "position", Vector2(200, 300)
+				[/codeblock]
+				will move the sprite to position (100, 200) and then to (200, 300). If you use [method PropertyTweener.from] or [method PropertyTweener.from_current], the starting position will be overwritten by the given value instead. See other methods in [PropertyTweener] to see how the tweening can be tweaked further.
+				[b]Note:[/b] You can find the correct property name by hovering over the property in the Inspector. You can also provide the components of a property directly by using [code]"property:component"[/code] (eg. [code]position:x[/code]), where it would only apply to that particular component.
+				Example: moving object twice from the same position, with different transition types.
+				[codeblock]
+				var tween = create_tween()
+				tween.tween_property($Sprite, "position", Vector2.RIGHT * 300).as_relative().set_trans(Tween.TRANS_SINE)
+				tween.tween_property($Sprite, "position", Vector2.RIGHT * 300).as_relative().from_current().set_trans(Tween.TRANS_EXPO)
+				[/codeblock]
 			</description>
 		</method>
 	</methods>
-	<members>
-		<member name="playback_process_mode" type="int" setter="set_tween_process_mode" getter="get_tween_process_mode" enum="Tween.TweenProcessMode" default="1">
-			The tween's animation process thread. See [enum TweenProcessMode].
-		</member>
-		<member name="playback_speed" type="float" setter="set_speed_scale" getter="get_speed_scale" default="1.0">
-			The tween's speed multiplier. For example, set it to [code]1.0[/code] for normal speed, [code]2.0[/code] for two times normal speed, or [code]0.5[/code] for half of the normal speed. A value of [code]0[/code] pauses the animation, but see also [method set_active] or [method stop_all] for this.
-		</member>
-		<member name="repeat" type="bool" setter="set_repeat" getter="is_repeat" default="false">
-			If [code]true[/code], the tween loops.
-		</member>
-	</members>
 	<signals>
-		<signal name="tween_all_completed">
+		<signal name="finished">
 			<description>
-				Emitted when all processes in a tween end.
+				Emitted when the [Tween] has finished all tweening. Never emitted when the [Tween] is set to infinite looping (see [method set_loops]).
+				[b]Note:[/b] The [Tween] is removed (invalidated) after this signal is emitted, but it doesn't happen immediately, but on the next processing frame. Calling [method stop] inside the signal callback will preserve the [Tween].
 			</description>
 		</signal>
-		<signal name="tween_completed">
-			<argument index="0" name="object" type="Object">
-			</argument>
-			<argument index="1" name="key" type="NodePath">
+		<signal name="loop_finished">
+			<argument index="0" name="loop_count" type="int">
 			</argument>
 			<description>
-				Emitted when a tween ends.
+				Emitted when a full loop is complete (see [method set_loops]), providing the loop index. This signal is not emitted after final loop, use [signal finished] instead for this case.
 			</description>
 		</signal>
-		<signal name="tween_started">
-			<argument index="0" name="object" type="Object">
-			</argument>
-			<argument index="1" name="key" type="NodePath">
+		<signal name="step_finished">
+			<argument index="0" name="idx" type="int">
 			</argument>
 			<description>
-				Emitted when a tween starts.
-			</description>
-		</signal>
-		<signal name="tween_step">
-			<argument index="0" name="object" type="Object">
-			</argument>
-			<argument index="1" name="key" type="NodePath">
-			</argument>
-			<argument index="2" name="elapsed" type="float">
-			</argument>
-			<argument index="3" name="value" type="Object">
-			</argument>
-			<description>
-				Emitted at each step of the animation.
+				Emitted when one step of the [Tween] is complete, providing the step index. One step is either a single [Tweener] or a group of [Tweener]s running parallelly.
 			</description>
 		</signal>
 	</signals>
 	<constants>
 		<constant name="TWEEN_PROCESS_PHYSICS" value="0" enum="TweenProcessMode">
-			The tween updates with the [code]_physics_process[/code] callback.
+			The [Tween] updates during physics frame.
 		</constant>
 		<constant name="TWEEN_PROCESS_IDLE" value="1" enum="TweenProcessMode">
-			The tween updates with the [code]_process[/code] callback.
+			The [Tween] updates during idle
+		</constant>
+		<constant name="TWEEN_PAUSE_BOUND" value="0" enum="TweenPauseMode">
+		</constant>
+		<constant name="TWEEN_PAUSE_STOP" value="1" enum="TweenPauseMode">
+		</constant>
+		<constant name="TWEEN_PAUSE_PROCESS" value="2" enum="TweenPauseMode">
 		</constant>
 		<constant name="TRANS_LINEAR" value="0" enum="TransitionType">
-			The animation is interpolated linearly.
 		</constant>
 		<constant name="TRANS_SINE" value="1" enum="TransitionType">
-			The animation is interpolated using a sine function.
 		</constant>
 		<constant name="TRANS_QUINT" value="2" enum="TransitionType">
-			The animation is interpolated with a quintic (to the power of 5) function.
 		</constant>
 		<constant name="TRANS_QUART" value="3" enum="TransitionType">
-			The animation is interpolated with a quartic (to the power of 4) function.
 		</constant>
 		<constant name="TRANS_QUAD" value="4" enum="TransitionType">
-			The animation is interpolated with a quadratic (to the power of 2) function.
 		</constant>
 		<constant name="TRANS_EXPO" value="5" enum="TransitionType">
-			The animation is interpolated with an exponential (to the power of x) function.
 		</constant>
 		<constant name="TRANS_ELASTIC" value="6" enum="TransitionType">
-			The animation is interpolated with elasticity, wiggling around the edges.
 		</constant>
 		<constant name="TRANS_CUBIC" value="7" enum="TransitionType">
-			The animation is interpolated with a cubic (to the power of 3) function.
 		</constant>
 		<constant name="TRANS_CIRC" value="8" enum="TransitionType">
-			The animation is interpolated with a function using square roots.
 		</constant>
 		<constant name="TRANS_BOUNCE" value="9" enum="TransitionType">
-			The animation is interpolated by bouncing at the end.
 		</constant>
 		<constant name="TRANS_BACK" value="10" enum="TransitionType">
-			The animation is interpolated backing out at ends.
 		</constant>
 		<constant name="EASE_IN" value="0" enum="EaseType">
-			The interpolation starts slowly and speeds up towards the end.
 		</constant>
 		<constant name="EASE_OUT" value="1" enum="EaseType">
-			The interpolation starts quickly and slows down towards the end.
 		</constant>
 		<constant name="EASE_IN_OUT" value="2" enum="EaseType">
-			A combination of [constant EASE_IN] and [constant EASE_OUT]. The interpolation is slowest at both ends.
 		</constant>
 		<constant name="EASE_OUT_IN" value="3" enum="EaseType">
-			A combination of [constant EASE_IN] and [constant EASE_OUT]. The interpolation is fastest at both ends.
 		</constant>
 	</constants>
 </class>
diff --git a/doc/classes/Tweener.xml b/doc/classes/Tweener.xml
new file mode 100644
index 0000000000..5cd502ced9
--- /dev/null
+++ b/doc/classes/Tweener.xml
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<class name="Tweener" inherits="RefCounted" version="4.0">
+	<brief_description>
+		Abstract class for all Tweeners used by [Tween].
+	</brief_description>
+	<description>
+		Tweeners are objects that perform a specific animating task, e.g. interpolating a property or calling a method at a given time. A [Tweener] can't be created manually, you need to use a dedicated method from [Tween] or [Node].
+	</description>
+	<tutorials>
+	</tutorials>
+	<methods>
+	</methods>
+	<signals>
+		<signal name="finished">
+			<description>
+				Emited when the [Tweener] has just finished its job.
+			</description>
+		</signal>
+	</signals>
+	<constants>
+	</constants>
+</class>
diff --git a/scene/animation/tween.cpp b/scene/animation/tween.cpp
index b4e597f75e..7bf616e602 100644
--- a/scene/animation/tween.cpp
+++ b/scene/animation/tween.cpp
@@ -30,535 +30,407 @@
 
 #include "tween.h"
 
-void Tween::_add_pending_command(StringName p_key, const Variant &p_arg1, const Variant &p_arg2, const Variant &p_arg3, const Variant &p_arg4, const Variant &p_arg5, const Variant &p_arg6, const Variant &p_arg7, const Variant &p_arg8, const Variant &p_arg9, const Variant &p_arg10) {
-	// Add a new pending command and reference it
-	pending_commands.push_back(PendingCommand());
-	PendingCommand &cmd = pending_commands.back()->get();
-
-	// Update the command with the target key
-	cmd.key = p_key;
-
-	// Determine command argument count
-	int &count = cmd.args;
-	if (p_arg10.get_type() != Variant::NIL) {
-		count = 10;
-	} else if (p_arg9.get_type() != Variant::NIL) {
-		count = 9;
-	} else if (p_arg8.get_type() != Variant::NIL) {
-		count = 8;
-	} else if (p_arg7.get_type() != Variant::NIL) {
-		count = 7;
-	} else if (p_arg6.get_type() != Variant::NIL) {
-		count = 6;
-	} else if (p_arg5.get_type() != Variant::NIL) {
-		count = 5;
-	} else if (p_arg4.get_type() != Variant::NIL) {
-		count = 4;
-	} else if (p_arg3.get_type() != Variant::NIL) {
-		count = 3;
-	} else if (p_arg2.get_type() != Variant::NIL) {
-		count = 2;
-	} else if (p_arg1.get_type() != Variant::NIL) {
-		count = 1;
-	} else {
-		count = 0;
-	}
+#include "scene/main/node.h"
 
-	// Add the specified arguments to the command
-	if (count > 0) {
-		cmd.arg[0] = p_arg1;
-	}
-	if (count > 1) {
-		cmd.arg[1] = p_arg2;
-	}
-	if (count > 2) {
-		cmd.arg[2] = p_arg3;
-	}
-	if (count > 3) {
-		cmd.arg[3] = p_arg4;
-	}
-	if (count > 4) {
-		cmd.arg[4] = p_arg5;
-	}
-	if (count > 5) {
-		cmd.arg[5] = p_arg6;
-	}
-	if (count > 6) {
-		cmd.arg[6] = p_arg7;
-	}
-	if (count > 7) {
-		cmd.arg[7] = p_arg8;
-	}
-	if (count > 8) {
-		cmd.arg[8] = p_arg9;
+void Tweener::set_tween(Ref<Tween> p_tween) {
+	tween = p_tween;
+}
+
+void Tweener::_bind_methods() {
+	ADD_SIGNAL(MethodInfo("finished"));
+}
+
+void Tween::start_tweeners() {
+	if (tweeners.is_empty()) {
+		dead = true;
+		ERR_FAIL_MSG("Tween without commands, aborting.");
 	}
-	if (count > 9) {
-		cmd.arg[9] = p_arg10;
+
+	for (List<Ref<Tweener>>::Element *E = tweeners.write[current_step].front(); E; E = E->next()) {
+		E->get()->start();
 	}
 }
 
-void Tween::_process_pending_commands() {
-	// For each pending command...
-	for (List<PendingCommand>::Element *E = pending_commands.front(); E; E = E->next()) {
-		// Get the command
-		PendingCommand &cmd = E->get();
-		Callable::CallError err;
-
-		// Grab all of the arguments for the command
-		Variant *arg[10] = {
-			&cmd.arg[0],
-			&cmd.arg[1],
-			&cmd.arg[2],
-			&cmd.arg[3],
-			&cmd.arg[4],
-			&cmd.arg[5],
-			&cmd.arg[6],
-			&cmd.arg[7],
-			&cmd.arg[8],
-			&cmd.arg[9],
-		};
-
-		// Execute the command (and retrieve any errors)
-		this->call(cmd.key, (const Variant **)arg, cmd.args, err);
-	}
+Ref<PropertyTweener> Tween::tween_property(Object *p_target, NodePath p_property, Variant p_to, float p_duration) {
+	ERR_FAIL_NULL_V(p_target, nullptr);
+	ERR_FAIL_COND_V_MSG(invalid, nullptr, "Tween was created outside the scene tree, can't use Tweeners.");
+	ERR_FAIL_COND_V_MSG(started, nullptr, "Can't append to a Tween that has started. Use stop() first.");
 
-	// Clear the pending commands
-	pending_commands.clear();
+	Ref<PropertyTweener> tweener = memnew(PropertyTweener(p_target, p_property, p_to, p_duration));
+	append(tweener);
+	return tweener;
 }
 
-bool Tween::_set(const StringName &p_name, const Variant &p_value) {
-	// Set the correct attribute based on the given name
-	String name = p_name;
-	if (name == "playback/speed" || name == "speed") { // Backwards compatibility
-		set_speed_scale(p_value);
-		return true;
+Ref<IntervalTweener> Tween::tween_interval(float p_time) {
+	ERR_FAIL_COND_V_MSG(invalid, nullptr, "Tween was created outside the scene tree, can't use Tweeners.");
+	ERR_FAIL_COND_V_MSG(started, nullptr, "Can't append to a Tween that has started. Use stop() first.");
 
-	} else if (name == "playback/active") {
-		set_active(p_value);
-		return true;
+	Ref<IntervalTweener> tweener = memnew(IntervalTweener(p_time));
+	append(tweener);
+	return tweener;
+}
 
-	} else if (name == "playback/repeat") {
-		set_repeat(p_value);
-		return true;
-	}
-	return false;
+Ref<CallbackTweener> Tween::tween_callback(Callable p_callback) {
+	ERR_FAIL_COND_V_MSG(invalid, nullptr, "Tween was created outside the scene tree, can't use Tweeners.");
+	ERR_FAIL_COND_V_MSG(started, nullptr, "Can't append to a Tween that has started. Use stop() first.");
+
+	Ref<CallbackTweener> tweener = memnew(CallbackTweener(p_callback));
+	append(tweener);
+	return tweener;
 }
 
-bool Tween::_get(const StringName &p_name, Variant &r_ret) const {
-	// Get the correct attribute based on the given name
-	String name = p_name;
-	if (name == "playback/speed") { // Backwards compatibility
-		r_ret = speed_scale;
-		return true;
+Ref<MethodTweener> Tween::tween_method(Callable p_callback, float p_from, float p_to, float p_duration) {
+	ERR_FAIL_COND_V_MSG(invalid, nullptr, "Tween was created outside the scene tree, can't use Tweeners.");
+	ERR_FAIL_COND_V_MSG(started, nullptr, "Can't append to a Tween that has started. Use stop() first.");
 
-	} else if (name == "playback/active") {
-		r_ret = is_active();
-		return true;
+	Ref<MethodTweener> tweener = memnew(MethodTweener(p_callback, p_from, p_to, p_duration));
+	append(tweener);
+	return tweener;
+}
 
-	} else if (name == "playback/repeat") {
-		r_ret = is_repeat();
-		return true;
+Ref<Tween> Tween::append(Ref<Tweener> p_tweener) {
+	ERR_FAIL_COND_V_MSG(invalid, nullptr, "Tween was created outside the scene tree, can't use Tweeners.");
+	ERR_FAIL_COND_V_MSG(started, nullptr, "Can't append to a Tween that has started. Use stop() first.");
+	p_tweener->set_tween(this);
+
+	if (parallel_enabled) {
+		current_step = MAX(current_step, 0);
+	} else {
+		current_step++;
 	}
-	return false;
-}
-
-void Tween::_get_property_list(List<PropertyInfo> *p_list) const {
-	// Add the property info for the Tween object
-	p_list->push_back(PropertyInfo(Variant::BOOL, "playback/active", PROPERTY_HINT_NONE, ""));
-	p_list->push_back(PropertyInfo(Variant::BOOL, "playback/repeat", PROPERTY_HINT_NONE, ""));
-	p_list->push_back(PropertyInfo(Variant::FLOAT, "playback/speed", PROPERTY_HINT_RANGE, "-64,64,0.01"));
-}
-
-void Tween::_notification(int p_what) {
-	// What notification did we receive?
-	switch (p_what) {
-		case NOTIFICATION_ENTER_TREE: {
-			// Are we not already active?
-			if (!is_active()) {
-				// Make sure that a previous process state was not saved
-				// Only process if "processing" is set
-				set_physics_process_internal(false);
-				set_process_internal(false);
-			}
-		} break;
+	parallel_enabled = default_parallel;
 
-		case NOTIFICATION_READY: {
-			// Do nothing
-		} break;
+	tweeners.resize(current_step + 1);
+	tweeners.write[current_step].push_back(p_tweener);
 
-		case NOTIFICATION_INTERNAL_PROCESS: {
-			// Are we processing during physics time?
-			if (tween_process_mode == TWEEN_PROCESS_PHYSICS) {
-				// Do nothing since we aren't aligned with physics when we should be
-				break;
-			}
+	return this;
+}
 
-			// Should we update?
-			if (is_active()) {
-				// Update the tweens
-				_tween_process(get_process_delta_time());
-			}
-		} break;
+void Tween::stop() {
+	started = false;
+	running = false;
+	dead = false;
+}
 
-		case NOTIFICATION_INTERNAL_PHYSICS_PROCESS: {
-			// Are we processing during 'regular' time?
-			if (tween_process_mode == TWEEN_PROCESS_IDLE) {
-				// Do nothing since we would only process during idle time
-				break;
-			}
+void Tween::pause() {
+	running = false;
+}
 
-			// Should we update?
-			if (is_active()) {
-				// Update the tweens
-				_tween_process(get_physics_process_delta_time());
-			}
-		} break;
+void Tween::play() {
+	ERR_FAIL_COND_MSG(invalid, "Tween invalid, can't play.");
+	ERR_FAIL_COND_MSG(dead, "Can't play finished Tween, use stop() first to reset its state.");
+	running = true;
+}
 
-		case NOTIFICATION_EXIT_TREE: {
-			// We've left the tree. Stop all tweens
-			stop_all();
-		} break;
-	}
+void Tween::kill() {
+	running = false; // For the sake of is_running().
+	dead = true;
 }
 
-void Tween::_bind_methods() {
-	// Bind getters and setters
-	ClassDB::bind_method(D_METHOD("is_active"), &Tween::is_active);
-	ClassDB::bind_method(D_METHOD("set_active", "active"), &Tween::set_active);
+bool Tween::is_running() {
+	return running;
+}
 
-	ClassDB::bind_method(D_METHOD("is_repeat"), &Tween::is_repeat);
-	ClassDB::bind_method(D_METHOD("set_repeat", "repeat"), &Tween::set_repeat);
+void Tween::set_valid(bool p_valid) {
+	invalid = !p_valid;
+}
 
-	ClassDB::bind_method(D_METHOD("set_speed_scale", "speed"), &Tween::set_speed_scale);
-	ClassDB::bind_method(D_METHOD("get_speed_scale"), &Tween::get_speed_scale);
-
-	ClassDB::bind_method(D_METHOD("set_tween_process_mode", "mode"), &Tween::set_tween_process_mode);
-	ClassDB::bind_method(D_METHOD("get_tween_process_mode"), &Tween::get_tween_process_mode);
-
-	// Bind the various Tween control methods
-	ClassDB::bind_method(D_METHOD("start"), &Tween::start);
-	ClassDB::bind_method(D_METHOD("reset", "object", "key"), &Tween::reset, DEFVAL(""));
-	ClassDB::bind_method(D_METHOD("reset_all"), &Tween::reset_all);
-	ClassDB::bind_method(D_METHOD("stop", "object", "key"), &Tween::stop, DEFVAL(""));
-	ClassDB::bind_method(D_METHOD("stop_all"), &Tween::stop_all);
-	ClassDB::bind_method(D_METHOD("resume", "object", "key"), &Tween::resume, DEFVAL(""));
-	ClassDB::bind_method(D_METHOD("resume_all"), &Tween::resume_all);
-	ClassDB::bind_method(D_METHOD("remove", "object", "key"), &Tween::remove, DEFVAL(""));
-	ClassDB::bind_method(D_METHOD("_remove_by_uid", "uid"), &Tween::_remove_by_uid);
-	ClassDB::bind_method(D_METHOD("remove_all"), &Tween::remove_all);
-	ClassDB::bind_method(D_METHOD("seek", "time"), &Tween::seek);
-	ClassDB::bind_method(D_METHOD("tell"), &Tween::tell);
-	ClassDB::bind_method(D_METHOD("get_runtime"), &Tween::get_runtime);
-
-	// Bind interpolation and follow methods
-	ClassDB::bind_method(D_METHOD("interpolate_property", "object", "property", "initial_val", "final_val", "duration", "trans_type", "ease_type", "delay"), &Tween::interpolate_property, DEFVAL(TRANS_LINEAR), DEFVAL(EASE_IN_OUT), DEFVAL(0));
-	ClassDB::bind_method(D_METHOD("interpolate_method", "object", "method", "initial_val", "final_val", "duration", "trans_type", "ease_type", "delay"), &Tween::interpolate_method, DEFVAL(TRANS_LINEAR), DEFVAL(EASE_IN_OUT), DEFVAL(0));
-	ClassDB::bind_method(D_METHOD("interpolate_callback", "object", "duration", "callback", "arg1", "arg2", "arg3", "arg4", "arg5"), &Tween::interpolate_callback, DEFVAL(Variant()), DEFVAL(Variant()), DEFVAL(Variant()), DEFVAL(Variant()), DEFVAL(Variant()));
-	ClassDB::bind_method(D_METHOD("interpolate_deferred_callback", "object", "duration", "callback", "arg1", "arg2", "arg3", "arg4", "arg5"), &Tween::interpolate_deferred_callback, DEFVAL(Variant()), DEFVAL(Variant()), DEFVAL(Variant()), DEFVAL(Variant()), DEFVAL(Variant()));
-	ClassDB::bind_method(D_METHOD("follow_property", "object", "property", "initial_val", "target", "target_property", "duration", "trans_type", "ease_type", "delay"), &Tween::follow_property, DEFVAL(TRANS_LINEAR), DEFVAL(EASE_IN_OUT), DEFVAL(0));
-	ClassDB::bind_method(D_METHOD("follow_method", "object", "method", "initial_val", "target", "target_method", "duration", "trans_type", "ease_type", "delay"), &Tween::follow_method, DEFVAL(TRANS_LINEAR), DEFVAL(EASE_IN_OUT), DEFVAL(0));
-	ClassDB::bind_method(D_METHOD("targeting_property", "object", "property", "initial", "initial_val", "final_val", "duration", "trans_type", "ease_type", "delay"), &Tween::targeting_property, DEFVAL(TRANS_LINEAR), DEFVAL(EASE_IN_OUT), DEFVAL(0));
-	ClassDB::bind_method(D_METHOD("targeting_method", "object", "method", "initial", "initial_method", "final_val", "duration", "trans_type", "ease_type", "delay"), &Tween::targeting_method, DEFVAL(TRANS_LINEAR), DEFVAL(EASE_IN_OUT), DEFVAL(0));
-
-	// Add the Tween signals
-	ADD_SIGNAL(MethodInfo("tween_started", PropertyInfo(Variant::OBJECT, "object"), PropertyInfo(Variant::NODE_PATH, "key")));
-	ADD_SIGNAL(MethodInfo("tween_step", PropertyInfo(Variant::OBJECT, "object"), PropertyInfo(Variant::NODE_PATH, "key"), PropertyInfo(Variant::FLOAT, "elapsed"), PropertyInfo(Variant::OBJECT, "value")));
-	ADD_SIGNAL(MethodInfo("tween_completed", PropertyInfo(Variant::OBJECT, "object"), PropertyInfo(Variant::NODE_PATH, "key")));
-	ADD_SIGNAL(MethodInfo("tween_all_completed"));
-
-	// Add the properties and tie them to the getters and setters
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "repeat"), "set_repeat", "is_repeat");
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "playback_process_mode", PROPERTY_HINT_ENUM, "Physics,Idle"), "set_tween_process_mode", "get_tween_process_mode");
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "playback_speed", PROPERTY_HINT_RANGE, "-64,64,0.01"), "set_speed_scale", "get_speed_scale");
-
-	// Bind Idle vs Physics process
-	BIND_ENUM_CONSTANT(TWEEN_PROCESS_PHYSICS);
-	BIND_ENUM_CONSTANT(TWEEN_PROCESS_IDLE);
+bool Tween::is_valid() {
+	return invalid;
+}
 
-	// Bind the Transition type constants
-	BIND_ENUM_CONSTANT(TRANS_LINEAR);
-	BIND_ENUM_CONSTANT(TRANS_SINE);
-	BIND_ENUM_CONSTANT(TRANS_QUINT);
-	BIND_ENUM_CONSTANT(TRANS_QUART);
-	BIND_ENUM_CONSTANT(TRANS_QUAD);
-	BIND_ENUM_CONSTANT(TRANS_EXPO);
-	BIND_ENUM_CONSTANT(TRANS_ELASTIC);
-	BIND_ENUM_CONSTANT(TRANS_CUBIC);
-	BIND_ENUM_CONSTANT(TRANS_CIRC);
-	BIND_ENUM_CONSTANT(TRANS_BOUNCE);
-	BIND_ENUM_CONSTANT(TRANS_BACK);
+Ref<Tween> Tween::bind_node(Node *p_node) {
+	bound_node = p_node->get_instance_id();
+	is_bound = true;
+	return this;
+}
 
-	// Bind the easing constants
-	BIND_ENUM_CONSTANT(EASE_IN);
-	BIND_ENUM_CONSTANT(EASE_OUT);
-	BIND_ENUM_CONSTANT(EASE_IN_OUT);
-	BIND_ENUM_CONSTANT(EASE_OUT_IN);
+Ref<Tween> Tween::set_process_mode(TweenProcessMode p_mode) {
+	process_mode = p_mode;
+	return this;
 }
 
-Variant Tween::_get_initial_val(const InterpolateData &p_data) const {
-	// What type of data are we interpolating?
-	switch (p_data.type) {
-		case INTER_PROPERTY:
-		case INTER_METHOD:
-		case FOLLOW_PROPERTY:
-		case FOLLOW_METHOD:
-			// Simply use the given initial value
-			return p_data.initial_val;
-
-		case TARGETING_PROPERTY:
-		case TARGETING_METHOD: {
-			// Get the object that is being targeted
-			Object *object = ObjectDB::get_instance(p_data.target_id);
-			ERR_FAIL_COND_V(object == nullptr, p_data.initial_val);
-
-			// Are we targeting a property or a method?
-			Variant initial_val;
-			if (p_data.type == TARGETING_PROPERTY) {
-				// Get the property from the target object
-				bool valid = false;
-				initial_val = object->get_indexed(p_data.target_key, &valid);
-				ERR_FAIL_COND_V(!valid, p_data.initial_val);
-			} else {
-				// Call the method and get the initial value from it
-				Callable::CallError error;
-				initial_val = object->call(p_data.target_key[0], nullptr, 0, error);
-				ERR_FAIL_COND_V(error.error != Callable::CallError::CALL_OK, p_data.initial_val);
-			}
-			return initial_val;
-		}
+Tween::TweenProcessMode Tween::get_process_mode() {
+	return process_mode;
+}
+
+Ref<Tween> Tween::set_pause_mode(TweenPauseMode p_mode) {
+	pause_mode = p_mode;
+	return this;
+}
+
+Tween::TweenPauseMode Tween::get_pause_mode() {
+	return pause_mode;
+}
+
+Ref<Tween> Tween::set_parallel(bool p_parallel) {
+	default_parallel = p_parallel;
+	parallel_enabled = p_parallel;
+	return this;
+}
+
+Ref<Tween> Tween::set_loops(int p_loops) {
+	loops = p_loops;
+	return this;
+}
+
+Ref<Tween> Tween::set_speed_scale(float p_speed) {
+	speed_scale = p_speed;
+	return this;
+}
+
+Ref<Tween> Tween::set_trans(TransitionType p_trans) {
+	default_transition = p_trans;
+	return this;
+}
 
-		case INTER_CALLBACK:
-			// Callback does not have a special initial value
-			break;
+Tween::TransitionType Tween::get_trans() {
+	return default_transition;
+}
+
+Ref<Tween> Tween::set_ease(EaseType p_ease) {
+	default_ease = p_ease;
+	return this;
+}
+
+Tween::EaseType Tween::get_ease() {
+	return default_ease;
+}
+
+Ref<Tween> Tween::parallel() {
+	parallel_enabled = true;
+	return this;
+}
+
+Ref<Tween> Tween::chain() {
+	parallel_enabled = false;
+	return this;
+}
+
+bool Tween::custom_step(float p_delta) {
+	bool r = running;
+	running = true;
+	bool ret = step(p_delta);
+	running = running && r; // Running might turn false when Tween finished.
+	return ret;
+}
+
+bool Tween::step(float p_delta) {
+	ERR_FAIL_COND_V_MSG(tweeners.is_empty(), false, "Tween started, but has no Tweeners.");
+
+	if (dead) {
+		return false;
 	}
-	// If we've made it here, just return the delta value as the initial value
-	return p_data.delta_val;
-}
-
-Variant Tween::_get_final_val(const InterpolateData &p_data) const {
-	switch (p_data.type) {
-		case FOLLOW_PROPERTY:
-		case FOLLOW_METHOD: {
-			// Get the object that is being followed
-			Object *target = ObjectDB::get_instance(p_data.target_id);
-			ERR_FAIL_COND_V(target == nullptr, p_data.initial_val);
-
-			// We want to figure out the final value
-			Variant final_val;
-			if (p_data.type == FOLLOW_PROPERTY) {
-				// Read the property as-is
-				bool valid = false;
-				final_val = target->get_indexed(p_data.target_key, &valid);
-				ERR_FAIL_COND_V(!valid, p_data.initial_val);
-			} else {
-				// We're looking at a method. Call the method on the target object
-				Callable::CallError error;
-				final_val = target->call(p_data.target_key[0], nullptr, 0, error);
-				ERR_FAIL_COND_V(error.error != Callable::CallError::CALL_OK, p_data.initial_val);
-			}
 
-			// If we're looking at an INT value, instead convert it to a FLOAT
-			// This is better for interpolation
-			if (final_val.get_type() == Variant::INT) {
-				final_val = final_val.operator real_t();
-			}
+	if (!running) {
+		return true;
+	}
 
-			return final_val;
-		}
-		default: {
-			// If we're not following a final value/method, use the final value from the data
-			return p_data.final_val;
+	if (is_bound) {
+		Object *bound_instance = ObjectDB::get_instance(bound_node);
+		if (bound_instance) {
+			Node *bound_node = Object::cast_to<Node>(bound_instance);
+			// This can't by anything else than Node, so we can omit checking if casting succeeded.
+			if (!bound_node->is_inside_tree()) {
+				return true;
+			}
+		} else {
+			return false;
 		}
 	}
-}
 
-Variant &Tween::_get_delta_val(InterpolateData &p_data) {
-	// What kind of data are we interpolating?
-	switch (p_data.type) {
-		case INTER_PROPERTY:
-		case INTER_METHOD:
-			// Simply return the given delta value
-			return p_data.delta_val;
-
-		case FOLLOW_PROPERTY:
-		case FOLLOW_METHOD: {
-			// We're following an object, so grab that instance
-			Object *target = ObjectDB::get_instance(p_data.target_id);
-			ERR_FAIL_COND_V(target == nullptr, p_data.initial_val);
-
-			// We want to figure out the final value
-			Variant final_val;
-			if (p_data.type == FOLLOW_PROPERTY) {
-				// Read the property as-is
-				bool valid = false;
-				final_val = target->get_indexed(p_data.target_key, &valid);
-				ERR_FAIL_COND_V(!valid, p_data.initial_val);
-			} else {
-				// We're looking at a method. Call the method on the target object
-				Callable::CallError error;
-				final_val = target->call(p_data.target_key[0], nullptr, 0, error);
-				ERR_FAIL_COND_V(error.error != Callable::CallError::CALL_OK, p_data.initial_val);
-			}
+	if (!started) {
+		current_step = 0;
+		loops_done = 0;
+		start_tweeners();
+		started = true;
+	}
 
-			// If we're looking at an INT value, instead convert it to a FLOAT
-			// This is better for interpolation
-			if (final_val.get_type() == Variant::INT) {
-				final_val = final_val.operator real_t();
-			}
+	float rem_delta = p_delta * speed_scale;
+	bool step_active = false;
 
-			// Calculate the delta based on the initial value and the final value
-			_calc_delta_val(p_data.initial_val, final_val, p_data.delta_val);
-			return p_data.delta_val;
+	while (rem_delta > 0 && running) {
+		float step_delta = rem_delta;
+		step_active = false;
+
+		for (List<Ref<Tweener>>::Element *E = tweeners.write[current_step].front(); E; E = E->next()) {
+			// Modified inside Tweener.step().
+			float temp_delta = rem_delta;
+			// Turns to true if any Tweener returns true (i.e. is still not finished).
+			step_active = E->get()->step(temp_delta) || step_active;
+			step_delta = MIN(temp_delta, rem_delta);
 		}
 
-		case TARGETING_PROPERTY:
-		case TARGETING_METHOD: {
-			// Grab the initial value from the data to calculate delta
-			Variant initial_val = _get_initial_val(p_data);
+		rem_delta = step_delta;
 
-			// If we're looking at an INT value, instead convert it to a FLOAT
-			// This is better for interpolation
-			if (initial_val.get_type() == Variant::INT) {
-				initial_val = initial_val.operator real_t();
-			}
+		if (!step_active) {
+			emit_signal("step_finished", current_step);
+			current_step++;
 
-			// Calculate the delta based on the initial value and the final value
-			_calc_delta_val(initial_val, p_data.final_val, p_data.delta_val);
-			return p_data.delta_val;
+			if (current_step == tweeners.size()) {
+				loops_done++;
+				if (loops_done == loops) {
+					running = false;
+					dead = true;
+					emit_signal("finished");
+				} else {
+					emit_signal("loop_finished", loops_done);
+					current_step = 0;
+					start_tweeners();
+				}
+			} else {
+				start_tweeners();
+			}
 		}
+	}
+
+	return true;
+}
 
-		case INTER_CALLBACK:
-			// Callbacks have no special delta
-			break;
+bool Tween::should_pause() {
+	if (is_bound && pause_mode == TWEEN_PAUSE_BOUND) {
+		Object *bound_instance = ObjectDB::get_instance(bound_node);
+		if (bound_instance) {
+			Node *bound_node = Object::cast_to<Node>(bound_instance);
+			return !bound_node->can_process();
+		}
 	}
-	// If we've made it here, use the initial value as the delta
-	return p_data.initial_val;
+
+	return pause_mode != TWEEN_PAUSE_PROCESS;
 }
 
-Variant Tween::_run_equation(InterpolateData &p_data) {
-	// Get the initial and delta values from the data
-	Variant initial_val = _get_initial_val(p_data);
-	Variant &delta_val = _get_delta_val(p_data);
-	Variant result;
+Variant Tween::interpolate_variant(Variant p_initial_val, Variant p_delta_val, float p_time, float p_duration, TransitionType p_trans, EaseType p_ease) {
+	ERR_FAIL_INDEX_V(p_trans, TransitionType::TRANS_MAX, Variant());
+	ERR_FAIL_INDEX_V(p_ease, EaseType::EASE_MAX, Variant());
 
+// Helper macro to run equation on sub-elements of the value (e.g. x and y of Vector2).
 #define APPLY_EQUATION(element) \
-	r.element = _run_equation(p_data.trans_type, p_data.ease_type, p_data.elapsed - p_data.delay, i.element, d.element, p_data.duration);
+	r.element = run_equation(p_trans, p_ease, p_time, i.element, d.element, p_duration);
 
-	// What type of data are we interpolating?
-	switch (initial_val.get_type()) {
-		case Variant::BOOL:
-			// Run the boolean specific equation (checking if it is at least 0.5)
-			result = (_run_equation(p_data.trans_type, p_data.ease_type, p_data.elapsed - p_data.delay, initial_val, delta_val, p_data.duration)) >= 0.5;
-			break;
+	switch (p_initial_val.get_type()) {
+		case Variant::BOOL: {
+			return (run_equation(p_trans, p_ease, p_time, p_initial_val, p_delta_val, p_duration)) >= 0.5;
+		}
 
-		case Variant::INT:
-			// Run the integer specific equation
-			result = (int)_run_equation(p_data.trans_type, p_data.ease_type, p_data.elapsed - p_data.delay, (int)initial_val, (int)delta_val, p_data.duration);
-			break;
+		case Variant::INT: {
+			return (int)run_equation(p_trans, p_ease, p_time, (int)p_initial_val, (int)p_delta_val, p_duration);
+		}
 
-		case Variant::FLOAT:
-			// Run the FLOAT specific equation
-			result = _run_equation(p_data.trans_type, p_data.ease_type, p_data.elapsed - p_data.delay, (real_t)initial_val, (real_t)delta_val, p_data.duration);
-			break;
+		case Variant::FLOAT: {
+			return run_equation(p_trans, p_ease, p_time, (real_t)p_initial_val, (real_t)p_delta_val, p_duration);
+		}
 
 		case Variant::VECTOR2: {
-			// Get vectors for initial and delta values
-			Vector2 i = initial_val;
-			Vector2 d = delta_val;
+			Vector2 i = p_initial_val;
+			Vector2 d = p_delta_val;
 			Vector2 r;
 
-			// Execute the equation and mutate the r vector
-			// This uses the custom APPLY_EQUATION macro defined above
 			APPLY_EQUATION(x);
 			APPLY_EQUATION(y);
-			result = r;
-		} break;
+			return r;
+		}
+
+		case Variant::VECTOR2I: {
+			Vector2i i = p_initial_val;
+			Vector2i d = p_delta_val;
+			Vector2i r;
+
+			APPLY_EQUATION(x);
+			APPLY_EQUATION(y);
+			return r;
+		}
 
 		case Variant::RECT2: {
-			// Get the Rect2 for initial and delta value
-			Rect2 i = initial_val;
-			Rect2 d = delta_val;
+			Rect2 i = p_initial_val;
+			Rect2 d = p_delta_val;
 			Rect2 r;
 
-			// Execute the equation for the position and size of Rect2
 			APPLY_EQUATION(position.x);
 			APPLY_EQUATION(position.y);
 			APPLY_EQUATION(size.x);
 			APPLY_EQUATION(size.y);
-			result = r;
-		} break;
+			return r;
+		}
+
+		case Variant::RECT2I: {
+			Rect2i i = p_initial_val;
+			Rect2i d = p_delta_val;
+			Rect2i r;
+
+			APPLY_EQUATION(position.x);
+			APPLY_EQUATION(position.y);
+			APPLY_EQUATION(size.x);
+			APPLY_EQUATION(size.y);
+			return r;
+		}
 
 		case Variant::VECTOR3: {
-			// Get vectors for initial and delta values
-			Vector3 i = initial_val;
-			Vector3 d = delta_val;
+			Vector3 i = p_initial_val;
+			Vector3 d = p_delta_val;
 			Vector3 r;
 
-			// Execute the equation and mutate the r vector
-			// This uses the custom APPLY_EQUATION macro defined above
 			APPLY_EQUATION(x);
 			APPLY_EQUATION(y);
 			APPLY_EQUATION(z);
-			result = r;
-		} break;
+			return r;
+		}
+
+		case Variant::VECTOR3I: {
+			Vector3i i = p_initial_val;
+			Vector3i d = p_delta_val;
+			Vector3i r;
+
+			APPLY_EQUATION(x);
+			APPLY_EQUATION(y);
+			APPLY_EQUATION(z);
+			return r;
+		}
 
 		case Variant::TRANSFORM2D: {
-			// Get the transforms for initial and delta values
-			Transform2D i = initial_val;
-			Transform2D d = delta_val;
+			Transform2D i = p_initial_val;
+			Transform2D d = p_delta_val;
 			Transform2D r;
 
-			// Execute the equation on the transforms and mutate the r transform
-			// This uses the custom APPLY_EQUATION macro defined above
 			APPLY_EQUATION(elements[0][0]);
 			APPLY_EQUATION(elements[0][1]);
 			APPLY_EQUATION(elements[1][0]);
 			APPLY_EQUATION(elements[1][1]);
 			APPLY_EQUATION(elements[2][0]);
 			APPLY_EQUATION(elements[2][1]);
-			result = r;
-		} break;
+			return r;
+		}
 
 		case Variant::QUATERNION: {
-			// Get the quaternian for the initial and delta values
-			Quaternion i = initial_val;
-			Quaternion d = delta_val;
+			Quaternion i = p_initial_val;
+			Quaternion d = p_delta_val;
 			Quaternion r;
 
-			// Execute the equation on the quaternian values and mutate the r quaternian
-			// This uses the custom APPLY_EQUATION macro defined above
 			APPLY_EQUATION(x);
 			APPLY_EQUATION(y);
 			APPLY_EQUATION(z);
 			APPLY_EQUATION(w);
-			result = r;
-		} break;
+			return r;
+		}
 
 		case Variant::AABB: {
-			// Get the AABB's for the initial and delta values
-			AABB i = initial_val;
-			AABB d = delta_val;
+			AABB i = p_initial_val;
+			AABB d = p_delta_val;
 			AABB r;
 
-			// Execute the equation for the position and size of the AABB's and mutate the r AABB
-			// This uses the custom APPLY_EQUATION macro defined above
 			APPLY_EQUATION(position.x);
 			APPLY_EQUATION(position.y);
 			APPLY_EQUATION(position.z);
 			APPLY_EQUATION(size.x);
 			APPLY_EQUATION(size.y);
 			APPLY_EQUATION(size.z);
-			result = r;
-		} break;
+			return r;
+		}
 
 		case Variant::BASIS: {
-			// Get the basis for initial and delta values
-			Basis i = initial_val;
-			Basis d = delta_val;
+			Basis i = p_initial_val;
+			Basis d = p_delta_val;
 			Basis r;
 
-			// Execute the equation on all the basis and mutate the r basis
-			// This uses the custom APPLY_EQUATION macro defined above
 			APPLY_EQUATION(elements[0][0]);
 			APPLY_EQUATION(elements[0][1]);
 			APPLY_EQUATION(elements[0][2]);
@@ -568,17 +440,14 @@ Variant Tween::_run_equation(InterpolateData &p_data) {
 			APPLY_EQUATION(elements[2][0]);
 			APPLY_EQUATION(elements[2][1]);
 			APPLY_EQUATION(elements[2][2]);
-			result = r;
-		} break;
+			return r;
+		}
 
 		case Variant::TRANSFORM3D: {
-			// Get the transforms for the initial and delta values
-			Transform3D i = initial_val;
-			Transform3D d = delta_val;
+			Transform3D i = p_initial_val;
+			Transform3D d = p_delta_val;
 			Transform3D r;
 
-			// Execute the equation for each of the transforms and their origin and mutate the r transform
-			// This uses the custom APPLY_EQUATION macro defined above
 			APPLY_EQUATION(basis.elements[0][0]);
 			APPLY_EQUATION(basis.elements[0][1]);
 			APPLY_EQUATION(basis.elements[0][2]);
@@ -591,634 +460,67 @@ Variant Tween::_run_equation(InterpolateData &p_data) {
 			APPLY_EQUATION(origin.x);
 			APPLY_EQUATION(origin.y);
 			APPLY_EQUATION(origin.z);
-			result = r;
-		} break;
+			return r;
+		}
 
 		case Variant::COLOR: {
-			// Get the Color for initial and delta value
-			Color i = initial_val;
-			Color d = delta_val;
+			Color i = p_initial_val;
+			Color d = p_delta_val;
 			Color r;
 
-			// Apply the equation on the Color RGBA, and mutate the r color
-			// This uses the custom APPLY_EQUATION macro defined above
 			APPLY_EQUATION(r);
 			APPLY_EQUATION(g);
 			APPLY_EQUATION(b);
 			APPLY_EQUATION(a);
-			result = r;
-		} break;
-
-		default: {
-			// If unknown, just return the initial value
-			result = initial_val;
-		} break;
-	};
-#undef APPLY_EQUATION
-	// Return the result that was computed
-	return result;
-}
-
-bool Tween::_apply_tween_value(InterpolateData &p_data, Variant &value) {
-	// Get the object we want to apply the new value to
-	Object *object = ObjectDB::get_instance(p_data.id);
-	ERR_FAIL_COND_V(object == nullptr, false);
-
-	// What kind of data are we mutating?
-	switch (p_data.type) {
-		case INTER_PROPERTY:
-		case FOLLOW_PROPERTY:
-		case TARGETING_PROPERTY: {
-			// Simply set the property on the object
-			bool valid = false;
-			object->set_indexed(p_data.key, value, &valid);
-			return valid;
+			return r;
 		}
 
-		case INTER_METHOD:
-		case FOLLOW_METHOD:
-		case TARGETING_METHOD: {
-			// We want to call the method on the target object
-			Callable::CallError error;
-
-			// Do we have a non-nil value passed in?
-			if (value.get_type() != Variant::NIL) {
-				// Pass it as an argument to the function call
-				Variant *arg[1] = { &value };
-				object->call(p_data.key[0], (const Variant **)arg, 1, error);
-			} else {
-				// Don't pass any argument
-				object->call(p_data.key[0], nullptr, 0, error);
-			}
-
-			// Did we get an error from the function call?
-			return error.error == Callable::CallError::CALL_OK;
+		default: {
+			return p_initial_val;
 		}
-
-		case INTER_CALLBACK:
-			// Nothing to apply for a callback
-			break;
 	};
-	// No issues found!
-	return true;
-}
-
-void Tween::_tween_process(float p_delta) {
-	// Process all of the pending commands
-	_process_pending_commands();
-
-	// If the scale is 0, make no progress on the tweens
-	if (speed_scale == 0) {
-		return;
-	}
-
-	// Update the delta and whether we are pending an update
-	p_delta *= speed_scale;
-	pending_update++;
-
-	// Are we repeating the interpolations?
-	if (repeat) {
-		// For each interpolation...
-		bool repeats_finished = true;
-		for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
-			// Get the data from it
-			InterpolateData &data = E->get();
-
-			// Is not finished?
-			if (!data.finish) {
-				// We aren't finished yet, no need to check the rest
-				repeats_finished = false;
-				break;
-			}
-		}
-
-		// If we are all finished, we can reset all of the tweens
-		if (repeats_finished) {
-			reset_all();
-		}
-	}
-
-	// Are all of the tweens complete?
-	int any_unfinished = 0;
-
-	// For each tween we wish to interpolate...
-	for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
-		// Get the data from it
-		InterpolateData &data = E->get();
-
-		// Is the data not active or already finished? No need to go any further
-		if (!data.active || data.finish) {
-			continue;
-		}
-
-		// Track if we hit one that isn't finished yet
-		any_unfinished++;
-
-		// Get the target object for this interpolation
-		Object *object = ObjectDB::get_instance(data.id);
-		if (object == nullptr) {
-			continue;
-		}
-
-		// Are we still delaying this tween?
-		bool prev_delaying = data.elapsed <= data.delay;
-		data.elapsed += p_delta;
-		if (data.elapsed < data.delay) {
-			continue;
-		} else if (prev_delaying) {
-			// We can apply the tween's value to the data and emit that the tween has started
-			_apply_tween_value(data, data.initial_val);
-			emit_signal("tween_started", object, NodePath(Vector<StringName>(), data.key, false));
-		}
-
-		// Are we at the end of the tween?
-		if (data.elapsed > (data.delay + data.duration)) {
-			// Set the elapsed time to the end and mark this one as finished
-			data.elapsed = data.delay + data.duration;
-			data.finish = true;
-		}
-
-		// Are we interpolating a callback?
-		if (data.type == INTER_CALLBACK) {
-			// Is the tween completed?
-			if (data.finish) {
-				// Are we calling this callback deferred or immediately?
-				if (data.call_deferred) {
-					// Run the deferred function callback, applying the correct number of arguments
-					switch (data.args) {
-						case 0:
-							object->call_deferred(data.key[0]);
-							break;
-						case 1:
-							object->call_deferred(data.key[0], data.arg[0]);
-							break;
-						case 2:
-							object->call_deferred(data.key[0], data.arg[0], data.arg[1]);
-							break;
-						case 3:
-							object->call_deferred(data.key[0], data.arg[0], data.arg[1], data.arg[2]);
-							break;
-						case 4:
-							object->call_deferred(data.key[0], data.arg[0], data.arg[1], data.arg[2], data.arg[3]);
-							break;
-						case 5:
-							object->call_deferred(data.key[0], data.arg[0], data.arg[1], data.arg[2], data.arg[3], data.arg[4]);
-							break;
-					}
-				} else {
-					// Call the function directly with the arguments
-					Callable::CallError error;
-					Variant *arg[5] = {
-						&data.arg[0],
-						&data.arg[1],
-						&data.arg[2],
-						&data.arg[3],
-						&data.arg[4],
-					};
-					object->call(data.key[0], (const Variant **)arg, data.args, error);
-				}
-			}
-		} else {
-			// We can apply the value directly
-			Variant result = _run_equation(data);
-			_apply_tween_value(data, result);
-
-			// Emit that the tween has taken a step
-			emit_signal("tween_step", object, NodePath(Vector<StringName>(), data.key, false), data.elapsed, result);
-		}
-
-		// Is the tween now finished?
-		if (data.finish) {
-			// Set it to the final value directly
-			Variant final_val = _get_final_val(data);
-			_apply_tween_value(data, final_val);
-
-			// Mark the tween as completed and emit the signal
-			data.elapsed = 0;
-			emit_signal("tween_completed", object, NodePath(Vector<StringName>(), data.key, false));
-
-			// If we are not repeating the tween, remove it
-			if (!repeat) {
-				call_deferred("_remove_by_uid", data.uid);
-				any_unfinished--;
-			}
-		}
-	}
-	// One less update left to go
-	pending_update--;
-
-	// If all tweens are completed, we no longer need to be active
-	if (any_unfinished == 0) {
-		set_active(false);
-		emit_signal("tween_all_completed");
-	}
-}
-
-void Tween::set_tween_process_mode(TweenProcessMode p_mode) {
-	tween_process_mode = p_mode;
-}
-
-Tween::TweenProcessMode Tween::get_tween_process_mode() const {
-	return tween_process_mode;
-}
-
-bool Tween::is_active() const {
-	return is_processing_internal() || is_physics_processing_internal();
-}
-
-void Tween::set_active(bool p_active) {
-	// Do nothing if it's the same active mode that we currently are
-	if (is_active() == p_active) {
-		return;
-	}
-
-	// Depending on physics or idle, set processing
-	switch (tween_process_mode) {
-		case TWEEN_PROCESS_IDLE:
-			set_process_internal(p_active);
-			break;
-		case TWEEN_PROCESS_PHYSICS:
-			set_physics_process_internal(p_active);
-			break;
-	}
-}
-
-bool Tween::is_repeat() const {
-	return repeat;
-}
-
-void Tween::set_repeat(bool p_repeat) {
-	repeat = p_repeat;
-}
-
-void Tween::set_speed_scale(float p_speed) {
-	speed_scale = p_speed;
-}
-
-float Tween::get_speed_scale() const {
-	return speed_scale;
-}
-
-void Tween::start() {
-	ERR_FAIL_COND_MSG(!is_inside_tree(), "Tween was not added to the SceneTree!");
-
-	// Are there any pending updates?
-	if (pending_update != 0) {
-		// Start the tweens after deferring
-		call_deferred("start");
-		return;
-	}
-
-	pending_update++;
-	for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
-		InterpolateData &data = E->get();
-		data.active = true;
-	}
-	pending_update--;
-
-	// We want to be activated
-	set_active(true);
-
-	// Don't resume from current position if stop_all() function has been used
-	if (was_stopped) {
-		seek(0);
-	}
-	was_stopped = false;
-}
-
-void Tween::reset(Object *p_object, StringName p_key) {
-	// Find all interpolations that use the same object and target string
-	pending_update++;
-	for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
-		// Get the target object
-		InterpolateData &data = E->get();
-		Object *object = ObjectDB::get_instance(data.id);
-		if (object == nullptr) {
-			continue;
-		}
-
-		// Do we have the correct object and key?
-		if (object == p_object && (data.concatenated_key == p_key || p_key == "")) {
-			// Reset the tween to the initial state
-			data.elapsed = 0;
-			data.finish = false;
-
-			// Also apply the initial state if there isn't a delay
-			if (data.delay == 0) {
-				_apply_tween_value(data, data.initial_val);
-			}
-		}
-	}
-	pending_update--;
-}
-
-void Tween::reset_all() {
-	// Go through all interpolations
-	pending_update++;
-	for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
-		// Get the target data and set it back to the initial state
-		InterpolateData &data = E->get();
-		data.elapsed = 0;
-		data.finish = false;
-
-		// If there isn't a delay, apply the value to the object
-		if (data.delay == 0) {
-			_apply_tween_value(data, data.initial_val);
-		}
-	}
-	pending_update--;
-}
-
-void Tween::stop(Object *p_object, StringName p_key) {
-	// Find the tween that has the given target object and string key
-	pending_update++;
-	for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
-		// Get the object the tween is targeting
-		InterpolateData &data = E->get();
-		Object *object = ObjectDB::get_instance(data.id);
-		if (object == nullptr) {
-			continue;
-		}
-
-		// Is this the correct object and does it have the given key?
-		if (object == p_object && (data.concatenated_key == p_key || p_key == "")) {
-			// Disable the tween
-			data.active = false;
-		}
-	}
-	pending_update--;
-}
-
-void Tween::stop_all() {
-	// We no longer need to be active since all tweens have been stopped
-	set_active(false);
-	was_stopped = true;
-	// For each interpolation...
-	pending_update++;
-	for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
-		// Simply set it inactive
-		InterpolateData &data = E->get();
-		data.active = false;
-	}
-	pending_update--;
-}
-
-void Tween::resume(Object *p_object, StringName p_key) {
-	// We need to be activated
-	// TODO: What if no tween is found??
-	set_active(true);
-
-	// Find the tween that uses the given target object and string key
-	pending_update++;
-	for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
-		// Grab the object
-		InterpolateData &data = E->get();
-		Object *object = ObjectDB::get_instance(data.id);
-		if (object == nullptr) {
-			continue;
-		}
-
-		// If the object and string key match, activate it
-		if (object == p_object && (data.concatenated_key == p_key || p_key == "")) {
-			data.active = true;
-		}
-	}
-	pending_update--;
-}
-
-void Tween::resume_all() {
-	// Set ourselves active so we can process tweens
-	// TODO: What if there are no tweens? We get set to active for no reason!
-	set_active(true);
-
-	// For each interpolation...
-	pending_update++;
-	for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
-		// Simply grab it and set it to active
-		InterpolateData &data = E->get();
-		data.active = true;
-	}
-	pending_update--;
-}
-
-void Tween::remove(Object *p_object, StringName p_key) {
-	// If we are still updating, call this function again later
-	if (pending_update != 0) {
-		call_deferred("remove", p_object, p_key);
-		return;
-	}
-
-	// For each interpolation...
-	List<List<InterpolateData>::Element *> for_removal;
-	for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
-		// Get the target object
-		InterpolateData &data = E->get();
-		Object *object = ObjectDB::get_instance(data.id);
-		if (object == nullptr) {
-			continue;
-		}
-
-		// If the target object and string key match, queue it for removal
-		if (object == p_object && (data.concatenated_key == p_key || p_key == "")) {
-			for_removal.push_back(E);
-		}
-	}
-
-	// For each interpolation we wish to remove...
-	for (List<List<InterpolateData>::Element *>::Element *E = for_removal.front(); E; E = E->next()) {
-		// Erase it
-		interpolates.erase(E->get());
-	}
-}
-
-void Tween::_remove_by_uid(int uid) {
-	// If we are still updating, call this function again later
-	if (pending_update != 0) {
-		call_deferred("_remove_by_uid", uid);
-		return;
-	}
-
-	// Find the interpolation that matches the given UID
-	for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
-		if (uid == E->get().uid) {
-			// It matches, erase it and stop looking
-			E->erase();
-			break;
-		}
-	}
-}
-
-void Tween::_push_interpolate_data(InterpolateData &p_data) {
-	pending_update++;
-
-	// Add the new interpolation
-	p_data.uid = ++uid;
-	interpolates.push_back(p_data);
-
-	pending_update--;
+#undef APPLY_EQUATION
 }
 
-void Tween::remove_all() {
-	// If we are still updating, call this function again later
-	if (pending_update != 0) {
-		call_deferred("remove_all");
-		return;
-	}
-	// We no longer need to be active
-	set_active(false);
-
-	// Clear out all interpolations and reset the uid
-	interpolates.clear();
-	uid = 0;
-}
-
-void Tween::seek(real_t p_time) {
-	// Go through each interpolation...
-	pending_update++;
-	for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
-		// Get the target data
-		InterpolateData &data = E->get();
-
-		// Update the elapsed data to be set to the target time
-		data.elapsed = p_time;
-
-		// Are we at the end?
-		if (data.elapsed < data.delay) {
-			// There is still time left to go
-			data.finish = false;
-			continue;
-		} else if (data.elapsed >= (data.delay + data.duration)) {
-			// We are past the end of it, set the elapsed time to the end and mark as finished
-			data.elapsed = (data.delay + data.duration);
-			data.finish = true;
-		} else {
-			// We are not finished with this interpolation yet
-			data.finish = false;
+Variant Tween::calculate_delta_value(Variant p_intial_val, Variant p_final_val) {
+	switch (p_intial_val.get_type()) {
+		case Variant::BOOL: {
+			return (int)p_final_val - (int)p_intial_val;
 		}
 
-		// If we are a callback, do nothing special
-		if (data.type == INTER_CALLBACK) {
-			continue;
+		case Variant::RECT2: {
+			Rect2 i = p_intial_val;
+			Rect2 f = p_final_val;
+			return Rect2(f.position - i.position, f.size - i.size);
 		}
 
-		// Run the equation on the data and apply the value
-		Variant result = _run_equation(data);
-		_apply_tween_value(data, result);
-	}
-	pending_update--;
-}
-
-real_t Tween::tell() const {
-	// We want to grab the position of the furthest along tween
-	pending_update++;
-	real_t pos = 0.0;
-
-	// For each interpolation...
-	for (const List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
-		// Get the data and figure out if its position is further along than the previous ones
-		const InterpolateData &data = E->get();
-		if (data.elapsed > pos) {
-			// Save it if so
-			pos = data.elapsed;
+		case Variant::RECT2I: {
+			Rect2i i = p_intial_val;
+			Rect2i f = p_final_val;
+			return Rect2i(f.position - i.position, f.size - i.size);
 		}
-	}
-	pending_update--;
-	return pos;
-}
-
-real_t Tween::get_runtime() const {
-	// If the tween isn't moving, it'll last forever
-	if (speed_scale == 0) {
-		return INFINITY;
-	}
-
-	pending_update++;
-
-	// For each interpolation...
-	real_t runtime = 0.0;
-	for (const List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
-		// Get the tween data and see if it's runtime is greater than the previous tweens
-		const InterpolateData &data = E->get();
-		real_t t = data.delay + data.duration;
-		if (t > runtime) {
-			// This is the longest running tween
-			runtime = t;
-		}
-	}
-	pending_update--;
-
-	// Adjust the runtime for the current speed scale
-	return runtime / speed_scale;
-}
-
-bool Tween::_calc_delta_val(const Variant &p_initial_val, const Variant &p_final_val, Variant &p_delta_val) {
-	// Get the initial, final, and delta values
-	const Variant &initial_val = p_initial_val;
-	const Variant &final_val = p_final_val;
-	Variant &delta_val = p_delta_val;
-
-	// What kind of data are we interpolating?
-	switch (initial_val.get_type()) {
-		case Variant::BOOL:
-			// We'll treat booleans just like integers
-		case Variant::INT:
-			// Compute the integer delta
-			delta_val = (int)final_val - (int)initial_val;
-			break;
-
-		case Variant::FLOAT:
-			// Convert to FLOAT and find the delta
-			delta_val = (real_t)final_val - (real_t)initial_val;
-			break;
-
-		case Variant::VECTOR2:
-			// Convert to Vectors and find the delta
-			delta_val = final_val.operator Vector2() - initial_val.operator Vector2();
-			break;
-
-		case Variant::RECT2: {
-			// Build a new Rect2 and use the new position and sizes to make a delta
-			Rect2 i = initial_val;
-			Rect2 f = final_val;
-			delta_val = Rect2(f.position - i.position, f.size - i.size);
-		} break;
-
-		case Variant::VECTOR3:
-			// Convert to Vectors and find the delta
-			delta_val = final_val.operator Vector3() - initial_val.operator Vector3();
-			break;
 
 		case Variant::TRANSFORM2D: {
-			// Build a new transform which is the difference between the initial and final values
-			Transform2D i = initial_val;
-			Transform2D f = final_val;
-			Transform2D d = Transform2D();
-			d[0][0] = f.elements[0][0] - i.elements[0][0];
-			d[0][1] = f.elements[0][1] - i.elements[0][1];
-			d[1][0] = f.elements[1][0] - i.elements[1][0];
-			d[1][1] = f.elements[1][1] - i.elements[1][1];
-			d[2][0] = f.elements[2][0] - i.elements[2][0];
-			d[2][1] = f.elements[2][1] - i.elements[2][1];
-			delta_val = d;
-		} break;
-
-		case Variant::QUATERNION:
-			// Convert to quaternianls and find the delta
-			delta_val = final_val.operator Quaternion() - initial_val.operator Quaternion();
-			break;
+			Transform2D i = p_intial_val;
+			Transform2D f = p_final_val;
+			return Transform2D(f.elements[0][0] - i.elements[0][0],
+					f.elements[0][1] - i.elements[0][1],
+					f.elements[1][0] - i.elements[1][0],
+					f.elements[1][1] - i.elements[1][1],
+					f.elements[2][0] - i.elements[2][0],
+					f.elements[2][1] - i.elements[2][1]);
+		}
 
 		case Variant::AABB: {
-			// Build a new AABB and use the new position and sizes to make a delta
-			AABB i = initial_val;
-			AABB f = final_val;
-			delta_val = AABB(f.position - i.position, f.size - i.size);
-		} break;
+			AABB i = p_intial_val;
+			AABB f = p_final_val;
+			return AABB(f.position - i.position, f.size - i.size);
+		}
 
 		case Variant::BASIS: {
-			// Build a new basis which is the delta between the initial and final values
-			Basis i = initial_val;
-			Basis f = final_val;
-			delta_val = Basis(f.elements[0][0] - i.elements[0][0],
+			Basis i = p_intial_val;
+			Basis f = p_final_val;
+			return Basis(f.elements[0][0] - i.elements[0][0],
 					f.elements[0][1] - i.elements[0][1],
 					f.elements[0][2] - i.elements[0][2],
 					f.elements[1][0] - i.elements[1][0],
@@ -1227,14 +529,12 @@ bool Tween::_calc_delta_val(const Variant &p_initial_val, const Variant &p_final
 					f.elements[2][0] - i.elements[2][0],
 					f.elements[2][1] - i.elements[2][1],
 					f.elements[2][2] - i.elements[2][2]);
-		} break;
+		}
 
 		case Variant::TRANSFORM3D: {
-			// Build a new transform which is the difference between the initial and final values
-			Transform3D i = initial_val;
-			Transform3D f = final_val;
-			Transform3D d;
-			d.set(f.basis.elements[0][0] - i.basis.elements[0][0],
+			Transform3D i = p_intial_val;
+			Transform3D f = p_final_val;
+			return Transform3D(f.basis.elements[0][0] - i.basis.elements[0][0],
 					f.basis.elements[0][1] - i.basis.elements[0][1],
 					f.basis.elements[0][2] - i.basis.elements[0][2],
 					f.basis.elements[1][0] - i.basis.elements[1][0],
@@ -1246,569 +546,342 @@ bool Tween::_calc_delta_val(const Variant &p_initial_val, const Variant &p_final
 					f.origin.x - i.origin.x,
 					f.origin.y - i.origin.y,
 					f.origin.z - i.origin.z);
-
-			delta_val = d;
-		} break;
-
-		case Variant::COLOR: {
-			// Make a new color which is the difference between each the color's RGBA attributes
-			Color i = initial_val;
-			Color f = final_val;
-			delta_val = Color(f.r - i.r, f.g - i.g, f.b - i.b, f.a - i.a);
-		} break;
+		}
 
 		default: {
-			static Variant::Type supported_types[] = {
-				Variant::BOOL,
-				Variant::INT,
-				Variant::FLOAT,
-				Variant::VECTOR2,
-				Variant::RECT2,
-				Variant::VECTOR3,
-				Variant::TRANSFORM2D,
-				Variant::QUATERNION,
-				Variant::AABB,
-				Variant::BASIS,
-				Variant::TRANSFORM3D,
-				Variant::COLOR,
-			};
-
-			int length = *(&supported_types + 1) - supported_types;
-			String error_msg = "Invalid parameter type. Supported types are: ";
-			for (int i = 0; i < length; i++) {
-				if (i != 0) {
-					error_msg += ", ";
-				}
-				error_msg += Variant::get_type_name(supported_types[i]);
-			}
-			error_msg += ".";
-			ERR_PRINT(error_msg);
-			return false;
+			return Variant::evaluate(Variant::OP_SUBTRACT, p_final_val, p_intial_val);
 		}
 	};
-	return true;
 }
 
-void Tween::_build_interpolation(InterpolateType p_interpolation_type, Object *p_object, NodePath *p_property, StringName *p_method, Variant p_initial_val, Variant p_final_val, real_t p_duration, TransitionType p_trans_type, EaseType p_ease_type, real_t p_delay) {
-	// TODO: Add initialization+implementation for remaining interpolation types
-	// TODO: Fix this method's organization to take advantage of the type
-
-	// Make a new interpolation data
-	InterpolateData data;
-	data.active = true;
-	data.type = p_interpolation_type;
-	data.finish = false;
-	data.elapsed = 0;
+void Tween::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("tween_property", "object", "property", "final_val", "duration"), &Tween::tween_property);
+	ClassDB::bind_method(D_METHOD("tween_interval", "time"), &Tween::tween_interval);
+	ClassDB::bind_method(D_METHOD("tween_callback", "callback"), &Tween::tween_callback);
+	ClassDB::bind_method(D_METHOD("tween_method", "method", "from", "to", "duration"), &Tween::tween_method);
+
+	ClassDB::bind_method(D_METHOD("custom_step", "delta"), &Tween::custom_step);
+	ClassDB::bind_method(D_METHOD("stop"), &Tween::stop);
+	ClassDB::bind_method(D_METHOD("pause"), &Tween::pause);
+	ClassDB::bind_method(D_METHOD("play"), &Tween::play);
+	ClassDB::bind_method(D_METHOD("kill"), &Tween::kill);
+
+	ClassDB::bind_method(D_METHOD("is_running"), &Tween::is_running);
+	ClassDB::bind_method(D_METHOD("is_valid"), &Tween::is_valid);
+	ClassDB::bind_method(D_METHOD("bind_node", "node"), &Tween::bind_node);
+	ClassDB::bind_method(D_METHOD("set_process_mode", "mode"), &Tween::set_process_mode);
+	ClassDB::bind_method(D_METHOD("set_pause_mode", "mode"), &Tween::set_pause_mode);
+
+	ClassDB::bind_method(D_METHOD("set_parallel", "parallel"), &Tween::set_parallel, DEFVAL(true));
+	ClassDB::bind_method(D_METHOD("set_loops", "loops"), &Tween::set_loops, DEFVAL(0));
+	ClassDB::bind_method(D_METHOD("set_speed_scale", "speed"), &Tween::set_speed_scale);
+	ClassDB::bind_method(D_METHOD("set_trans", "trans"), &Tween::set_trans);
+	ClassDB::bind_method(D_METHOD("set_ease", "ease"), &Tween::set_ease);
 
-	// Validate and apply interpolation data
+	ClassDB::bind_method(D_METHOD("parallel"), &Tween::parallel);
+	ClassDB::bind_method(D_METHOD("chain"), &Tween::chain);
 
-	// Give it the object
-	ERR_FAIL_COND_MSG(p_object == nullptr, "Invalid object provided to Tween.");
-	data.id = p_object->get_instance_id();
+	ClassDB::bind_method(D_METHOD("interpolate_value", "trans_type", "ease_type", "elapsed_time", "initial_value", "delta_value", "duration"), &Tween::interpolate_variant);
 
-	// Validate the initial and final values
-	ERR_FAIL_COND_MSG(p_initial_val.get_type() != p_final_val.get_type(), "Initial value type '" + Variant::get_type_name(p_initial_val.get_type()) + "' does not match final value type '" + Variant::get_type_name(p_final_val.get_type()) + "'.");
-	data.initial_val = p_initial_val;
-	data.final_val = p_final_val;
+	ADD_SIGNAL(MethodInfo("step_finished", PropertyInfo(Variant::INT, "idx")));
+	ADD_SIGNAL(MethodInfo("loop_finished", PropertyInfo(Variant::INT, "loop_count")));
+	ADD_SIGNAL(MethodInfo("finished"));
 
-	// Check the Duration
-	ERR_FAIL_COND_MSG(p_duration < 0, "Only non-negative duration values allowed in Tweens.");
-	data.duration = p_duration;
+	BIND_ENUM_CONSTANT(TWEEN_PROCESS_PHYSICS);
+	BIND_ENUM_CONSTANT(TWEEN_PROCESS_IDLE);
 
-	// Tween Delay
-	ERR_FAIL_COND_MSG(p_delay < 0, "Only non-negative delay values allowed in Tweens.");
-	data.delay = p_delay;
+	BIND_ENUM_CONSTANT(TWEEN_PAUSE_BOUND);
+	BIND_ENUM_CONSTANT(TWEEN_PAUSE_STOP);
+	BIND_ENUM_CONSTANT(TWEEN_PAUSE_PROCESS);
 
-	// Transition type
-	ERR_FAIL_COND_MSG(p_trans_type < 0 || p_trans_type >= TRANS_COUNT, "Invalid transition type provided to Tween.");
-	data.trans_type = p_trans_type;
+	BIND_ENUM_CONSTANT(TRANS_LINEAR);
+	BIND_ENUM_CONSTANT(TRANS_SINE);
+	BIND_ENUM_CONSTANT(TRANS_QUINT);
+	BIND_ENUM_CONSTANT(TRANS_QUART);
+	BIND_ENUM_CONSTANT(TRANS_QUAD);
+	BIND_ENUM_CONSTANT(TRANS_EXPO);
+	BIND_ENUM_CONSTANT(TRANS_ELASTIC);
+	BIND_ENUM_CONSTANT(TRANS_CUBIC);
+	BIND_ENUM_CONSTANT(TRANS_CIRC);
+	BIND_ENUM_CONSTANT(TRANS_BOUNCE);
+	BIND_ENUM_CONSTANT(TRANS_BACK);
 
-	// Easing type
-	ERR_FAIL_COND_MSG(p_ease_type < 0 || p_ease_type >= EASE_COUNT, "Invalid easing type provided to Tween.");
-	data.ease_type = p_ease_type;
+	BIND_ENUM_CONSTANT(EASE_IN);
+	BIND_ENUM_CONSTANT(EASE_OUT);
+	BIND_ENUM_CONSTANT(EASE_IN_OUT);
+	BIND_ENUM_CONSTANT(EASE_OUT_IN);
+}
 
-	// Is the property defined?
-	if (p_property) {
-		// Check that the object actually contains the given property
-		bool prop_valid = false;
-		p_object->get_indexed(p_property->get_subnames(), &prop_valid);
-		ERR_FAIL_COND_MSG(!prop_valid, "Tween target object has no property named: " + p_property->get_concatenated_subnames() + ".");
+Ref<PropertyTweener> PropertyTweener::from(Variant p_value) {
+	initial_val = p_value;
+	do_continue = false;
+	return this;
+}
 
-		data.key = p_property->get_subnames();
-		data.concatenated_key = p_property->get_concatenated_subnames();
-	}
+Ref<PropertyTweener> PropertyTweener::from_current() {
+	do_continue = false;
+	return this;
+}
 
-	// Is the method defined?
-	if (p_method) {
-		// Does the object even have the requested method?
-		ERR_FAIL_COND_MSG(!p_object->has_method(*p_method), "Tween target object has no method named: " + *p_method + ".");
+Ref<PropertyTweener> PropertyTweener::as_relative() {
+	relative = true;
+	return this;
+}
 
-		data.key.push_back(*p_method);
-		data.concatenated_key = *p_method;
-	}
+Ref<PropertyTweener> PropertyTweener::set_trans(Tween::TransitionType p_trans) {
+	trans_type = p_trans;
+	return this;
+}
 
-	// Is there not a valid delta?
-	if (!_calc_delta_val(data.initial_val, data.final_val, data.delta_val)) {
-		return;
-	}
+Ref<PropertyTweener> PropertyTweener::set_ease(Tween::EaseType p_ease) {
+	ease_type = p_ease;
+	return this;
+}
 
-	// Add this interpolation to the total
-	_push_interpolate_data(data);
+Ref<PropertyTweener> PropertyTweener::set_delay(float p_delay) {
+	delay = p_delay;
+	return this;
 }
 
-void Tween::interpolate_property(Object *p_object, NodePath p_property, Variant p_initial_val, Variant p_final_val, real_t p_duration, TransitionType p_trans_type, EaseType p_ease_type, real_t p_delay) {
-	// If we are busy updating, call this function again later
-	if (pending_update != 0) {
-		_add_pending_command("interpolate_property", p_object, p_property, p_initial_val, p_final_val, p_duration, p_trans_type, p_ease_type, p_delay);
+void PropertyTweener::start() {
+	elapsed_time = 0;
+	finished = false;
+
+	Object *target_instance = ObjectDB::get_instance(target);
+	if (!target_instance) {
+		WARN_PRINT("Target object freed before starting, aborting Tweener.");
 		return;
 	}
 
-	// Check that the target object is valid
-	ERR_FAIL_COND_MSG(p_object == nullptr, vformat("The Tween \"%s\"'s target node is `null`. Is the node reference correct?", get_name()));
-
-	// Get the property from the node path
-	p_property = p_property.get_as_property_path();
-
-	// If no initial value given, grab the initial value from the object
-	// TODO: Is this documented? This is very useful and removes a lot of clutter from tweens!
-	if (p_initial_val.get_type() == Variant::NIL) {
-		p_initial_val = p_object->get_indexed(p_property.get_subnames());
+	if (do_continue) {
+		initial_val = target_instance->get_indexed(property);
 	}
 
-	// Convert any integers into REALs as they are better for interpolation
-	if (p_initial_val.get_type() == Variant::INT) {
-		p_initial_val = p_initial_val.operator real_t();
-	}
-	if (p_final_val.get_type() == Variant::INT) {
-		p_final_val = p_final_val.operator real_t();
+	if (relative) {
+		final_val = Variant::evaluate(Variant::Operator::OP_ADD, initial_val, base_final_val);
 	}
 
-	// Build the interpolation data
-	_build_interpolation(INTER_PROPERTY, p_object, &p_property, nullptr, p_initial_val, p_final_val, p_duration, p_trans_type, p_ease_type, p_delay);
+	delta_val = tween->calculate_delta_value(initial_val, final_val);
 }
 
-void Tween::interpolate_method(Object *p_object, StringName p_method, Variant p_initial_val, Variant p_final_val, real_t p_duration, TransitionType p_trans_type, EaseType p_ease_type, real_t p_delay) {
-	// If we are busy updating, call this function again later
-	if (pending_update != 0) {
-		_add_pending_command("interpolate_method", p_object, p_method, p_initial_val, p_final_val, p_duration, p_trans_type, p_ease_type, p_delay);
-		return;
+bool PropertyTweener::step(float &r_delta) {
+	if (finished) {
+		// This is needed in case there's a parallel Tweener with longer duration.
+		return false;
 	}
 
-	// Check that the target object is valid
-	ERR_FAIL_COND_MSG(p_object == nullptr, vformat("The Tween \"%s\"'s target node is `null`. Is the node reference correct?", get_name()));
-
-	// Convert any integers into REALs as they are better for interpolation
-	if (p_initial_val.get_type() == Variant::INT) {
-		p_initial_val = p_initial_val.operator real_t();
-	}
-	if (p_final_val.get_type() == Variant::INT) {
-		p_final_val = p_final_val.operator real_t();
+	Object *target_instance = ObjectDB::get_instance(target);
+	if (!target_instance) {
+		return false;
 	}
+	elapsed_time += r_delta;
 
-	// Build the interpolation data
-	_build_interpolation(INTER_METHOD, p_object, nullptr, &p_method, p_initial_val, p_final_val, p_duration, p_trans_type, p_ease_type, p_delay);
-}
-
-void Tween::interpolate_callback(Object *p_object, real_t p_duration, String p_callback, VARIANT_ARG_DECLARE) {
-	// If we are already updating, call this function again later
-	if (pending_update != 0) {
-		_add_pending_command("interpolate_callback", p_object, p_duration, p_callback, p_arg1, p_arg2, p_arg3, p_arg4, p_arg5);
-		return;
+	if (elapsed_time < delay) {
+		r_delta = 0;
+		return true;
 	}
 
-	// Check that the target object is valid
-	ERR_FAIL_COND(p_object == nullptr);
-
-	// Duration cannot be negative
-	ERR_FAIL_COND(p_duration < 0);
-
-	// Check whether the object even has the callback
-	ERR_FAIL_COND_MSG(!p_object->has_method(p_callback), "Object has no callback named: " + p_callback + ".");
-
-	// Build a new InterpolationData
-	InterpolateData data;
-	data.active = true;
-	data.type = INTER_CALLBACK;
-	data.finish = false;
-	data.call_deferred = false;
-	data.elapsed = 0;
-
-	// Give the data it's configuration
-	data.id = p_object->get_instance_id();
-	data.key.push_back(p_callback);
-	data.concatenated_key = p_callback;
-	data.duration = p_duration;
-	data.delay = 0;
-
-	// Add arguments to the interpolation
-	int args = 0;
-	if (p_arg5.get_type() != Variant::NIL) {
-		args = 5;
-	} else if (p_arg4.get_type() != Variant::NIL) {
-		args = 4;
-	} else if (p_arg3.get_type() != Variant::NIL) {
-		args = 3;
-	} else if (p_arg2.get_type() != Variant::NIL) {
-		args = 2;
-	} else if (p_arg1.get_type() != Variant::NIL) {
-		args = 1;
+	float time = MIN(elapsed_time - delay, duration);
+	target_instance->set_indexed(property, tween->interpolate_variant(initial_val, delta_val, time, duration, trans_type, ease_type));
+
+	if (time < duration) {
+		r_delta = 0;
+		return true;
 	} else {
-		args = 0;
+		finished = true;
+		r_delta = elapsed_time - delay - duration;
+		emit_signal("finished");
+		return false;
 	}
-
-	data.args = args;
-	data.arg[0] = p_arg1;
-	data.arg[1] = p_arg2;
-	data.arg[2] = p_arg3;
-	data.arg[3] = p_arg4;
-	data.arg[4] = p_arg5;
-
-	// Add the new interpolation
-	_push_interpolate_data(data);
 }
 
-void Tween::interpolate_deferred_callback(Object *p_object, real_t p_duration, String p_callback, VARIANT_ARG_DECLARE) {
-	// If we are already updating, call this function again later
-	if (pending_update != 0) {
-		_add_pending_command("interpolate_deferred_callback", p_object, p_duration, p_callback, p_arg1, p_arg2, p_arg3, p_arg4, p_arg5);
-		return;
+void PropertyTweener::set_tween(Ref<Tween> p_tween) {
+	tween = p_tween;
+	if (trans_type == Tween::TRANS_MAX) {
+		trans_type = tween->get_trans();
 	}
-
-	// Check that the target object is valid
-	ERR_FAIL_COND(p_object == nullptr);
-
-	// No negative durations allowed
-	ERR_FAIL_COND(p_duration < 0);
-
-	// Confirm the callback exists on the object
-	ERR_FAIL_COND_MSG(!p_object->has_method(p_callback), "Object has no callback named: " + p_callback + ".");
-
-	// Create a new InterpolateData for the callback
-	InterpolateData data;
-	data.active = true;
-	data.type = INTER_CALLBACK;
-	data.finish = false;
-	data.call_deferred = true;
-	data.elapsed = 0;
-
-	// Give the data it's configuration
-	data.id = p_object->get_instance_id();
-	data.key.push_back(p_callback);
-	data.concatenated_key = p_callback;
-	data.duration = p_duration;
-	data.delay = 0;
-
-	// Collect arguments for the callback
-	int args = 0;
-	if (p_arg5.get_type() != Variant::NIL) {
-		args = 5;
-	} else if (p_arg4.get_type() != Variant::NIL) {
-		args = 4;
-	} else if (p_arg3.get_type() != Variant::NIL) {
-		args = 3;
-	} else if (p_arg2.get_type() != Variant::NIL) {
-		args = 2;
-	} else if (p_arg1.get_type() != Variant::NIL) {
-		args = 1;
-	} else {
-		args = 0;
+	if (ease_type == Tween::EASE_MAX) {
+		ease_type = tween->get_ease();
 	}
+}
 
-	data.args = args;
-	data.arg[0] = p_arg1;
-	data.arg[1] = p_arg2;
-	data.arg[2] = p_arg3;
-	data.arg[3] = p_arg4;
-	data.arg[4] = p_arg5;
+void PropertyTweener::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("from", "value"), &PropertyTweener::from);
+	ClassDB::bind_method(D_METHOD("from_current"), &PropertyTweener::from_current);
+	ClassDB::bind_method(D_METHOD("as_relative"), &PropertyTweener::as_relative);
+	ClassDB::bind_method(D_METHOD("set_trans", "trans"), &PropertyTweener::set_trans);
+	ClassDB::bind_method(D_METHOD("set_ease", "ease"), &PropertyTweener::set_ease);
+	ClassDB::bind_method(D_METHOD("set_delay", "delay"), &PropertyTweener::set_delay);
+}
 
-	// Add the new interpolation
-	_push_interpolate_data(data);
+PropertyTweener::PropertyTweener(Object *p_target, NodePath p_property, Variant p_to, float p_duration) {
+	target = p_target->get_instance_id();
+	property = p_property.get_as_property_path().get_subnames();
+	initial_val = p_target->get_indexed(property);
+	base_final_val = p_to;
+	final_val = base_final_val;
+	duration = p_duration;
 }
 
-void Tween::follow_property(Object *p_object, NodePath p_property, Variant p_initial_val, Object *p_target, NodePath p_target_property, real_t p_duration, TransitionType p_trans_type, EaseType p_ease_type, real_t p_delay) {
-	// If we are already updating, call this function again later
-	if (pending_update != 0) {
-		_add_pending_command("follow_property", p_object, p_property, p_initial_val, p_target, p_target_property, p_duration, p_trans_type, p_ease_type, p_delay);
-		return;
-	}
+PropertyTweener::PropertyTweener() {
+	ERR_FAIL_MSG("Can't create empty PropertyTweener. Use get_tree().tween_property() or tween_property() instead.");
+}
 
-	// Get the two properties from their paths
-	p_property = p_property.get_as_property_path();
-	p_target_property = p_target_property.get_as_property_path();
+void IntervalTweener::start() {
+	elapsed_time = 0;
+	finished = false;
+}
 
-	// If no initial value is given, grab it from the source object
-	// TODO: Is this documented? It's really helpful for decluttering tweens
-	if (p_initial_val.get_type() == Variant::NIL) {
-		p_initial_val = p_object->get_indexed(p_property.get_subnames());
+bool IntervalTweener::step(float &r_delta) {
+	if (finished) {
+		return false;
 	}
 
-	// Convert initial INT values to FLOAT as they are better for interpolation
-	if (p_initial_val.get_type() == Variant::INT) {
-		p_initial_val = p_initial_val.operator real_t();
+	elapsed_time += r_delta;
+
+	if (elapsed_time < duration) {
+		r_delta = 0;
+		return true;
+	} else {
+		finished = true;
+		r_delta = elapsed_time - duration;
+		emit_signal("finished");
+		return false;
 	}
+}
 
-	// Confirm the source and target objects are valid
-	ERR_FAIL_COND(p_object == nullptr);
-	ERR_FAIL_COND(p_target == nullptr);
+IntervalTweener::IntervalTweener(float p_time) {
+	duration = p_time;
+}
 
-	// No negative durations
-	ERR_FAIL_COND(p_duration < 0);
+IntervalTweener::IntervalTweener() {
+	ERR_FAIL_MSG("Can't create empty IntervalTweener. Use get_tree().tween_interval() instead.");
+}
 
-	// Ensure transition and easing types are valid
-	ERR_FAIL_COND(p_trans_type < 0 || p_trans_type >= TRANS_COUNT);
-	ERR_FAIL_COND(p_ease_type < 0 || p_ease_type >= EASE_COUNT);
+Ref<CallbackTweener> CallbackTweener::set_delay(float p_delay) {
+	delay = p_delay;
+	return this;
+}
 
-	// No negative delays
-	ERR_FAIL_COND(p_delay < 0);
+void CallbackTweener::start() {
+	elapsed_time = 0;
+	finished = false;
+}
 
-	// Confirm the source and target objects have the desired properties
-	bool prop_valid = false;
-	p_object->get_indexed(p_property.get_subnames(), &prop_valid);
-	ERR_FAIL_COND(!prop_valid);
+bool CallbackTweener::step(float &r_delta) {
+	if (finished) {
+		return false;
+	}
 
-	bool target_prop_valid = false;
-	Variant target_val = p_target->get_indexed(p_target_property.get_subnames(), &target_prop_valid);
-	ERR_FAIL_COND(!target_prop_valid);
+	elapsed_time += r_delta;
+	if (elapsed_time >= delay) {
+		Variant result;
+		Callable::CallError ce;
+		callback.call(nullptr, 0, result, ce);
+		if (ce.error != Callable::CallError::CALL_OK) {
+			ERR_FAIL_V_MSG(false, "Error calling method from CallbackTweener: " + Variant::get_call_error_text(this, callback.get_method(), nullptr, 0, ce));
+		}
 
-	// Convert target INT to FLOAT since it is better for interpolation
-	if (target_val.get_type() == Variant::INT) {
-		target_val = target_val.operator real_t();
+		finished = true;
+		r_delta = elapsed_time - delay;
+		emit_signal("finished");
+		return false;
 	}
 
-	// Verify that the target value and initial value are the same type
-	ERR_FAIL_COND(target_val.get_type() != p_initial_val.get_type());
-
-	// Create a new InterpolateData
-	InterpolateData data;
-	data.active = true;
-	data.type = FOLLOW_PROPERTY;
-	data.finish = false;
-	data.elapsed = 0;
-
-	// Give the InterpolateData it's configuration
-	data.id = p_object->get_instance_id();
-	data.key = p_property.get_subnames();
-	data.concatenated_key = p_property.get_concatenated_subnames();
-	data.initial_val = p_initial_val;
-	data.target_id = p_target->get_instance_id();
-	data.target_key = p_target_property.get_subnames();
-	data.duration = p_duration;
-	data.trans_type = p_trans_type;
-	data.ease_type = p_ease_type;
-	data.delay = p_delay;
-
-	// Add the interpolation
-	_push_interpolate_data(data);
-}
-
-void Tween::follow_method(Object *p_object, StringName p_method, Variant p_initial_val, Object *p_target, StringName p_target_method, real_t p_duration, TransitionType p_trans_type, EaseType p_ease_type, real_t p_delay) {
-	// If we are currently updating, call this function again later
-	if (pending_update != 0) {
-		_add_pending_command("follow_method", p_object, p_method, p_initial_val, p_target, p_target_method, p_duration, p_trans_type, p_ease_type, p_delay);
-		return;
-	}
-	// Convert initial INT values to FLOAT as they are better for interpolation
-	if (p_initial_val.get_type() == Variant::INT) {
-		p_initial_val = p_initial_val.operator real_t();
-	}
+	r_delta = 0;
+	return true;
+}
 
-	// Verify the source and target objects are valid
-	ERR_FAIL_COND(p_object == nullptr);
-	ERR_FAIL_COND(p_target == nullptr);
+void CallbackTweener::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_delay", "delay"), &CallbackTweener::set_delay);
+}
 
-	// No negative durations
-	ERR_FAIL_COND(p_duration < 0);
+CallbackTweener::CallbackTweener(Callable p_callback) {
+	callback = p_callback;
+}
 
-	// Ensure that the transition and ease types are valid
-	ERR_FAIL_COND(p_trans_type < 0 || p_trans_type >= TRANS_COUNT);
-	ERR_FAIL_COND(p_ease_type < 0 || p_ease_type >= EASE_COUNT);
+CallbackTweener::CallbackTweener() {
+	ERR_FAIL_MSG("Can't create empty CallbackTweener. Use get_tree().tween_callback() instead.");
+}
 
-	// No negative delays
-	ERR_FAIL_COND(p_delay < 0);
+Ref<MethodTweener> MethodTweener::set_delay(float p_delay) {
+	delay = p_delay;
+	return this;
+}
 
-	// Confirm both objects have the target methods
-	ERR_FAIL_COND_MSG(!p_object->has_method(p_method), "Object has no method named: " + p_method + ".");
-	ERR_FAIL_COND_MSG(!p_target->has_method(p_target_method), "Target has no method named: " + p_target_method + ".");
+Ref<MethodTweener> MethodTweener::set_trans(Tween::TransitionType p_trans) {
+	trans_type = p_trans;
+	return this;
+}
 
-	// Call the method to get the target value
-	Callable::CallError error;
-	Variant target_val = p_target->call(p_target_method, nullptr, 0, error);
-	ERR_FAIL_COND(error.error != Callable::CallError::CALL_OK);
+Ref<MethodTweener> MethodTweener::set_ease(Tween::EaseType p_ease) {
+	ease_type = p_ease;
+	return this;
+}
 
-	// Convert target INT values to FLOAT as they are better for interpolation
-	if (target_val.get_type() == Variant::INT) {
-		target_val = target_val.operator real_t();
-	}
-	ERR_FAIL_COND(target_val.get_type() != p_initial_val.get_type());
-
-	// Make the new InterpolateData for the method follow
-	InterpolateData data;
-	data.active = true;
-	data.type = FOLLOW_METHOD;
-	data.finish = false;
-	data.elapsed = 0;
-
-	// Give the data it's configuration
-	data.id = p_object->get_instance_id();
-	data.key.push_back(p_method);
-	data.concatenated_key = p_method;
-	data.initial_val = p_initial_val;
-	data.target_id = p_target->get_instance_id();
-	data.target_key.push_back(p_target_method);
-	data.duration = p_duration;
-	data.trans_type = p_trans_type;
-	data.ease_type = p_ease_type;
-	data.delay = p_delay;
-
-	// Add the new interpolation
-	_push_interpolate_data(data);
-}
-
-void Tween::targeting_property(Object *p_object, NodePath p_property, Object *p_initial, NodePath p_initial_property, Variant p_final_val, real_t p_duration, TransitionType p_trans_type, EaseType p_ease_type, real_t p_delay) {
-	// If we are currently updating, call this function again later
-	if (pending_update != 0) {
-		_add_pending_command("targeting_property", p_object, p_property, p_initial, p_initial_property, p_final_val, p_duration, p_trans_type, p_ease_type, p_delay);
-		return;
-	}
-	// Grab the target property and the target property
-	p_property = p_property.get_as_property_path();
-	p_initial_property = p_initial_property.get_as_property_path();
+void MethodTweener::start() {
+	elapsed_time = 0;
+	finished = false;
+}
 
-	// Convert the initial INT values to FLOAT as they are better for Interpolation
-	if (p_final_val.get_type() == Variant::INT) {
-		p_final_val = p_final_val.operator real_t();
+bool MethodTweener::step(float &r_delta) {
+	if (finished) {
+		return false;
 	}
 
-	// Verify both objects are valid
-	ERR_FAIL_COND(p_object == nullptr);
-	ERR_FAIL_COND(p_initial == nullptr);
-
-	// No negative durations
-	ERR_FAIL_COND(p_duration < 0);
-
-	// Ensure transition and easing types are valid
-	ERR_FAIL_COND(p_trans_type < 0 || p_trans_type >= TRANS_COUNT);
-	ERR_FAIL_COND(p_ease_type < 0 || p_ease_type >= EASE_COUNT);
-
-	// No negative delays
-	ERR_FAIL_COND(p_delay < 0);
-
-	// Ensure the initial and target properties exist on their objects
-	bool prop_valid = false;
-	p_object->get_indexed(p_property.get_subnames(), &prop_valid);
-	ERR_FAIL_COND(!prop_valid);
+	elapsed_time += r_delta;
 
-	bool initial_prop_valid = false;
-	Variant initial_val = p_initial->get_indexed(p_initial_property.get_subnames(), &initial_prop_valid);
-	ERR_FAIL_COND(!initial_prop_valid);
-
-	// Convert the initial INT value to FLOAT as it is better for interpolation
-	if (initial_val.get_type() == Variant::INT) {
-		initial_val = initial_val.operator real_t();
-	}
-	ERR_FAIL_COND(initial_val.get_type() != p_final_val.get_type());
-
-	// Build the InterpolateData object
-	InterpolateData data;
-	data.active = true;
-	data.type = TARGETING_PROPERTY;
-	data.finish = false;
-	data.elapsed = 0;
-
-	// Give the data it's configuration
-	data.id = p_object->get_instance_id();
-	data.key = p_property.get_subnames();
-	data.concatenated_key = p_property.get_concatenated_subnames();
-	data.target_id = p_initial->get_instance_id();
-	data.target_key = p_initial_property.get_subnames();
-	data.initial_val = initial_val;
-	data.final_val = p_final_val;
-	data.duration = p_duration;
-	data.trans_type = p_trans_type;
-	data.ease_type = p_ease_type;
-	data.delay = p_delay;
-
-	// Ensure there is a valid delta
-	if (!_calc_delta_val(data.initial_val, data.final_val, data.delta_val)) {
-		return;
+	if (elapsed_time < delay) {
+		r_delta = 0;
+		return true;
 	}
 
-	// Add the interpolation
-	_push_interpolate_data(data);
-}
+	float time = MIN(elapsed_time - delay, duration);
+	Variant current_val = tween->interpolate_variant(initial_val, delta_val, time, duration, trans_type, ease_type);
+	const Variant **argptr = (const Variant **)alloca(sizeof(Variant *));
+	argptr[0] = &current_val;
 
-void Tween::targeting_method(Object *p_object, StringName p_method, Object *p_initial, StringName p_initial_method, Variant p_final_val, real_t p_duration, TransitionType p_trans_type, EaseType p_ease_type, real_t p_delay) {
-	// If we are currently updating, call this function again later
-	if (pending_update != 0) {
-		_add_pending_command("targeting_method", p_object, p_method, p_initial, p_initial_method, p_final_val, p_duration, p_trans_type, p_ease_type, p_delay);
-		return;
+	Variant result;
+	Callable::CallError ce;
+	callback.call(argptr, 1, result, ce);
+	if (ce.error != Callable::CallError::CALL_OK) {
+		ERR_FAIL_V_MSG(false, "Error calling method from MethodTweener: " + Variant::get_call_error_text(this, callback.get_method(), argptr, 1, ce));
 	}
 
-	// Convert final INT values to FLOAT as they are better for interpolation
-	if (p_final_val.get_type() == Variant::INT) {
-		p_final_val = p_final_val.operator real_t();
+	if (time < duration) {
+		r_delta = 0;
+		return true;
+	} else {
+		finished = true;
+		r_delta = elapsed_time - delay - duration;
+		emit_signal("finished");
+		return false;
 	}
+}
 
-	// Make sure the given objects are valid
-	ERR_FAIL_COND(p_object == nullptr);
-	ERR_FAIL_COND(p_initial == nullptr);
-
-	// No negative durations
-	ERR_FAIL_COND(p_duration < 0);
-
-	// Ensure transition and easing types are valid
-	ERR_FAIL_COND(p_trans_type < 0 || p_trans_type >= TRANS_COUNT);
-	ERR_FAIL_COND(p_ease_type < 0 || p_ease_type >= EASE_COUNT);
-
-	// No negative delays
-	ERR_FAIL_COND(p_delay < 0);
-
-	// Make sure both objects have the given method
-	ERR_FAIL_COND_MSG(!p_object->has_method(p_method), "Object has no method named: " + p_method + ".");
-	ERR_FAIL_COND_MSG(!p_initial->has_method(p_initial_method), "Initial Object has no method named: " + p_initial_method + ".");
-
-	// Call the method to get the initial value
-	Callable::CallError error;
-	Variant initial_val = p_initial->call(p_initial_method, nullptr, 0, error);
-	ERR_FAIL_COND(error.error != Callable::CallError::CALL_OK);
-
-	// Convert initial INT values to FLOAT as they aer better for interpolation
-	if (initial_val.get_type() == Variant::INT) {
-		initial_val = initial_val.operator real_t();
+void MethodTweener::set_tween(Ref<Tween> p_tween) {
+	tween = p_tween;
+	if (trans_type == Tween::TRANS_MAX) {
+		trans_type = tween->get_trans();
 	}
-	ERR_FAIL_COND(initial_val.get_type() != p_final_val.get_type());
-
-	// Build the new InterpolateData object
-	InterpolateData data;
-	data.active = true;
-	data.type = TARGETING_METHOD;
-	data.finish = false;
-	data.elapsed = 0;
-
-	// Configure the data
-	data.id = p_object->get_instance_id();
-	data.key.push_back(p_method);
-	data.concatenated_key = p_method;
-	data.target_id = p_initial->get_instance_id();
-	data.target_key.push_back(p_initial_method);
-	data.initial_val = initial_val;
-	data.final_val = p_final_val;
-	data.duration = p_duration;
-	data.trans_type = p_trans_type;
-	data.ease_type = p_ease_type;
-	data.delay = p_delay;
-
-	// Ensure there is a valid delta
-	if (!_calc_delta_val(data.initial_val, data.final_val, data.delta_val)) {
-		return;
+	if (ease_type == Tween::EASE_MAX) {
+		ease_type = tween->get_ease();
 	}
+}
 
-	// Add the interpolation
-	_push_interpolate_data(data);
+void MethodTweener::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_delay", "delay"), &MethodTweener::set_delay);
+	ClassDB::bind_method(D_METHOD("set_trans", "trans"), &MethodTweener::set_trans);
+	ClassDB::bind_method(D_METHOD("set_ease", "ease"), &MethodTweener::set_ease);
 }
 
-Tween::Tween() {
+MethodTweener::MethodTweener(Callable p_callback, float p_from, float p_to, float p_duration) {
+	callback = p_callback;
+	initial_val = p_from;
+	delta_val = tween->calculate_delta_value(p_from, p_to);
+	duration = p_duration;
 }
 
-Tween::~Tween() {
+MethodTweener::MethodTweener() {
+	ERR_FAIL_MSG("Can't create empty MethodTweener. Use get_tree().tween_method() instead.");
 }
diff --git a/scene/animation/tween.h b/scene/animation/tween.h
index 142c0c65e0..947cdb7c2d 100644
--- a/scene/animation/tween.h
+++ b/scene/animation/tween.h
@@ -31,10 +31,33 @@
 #ifndef TWEEN_H
 #define TWEEN_H
 
-#include "scene/main/node.h"
+#include "core/object/ref_counted.h"
 
-class Tween : public Node {
-	GDCLASS(Tween, Node);
+class Tween;
+class Node;
+
+class Tweener : public RefCounted {
+	GDCLASS(Tweener, RefCounted);
+
+public:
+	virtual void set_tween(Ref<Tween> p_tween);
+	virtual void start() = 0;
+	virtual bool step(float &r_delta) = 0;
+
+protected:
+	static void _bind_methods();
+	Ref<Tween> tween;
+	float elapsed_time = 0;
+	bool finished = false;
+};
+
+class PropertyTweener;
+class IntervalTweener;
+class CallbackTweener;
+class MethodTweener;
+
+class Tween : public RefCounted {
+	GDCLASS(Tween, RefCounted);
 
 public:
 	enum TweenProcessMode {
@@ -42,6 +65,12 @@ public:
 		TWEEN_PROCESS_IDLE,
 	};
 
+	enum TweenPauseMode {
+		TWEEN_PAUSE_BOUND,
+		TWEEN_PAUSE_STOP,
+		TWEEN_PAUSE_PROCESS,
+	};
+
 	enum TransitionType {
 		TRANS_LINEAR,
 		TRANS_SINE,
@@ -54,8 +83,7 @@ public:
 		TRANS_CIRC,
 		TRANS_BOUNCE,
 		TRANS_BACK,
-
-		TRANS_COUNT,
+		TRANS_MAX
 	};
 
 	enum EaseType {
@@ -63,130 +91,187 @@ public:
 		EASE_OUT,
 		EASE_IN_OUT,
 		EASE_OUT_IN,
-
-		EASE_COUNT,
+		EASE_MAX
 	};
 
 private:
-	enum InterpolateType {
-		INTER_PROPERTY,
-		INTER_METHOD,
-		FOLLOW_PROPERTY,
-		FOLLOW_METHOD,
-		TARGETING_PROPERTY,
-		TARGETING_METHOD,
-		INTER_CALLBACK,
-	};
+	TweenProcessMode process_mode = TweenProcessMode::TWEEN_PROCESS_IDLE;
+	TweenPauseMode pause_mode = TweenPauseMode::TWEEN_PAUSE_STOP;
+	TransitionType default_transition = TransitionType::TRANS_LINEAR;
+	EaseType default_ease = EaseType::EASE_IN_OUT;
+	ObjectID bound_node;
 
-	struct InterpolateData {
-		bool active = false;
-		InterpolateType type = INTER_CALLBACK;
-		bool finish = false;
-		bool call_deferred = false;
-		real_t elapsed = 0.0;
-		ObjectID id;
-		Vector<StringName> key;
-		StringName concatenated_key;
-		Variant initial_val;
-		Variant delta_val;
-		Variant final_val;
-		ObjectID target_id;
-		Vector<StringName> target_key;
-		real_t duration = 0.0;
-		TransitionType trans_type = TransitionType::TRANS_BACK;
-		EaseType ease_type = EaseType::EASE_COUNT;
-		real_t delay = 0.0;
-		int args = 0;
-		Variant arg[5];
-		int uid = 0;
-	};
+	Vector<List<Ref<Tweener>>> tweeners;
+	int current_step = -1;
+	int loops = 1;
+	int loops_done = 0;
+	float speed_scale = 1;
 
-	String autoplay;
-	TweenProcessMode tween_process_mode = TWEEN_PROCESS_IDLE;
-	bool repeat = false;
-	float speed_scale = 1.0;
-	mutable int pending_update = 0;
-	int uid = 0;
-	bool was_stopped = false;
+	bool is_bound = false;
+	bool started = false;
+	bool running = true;
+	bool dead = false;
+	bool invalid = true;
+	bool default_parallel = false;
+	bool parallel_enabled = false;
 
-	List<InterpolateData> interpolates;
+	typedef real_t (*interpolater)(real_t t, real_t b, real_t c, real_t d);
+	static interpolater interpolaters[TRANS_MAX][EASE_MAX];
 
-	struct PendingCommand {
-		StringName key;
-		int args = 0;
-		Variant arg[10];
-	};
-	List<PendingCommand> pending_commands;
+	void start_tweeners();
 
-	void _add_pending_command(StringName p_key, const Variant &p_arg1 = Variant(), const Variant &p_arg2 = Variant(), const Variant &p_arg3 = Variant(), const Variant &p_arg4 = Variant(), const Variant &p_arg5 = Variant(), const Variant &p_arg6 = Variant(), const Variant &p_arg7 = Variant(), const Variant &p_arg8 = Variant(), const Variant &p_arg9 = Variant(), const Variant &p_arg10 = Variant());
-	void _process_pending_commands();
+protected:
+	static void _bind_methods();
 
-	typedef real_t (*interpolater)(real_t t, real_t b, real_t c, real_t d);
-	static interpolater interpolaters[TRANS_COUNT][EASE_COUNT];
+public:
+	Ref<PropertyTweener> tween_property(Object *p_target, NodePath p_property, Variant p_to, float p_duration);
+	Ref<IntervalTweener> tween_interval(float p_time);
+	Ref<CallbackTweener> tween_callback(Callable p_callback);
+	Ref<MethodTweener> tween_method(Callable p_callback, float p_from, float p_to, float p_duration);
+	Ref<Tween> append(Ref<Tweener> p_tweener);
 
-	real_t _run_equation(TransitionType p_trans_type, EaseType p_ease_type, real_t t, real_t b, real_t c, real_t d);
-	Variant &_get_delta_val(InterpolateData &p_data);
-	Variant _get_initial_val(const InterpolateData &p_data) const;
-	Variant _get_final_val(const InterpolateData &p_data) const;
-	Variant _run_equation(InterpolateData &p_data);
-	bool _calc_delta_val(const Variant &p_initial_val, const Variant &p_final_val, Variant &p_delta_val);
-	bool _apply_tween_value(InterpolateData &p_data, Variant &value);
+	bool custom_step(float p_delta);
+	void stop();
+	void pause();
+	void play();
+	void kill();
 
-	void _tween_process(float p_delta);
-	void _remove_by_uid(int uid);
-	void _push_interpolate_data(InterpolateData &p_data);
-	void _build_interpolation(InterpolateType p_interpolation_type, Object *p_object, NodePath *p_property, StringName *p_method, Variant p_initial_val, Variant p_final_val, real_t p_duration, TransitionType p_trans_type, EaseType p_ease_type, real_t p_delay);
+	bool is_running();
+	void set_valid(bool p_valid);
+	bool is_valid();
 
-protected:
-	bool _set(const StringName &p_name, const Variant &p_value);
-	bool _get(const StringName &p_name, Variant &r_ret) const;
-	void _get_property_list(List<PropertyInfo> *p_list) const;
-	void _notification(int p_what);
+	Ref<Tween> bind_node(Node *p_node);
+	Ref<Tween> set_process_mode(TweenProcessMode p_mode);
+	TweenProcessMode get_process_mode();
+	Ref<Tween> set_pause_mode(TweenPauseMode p_mode);
+	TweenPauseMode get_pause_mode();
 
-	static void _bind_methods();
+	Ref<Tween> set_parallel(bool p_parallel);
+	Ref<Tween> set_loops(int p_loops);
+	Ref<Tween> set_speed_scale(float p_speed);
+	Ref<Tween> set_trans(TransitionType p_trans);
+	TransitionType get_trans();
+	Ref<Tween> set_ease(EaseType p_ease);
+	EaseType get_ease();
 
-public:
-	bool is_active() const;
-	void set_active(bool p_active);
-
-	bool is_repeat() const;
-	void set_repeat(bool p_repeat);
-
-	void set_tween_process_mode(TweenProcessMode p_mode);
-	TweenProcessMode get_tween_process_mode() const;
-
-	void set_speed_scale(float p_speed);
-	float get_speed_scale() const;
-
-	void start();
-	void reset(Object *p_object, StringName p_key);
-	void reset_all();
-	void stop(Object *p_object, StringName p_key);
-	void stop_all();
-	void resume(Object *p_object, StringName p_key);
-	void resume_all();
-	void remove(Object *p_object, StringName p_key);
-	void remove_all();
-
-	void seek(real_t p_time);
-	real_t tell() const;
-	real_t get_runtime() const;
-
-	void interpolate_property(Object *p_object, NodePath p_property, Variant p_initial_val, Variant p_final_val, real_t p_duration, TransitionType p_trans_type = TRANS_LINEAR, EaseType p_ease_type = EASE_IN_OUT, real_t p_delay = 0);
-	void interpolate_method(Object *p_object, StringName p_method, Variant p_initial_val, Variant p_final_val, real_t p_duration, TransitionType p_trans_type = TRANS_LINEAR, EaseType p_ease_type = EASE_IN_OUT, real_t p_delay = 0);
-	void interpolate_callback(Object *p_object, real_t p_duration, String p_callback, VARIANT_ARG_DECLARE);
-	void interpolate_deferred_callback(Object *p_object, real_t p_duration, String p_callback, VARIANT_ARG_DECLARE);
-	void follow_property(Object *p_object, NodePath p_property, Variant p_initial_val, Object *p_target, NodePath p_target_property, real_t p_duration, TransitionType p_trans_type = TRANS_LINEAR, EaseType p_ease_type = EASE_IN_OUT, real_t p_delay = 0);
-	void follow_method(Object *p_object, StringName p_method, Variant p_initial_val, Object *p_target, StringName p_target_method, real_t p_duration, TransitionType p_trans_type = TRANS_LINEAR, EaseType p_ease_type = EASE_IN_OUT, real_t p_delay = 0);
-	void targeting_property(Object *p_object, NodePath p_property, Object *p_initial, NodePath p_initial_property, Variant p_final_val, real_t p_duration, TransitionType p_trans_type = TRANS_LINEAR, EaseType p_ease_type = EASE_IN_OUT, real_t p_delay = 0);
-	void targeting_method(Object *p_object, StringName p_method, Object *p_initial, StringName p_initial_method, Variant p_final_val, real_t p_duration, TransitionType p_trans_type = TRANS_LINEAR, EaseType p_ease_type = EASE_IN_OUT, real_t p_delay = 0);
-
-	Tween();
-	~Tween();
+	Ref<Tween> parallel();
+	Ref<Tween> chain();
+
+	real_t run_equation(TransitionType p_trans_type, EaseType p_ease_type, real_t t, real_t b, real_t c, real_t d);
+	Variant interpolate_variant(Variant p_initial_val, Variant p_delta_val, float p_time, float p_duration, Tween::TransitionType p_trans, Tween::EaseType p_ease);
+	Variant calculate_delta_value(Variant p_intial_val, Variant p_final_val);
+
+	bool step(float p_delta);
+	bool should_pause();
+
+	Tween() {}
 };
 
+VARIANT_ENUM_CAST(Tween::TweenPauseMode);
 VARIANT_ENUM_CAST(Tween::TweenProcessMode);
 VARIANT_ENUM_CAST(Tween::TransitionType);
 VARIANT_ENUM_CAST(Tween::EaseType);
 
+class PropertyTweener : public Tweener {
+	GDCLASS(PropertyTweener, Tweener);
+
+public:
+	Ref<PropertyTweener> from(Variant p_value);
+	Ref<PropertyTweener> from_current();
+	Ref<PropertyTweener> as_relative();
+	Ref<PropertyTweener> set_trans(Tween::TransitionType p_trans);
+	Ref<PropertyTweener> set_ease(Tween::EaseType p_ease);
+	Ref<PropertyTweener> set_delay(float p_delay);
+
+	void set_tween(Ref<Tween> p_tween) override;
+	void start() override;
+	bool step(float &r_delta) override;
+
+	PropertyTweener(Object *p_target, NodePath p_property, Variant p_to, float p_duration);
+	PropertyTweener();
+
+protected:
+	static void _bind_methods();
+
+private:
+	ObjectID target;
+	Vector<StringName> property;
+	Variant initial_val;
+	Variant base_final_val;
+	Variant final_val;
+	Variant delta_val;
+
+	float duration = 0;
+	Tween::TransitionType trans_type = Tween::TRANS_MAX; // This is set inside set_tween();
+	Tween::EaseType ease_type = Tween::EASE_MAX;
+
+	float delay = 0;
+	bool do_continue = true;
+	bool relative = false;
+};
+
+class IntervalTweener : public Tweener {
+	GDCLASS(IntervalTweener, Tweener);
+
+public:
+	void start() override;
+	bool step(float &r_delta) override;
+
+	IntervalTweener(float p_time);
+	IntervalTweener();
+
+private:
+	float duration = 0;
+};
+
+class CallbackTweener : public Tweener {
+	GDCLASS(CallbackTweener, Tweener);
+
+public:
+	Ref<CallbackTweener> set_delay(float p_delay);
+
+	void start() override;
+	bool step(float &r_delta) override;
+
+	CallbackTweener(Callable p_callback);
+	CallbackTweener();
+
+protected:
+	static void _bind_methods();
+
+private:
+	Callable callback;
+	float delay = 0;
+};
+
+class MethodTweener : public Tweener {
+	GDCLASS(MethodTweener, Tweener);
+
+public:
+	Ref<MethodTweener> set_trans(Tween::TransitionType p_trans);
+	Ref<MethodTweener> set_ease(Tween::EaseType p_ease);
+	Ref<MethodTweener> set_delay(float p_delay);
+
+	void set_tween(Ref<Tween> p_tween) override;
+	void start() override;
+	bool step(float &r_delta) override;
+
+	MethodTweener(Callable p_callback, float p_from, float p_to, float p_duration);
+	MethodTweener();
+
+protected:
+	static void _bind_methods();
+
+private:
+	float duration = 0;
+	float delay = 0;
+	Tween::TransitionType trans_type = Tween::TRANS_MAX;
+	Tween::EaseType ease_type = Tween::EASE_MAX;
+
+	Ref<Tween> tween;
+	Variant initial_val;
+	Variant delta_val;
+	Callable callback;
+};
+
 #endif
diff --git a/scene/main/node.cpp b/scene/main/node.cpp
index c39b8005e4..076394dfa8 100644
--- a/scene/main/node.cpp
+++ b/scene/main/node.cpp
@@ -35,6 +35,7 @@
 #include "core/object/message_queue.h"
 #include "core/string/print_string.h"
 #include "instance_placeholder.h"
+#include "scene/animation/tween.h"
 #include "scene/debugger/scene_debugger.h"
 #include "scene/resources/packed_scene.h"
 #include "scene/scene_string_names.h"
@@ -1683,6 +1684,13 @@ int Node::get_index() const {
 	return data.pos;
 }
 
+Ref<Tween> Node::create_tween() {
+	ERR_FAIL_COND_V_MSG(!data.tree, nullptr, "Can't create Tween when not inside scene tree.");
+	Ref<Tween> tween = get_tree()->create_tween();
+	tween->bind_node(this);
+	return tween;
+}
+
 void Node::remove_and_skip() {
 	ERR_FAIL_COND(!data.parent);
 
@@ -2552,6 +2560,7 @@ void Node::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("is_physics_processing_internal"), &Node::is_physics_processing_internal);
 
 	ClassDB::bind_method(D_METHOD("get_tree"), &Node::get_tree);
+	ClassDB::bind_method(D_METHOD("create_tween"), &Node::create_tween);
 
 	ClassDB::bind_method(D_METHOD("duplicate", "flags"), &Node::duplicate, DEFVAL(DUPLICATE_USE_INSTANCING | DUPLICATE_SIGNALS | DUPLICATE_GROUPS | DUPLICATE_SCRIPTS));
 	ClassDB::bind_method(D_METHOD("replace_by", "node", "keep_groups"), &Node::replace_by, DEFVAL(false));
diff --git a/scene/main/node.h b/scene/main/node.h
index e7b36f351b..0d1685a2be 100644
--- a/scene/main/node.h
+++ b/scene/main/node.h
@@ -41,6 +41,9 @@
 
 class Viewport;
 class SceneState;
+class Tween;
+class PropertyTweener;
+
 class Node : public Object {
 	GDCLASS(Node, Object);
 	OBJ_CATEGORY("Nodes");
@@ -308,6 +311,8 @@ public:
 	void remove_and_skip();
 	int get_index() const;
 
+	Ref<Tween> create_tween();
+
 	void print_tree();
 	void print_tree_pretty();
 
diff --git a/scene/main/scene_tree.cpp b/scene/main/scene_tree.cpp
index e4ba93feec..2d0d6921d3 100644
--- a/scene/main/scene_tree.cpp
+++ b/scene/main/scene_tree.cpp
@@ -41,6 +41,7 @@
 #include "core/os/os.h"
 #include "core/string/print_string.h"
 #include "node.h"
+#include "scene/animation/tween.h"
 #include "scene/debugger/scene_debugger.h"
 #include "scene/resources/font.h"
 #include "scene/resources/material.h"
@@ -412,6 +413,9 @@ bool SceneTree::physics_process(float p_time) {
 	_notify_group_pause("physics_process", Node::NOTIFICATION_PHYSICS_PROCESS);
 	_flush_ugc();
 	MessageQueue::get_singleton()->flush(); //small little hack
+
+	process_tweens(p_time, true);
+
 	flush_transform_notifications();
 	call_group_flags(GROUP_CALL_REALTIME, "_viewports", "update_worlds");
 	root_lock--;
@@ -478,6 +482,8 @@ bool SceneTree::process(float p_time) {
 		E = N;
 	}
 
+	process_tweens(p_time, false);
+
 	flush_transform_notifications(); //additional transforms after timers update
 
 	_call_idle_callbacks();
@@ -512,6 +518,32 @@ bool SceneTree::process(float p_time) {
 	return _quit;
 }
 
+void SceneTree::process_tweens(float p_delta, bool p_physics) {
+	// This methods works similarly to how SceneTreeTimers are handled.
+	List<Ref<Tween>>::Element *L = tweens.back();
+
+	for (List<Ref<Tween>>::Element *E = tweens.front(); E;) {
+		List<Ref<Tween>>::Element *N = E->next();
+		// Don't process if paused or process mode doesn't match.
+		if ((paused && E->get()->should_pause()) || (p_physics == (E->get()->get_process_mode() == Tween::TWEEN_PROCESS_IDLE))) {
+			if (E == L) {
+				break;
+			}
+			E = N;
+			continue;
+		}
+
+		if (!E->get()->step(p_delta)) {
+			E->get()->set_valid(false);
+			tweens.erase(E);
+		}
+		if (E == L) {
+			break;
+		}
+		E = N;
+	}
+}
+
 void SceneTree::finalize() {
 	_flush_delete_queue();
 
@@ -1091,6 +1123,27 @@ Ref<SceneTreeTimer> SceneTree::create_timer(float p_delay_sec, bool p_process_al
 	return stt;
 }
 
+Ref<Tween> SceneTree::create_tween() {
+	Ref<Tween> tween;
+	tween.instance();
+	tween->set_valid(true);
+	tweens.push_back(tween);
+	return tween;
+}
+
+Array SceneTree::get_processed_tweens() {
+	Array ret;
+	ret.resize(tweens.size());
+
+	int i = 0;
+	for (List<Ref<Tween>>::Element *E = tweens.front(); E; E = E->next()) {
+		ret[i] = E->get();
+		i++;
+	}
+
+	return ret;
+}
+
 void SceneTree::_network_peer_connected(int p_id) {
 	emit_signal("network_peer_connected", p_id);
 }
@@ -1199,6 +1252,8 @@ void SceneTree::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("is_paused"), &SceneTree::is_paused);
 
 	ClassDB::bind_method(D_METHOD("create_timer", "time_sec", "process_always"), &SceneTree::create_timer, DEFVAL(true));
+	ClassDB::bind_method(D_METHOD("create_tween"), &SceneTree::create_tween);
+	ClassDB::bind_method(D_METHOD("get_processed_tweens"), &SceneTree::get_processed_tweens);
 
 	ClassDB::bind_method(D_METHOD("get_node_count"), &SceneTree::get_node_count);
 	ClassDB::bind_method(D_METHOD("get_frame"), &SceneTree::get_frame);
diff --git a/scene/main/scene_tree.h b/scene/main/scene_tree.h
index 78c4c14e97..0e9ffb0f5f 100644
--- a/scene/main/scene_tree.h
+++ b/scene/main/scene_tree.h
@@ -47,6 +47,7 @@ class Window;
 class Material;
 class Mesh;
 class SceneDebugger;
+class Tween;
 
 class SceneTreeTimer : public RefCounted {
 	GDCLASS(SceneTreeTimer, RefCounted);
@@ -151,6 +152,7 @@ private:
 	//void _call_group(uint32_t p_call_flags,const StringName& p_group,const StringName& p_function,const Variant& p_arg1,const Variant& p_arg2);
 
 	List<Ref<SceneTreeTimer>> timers;
+	List<Ref<Tween>> tweens;
 
 	///network///
 
@@ -171,6 +173,7 @@ private:
 	void node_added(Node *p_node);
 	void node_removed(Node *p_node);
 	void node_renamed(Node *p_node);
+	void process_tweens(float p_delta, bool p_physics_frame);
 
 	Group *add_to_group(const StringName &p_group, Node *p_node);
 	void remove_from_group(const StringName &p_group, Node *p_node);
@@ -318,6 +321,8 @@ public:
 	Error reload_current_scene();
 
 	Ref<SceneTreeTimer> create_timer(float p_delay_sec, bool p_process_always = true);
+	Ref<Tween> create_tween();
+	Array get_processed_tweens();
 
 	//used by Main::start, don't use otherwise
 	void add_current_scene(Node *p_current);
diff --git a/scene/register_scene_types.cpp b/scene/register_scene_types.cpp
index 332976a18d..68338cde53 100644
--- a/scene/register_scene_types.cpp
+++ b/scene/register_scene_types.cpp
@@ -407,6 +407,11 @@ void register_scene_types() {
 
 	ClassDB::register_class<AnimationPlayer>();
 	ClassDB::register_class<Tween>();
+	ClassDB::register_virtual_class<Tweener>();
+	ClassDB::register_class<PropertyTweener>();
+	ClassDB::register_class<IntervalTweener>();
+	ClassDB::register_class<CallbackTweener>();
+	ClassDB::register_class<MethodTweener>();
 
 	ClassDB::register_class<AnimationTree>();
 	ClassDB::register_class<AnimationNode>();
diff --git a/thirdparty/misc/easing_equations.cpp b/thirdparty/misc/easing_equations.cpp
index af48aaf079..ce32c1a362 100644
--- a/thirdparty/misc/easing_equations.cpp
+++ b/thirdparty/misc/easing_equations.cpp
@@ -297,7 +297,7 @@ static real_t out_in(real_t t, real_t b, real_t c, real_t d) {
 }
 }; // namespace back
 
-Tween::interpolater Tween::interpolaters[Tween::TRANS_COUNT][Tween::EASE_COUNT] = {
+Tween::interpolater Tween::interpolaters[Tween::TRANS_MAX][Tween::EASE_MAX] = {
 	{ &linear::in, &linear::out, &linear::in_out, &linear::out_in },
 	{ &sine::in, &sine::out, &sine::in_out, &sine::out_in },
 	{ &quint::in, &quint::out, &quint::in_out, &quint::out_in },
@@ -311,7 +311,7 @@ Tween::interpolater Tween::interpolaters[Tween::TRANS_COUNT][Tween::EASE_COUNT]
 	{ &back::in, &back::out, &back::in_out, &back::out_in },
 };
 
-real_t Tween::_run_equation(TransitionType p_trans_type, EaseType p_ease_type, real_t t, real_t b, real_t c, real_t d) {
+real_t Tween::run_equation(TransitionType p_trans_type, EaseType p_ease_type, real_t t, real_t b, real_t c, real_t d) {
 
 	interpolater cb = interpolaters[p_trans_type][p_ease_type];
 	ERR_FAIL_COND_V(cb == NULL, b);