Document EOS release 2026.03.06 and 2026.03.17

Author: hach-que

docs/changelog/2026/03.06/_index.mdx

@@ -0,0 +1,15 @@
+import NodeRef from "@site/src/components/NodeRef";
+
+### 2026.03.06
+
+This release fixes several issues:
+
+- Fixed a potential crash if the procedural sound wave object used by voice chat was unexpectedly garbage collected.
+- Fixed an issue where clients would not connect to voice chat channels correctly if there were multiple voice chat components referencing the same voice chat group.
+- Fixed an issue where clients would not reconnect to voice chat channels when the server performs server travel, or the client otherwise disconnects and then quickly reconnects to the same game server.
+- Fixed an issue where presence was not working correctly on Meta Quest.
+- Fixed a crash that could happen when signing in with Google on some Android devices.
+- Fixed a crash that could happen when the matchmaking engine shuts down on game exit.
+- Fixed an issue where `MaxPacketHandlerBits` was not set correctly on the net connection.
+- Added a new low-level `IMetaPlatformSystem` C++ API for performing custom calls to the Oculus platform SDK.
+- Unreal Engine 5.3 has been removed from the build matrix, as we no longer have any Premium support customers who require support for this engine.

docs/changelog/2026/03.17/_index.mdx

@@ -0,0 +1,16 @@
+import NodeRef from "@site/src/components/NodeRef";
+
+### 2026.03.17
+
+This release improves the asynchronous task library and fixes several issues:
+
+- Added thread policies to asynchronous tasks, which makes writing cross-thread code easier.
+- Fixed an issue where exceptions thrown by asynchronous functions using `TTask<>` were not re-thrown. This improves diagnostics when debugging crashes in Visual Studio that involve asynchronous functions.
+- Fixed a crash when the engine runs `OnRegister` twice for the same voice chat component.
+- Fixed a crash that could happen if voice chat was polling hardware devices for audio during game exit.
+- Fixed a build error that could occur when extracting SDK files for Android builds.
+- Improved the performance of the asynchronous task library and reduced the number of allocations that occur when invoking an asynchronous function.
+- Increased the size of audio buffers in voice chat to reduce the chance of buffer underruns.
+- Improved logging when audio buffers underrun for voice chat.
+- Changed the implementation of `URedpointVoiceChatSoundWave` used by the voice chat system in an attempt to mitigate a crash caused by the audio processing logic in `USoundWaveProcedural`.
+- Removed legacy code guards referring to engine versions prior to Unreal Engine 5.5.

docs/changelog/2026/_index.mdx

@@ -1,7 +1,11 @@
+import R0317 from "./03.17/_index.mdx";
+import R0306 from "./03.06/_index.mdx";
 import R0221 from "./02.21/_index.mdx";
 import R0212 from "./02.12/_index.mdx";
 import R0119 from "./01.19/_index.mdx";
 
+<R0317 />
+<R0306 />
 <R0221 />
 <R0212 />
 <R0119 />

docs/systems/async.md

@@ -192,3 +192,40 @@ When using `ETaskBinding::Unbound`, the first argument must always be the `IUnbo
 :::info
 You can also use `co_await` in non-capturing lambdas using `ETaskBinding::Lambda`, but we no longer recommend this task binding type because you can't capture locals and you need to perform any lifetime/validity checks manually.
 :::
+
+### Running asynchronous code on background threads
+
+You can specify what thread an asynchronous function should run on with a thread task policy as the third parameter to `TTask<>`, like so:
+
+```cpp
+TTask<void, ETaskBinding::Static, FBackgroundThreadTaskPolicy> MyFunction(float Seconds)
+{
+    // Print out a message.
+    UE_LOG(LogTemp, Warning, TEXT("This is running on a background thread."));
+
+    // co_return - always required, even in TTask<void> functions.
+    co_return;
+}
+```
+
+Whenever you `co_await` or use `AsCallback` to invoke `MyFunction`, the entire function runs on a background thread per `FBackgroundThreadTaskPolicy`. You do not need to manually schedule the work on a different thread, and the asynchronous task library ensures that the caller of `MyFunction` resumes on it's original thread when `MyFunction` completes.
+
+All types of asynchronous functions, including lambdas bound with `Bind()`, support thread task policies.
+
+The available thread task policies are:
+
+- `FCurrentThreadTaskPolicy`: This is the default when you don't specify a thread task policy, and results in the function running on the same thread as the caller.
+- `FGameThreadTaskPolicy`: This function will run on the game thread. If the caller is already running on the game thread, then the function is invoked directly. If the caller is not the game thread, this function will be scheduled to run on the game thread through an internal call to `AsyncTask(ENamedThreads::GameThread, ...)`.
+- `FBackgroundThreadTaskPolicy`: This function will run on a worker pool thread. If the caller is already running on a worker pool thread, then this function is invoked directly. If the caller is not a worker pool thread (e.g. it's the game thread), this function will be scheduled to run on the worker pool through an internal call to `AsyncPool(*GThreadPool, ...)`
+
+:::danger
+If the caller of an asynchronous function is running on a thread other than the game thread or worker pool, and that asynchronous function uses a thread task policy other than `FCurrentThreadTaskPolicy`, you will get an assertion when the function completes and tries to resume the caller on it's original thread.
+
+This is because `FCurrentThreadTaskPolicy` does not know how to resume work on threads other than the game thread or worker pool (see the `FCurrentThreadTaskPolicy::RunOnDesiredThread` implementation). If you require support for other types of threads, please let support know and we will update `FCurrentThreadTaskPolicy::RunOnDesiredThread` to support your use case.
+:::
+
+:::danger
+Deferred tasks created with `TTask<>::Deferred()` do not currently automatically return to the caller's thread upon `SetValue` being called. This makes certain functions such as `Delay` unsafe to call from a background thread.
+
+We plan on changing this in the future, so that deferred tasks automatically resume execution on the thread that `TTask<>::Deferred()` ran on.
+:::