Hello,

a lot of work went into HOTween, and a lot more is to come (to fix eventual bugs that should appear, but mostly to add more features). If you use it and like it, even a small donation would be greatly appreciated, and would help funding HOTween's evolution (plus it would greatly boost my self-esteem :P)

Thanks :)
Daniele Giardini

Get HOTween

Here it is (.zip)

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

Ohno! This column is so empty! What will I do now?

Maybe writing some non-sentences will help...

Like... CATAPRAXIS!

See the camel?

Revolution?

Megarobots are cool, but the conversation is quite boring

Sanity is overrated

Jelena is an awesome comic artist

Yuhuuuu?

History teaches us what went wrong, so that next time we can go wrong more quickly

x + 3 = Mister X

y + 4 = Madame Y

z + 5 = zzzzzz

Don't tell me you're reading this! Seriously?

No, that's not what I said. That's what YOU said

Bonk!

We are going doooown

And dooooowner!

Oh, look, more non-sentences below!

X: "Hey, have you seen my socks?"
Y: "What am I? Your sockretary?"

This will never end

I'm getting hungry. As soon as I finish writing these things I'm eating something big

Exploramation

What happened to Frank Miller?

I have a cat whose name is Blues, but she's not very bluesish

I wonder...

Is that a wall? A typewriter? A pumpkin? Oh no: it's Humbert! Hey, Humbert, you look good today!

A

B

C

I have 23 more of those, but I'll keep them for later...

Catapraxis! Oops, I'm repeating myself

Now this is the punishment for doing such long pages

Is this it?

D

E

Told you I was keeping some for later

Ulysses Rejoyce

Yes, I'm inventing all this stuff in a single session: that's what too much coding will bring you

Chester Brown: I just love his stuff

Did I mention that I was hungry?

Enough!

See ya

No really, I'm stopping now

...

END

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
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.
Flash export is not supported.

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.