a Unity Tween EnginePowered by DEMIGIANT

Get HOTween

Here it is (.zip)

For release notes, changelog, and HOTween's Visual Editor, head to Download.

DOTween (HOTween v2) IS OUT!
More than 4x faster, more efficient, and with tons of new features.
Check it out

HOTween is a fast, type-safe object-oriented tween engine for Unity, compatible with all of Unity's scripting languages.

Whew, ok, now that I'm over with the big eye-catching phrase, let me explain what this is about...

As stated above, HOTween is a script library for Unity, who can automate the animation of any numeric (and some non-numeric) property or field (numbers, vectors, transforms, and so on) in many different ways. Its core is composed by:

HOTween

Controls all Tweeners and Sequences, and is directly used to create Tweeners (via HOTween.To()).

Tweeners

Created by HOTween.To(), they're the real workers, and directly animate the given properties of the given target.

Sequences

Used to create a tween timeline. By adding Tweeners or other Sequences to them, they can be used to create complex but easy to control animations.

HOTween works on Windows, Windows Phone 8, Windows 8 Store, Mac, iOS, Android.
HOTweenMicro is needed for iOS, Windows 8 Phone/Store and WebGL.
Flash export is not supported.

Beware, Unity 4.5.2 introduced a bug which prevents HOTween from working on Windows Store (Windows Phone is still ok). There is a workaround here while the Unity guys solve it.

HOTween Visual Editor

HOTween Editor is a visual editor for HOTween. Using a single dockable panel, you can add to it all the targets and properties you wish to tween in each scene, allowing you to tween everything, including any attached MonoBehaviours properties and fields.

Note though that HOTween is mainly created for scripting. Some plugins that are available via script are not available in HOTween Editor (PlugVector3Path and PlugSetColor), and you can't create Sequences.

Interface overhaul

The interface of HOTween Visual Editor has received a big overhaul since it was created. Here is a schema of some of its current buttons

HOTweenComponent

Now HOTween Editor also comes with HOTweenComponent. Just attach it to a GameObject (via the Component > HOTween > HOTweenComponent menu item), and start adding tweens to any of its Components. Works also with prefabs!

NEW! HOPath, Visual Path Editor by Vevusio

Vevusio created a visual path editor for HOTween. You can see the announcement and download it from here.

HOTween Inspector

While playing your project in Unity's Editor, selecting HOTween's instance will show a panel full of debug information in Unity's Inspector.

Note that this panel is for debug purposes only, and while it's being shown your framerate will obviously drop. Thus, avoid selecting HOTween's instance when profiling.

Features

Built for speed, type-safety, and robustness, HOTween's features are:

Animation speed

Yup, speed. HOTween is VERY fast and reliable. Just check HOTween's Test Run and see for yourself.

Fast scripting

Coding-wise, HOTween is built so that code-assist will immediately show you all the available options, while helping you to auto-complete them quickly. Also, when using plugins, just write "Plug" (or even "Pl" is enough), and code-assist will show you all the available ones.

Type-safety

The only string you will have to write is the name of the property to tween. All the rest is fully integrated into code-assist and auto completion.

Multiple update choices

Each tween can be independently set to update at each Update, LateUpdate, FixedUpdate, or to use a special time-independent update, which will not be influenced by changes to Unity's internal timeScale (useful to animate GUI elements while a game is paused).

Make it simple, make it complex

You can write a simple tween just like this:HOTween.To(myObject, 1, "myProperty", 2); or you can create complex animations of multiple properties, with all the parameters you want, and nest them inside Sequences: both of them are controlled in the same easy way.

Extremely accurate time calculations

HOTween calculates time in a very precise way, which comes handy especially with loops. This means for example that 1000 loops of 1 second each will play exactly as long as a single loop of 1000 seconds.

Easing (both regular and with AnimationCurves)

No tween engine can go without easing, which allows to smooth the animations in various ways, so here it is (thanks to Robert Penner's easing equations). Plus, you can also use a Unity AnimationCurve to apply the ease of your choice.

Loops

You can create simple loops (X to Y, then restart), yoyo loops (X to Y, then Y to X and repeat), plus yoyo inverse loops (which work like yoyo loops, but invert their easing when moving back to the original position) and incremental loops (which increment values with each loop). You can set the exact number of loops you want, or let them go on forever.

Time scale

You can set different time scales for every tween, and you can change them even while the tweens are running.

Tween along paths with constant speed

You can use the PlugVector3Path plugin to animate something along a path, with constant speed regardless of waypoints distance, and which can be set as straight or curved with a simple boolean parameter

Plugins

HOTween automatically detects the type of property you are animating, and applies the relative default plugin. But you can always choose another one (for example, when you animate a Vector3, you can decide to use a plugin which will animate only one of the axis, or combine them anyway you want) or create your own custom plugins.

Callbacks

Easy to set callbacks, to invoke the function of your choice (public, private, static, whatever) when something happens during the animation.

Overwrite Manager

HOTween implements an overwrite manager (which can also be deactivated, in case you're looking for maximum performance), to correctly manage overlapping tweens of the same property.

Coroutines

You can just use a coroutine to create your tween and wait for it to complete (using the WaitForCompletion coroutine).

Common Interface

Is it a Tweener or a Sequence? Who cares? They both share the same IHOTweenComponent interface, thus you can control each of them in the same way.

Powerful controls

A full range of controls: Play, Pause, Reverse, Rewind, Restart, Complete, GoTo, GoToAndPlay.

Why HOTween?

NOTE: this was written in the first days of January 2012, so it might seem a little outdated. Still, it's an insight on my thoughts at the time, so I'm leaving it here :P

These days, Bob Berkebile's iTween is the established tween engine for Unity, and there are no other options (Adrian's AniMate looked extremely interesting, but I suppose it died). I personally used iTween for a while, but though I consider it a great library, which clearly shows a lot of love and dedication, I was quite unhappy with its approach. Most of all, I felt the lack of a truly object-oriented tweening engine (iTween is too "gameObject-oriented" for my tastes).

I come from many years of ActionScript - though C# rules - and my first love (for what concerns tween engines) was Zeh Fernando's Tweener, while later I moved to Jack Doyles' TweenLite, which I consider the absolute top in the field. So, I have quite a long experience - as a user - with tween engines, and I decided I might be able to create one that suited my needs. Even if I was definitely inspired by those engines, HOTween is not a port of anything (though I ported to C# Robert Penner's fundamental easing equations): it is my egotistical way of doing it :P

As every coder in the field says, creating a serious tween engine is no piece of cake. I pondered about it a lot, and completely scrapped my work twice, because I wanted to implement the best compromise between ease of use and power. In the end (or the beginning, since I obviously plan to go on improving it), I'm quite happy with the final result...

HOTween is a robust and powerful engine: it's very fast (check HOTween's Test Run), easy to use, and extremely flexible. You can animate any numeric (and even some non-numeric) value, kill and create tweens in the same piece of code without worrying about Unity's delayed object destruction, create Sequences nested into each other, control tweens in many ways, and its structure is made up of plugins, thus I can - and will - build more effects without messing up the base engine.

A note on iTween

It's important to note that HOTween doesn't aim to be "better" than iTween. Simply put, they're two very different engines, for different coding tastes, and they can work quite well together. While with HOTween I wanted to focus just on the speed and robustness of tweening, iTween is a Jack of all trades, and automates a lot more stuff than simple tweens.