Unity Slerp: A Comprehensive Guide

On this page


    As a game developer, I always use Slerp to handle spherical linear interpolation in Unity. This method enables you to create smooth transitions between two rotations. In this article, we will review Unity Slerp. I will review its definition applications and provide practical examples. Whether you are new to Unity or an experienced developer, keep reading. This guide will provide valuable insights into the Slerp technique.

    Unity Slerp Syntax


    public static Vector3 Slerp(Vector3 a, Vector3 b, float t);

    public static Quaternion Slerp(Quaternion a, Quaternion b, float t);


    Unity Slerp Usage


    using UnityEngine;


    public class Slerp : MonoBehaviour


        [Range(0f, 1f)]

        public float interpolator = 0f;

        public Transform target;

        private void Update()


            if (target == null)


            transform.position = Vector3.Slerp(Vector3.zero, target.position, interpolator);

            transform.rotation = Quaternion.Slerp(



                interpolator * Time.deltaTime





    What is Slerp in Unity?

    The Unity Slerp method is a fundamental mathematical operation. Developers use this operation to interpolate between two rotations in 3D space. It provides a way to transition from one rotation to another over time. This smooth rotation enables you to create natural-looking animations. The Slerp technique is essential in game development. As a developer, you need to create realistic characters and camera movement. Slerp enables you to do that.

    The Basics of Quaternion Rotation

    In this section, I will give a high-level look at rotations in Unity. Before we address Slerp, we will review quaternions. Unity represents a rotation as a quaternion. A quaternion is a complex, four-component math construct. I assume you are familiar with Euler angles. Quaternions offer several advantages over Euler angles. Euler angles are subject to gimbal lock, whereas Quaternions are not. Also, Quaternions provide smoother and more consistent interpolation.

    The Basics of Vector Rotation

    In this section, I'll give a high-level look at vectors in Unity. In Unity, you can represent a direction as a Vector. A vector is a two, three, or four-component math construct. When treated as a direction, the vector represents the relative position of something. For example, a Vector3 of (1,0,0) represents the direction of "right."

    Unity offers Slerp implementations for both Quaternions and Vector3 classes. But it helps to understand both options.

    What is Slerp?

    Slerp stands for Spherical Linear Interpolation. It works by finding the shortest path between two rotations on the surface of a sphere and interpolating between them. This results in a smooth and natural transition between rotations. Slerp is ideal for animations and camera movements.

    If you're uncomfortable with Linear Interpolation, read my guide to Lerp.

    When to Use Slerp

    Slerp is useful when you need to transition between a rotation or direction seamlessly. Some examples include:

    • Smooth camera movements in games.
    • Realistic character animations.
    • Precise object rotations in 3D modeling.

    Implementing Slerp in Unity

    To use Slerp in Unity, you'll need to work with quaternions or Vector3s. The Slerp method expects a start and an end rotation. And you need to provide an interpolation factor. The interpolation factor represents how far along the interpolation you are. 

    You can think of the interpolation as a curve. The start of the curve is the start rotation, and the end of the curve is the end rotation. The interpolator represents how far along the curve you are. 

    Unity provides built-in functions for Slerp, making it straightforward to use. Unity includes built-in functions for both Quaternions and Vector3s.

    Practical Example: Smooth Camera Movement

    Consider a practical example: creating smooth camera movement in a game. In this example, you will apply Slerp to interpolate between the current camera and target rotation. This interpolation enables us to achieve cinematic camera transitions. These types of camera movements help players feel more immersed in your game.

    Here's an example of how you might do this:


    using UnityEngine;


    public class SlerpCamera : MonoBehaviour


        public Transform player;

        public float interpolator;

        void LateUpdate()


            transform.rotation = Quaternion.Slerp(



                Time.deltaTime * interpolator





    For this example, we used Late Update. Late Update is a powerful event function to control cameras in Unity. Read my comprehensive guide to Unity Late Update to learn more about it.

    Advantages of Using Slerp

    Using Slerp in your Unity projects offers several advantages:

    • Smooth and natural animations.
    • Elimination of gimbal lock issues.
    • Precise control over rotation transitions.

    Tips for Efficient Slerp Usage

    To make the most of Slerp, consider the following tips:

    • Use quaternions or directional Vector3s as input. Don't use Euler angles.
    • Experiment with different interpolation factors for desired effects.
    • Keep performance in mind, especially in complex scenes.

    Common Pitfalls and How to Avoid Them

    While Slerp is a powerful tool, it's essential to be aware of common pitfalls. Understanding the technique and its parameters is vital to avoiding these issues. Unity will clamp the interpolator to the range [0,1]. As a result, you will prevent overshoot with the default implementations of Slerp. Apart from that, ensure you normalize the interpolator with Time.deltaTime. Using deltaTime ensures that the interpolation is frame-rate independent.

    Slerp vs. Lerp: Understanding the Difference

    You can compare Slerp to another interpolation technique called Lerp (Linear Interpolation). Read our complete guide to Lerp to learn more about that function.

    Frequently Asked Questions

    Is Slerp only used for 3D game development?

    No. Developers use Slerp in 3D game development. But you can also use it in 3D modeling and animation fields.

    Can I use Slerp for 2D games?

    Yes. You can use Slerp in 2D games as well. Slerp is excellent for any scenario where you need smooth transitions between rotations or Vectors.

    Are there any alternatives to Slerp in Unity?

    Yes. Unity provides other interpolation methods. You can use Lerp for non-spherical interpolation or nlerp for normalized interpolation. These methods are best in different scenarios, so it helps to have a holistic understanding.

    How do I choose the interpolation factor for Slerp?

    You should choose the interpolation factor based on the desired speed of the rotation transition. Remember that the interpolator represents how 'close' you are to the a vs. b input. 

    A value of 0 means that you are still at 'a'. A value of 1 means that you have already arrived at 'b .' A value of 0.5 means that you're halfway through the interpolation.

    Suppose your 'a' input is a constant value. You can, alternatively, use 'a' input as a dynamic value (e.g., transform.position). In this case, the interpolation represents how quickly your transform.position should change over time (per frame). Experimentation and testing are crucial to finding the best value.

    Where can I learn more about quaternion math and Unity Slerp?

    You can find extensive documentation on quaternion math and Unity Slerp on the official Unity website. You can also find more information on various online forums. I'd also recommend the 3blue1brown series on Quaternions for a primer.


    In conclusion, Unity Slerp is a powerful tool for making smooth rotations and animations in your Unity games. Now that you understand quaternions and vector directions, you have the foundation required to use Slerp. And we've also given a complete review of the Slerp method. In the future, you can develop better-quality projects and provide a more immersive experience for players.

    Join our newsletter to get the latest updates
    Sign Up
    Michael Sacco
    Founder & CEO

    Michael Sacco is the Founder and CEO of OccaSoftware where he specializes in developing game assets for Unity game developers. With a background ranging from startups to American Express, he's been building great products for more than 10 years.

    c sharp
    Unity Basics