diff --git a/SharpEngine.Core/Utils/Tween/TweenData.cs b/SharpEngine.Core/Utils/Tween/TweenData.cs
index 5953f1a..c2a4bfa 100644
--- a/SharpEngine.Core/Utils/Tween/TweenData.cs
+++ b/SharpEngine.Core/Utils/Tween/TweenData.cs
@@ -1,84 +1,65 @@
-using SharpEngine.Core.Manager;
 using System;
-using System.Linq.Expressions;
-using System.Reflection;
 using JetBrains.Annotations;
 
 namespace SharpEngine.Core.Utils.Tween
 {
-    internal class TweenData<TD, TDStep>(
-        object obj,
-        Expression<Func<object, TD>> property,
-        TD from,
-        TD to,
-        float duration,
-        bool useFrom = true)
-        where TD : notnull
-    {
-        [UsedImplicitly]
-        public object Obj { get; set; } = obj;
+	public abstract class ITweenData
+	{
+		public abstract void Launch();
+		public abstract void Update(float t);
+	}
 
-        [UsedImplicitly]
-        public Expression<Func<object, TD>> Property { get; set; } = property;
+	public abstract class TweenData<T> : ITweenData
+	{
+		[UsedImplicitly]
+		public Func<T> Getter { get; set; } = default!;
 
-        [UsedImplicitly]
-        public TD From { get; set; } = from;
+		[UsedImplicitly]
+		public Action<T> Setter { get; set; } = default!;
 
-        [UsedImplicitly]
-        public TD To { get; set; } = to;
+		[UsedImplicitly]
+		public T From { get; set; } = default!;
 
-        [UsedImplicitly]
-        public float Duration { get; set; } = duration;
+		[UsedImplicitly]
+		public T To { get; set; } = default!;
 
-        [UsedImplicitly]
-        public TD CurrentValue { get; set; } = default!;
-        [UsedImplicitly]
-        public TDStep Step { get; set; } = default!;
-        [UsedImplicitly]
-        public bool UseFrom { get; set; } = useFrom;
+		internal bool UseCurrentValue { get; set; }
 
-        public void Launch() 
-        { 
-            CurrentValue = UseFrom ? From : Property.Compile()(Obj);
-            Step = CurrentValue switch
-            {
-                float fFrom when To is float fTo => (TDStep)(object)((fTo - fFrom) / Duration),
-                int iFrom when To is int iTo => (TDStep)(object)((iTo - iFrom) / Duration),
-                Color cFrom when To is Color cTo => (TDStep)(object)new ColorStep(
-                    (short)((cTo.R - cFrom.R) / Duration),
-                    (short)((cTo.G - cFrom.G) / Duration),
-                    (short)((cTo.B - cFrom.B) / Duration),
-                    (short)((cTo.A - cFrom.A) / Duration)
-                ),
-                _ => throw new NotSupportedException("Unsupported type for tweening.")
-            };
+		public sealed override void Launch()
+		{
+			if (UseCurrentValue)
+				From = Getter();
+		}
+	}
 
-            DebugManager.Log(LogLevel.Debug, $"Tween Launched: From = {From}, To = {To}, Duration = {Duration}, Step = {Step}");
-        }
+	internal sealed class IntTweenData : TweenData<int>
+	{
+		public override void Update(float t)
+		{
+			Setter(t >= 1f ? To : (int)(From + ((double)To - From) * t));
+		}
+	}
 
-        public void Update(float deltaTime)
-        {
-            if (Duration <= 0)
-            {
-                ((PropertyInfo)((MemberExpression)Property.Body).Member).SetValue(Obj, To);
-                return;
-            }
+	internal sealed class FloatTweenData : TweenData<float>
+	{
+		public override void Update(float t)
+		{
+			Setter(t >= 1f ? To : From + (To - From) * t);
+		}
+	}
 
-            CurrentValue = CurrentValue switch
-            {
-                float cVal when Step is float step => (TD)(object)(cVal + step * deltaTime),
-                int cVal when Step is int step => (TD)(object)(cVal + (int)(step * deltaTime)),
-                Color cVal when Step is ColorStep step => (TD)(object)new Color(
-                    (byte)(cVal.R + step.RStep * deltaTime),
-                    (byte)(cVal.G + step.GStep * deltaTime),
-                    (byte)(cVal.B + step.BStep * deltaTime),
-                    (byte)(cVal.A + step.AStep * deltaTime)
-                ),
-                _ => CurrentValue
-            };
-
-            ((PropertyInfo)((MemberExpression)Property.Body).Member).SetValue(Obj, CurrentValue);
-            Duration -= deltaTime;
-        }
-    }
+	internal sealed class ColorTweenData : TweenData<Color>
+	{
+		public override void Update(float t)
+		{
+			Setter(
+				new Color(
+					(int)(From.R + (To.R - From.R) * t),
+					(int)(From.G + (To.G - From.G) * t),
+					(int)(From.B + (To.B - From.B) * t),
+					(int)(From.A + (To.A - From.A) * t)
+				)
+			);
+		}
+	}
 }
