Many Unity developers run into strange behavior after pausing their game using Time.timeScale = 0. Coroutines stop working. Physics freezes. Animations behave unexpectedly. UI timers break.

This is often described as a “Time.timeScale bug,” but in reality, Unity is doing exactly what it is designed to do.

The confusion comes from not fully understanding what Time.timeScale actually controls.

This article explains how pausing affects coroutines, physics, animations, and timers, and how to pause your game safely without breaking systems.

What Time.timeScale Actually Does

Time.timeScale controls how fast time passes in your game.

Default value:

Time.timeScale = 1f;

Slow motion example:

Time.timeScale = 0.5f;

Pause example:

Time.timeScale = 0f;

When set to zero, all time-based calculations that rely on Time.deltaTime stop progressing.

Why Physics Stops When Paused

Unity’s physics engine runs using FixedUpdate(), which depends on time progression.

When Time.timeScale = 0:

• FixedUpdate() stops running
• Physics simulation freezes
• Rigidbodies stop moving
• Forces are not applied

This is expected behavior.

If you need physics to continue during pause (rare case), you must simulate physics manually or avoid using timeScale for that system.

Why Coroutines Stop Working

Coroutines that use WaitForSeconds are affected by timeScale.

Example:

yield return new WaitForSeconds(2f);

If timeScale is zero, this coroutine will never continue, because scaled time is not advancing.

This is one of the most common sources of confusion.

The Correct Way to Run Coroutines During Pause

Use WaitForSecondsRealtime instead:

yield return new WaitForSecondsRealtime(2f);

This uses unscaled time and works even when the game is paused.

Animations and timeScale

By default, Animator components are affected by timeScale.

If you pause the game, animations stop.

If you want UI animations to continue during pause, change the Animator update mode:

• Select Animator component
• Set Update Mode to Unscaled Time

Now the animation ignores timeScale.

Timers Breaking During Pause

Many developers create timers like this:

timer += Time.deltaTime;

When timeScale is zero, Time.deltaTime becomes zero.

The timer stops.

If you need a timer that runs during pause, use:

timer += Time.unscaledDeltaTime;

Update Still Runs During Pause

Important detail: Update() continues running even when timeScale is zero.

But:

• Time.deltaTime becomes 0
• FixedUpdate() stops

This means input handling and UI logic can still work while the game is paused.

Common Pause System Mistakes

1. Expecting Coroutines to Continue

If you use WaitForSeconds, they will freeze.

2. Using deltaTime for UI Effects

UI animations that depend on deltaTime will stop unless switched to unscaled time.

3. Forgetting to Resume timeScale

Always restore timeScale when unpausing:

Time.timeScale = 1f;

Reliable Pause System Pattern

Simple pause manager:

public void PauseGame()
{
    Time.timeScale = 0f;
}

public void ResumeGame()
{
    Time.timeScale = 1f;
}

For UI timers or animations that must continue:

• Use Time.unscaledDeltaTime
• Use WaitForSecondsRealtime
• Set Animator to Unscaled Time

Advanced Alternative: Manual Pause Control

Instead of using timeScale, you can manually disable gameplay systems:

• Disable player controller
• Disable enemy AI
• Stop movement scripts

This avoids global time freezing and gives more control.

Is This Really a Bug?

No. Unity is working as intended. Time.timeScale scales all time-dependent systems. When set to zero, scaled time stops completely.

The issue only appears to be a bug when developers expect certain systems to ignore timeScale.

Conclusion

The Unity Time.timeScale “bug” is really a misunderstanding of how scaled and unscaled time work.

When you pause using Time.timeScale = 0:

• Physics stops
• FixedUpdate stops
• WaitForSeconds pauses
• deltaTime becomes zero

To build a reliable pause system, use unscaled time for UI and real-time systems, and scaled time for gameplay systems.

Once you separate those two concepts, pausing becomes predictable and stable.