PrimeTween vs DOTween Performance Comparison

[KyryloKuzyk]

PrimeTween vs DOTween Performance Comparison

All benchmarks in this article are performed with the official Performance testing API and can be easily replicated by cloning the Benchmarks repo.

Before jumping to exact numbers, let's discuss quick takeaways:

• PrimeTween is about 5x faster in starting animations, which means that starting an animation has almost no overhead in comparison to actually running it. After all, there is little sense in processing animations quickly if you can't start them quickly in the first place.
• PrimeTween is 1.4 - 2.0x faster in the most common use cases in terms of runtime performance. This is the performance gain that occurs every frame.
• PrimeTween never allocates garbage, while DOTween allocates 734B per every animation start and 584B per delay.

Runtime Performance

Test environment: Unity 2022.3.9, Macbook Pro M1 32GB, IL2CPP build, 100.000 iterations per test, average frame time in milliseconds (lower numbers are better).

	DOTween 1.2.745	PrimeTween 1.0.10	Performance gain
Animation start	33.54 ms	5.76 ms	5.8x
Animation start (all params)	38.01 ms	6.72 ms	5.7x
Position animation	8.91 ms	4.34 ms	2.0x
Rotation animation	9.74 ms	6.79 ms	1.4x
Custom animation	4.93 ms	3.28 ms	1.5x
Custom animation curve	12.11 ms	4.84 ms	2.5x
Delay	4.17 ms	2.07 ms	2.0x
Delay start	15.37 ms	7.32 ms	2.1x
Sequence with 3 tweens	9.36 ms	2.83 ms	3.3x
Sequence start	45.59 ms	8.83 ms	4.9x

GC Memory Allocations

The amount of GCAlloc per one iteration, lower numbers are better.

	DOTween 1.2.745	PrimeTween 1.0.10
Animation	734 B	0 B
Animation recycle (1*)	502 B	-
Animation recycle (2*)	324 B	-
Delay	584 B	0 B
Sequence with 3 tweens	2846 B	0 B

Zero-allocation is the cornerstone of PrimeTween's design. PrimeTween never allocates GC and never produces micro-freezes that can worsen the player's experience.

DOTween allocates on each animation and delay start. This is the reason why tween caching like in the DOTweenWindow.cs example is a very common pattern among DOTween users. This usage pattern not only makes the code more complicated but has a runtime performance downside - cached tweens still receive an update every frame and consume memory.

Another option to reduce GC pressure with DOTween is to enable the ‘Recycle Tweens’ setting. This setting should be used very cautiously because every tween reference you store will be recycled and used for new tweens, which can lead to unpredictable and hard-to-detect bugs. Animation recycle (1*) includes the OnKill() callback that clears the tween reference so it doesn't point to a wrong one in the future. Animation recycle (2*) shows the usage without storing the tween's reference.

Conclusion

This concludes the performance comparison, the next one on my roadmap is to compare PrimeTween with other tween libraries. For now, I welcome everyone to clone the Benchmarks and play with the tests yourself. After cloning the repo, open the 'Window/General/Test Runner' and run the tests on the target platform by pressing the 'Run All Tests (TargetPlatform)' button.

All tests were performed with the PRIME_TWEEN_DISABLE_ASSERTIONS define. PrimeTween heavily uses assertions in development builds, and this define will disable them to match the release performance in tests.

Spotted an error in the measurement method? Or have something to add? You are welcome in the comments!

[aprius]

Recently I also saw a new tween library called Magic Tween. In addition to being based on ECS, it also supports traditional implementations. Can you do a test comparing Prime Tween with it?.

https://github.com/AnnulusGames/MagicTween

https://annulusgames.com/blog/magic-tween/

[KyryloKuzyk]

Yes, will do the comparison with other libraries in the future.

MagicTween's author already did an amazing job comparing our libraries and showed that PrimeTween is as fast as MagicTween in the most common scenario of animation positions.

However, he did the test with enabled assertions, which are not present in release builds. With the PRIME_TWEEN_DISABLE_ASSERTIONS define, PrimeTween is whopping 13.5x faster in starting the animations. In PrimeTween, starting animations has almost no cost, while MagicTween has a bottleneck here. At the end of the day, performance should be measured by the worst-case scenario, so it doesn't make much sense to process animations quickly if you can't start them quickly in the first place.

[KyryloKuzyk]

Did the quick tests. The numbers in tests were inconclusive because MagicTween's average frame times vary almost twofold from run to run. Maybe this will be addressed in future versions, so I can do more precise measurements.

Given the inconclusive results, my current best estimates are:

• PrimeTween is 14! times faster in starting animations. This is a serious bottleneck in the current version of MagicTween.
• Both libs have a similar performance in animating positions.
• MagicTween is faster in animating rotations because it uses math.nlerp() instead of Quaternion.Slerp(). However, the math.nlerp() is an approximation that is precise only with small angles.
• MagicTween allocates 48B of GC on every animation start.

	MagicTween 0.1.1	PrimeTween 1.0.10	Difference
Position animation	3.12-5.33 ms	4.34 ms	0.71-1.23x
Rotation animation	3.08-5.48 ms	6.79 ms	0.45-0.81x
Animation start	81.25 ms	5.76 ms	14.11x
Animation GC	48 B	0 B	-