diff --git a/SharpEngine.Core/Utils/Tween/TweenStep.cs b/SharpEngine.Core/Utils/Tween/TweenStep.cs
index 2d5d581..8836187 100644
--- a/SharpEngine.Core/Utils/Tween/TweenStep.cs
+++ b/SharpEngine.Core/Utils/Tween/TweenStep.cs
@@ -1,6 +1,7 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq.Expressions;
+using System.Reflection;
 using JetBrains.Annotations;
 
 namespace SharpEngine.Core.Utils.Tween;
@@ -13,97 +14,316 @@ namespace SharpEngine.Core.Utils.Tween;
 /// animated properties.</remarks>
 public class TweenStep
 {
-    /// <summary>
-    /// Duration of the step
-    /// </summary>
-    [UsedImplicitly]
-    public float CurrentDuration { get; set; }
-
-    private readonly List<TweenData<float, float>> _floatTweens = [];
-    private readonly List<TweenData<int, int>> _intTweens = [];
-    private readonly List<TweenData<Color, ColorStep>> _colorTweens = [];
-
-    /// <summary>
-    /// Initializes a new instance of the TweenStep class with the specified duration.
-    /// </summary>
-    /// <param name="duration">The duration, in seconds, for this tween step. Must be greater than or equal to zero.</param>
-    public TweenStep(float duration)
-    {
-        CurrentDuration = duration;
-    }
-
-    /// <summary>
-    /// Add a float tween to the step
-    /// </summary>
-    /// <param name="entity">Entity</param>
-    /// <param name="property">Property which be modified</param>
-    /// <param name="to">Target Value</param>
-    /// <param name="duration">Duration of the tween</param>
-    /// <param name="from">Source Value</param>
-    /// <returns>Tween Step</returns>
-    public TweenStep Float(object entity, Expression<Func<object, float>> property, float to, float duration, float? from = null)
-    {
-        _floatTweens.Add(new TweenData<float, float>(entity, property, from ?? 0, to, duration, from is not null));
-        return this;
-    }
-
-    /// <summary>
-    /// Add an int tween to the step
-    /// </summary>
-    /// <param name="entity">Entity</param>
-    /// <param name="property">Property which be modified</param>
-    /// <param name="to">Target Value</param>
-    /// <param name="duration">Duration of the tween</param>
-    /// <param name="from">Source Value</param>
-    /// <returns>Tween Steps</returns>
-    [UsedImplicitly]
-    public TweenStep Int(object entity, Expression<Func<object, int>> property, int to, float duration, int? from = null)
-    {
-        _intTweens.Add(new TweenData<int, int>(entity, property, from ?? 0, to, duration, from is not null));
-        return this;
-    }
-
-    /// <summary>
-    /// Animates a color property of the specified entity from a starting value to a target value over the given
-    /// duration.
-    /// </summary>
-    /// <param name="entity">The entity whose color property will be animated.</param>
-    /// <param name="property">An expression that selects the color property of the entity to animate.</param>
-    /// <param name="to">The target color value to animate to.</param>
-    /// <param name="duration">The duration, in seconds, over which the animation occurs. Must be greater than zero.</param>
-    /// <param name="from">The initial color value to animate from. If null, the current value of the property is used.</param>
-    /// <returns>The current <see cref="TweenStep"/> instance, allowing for method chaining.</returns>
-    [UsedImplicitly]
-    public TweenStep Color(object entity, Expression<Func<object, Color>> property, Color to, float duration, Color? from = null)
-    {
-        _colorTweens.Add(new TweenData<Color, ColorStep>(entity, property, from ?? Utils.Color.White, to, duration, from is not null));
-        return this;
-    }
-
-    /// <summary>
-    /// Update the tween step
-    /// </summary>
-    /// <param name="deltaTime">Delta time</param>
-    /// <returns>If a step ended</returns>
-    public bool Update(float deltaTime)
-    {
-        CurrentDuration -= deltaTime;
-        foreach (var floatTween in _floatTweens)
-            floatTween.Update(deltaTime);
-        foreach (var intTween in _intTweens)
-            intTween.Update(deltaTime);
-        foreach (var colorTween in _colorTweens)
-            colorTween.Update(deltaTime);
-        return CurrentDuration <= 0f;
-    }
-
-    internal void Launch()
-    {
-        foreach (var floatTween in _floatTweens)
-            floatTween.Launch();
-        foreach (var intTween in _intTweens)
-            intTween.Launch();
-        foreach (var colorTween in _colorTweens)
-            colorTween.Launch();
-    }
+	/// <summary>
+	/// Duration of the step
+	/// </summary>
+	[UsedImplicitly]
+	public float Duration { get; set; }
+
+	/// <summary>
+	/// Elapsed time of the step
+	/// </summary>
+	[UsedImplicitly]
+	public float Elapsed { get; set; }
+
+	private readonly List<(ITweenData Data, float Duration)> _tweens = [];
+
+	/// <summary>
+	/// Initializes a new instance of the TweenStep class with the specified duration.
+	/// </summary>
+	/// <param name="duration">The duration, in seconds, for this tween step. Must be greater than or equal to zero.</param>
+	public TweenStep(float duration)
+	{
+		Duration = duration;
+		Elapsed = 0;
+	}
+
+	/// <summary>
+	/// Add a float tween to the step
+	/// </summary>
+	/// <param name="entity">Entity</param>
+	/// <param name="property">Property which be modified</param>
+	/// <param name="to">Target Value</param>
+	/// <param name="duration">Duration of the tween</param>
+	/// <param name="from">Source Value</param>
+	/// <returns>Tween Step</returns>
+	public TweenStep Float<T>(
+		T entity,
+		Expression<Func<T, float>> property,
+		float to,
+		float duration,
+		float? from = null
+	)
+		where T : class
+	{
+		return from.HasValue
+			? Custom<T, FloatTweenData, float>(entity, property, from.Value, to, duration)
+			: Custom<T, FloatTweenData, float>(entity, property, to, duration);
+	}
+
+	/// <summary>
+	/// Add an int tween to the step
+	/// </summary>
+	/// <param name="entity">Entity</param>
+	/// <param name="property">Property which be modified</param>
+	/// <param name="to">Target Value</param>
+	/// <param name="duration">Duration of the tween</param>
+	///
+	/// <param name="from">Source Value</param>
+	/// <returns>Tween Steps</returns>
+	[UsedImplicitly]
+	public TweenStep Int<T>(
+		T entity,
+		Expression<Func<T, int>> property,
+		int to,
+		float duration,
+		int? from = null
+	)
+		where T : class
+	{
+		return from.HasValue
+			? Custom<T, IntTweenData, int>(entity, property, from.Value, to, duration)
+			: Custom<T, IntTweenData, int>(entity, property, to, duration);
+	}
+
+	/// <summary>
+	/// Animates a color property of the specified entity from a starting value to a target value over the given
+	/// duration.
+	/// </summary>
+	/// <param name="entity">The entity whose color property will be animated.</param>
+	/// <param name="property">An expression that selects the color property of the entity to animate.</param>
+	/// <param name="to">The target color value to animate to.</param>
+	/// <param name="duration">The duration, in seconds, over which the animation occurs. Must be greater than zero.</param>
+	/// <param name="from">The initial color value to animate from. If null, the current value of the property is used.</param>
+	/// <returns>The current <see cref="TweenStep"/> instance, allowing for method chaining.</returns>
+	[UsedImplicitly]
+	public TweenStep Color<T>(
+		T entity,
+		Expression<Func<T, Color>> property,
+		Color to,
+		float duration,
+		Color? from = null
+	)
+		where T : class
+	{
+		return from.HasValue
+			? Custom<T, ColorTweenData, Color>(entity, property, from.Value, to, duration)
+			: Custom<T, ColorTweenData, Color>(entity, property, to, duration);
+	}
+
+	public TweenStep Custom<TEntity, TData, T>(
+		TEntity entity,
+		Expression<Func<TEntity, T>> property,
+		T to,
+		float duration
+	)
+		where TEntity : class
+		where TData : TweenData<T>, new()
+	{
+		var compiledGetter = property.Compile();
+		var compiledSetter = CompileSetter(property);
+		Func<T> getter = () => compiledGetter(entity);
+		Action<T> setter = value => compiledSetter(entity, value);
+
+		return Custom<TData, T>(getter, setter, default!, to, duration, useCurrentValue: true);
+	}
+
+	public TweenStep Custom<TEntity, TData, T>(
+		TEntity entity,
+		Expression<Func<TEntity, T>> property,
+		T from,
+		T to,
+		float duration
+	)
+		where TEntity : class
+		where TData : TweenData<T>, new()
+	{
+		var compiledGetter = property.Compile();
+		var compiledSetter = CompileSetter(property);
+		Func<T> getter = () => compiledGetter(entity);
+		Action<T> setter = value => compiledSetter(entity, value);
+
+		return Custom<TData, T>(getter, setter, from, to, duration);
+	}
+
+	private TweenStep Custom<TData, T>(
+		Func<T> getter,
+		Action<T> setter,
+		T from,
+		T to,
+		float duration,
+		bool useCurrentValue = false
+	)
+		where TData : TweenData<T>, new()
+	{
+		_tweens.Add(
+			(
+				new TData
+				{
+					Getter = getter,
+					Setter = setter,
+					From = from,
+					To = to,
+					UseCurrentValue = useCurrentValue,
+				},
+				duration
+			)
+		);
+		return this;
+	}
+
+	/// <summary>
+	/// Update the tween step
+	/// </summary>
+	/// <param name="deltaTime">Delta time</param>
+	/// <returns>If a step ended</returns>
+	public bool Update(float deltaTime)
+	{
+		Elapsed += deltaTime;
+		foreach (var tween in _tweens)
+		{
+			float progress =
+				tween.Duration <= 0 ? 1f : System.Math.Clamp(Elapsed / tween.Duration, 0f, 1f);
+			tween.Data.Update(progress);
+		}
+
+		return Elapsed >= Duration;
+	}
+
+	internal void Launch()
+	{
+		Elapsed = 0;
+		foreach (var tween in _tweens)
+			tween.Data.Launch();
+	}
+
+	private static Action<T, TValue> CompileSetter<T, TValue>(
+		Expression<Func<T, TValue>> expression
+	)
+		where T : class
+	{
+		if (expression.Body is not MemberExpression)
+			throw new ArgumentException(
+				"Expression must be a field or property access.",
+				nameof(expression)
+			);
+
+		// Extract:
+		//
+		// x => x.A.B.C.Value
+		//
+		// into:
+		//
+		// A, B, C, Value
+
+		var members = new List<MemberInfo>();
+
+		Expression? current = expression.Body;
+
+		while (current is MemberExpression memberExpression)
+		{
+			members.Add(memberExpression.Member);
+			current = memberExpression.Expression;
+		}
+
+		if (current != expression.Parameters[0])
+			throw new ArgumentException(
+				"Expression must originate from the lambda parameter.",
+				nameof(expression)
+			);
+
+		members.Reverse();
+
+		var objParameter = Expression.Parameter(typeof(T), "obj");
+
+		var valueParameter = Expression.Parameter(typeof(TValue), "value");
+
+		List<ParameterExpression> variables = [];
+		List<Expression> body = [];
+
+		// Structs that will need to be copied back into their parents.
+		var writeBacks =
+			new List<(Expression Parent, MemberInfo Member, ParameterExpression Temp)>();
+
+		Expression owner = objParameter;
+
+		// Walk everything except the final member.
+		for (int i = 0; i < members.Count - 1; i++)
+		{
+			var member = members[i];
+
+			var access = Expression.MakeMemberAccess(owner, member);
+
+			if (access.Type.IsValueType)
+			{
+				/*
+				 * Struct:
+				 *
+				 * obj.Position.X
+				 *
+				 * becomes roughly:
+				 *
+				 * var temp = obj.Position;
+				 */
+
+				var temp = Expression.Variable(access.Type, $"temp{i}");
+
+				variables.Add(temp);
+
+				body.Add(Expression.Assign(temp, access));
+
+				writeBacks.Add((owner, member, temp));
+
+				owner = temp;
+			}
+			else
+			{
+				// Classes don't need copying.
+				owner = access;
+			}
+		}
+
+		// Final property/field.
+		var leafMember = members[^1];
+
+		EnsureWritable(leafMember);
+
+		var leaf = Expression.MakeMemberAccess(owner, leafMember);
+
+		body.Add(Expression.Assign(leaf, valueParameter));
+
+		for (int i = writeBacks.Count - 1; i >= 0; i--)
+		{
+			var writeBack = writeBacks[i];
+
+			EnsureWritable(writeBack.Member);
+
+			var destination = Expression.MakeMemberAccess(writeBack.Parent, writeBack.Member);
+
+			body.Add(Expression.Assign(destination, writeBack.Temp));
+		}
+
+		var block = Expression.Block(variables, body);
+
+		return Expression.Lambda<Action<T, TValue>>(block, objParameter, valueParameter).Compile();
+	}
+
+	private static void EnsureWritable(MemberInfo member)
+	{
+		switch (member)
+		{
+			case PropertyInfo { SetMethod: null } property:
+				throw new ArgumentException($"Property '{property.Name}' is not writable.");
+
+			case FieldInfo { IsInitOnly: true } field:
+				throw new ArgumentException($"Field '{field.Name}' is readonly.");
+
+			case PropertyInfo:
+			case FieldInfo:
+				return;
+
+			default:
+				throw new ArgumentException($"Member '{member.Name}' is not a field or property.");
+		}
+	}
 }
