CoroFlow
C++20 coroutines for Unreal Engine gameplay code

Overview

CoroFlow is a C++-first library that brings C++20 coroutines to Unreal Engine. Asynchronous work that normally needs timers, delegates, latent-action classes and callback chains becomes sequential code: co_await a delay, an asset load, a line trace, a thread switch or another coroutine and the function continues where it left off.

• Latent UFUNCTIONs without boilerplate: return FVoidCoroutine from a meta=(Latent) function and Blueprints get a normal latent node; the coroutine is cleaned up if its object is destroyed.
• Plain C++ coroutines: TCoroutine<T> with results, continuations, waiting and cancellation.
• Game-thread timing: next tick, N ticks, seconds (dilated, unpaused, real, audio), predicates and per-actor dilation.
• Threads: move between the game thread, UE::Tasks, named threads, thread pools and new threads.
• Engine integration: async loading, async traces/sweeps/overlaps, timelines, tick time budgets, HTTP, animation montages and notifies, AI movement and pathfinding.
• Composition: WhenAny, WhenAll, Race, awaitable events and semaphores, generators with co_yield.
• Gameplay Ability System integration (optional module) and a Gameplay Debugger category.

Requirements

Installation

1. Install CoroFlow from the launcher into your engine, or copy the CoroFlow folder into your project's Plugins folder, and enable it in Edit > Plugins.
2. Make sure every Target.cs uses the latest settings: DefaultBuildSettings = BuildSettingsVersion.Latest; and IncludeOrderVersion = EngineIncludeOrderVersion.Latest;. Do not force CppStandard to C++17 in modules that use CoroFlow.
3. Add the modules you use to your .Build.cs, e.g. PublicDependencyModuleNames.AddRange(new[] { "CoroFlow", "CoroFlowAI" });, and include only the header named after each module (CoroFlow.h, CoroFlowAI.h, CoroFlowGAS.h).
4. For CoroFlowGAS, enable the engine's GameplayAbilities plugin in your project.
5. Regenerate project files and build.

Quick start

C++ (latent UFUNCTION)

// MyActor.h
#include "CoroFlow.h"

UFUNCTION(BlueprintCallable, meta = (Latent, LatentInfo = LatentInfo))
FVoidCoroutine LoadAndSpin(TSoftObjectPtr<UStaticMesh> Mesh, FLatentActionInfo LatentInfo);

// MyActor.cpp
using namespace CoroFlow;

FVoidCoroutine AMyActor::LoadAndSpin(TSoftObjectPtr<UStaticMesh> Mesh, FLatentActionInfo LatentInfo)
{
    co_await Latent::Seconds(0.5);                          // does not block the game thread

    UStaticMesh* Loaded = co_await Latent::AsyncLoadObject(Mesh);

    co_await Async::MoveToTask();                           // continue on a worker thread
    double Sum = 0;
    for (int32 i = 0; i < 1000000; ++i)
        Sum += FMath::Sqrt(static_cast<double>(i));
    co_await Async::MoveToGameThread();                     // back to the game thread

    co_await Latent::Timeline(this, 0, 360, 2.0, [this](double Angle)
    {
        SetActorRotation(FRotator(0, Angle, 0));
    });
}

Blueprint

1. Build the code above, open the actor's Blueprint and search for Load And Spin: it is a latent node (clock icon) with a Mesh input; the coroutine return value is hidden.
2. Connect the exec pins; the output exec fires when the coroutine finishes. Destroying the actor while it runs cancels the coroutine cleanly.

C++ (plain coroutine with a result)

TCoroutine<int32> CountAsync()
{
    co_await CoroFlow::Async::MoveToTask();
    co_return 42;
}

TCoroutine<> UseIt()
{
    int32 Value = co_await CountAsync();    // awaiting a TCoroutine<T> yields T
    co_await CoroFlow::Async::MoveToGameThread();
    UE_LOG(LogTemp, Display, TEXT("Value %d"), Value);
}

Blueprint latent nodes

CoroFlow has no Blueprint function library of its own. Instead, the CoroFlowK2 editor module turns every BlueprintCallable UFUNCTION that returns FVoidCoroutine into a call node with the coroutine pin hidden (default category Call Coroutine when the function has none). With meta=(Latent, LatentInfo=...) the node is latent and continues when the coroutine completes.

Coroutine types

Latent awaiters (namespace CoroFlow::Latent)

Latent awaiters run on the game thread through the latent action manager. They can be used from latent and async coroutines.

Loading & collision (namespace CoroFlow::Latent)

Threads & timing (namespace CoroFlow::Async)

Implicitly awaitable without wrappers: TCoroutine<T>, UE::Tasks::TTask<T>, TFuture<T> and engine delegates, including dynamic and multicast delegates (the await result holds the delegate's parameters).

Aggregates & threading primitives

Cancellation

Generators, HTTP, animation

AI (module CoroFlowAI, namespace CoroFlow::AI)

Gameplay Ability System (module CoroFlowGAS)

Optional: enable the engine's GameplayAbilities plugin and add "CoroFlowGAS" to your Build.cs. Ability coroutines return CoroFlow::GAS::FAbilityCoroutine.

CoroFlow::GAS::FAbilityCoroutine UMyAbility::ExecuteAbility(FGameplayAbilitySpecHandle Handle,
    const FGameplayAbilityActorInfo* ActorInfo, FGameplayAbilityActivationInfo ActivationInfo,
    const FGameplayEventData* TriggerEventData)
{
    if (!CommitAbility(Handle, ActorInfo, ActivationInfo))
        co_return;
    co_await CoroFlow::Latent::Seconds(1);   // ability ends when the coroutine returns
}

Gameplay Debugger

The CoroFlowDebug module adds a CoroFlow Gameplay Debugger category listing running coroutines. It needs coroutine tracking, which is off by default because of its runtime cost: add CoroFlowModuleRules.bEnableCoroutineTracking = true; to your Target.cs. Console variables: CoroFlow.MaxDisplayedCoroutines (default 20) and CoroFlow.MaxDisplayedCoroutinesOnTarget (default 5). CoroFlowDebug.bRegisterConditionalTextFormatArgumentModifier = true; (in every Target.cs) makes the |conditional text-format modifier available to your own localized text.

Troubleshooting

Credits

© 2026 Alpha XP — alphaxp.net · Support: support@alphaxp.net. Built and verified for Unreal Engine 5.8.