Tickle

A performant, lightweight and intuitive open-source tween library for Unity. Optionally uses Unity's Job System to unlock even more performance!

✔️ Why "Tickle"

The name "Tickle" reflects our focus on improving developer experience by building something that is "small, simple, and fast".

Moving an object in your scene can be as simple as this:

transform.LerpPosition(start, end, duration).Start();

There are already many tween libraries out there, but we want to create a library that

• Offers only a light set of API for the most intuitive and common features, such that it can be easily extended/customized to your own needs
• Does not contain compulsory external dependencies
• Is beautiful to read and easy to reason, even if at the low cost of very little GC allocation, and yet...
• ...could still be trusted for relatively high performance, which could optionally be made even better with Unity's Job System!

You may read more about the API design decisions and technical implementation details in the blog.

💻 Installation

Simply download the latest released Unity Asset Package here.

After installation, please make sure that you go to "Project Settings" > "Player" > "Other Settings", and then enable "Allow unsafe code".

We will support installation via OpenUPM and perhaps other methods once we have arrived at a stable first version (i.e., v1.0.0).

📖 "All-you-need" Documentation

Tickle takes pride in its small and simple API design and footprint. Here is all you need to know about working with Tickle.

🕺Creating a simple lerp with a "Tickle"

A "Tickle" simply describes the linear interpolation (i.e. a "Lerp") of a single property.

ITickle tickle = transform.LerpScale(start: 1, end: 2, duration: 3);
tickle.OnComplete(() => Debug.Log("Finished with scaling"));
tickle.Start();
// Also supports tickle.Stop()/Pause()/Resume()

You may also chain together your method calls like this:

ITickle tickle = transform
    .LerpScale(start, end, duration)
    .OnComplete(() => Debug.Log("Finished with scaling"))
    .Start();

Please refer to the full list of available lerp functions.

🕺💃 Grouping lerps with a "TickleSet"

A "TickleSet" is a set of Tickles that run parallel to each other. Intuitively, a TickleSet is simply an array of Tickles.

// An array of Tickles simply makes a "TickleSet"
ITickle[] tickleSet = new ITickle[] {
    transform.LerpPosition(startPos, endPos, duration),
    transform.LerpScale(startSize, endSize, duration)
};
tickleSet.OnComplete(() => Debug.Log("Finished with set"))
tickleSet.Start();

Or if it is clearer, you may explicitly declare a TickleSet object.

var tickleSet = new TickleSet()
    .Join(transform.LerpPosition(startPos, endPos, duration))
    .Join(transform.LerpScale(startSize, endSize, duration));
    .OnComplete(() => Debug.Log("Finished with set"));
    .Start();

🔗 Sequencing lerps with a "TickleChain"

A "TickleChain" is a sequence of Tickles that run one after another. Intuitively, it is an array of TickleSets, or a 2D array of Tickles!

// Creating a TickleChain
ITickle[][] tickleChain = new ITickle[][]
{
    new ITickle[] { // TickleSet 1
        transform.LerpPosition(startPos, endPos, duration),
        transform.LerpScale(startSize, endSize, duration)
    },
    new ITickle[] { // TickleSet 2
        transform.LerpPosition(endPos, startPos, duration),
        transform.LerpScale(endSize, startSize, duration)
    }
}
.OnComplete(() => Debug.Log("Finished with sequence"))
.Start();

If you so choose, you may also explicitly declare a TickleChain object. You can chain together both TickleSets as well as plain Tickles.

var tickleChain = new TickleChain()
    .Chain(tickleSet)
    .Chain(transform.LerpScale(startSize, endSize, duration))
    .OnComplete(() => Debug.Log("Finished with sequence"))
    .Start();

Again, you are encouraged to write this the way you find to be the clearest/prettiest to you.

📈 Easing functions

Tickle supports a limited set of easing functions. Here is an example:

transform.LerpPosition(start, end, duration, Ease.InQuad);

We are currently working to support even more easing functions, as well as the ability for users to define their own. Please refer to the full list of available ease functions.

⚡ Enabling Unity's Burst + Job System

If you'd like to tap on Unity's Burst compiler and Jobs system for high performance tweening of an extremely large number of objects, you may install the Burst package from Unity's Package Manager.

After that, please enter "ENABLE_BURST" in "Project Settings" > "Player" > "Other Settings" > "Scripting Define Symbols".

🛠️ Want customisability / even more performance?

Tickle is actually a wrapper around a highly-performant custom lerp library that features zero-allocation and no boxing, and works with contiguous memory to avoid cache misses. In comparison, Tickle introduces just slight overhead in order to provide QoL features such as sequencing tweens (via "TickleChains") and supporting action delegates (e.g., "onComplete" callbacks).

If you wish to squeeze even more performance, or you'd like to implement your own wrapper around the lerp library, you may skip using the Tickle wrapper and work directly with the lerp library instead.

using Tickle.Lerp;

public class Example : MonoBehaviour
{
    private int _lerpId;
    private float _target = 0;
    private bool _isDone = false;
    
    private void Start()
    {
        _lerpId = Lerp<float>.Create(ref _target, ref _isDone, start, end, duration);
        Lerp<float>.Start(_lerpId);
    }
    
    private void Update()
    {
        Debug.Log(_target);
    
        if (_isDone)
            Debug.Log("Lerp is finished");
    }
}

Other than Lerp<float>, we currently also support Lerp<Color>, Lerp<Vector2>, Lerp<Vector3>, Lerp<Vector4> and Lerp<Quaternion>.

You may read more about the API design decisions and technical implementation details in the blog.

🔌 API List

Please note that the API is still being changed and extended on.

Tickler.WaitForSeconds(float seconds, Action onComplete);

<float>.Lerp(float start, float end, floar duration, Ease ease, Action onComplete);

<transform>.LerpPosition(Vector3 start, Vector3 end, float duration, Ease ease, Action onComplete);

<transform>.LerpScale(Vector3 start, Vector3 end, float duration, Ease ease, Action onComplete);

<transform>.LerpRotation(Vector3 eulerStart, Vector3 eulerEnd, float duration, Ease ease, Action onComplete);

📺 Showcase

We are interested in showcasing projects that use Tickle! Please get in touch with me at tankangsoon@gmail.com.

👏 Support & Contribute

Bug reports: Issues

Questions and feature requests: Discussions

To become a contributor, feel free to contact me at tankangsoon@gmail.com

For contributors, please refer to the Issues page for a list of potential tasks you could work on. For newcomers, you may pay attention to the "good first issue" label. Thank you!

© Tan Kang Soon 2025