diff --git a/Testing/MyScene.cs b/Testing/MyScene.cs
index ff67ff7..ce1dd39 100644
--- a/Testing/MyScene.cs
+++ b/Testing/MyScene.cs
@@ -46,15 +46,16 @@ public override void OpenScene()
     {
         base.OpenScene();
 
+		TransformComponent transform = Entities[0].GetComponentAs<TransformComponent>()!;
         Window?.TweenManager.Tweens.Add(new Tween([
             new TweenStep(5)
-                .Float(Entities[0].GetComponentAs<TransformComponent>()!, x => ((TransformComponent)x).LocalRotation, 360, 5)
-                .Float(Entities[0].GetComponentAs<TransformComponent>()!.LocalPosition, x => ((Vec2)x).X, 100, 5)
-                .Float(Entities[0].GetComponentAs<TransformComponent>()!.LocalPosition, x => ((Vec2)x).Y, 100, 5),
+                .Float(transform, x => x.LocalRotation, 360, 5)
+                .Float(transform, x => x.LocalPosition.X, 100, 5)
+                .Float(transform, x => x.LocalPosition.Y, 100, 5),
             new TweenStep(10)
-                .Float(Entities[0].GetComponentAs<TransformComponent>()!, x => ((TransformComponent)x).LocalRotation, 720, 5)
-                .Float(Entities[0].GetComponentAs<TransformComponent>()!.LocalPosition, x => ((Vec2)x).X, 0, 5)
-                .Float(Entities[0].GetComponentAs<TransformComponent>()!.LocalPosition, x => ((Vec2)x).Y, 0, 5),
+                .Float(transform, x => x.LocalRotation, 720, 5)
+                .Float(transform, x => x.LocalPosition.X, 0, 5)
+                .Float(transform, x => x.LocalPosition.Y, 0, 5),
         ], () => DebugManager.Log(LogLevel.Info, "FIN DU TWEEN")));
     }
-}
+}
\ No newline at end of file