https://github.com/Cysharp/UniTask

Info

• Provides an efficient allocation-free async/await integration for Unity.
• Struct-based UniTask<T> and custom AsyncMethodBuilder to achieve zero allocation
• Makes all Unity AsyncOperations and Coroutines awaitable
• PlayerLoop based task(UniTask.Yield, UniTask.Delay, UniTask.DelayFrame, etc..) that enable replacing all coroutine operations
• MonoBehaviour Message Events and uGUI Events as awaitable/async-enumerable
• Runs completely on Unity's PlayerLoop, so doesn't use threads and runs on WebGL, wasm, etc.
• Asynchronous LINQ, with Channel and AsyncReactiveProperty
• TaskTracker window to prevent memory leaks
• Highly compatible behaviour with Task/ValueTask/IValueTaskSource
• Refer to the official docs on its GitHub page for detailed info

Examples

• Synchronous version of the task method

public UniTask DemoAsync()
{
    // Do some stuff
    return UniTask.CompletedTask;
}

• Standard awaits

public async UniTask DemoAsync()
{
    // await frame-based operation like a coroutine
    await UniTask.DelayFrame(100);

    // replacement of yield return new WaitForSeconds/WaitForSecondsRealtime
    await UniTask.Delay(TimeSpan.FromSeconds(10), ignoreTimeScale: false);

    // yield any playerloop timing(PreUpdate, Update, LateUpdate, etc...)
    await UniTask.Yield(PlayerLoopTiming.PreLateUpdate);

    // replacement of yield return null
    await UniTask.Yield();
    await UniTask.NextFrame();

    // replacement of WaitForEndOfFrame
#if UNITY_2023_1_OR_NEWER
    await UniTask.WaitForEndOfFrame();
#else
    // requires MonoBehaviour(CoroutineRunner))
    await UniTask.WaitForEndOfFrame(this); // this is MonoBehaviour
#endif

	// replacement of yield return new WaitForFixedUpdate(same as UniTask.Yield(PlayerLoopTiming.FixedUpdate))
    await UniTask.WaitForFixedUpdate();

    // replacement of yield return WaitUntil
    await UniTask.WaitUntil(() => isActive == false);

    // special helper of WaitUntil
    await UniTask.WaitUntilValueChanged(this, x => x.isActive);

    // You can await IEnumerator coroutines
    await FooCoroutineEnumerator();

    // You can await a standard task
    await Task.Run(() => 100);

    // Multithreading, run on ThreadPool under this code
    await UniTask.SwitchToThreadPool();

    /* work on ThreadPool */

    // return to MainThread(same as `ObserveOnMainThread` in UniRx)
    await UniTask.SwitchToMainThread();

    // Scene loading
    await SceneManager.LoadSceneAsync("scene2");

    // Asset loading
    var asset = await Resources.LoadAsync<TextAsset>("foo");

    // .WithCancellation enables Cancel, GetCancellationTokenOnDestroy synchornizes with lifetime of GameObject
    var asset2 = await Resources.LoadAsync<TextAsset>("bar").WithCancellation(this.GetCancellationTokenOnDestroy());

    // .ToUniTask accepts progress callback(and all options), Progress.Create is a lightweight alternative of IProgress<T>
    var asset3 = await Resources.LoadAsync<TextAsset>("baz").ToUniTask(Progress.Create<float>(x => Debug.Log(x)));

    // Web requests
    var txt2 = (await UnityWebRequest.Get("https://...").SendWebRequest()).downloadHandler.text;

    var task2 = GetTextAsync(UnityWebRequest.Get("<http://bing.com>"));
    async UniTask<string> GetTextAsync(UnityWebRequest req)
    {
        var op = await req.SendWebRequest();
        return op.downloadHandler.text;
    }
}

• Await Services

public async UniTask DemoAsync()
{
    var networkMgr = await AppCore.Services.AwaitRegistered<MasterNetworkManager>();
}

• Await callbacks