UniTask - High-Performance Async for Unity

Overview

UniTask is a zero-allocation async/await library optimized for Unity, providing allocation-free asynchronous programming patterns superior to standard C# Task.

Foundation Required: unity-csharp-fundamentals (TryGetComponent, FindAnyObjectByType), csharp-async-patterns (Task, async/await), unity-async (Unity async context)

Core Topics:

• Allocation-free async/await patterns
• Coroutine to UniTask migration
• PlayerLoop-based execution model
• Memory pool management and GC pressure reduction
• Advanced cancellation and timeout handling
• Integration with Unity systems (Addressables, DOTween, etc.)

Learning Path: C# async basics → Unity async context → UniTask optimization → Production patterns

Quick Start

UniTask vs Task Performance

// Standard Task (allocates memory)
public async Task<int> GetStandard()
{
    await Task.Delay(1000);
    return 42;
}

// UniTask (zero allocation)
public async UniTask<int> GetOptimized()
{
    await UniTask.Delay(1000);
    return 42;
}

Basic Patterns

// Frame-based delays
await UniTask.Yield();                    // Next frame
await UniTask.DelayFrame(10);            // Wait 10 frames
await UniTask.NextFrame();               // Explicit next frame

// Time-based delays
await UniTask.Delay(TimeSpan.FromSeconds(1));
await UniTask.WaitForSeconds(1f);

// Unity operations
await Resources.LoadAsync<Sprite>("icon").ToUniTask();
await SceneManager.LoadSceneAsync("Level1").ToUniTask();

// Cancellation
CancellationTokenSource cts = new CancellationTokenSource();
await SomeOperation(cts.Token);

When to Use

UniTask (This Skill)

• Zero-allocation critical paths (mobile, performance-critical scenarios)
• Memory-efficient async operations
• PlayerLoop timing control and customization
• Coroutine replacement for better performance
• Integration with Unity async operations

Alternatives

• unity-async skill: General Unity async patterns, coroutines, Job System
• Standard Task: Cross-platform .NET code, non-performance-critical scenarios

Reference Documentation

UniTask Fundamentals

Core UniTask concepts and migration:

• UniTask vs Task performance characteristics
• Coroutine migration patterns
• PlayerLoop execution model
• Memory pool management
• Basic async operations

Performance Optimization

Advanced performance techniques:

• Allocation-free patterns
• GC pressure reduction
• PlayerLoop timing control
• Memory profiling with UniTask.Tracker
• Burst-compatible async patterns

Integration Patterns

Unity system integrations:

• Addressables async loading
• DOTween integration
• UnityWebRequest patterns
• UI event handling
• AsyncReactiveProperty usage

Key Principles

1. Zero-Allocation Focus: UniTask eliminates allocations for async operations
2. PlayerLoop Integration: Tight Unity integration for optimal performance
3. Always Support Cancellation: Use this.GetCancellationTokenOnDestroy() for MonoBehaviour lifecycle
4. Prefer UniTask over Task: Better performance and Unity compatibility
5. Profile Memory Usage: Use UniTask.Tracker to monitor active tasks and memory

Common Patterns

Automatic Cancellation with MonoBehaviour

public class Example : MonoBehaviour
{
    async UniTaskVoid Start()
    {
        // Auto-cancels when GameObject is destroyed
        await LoadData(this.GetCancellationTokenOnDestroy());
    }
}

Parallel Operations

// Execute multiple operations in parallel
(int result1, string result2, float result3) = await UniTask.WhenAll(
    Operation1(),
    Operation2(),
    Operation3()
);

Timeout Handling

CancellationTokenSource cts = new CancellationTokenSource();
cts.CancelAfterSlim(TimeSpan.FromSeconds(5)); // PlayerLoop-based

try
{
    await LongOperation(cts.Token);
}
catch (OperationCanceledException)
{
    Debug.Log("Operation timed out");
}

Platform Considerations

• WebGL: Limited threading, UniTask provides frame-based async as primary pattern
• Mobile: Critical for battery optimization and memory efficiency
• Desktop: Full feature support with optimal performance

Best Practices

1. Use CancellationToken: Always pass cancellation tokens, prefer this.GetCancellationTokenOnDestroy()
2. Avoid async void: Use UniTaskVoid for fire-and-forget operations
3. PlayerLoop Optimization: Use minimal PlayerLoop injection for better performance
4. Profile with Tracker: Monitor memory with UniTask.Tracker in editor
5. Chain Operations: Use WhenAll/WhenAny for parallel execution
6. Thread Switching: Use SwitchToMainThread()/SwitchToThreadPool() appropriately

Integration with Other Skills

• unity-async: Provides foundation for Unity async patterns
• unity-reactive: AsyncReactiveProperty bridges UniTask with R3
• unity-di: UniTask works seamlessly with VContainer DI patterns
• unity-performance: UniTask reduces GC pressure significantly