unity-async
Handle Unity's asynchronous programming patterns including coroutines, async/await, and Job System. Masters Unity's main thread restrictions and threading models. Use when guidance needed on Unity async operations, coroutine optimization, or parallel processing in Unity context.
When & Why to Use This Skill
This Claude skill provides expert guidance on mastering Unity's asynchronous programming models, including Coroutines, async/await, and the C# Job System. It helps developers solve complex concurrency issues, navigate main thread restrictions, and implement high-performance parallel processing using the Burst compiler, ensuring smooth and responsive gameplay.
Use Cases
- Case 1: Implementing non-blocking resource loading and network requests using UnityWebRequest and Addressables with async/await patterns.
- Case 2: Optimizing CPU-intensive calculations by offloading data processing to the Unity Job System to maintain high frame rates.
- Case 3: Managing complex game state transitions and frame-based timing logic through optimized Coroutine structures.
- Case 4: Resolving thread-safety issues and marshaling data back to the main thread when performing background operations.
| name | unity-async |
|---|---|
| description | Handle Unity's asynchronous programming patterns including coroutines, async/await, and Job System. Masters Unity's main thread restrictions and threading models. Use when guidance needed on Unity async operations, coroutine optimization, or parallel processing in Unity context. |
| - csharp-plugin | csharp-async-patterns |
Unity Async Patterns
Overview
Unity-specific async patterns extending foundational C# async/await concepts.
Foundation Required: unity-csharp-fundamentals (TryGetComponent, FindAnyObjectByType, null-safe coding)
Core Topics:
- Coroutines and yield instructions
- async/await with Unity main thread constraints
- Unity Job System and Burst compiler
- Thread safety and marshaling
- Addressables and UnityWebRequest integration
Learning Path: C# async basics → Unity context → UniTask optimization → Reactive patterns
Quick Start
Three Unity Async Approaches
// 1. Coroutine (Unity-specific, frame-based)
IEnumerator LoadDataCoroutine()
{
yield return new WaitForSeconds(1f);
UnityWebRequest request = UnityWebRequest.Get(url);
yield return request.SendWebRequest();
ProcessData(request.downloadHandler.text);
}
// 2. Async/Await (C# standard + Unity constraints)
async Task<string> LoadData(CancellationToken ct)
{
await Task.Delay(1000, ct);
using UnityWebRequest request = UnityWebRequest.Get(url);
await request.SendWebRequest();
return request.downloadHandler.text;
// Unity auto-marshals to main thread
}
// 3. Job System (parallel data processing)
[BurstCompile]
struct VelocityJob : IJobParallelFor
{
[ReadOnly] public NativeArray<Vector3> velocities;
public NativeArray<Vector3> positions;
public float deltaTime;
public void Execute(int index)
{
positions[index] += velocities[index] * deltaTime;
}
}
When to Use
Unity Async (This Skill)
- Frame-based timing and Unity API integration
- Standard async/await with Unity constraints
- Job System parallelization
- Main thread restrictions and solutions
Specialized Agents
- unity-unitask-pro: Zero-allocation async, memory-critical scenarios
- unity-reactive-pro: Event streams, MVVM/MVP, reactive state management
Reference Documentation
Unity-Specific Extensions
- Coroutines vs async/await decision framework
- Main thread restrictions and solutions
- Job System usage patterns
- MonoBehaviour lifecycle integration
- yield return variations
- Coroutine chaining and composition
- Custom yield instructions
- Performance considerations
- Main thread vs background threads
- UnityMainThreadDispatcher patterns
- Job System and Burst compiler
- Thread-safe data structures (NativeArray, NativeContainer)
Key Principles
- Main Thread Only: Unity APIs require main thread
- Coroutines for Frames: Frame-based operations use coroutines
- Job System for Parallelism: CPU-intensive data processing
- UniTask for Performance: Zero-allocation critical paths
- R3 for Reactive: Complex event streams and data binding
Common Patterns
Frame Timing
yield return null; // Next frame
yield return new WaitForEndOfFrame(); // After rendering
yield return new WaitForFixedUpdate(); // Physics update
Async Resource Loading
AsyncOperation asyncLoad = SceneManager.LoadSceneAsync("Scene");
while (!asyncLoad.isDone)
{
float progress = Mathf.Clamp01(asyncLoad.progress / 0.9f);
yield return null;
}
Addressables Integration
AsyncOperationHandle<GameObject> handle = Addressables.LoadAssetAsync<GameObject>("AssetKey");
await handle.Task;
GameObject prefab = handle.Result;
Platform Considerations
- WebGL: No threading, coroutines primary, Job System unavailable
- Mobile: Battery optimization critical, limit thread count
- Desktop: Full threading support, higher performance budgets
Agent Delegation
Unity Async Needs
├── Frame timing → unity-async (coroutines)
├── Standard async → unity-async (async/await)
├── Parallel data → unity-async (Job System)
├── Zero-allocation → unity-unitask-pro agent
└── Reactive patterns → unity-reactive-pro agent