Week of October 5 to October 11, 2026 | 1,168 commits on ue6-main, 92 on ue5-main, 113 on the public 5.8 branch | Branch: ue6-main

Overview

If you ship on 5.8, start with the last section of this post. On Monday the public 5.8 branch was bumped with “Update version for 5.8.4,” a commit carrying a #lockdown tag, and 108 cherry-picked fixes landed alongside it in one block. One of them says outright that it is a “Backport UE-395636 for the UE 5.8.4 hotfix candidate.” There is no 5.8.4 release tag yet (the newest is 5.8.3), so this is a hotfix candidate still being assembled. What is in it matters for build farms: a UBT fix for binaries that were not being relinked, a UAT log stall, a Horde path traversal fix, an iOS lifecycle default change for Xcode 27, and a Vulkan fence default flip that applies to desktop.

On ue6-main, this was a week of defaults. D3D12 residency management moved to a new tracker, opt-in on Monday and default by Thursday (c43ab669). Vulkan bindless now prefers descriptor heaps and shader objects (27c90725). The platform I/O dispatcher, which last week’s post reported as not enabled, is now on by default for game and client targets (b865826a). And the editor auto-starts its MCP server through per-user settings (9fb9185f). Lumen got a new runtime surface cache, LumenWorldCache (c249eca8), and in the same week lost its seven per-subsystem hardware ray tracing CVars (069e277d), so any config that toggled HWRT for one Lumen pass now does nothing.

At 1,168 commits, ue6-main had its busiest week since this briefing started tracking it in June, above the previous high of 1,072 for September 21 to 27 and last week’s 1,065. Among named subsystems, build leads at 99, followed by editor at 81, core at 72, rendering at 71, and platform at 40.

Development Trends

Agent tooling had its biggest week yet

Pattern: counted the way we counted last week (commits touching the toolset registry, the AI Assistant plugin, the experimental toolsets, AsyncFunctionResult, and ToolsetCore, by path or by name in the message, with mesh modeling toolsets excluded), the cluster came to 64 this week. Including the ModelContextProtocol plugin and a few incidental sweeps brings it to 79. The four prior weeks were 20, 30, 56, and 46. Either way, this is the highest of the five.

Interpretation: the new work gives agents more reach and more control over what they start. A new ToolCalls toolset lets the agent see and stop calls it backgrounded, with “ListRunning, GetResult, Cancel and CancelAll,” each “scoped to the conversation of the call that invoked it, so one conversation cannot read or stop another’s work.” (0551fdd9). A Knowledge Base plugin adds “a registry of providers with an in-memory SQLite/FTS5 index” (10061736). A FabToolset was added “for searching and installing Fab listings” (66b14bed). Sequencer and animation tools moved onto native scripting APIs, removing several Python toolsets (e4d068b7).

Most teams will notice the MCP server change. One commit, part of a change that starts Python at editor boot, removed the “UEFN MCP Toolsets experimental setting, project-gated Python registration shim, and MCP server auto-start helper” (e0a3c77f). The next day, another enabled “MCP server auto-start by default in the editor and UEFN through editor per-user settings, keeping the C++ default disabled for runtime targets” (9fb9185f). It lands as bAutoStartServer=True in BaseEditorPerProjectUserSettings.ini, and the commit does not say what the server binds to. If you run the editor on build agents or shared machines, decide whether you want it running there and override the setting if not.

Who cares: tools programmers, pipeline and automation teams, anyone responsible for what runs on editor machines.

Signal strength: Strong.

UBA volume fell, and authorship spread out

Pattern: counting commits whose paths touch UnrealBuildAccelerator, this week came to 13, the lowest of the five weeks we have counted (the priors were 37, 19, 36, and 19). Last week all 19 came from one engineer. This week the 13 came from six engineers, split 6, 3, 1, 1, 1, and 1.

Interpretation: last week we wrote that UBA was still one engineer’s work, and this week does not fit that reading. The work also leaned toward correctness (a wrong-size CAS entry, a heap overflow, a Linux deadlock), covered under Highlights. One week of broader authorship does not establish a pattern, so we will keep counting.

Who cares: build and CI engineers, anyone whose build farm depends on UBA.

Signal strength: Moderate.

Land opt-in, then flip the default within days

Pattern: three RHIs changed defaults. The D3D12 residency tracker landed as opt-in on Monday (65917c7e), took a startup crash fix on Tuesday (256bd31e), and became the default on Thursday (c43ab669). Vulkan bindless switched its preferred extension and enabled shader objects on Friday (27c90725). Mac enabled “the RHI thread by default at ES3_1” (4c5a115c). Outside the RHIs, the platform I/O dispatcher went default for game targets the same day its deadlock fix landed (a26cc9d9, b865826a).

Interpretation: this week, Epic did not leave these new paths behind opt-in flags for long. A regression after a sync can come from a default you did not change. The D3D12 and I/O dispatcher commits document a way back, listed under Highlights. The Vulkan and Mac commits do not.

Who cares: rendering and RHI engineers, anyone running performance or stability passes against ue6-main.

Signal strength: Moderate.

TL;DR

• If you ship on 5.8, a 5.8.4 hotfix candidate is being assembled. The version bump came with 108 cherry-picks. They include a UBT fix for external libs “preventing binaries from being relinked,” a UAT log stall, a Horde path traversal fix, and two default changes, iOS UIScene lifecycle and Vulkan r.Vulkan.CpuWaitForFence. Details are in the 5.8 section below.
• D3D12 residency now uses a new tracker by default. D3D12.ResidencyManagement went from 1 to 2. The commit says “Use D3D12.ResidencyManagement=1 to switch back” (c43ab669). It is read-only, so set it in config.
• Per-pass Lumen HWRT CVars are gone. Seven were removed, and “r.Lumen.HardwareRayTracing is now the only CVar to toggle between SWRT and HWRT” (069e277d). LumenWorldCache arrived as an opt-in replacement for card-based surface caching (c249eca8).
• The platform I/O dispatcher is on for game and client builds. UE_PLATFORM_IO_DISPATCHER_ENABLED “now defaults to UE_GAME instead of 0,” and “-NoPlatformIo disables the platform dispatcher at runtime” (b865826a).
• More defaults moved. Vulkan bindless prefers VK_EXT_descriptor_heap with shader objects on (27c90725). r.ShaderPipelines became read-only (efc31233). r.AVBOIT.SampleBias went from -2 to 0 (602f1317). Nanite visualization modes now need r.ForceDebugViewModes=1 outside editor and ODSC shader maps (87860b5e). Low and Medium shadow quality now use Stochastic PCSS for directional VSM (3bf20216).
• Expect one-time recooks. At least four commits announce them, including “one-time full recook” (a14aa680) and “one-time recook of all blueprint packages” (8d5abe19). A multithreaded save race that produced packages “with an empty header” is fixed (7ac3eb85).
• UBA served wrong file content on Mac helpers. A symlink’s size was stored against its target’s hash, so “Mac helpers served 15 bytes” and remote compiles failed (711b4de2). A heap overflow in long sessions is also fixed (5d50dc97).
• Check CI wrappers that key on exit codes. Invalid MRQ arguments now exit with an error code instead of crashing (b097d529), and Mac build-machine crashes exit “1 instead of 3” (4a65fd73). A title-only commit reads “[Mac] Require macOS 15 Sequoia” (8a45c509).

Highlights

D3D12 residency moved to a new tracker, opt-in Monday and default by Thursday

What changed

On Monday, “New D3D12 GPU residency tracker, replacing D3DX12Residency” landed with the line “Opt in with D3D12.ResidencyManagement=2; the default (1) keeps the existing D3DX12Residency path unchanged.” The commit describes it as “Much cheaper than D3DX12Residency on the submission and RHI threads” and says “The new tracker also covers work graphs, which D3DX12Residency never tracked, and frees their backing memory” (65917c7e). On Tuesday, a startup crash from “a bad robomerge resolve” was fixed (256bd31e). On Thursday: “Use the new D3D12 residency management code path by default,” with “Use D3D12.ResidencyManagement=1 to switch back to the D3DX12Residency library” (c43ab669).

The diff confirms the default moved from 1 to 2, and the help text now marks the RHICore residency tracker as the default. The CVar is read-only, read once at device creation.

Why this is important

A new residency implementation can change hitching, paging, and device-removed behavior without any change in your content, and the commits say nothing about behavior under memory pressure. If a D3D12 build on ue6-main starts stalling or losing the device after this sync, set D3D12.ResidencyManagement=1 in config first, since the CVar cannot be changed at runtime.

Who should care

D3D12 rendering engineers, performance teams, anyone triaging GPU memory issues on Windows.

Urgency

Act now if you profile D3D12 memory or see new stalls after syncing. Track otherwise.

Lumen added a runtime surface cache and removed its per-pass HWRT toggles

What changed

LumenWorldCache is described as an “automatic surface cache replacing previous LumenSurfaceCache relying on precomputed mesh cards.” It is “built at runtime by path tracing (by default 1/64 spp) from GBuffer and caching hits in sparse voxel cells” and “Requires ray tracing and hit-lighting (full/material ray tracing mode).” The claimed benefits include “No CPU overhead,” “x10 smaller memory usage,” and skipping the card cooking step. Measured on “FortGPUTestBed, console, 1080p, High scalability,” it came in “0.35ms slower indoors” and “0.4ms faster ourdoors” (sic). The “Missing functionality” list is long, including “Lumen hit-lighting support,” “Ambient Lighting Volume support,” and “Far Field support” (c249eca8).

One detail needs care. The message says to enable it with “r.Lumen.WorldCache.Support 1,” but the diff registers r.Lumen.WorldCache.Supported (default false), plus r.Lumen.WorldCache.Allowed (default true) for scalability and device profiles. Use the name in the diff.

Epic cleared the way in the same week. Two experimental paths, r.LumenScene.GPUDrivenUpdate (d9e01e2a) and r.LumenScene.DirectLighting.Stochastic 1 (771669e4), were removed for “fundamental issues” that “weren’t ever solved,” and both commits name LumenWorldCache as “a more promising approach.”

Then the per-subsystem HWRT toggles went. “Those CVars were added during the initial HWRT bringup for debugging but they don’t make much sense anymore (nor they work well),” and “r.Lumen.HardwareRayTracing is now the only CVar to toggle between SWRT and HWRT” (069e277d). The diff removes seven:

• r.Lumen.RadianceCache.HardwareRayTracing
• r.LumenScene.Radiosity.HardwareRayTracing
• r.Lumen.Reflections.HardwareRayTracing
• r.LumenScene.DirectLighting.HardwareRayTracing
• r.Lumen.ScreenProbeGather.HardwareRayTracing
• r.Lumen.TranslucencyVolume.HardwareRayTracing
• r.Lumen.Visualize.HardwareRayTracing

Why this is important

The CVar removal hits config today. A project that ran HWRT reflections but software tracing for screen probes, or turned HWRT off for one pass on a lower-end device profile, loses that split, and the ini lines stop doing anything. Search your config and device profiles. WorldCache is opt-in, needs full ray tracing, and still has gaps, but the removals show where Lumen is heading. If you have built anything on mesh card data, watch it.

Who should care

Rendering engineers, technical artists shipping Lumen with HWRT, anyone with Lumen CVars in device profiles.

Urgency

Act now if your config sets any of the seven removed CVars. Track WorldCache.

Defaults that moved this week

What changed

• Vulkan bindless prefers descriptor heaps and shader objects. “VulkanRHI: Change default to shader_objects and descriptor_heaps for bindless” (27c90725). The diff changes r.Vulkan.Bindless.PreferredExtension from 0 to 1 (VK_EXT_descriptor_heap) and r.Vulkan.AllowShaderObject from 0 to 1.
• The platform I/O dispatcher is on for game and client targets. “UE_PLATFORM_IO_DISPATCHER_ENABLED now defaults to UE_GAME instead of 0. Game and client targets use the platform I/O dispatcher; server and editor targets keep the existing I/O path.” The commit adds that “-NoPlatformIo disables the platform dispatcher at runtime” (b865826a). It landed right after “Fixed I/O dispatcher deadlock when running with the new platform dispatcher” (a26cc9d9).
• The editor auto-starts its MCP server. Covered under Development Trends (9fb9185f). The C++ default stays disabled for runtime targets.
• r.ShaderPipelines is read-only. Material shader pipelines are no longer compiled where the CVar is off, which the commit says includes Windows. “r.ShaderPipelines is now read-only, since toggling it on at runtime would find no pipelines and fall back to the default material” (efc31233). The code default stays 1, but the commit notes Windows runs with r.ShaderPipelines=0.
• AVBOIT sample bias went from -2 to 0. The diff changes r.AVBOIT.SampleBias from -2.0 to 0.0, part of a transmittance fix covered below (602f1317).
• Nanite visualization needs a flag in packaged builds. The raster VISUALIZE permutations now compile only “for editor and ODSC shader maps (or r.ForceDebugViewModes=1),” and the visualizations that need them are disabled elsewhere. Development builds show “an on-screen message” when one is requested but unavailable (87860b5e).
• Directional VSM uses Stochastic PCSS at Low and Medium shadow quality. Set through BaseScalability.ini, covered below (3bf20216).
• Win64 links write the PE checksum. WindowsTargetRules.bSetImageChecksum now defaults “to true for Win64,” for non-incremental links. Covered under the Wine fixes below (62be1807).

Why this is important

The Vulkan change switches the descriptor model and the pipeline object model at once, so test it first. The I/O dispatcher affects every packaged game build. If you see new loading hangs, -NoPlatformIo is your first bisect step. QA and performance teams that use Nanite visualize modes in packaged Development builds will need r.ForceDebugViewModes=1 for the target platform.

Who should care

RHI engineers, Vulkan teams, anyone shipping packaged builds from ue6-main, QA and performance teams.

Urgency

Act now on Vulkan and the I/O dispatcher if you run either. Track the rest.

Nanite culling was rewritten, and translucency got correctness fixes

What changed

Nanite has a “New faster Nanite multi-pass culling implementation with SIMPLE/COMPLEX shader classification, adaptive fanout and cluster range encoding.” Instances needing expensive features such as skinning or WPO are classified COMPLEX and traversed by a separate permutation. The commit says “This new culling path is now used everywhere and the old persistent culling path has been removed,” and that “Performance tends to be at slightly better or at parity on tiny scene, but significantly better for even moderately large scenes.” New controls: r.Nanite.Culling.Classification (default 1) and r.Nanite.Culling.AdaptiveFanoutThreadBudget, “0 to disable” (ad75acf2).

On translucency, an AVBOIT and MLAB fix corrects three visible problems. The old -2 slice bias “also discarded real occluders - geometry behind one slice of glass kept an untinted highlight,” and now “the bias defaults to 0.” On MLAB’s separate translucency path, the background was attenuated twice, “so a measured green of 0.24 reached the screen as 0.02.” And the combine sample array was resized to cover r.OIT.SortedPixels.MaxSampleCount, “which previously sorted out of bounds at 9 or 16” (602f1317).

For low-end platforms, directional VSM gained a Stochastic PCSS projection, “usually taking less than half the time” of SMRT at reduced quality, with no local light support yet. The CVar’s code default stays SMRT, but the diff sets r.Shadow.Virtual.ProjectionMethodDirectional=1 in BaseScalability.ini at Low and Medium shadow quality, so those levels now use SPCSS by default (3bf20216).

Why this is important

There is no fallback to the old Nanite culling path. If your GPU frame time moves after this sync, in either direction, this is a likely place to look, and r.Nanite.Culling.Classification and the fanout budget are the knobs to bisect with. The AVBOIT change alters how translucency looks: anything tuned against the old bias, or against MLAB’s double attenuation, will render differently. And if you ship at Low or Medium shadow quality, directional shadows now use a different, cheaper projection unless your own scalability config sets the CVar back to 0.

Who should care

Graphics programmers, technical artists working with translucency, low-end platform teams.

Urgency

Track. Re-check translucent content if you use AVBOIT or MLAB, and directional shadows if you ship Low or Medium shadow quality.

UBA: a wrong-content CAS entry, a heap overflow, and Wine farm fixes

What changed

The UBA fix with the most visible symptom is for Mac helpers. With symlink support on, “a symlink’s size is its target path length.” PopulateCasFromDirsRecursive “hashed the link target’s content but stored the link size, so a CAS entry could advertise the wrong size.” In practice, “Xcode’s usr/include/sched.h -> pthread/sched.h (15 bytes) shares a CAS key with AutoSDK AppleOSS sched.h, so Mac helpers served 15 bytes and remote compiles failed with” an unterminated /* comment error (711b4de2).

Other correctness fixes:

• Heap overflow. A fixed 1M-entry array “was written past its end when a directory chain grew longer (one link per mtime change, e.g. frequently touched lock files in a long session)” (5d50dc97).
• Linux deadlock. “Linux: fix opendir/fstat deadlock” (3573b6fc).
• ParkingLot race. A race in TimedWait caused “the later wait to end too early” (e0106d20).

For Wine-hosted builds, two large fixes. On hosts with more than 64 logical processors, wineserver’s default affinity “pins every Wine thread, and therefore every spawned cl.exe/UbaObjTool.exe, to CPUs 0-63.” A preloaded shim fixes that, with a caveat: “A wineserver started earlier without the shim (e.g. by running any Wine program first) keeps the 0-63 pinning until it exits; ‘wineserver -k’ before building clears it” (fce0c399). And because editor DLLs carried a zero timestamp and checksum, “Every module load therefore made one server round trip per loaded module, which scales with the square of the module count: about 621k calls during editor startup.” UBT now writes the PE checksum for non-incremental Win64 links (incremental links still skip it), which fixed it. Under Wine 11.7, “Windows_LoadLibrary: 21.6s -> 5.9s (982 loads)” and “Cook wall time: about 110-116s -> 97s.” The commit says “native behavior is unchanged” (62be1807). A related fix for Wine cooks against UBA Horde agents, where “every distributed job failed,” keeps “existing Windows hashes and DDC keys” unchanged on native Windows (9719af0c).

Two protocol changes. SessionNetworkVersion went to 68 with arm64 Wine helper and cross-architecture scheduling fixes (fb715dd6), then to 69 with keyed process reuse, where “processes without a key are not reused” and “The UbaController change that sets the key for ShaderCompileWorker must land with or before this” (6366bbe2). UBT now requests cross-architecture workers (534aa3cd).

Why this is important

If Mac remote compiles have failed on a stray comment error, take the CAS fix. The heap overflow needs a long session with frequently touched files, the example the commit gives. With the network version bumping twice in one week, update hosts and helpers together. The commits do not say how mismatched versions behave. If you build under Wine on large machines, start wineserver through a launcher that preloads the shim (the commit says ushell’s .build --wine does), and run wineserver -k first if one is already running.

Who should care

Build and CI engineers, build-farm owners, anyone running Mac, Linux, arm64, or Wine helpers.

Urgency

Act now if you run UBA with Mac helpers or Wine on more than 64 cores. Track otherwise.

Cook and staging: an empty-header race, shader library collisions, and a run of one-time recooks

What changed

Under multithreaded save, a process-wide guard for unversioned content raced across save threads. “The guard that ends first restores 0 while another thread is still reading its summary; that read stops early and the optimizer produces the package with an empty header (no name map, imports or soft references), logging only a warning.” The allowance is now per package, and “A bad cooked summary is now Fatal, not a warning plus a broken package” (7ac3eb85).

Staging and packaging fixes:

• Named pakchunks and shader libraries. Sub-containers of a named pakchunk resolved “to the same shader library as the base container and closing it on unmount.” The mangled id also used “CityHash64 & 0xFF, a 1-in-256 collision that could skip opening a library” (b1794cbc).
• Mac and Linux staging. “On Mac/Linux, DirectoriesToAlwaysStageAs* entries using Windows path separators are never found, so their contents go unstaged.” On one test, “Unable to find directory” warnings dropped “from 21 to 5” (94f3ceb6).
• DDC graph forwarding. -ddc=<graph> “was passed to the cook and run commandlets but never to UnrealPak, so UnrealPak always used the project’s default DDC graph” (931595fd).

Plan for recooks. Several commits announce one-time invalidations:

• “Incremental cook impact: one-time recook of all blueprint packages” (8d5abe19).
• “Incremental cook impact: one-time full recook. The global dependencies hash changes for every cook, in every reachability mode” (a14aa680).
• “one-time recook of generated packages whose digest included transient or subsystem classes (WP cells with world subsystems)” (c5a81cbb).
• Two CookIncrementalVersion bumps, both for a “Native change not picked up” (40579ca1, f10e20cc).
• Shader source files are now hashed with FShaderHash, which “bumps shader map cache versions as a safety measure” (6bfb22a7), so expect a shader recompile as well.

Two cook behavior changes apply without opting in. Loaded packages kept loader read buffers until GC, “which costs several GB of commit per cook process.” The flush now applies to “every cook-by-the-book cook outside the editor” (2cde43c5). A multithreaded save safety change notes, “This changes load timing for the default single-threaded cook too,” and cooks no longer write GatherableTextData (27b85436).

Why this is important

The empty-header bug produced a broken package with only a warning. If you cook with multithreaded save, take this fix and treat any packages from affected builds as suspect. The shader library collision “could skip opening a library.” On Mac or Linux staging hosts, check whether DirectoriesToAlwaysStageAs* entries with backslashes were ever staged. Schedule the recooks: one full recook, one of every blueprint, and a shader recompile are all in this week’s range.

Who should care

Build and release engineers, platform teams staging on Mac or Linux, anyone running multithreaded save or incremental cooks.

Urgency

Act now if you cook with multithreaded save or stage on Mac or Linux. Plan for the recooks.

CI exit codes, toolchain floors, and Horde

What changed

Exit codes your wrappers may depend on:

• Movie Render Queue. Invalid command line arguments “previously hit a Fatal log (crash, crash report). They now log an Error and exit with the existing MoviePipelineErrorCodes value (NoAsset = 2, NoConfig = 3, Critical = 1)” (b097d529).
• Mac build-machine crashes. “Mac build machines installed a log-only crash handler, so a farm crash left no CrashReport-UE-* folder for Gauntlet to collect.” Now “build-machine crashes write the report folder and skip CrashReportClient, exiting 1 instead of 3” (4a65fd73).

Toolchain changes:

• Enforced minimums. UBT published its current floors: “MSVC 14.44.35211,” “Windows Clang 20.1.8,” “Linux Clang 20,” “Android NDK r27c, Clang 18.0.3,” and “Xcode 26.1.1, Apple Clang 17 or later, LLVM 19.1.5 or later” (18dae879).
• MSVC 14.51. “UnrealBuildTool: Remove MSVC 14.51 from preferred” (37a2daf1). See the follow-up under Worth Tracking.
• macOS 15. “[Mac] Require macOS 15 Sequoia” (8a45c509). bEnableOSX109Support is now deprecated and ignored (4753eda2).
• Clang warnings as errors. “Clang’s -Wno-error=X overrides -Werror regardless of argument order, so these warnings stayed warnings.” Warning-level CppCompileWarnings now become errors under bWarningsAsErrors (2599812f).
• Build.sh. Mac and Linux now refresh UBT before use and serialize Build.sh per engine: “Concurrent runs wait” (3ccad7e7).
• Smaller fixes. A race writing PGO sidecar files during makefile creation on clean workspaces (551c4523), and a missing space that was “preventing -icf=all from working on Android” (7b9d5661).

Horde:

• Secrets in debug endpoints. “The config, app settings and environment debug endpoints returned secrets in clear text, also secrets resolved from the secret store.” They now show “[redacted]” (76e3d23a).
• Upgrade ordering. Tool deployments now stay pending until their archive is built. The commit warns: “Hold tool uploads until all servers run this version, because older servers do not know the pending state” (67c42f3a).

Why this is important

If you build with warnings as errors on clang, this change can fail builds that previously passed, with no code change on your side. The exit code changes break the opposite way: a script that waited for a crash or matched exit code 3 on Mac will now misread the result. If you self-host Horde, upgrade for the redaction fix, consider whether anyone could reach those debug endpoints, and rotate secrets if so. Then upgrade every server before uploading tools.

Who should care

Build and CI engineers, render farm owners, Horde administrators, Mac and Linux build owners.

Urgency

Act now on Horde secrets and on clang warnings as errors. Check MRQ and Mac crash wrappers at your next sync.

Worth Tracking

New BCn realtime encoders. “New, higher-quality BCn realtime encoders” come in three levels. Level 1 costs “about 15-20% extra compute” over the lowest level. The sRGB entry points now “convert all pixels to encoded space first, which is more expensive but can make a quite significant difference depending on content” (3e4dc512). The commit does not list which call sites use the new encoders, so check any GPU texture compression you rely on.

Ray tracing enablement semantics. IsRayTracingEnabledForProject and ShouldCompileRayTracingShadersForProject “aren’t affected by runtime settings when running non-editor executable” (b2d94575). IsRayTracingEnabled(EShaderPlatform) “now takes project settings into account,” and passes should use CanUseRayTracingShaders and CanUseInlineRayTracing at runtime (a73d5cc6). Custom ray tracing shaders should no longer use Hit.InstanceID or GetInstanceUserData() directly as a GPU Scene instance id, and should go “through DecodeRayTracingInstanceId(…)” (b083d033). If you maintain custom ray tracing passes, read all three.

PCG Component Lite and UnrealConsole. PCG Component Lite went from P9 to P11 this week, adding “editor discovery, details actions, preview controls and debugging” (3344fa1a), interactive and manual-edit tools (0087d60c), and editor partitioning (8e742167), plus a “PCG Volume Lite that will instantiate a PCG Component Lite” (5a53d40b). A new switch, ShouldUsePCGVolumeLite(), now chooses between Lite and legacy volumes (f84cac56), but no commit states its default or a migration path. UnrealConsole, the headless editor host we flagged last week, kept moving: ULevelEditorSubsystem methods “now act as if no level editor is open, instead of check()ing or dereferencing null” (d3cf44c5).

Two follow-ups on last week’s post. Last week we reported that the change enabling the new platform IO dispatcher on all platforms was backed out with no reland, so the new dispatcher was not enabled. This week it is on by default for game and client targets, after a deadlock fix (a26cc9d9, b865826a). Server and editor targets keep the old path. We also covered MSVC 14.51 being made the preferred toolchain and then banned for a miscompile. This week it was removed from the preferred list (37a2daf1), and the diff adds a SuggestedVisualCppVersion so the ban error no longer suggests a banned toolchain. Two other items we flagged last week, the occlusion feedback opt-in and the renamed ray-traced skinning cache CVars, had no new commits.

What We Ignored

This week we ignored most of the 1,168 commits: Verse and UEFN work, scene graph changes, Python API expansion, Niagara editor polish, test automation tooling, Mesh Partition churn, IoStore on-demand container TOC patching, and narrow editor crash fixes. There were 17 commits tagged [Backout], against 24 last week, inside the normal band for this branch. Most relanded in-window.

Three that did not come back are worth naming, because their titles make them sound shipped. “[Component visualizers] Enable ITF Visualizers by default” (ee128853) was backed out (3dae15ca), so that default did not change. “Niagara - Fix crash when a GPU stage only reads an array data interface that another GPU stage in the same system writes to” (3b713266) was backed out (0639068e), so that crash is still unfixed on this branch. And “Linux: Rectify stacktrace cutoff-frame semantics” (a6a58aff) was backed out (da381317), so Linux stack trimming is unchanged.

A few one-liners. A network ping bug wrote “into freed memory, which surfaced as heap corruption in unrelated systems (e.g. Slate FTextLayout teardown) on the Connecting screen” when two or more ping types were configured as moving averages (3ce03197). Perforce source control disabled the p4api signaler outside Windows, citing “evidence” that “concurrent connections corrupt the heap on Linux in particular” (d574ddfd). “Fixed vulnerability issue in InterchangePSDTranslator,” with no further detail in the message (4310366a). And the legacy Project Launcher was removed (92cf4524), along with its “deprecated Project Launcher and Launcher Services APIs” (70c92023).

For teams shipping on 5.8

On Monday, October 5, the public 5.8 branch took “Update version for 5.8.4” (8ef25888), which changes the patch version from 3 to 4 and carries a #lockdown tag. It came with 108 cherry-picked fixes, all dated the same day in one contiguous block of changelists. One of them is explicit: “Backport UE-395636 for the UE 5.8.4 hotfix candidate: prevent stale editor-instance access in UAssetEditorSubsystem::CloseAllEditorsForAsset,” noting “Static compatibility checked against Dev-Release-5.8” (f1190727). There is no 5.8.4 release tag yet. The newest is 5.8.3, so treat this as a candidate that can still change. Of the 113 commits, 4 are Localization Automation and none is a backout. About 30% of them (33 of 108) match the titles of fixes that were on ue5-main or ue6-main last week. About one in five of the rest (16 of 75) carry cherry-pick tags pointing at older changelists.

In the 5.8.4 candidate

• UBT was not relinking binaries when external libs changed. The FirstOrDefault check “was not equivalent to Contains’ behavior. This was breaking the timestamp check on external libs and preventing binaries from being relinked” (1fb9a4a0). If you link prebuilt external libraries, incremental builds could have shipped stale binaries. Take this one first.
• UAT log output stalled. A bare = toolchain separator was mistaken “for an ASAN report header,” which “stalls all UAT log output until the LogEventParser 1024-line cap” (451845be). Separately, UAT now starts commandlets with a UTF-8 environment, fixing “garbled output from the commandlets when running UAT on a system that is set to a non-latin codepage (Japanese, Chinese…)” (8c37fa5d). Last week this fix was on ue5-main only.
• Horde path traversal. “Horde: Prevent path traversal when extracting artifact and workspace contents.” Anything that “would resolve outside the target directory now fails closed and aborts the operation instead of writing the file” (b3f8a2e2). A security fix for anyone running Horde on 5.8.
• Virtual texture DDC crash after a full disk. “If the disk was full (or on other IO errors) the temp file was left short but still flagged as available,” and “The existing file validation only hashes the first 32 KB, so a file truncated beyond that passed validation on later editor runs and kept crashing” (6fc486ee). Build machines with tight disks should take this.
• iOS UIScene lifecycle is now the default. “Switch iOS client to use UIScene lifecycle by default to avoid crash on start. When an iOS app is compiled with Xcode27, iOS27 enforces use of UIScene” (915fcb2f). The diff sets bUseSceneBasedLifecycle=True in BaseEngine.ini. The C++ default stays false, so projects that explicitly set it to False in their own config keep the old lifecycle. The header calls it compile-time only, so a rebuild is required after changing it.
• iOS finalize on macOS 27. iOS .app finalize failed with a “Bad file descriptor” error on macOS 27. The build executor spawned actions without stdin, and xcodebuild “then cannot launch /bin/sh for a scheme’s script phases” (269b89a9).
• Vulkan fence default flipped. The message reads “change the default for r.Vulkan.CpuWaitForFence to use semaphores on desktop” (1ad8824e). The diff changes the code default from 1 to 0 with no platform check. Android already set 0 through AndroidEngine.ini, so in practice desktop Vulkan (Windows and Linux) is what changes. The CVar is read-only. To restore the old behavior, set r.Vulkan.CpuWaitForFence=1 in config.
• D3D12 enhanced barriers. “Fix enhanced barrier layout selection and synchronization,” a manual integration of three changelists. Queue-specific layouts meant “resources transitioned on one pipe were left in layouts invalid to consume on the other,” and transient aliasing acquires now synchronize “with SYNC_ALL” (9d10f6af). Relevant if you use async compute on D3D12.
• Shader preprocessor heap overread. “a source with an unmatched quote or apostrophe therefore scanned past the NUL terminator into adjacent heap memory,” traced to “material custom node text.” Such files now report “Unclosed string literal.” (b3eb2d65).
• Linux crash reporting. “Stop Linux crash reporting from exhausting the crash allocator’s large pool.” A new unix.CaptureAllThreadStacksMaxChars bounds the all-thread dump (5d863562). The diff sets it to 96 * 1024 characters by default, with 0 meaning unbounded.
• RigVM editor-only data in cooked packages. The editor asset was created RF_Public, so “the editor asset and its model/EdGraph tree were saved into cooked packages, producing missing class errors for ControlRigDeveloper/RigVMDeveloper types on load.” PostLoad now clears the flag “so existing assets are fixed too” (9576cbc6). ue5-main already had its own fix and took only the PostLoad cleanup for older assets, as a “Partial forward port” (049211f1).
• DDC-dependent output. Substrate Toon materials lost a GBuffer write “when fetching from DDC” (74bd88e7), and Mutable’s DDC value changed “from compilation to compilation” (ee0e70f0).
• Crashes and regressions. An XSX “EOS delay-load crash on launch with modern GDK folder layout” (4c0f5eda), alongside an EOSSDK 1.19.2.1 binary update that lists deprecated console SDKs “to be removed in a future release” (5da24655). A Mac editor exit crash whose crash group “reports 37 users and 37 occurrences on 5.8.x” (5561a4c5). A Sequencer world leak that “fatal errors as a world leak” when a level containing a level sequence actor is removed (17f4598e). A Promote To Variable rename bug that “regressed in 5.8” (f7583e0b), and Mover “concurrency-related crashes” (9bb4abbe).
• Fixes we flagged earlier. The landscape edit layers assertion “when two landscape components overlap,” whose message notes “New functions intentionally omit LANDSCAPE_API to make the CL hotfix compatible” (5eb15c8c), is in the candidate. Last week we guessed it was headed for a hotfix. The CEF update that “Fixes editor crashes when the GPU process is reported as unusable” is in too (3d8fd89f).
• Editor quality of life. A Control Rig fix cuts a save stall in Animation Mode that scaled with the number of characters. The repro “goes from 11-17s to 1.7s” (5a62d8e6). A PCG refresh fix adds pcg.ActorTracking.EnablePreviousDataCleanupHotFix, on by default in the diff, as a guard “if it ever has side effects” (3b767ba6).

On ue5-main only

ue5-main ran 92 commits with three backouts, one of them relanded in-window. None of the items below carries a message saying it is headed for 5.8.x.

• Force delete crash. Force-deleting an asset whose editor edits more than one of its objects “closed the editor once per listing, and the first close destroys the toolkit, so the second ran on freed memory” (06cc4cd6).
• Control Rig duplicate and paste. A regression where “every derived field was dropped on duplicate and paste,” so “A duplicated control lost its limits, rotation order and min/max” (d1ba8344).
• Cook determinism. Package access tracking fixes for recording “that depended on load order, GC timing and which process (director or CookWorker) saved the package, which caused spurious and missed incremental recooks.” Expect a “one-time recook of most blueprints” (4425f181).
• Sequencer spawnables. “Spawnables vanish permanently after undoing a space switch compensation” (77f056f7).
• Smaller fixes. A water info LOD gather that “crashed the editor whenever a water zone rendered its info texture” (5263eb77), and a “noisy/black thumbnail when enabling separate translucency” (ae65f725).
• Gaussian Splat came over from UE6. Seven batches merged “//UE6/Main Gaussian Splat work into //UE5/Main,” one of which includes “Enable the GaussianSplat plugin” (d7ec4548).

Closing

The 5.8.4 candidate is the part of this week most readers can use right now, and it is still open. On ue6-main, if behavior changes after this sync, check the defaults above before you start bisecting.

Commit SHAs are cited inline, in parentheses, next to each claim. They reference the ue6-main branch of EpicGames/UnrealEngine, except in the “For teams shipping on 5.8” section: there, items under “In the 5.8.4 candidate” reference the public 5.8 branch (the forward port 049211f1 is on ue5-main), and items under “On ue5-main only” reference ue5-main.

Week of September 28 to October 4, 2026 | 1,065 commits on ue6-main, 123 on ue5-main | Branch: ue6-main

Overview

On Thursday, Windows_SDK.json added “14.51.36231-14.51.99999 as the top preferred MSVC range so UnrealBuildTool selects it when installed” (b9836eed). On Friday, the same file banned it: “Ban MSVC 14.51 due to an optimizer miscompile causing memory corruption and HeadlessChaos cluster assertions. Reproduced with cl 19.51.36260; /d2SSAOptimizer- avoids the failure.” (71b4bbb5). Epic caught a compiler bug in its own build within a day of choosing that compiler. If your build machines picked up 14.51 on their own, check that first.

Much of the rest of the week changes what your build or game does without producing an error. The ray-traced skinned mesh cache renamed its console variables, and the commit says outright that “project ini overrides of the old names are ignored” (95930ecc). PSO precache deferral went on by default (7cc9b379), Mac bindless went on by default (d0841228), and a mesh pass sort key had been returning 0 (69b6a2af). The cooker also got a run of incremental correctness fixes, including one that recooked “every Blueprint deriving from a class with SparseClassDataTypes” on each incremental cook (fd0a139c).

At 1,065 commits, ue6-main came in just under last week’s 1,072, the busiest week since this briefing started tracking it in June. Among named subsystems, build leads at 104, followed by editor at 86, rendering at 69, and core at 67.

Development Trends

Agent tooling eased off its peak, and kept building out

Pattern: counting commits that touch the toolset registry, the AI Assistant plugin, the experimental toolsets, AsyncFunctionResult, and ToolsetCore (by path or by name in the message, with mesh modeling toolsets excluded), the cluster came to 46 this week, against 56 last week, 30 the week before, and 20 the week before that. It is off last week’s high and still more than double the early September count.

Interpretation: the work moved from structure to behavior. A new MediaToolset plugin adds “four read-only AI-callable tools: ReadImageFile, GetVideoInfo, SkimVideo and SampleFrames,” with video decoding through Media Foundation “gated on PLATFORM_WINDOWS” (03b4fb0f). ObjectToolset now refuses writes to class default data a Blueprint does not own. Before, “an agent could write to a native CDO like Default__StaticMeshActor, or one of its default subobjects, and change every object of that class created for the rest of the session” (a1e938cf). Agent undo got sturdier: each tool call’s edits now go into their own buffer (7406cee2), and undoing through the EDA “now reverts unconditionally, hand edits included” (c9b057b6). One change did not stick: AllToolsets, EditorToolset, and AnimationAssistantToolset were restricted to desktop platforms early in the week (ff17b2f4), and the restriction was reverted on Friday, “removing SupportedTargetPlatforms from the AllToolsets, AnimationAssistantToolset, and EditorToolset plugins” (258545c3). We are watching UnrealConsole most closely, covered under Worth Tracking.

Who cares: tools programmers, pipeline and automation teams, anyone scripting the editor through the toolset APIs.

Signal strength: Strong.

UBA is still one engineer’s work

Pattern: counting commits touching UnrealBuildAccelerator the same way each week: 37 with 29 from one engineer (Sep 7 to 13), 19 with 10 from a second engineer and 7 from the original (Sep 14 to 20), 36 all from the original (Sep 21 to 27), and 19 this week, all from the same engineer behind last week’s 36.

Interpretation: last week we dropped our handoff reading, and this week supports that. Volume fell to 19, but authorship did not change. The work is mostly Linux and Ninja: Go and static-glibc syscalls routed through UBA’s virtual filesystem (47ff3089, 4d7e530e, a8fbc0eb), generated Ninja dependencies kept so “consumers rebuild after changed generators” (a2c1462d), and oversized static command lines that “fail cleanly with E2BIG” when they still do not fit (f987c8ac). The storage proxy fix in Highlights is the one most farms should take.

Who cares: build and CI engineers, anyone whose build farm depends on UBA.

Signal strength: Moderate.

Cook correctness, and DLC cooking in particular

Pattern: twelve commits this week open with “Cooker:”, most of them under one DLC ticket, alongside a set of incremental cook fixes and a merge of determinism fixes from Main. The low tier alone carries about 25 cook determinism commits, a series from one engineer among them.

Interpretation: the commits suggest Epic is making incremental cooks something it trusts for shipping as well as iteration. Several fixes close cases where an incremental cook either did too much work or skipped work it should have done, and the DLC series adds warnings for content a DLC cook depends on but did not cook.

Who cares: build engineers, release managers, anyone running incremental or DLC cooks.

Signal strength: Moderate.

TL;DR

• Check which MSVC your Windows build machines are using. 14.51 became the top preferred range on Thursday (b9836eed) and was banned on Friday for “an optimizer miscompile causing memory corruption and HeadlessChaos cluster assertions” (71b4bbb5). 14.50 remains available.
• The ray-traced skinned mesh cache CVars were renamed, and old names are ignored. r.Skinning.RayTracingCache is now r.Skinning.Cache.RayTracing (95930ecc). Refits now default to an unlimited budget instead of the old “250k triangles per frame” cap (3bd88216), and a new r.Skinning.Cache.RayTracing.BudgetMB defaults to 256 (98f9acf2).
• An occlusion feedback regression fix is off by default. With r.OcclusionFeedback.Enable=1, spurious visible verdicts kept re-arming skeletal pose ticking and Niagara visibility work. The fix sits behind r.OcclusionFeedback.UntestedAsIndefinite, “(default 0)” (46ea29b0). If you run occlusion feedback, opt in.
• Incremental cooks got more correct. Blueprints with sparse class data were recooked on each incremental cook (fd0a139c), and a comparison bug “led to missed incremental recooks” (2e1c5832). The determinism merge from Main shipped after one backout (78a2556e).
• Several defaults moved. r.PSOPrecache.DeferUntilPostLoad is on (7cc9b379), Mac bindless is on (d0841228), two Chaos user data fixes default on (f5ecfea2, 0b2283ee), and the Sequencer landing mode went from 2 to 3 (868a4600).
• UBA’s storage proxy could hang fetches “until 10 minute timeout” and leave helpers looping (94dbca45). Launch On iteration lost about 4 seconds without AutoSDK (d65c5690) and about 2 seconds on Android (d42c6f51).
• If you ship on 5.8: an XSX EOS delay-load crash on launch, garbled UAT commandlet output on non-Latin build agents, a Lumen atlas cleared each frame while a SceneCapture2D renders, and a hotfix-compatible landscape edit layer fix are in the 5.8 section below, with commit references.

Highlights

MSVC 14.51 was preferred, then banned

What changed

Two commits a day apart, in changelist order. First, “Windows_SDK.json: prefer MSVC 14.51,” adding “14.51.36231-14.51.99999 as the top preferred MSVC range so UnrealBuildTool selects it when installed. 14.50 and 14.44 remain as fallbacks.” (b9836eed). A companion commit fixed 14.51 validation warnings (4a4575f1). Then: “Ban MSVC 14.51 due to an optimizer miscompile causing memory corruption and HeadlessChaos cluster assertions. Reproduced with cl 19.51.36260; /d2SSAOptimizer- avoids the failure. Valid installed toolchains, including 14.50, remain available.” (71b4bbb5).

Why this is important

A miscompile that shows up as memory corruption does not fail the build. It can ship and surface later as a crash that is hard to trace back to the compiler. The message cites HeadlessChaos cluster assertions as the symptom Epic saw. If a Windows build machine installed 14.51 and your engine version was between these two commits, or if you set toolchain preferences yourself, check the compiler version in your build logs. The commit names a workaround flag, /d2SSAOptimizer-, but the engine’s answer is to not use 14.51 at all.

Who should care

Build engineers, CI owners, anyone maintaining Windows build images.

Urgency

Act now if any Windows build machine has MSVC 14.51 installed.

The ray-traced skinned mesh cache was rebuilt, and its CVars renamed

What changed

Four commits from one engineer rebuilt the ray tracing cache for animated instanced skinned meshes (ISKM). Storage became demand-driven: “only active slots own a block and a BLAS, so memory follows active slots and inactive slots are never skinned or built” (781f4415).

The cache then moved onto the shared dynamic geometry budget. The commit flags a “Behavior change with default settings: the manager’s budget is unlimited by default, so every visible cache slot is refit every frame (previously capped at 250k triangles per frame by r.Skinning.RayTracingCache.MaxTrianglesPerFrame).” It measured “cache skinning 0.01 -> 0.21 ms p50” on its perf test level and says “Projects that relied on the old cap should set r.RayTracing.DynamicGeometry.MaxUpdatePrimitivesPerFrame.” It removed r.Skinning.RayTracingCache.MaxTrianglesPerFrame and r.Skinning.RayTracingCache.RebuildInterval, and fixed “a latent cross-queue race with r.RayTracing.AsyncBuild 1” (3bd88216).

The same day, the names changed: “Impact: renamed console variables, so project ini overrides of the old names are ignored.” r.Skinning.RayTracingCache became r.Skinning.Cache.RayTracing, MaxInitialBuildTrianglesPerFrame, PageSizeMB, and PageIdleFrames moved under r.Skinning.Cache.RayTracing.*, and r.Skinning.RayTracingCache.Audit became r.Skinning.Cache.Audit (95930ecc).

Two days later, slots got per-slot LODs and a scene-wide memory budget, r.Skinning.Cache.RayTracing.BudgetMB “(default 256, 0 = unlimited).” Nearby instances now “trace finer LODs (the cache used the coarsest LOD),” and scenes over budget trace their farthest instances with static geometry: “a 10,000 instance crowd: 642 MB -> 256 MB.” Render thread cost of the update is quoted at “0.18 ms for 4,000 instances, 0.50 ms for 10,000 instances (Development)” (98f9acf2).

Why this is important

Two separate changes can bite here. A config file that sets any r.Skinning.RayTracingCache.* variable now sets nothing, with no error. And with default settings, refits are no longer capped, which the commit itself says “costs more GPU with many animations.” If you tuned crowds against the 250k cap, your GPU budget moved. The commit also notes that at a matched 250k budget “GPU cost is unchanged and cache CPU time in the scene update drops 20-88%,” so setting the shared budget explicitly gets you the old cost with the new scheduling.

Who should care

Graphics programmers, technical artists running large animated crowds under ray tracing, anyone with skinning cache CVars in config.

Urgency

Act now if your project config sets any of the old CVar names or relied on the 250k refit cap. Track otherwise.

The chunk assigner can now be enabled from a project setting

What changed

Client and game targets can now turn on the oplog chunk assigner with a project setting, [/Script/UnrealEd.ProjectPackagingSettings] bRunChunkAssigner, which the commit adds to BaseGame.ini as “Default False.” DLC reads the plugin’s Config/Game.ini first. “Dedicated servers only run it with -RunChunkAssigner / -ChunkAssigner=.” The commit message reads as if the setting replaces the flag, but the diff shows otherwise: the flag’s help text now says it forces the assigner “for every target, including dedicated servers,” and the setting decides only “Without this flag” (bb4f6b5a). An earlier commit passed the metadata directory through to the assigner (b8279ecf), and a follow-up stages GameFeatureVersePaths.bin explicitly, deleting any previous copy first “so a stale copy is never paked” (a6cdc4f9).

Why this is important

Nothing breaks. Pipelines that pass -RunChunkAssigner keep working, and with the setting defaulting to False, projects that never used the assigner see no change. What is new is that a project can turn the assigner on for client builds in config instead of carrying a command-line flag through every BuildCookRun invocation, and that the message’s “instead of” wording overstates the change if you read it alone.

Who should care

Build and release engineers, anyone using the oplog chunk assigner.

Urgency

Track. Consider moving to the project setting if you already pass the flag for client builds.

Incremental cooks stopped overcooking and undercooking

What changed

Three fixes, failing in different directions. The Blueprint native class dependency hash varied with sparse class data creation order, “which caused every Blueprint deriving from a class with SparseClassDataTypes to be reported as Native Class Changed and recooked on every incremental cook” (fd0a139c). In the other direction, “Algo::CompareAsInt in ARFilter.cpp repeated LessThan(*A, *B), so it never returned +1,” the cook’s asset registry access tracker overwrote records on hash collisions, and “the dropped AR-query build dependencies led to missed incremental recooks” (2e1c5832). And packages importing a class that CoreRedirects declares removed now stay eligible for incremental cooking (760e6ed4).

“Merge cook determinism fixes from Main” covers “cook dependency tracking, deterministic actor naming and ordering, archetype inheritance, soft object path fixup, shader library sorting.” It was backed out once and relanded inside the week (78a2556e).

For DLC, CookImportChecker now runs on DLC cooks, “giving warnings for missing hard imports and adding missing soft imports to the Cook.ReferencesOfUncooked op in the DLC cook’s oplog” (45178bb1). -DlcPluginOnly had a plain bug: “Packages outside of the plugin were still being cooked” (b4a4d9cc). The uncooked references list now works for loose file cooks (02b84132), and UnrealPak and IoStore no longer look for DevelopmentAssetRegistry.bin to find metadata, because “-NoSaveDevAR skips it for performance” (1f7d40c4).

On speed, a material change adds cook.MICParameterLookupCache “(default 0; set by -CookExperimentalOptimizations)” and measures “UpdateParameters 602 s -> 8 s, about -4.8% wall” on a content subset. Two caveats come with it: materials see a “one-time TargetDomainKey change,” and “UMaterialInstance editor layout change (ReentrantFlag removed); editor plugins must rebuild” (8a5911ac).

Why this is important

The sparse class data bug is easy to spot, because incremental cooks do far more work than they should. The comparison bug is worse, because a missed recook can leave stale cooked data in a build with nothing to flag it. If you rely on incremental cooks for anything that goes to players, take 2e1c5832. Expect one larger-than-usual incremental cook after 8a5911ac because of the key change, and rebuild editor plugins that touch UMaterialInstance.

Who should care

Build engineers, release managers, DLC and plugin content teams, editor plugin authors.

Urgency

Act now if you ship from incremental or DLC cooks. Track otherwise.

Defaults that moved this week

What changed

None of these announce themselves at build time.

• PSO precache deferral is on. r.PSOPrecache.DeferUntilPostLoad (default 1) defers precaching on loaded components until their own PostLoad, because an actor’s PostLoad can change materials first. “Behavior change: on by default. r.PSOPrecache.DeferUntilPostLoad=0 restores the previous behavior.” (7cc9b379).
• Mac bindless is on. “Enable Bindless on all Mac platforms by default.” The diff changes BindlessConfiguration from Disabled to All in BaseMacEngine.ini (d0841228).
• Chaos user data, two fixes default on. p.Chaos.UserDataPT.SkipNullPayloadOnAdd, “default on” (f5ecfea2). And p.Chaos.UserDataPT.SkipInputsDuringResim, “default on,” because a resim replay “stored nulls over live data and repeated old removals” (0b2283ee). Seven commits added eight new collision options alongside, each “default off” in its message (2a3d0def, 60a3728a, cb076f03, eb642d3c, dc5169d4, 7c340dd7, 20f3192e).
• Sequencer landing mode. “Change the default Sequencer.SwitchBoundary.OccupiedLandingMode from 2 to 3 (keep the existing world at the moving boundary and always add a key at the drag start)” (868a4600).
• Animation tick ordering. EndPhysicsTick now waits on the skeletal mesh primary tick, with an opt-out, tick.EndPhysicsTickWaitsForAnimation=0 (53d95ea0).
• Mesh pass sorting was off. “Fix TShaderRef::GetSortKey() always returning 0, which left every mesh pass sorted by state bucket id instead of by shader” (69b6a2af). The message does not say when the bug came in.
• An occlusion feedback fix you have to opt into. With r.OcclusionFeedback.Enable=1, spurious visible verdicts re-armed “the 1 second bRecentlyRendered window and all the work keyed on it: skeletal pose ticking (ShouldTickPose, URO, Animation Budget Allocator) and effects.” The fix sits behind r.OcclusionFeedback.UntestedAsIndefinite, “(default 0),” and the diff confirms 0 (46ea29b0).

Why this is important

Act on the occlusion feedback item first. The commit calls it “a game thread regression,” but the default leaves the regression in place, so a project running occlusion feedback has to set r.OcclusionFeedback.UntestedAsIndefinite=1 (or already run r.OcclusionFeedback.VisibleTestPeriod above 1) to get the fix. The sort key fix is a silent performance change: mesh passes now sort by shader as intended. The message gives no performance numbers, so measure before and after if you profile draw submission closely. One adjacent fix: setting r.CustomDepth to the value it already had reregistered “every component in every world for no change: a large hitch” (1ff8ad7a).

Who should care

Graphics and gameplay programmers, Mac teams, network physics programmers, Sequencer animators, performance engineers.

Urgency

Act now on occlusion feedback if you run it. Track the rest at your next integration.

Mobile and lower-end GPUs got more reach

What changed

Ambient Lighting Volumes moved to mobile. The commit cuts instance data “from 6 uint4 to 3 uint4,” reduces “the overhead cost from 0.5ms to 0.3ms when simply enabling ALVs on a mobile platform,” notes that “android has been able to cook with ALV enabled,” and concludes “ALV is now enabled by default on mobile platforms” (ee32ab5b). The diff shows no CVar or ini default change, and the new mobile shader path is still gated on the project’s ALV support setting. The day after, ALVs were disabled again in the mobile merged light pass “due to out of smaplers for some game materials” (63a418c0), then re-enabled two days later after a texture slot was saved so they “should fit withing the 16 samplers limit of Android OpenGL” (ca4699fe).

On desktop, a new r.SM6.RequireAtomic64 (default: true) lets otherwise-compatible D3D12 and Mac GPUs select SM6 without 64-bit typed atomics when set to false, while it will “Keep Nanite unavailable on unsupported GPUs” (6b14511d). The engine default is unchanged. Lyra is the only project that sets it false this week, with “Nanite remains disabled on those GPUs” (c9d18676).

For Adreno, a SPIR-V optimizer pass now “stores a null value into every fragment output the shader declares but never writes,” because “Pixels shaders that do not write to all declared outputs may hang Adreno GPUs” (1b9401b7). It replaces an earlier runtime fix for the same GPU failure on the “Galaxy S24 with Adreno 750,” backed out with the note “Shader fix now applied in a ShaderConductor” (ddf3b96f). Separately, debug view markup had “pushed landscape materials over the ES3.1 16 sampler limit” under the new material translator (daeb62f8).

Why this is important

The ALV message says enabled by default on mobile, and the commits back that up as a cost reduction rather than a flag flip. Whether your mobile build uses ALVs still depends on your project’s ALV support setting, so check yours. Three commits this week ran into mobile sampler limits (16 on ES3.1 and Android OpenGL), so expect more of that. The SM6 change opens a path for GPUs without 64-bit atomics, but only if you opt in, and Nanite stays off on those GPUs either way. The Adreno fix lands in the shader compiler, so it applies after a shader rebuild.

Who should care

Mobile rendering engineers, Android teams, technical artists using ALVs, teams supporting older desktop GPUs.

Urgency

Act now if you ship on Adreno and have seen GPU hangs. Track otherwise.

UBA fetch hangs fixed, and Launch On got faster

What changed

UBA’s storage proxy fix covers several ways a fetch could stall. The proxy used to drop the client when the server could not provide a file, which “made the helper get the same proxy again and loop reconnecting forever.” A leaked begin message meant “all later fetches of that file hung until 10 minute timeout.” And “A failed fetch begin is no longer cached forever in the proxy” (94dbca45).

Launch On iteration got two cuts. Without AutoSDK, editor and commandlet startup ran a BuildUBT up-to-date check that “costs ~4s even when nothing changed, while UBT itself takes ~0.7s. This is paid on every cook in Launch On Device.” It is now skipped when UBT is launched with bSkipBuildUBT (d65c5690). On Android, AFS deploy avoids “a second file server start on every iterative deploy (~2s per Launch On)” (d42c6f51), and quick launch incremental deploy was fixed (18b07486). A third change, reusing the cached UATRules assembly instead of recompiling it “(~2s, e.g. every editor quick launch),” was backed out the same day with no reland, so it did not ship (88268823).

Why this is important

The proxy bug showed up as helpers stuck, or processes failing with “missing files that are not missing.” If you run UBA with a storage proxy and have seen intermittent ten-minute stalls, test with this. The Launch On changes are small numbers that add up for anyone iterating on device several times an hour.

Who should care

Build and CI engineers, UBA operators, anyone iterating with Launch On.

Urgency

Act now if you run UBA through a storage proxy. Track otherwise.

Worth Tracking

Frame pacing groundwork landed, compiled out. A new frame pacer measures each pipeline stage from a per-frame task timing graph, “takes the slowest stage’s recurrence as the achievable frame period,” and delays frame start so work lands “just-in-time for the flip minus r.FramePacing.TargetSlack.” The commit ends with “All task timing and frame pacer code is disabled by UE_TASK_TIMING_ENABLE 0 for now.” (c8214148). The next day, the D3D12 RHI removed its PresentOnSubmissionThread paths, which “have been disabled for a while,” because removing them “will make it easier to support the new frame pacing system in D3D12” (2dcea985). Nothing changes for you yet. When UE_TASK_TIMING_ENABLE flips, frame timing behavior changes with it.

UnrealConsole, a headless editor host. Seven commit messages name it this week. It boots a “curated” startup that was missing two steps “relative to FEngineLoop,” one of which left “any map load” failing CheckForWorldGCLeaks under -minimalengine (8ffa5e75). Saving under “UnrealConsole’s minimal engine” failed (c625ee5a), Slate gained a way to skip editor UI because “UnrealConsole being headless doesn’t want any Slate” (3c28faf2), and toolsets learned to work without it: the agent plugin skips its settings panel “(UnrealConsole headless host)” (dd5f55ec), and the toolset registry tolerates missing editor subsystems “for headless editor hosts” (12efd3d9). No message states the purpose. The commits suggest a headless editor that agent tools can drive without a UI.

PCG Component Lite. Eight commits this week, counting a backout and its reland, took the series from P4 through P8, including “P6 - add the non-partitioned Lite component” (b2f57825) and a display name of “PCG (Lite)” (a2f7ef33). Last week PCG added a base class to “phase out the old overcrowded component with a new one.” No commit yet states a default or a migration path.

Two follow-ups on last week’s post. We reported the Iris RPC ownership bypass fix as backed out with no reland. It relanded on Monday as “Re-submit of CL 58175859 (backed out in CL 58581021). Fix Iris RPC ownership bypass and type confusion during RPC processing.” with new tests, and nothing backed it out through Sunday (d42001cf). We also said we would not count the VBench TWriteBarrier change as shipped until the next reland. It also relanded on Monday, with the same “10% speedup on VBench” text, and stayed in through the end of the week (8feb3d14).

What We Ignored

This week we ignored roughly 830 commits: config and plugin descriptor churn, Verse, UEFN, and scene graph work, animation framework and RigVM polish, AI toolset API surface, virtual production and media plumbing, editor UI, header tool codegen, test and static analysis cleanup, and the usual small fixes. There were 24 commits tagged [Backout], the same as last week and inside the normal band for this branch. Several relanded in-window, including the cook determinism merge above, PCG Component Lite P5 (2ec4c4e4), and a TEDS column API change (8dbc277a).

Three that did not come back are worth naming, because their titles make them sound shipped. “Enabling new platform IO dispatcher on all platforms until hard-lock to give it some testing” was backed out with no reland (4572de78), so the new dispatcher is not enabled. The UATRules cache reuse mentioned above did not ship (88268823). And a ChaosCloth change to stop rotating reference bone velocity, which would have removed a “fake centripetal acceleration,” was backed out with no reland (d5e43eb6).

A few one-liners. GAS CancelAbilities was cancelling all instances instead of the targeted ones (150de265). A Niagara PSO readiness bug left some effects that “can never be culled,” with kill switches fx.Niagara.RestoreSoloAfterReady=0 and fx.Niagara.RegisterScalabilityAfterReady=0 (e312517c). With memory-mapped shaders, encrypted IAD chunks reached the shader archive and “Oodle decompression in CreateShader then failed fatally” (16c68d93). And “project-scoped asset module accessibility” is now on by default, which “can cause some ambiguity errors” (c5449c37).

For teams shipping on 5.8

ue5-main ran 123 commits with no backouts, against 196 last week. There was no gather changelist and no hotfix version bump. Of 122 analyzable commits, 111 carry an exact title twin on ue6-main, so most of this list is mirrored there. The traffic is mostly animation framework work (about 45 commits), Control Rig, and Sequencer, with rendering thin at six commits. A handful of the items below are on this branch only, and each says so.

• XSX EOS delay-load crash on launch. “Fix EOS delay-load crash on launch with modern GDK folder layout,” with a note to “Remove once EOSSDK ships a modern-layout XSX binary.” It changes build rules only (ef041c2a). This one is on ue5-main only. A separate EOSSDK v1.19.2.1 binary update marks “PS4 10.008.001/10.508.001, PS5 10.00.00.40/11.00.00.40, Switch 18.3.1/19.3.5, XboxOneGDK/XSX 240300-241000” as deprecated and adds “Switch/Switch2 22.2.5” (e0b317d6). Its message does not say whether it ships the modern-layout XSX binary.
• UAT output on non-Latin build agents. UAT now starts commandlets with a UTF-8 environment, fixing “garbled output from the commandlets when running UAT on a system that is set to a non-latin codepage (Japanese, Chinese…)” (97185d08). On ue5-main only. If your build agents run a Japanese or Chinese system locale, take this.
• Lumen atlas cleared each frame under SceneCapture2D. “Fix Lumen indirect lighting atlas being cleared every frame when a SceneCapture2D is rendering” (0fda89fd). Also on ue6-main. A separate Lumen crash when uploading “more instance indices than GPUScene can hold (MAX_INSTANCE_ID)” is also fixed (6014b88a), on both branches, alongside a Vulkan ReadSurfaceData null check (61e2141e).
• A landscape fix written to be hotfix compatible. An assertion in the batched edit layers merge “when two landscape components overlap” is fixed, and the commit notes “New functions intentionally omit LANDSCAPE_API to make the CL hotfix compatible.” (4ff41bbd). It is also on ue6-main. It is the only commit this week that says this, which suggests it is a candidate for a 5.8 hotfix, though no message says so.
• Static mesh builds crashed on meshes with no UVs. “Array index out of bounds: 0 into an array of size 0” in the async static mesh build “whenever bUseMikkTSpace was on, which is the default.” It now falls back to per-vertex tangent averaging, with “No behaviour change for meshes with at least one UV channel” (0c34c4aa). Also on ue6-main.
• Mac pak staging for projects outside the engine root. A GitHub pull request (PR #15101) fixes the CreatePaksUsingChunkManifests lookup path “so that it works for mac platforms and not just windows particularly for projects that live outside the UE root” (01428705). Also on ue6-main.
• Editor web views no longer take the editor down. The CEF v128 update “Fixes editor crashes when the GPU process is reported as unusable,” and the web views now show a spinner instead (7bb6f298). A shutdown crash with -RenderOffScreen is fixed too (1d60c6cb). Both are also on ue6-main. The commits suggest the second matters most on headless build agents.
• PIE crash on brushes without a level. “EXCEPTION_ACCESS_VIOLATION reading address 0x0000000000000028” in ABrush::PostLoad, where “Every reported occurrence is a PIE world duplication.” The fix adds an ensure, and “projects that suppress LogBrush will see the ensure where they previously saw nothing. It fires once per session.” (9396d5b1). Also on ue6-main.
• Cook determinism, two fixes. PoseSearch PCA data varied with CPU cache size, so “a machine with a 32 KB L1 and one with a 48 KB L1” produced different covariances. The fix bumps DatabaseIndexDerivedDataCacheKeyVersion “to rebuild the cached indices” (5cc61f39). A Control Rig anim graph node’s compiled class “no longer depends on cook load order” (e8dcfef1). Both are also on ue6-main. Expect a PoseSearch DDC rebuild.
• Sequencer landing mode default changed here too. Sequencer.SwitchBoundary.OccupiedLandingMode went “from 2 to 3” (de572aff), the same change as on ue6-main.
• Visual Studio 2026 solutions. The source code accessor did not recognize .slnx, so clicking a Blueprint’s native parent class “launched a new devenv on every click,” and the hot reload “save all open Visual Studio documents before compiling” hook was silently disabled (5fc7f720). No twin landed on ue6-main this week. The commit is a cherry-pick of an older changelist.
• Animation framework content needs a resave. An output variables change includes an “asset registry version bump,” and “UAF content needs a resave with or directly after this change” (8b1e4487). Also on ue6-main.
• The GC barrier change from last week, one follow-up. Epic’s own replication test target needed an explicit opt-in: “CIS compile error fix: enabling the GC barrier for replication tests (required by TestGarbageObjectPtrReference)” (acf28db8), also on ue6-main. It is a one-file target change, and it is the pattern to expect in your own non-editor targets if they depend on the barrier. Nothing on this branch touched last week’s AVBOIT, Nanite translucency, Vulkan fence, or RigVM Return node defaults, so last week’s state stands.
• Crash fixes worth taking. A use-after-free in constraint tick prerequisites (6f08631b) and a “GC-related regression from CL 56542014 that could cause crashes in other engine systems like MRQ” (51775abc), both also on ue6-main.

Closing

A compiler was chosen and withdrawn inside a day because HeadlessChaos asserted. Epic’s test coverage caught it, and your build logs are where you confirm you are on the right side of it.

Commit SHAs are cited inline, in parentheses, next to each claim. They reference the ue6-main branch of EpicGames/UnrealEngine unless the claim is in the “For teams shipping on 5.8” section, which references ue5-main. Many of the highest-interest entries resolve to Commit.gitdeps.xml binary-manifest blobs: the commit message is real, but the code lives in Epic’s internal binaries, which we cannot see.

Week of September 21 to September 27, 2026 | 1,072 commits on ue6-main, 196 on ue5-main | Branch: ue6-main

Overview

One of the week’s largest commits ports most of Epic’s editor toolsets from Python to C++ (all but the programmatic and Python toolsets), and its message lays out “the general LLM process” it used: port each Python toolset to C++, point the Python tests at it, iterate until they pass, port the tests to C++, iterate again, then “Perform audit for API drift and test coverage regressions” and “Audit until tests pass.” (15fd454a). The tools a model uses to drive the editor were rewritten, in part, by a model, with the test suite as the contract. Earlier in the week the toolset provider interface moved into a new engine module, ToolsetCore, that depends only on Core and CoreUObject (6d7f31bd). The interface agent tools are registered through is moving out of a plugin and into the engine.

Two things we told you last week changed. Adaptive Voxel-Based OIT, which landed on both branches with r.OIT.Method defaulting to it, now defaults off: the value went from 1 to 0 on ue6-main (511c9d7e) and ue5-main alike, “to sort out some ThinTranslucency issues.” Nanite translucency support went off the day before (81b50042), on both branches, and a separate commit quietly switched off its runtime toggle too (4327b52b). And the UBA ownership handoff we described as genuine did not show up this week: all 36 commits touching UnrealBuildAccelerator this week came from the original engineer.

At 1,072 commits this is the busiest week ue6-main has had since this briefing started tracking it in June, clear of last week’s 963. Among named subsystems, build leads at 121, followed by rendering at 71, editor at 64, and core at 56.

Development Trends

Agent tooling nearly doubled, and moved into the engine

Pattern: commits touching the toolset registry, the AI Assistant plugin, the experimental toolsets, AsyncFunctionResult, and ToolsetCore came to 56 this week, against 30 last week and 20 the week before, counted the same way each week. It is the largest weekly count we have measured on this cluster, which ran between 19 and 30 a week from the week of August 17 through last week. Two weeks running, the work has produced a new engine module: AsyncFunctionResult last week, ToolsetCore this week (6d7f31bd). And the Python-to-C++ port (15fd454a) says in its own message that it is “in prep for consolidating these toolsets with their related subsystems.”

Interpretation: the destination is stated: each subsystem exposes its own tools, instead of a plugin wrapping them. ToolsetCore exists so that “a class that already has a base it can’t leave - an engine or editor subsystem, a settings object - can expose AICallable tools by implementing IToolsetProvider instead of inheriting UToolsetDefinition.” The permission model kept pace: five commits hide individual tools and whole toolsets when the host is restricted (05da90e0, 8275809e, 33602841, 97e5f51b, 4614680c). Two of them state the rule outright: “a Shipping editor is always restrictive. Roles are not consulted.” (8275809e, 33602841). Two others go further: EditorAppToolset’s PIE tools are also withheld from sessions granted the VKCreateUGC role (05da90e0), and CheatsToolset from sessions granted the base creator role, even with restrictive mode off (97e5f51b).

Who cares: tools programmers, pipeline and automation teams, anyone scripting the editor through the toolset Python API.

Signal strength: Strong.

UBA went back to one engineer

Pattern: counting commits touching UnrealBuildAccelerator the same way each week: 37 commits with 29 from one engineer (Sep 7 to 13), 19 with 10 from a second engineer and 7 from the original (Sep 14 to 20), and 36 this week, all from the original engineer. The second engineer has no commits of any kind in this week’s data.

Interpretation: last week we wrote that the split “reads as a real handoff of ownership rather than a week of holiday cover.” One week later, the data does not support that reading. A single week of other work or time off is the likelier explanation, and the concentration we have tracked since August is intact. We are keeping the pattern on the list and dropping the conclusion. The work itself is covered in the highlights below.

Who cares: build and CI engineers, anyone whose build farm depends on UBA.

Signal strength: Moderate.

Translucency shipped, then stepped back

Pattern: last week Nanite translucency and AVBOIT landed together. This week Nanite translucency was fixed to cast shadows (07ae0b96), then disabled by default the next day after EngineTests failed to run green (81b50042), with its runtime toggle also defaulted off in a separate commit (4327b52b), and AVBOIT’s method default went to 0 a day after that (511c9d7e). The same disables landed on ue5-main, cited in the 5.8 section below. Nothing re-enabled either one before the week closed.

Interpretation: the code is still in both branches and still selectable. Epic pulled the defaults back while test and content issues get resolved, which is normal for a large rendering feature meeting a real test suite. If you scheduled an evaluation from last week’s post, you now have to opt in on both. Set r.OIT.Method to 1 on top of the existing r.AVBOIT.Support project opt-in, set the read-only r.Nanite.AllowTranslucency to 1 in config, and set r.Nanite.AllowTranslucentMaterials to 1, which a separate commit also switched off by default (4327b52b).

Who cares: graphics programmers, technical artists evaluating translucency, anyone who read last week’s AVBOIT section.

Signal strength: Moderate.

TL;DR

• AVBOIT and Nanite translucency are off by default again, on both branches. r.OIT.Method went from 1 to 0 (511c9d7e) and the read-only r.Nanite.AllowTranslucency went from 1 to 0 (81b50042). A separate commit also set the runtime toggle r.Nanite.AllowTranslucentMaterials to 0, without mentioning it in its message (4327b52b). Last week’s post described the earlier default. Nothing re-enabled either before the week closed.
• If you run MSVC static analysis in CI, check it analyzed anything. -StaticAnalyzer=Default on -SingleFile compiles “silently analyzed nothing,” because cl.exe ignores /analyze from a nested response file, and normal compiles would have done the same with bWriteSarif disabled (e5982767). Reproduced on MSVC 14.44, 14.50, and 14.51.
• If you ship on 5.8: a StateStack memory fix whose own message says the hotfix-compatible workaround “dead-ended in 5.8.3,” a Mac editor exit assert affecting “37 users and 37 occurrences on 5.8.x,” and two Xcode 27 and macOS 27 fixes are covered with commit references in the 5.8 section below.
• Iris changed its protocol hash, and an RPC ownership bypass fix came back out. Replication switched from CityHash to XXHash, so “clients and servers must be built from the same revision” (1c98a69c). Separately, a fix from the week before, for “Iris RPC ownership bypass and type confusion,” was backed out with no reland (a10acade).
• The TObjectPtr GC barrier is now off by default outside the editor, on both branches. bWithGCBarrier resolves to true only for Editor targets (b561343d, with the ue5-main commit cited in the 5.8 section). If you run incremental reachability in a cooked game, client, or server build, set it on that target.
• UBA’s scheduler was capping Horde help. Coordinators read the remote process count as total wanted cores, so a 5,000-process run “capped at ~3700 cores” (44ce71cb).
• FSceneViewState split into game-thread and render-thread halves (ce0628ef), with several FSceneViewStateInterface methods deprecated and stubbed. Act now if your renderer code or plugins reach into view state.
• The editor toolsets were ported from Python to C++ using an LLM-driven process described in the commit (15fd454a), and the toolset provider interface moved into a new engine module (6d7f31bd).

Highlights

AVBOIT and Nanite translucency are off by default

What changed

Four commits, in changelist order. First, Nanite translucent materials set to Cast Dynamic Shadow as Masked now cast shadows. The commit explains that “Nanite hid every translucent raster bin in every cull except the AVBOIT extinction cull, so Nanite translucency cast no shadows at all,” and now matches non-Nanite behavior, “an opaque shadow wherever opacity is non-zero,” behind r.Nanite.TranslucentShadows (07ae0b96). Later the same day, a vertex factory cleanup titled “Nanite translucency: only compile the vertex factory for the passes it implements.” also flipped the runtime toggle r.Nanite.AllowTranslucentMaterials from 1 to 0, a change its message does not mention (4327b52b). Next, the following day: “Disabling Nanite Translucency shaders. Some bugs need to be dealt with before enabling again. EngineTests didn’t run green due to this.” The diff changes one line: the default of r.Nanite.AllowTranslucency, a read-only console variable, from 1 to 0 (81b50042). Last, a day later: “Disabling AVBOIT by default to sort out some ThinTranslucency issues.” That diff also changes one line, the default of r.OIT.Method from 1 to 0 (511c9d7e). All three default changes landed on ue5-main as well. Nothing in the window turns any of them back on.

Why this is important

Last week we told you r.OIT.Method defaulted to AVBOIT, with the shader permutations gated behind the off-by-default r.AVBOIT.Support. Both halves were true when written. The first half is no longer true. The practical default was ordinary sorted translucency then and it still is, but an evaluation now needs the method set explicitly as well as the permutations enabled. And because r.Nanite.AllowTranslucency is read-only, turning Nanite translucency support back on means editing config and restarting, with a shader recompile. The runtime toggle, r.Nanite.AllowTranslucentMaterials, now also defaults to 0 (4327b52b) and only matters once support is on at startup.

Look at the stated reasons. Epic pulled the Nanite translucency default because its own test suite went red, and AVBOIT’s to sort out ThinTranslucency issues. Neither commit describes a design change. Expect both back once those bugs are fixed, and read the re-enabling commits for what changed.

Who should care

Graphics programmers, technical artists evaluating translucency, anyone who acted on last week’s AVBOIT section.

Urgency

Act now if you scheduled an AVBOIT evaluation from last week’s post. Track otherwise.

MSVC static analysis could run and analyze nothing

What changed

From the commit: “cl.exe honours most options from a nested response file, but not /analyze: it has to be on the command line or in the top-level response file to enable static analysis”. UBT put /analyze in each module’s shared response file, which every compile’s own response file includes, so analysis was only switched on by the /analyze:log that bWriteSarif adds per file. “-SingleFile compiles don’t get /analyze:log, so -StaticAnalyzer=Default silently analyzed nothing, and normal compiles would have done the same with bWriteSarif disabled.” It reproduces on MSVC 14.44, 14.50, and 14.51. /analyze is now added to the per-file arguments whenever the global arguments go into a shared response file (e5982767).

Why this is important

A static analysis job that silently analyzes nothing reports zero findings, and zero findings looks exactly like clean code. Nothing fails, so nothing prompts anyone to look. If your CI runs -StaticAnalyzer=Default on single-file compiles, or with bWriteSarif disabled, and UBT put the global arguments in a shared response file, those runs analyzed nothing. After this fix they will, so expect findings you have not seen before.

Alongside it, the assert API was reworked with proper [[noreturn]] guarantees and cold-path hints, which “Reduced program size by 11.4 MiB on the tested server target” and “Savings averaged ~1.4% on measured server targets.” The same commit notes FDebug::AssertFailed[V] “is now [[noreturn]], requires the ProgramCounter,” which matters to any fork calling it directly (1947e188).

Who should care

Build engineers, CI owners, anyone running MSVC static analysis, engine-fork maintainers.

Urgency

Act now if you run MSVC static analysis in CI. Check that your last runs actually analyzed files.

UBA’s scheduler was telling Horde it was satisfied too early

What changed

Scheduler::GetProcessCountThatCanRunRemotelyNow now includes processes already running on helpers “again,” which marks this as a regression, though the commit does not say when it came in. The consequence it describes: “Coordinators (Horde) treat the value as total wanted cores, so ready-only made them report ‘Satisfied’ once held cores exceeded the ready queue (5000 process UbaCli run capped at ~3700 cores).” (44ce71cb). A companion fix removed a deadlock where SessionServer called scheduler callbacks while holding m_remoteProcessAndSessionLock (f6a17f28).

The rest of UBA’s week came from the same engineer, and much of it was Linux: process lifetime and syscall tracking. A linker-style parent can exit while its child is still writing output, and UBA used to rearm SIGHUP after fork and for every preloaded exec, “so the child is terminated early” (28df7217). “Go symlink/symlinkat syscalls bypassed UBA tracking, so successful creation could be invisible to later reads or absent from published agent outputs” (cc8f9ff8). “Static-glibc symlink and symlinkat calls aborted as unsupported” (0867f702). Orphan watchdogs were reworked (be4f6330, 04230c74), and the GCC runtime dependency was removed from the Linux bootstrap (6a18ba11).

Why this is important

The scheduler bug shows up as a ceiling with no error attached. A farm that plateaus below its helper count looks like a sizing problem. If you run large UBA jobs coordinated by Horde and have seen remote help flatten out before your pool is exhausted, this is worth testing against.

Most of these Linux fixes close a case where UBA lost track of work or cut it short, and the rest tighten cleanup and dependencies. If Linux builds under UBA have produced missing outputs or failed symlink calls, retest after taking these.

Who should care

Build and CI engineers, Horde operators, anyone building Linux targets under UBA.

Urgency

Act now if you coordinate large UBA runs through Horde or build Linux targets under UBA. Track otherwise.

Iris shifted its protocol identifiers, and an ownership bypass fix came back out

What changed

Iris switched from CityHash to XXHash, and the commit carries the warning directly: “Note that this shifts every replication protocol identifier, so clients and servers must be built from the same revision.” (1c98a69c).

Separately, a commit from last week, “Fix Iris RPC ownership bypass and type confusion during RPC processing”, was backed out this week (a10acade). The backout gives no reason, and there is no reland in the window. As of the end of the week, that fix is not in ue6-main.

Why this is important

The hash change is a hard compatibility boundary. Any setup where client and server builds can drift, whether staged server rollouts, mixed-revision test farms, or a dedicated server built from a different changelist than the client, cannot mix builds on either side of this commit. Your deployment process has to enforce the same-revision rule.

The backout matters because the title describes an RPC ownership bypass and type confusion fix, and a changelog read on either side of it can easily leave you thinking it shipped. It did not, for now. We do not know why it came out, and we are not going to guess.

Who should care

Network programmers, anyone running Iris, teams with staged or mixed-revision server deployments.

Urgency

Act now on the hash change if you integrate ue6-main and run Iris. Track the RPC fix for a reland.

The renderer split view state across threads

What changed

Five commits under one ticket (UE-376381) separate game-thread view state from render-thread view state. FSceneViewGameState is new: it “implements FSceneViewStateInterface and owns the game thread half of the view state,” while “FSceneViewState becomes the render half and no longer implements the interface.” UniqueID was renamed to ViewKey (ce0628ef). Earlier in the week, ResetViewState began queuing deletes to the render thread, and a number of FSceneViewStateInterface methods were “Deprecated and stubbed” (fbd9cb07). Sequencer had been writing SequencerState into FSceneViewState on the game thread “while the renderer reads it off the RT.” It is now passed through FSceneViewInitOptions, the setters and getters are deprecated, and “SequencerState is now Editor only” (7c88cf41).

In the same area, the experimental LumenRef mode was renamed to LumenPT “due to annoying name/CVar autocomplete collisions with r.Lumen.Reflections.*” (72cf5c8e) and gained height fog (5e1d5296), and r.MegaLights.HardwareRayTracing.EndBias and r.LumenPT.LightEndBias were replaced by a shared r.Shadow.RayEndBias (2426acdb).

Why this is important

A deprecated-and-stubbed method still compiles, with only a deprecation warning, and then returns a placeholder (0, false, or null) instead of real data. For a fork, that is quieter than the summer’s scene decomposition work and in some ways worse. A renamed field breaks the build. A stubbed one hands back a placeholder value and keeps going. The renamed console variables are the smaller version of the same problem. A config file that sets r.MegaLights.HardwareRayTracing.EndBias now sets nothing.

Who should care

Graphics programmers, engine-fork maintainers, render plugin authors, anyone with MegaLights or Lumen console variables in project config.

Urgency

Act now if you maintain renderer code that touches view state. Track otherwise.

The agent tools moved into C++ and into the engine

What changed

The editor toolsets, except the programmatic and Python toolsets, were ported from Python to C++ “in prep for consolidating these toolsets with their related subsystems.” The commit describes the method as an LLM process driven by the test suite, ending with “Perform audit for API drift and test coverage regressions” and “Audit until tests pass.” It also notes that AssetTools.FindAsset “is significantly optimized and made async” and that shared utilities were factored out “so that toolsets don’t depend on one another” (15fd454a).

The toolset provider interface moved into a new engine module, ToolsetCore, which “only depends on Core and CoreUObject.” It lets existing engine and editor subsystems expose AI-callable tools by implementing IToolsetProvider, and adds opt-in instance dispatch, “which relaxes the requirement that AICallable functions be static.” It landed, was backed out, and relanded in the window (6d7f31bd). Programmatic toolset scripts now run as coroutines on the editor thread, which the commit says “is about 5x faster than previous” (dbed8596).

Two Python toolset APIs now fail loudly. AssetTools.save_assets was replaced by a single-path save_asset “that raises when a save fails,” and the empty-list “save all dirty assets” mode was removed because it “silently skipped anything the engine failed to mark dirty” (2c893cd8). SceneTools.get_current_level() now raises during PIE “instead of silently returning empty string” (0fdfdb94).

Why this is important

The LLM detail matters for what it says about the process. The contract for the port was the test suite plus an explicit audit for API drift, which is the right way to make a large mechanical rewrite trustworthy regardless of who or what does the typing.

The practical changes are the fail-loud ones. Any script calling save_assets needs porting to the single-path save_asset, and one that relied on the empty-list save-all mode loses it entirely. Reading the current level during PIE now raises.

One commit title reads “Enforce asset reference filter policy in ReferenceConverter so that LLMs can bypass reference restrictions when setting properties.” (d998b1e1). The new tests say otherwise. The ones covering refused references assert that the import fails, most of them with an “asset reference policy” error, and one confirms that a permitted reference still goes through. The change closes the bypass. The title appears to be missing a “not.”

Who should care

Tools programmers, pipeline and automation teams, anyone scripting the editor through the toolset Python API.

Urgency

Act now if you script against AssetTools.save_assets or SceneTools.get_current_level. Track otherwise.

Worth Tracking

The TObjectPtr GC barrier is now off by default outside the editor. UE_WITH_GC_BARRIER decides per target whether the barrier is compiled in, controlled by bWithGCBarrier in the target rules. The message leaves out the default, but the diff has it. The property resolves to true only for Editor targets, and its doc comment says the barriers are “Off for everything but the editor unless a target opts in.” Before this change the barrier was compiled into every target. UE_OBJECT_PTR_GC_BARRIER is deprecated, and enabling incremental reachability in a build without the barrier produces a LogGarbage warning (b561343d). The same change is on ue5-main, cited in the 5.8 section below. If you run gc.AllowIncrementalReachability in a cooked game, client, or server build, set bWithGCBarrier=true on that target, or you will get the warning instead of incremental reachability. Everyone else gets the runtime saving without doing anything.

Hair got volumetric multiple scattering, and it is being hardened quickly. The new method approximates multiple scattering within hair volumetrically, “based on [Hu et al. 2026],” selected at compile time, with the voxelization step’s per-voxel direction accumulation noted as having “a significant transient memory cost” (1469ffed). A denoising and optimization pass followed two days later, with a bilateral filter that “should be disabled for use with a neural denoiser” (dd82a008), then early termination on transmittance (bc461fb5). Three passes from one engineer between September 21 and September 25. Groom teams should watch the memory note before anything else.

What We Ignored

This week we ignored roughly 850 commits: localization automation, binary manifest drops for internal content pipelines, test infrastructure, Verse and UEFN scene graph work, internal tooling for Epic’s own merge and submit pipelines, and the usual run of small cleanups. There were 24 commits tagged [Backout], inside the normal band for this branch. Most relanded in-window, including ToolsetCore above and an optional Chaos cached contact manifold that is default off and gated by p.Chaos.Collision.ManifoldCache.Enabled (f2f66d89).

Besides the Iris fix covered above, two that did not come back are worth naming, because each follows up on something we covered. A mechanism for AutoRTFM module defaults, following last week’s ModuleRules migration, was backed out the same day it landed, with no reland (9d4b8559, backed out at 28005d1d). And “Make TWriteBarrier and VRestValue AUTORTFM_DISABLE, and remove EWriteMode::Default,” which claimed “a 10% speedup on VBench,” was relanded and then followed by another backout carrying the same description (dcafbb1e, backed out at bc02dce6). The AutoRTFM change is out of the tree at the end of the week, and we would not count the VBench speedup as shipped until the next reland.

Of 1,072 commits, 224 worth reading. Scene graph and typed element work was again the largest identifiable feature cluster at 61 commits, and again almost none of it individually notable. The multiprocess cook load balancer went from “O(n log n) -> O(log n),” a “~6x improvement for cluster size of 1 million,” which applies to the load balancer rather than to total cook time (febb9d11). PCG added a new base class for the PCG Component to “phase out the old overcrowded component with a new one” (690c9f65). And a vulnerability “when loading an FBX file with embedded files” was fixed with no further detail in the commit (cd1a46ca).

For teams shipping on 5.8

ue5-main ran 196 commits with 2 backouts, both relanded. There was no gather changelist this week, and the week was still busy. The volume is a Nanite ray tracing series from one engineer (31 commits tagged [Nanite Ray Tracing], 35 from that engineer in all, counting related HWRT and D3D12 work), a Control Rig burst, and a wide spread of crash and correctness fixes, two of which name 5.8 in their own text.

• Animation state machine memory could be invalidated, and 5.8.3 only has the workaround. FEncounteredStateMachineStack::StateStack was “using mem stack allocator when it’s data can persist outside of the stack which resulted in invalidated memory.” The fix also “bumps state stack inline allocation to 8 to avoid more heap allocations,” and the commit states that “A hotfix compatible workaround was previously implemented at 57738922 and dead-ended in 5.8.3.” (65f7b94a). We rate this the week’s most actionable item for anyone on 5.x. The full fix is on ue5-main. The commit does not say whether it will reach a 5.8 hotfix.
• Mac editors asserted on exit. “Cocoa can call -[FMetalView hitTest:] while the game thread is inside FEngineLoop::Exit,” after Slate’s widgets are gone, and the hit test “walks sparse-array indices for freed FWidgetData and asserts.” The deferred hit test now bails once engine exit is requested. The commit reports “37 users and 37 occurrences on 5.8.x, every one with an EditorExit activity hint” (2c773ff7).
• Two Apple toolchain blockers. “When an iOS app is compiled with Xcode27, iOS27 enforces use of UIScene,” so the iOS client now uses the UIScene lifecycle by default “to avoid crash on start” (aa25acc1). And iOS .app finalization was failing with “Bad file descriptor” on macOS 27: “The build executor spawns actions without an open descriptor 0. xcodebuild inherits it and then cannot launch /bin/sh for a scheme’s script phases, so app finalization fails and blames the script.” The xcodebuild finalize step now gets an empty stdin (71857dd9). If your Mac build agents are moving to macOS 27, take this before they do.
• Linux crash reporting could exhaust the crash allocator’s large pool. The engine log is now copied “through a fixed 64K buffer rather than IFileManager::Copy, which allocates a scratch buffer of min(1MB, file size),” thread XML is moved rather than copied, and the all-thread dump is bounded by unix.CaptureAllThreadStacksMaxChars (2c030936).
• Two DDC correctness fixes. Mutable’s DDC computed value for customizable objects was “changing from compilation to compilation,” ported from an earlier change (18bc0ec8). And Substrate Toon was missing its GBuffer custom data write “when fetching from DDC” (3e89ad5e). The first is the same class of bug as last week’s determinism gather, arriving on its own.
• AVBOIT and Nanite translucency are off by default here too (b2ec217e, acb2e828, a4bc702e), the same default changes described in the highlights above, including the unannounced r.Nanite.AllowTranslucentMaterials flip. If you read last week’s 5.8 note that AVBOIT was on this branch, it still is, but it now needs r.OIT.Method set explicitly on top of the r.AVBOIT.Support project opt-in.
• Skeletal mesh and blend space crashes. “Stale reference poses could survive a mesh reload and crash on remap” (99598786). A UBlendSpace marker sync assert “caused by a stale leader sample” (28f09fa6), and a blend space grid widget crash “on runtime data that outlives its samples” (57b02e9c).
• Sequencer attach track jumped on non-root sockets. “Compensation was pinned to the root component while evaluation attached to the socket, so the object jumped by the socket’s transform relative to the root,” visible only when the socket’s mesh sits under a default scene root (3c591f15). Binding overrides also asserted “when the player has no shared playback state yet,” for example when overriding bindings from Python or Blueprint before the sequence starts playing (e8cace23).
• Nanite streaming, occlusion culling, and foliage fixes. A mitigation for crashing when r.Nanite.Streaming.StreamingPoolSize is set too high (38986ccc), a workaround for incorrect codegen in FGPUOcclusionPacket::OcclusionCullPrimitive (c82bca23), and stale HISM transforms with foliage.densityscale below 1.0 (fc54f6ff).
• Vulkan fence wait default changed. r.Vulkan.CpuWaitForFence now defaults to 0 (the commit describes this as using semaphores on desktop) instead of 1 (ce723723), alongside an assert fix for invalid window handles (ca2d92c8). The diff changes the default unconditionally, so check it on every Vulkan platform you ship, not only desktop.
• The TObjectPtr GC barrier is now off by default for non-editor targets here too (c92351b9), as described in Worth Tracking above. If you run incremental reachability in a cooked build, set bWithGCBarrier=true on that target before you take this.
• MegaLights ignored IES profiles in volumes. Volumetric fog and lit translucency lighting were ignoring IES profiles under MegaLights (a54423d6).
• A RigVM default was flipped and walked back in the same week. A function’s Return node was made to exit the function, with the new RigVM.Compiler.ReturnNodeExitsFunction defaulting to true (c24c6f3e), then the CVar was defaulted to false because “Existing rigs rely on nodes running after the Return” (c0be2c90). The old behavior is the default. The early exit is opt-in.

Closing

The toolsets in the commit we led with were ported by a process its author wrote down, and the most useful sentence in it is the one about auditing for API drift. It tells you how the port was checked, and the method is worth copying.

Commit SHAs are cited inline, in parentheses, next to each claim. They reference the ue6-main branch of EpicGames/UnrealEngine unless the claim is in the “For teams shipping on 5.8” section, which references ue5-main. Many of the highest-interest entries resolve to Commit.gitdeps.xml binary-manifest blobs: the commit message is real, but the code lives in Epic’s internal binaries, which we cannot see.

Week of September 14 to September 20, 2026 | 963 commits on ue6-main, 172 on ue5-main | Branch: ue6-main

Overview

The most consequential commit this week edits one file and changes no behavior. EUnrealEngineObjectUE5Version is now frozen: a static_assert makes any further append to the enum fail to compile, the global package version is edited only from //UE6/Main from here, and EUnrealEngineObjectUE6Version continues the same numbering in the same serialized slot (802d4310). The commit says that if a UE5-only global version bump is ever unavoidable, use the UE4 enum’s slot instead. That is a line being drawn, in code, about which branch the engine’s version number comes from.

The rest of the week reads like the same decision playing out. Four months of cook and DDC determinism work was gathered into //UE5/Main as a single changelist listing 34 incorporated CLs, which is the largest thing to happen to the 5.x stream in weeks and includes fixes this briefing covered on ue6-main back in August. Epic’s implementation of Adaptive Voxel-Based Order Independent Transparency landed on both branches inside the same window. And the AutoRTFM migration that last week’s build-file groundwork promised arrived, rewriting every build file in the tree that set the legacy flags.

At 963 commits the week sits at the top of the band this branch has held since June, three clear of two earlier weeks, so read it as a busy week rather than a record. Build is the top subsystem at 116, followed by rendering at 71, editor at 69, and core at 60.

Development Trends

The UE5 and UE6 boundary stopped being implicit

Pattern: three separate commits this week define the relationship between the two branches rather than just reflecting it. The UE5 object version enum froze with a compile-time guard and handed numbering to UE6 in the same serialized slot (802d4310, with the identical change landing on the maintenance branch the same day). Four months of determinism fixes were gathered into //UE5/Main in one changelist. AVBOIT landed on ue5-main and on ue6-main the same day (4402e92a). The ue5-main commits behind all three are cited in the 5.8 section below.

Interpretation: for three months this briefing has described ue5-main as maintenance and ue6-main as where the engine is going. That framing is now too simple. Traffic moves in both directions, and the version freeze is the clearest statement yet of what the split actually means: UE6 owns the format’s forward motion, UE5 keeps a frozen slot and receives backports. If you maintain a fork, the freeze commit is the one to read, because it tells you where your own custom version entries should now live.

Who cares: engine-fork maintainers, anyone carrying custom object versions, technical directors planning a UE6 merge.

Signal strength: Strong.

Agent tooling grew by half and gained its own engine module

Pattern: commits touching the toolset registry, the AI Assistant plugin, the experimental toolsets, and the new async tool-call module came to 30 this week, against 20 in each of the two prior weeks measured the same way, a half-again increase on a cluster that had been flat. The work has moved past capability and permissions into module structure and editor integration: the async tool call result was split into its own engine module, AsyncFunctionResult (3cbf8b56), toolsets backed by a function library are now tracked for validity and retired when their backing class unloads (9adf873e), and an editor-side prompt provider lets tools contribute AI Assistant menu entries without depending on the plugin, first consumer being a right-click “Analyze Crash” on Crash Diagnostics rows (d7b1a871).

Interpretation: a feature that needs its own engine module has stopped being a plugin. The Crash Diagnostics integration is the more telling half. Epic is not just exposing the editor to an agent, it is wiring the agent into the editor’s own diagnostic surfaces as a default affordance, behind a provider interface so the plugin can stay off by default and the menu entry still appear when it is loaded.

Who cares: tools programmers, pipeline and automation teams, anyone evaluating model-driven editor automation.

Signal strength: Strong.

UnrealBuildAccelerator’s single-author concentration has genuinely broken

Pattern: we have tracked this for six weeks. Counting commits touching UnrealBuildAccelerator the same way each week: Aug 31 to Sep 6 was 39 commits with 38 from one engineer; Sep 7 to 13 was 37 with 29 from that engineer and 7 from a second; this week is 19 commits with 10 from the second engineer, 7 from the original, and 2 from a third. Total volume also roughly halved.

Interpretation: the primary author is no longer the majority of UBA’s commit log, and that took three weeks to happen rather than one, which reads as a real handoff of ownership rather than a week of holiday cover. The work that came with it is not maintenance either. The memory watchdog rework (dd25c6ac) is the week’s most substantial UBA commit by some distance, and it comes from the newer engineer.

Who cares: build and CI engineers, anyone whose build farm depends on UBA.

Signal strength: Moderate.

The cook-determinism campaign reached the branch people ship from

Pattern: every week since early August has carried cook or cache determinism work on ue6-main. This week it crossed over. The gather changelist lists 34 incorporated CLs spanning May to September 2026, including the Blueprint RNG fix this briefing covered on ue6-main in the August 10 to 16 edition, material slot name derivation, static mesh lighting GUIDs, audio derived-data keys, and two numbered entries from a seven-part cook-metadata determinism series.

Interpretation: the campaign has been readable as UE6 hygiene for two months. Its arrival in //UE5/Main changes who it is for. If you ship on 5.8 and your incremental cooks have been invalidating more than they should, this is the changelist that addresses it, and the fixes have had months of soak time on the other branch before getting here.

Who cares: build and CI engineers on 5.8, anyone running incremental cooks on a farm.

Signal strength: Strong.

TL;DR

• EUnrealEngineObjectUE5Version is frozen behind a static_assert, and the engine’s global package version is edited only from //UE6/Main from now on, with EUnrealEngineObjectUE6Version continuing the numbering in the same serialized slot (802d4310). If you carry custom object versions in a fork, read this commit.
• If you ship on 5.8: four months of cook and DDC determinism work landed on ue5-main in one changelist listing 34 incorporated CLs, covered with its commit reference in the 5.8 section below. This is the week’s most actionable item for anyone still on 5.x.
• UBA’s memory watchdog was comparing both of its thresholds against the commit limit, so on a 274 GB machine the kill threshold sat at 100.9% of physical RAM and could not fire before the machine paged (dd25c6ac). The new modes default to the old behavior, so nothing changes until you configure it.
• AutoRTFM’s migration reached the build files (3a3da019), and the legacy module properties were marked obsolete three days later (83b47050). Out-of-tree modules get the deprecation warning now and the removal later.
• Adaptive Voxel-Based Order Independent Transparency landed on both branches (4402e92a, and on ue5-main as cited in the 5.8 section). r.OIT.Method defaults to it, but the shader permutations are a project opt-in that is off by default, so nothing changes in your project until you turn it on.
• Horde’s Mongo index creation no longer blocks server startup, and a failed build no longer faults a collection for the process lifetime (394690eb). Act now if you self-host Horde.
• Ness became something you can switch on: UE_WITH_NESS=1 now enables it for any project without editing the target, and Lyra runs in its test job by default (708358b4).

Highlights

The UE5 object version enum is frozen

What changed

EUnrealEngineObjectUE5Version can no longer be appended to. The commit adds a static_assert so any further entry fails to compile, plus matching comments, and states the rule directly: the global package version is now edited only from //UE6/Main, and EUnrealEngineObjectUE6Version continues this numbering in the same serialized slot. If a UE5-only global version bump is ever unavoidable, the instruction is to use the EUnrealEngineObjectUE4Version slot instead. No code or format change, and the commit notes the added lines are byte-identical to //UE6/Main so the merge is conflict-free (802d4310). The same change landed on ue5-main the same day.

Why this is important

The object version enum is how the engine decides what a serialized package means. Freezing it is the moment the two branches stop being two lines of development that happen to share a format and start being one format with a defined owner. For anyone maintaining a fork, the practical consequence is immediate: a custom entry appended to the UE5 enum will now fail to compile, and the commit tells you where to put it instead. The instruction to fall back to the UE4 slot is also worth reading carefully, because it implies the UE5 slot is considered closed rather than merely full.

This is the kind of change that produces no release note and no behavioral difference, and then explains a class of merge conflict six months later.

Who should care

Engine-fork maintainers, anyone carrying custom object versions or serialization changes, technical directors planning a UE6 merge.

Urgency

Act now if you maintain a fork. Track otherwise.

UBA was throttling builds against a number the machine was not holding

What changed

The memory watchdog applied both of its percentage thresholds to the commit limit rather than to the quantity each threshold came from. The commit gives the consequence precisely: on a 274 GB machine the kill threshold sat at 100.9% of physical RAM and could not fire before the machine paged, and under MSVC, where commit peaks at 256 GB while resident never passes 147 GB, the build was throttled on a number 1.75 times what the machine was actually holding (dd25c6ac).

MemThresholdMode now selects how thresholds are derived and defaults to Legacy, so omitting every new key changes nothing. Split gives physical and commit their own wait and kill pairs compared against their own measured quantity, and Headroom uses the same two axes with each threshold set to its base minus a reserve in bytes. The commit states Headroom ships, with wait reserves of 0, meaning measured per tick from how far usage ran past the last published estimate, and kill reserves of 4 GB capped at 10% of their own axis so a fixed few gigabytes cannot become a quarter of a small machine. Dropping the busy-state sample interval from 1000 ms to 250 ms took p99 overshoot from 13.60 GB to 2.10 GB.

The measured result on a large game module against Legacy: clang went from 401.9s to 365.3s at 61.4 to 87.1 mean concurrency with no kills, and MSVC from 431.5s to 392.8s at 50.1 to 63.9 with 8 kills. Structurally, every throttle and kill decision now lives in MemoryWatchdog and reaches the scheduler through callbacks, so the scheduler keeps no memory state and takes no memory lock, and the racing check moved to its own thread, which means enabling the watchdog no longer disables racing.

Why this is important

A kill threshold above physical RAM is a safety mechanism that cannot engage, and the failure it was supposed to prevent shows up as a machine paging rather than as an error anyone attributes to the watchdog. The concurrency numbers are the part to note: the win is not primarily wall clock, it is that the build stops throttling itself on a number that was never the constraint. If you run UBA on machines with large amounts of memory, this is worth measuring rather than assuming.

The MSVC row still reports 8 kills after the fix, which is honest reporting rather than a clean result, and worth knowing before you attribute a killed action to your own configuration.

Who should care

Build engineers, CI and infrastructure teams, anyone running distributed compiles on high-memory agents.

Urgency

Act now if you run UBA on large-memory machines. The defaults are unchanged, so this is an opt-in you have to make.

AutoRTFM’s migration reached every build file

What changed

Across 90 build files, every bDisableAutoRTFMInstrumentation and bInjectAutoRTFMAttributeDisables assignment was replaced with AutoRTFM.DefaultMode, and every AutoRTFMExternalMappingFiles.Add call with AutoRTFM.ExternalMappingFiles.Add. The commit titles itself a migration of every .Build.cs, which in practice means every one that set those properties (3a3da019). The commit is explicit that it does not change behavior, that the legacy properties still exist and still work, and that they would be deprecated by the next changelist. Three days later they were: ModuleRules.bDisableAutoRTFMInstrumentation, ModuleRules.bInjectAutoRTFMAttributeDisables, and ModuleRules.AutoRTFMExternalMappingFiles are marked [Obsolete] naming their replacements, with the commit noting nothing in the tree uses them so the build is unaffected, and that they keep working for anything outside the tree until a final step removes them (83b47050).

Why this is important

Last week this was a prediction. The commit that added the ModuleRules.AutoRTFM property kept the legacy flags as facades and explicitly changed no build files, and we said the migration commit it promised was the one that would reach your build files. It did, in the same shape, one week later.

The sequencing is the useful part for anyone maintaining out-of-tree modules. The three steps so far are introduce, migrate in-tree, deprecate, and Epic has stated the fourth is removal. You are currently in the window where your build files still compile and now produce a deprecation warning. That window closes on Epic’s schedule, not yours, and the warning is the only notice you get.

Who should care

Anyone maintaining out-of-tree modules or a plugin distributed as source, build engineers, engine-fork maintainers.

Urgency

Act now. The change is mechanical and the deprecation is already live.

Order-independent transparency landed, and it is off by default

What changed

Epic implemented Adaptive Voxel-Based Order Independent Transparency, citing Drobot 2025 from Advances in Real-Time Rendering at SIGGRAPH 2025, covering both Nanite and non-Nanite translucency. It landed on ue5-main first and on ue6-main the same day, the latter with follow-up fixes squashed in (4402e92a). The ue5-main commits are cited in the 5.8 section below.

The technique approximates, for each event at depth z, the transmittance integral of everything in front of it, using a camera-aligned froxel volume. Occupancy of virtual slices is marked from the view-space depth ranges of visible translucent geometry and a prefix sum compacts them into physical slices, producing a depth-warp lookup table built on the GPU with no CPU readback. Translucent draws then splat extinction into that volume at reduced resolution, 1/8th by default, using InterlockedAdd. The commit is specific that no raster-ordered views are used anywhere and that the whole thing is built on plain UAV atomics, which is what distinguishes it from the existing r.OIT.SortedPixels MLAB path. Fully extinct 16x16 tiles emit depth-write quads so HiZ kills translucent pixels behind fully opaque smoke.

The switches matter more than the algorithm for most readers. r.OIT.Method selects at runtime, with 0 for none, 1 for AVBOIT as the default, and 2 for MLAB, and each falls back to standard sorted translucency where project or platform support is missing. The AVBOIT shader permutations are a project opt-in through r.AVBOIT.Support, which is read-only and defaults to off. Alongside it, r.Nanite.AllowTranslucentMaterials became a runtime toggle with a render state recreate sink, mirroring r.Nanite.AllowMaskedMaterials, where the previous r.Nanite.AllowTranslucency was read-only and needed a restart (ef4c92f9), and shader compile and stability fixes followed the same week (d4125ecf).

Why this is important

Read the two defaults together before you conclude anything shipped. The method selector defaults to AVBOIT, and the shader permutations that make it possible are off unless a project turns them on, so the practical default is unchanged and the fallback is ordinary sorted translucency. This is a feature made available, not a feature switched on.

There is also a content constraint stated plainly in the commit, and it is the sort of thing that costs a week if you find it by experiment: translucent materials must output their own luminance only. Materials that sample scene color self-composite the background, which the resolve then adds again. The commit calls this inherent to every transmittance-integral OIT, and says refraction and distortion are future work. If your translucent materials read scene color, evaluate that before evaluating performance.

Who should care

Graphics programmers, technical artists working on translucency-heavy content, anyone who has been maintaining a bespoke sorted-translucency workaround.

Urgency

Track, and read the content constraint before you schedule an evaluation.

Horde’s Mongo index creation stopped blocking startup

What changed

Index creation previously blocked server startup. The collection wrapper gated every operation on its index build, builds serialized behind a cluster-wide lock, and a build that failed three times faulted the wrapper, failing every subsequent operation on that collection for the process lifetime. Indexes are now built by a background MongoMaintenanceService registered ahead of all other hosted services. Operations are never gated on non-unique indexes; collections with unique indexes wait only until those are confirmed, bounded by a 30 second default. Only worker-mode writable instances build, others poll, and failures retry with capped exponential backoff. A unique build failing on duplicates moves all but the newest duplicate per key into a sibling .DuplicateQuarantine collection, copying before deleting, then retries (394690eb). Follow-ups reported build progress to the database audit log (9c51e0dd) and reordered things so unique indexes build first with the gate confirming them itself (19578c7b).

The same changelist added a diagnostics layer: operations issued during a request are stamped with a comment naming the caller, route template, and trace id, and an operation tracker retains the slowest of the last hour aggregated per user, route, collection, and command, surfaced through new admin-only endpoints and a Database Insights view.

Why this is important

The faulted-wrapper behavior is the one to internalize. A transient index build failure turning into permanent per-collection failure for the lifetime of the process is the kind of bug that presents as “Horde is broken, restart it,” which works, which means nobody diagnoses it. If you self-host Horde, this is a real availability fix, and the new diagnostics are the first time the server will tell you which caller is responsible for database load.

Who should care

Anyone self-hosting Horde, build infrastructure teams, studios running their own CI backplane.

Urgency

Act now if you self-host Horde.

The agent surface grew a module and a menu

What changed

The async tool call result was split into its own engine module, AsyncFunctionResult. It landed, was backed out, and relanded inside the window, and the relanded version reaches further, into the modular test runner (3cbf8b56). Around it, toolsets backed by a function library are now tracked for validity and retired when the backing class unloads, rather than lingering as registrations pointing at nothing (9adf873e).

The integration that matters is smaller. IEditorAIPromptProvider is a new editor-side interface in EditorFramework that lets tools contribute AI Assistant menu entries without depending on the AI Assistant plugin, which is off by default. The AI Assistant editor module implements it, so the section appears only while the plugin is loaded. The first consumer is Crash Diagnostics, which gained a right-click menu on crash rows with Copy Full Path, Open Containing Folder, and an Analyze Crash entry that opens a conversation about the crash under the cursor (d7b1a871).

Why this is important

A capability that needs its own engine module is no longer a plugin experiment, and a provider interface designed so the menu entry appears only when an off-by-default plugin is loaded is the shape of something Epic expects to be on for a lot of people later. The Crash Diagnostics choice is a deliberate one: it is the editor surface where a developer is already stuck, already has structured data in front of them, and has the least to lose from a model’s first answer being wrong.

Who should care

Tools programmers, pipeline and automation teams, anyone evaluating model-driven editor automation.

Urgency

Track.

Worth Tracking

Ness became something you can turn on. Twelve commits this week, down from last week’s twenty-one, but the shape changed. UE_WITH_NESS=1 is now a compile argument that enables Ness for any project without modifying the target directly, and Lyra is enabled by default in the Ness Test job (708358b4). Last week we said the commit messages do not explain what it is for and we were not going to guess. That is still true, and we still are not. What changed is that it now has an opt-in switch and a real game running through its test job, which is what a serialization layer does immediately before people outside the team are expected to try it. Keep it on the list.

A devirtualization option appeared with no discussion attached. bDevirtualizeFunctionCalls is a new target option enabling C++ virtual call devirtualization on the clang toolchain via -fwhole-program-vtables and -fforce-emit-vtables (7929ed04). The commit body is the title, and it carries four reviewers, which is more than most build options get. Whole-program vtables require link-time optimization to be meaningful, so this reads as connected to the distributed ThinLTO work that has been landing since early September rather than as a standalone flag. No measurements were published with it, which is the reason it is here rather than in the highlights.

What We Ignored

This week we ignored roughly 750 commits: localization automation, binary manifest drops for internal content pipelines, documentation generation, test-only fixes, editor UI polish, and the usual run of small cleanups. There were 17 commits tagged [Backout], inside the normal band for this branch and not a story on its own. Most relanded in-window, including the AsyncFunctionResult module split covered above and a fix making RigVM function libraries cook deterministically (a39dcf65, relanded at 3e145d8a).

Two that did not come back are worth naming, because both are cook-determinism work and this post spends a section arguing that campaign is going well. A cooker change serializing a null SoftObjectPath for paths pointing at objects found not to need cooking was reverted because it produced errors in AssetManager, which expects an array of FSoftObjectPath not to be empty (51aadf70). And a change skipping the GeometryCollectionComponent RestTransforms mismatch reset during cook, so that cooked output would stop depending on whether component registration ran before the save, was backed out on the last day of the window with no reland (46c3e48d). Both were still out of the tree when the week closed.

Of 963 commits, 210 worth reading. Scene graph and typed element work was the largest identifiable feature cluster at 65 commits, almost none of it individually notable, which is the same pattern that cluster has shown since August. Vulkan took a round of structural work including removal of the legacy VULKAN_ENABLE_DUMP_LAYER and VULKAN_ENABLE_WRAP_LAYER paths (2c1455fe) and buffer defragmentation support (cca2d1a4). Android fatal signal handling was reworked so the original faulting context is preserved and handed to the OS crash handler after engine reporting completes, times out, or the forwarded handler itself faults (ad9c3864). And a run of Clang 23 analyzer findings was addressed across the Win64 editor (d97fe6fc), which is worth knowing about if your own static analysis is about to get noisier for the same reason.

For teams shipping on 5.8

ue5-main ran 172 commits with 2 backouts, and this was not a maintenance week. Several items are worth a cherry-pick, and the first is the largest thing to reach this branch in weeks.

• Four months of cook and DDC determinism work arrived in one changelist. One changelist gathered cook, cook-metadata, and DDC determinism fixes from May through September 2026 into //UE5/Main, listing 34 incorporated CLs (d360778e). The list is worth reading in full, because the fixes are individually small and collectively describe every way a cook can be a function of something other than its inputs: derived-data key collisions between sound waves sharing a CompressedDataGuid, non-deterministic texture coordinate data in cooked static mesh data, owner-derived shader FriendlyName values baked into content-addressed shader map values for both ComputeKernel and OpenColorIO, an uninitialized padding field serialized into cooked cloth render data, a random StyleRule RuleId minted during cook saves, UBodySetup::BodySetupGuid as a random bumped GUID rather than a content hash, UStaticMesh::LightingGuid, material slot names, hlslcc transcendental constant folding that was not cross-machine deterministic, and Blueprint RNG nodes routed through FCookRand. That last one is the fix this briefing covered on ue6-main in the August 10 to 16 edition. Two of the entries are numbered parts of a seven-part “cook metadata determinism” series, so that series arrives only partially. The expensive cache bugs are the ones that produce correct output, and a cook that invalidates too often is indistinguishable from a project that is simply large. Expect invalidation on the first cook after taking it, for the same reason every determinism fix in this campaign has carried that cost. This is the week’s most actionable item for anyone on 5.x.
• The UE5 object version enum froze here too (93cb7201), the same change described in the highlights above. If you carry custom object versions on 5.x, the UE4 slot is now where the commit tells you to put them.
• HLOD bakes could produce black virtual texture pages that never regenerated. HLOD captures rendered a fixed number of warmup frames back to back, so virtual texture feedback was rarely read back in time, tile production stayed throttled, and adaptive RVTs refined only one grid cell per frame, meaning textures were captured before the RVT had converged. Separately, in the editor, shaders compile on demand from the first draws that need them and the RVT page pass falls back to the default material until then, so the first bake of a session produced black pages that were never re-produced. Capture view families now disable VT throttling, warmup waits for the GPU, tiles covering the captured bounds are requested explicitly at the captured resolution, and a warmup that triggers shader compilation now finishes it and warms up again. It also fixes a crash when force-building several HLOD actors from the details panel, where the render state recreate context held raw pointers to garbage-collected components (eaf526fb).
• Depth of field mixed colors across depth layers. Tiles containing both foreground and background pixels selected higher mip levels, so heavily out-of-focus areas bled colors from different depth layers into neighboring pixels. Tiles with both now select mip 0. The same commit fixes Diaphragm DOF sampling NaNs during CocFlattenMainCS on some platforms, and a recombine pass whose CoC radius disagreed with earlier passes when internal resolution was reduced, which produced blocky artifacts when upscaling (4676caf0).
• Global distance field recaching during streaming was excessive. Deferred update flags are now cleared after any recache, only one streaming clipmap recapture is allowed per frame, and mesh SDFs too small to meaningfully affect the result no longer trigger a streaming recapture (0a80d473).
• Two landscape crashes, both in code paths you hit by accident. Loading an old landscape that predates edit layers crashed semi-randomly (e26aa9a4), and a race condition crashed the landscape editor following an undo (448bfbab).
• PCG crashed iterating destroyed execution sources in the tracking manager octree. Entries now hold a weak pointer and skip destroyed sources, and unregister from the owning world subsystem on BeginDestroy (ae2a64d1).
• Control Rig crashed when switching the control type of a spawned control, fixed and then improved in the same week (ff852c4d, 0599fff5).
• Two UAF crashes: parallel module ticks resolving the same variable reference (5ff5b1a4), and VariableReferencePropertyCustomization used in a context providing no valid property utilities (74168ccd).
• Sequencer leaked on level removal. Removing a level containing a level sequence actor leaked through GC (340ec52c), and dropping an animation asset with the Anim Mixer plugin enabled asserted (906de4c1).
• Editor crashed reopening a docked asset editor after reloading the editor layout (5d4d8082), and Movie Render Pipeline crashed in the graph when rendering a sequence without audio while audio was enabled as an output (a37314fe).
• AVBOIT is on this branch too (a3f91409, 669b3d63, a86b5948), with the same project opt-in default described above. Worth knowing it exists on 5.x before someone on your team reads about it and assumes it is UE6-only.

Closing

The commit that mattered most this week changes one file, adds a static_assert, and alters no behavior at all. It just decides, permanently, which branch the engine’s version number comes from. Those are the ones worth reading the log for: the changes that cost nothing today and constrain everything afterwards, and that no release note will ever mention because, strictly speaking, nothing happened.

Commit SHAs are cited inline, in parentheses, next to each claim. They reference the ue6-main branch of EpicGames/UnrealEngine unless the claim is in the “For teams shipping on 5.8” section, which references ue5-main. Many of the highest-interest entries resolve to Commit.gitdeps.xml binary-manifest blobs: the commit message is real, but the code lives in Epic’s internal binaries, which we cannot see.

Week of September 7 to September 13, 2026 | 727 commits on ue6-main, 127 on ue5-main | Branch: ue6-main

Overview

Two small commits this week explain why your incremental cooks have been doing more work than they should. A class default object that mints a GUID in its constructor, and a component that writes to itself while being serialized, both made native class hashes differ between identical cooks, so dependent blueprints never cached and recooked every time. Neither commit is large. Both are the kind of thing you cannot find from the outside, because the symptom is a cook that is merely slower than it should be, not a cook that fails.

Around that, the week’s other through-line is the editor growing a tool surface built for a non-human caller. Epic shipped a native file-operations plugin, a plugin that reads your Codex and Claude configuration directories, an isolated undo buffer for tool calls, and a fix for a Model Context Protocol server that reported a live endpoint it did not have. On the build side, UnrealBuildAccelerator’s Linux port finally got the compressed-intermediates path that made the Windows path cheap. At 727 commits the week sits at the low end of this branch’s usual band, which is week-to-week variance rather than a slowdown.

Development Trends

The cook and cache determinism thread is now three months long

Pattern: every week since early August has carried at least one fix for a cache key that depended on something that is not an input. Shader job cache keys dropping at growth boundaries in early August, random numbers baked into packages the week after, cook metadata that did not match its own bytes at the start of September, and this week two separate sources of native class hash instability (25599f8a, 8c37fb4f) plus compile-relevant texture state that was missing from material shadermap keys (db1878a8).

Interpretation: this is not a bug cluster, it is a campaign, and the direction is consistent. Epic is making the cook reproducible by removing hidden inputs one at a time. Each fix carries a one-time invalidation cost and a permanent reduction in redundant work afterward. The pattern also tells you where to look in your own pipeline: the expensive cache bugs are not the ones that produce wrong output, they are the ones that produce correct output too often.

Who cares: build and CI engineers, anyone running incremental cooks on a farm.

Signal strength: Strong.

Agent tooling stopped being a plugin and started being infrastructure

Pattern: in-editor agent tooling has appeared in this report since mid-July, first as a toolset and crash-hardening audit, then as a background tool-call mechanism, then as reflection APIs reshaped around token cost. This week it arrives with a permission model with a restricted mode (f1f0470e), an isolated undo buffer so agent edits stay out of the user’s undo queue (6c091f40), a hardened Model Context Protocol transport (b11e879d), a catalog-caching proxy (8a6f9e96), and modal-popup suppression during tool calls (2ff22fa2).

Interpretation: the failure modes being fixed are the ones that only matter when a machine is driving. A human notices a modal dialog and dismisses it. An agent hangs on it. The presence of a restricted mode that hides read operations, not just writes, says Epic expects this surface to run against projects where the caller is not fully trusted.

Who cares: tools programmers, pipeline and automation teams, anyone evaluating model-driven editor automation.

Signal strength: Strong.

UnrealBuildAccelerator’s Linux port caught up, and its author concentration loosened

Pattern: we have flagged for a month that UBA’s commits came almost entirely from one author. This week it is 32 of 40, with a second author at 7. Last week it was 38 of 39. The work itself moved to Linux: compressed intermediate files (26ad0bae), a native visualizer on both Wayland and X11 (bf02cca5, 874ab3f1), and a fix for Ctrl-C not reaching UnrealBuildTool at all on Linux (ebf19945).

Interpretation: a second name in the commit log is the first movement on this in five weeks of watching it, and it is worth reading as capacity rather than as a handover, because the primary author’s volume did not drop. The Linux focus is the more consequential half. Compressed intermediates are the mechanism that made UBA’s remote-compile path cheap on Windows, and cloud build farms for UE studios are usually Linux.

Who cares: build and CI engineers, studios running distributed compiles on Linux agents.

Signal strength: Moderate.

The renderer decomposition started removing console variables, not just code

Pattern: the SceneData migration has produced a cluster every week since mid-July. The character keeps escalating. Converting call sites gave way to deleting the old ones at the start of September, and this week legacy primitive HZB occlusion culling was removed along with the r.HZBOcclusion console variable (a89416ed), while GetLumenSceneData moved out of FScene entirely (e9c15aa6).

Interpretation: a removed function is a compile error you fix in an afternoon. A removed console variable is a shipped configuration that silently stops existing, and anyone carrying it in a device profile or a studio default finds out at runtime. This is the point in a migration where the merge cost stops being mechanical.

Who cares: graphics programmers maintaining custom renderer code, anyone planning a UE6 merge for an engine fork.

Signal strength: Strong.

TL;DR

• Two commits fixed native class hashes that changed between identical cooks, so dependent blueprints stopped caching and recooked forever (25599f8a, 8c37fb4f). Expect a one-time invalidation of every dependent blueprint on the first cook after you take these, then less work permanently.
• -SkipOnlyEditorOnly=false is no longer supported and now activates a narrower reachability mode (7d0a26b5). Packages that were only ever pulled into your cook incidentally will stop being included. If you rely on that, declare the dependency.
• UnrealBuildAccelerator got compressed intermediate files on Linux (26ad0bae), and Ctrl-C now actually cancels UnrealBuildTool there (ebf19945).
• Epic shipped an agent-facing tool surface into the editor, including a plugin that discovers skills, agents, and AGENTS.md or CLAUDE.md from configured Codex and Claude directories (dc21275d).
• The renderer removed the r.HZBOcclusion console variable along with legacy primitive HZB occlusion culling (a89416ed).
• A Verse codegen fast path took script deserialization on a 5000-message repro from 15.5 minutes to 1.4 seconds (ac696db9).
• If you ship on 5.8: a per-bone blend setup fix that only affected cooked builds, a Sequencer duplication bug that overwrote the original’s anim sequence assets on disk, and a Vulkan regression that rendered large TMV plates black. All three are cherry-pick candidates, and they are covered with their commit references in the 5.8 section below.

Highlights

The cook has been recooking blueprints that never changed

What changed

Two independent sources of instability in the cook’s native class hash were fixed. HashNativeClass stringifies a class and its class default object to detect when a native class has changed. A default object holding a member whose constructor calls FGuid::NewGuid() hashes differently in every process, so the class reported as changed on every cook and its dependent blueprints never cached. The fix adds an opt-in filter flag for members already tagged as unstable at initialization, and tags three members that were missing it (25599f8a). Separately, USplineComponent::Serialize assigned LastAuthority whenever the archive reported saving, and the dependency hasher stringifies through an archive that reports saving, so hashing a class whose default object holds a spline mutated that object. Whether the stamped value landed in the hashed text depended on what else had serialized the component earlier in the process, which made the hash differ between identical incremental cooks (8c37fb4f).

Why this is important

These are the expensive kind of cache bug, because the output is correct. Nothing fails, nothing looks wrong, and the only symptom is that incremental cooks do full-cook work on blueprints nothing touched. Both commits note that the first cook after the change is a one-time invalidation of every dependent blueprint, so budget for one slow cook and measure the steady state after it.

Who should care

Build and CI engineers, anyone running incremental cooks on a farm, studios where cook time is a scheduling constraint.

Urgency

Act now.

The cooker’s reachability rules changed, and packages will cook out

What changed

-SkipOnlyEditorOnly=false is deprecated, warns when set, and now activates -Cook.RequiredReachability=Editor rather than the full behavior it used to provide. Two consequences are stated in the commit. Packages incidentally loaded while loading and saving a referenced package are no longer included in the cook unless they are declared in AssetRegistry dependencies or actually used in the cooked package. And in MultiPlatform cooking, packages required on one platform are no longer automatically added to the other platforms (7d0a26b5).

Why this is important

Incidental-load reachability is the sort of thing a project depends on without anyone deciding to. If an asset has been arriving in your cooked build because something else happened to load it during a save, it stops arriving, and the failure shows up at runtime as a missing reference rather than at cook time as an error. The MultiPlatform half has the same shape across platforms.

Who should care

Build engineers, anyone cooking for more than one platform in a single invocation, teams with large legacy content sets.

Urgency

Act now.

UnrealBuildAccelerator’s Linux port stops paying full freight

What changed

Compressed intermediate files landed on Linux, covering .obj, .o, .pch, and .gch (26ad0bae). The implementation hands the compiler process a real file descriptor to a session-owned file mapping, so reads, writes, and seeks go to the kernel rather than through Windows-style emulated file semantics over a shared-memory view. It also adds a clang linker dependency crawler so object files decompress in parallel as the linker opens them rather than serially. The commit states it is not enabled on macOS, because darwin cannot reopen a shared-memory object and file position would end up shared between processes.

The tail of bugs that followed is instructive, and all of it landed in the same week: a cross-device move of a streamed write truncating files to zero bytes, because the copy fallback used the creation size that compressed writers set to zero (c84a58fc); the copy fallback not preserving timestamps, so deferred cache creation re-read and re-hashed the file (bad3d287); and storage not reporting a size for a prefetched cache file, so the detour fell back to a directory-table size produced on a different machine (652609f3, a79c60b6).

Separately, Ctrl-C had stopped cancelling UnrealBuildTool on Linux. SetupOrphanReaper() called setpgid(0,0) without a following tcsetpgrp(), so terminal-generated SIGINT never reached the process. It sits in a startup path UnrealBuildTool calls unconditionally, so the executor you were using did not matter (ebf19945).

Why this is important

Compressed intermediates are the mechanism that made UBA’s remote-compile path cheap on network and disk on Windows. Linux agents have been paying full-size transfers for every object file and precompiled header. For studios whose farms are Linux cloud runners, which is most of them, this changes the transfer economics of distributed compilation. The accompanying bug tail is a fair warning that it arrived by being shipped and exercised.

Who should care

Build engineers, CI and infrastructure teams, anyone running distributed UE compiles on Linux agents.

Urgency

Act now if you are on Linux agents, and benchmark before and after rather than assuming the win.

Epic shipped an agent-facing tool surface into the editor

What changed

A cluster of work made editor tooling safe and available for a non-human caller. FileSystemToolset is a new plugin exposing nine native file operations, including reading images up to 64 MiB, listing directories, writing and editing text, deleting files, and downloading HTTPS URLs. It hides all nine tools, reads included, when a registered permission provider reports restricted mode, because native paths bypass asset permission rules (f1f0470e). Follow-ups raised the download ceiling (24b5b652), fixed directory listings for reserved Windows filenames (1b05afef), and fixed a crash where probing DNS names through ISocketSubsystem::GetAddressFromString translated whatever socket error happened to be pending and hit a check on Windows (814fef49).

AgentPluginToolset is also new, and it discovers Codex and Claude plugin manifests, direct child skills, agents, and AGENTS.md or CLAUDE.md from the current tool working directory, with deterministic capability IDs and rejection of names containing the characters used to delimit capability references (dc21275d). The registry underneath gained a real execution model: tool calls now receive a context carrying a cancellation token and an isolated undo buffer, installed for the duration of the call so agent edits stay out of the user’s undo queue (6c091f40, 4b8bace5).

Two fixes show the shape of the risk. FModelContextProtocolServer::Start requested its HTTP router before listeners started, so the server reported a configured endpoint that did not exist, and a second editor could connect to the first through the shared port (b11e879d). And because a comment box is a graph node that stores its label in the same field a node note uses, set_node_note overwrote comment box labels and reported success, which means an agent tidying notes across a graph would have quietly rewritten every comment box it touched (66ef7da5).

Why this is important

The details give away how seriously this is being taken. A restricted mode that hides reads rather than only writes, an undo buffer that isolates a caller’s edits, modal-popup suppression during tool calls (2ff22fa2), and editor screenshots forced to opaque alpha because the images are handed to a vision model that composites against an unknown background (f35c9967). These are not the concerns of a prototype. If you are planning editor automation, this registry is the surface to build against rather than a bespoke bridge.

Who should care

Tools programmers, pipeline and automation teams, anyone evaluating model-driven editor automation.

Urgency

Track.

The renderer removed a console variable, not just code

What changed

Legacy primitive HZB occlusion culling was removed along with the r.HZBOcclusion console variable, preserving hardware queries, mobile feedback, and feature-specific HZB consumers (a89416ed). GetLumenSceneData moved out of FScene and now returns a reference, so a Lumen-specific extension is no longer included across the whole renderer (e9c15aa6). Deprecated code was removed from Renderer and RenderCore (0ad1a9c8, 65641439).

The migration underneath continued at pace. Velocity moved onto scene data and dirty tracking, storing a persistent primitive ID rather than a scene-info pointer, with the registration set becoming a bool data array so freed IDs reset automatically and recycled IDs cannot inherit a stale bit (657a7a7d). Capsule shadows did the same, with the indirect-shadow gather reading proxies and bounds through read views (a589535d). A parallel iteration primitive landed for the whole migration to use (6d2cea0a). Hardware ray tracing is being re-homed the same way, moving primitive registration into a ray tracing scene extension (f76c2e3a) and splitting base and decal instances into separate cached entries for about 0.1ms of CPU time in the MegaLights demo (5ee6b5a9).

Why this is important

A removed function is a compile error. A removed console variable is a shipped configuration that stops existing, and a device profile or studio default carrying r.HZBOcclusion now sets nothing. This is where the merge cost of the SceneData work stops being mechanical, because the question is no longer whether your code compiles but whether it assumed an invariant that is gone.

Who should care

Graphics programmers maintaining custom renderer code, engine-fork maintainers, technical directors planning a UE6 merge.

Urgency

Act now if you maintain a renderer fork.

Verse load times: 15.5 minutes to 1.4 seconds

What changed

Islands with many <localizes> declarations hung on load. Each message initializer emitted roughly 19 property operands plus 5 temporary properties into the shared initialization function, and every operand deserialized through a field-path resolve that linearly scans the owner’s field list, making the whole thing quadratic in message count. A codegen fast path now emits simple message literals as a single MakeMessageLiteral call with 3 operands and 1 temporary. On a 5000-message repro, script deserialization went from 15.5 minutes to 1.4 seconds (ac696db9). The commit notes that other functions and types can hit the same pattern, and that the new VM does not, calling the VM swap the long-term fix.

Alongside it, a Verse interface-field memory corruption was fixed. The compiler’s check for which class controls an interface field’s C++ declaration succeeded for the first class to override the field without considering that a superclass may already have defined it, producing two copies of the field, with the subclass’s binding overwriting the superclass property’s offset (4b146290).

Why this is important

The number is the story. A quadratic in a load path is the kind of thing that is invisible at small content scale and fatal at large content scale, and the repro size where it becomes fatal is well inside what a shipping island can reach. The interface-field bug is the more dangerous of the two in a quieter way, since memory corruption from a compiler-side ownership check does not present as a Verse problem.

Who should care

Teams shipping Verse content at scale, anyone whose editor or cook load times have grown non-linearly with content.

Urgency

Act now if load times are a problem for you.

The Windows link step is in flux

What changed

Windows distributed ThinLTO backend codegen was corrected to match lld’s default optimization level for all backends and to restore function and data sections. The measured result on a Win64 Test build at the same head: the text section shrank from 525.0 MB to 440.4 MB, section hashes matched the in-process link, all 480,230 text functions matched in size, and backend warning lines went from 19,698 to zero (e2d40c29).

Rad Game Tools’ linker is being stabilized in the same window, with four binary drops in three days and a backout between them. One drop shipped a build carrying two patches, numbered 934 and 935, that the later drops do not (cfae9390), was backed out (6d00de1b), and the three later drops all list a different base and do not carry those two patches, so that specific build did not come back this week. Separately, radobj and radlink are now explicitly disabled when profile-guided optimization is being used, in both the optimize and profile directions (a3a141f6, c89635df).

ASan needed toolchain work on both platforms: forcing ASan libraries to the start of the library list and import table, because atexit table allocations were using unshadowed memory (f27dd11a), and fixing Linux server ASan runtime loading where an architecture suffix added during copy broke the dependency name baked in at link time (0920739a).

Why this is important

If you ship profile-guided optimized Windows builds, the radlink exclusion is a live constraint rather than a note. The ThinLTO numbers are worth having as a baseline: a correctly configured distributed backend should match the in-process link byte for byte, and if yours does not, the warning count is the tell.

Who should care

Build engineers on Windows, console and platform teams, anyone using PGO or sanitizer builds.

Urgency

Act now for PGO users. Track otherwise.

Ambient Lighting Volumes leave mobile

What changed

Diffuse from capture was extended to the desktop deferred Substrate non-Lumen path, with the renames that go with leaving mobile behind: bMobileDiffuseFromCapture became bDiffuseFromCapture, and r.Mobile.DiffuseFromCapture became r.ReflectionCapture.DiffuseFromCapture (8aca08e0). Tile-culled ALV sampling was added for Lumen screen probes and translucency lighting volume froxels, and the console variable dropped its experimental infix, from r.AmbientLightingVolume.Experimental.EnableForLumen to r.AmbientLightingVolume.EnableForLumen. Measured on PC on a level carrying many volumes, the Lumen probe gather went from 1.9ms without the acceleration structure to a stable 1.5ms with it, matching the cost of hiding all the volumes. World-space probes keep the brute-force path because they can sit outside the view frustum (7b246bea).

Why this is important

Dropping an experimental infix from a console variable name and removing a mobile prefix from a feature flag is a rename, not a documented status change, and it should not be read as a graduation. It is worth noting anyway, because a desktop consumer, a Lumen integration behind a non-experimental variable, and an acceleration structure arriving together is the shape a system takes in the weeks before a default changes.

Who should care

Lighting artists, graphics programmers, mobile and cross-platform titles.

Urgency

Track.

The CI flakiness fixes are worth less than their diagnoses

What changed

A run of Gauntlet and Horde fixes this week read as a postmortem series. Clearing stale artifacts between reservation-block steps deleted the entire user directory, throwing away the editor’s asset registry cache and pip environment, so every step after the first spent about three minutes re-gathering 22,000 assets and reinstalling dependencies before dispatching a single test, which was long enough for an idle console to be PLM-constrained and the run killed with zero tests reported (ca638a0f). The Android transfer budget was widened after measurement against the slowest device in the pool, and more usefully, a transfer timeout now raises a specific exception rather than a generic device exception that pulled a healthy handset out of the shared pool for every other job (b852b661).

The Horde ref index is eventually consistent and ref reads are not retried internally, which is why artifact retrieval intermittently returned not-found for artifacts that existed while jobs immediately before and after succeeded (0094ee23). A staged CLI binary update notes that the new binaries alone would have made macOS clones exit with an argument-parse error, because the new version removed a flag the caller still defaulted on for macOS (d9c0a9d4). Two more are the same class of bug from opposite ends: an audio device garbage collection race hitting about a third of scheduled runs in one test group (7ec88951), and a use-after-free where a screenshot taker only unbound from a process-global delegate if a game viewport client happened to exist (2f4cefc3).

Why this is important

None of these are Unreal-specific. Eventually consistent reads without retries, a cleanup step that deletes a warm cache, an error type too generic to keep a healthy machine in the pool, and a delegate unbind behind a conditional are all failure modes that exist in any device-based automation. The fixes matter to Epic. The diagnoses are the part worth stealing.

Who should care

Build and QA infrastructure, anyone running automated device testing.

Urgency

Track.

Worth Tracking

Something called Ness is being built in Runtime/Ness, and it is reaching into CoreUObject. Twenty-one commits this week touch NessCore, NessUObject, and a NessEngine plugin: property bindings split per container kind, packets, load plans, diffing, roundtrip tests, an export map describing each export with a saved index and state, and hooks landing inside CoreUObject itself. One crash fix around map property bindings in Lyra reached the high-interest tier (5d187f0f), and the rest sat below it. The commit messages do not explain what it is for, and we are not going to guess. What is worth noting is the shape: a new serialization and binding layer, with its own module split, arriving alongside changes to the default save path. A new layer under CoreUObject is not a plugin experiment, and it is the sort of thing that is obvious in hindsight three releases later. We will keep counting it.

AutoRTFM is becoming per-module policy rather than one global switch. EpicClang gained a flag taking a mapping file that assigns default modes to directory paths, and an unmapped file path now raises a diagnostic rather than defaulting to enabled (3e96f550). UnrealBuildTool gained a matching ModuleRules.AutoRTFM property with the legacy flags kept as facades, explicitly changing no build files yet and not yet passing the new compiler flag (0d034f4c). The diagnostic on unmapped paths is the part to watch, because it means Epic now expects every file in the tree to have a declared mode. If you maintain out-of-tree modules, the migration commit that 0d034f4c promises is the one that will reach your build files.

What We Ignored

This week we ignored roughly 550 commits: localization automation, binary manifest drops for internal facial and PCG content pipelines, test-only fixes, XML documentation comments, editor UI polish, and the usual run of small cleanups. There were 15 commits tagged [Backout], which is inside the normal band for this branch and not a story on its own. Of them, the ones worth knowing about are covered above or did reland in-window. Two did not come back this week: USD runtime memory overloads (e43099c2, backed out by 84d4e02e) and a Composure compile fix (a929b1df, backed out by fd799bbc).

Build is the top subsystem at 97 commits, followed by editor and core at 61 each and rendering at 59. Of 727 commits, 160 worth reading.

For teams shipping on 5.8

ue5-main saw 127 commits this week with no backouts at all, and it is not pure maintenance. Most of the volume is Control Rig, RigVM, Sequencer, and Movie Render Graph authoring polish, but several fixes are worth a cherry-pick if you ship on 5.8 today.

• A per-bone blend regression that only affects cooked builds. InitializePerBoneBlend had been moved inside a WITH_EDITOR block, so per-bone blend setup ran in editor builds and silently did nothing in a cooked game (55537993). This is the most consequential fix on the branch this week, and it will not reproduce in PIE.
• A Sequencer duplication bug that overwrote assets on disk. Duplicating a level sequence left the copy sharing the original’s link items, so saving the duplicate re-exported over the original’s linked anim sequences and stole their back-links. Duplicating an anim sequence copied its back-link untouched, leaving two anims claiming the same binding. The fix strips links from the duplicate by default. Note the intentional behavior change: a duplicated sequence no longer drives the original’s anims, so anyone relying on that sharing has to relink (0c2b200c).
• A Vulkan regression that rendered large TMV plates black. The intermediate target hint gated a reserved-resource flag on a global that only says the RHI can create the virtual resource. Vulkan reports true, but only D3D12 has a sparse output backend registered, so the texture got address space and never a committed tile. Only plates whose mip 0 exceeds the sparse-output threshold requested the flag, which is why HD and 4K kept working (4157725d).
• Two Control Rig bugs that produce wrong data rather than wrong UI. Applying multiple poses collapsed the hierarchy to the origin when every pose weight fell below relevance, because the empty influence list fell through to the branch that widens selection to every bone and wrote identity transforms into all of them, with a stale cache keeping it doing so on later frames (398093ba). Separately, baking animation onto a control rig lost timecode attributes on both bake paths (190216d6).
• Animation runtime crashes. A rig hierarchy could not grow past four megabytes, which an AnimSequence bake writing thousands of curve controls hit (ea26c7c5); an unresolved function table was indexed with a bytecode callable index (b9abdf96); and a pose adapter asserted when a Control Rig recompiled while it was ticking (318396f9).
• Three compile breaks that only show up on build farms. A missing editor guard that broke the non-unity build (c3806dae), a mismatched guard in a dynamic property test (978eacc6), and a Composure compile failure from a merge (4f3ecf85). The first matters if your farm builds non-unity for warning cleanliness.
• Deprecations, including one naming 5.9. Composure deprecates two members in 5.9 while retaining compatibility for now (5f2f217f), and a MovieScene decoration accessor is deprecated in favor of a new one as decorations move to instanced structs (9e6c2d04).
• A custom version bump on a maintenance branch. The Anim Sequence Transform Provider gained per-sequence and per-pose GPU instance bounds with readback and a runtime sequence allocation API, and it adds an entry to the stream object versions (1be8db07). Worth reading carefully before merging if you carry local engine changes.

Closing

The two commits that mattered most this week are four files between them, and neither one fails anything. They just made the cook do work it had already done. That is the class of problem worth building a habit around: the cache that is always correct and never warm costs you more over a year than the bug that breaks the build, because the bug gets fixed the day it lands.

Commit SHAs are cited inline, in parentheses, next to each claim. They reference the ue6-main branch of EpicGames/UnrealEngine unless the claim is in the “For teams shipping on 5.8” section, which references ue5-main. Many of the highest-interest entries resolve to Commit.gitdeps.xml binary-manifest blobs: the commit message is real, but the code lives in Epic’s internal binaries, which we cannot see.

Week of August 31 to September 6, 2026 | 862 commits on ue6-main, 110 on ue5-main | Branch: ue6-main

Overview

The two most consequential changes this week have one-line commit messages and no release note. Live Coding 2 became the default, and the input thread was enabled on game input platforms. Neither was announced, both change how the editor behaves on your machine, and both have commit bodies shorter than their titles. Around them, build and cache infrastructure kept consolidating: distributed ThinLTO landed end to end, the DDC backend inventory started getting cut down to Zen for 6.0, and Zen turned server lifecycle into a documented contract, including one change that breaks health probes. On the rendering side, the SceneData migration stopped converting call sites and started deleting the old ones, which is the week renderer forks feel.

Development Trends

Build is the product surface in UE6

Pattern: build has been the top high-interest subsystem for eight weeks running, and this week it accounts for 108 of the 197 commits worth reading. Over the same window it has held a narrow band (98, 87, 61, 85, 121, 117, 98, 108) instead of spiking and decaying like a push.

Interpretation: the composition has shifted. Cache-server firefighting dominated earlier weeks. This week is feature work with contracts attached: a distributed link step, machine-readable lifecycle results from Zen, a deprecation warning wired into BaseEngine.ini. The work has moved from stabilizing the build to deciding what 6.0’s build story is allowed to depend on.

Who cares: build and CI engineers, anyone maintaining an internal fork of UBT or BuildGraph.

Signal strength: Strong.

Unreal Build Accelerator is still one person

Pattern: 38 of this week’s 39 UBA commits carry a single author. Checking the four prior weeks in the same way: 26 of 28, 43 of 50, 37 of 37, and 20 of 20. Five weeks running.

Interpretation: we have flagged this for a month now and the concentration has not loosened. The work continues to check out as careful, well-reasoned engineering, and this week includes the single best root-cause writeup in the window. The risk here is structural, not a quality problem. A build accelerator that a growing number of studios depend on has one person holding its correctness surface.

Who cares: studios adopting UBA as core CI infrastructure.

Signal strength: Strong.

The renderer decomposition moved from converting to deleting

Pattern: the SceneData and scene-extension migration has produced a fresh cluster every week since mid-July, and this week the character of it changed: FPrimitiveSceneInfo::PackedIndex was removed outright along with the sorted-order machinery in FScene, rather than another round of call sites being converted.

Interpretation: deprecation shims protect you from a renamed function. They do not protect you from a removed invariant. The prior seven weeks were survivable for a fork by fixing compile errors. This one requires knowing whether your code assumed FScene’s arrays were kept in sorted order.

Who cares: graphics programmers maintaining custom renderer code or engine forks.

Signal strength: Strong.

Epic is shaping editor tool APIs around language-model cost

Pattern: one commit names token cost as its engineering motivation, in those words, rewriting property addressing because the old shape “routinely cost tens of thousands of tokens.” Two more are shaped by the same pressure without naming it: a log toolset now caps each returned entry so a single engine line cannot swamp a caller’s budget, and typed toolset returns replaced JSON strings so the model reads results directly instead of writing a throwaway script to parse them. A fourth preserves an explicit Claude Code override in the experimental terminal plugin’s keyboard negotiation.

Interpretation: the in-editor agent work has moved past plumbing. When a team rewrites a reflection API because of what it costs a model to read, the agent has become a consumer the engine API is designed around. One commit saying so plainly is a weaker signal than a trend, which is why this is worth watching rather than concluding.

Who cares: tools engineers, anyone building editor automation.

Signal strength: Moderate.

TL;DR

• Live Coding 2 is on by default, and so is the input thread on game input platforms. Both landed with a one-line commit message and no announcement, and both change local editor behavior after your next sync.
• Zen 5.8.21 changes what /health/ready means. It now answers 503 between route registration and actual readiness, where the catch-all previously answered 200. If your CI treats that path as a liveness probe, it will start reporting a healthy server as down.
• FPrimitiveSceneInfo::PackedIndex and FScene’s sorted-order maintenance are gone. Renderer forks that index into scene arrays by packed index break here, and the deprecation shim does not cover the removed sort invariant.
• Three unrelated systems hit the same worker-starvation deadlock in the same week: AssetRegistry, the shader code archive, and UBA’s macOS process supervision.
• If you ship on 5.8 rather than tracking ue6-main, four fixes are worth cherry-picking this week, including a Mac process-tree bug that leaves an orphaned UnrealBuildTool holding the global mutex until you reboot. See the 5.8 section at the end.

Highlights

Live Coding 2 and the input thread are on by default

What changed: Live Coding 2 was enabled by default in a commit whose entire body is one bullet point, touching a single build file (b3de9a0e). Supporting work the same week enabled its target build, on-demand cross-process activation, and a compile-readiness query (c8d36548), and skipped the Live Coding hotkey listener thread in commandlets (0ff624e6). Separately, the input thread was turned on for game input platforms, moving input off the game thread, with -NoInputThread as the escape hatch (ee858a9b). Two same-week fixes back it: stuck controller input on disconnect (14a1830b) and a re-entrancy ensure in the async input consumer drain, itself called out as a regression (ac09c713). A third default flip enabled Verse access-specifier authoring and enforcement (40ff6c4e).

Why this is important: these are the changes most likely to alter what you experience next week, and the least likely to be noticed. Live Coding 2 becoming the default is an iteration-time change for every programmer on Windows. Moving input off the game thread changes timing characteristics for input-sensitive gameplay code, and the two follow-up fixes show it is finding real edges. Downstream, LiveCodingConsole was removed from the installed-engine build because Live Coding 2 brings its own broker (53fc59a2), so an installed engine you produce now ships different artifacts.

Who should care: everyone. Programmers for the iteration change, gameplay engineers for input timing, and build engineers for the installed-engine artifact difference.

Urgency: Act now. Not because anything is broken, but because you should know your defaults changed before you debug a timing difference you did not introduce.

Distributed ThinLTO lands end to end, and the linker keeps changing underneath it

What changed: UnrealBuildTool can now hand ThinLTO backend compilations to UBA as distributed jobs instead of running them inside the linker, behind -ThinLTODistributed and off by default (20efe89f). The UBA-side implementation followed: distributor JSON parsing, path conversion, argument quoting, linker temp files registered as virtual inputs without copying, and the waiting linker’s scheduler weight released during backend execution (17ece9ab). Two follow-ups fixed what a real farm exposed. Virtual basenames were normalizing into invalid paths in the job manifest, and because ThinLTO uses the input path as the module identifier, substituting a physical alias broke index lookup and crashed the backend (6ef3b91c). Backends exiting zero had all output except lines containing “error” silently dropped, so distributed warnings were invisible unless something failed (7d9ffd56).

Why this is important: the link step is often the last serial bottleneck in a shipping build, and this is the first credible path to distributing it. The pace matters as much as the feature: implementation, manifest contract, path-identity fix, and diagnostics fix inside four days. A farm is setting that schedule, not a design document. Underneath it, Epic dropped five Radlinker binary revisions in four days (bcc3b1cd, b9f958b9, e0244a88, deffbde0, b93cddc7), which means a Commit.gitdeps.xml sync is now potentially a linker change.

Who should care: build engineers, toolchain owners, anyone whose shipping link step is the long pole.

Urgency: Track, and act now if you already run LTO builds on a UBA farm. It is off by default, so nothing changes until you opt in.

UBA’s hardest bugs this week were on macOS and Linux

What changed: 39 high-interest commits carry the UBA tag, and 19 of them are Visualizer work. The new Visualizer was added as a parallel tree, improved twice, then dropped on top of the original directory with files overwritten and reconciled, and the shim target deleted, all on the same day (aabd63fa, 31989735, 4ec26bb6, ad444118, 88a3f651). The important work is elsewhere. On macOS there is no PR_SET_CHILD_SUBREAPER, so waitid on a grandchild returns ECHILD whether it is alive or dead, and UBA treated that plus zero received messages as an exit (13b4f0ea). Since UBT spawns clang++ which spawns cc1 and ld, every compile and link child is a grandchild. The host was destroying a live process’s shared events and returning its communication slot to the allocator, which handed the same slot straight back out. Two more: fixed-address snapshot collisions are now rejected on Mac rather than mapped over live child mappings, and POSIX fatal-signal reporting now exits without RPC cleanup to break a deadlock where clang’s crash handler waits on an RPC while the host waits for clang to exit (cb4a3a1c). Network-layer work covered connection-loss handling during cancellation (0369c997), an agent-listen race with a 15 to 45 second reaction window (84dfad3a), and asynchronous handshakes so a stalled one stops blocking later connections (2bbbd6b2).

Why this is important: the grandchild fix is the most useful commit in the window to read in full. The failure it describes is invisible in exactly the way distributed build failures usually are: a live process’s slot gets recycled, and the corruption surfaces somewhere unrelated. If you run UBA agents on macOS or Linux and have been writing off intermittent farm failures as flakiness, this is a plausible mechanism. The fixed-address collision commit hedges carefully: the unsafe mapping is a possible initial corruption source, not a proven cause of that particular farm failure. Read it with the hedge intact.

Who should care: build engineers and CI operators running distributed compile farms, especially cross-platform ones.

Urgency: Act now if your agents run on macOS or Linux.

Zen 5.8.21 turns server lifecycle into a contract, and changes what a health probe means

What changed: a one-line Commit.gitdeps.xml bump carries the longest release note in the window (84ae3c43). zen up, zen status, and zen service status accept --output-path and write a structured result carrying effective port, pid, session id, readiness, and data directory, so callers stop scraping console text. Exit codes now identify causes, and the full contract is documented. The behavior changes matter more than the features. /health/ready answers 200 only once the server can serve requests, 503 before that and again once shutdown begins, where the catch-all previously answered 200 as soon as the health routes existed. And an unrecognized path under /health/ now answers 404 instead of 200. Lifecycle semantics tightened too: zen up reuses a server that is already starting rather than racing it, and zen down refuses --pid 0 and -p 0, which previously let an unset script variable expanding to zero stop an arbitrary server. There is also a real security fix: the oidc-exe-path request field is now ignored, closing a local privilege-escalation hole where a client could name an executable for the server to launch.

Why this is important: this release closes the gap between “my script ran zen” and “my script knows what zen did,” and it closes it by making previously permissive responses strict. The health-probe change is the one that bites without warning, because a probe pointed at /health/ready used to succeed for the wrong reason. Probe /health for liveness. The --pid 0 refusal is worth checking your own scripts against.

Who should care: build and CI engineers, DevOps, anyone scripting zenserver lifecycle or cook infrastructure.

Urgency: Act now if you script zenserver in CI.

The DDC backend inventory is being cut down for 6.0

What changed: eight commits from one engineer, all sharing a synced changelist, systematically retire DDC backends. S3 DDC was deleted outright, with the commit stating that for 6.0 its users can move to Cloud DDC or build on the pak file cache or its forthcoming replacement (e5a7f7b4). The FileSystem cache store now emits a deprecation warning when used, wired into BaseEngine.ini and ShaderCompileWorker’s DefaultEngine.ini (761cd96c). Deprecated graphs and stores were removed from configs (8fb6585c), 5.8-deprecated code removed (2962e510), the DDC IO thread pool is created lazily only when a store needs it (7d6e0e25), and Jupiter access-token races were fixed (31611935).

Why this is important: the FileSystem cache store is the shared-DDC-on-a-network-share setup plenty of studios still run, and a deprecation warning is the first shot rather than the last. Read alongside the S3 removal and the Zen investment, the practical direction for 6.0 is Zen or Cloud DDC. Nothing this week removes the FileSystem cache store. It warns.

Who should care: build engineers, studio IT, anyone running a shared DDC.

Urgency: Track. Start the conversation about what replaces a network-share DDC before it becomes a 6.0 upgrade blocker.

The packed primitive index is gone from the renderer

What changed: FPrimitiveSceneInfo::PackedIndex was removed, GetIndex() deprecated and redirected to the persistent primitive id, and the machinery that kept FScene in sorted order removed along with the extra copies of added and removed primitives and TScenePrimitiveArray (c281fdce). A companion commit folded FPrimitiveSceneInfo::AddToScene into FScene::ProcessPendingAddToScene (1c348679). Conversions feeding it landed the same week for Nanite custom-depth visibility (c799f3cd), mobile CSM subject primitives (86f9b991), and ray tracing group ids moving into the ray tracing scene extension (8861cfe5). Two real races were fixed on the way through: the uniform-buffer update path was decoupled from GPUScene dirty state, fixing a race where light map allocations raced the update (85df40a2), and dirty-mask marking now validates its access context the same way per-element writes do (b21d5926).

Why this is important: code that assumed FScene’s arrays were maintained in sorted order will compile and then be wrong. The previous seven weeks of this migration announced themselves as compile errors. A removed invariant does not. A batch of deprecated includes was also removed from RenderCore and Renderer headers the same week (5e2a1be7), so expect merge conflicts on top of the semantic change.

Who should care: graphics programmers, engine-fork maintainers, anyone with plugins that reach into scene arrays.

Urgency: Act now if you maintain a renderer fork.

Nanite hardware ray tracing stops guessing at memory, and the light paths are being unified

What changed: two Nanite fixes undo the same class of mistake, using a proxy for a number instead of the number. The CLAS address reservation was a worst-case product of BLAS count and resident clusters, which caused out-of-memory failures on large assemblies; it is now a per-part capacity vector fed by readback of the cluster count hierarchy traversal actually emitted, with the base mesh BLAS still using the old value so it is never skipped (f837c054). The BLAS cache-hit test was per-BLAS when only the base BLAS seeds traversal, so a part could miss the cache, get a null address, and have no path to rebuild; a new pass now folds per-slot cache-miss results into a per-geometry rebuild flag (eea475df). Separately, FRTLightingData was removed in favor of FForwardLightData, unifying ray-traced hit lighting with the forward light path (eaff98e0), and LumenRef’s direct lighting now routes through MegaLights material and shading functions, fixing wrong hair appearance and bad subsurface demodulation (f826d845).

Why this is important: the Nanite memory work makes assemblies with hardware ray tracing materially more usable than a week ago. The commit says the change significantly reduces memory overhead on large assemblies that previously caused out-of-memory issues, and it does not quote a figure, so neither will we. The light-path unification is the theme most likely to produce visual diffs in a fork: lights are no longer skipped from ray tracing when “affect ray traced reflections” is disabled, because they may still be used by GI or ray-traced translucency. That behavior change is deliberate.

Who should care: graphics programmers shipping hardware ray tracing, lighting and look-dev teams comparing offline reference against realtime.

Urgency: Track, and benchmark before integrating if you ship Nanite assemblies with hardware ray tracing.

Worker starvation was the bug of the week, in three unrelated systems

What changed: three systems independently hit the same failure. A thread that is itself a task worker blocks waiting on another task, and with enough concurrent waiters no worker remains to run the thing being waited on. AssetRegistry’s mount register and unload paths were converted to continuations instead of waits, with per-provider state replacing a registration critical section and a new join built on task retraction so the synchronous wrappers cannot deadlock when called from a task thread (8070e00e, 26cae9d1). FShaderCodeArchive::WaitForPreload was waiting on the task completion event alone, and now waits on the reads and retracts and executes when done, tested at 16 preloads against 6 workers (a86de5f6). UBA’s macOS process supervision, covered above, is the third (13b4f0ea). Alongside them, a set of use-after-free fixes with real root causes: a Slate render-thread use-after-free of cached clip states, with release deferred to the render thread (e7640b2a), a dangling reference when initializing maps from a tuple with converting element types, which touches core container headers and so reaches everything (c76e7d6b), and a FastGeo async render-state job outliving its container where the previous guard was itself the use-after-free, because testing the object read it (9623ab20).

Why this is important: the pattern is more useful than any individual fix. If your codebase calls a blocking wait from anything that could be running on a task thread, that is this week’s homework, and three separate Epic teams just paid for the lesson. The FastGeo case is the one to internalize: a validity check that dereferences the thing it is validating is not a guard.

Who should care: everyone touching runtime, editor, or tools code with task-graph usage.

Urgency: Act now on the pattern, track the individual fixes.

Cook determinism: the bytes matched, the metadata did not

What changed: a numbered seven-part series is landing fixes for non-deterministic cook metadata, meaning the recorded build dependencies rather than the cooked output. Three of the seven appear in this window. An anim sequence sync-marker refresh is now skipped under the cook commandlet, because the package access tracker was attributing blend-space sample reads to whichever asset happened to be post-loading (0b4e3fb9). Shader-symbol config queries were wrapped in an ignore scope (a806e358). Static mesh ray tracing config access was replaced with an explicit per-platform cook dependency function (ea91bf83).

Why this is important: the commit bodies quantify it from a real oplog diff. 46,377 anim sequence packages, 28 percent of the 168,009 affected, had byte-identical cooked output but different recorded dependencies. Shader symbol settings accounted for another 8,820, and static mesh ray tracing for 13,334, where most meshes never recorded the dependency at all and so would not have been recooked when the setting changed. Recorded dependencies are what decides whether an incremental cook or a shared DDC hit is valid. If you have watched an incremental cook rebuild a third of your content for no visible reason, this is a mechanism that explains it. The static mesh fix also names a specific multi-platform failure, where Linux ray tracing settings bled into Windows client artifacts on shared cook workers because editor config reads are recorded platform-agnostically.

Who should care: build engineers, anyone running incremental cooks or a shared DDC across platforms.

Urgency: Track. Four of the seven fixes are not in this window, so the series is not finished.

Worth Tracking

The Slate render-transform fast path is written, fixed twice, and still switched off. The optimization landed with its cvar enabled after testing across several titles (27cc168f), an always-clip ancestor edge case followed (9e12c736), and then the cvar was turned back off, described as temporary (87b84a83). Two fixes landed after that: a guard against a non-invertible accumulated transform producing NaN (7ab7a263) and the render-thread use-after-free noted above (e7640b2a). Nothing in this window turns it back on. If it re-enables next week, it is a real Slate invalidation win for heavy HUD and menu hierarchies.

Verse’s move to UnrealHeaderTool did not ship, whatever a changelog implies. The conversion from Verse’s native interop generator to UHT landed on September 1 (70a84c52) and was backed out on September 4 (adef434b), later by changelist number, with no reland in this window. Worth a line only because the net state is easy to get wrong: the preparation work landed and stayed (3d7c9488, 72262635, 9bfa3fa9), so the surrounding commits read like a shipped migration. It is not one yet.

An experimental UV parameterization and atlas system is getting optimization passes nobody is discussing. The JOULE plugin tree carries atlas packing, genus cuts, seam opening, quadric collapse reduction, and a voxel lattice core. Four commits this week, all from one author under one ticket, cover a seam-aware field transfer (c80b5540), quadric collapse optimization with cached edge partners (eb3f8c4a), a caching pass for mesh traversal patterns (2e835f31), and disabling static analysis on the build target (7495b514). That last one is routine for a fast-moving experimental target and should not be read as a quality signal. The reason to watch: the plugin is about four weeks old and already receiving cache-locality work, which is not what a shelved prototype gets. A first-party automatic UV unwrap and atlas generator in the engine would displace a category of DCC and third-party tooling.

What We Ignored

We ignored 427 low-interest commits and 36 filtered as noise. The bulk was routine: localization automation against Commit.gitdeps.xml, template fixes, content drops with no engineering signal, cosmetic robomerge commits, and a long tail of narrow editor crash fixes each affecting one repro. We also set aside 26 commits that touch only Commit.gitdeps.xml, where the change lives in the binary manifest rather than in anything readable. Two were opaque enough to name rather than summarize: a commit enabling divergence emission and one turning off a debug visualization, neither attributable to a named system.

For teams shipping on 5.8

ue5-main saw 110 commits this week, and it was not pure maintenance. Several fixes are worth a cherry-pick if you ship on 5.8 today, and the rest is editor-tooling crash cleanup plus localization and template churn.

• Two runtime regressions worth cherry-picking. A per-frame memory leak in Vulkan parallel render passes under dynamic rendering, merged from a community pull request (9f7521b8). And a Nanite LOD scaling regression where HZB sizing fed the temporal upscale factor into LOD selection, and split-screen used the whole view family width instead of the per-view width (37bf9329).
• A World Partition data-drift fix. Actor descriptors now serialize root component absolute transform flags, so saving a parent no longer drifts children using absolute location, rotation, or scale (53fdc035).
• Two packaging and build-farm blockers. iPhonePackager now signs frameworks embedded in the app bundle before the app itself, each with its own bundle identifier and resources, with a flag to fall back (739e7143). On Mac, terminating a process tree walked only one level of children, so a canceled editor package left an orphaned UnrealBuildTool holding the global mutex and every later package failed until reboot (6b110837).
• A crash-report sweep. Eight crash fixes carry adjacent ticket numbers, covering the accumulation depth-of-field viewport preview (0f00e5be), Control Rig keying after teardown (2747b9ce), a RigVM pin lookup (527d596f), two PCG crashes (7a256025, 902082dd), skeletal mesh reduction and conversion (d1ab8e1c, 4cf4f905), and SVG import (13e5bb9d). Separately, TextureGraph export no longer crashes under -nullrhi, which is how build machines run it (db794640).
• One fix took three tries, one change did not ship. Ordered by changelist trailer: the Sequencer curve editor delete crash landed (8716261c), was backed out (c76fe104), then relanded a day later with a note that the fix has to stay header-defined or the animation tests fail to link (bcb68395). The FK Control Rig quadratic-initialization fix relanded after two prior backouts (884772cd). Control Rig variable overrides landed and were backed out the same day (49d9136f, then dd3e0b00), with no reland in the window, so that one did not ship.
• Epic is still landing deprecations in 5.x. Using the FileSystem DDC cache store now emits a deprecation warning here too (80d04074), which matters if your shared DDC sits on a network share.

Closing

The headline changes this week were the ones nobody wrote a release note for. Two defaults flipped, a health probe changed meaning, and a renderer invariant disappeared, all in commits short enough to scroll past. Read the commits. The changelog will not have any of it.

Commit SHAs are cited inline, in parentheses, next to each claim. They reference the ue6-main branch of EpicGames/UnrealEngine unless the claim is in the “For teams shipping on 5.8” section, which references ue5-main. Many of the highest-interest entries resolve to Commit.gitdeps.xml binary-manifest blobs: the commit message is real, but the code lives in Epic’s internal binaries, which we cannot see.

Week of August 24 - 30, 2026 | 918 commits on ue6-main, 174 on ue5-main | Branch: ue6-main

Overview

This was a rendering-and-tooling week more than a rendering-and-crashes week: the FScene-to-Scene-Extensions decomposition reached ray tracing specifically for a second straight arc, LumenRef kept building out its direct-lighting path, and a chunk of legacy rendering code (SSGI among it) got deleted outright. Away from rendering, a single engineer carried Unreal Build Accelerator’s correctness work for a fourth consecutive week, and a second engineer shipped a large, previously untracked campaign on Unreal Toolbox (the internal developer-tool distribution app). The AI editor assistant’s background tool-call mechanism relanded after repeated backouts. Nothing here is an emergency for most teams, but the ray-tracing API surface is visibly stabilizing and worth reading if you maintain a renderer fork.

Development Trends

Renderer Decomposition Reaches Ray Tracing Directly, Seventh Consecutive Week

Pattern: FScene’s split into modular Scene Extensions has produced a fresh cluster every week since reopening July 19. This week the target is explicitly ray tracing: static mesh cache data and machinery moved out of FScene/FPrimitiveSceneInfo into a new FStaticMeshSceneExtension (4a8f93d6), NativeInstances was renamed to TLASInstances (967e1001), FGeometryManagerHandle was refactored “to simplify upcoming changes” (41fadeba), Nanite-tagged ray tracing instance processing moved into Nanite::FRayTracingManager (a34192d5), and PrimitiveRayTracingFlags/PrimitiveRayTracingDatas plus path-tracing invalidation moved into FRayTracingSceneExtension (26233121). UE_INTERNAL was dropped from RayTracingInstanceBufferUtil.h (767182ba), which reads as the API settling into something other teams are meant to build against. The same arc produced a real fix: skeletal meshes were dropping out of the TLAS entirely when r.RayTracing.DynamicGeometry.MaxUpdatePrimitivesPerFrame was enabled (8a51a944).

Interpretation: seven straight weeks of continuous evidence, with this week narrowing from general scene-storage refactoring to ray tracing specifically. The UE_INTERNAL removal is the clearest signal yet that a chunk of this surface is stabilizing rather than still churning.

Who cares: renderer and engine-core teams, especially anyone maintaining hardware ray tracing or Lumen HWRT in a fork.

Signal strength: Strong. Seven weeks of continuous, substantive evidence since reopening July 19.

Build Infrastructure: UBA Correctness Work Continues, One Engineer Still Carrying It

Pattern: Build stayed elevated at 98 commits (down from 121 and 117 the prior two weeks, still well above the pre-July baseline). Unlike the last three weeks’ architecture passes (multi-tenancy, then a three-front rebuild), this week is a return to smaller, numerous correctness fixes, nearly all from the same engineer: a known-inputs streaming feature for the scheduler’s YAML config (f0365f92, e605db48), a compression double-encode fix for RAD OBJ files (29c9b0ef), a COFF-writer padding fix specifically so RAD Linker stops choking on the output (ab784a2a), removable-cache memory-leak diagnostics (31eece04), invisible folders and per-process overlay directories (422e38eb), a POSIX stat fix for leading parent-relative paths (643b90af), and exact cache-entry offset-vector reallocation during maintenance (541ed2ff).

Interpretation: the same single-engineer concentration flagged the last two weeks continues into a fourth week. The work itself keeps checking out as sound, narrowly-scoped correctness fixes, but the bus-factor risk is now a month-long pattern, not a one-week anomaly.

Who cares: build and tools teams running distributed builds through UBA.

Signal strength: Strong. Fourth consecutive week of concentrated single-author UBA activity.

AI Editor Assistant: Background Tool-Call Mechanism Relands After Repeated Backouts

Pattern: The AI assistant’s mechanism for backgrounding a long-running tool call (running it in a bounded window, then posting the result back to the conversation once it finishes) shipped this week at da58b851ec, citing a prior backout, and again at a515a8f521, citing two prior backouts (tracked under UE-390053). A related crash fix landed cleanly: the test spec backing this feature held its tool promise as a plain member that a background-static destructor tried to fulfill, crashing any process that loaded the plugin without running the test (fc4f1566b5). Separately, AIAssistant and MCPClientToolset were split into standalone EditorAndProgram/editor module pairs (4bff8240d1), and MetaSound’s agent-tooling integration was promoted out of an internal FortTech plugin into a standalone experimental engine toolset registered to load by default (ec883d85aa).

Interpretation: this is the same Agent Tooling arc that has read as cooling for two weeks, and it isn’t silent. A feature that needed three attempts to land, plus two module splits that widen its footprint into audio tooling, reads as continued, if lower-volume, investment rather than a wind-down.

Who cares: editor and tools teams following Epic’s in-editor AI agent work.

Signal strength: Moderate. One concrete cluster after two quieter weeks; worth another week of data before calling it reactivated.

A New, Previously Untracked Story: Unreal Toolbox Gets a Major Investment Week

Pattern: One engineer authored at least 23 commits this week entirely inside Unreal Toolbox, the managed developer-tool distribution and self-update application. The work spans a full self-update UX overhaul with staged versions, deferred updates, and shutdown-race handling, validated with “33 passing tests and clean Development and Analyze builds” by the commit’s own description (b54af79f), structured telemetry with bounded delivery retries and privacy safeguards (53777fd5), deduplicated Horde authentication so marketplace and settings auth share one interactive login instead of racing (1f2a2563), persisted launch profiles with Check Now progress reporting (172a2c8a), and a full branding pass replacing the Unreal Engine logo with a dedicated Toolbox icon across tray, window, and macOS packaging (2e43a4f3).

Interpretation: this is not part of any previously tracked pattern, and the volume (23+ commits, one engineer, one week) is large enough to flag on its own rather than folding it into general editor and tooling activity. Whether it recurs next week decides if this becomes a sustained story.

Who cares: anyone whose studio uses Unreal Toolbox for managed tool distribution or UGS integration.

Signal strength: Single week. Worth watching for a second week of data.

TL;DR

• The FScene-to-Scene-Extensions decomposition reached ray tracing specifically this week (static mesh cache data, NativeInstances renamed to TLASInstances, Nanite::FRayTracingManager), with UE_INTERNAL dropped from a key header, a signal the API is stabilizing. A real bug in the same arc: skeletal meshes could drop out of the ray-tracing TLAS entirely under a common cvar.
• Unreal Build Accelerator’s correctness work continues into a fourth straight week, still carried almost entirely by one engineer: a known-inputs streaming feature, a RAD Linker compatibility fix, and several cache and diagnostics fixes.
• A Sequencer camera-shake-preview teardown fix shipped successfully on ue5-main this week after one backout, but remains reverted on ue6-main, where it was submitted twice and backed out with no reland in this week’s window. Same patch, opposite outcome by branch.

Highlights

Ray tracing gets its own Scene Extensions pass, and a real TLAS bug gets fixed

What changed: Static mesh cache data and machinery moved out of FScene/FPrimitiveSceneInfo into a new FStaticMeshSceneExtension (4a8f93d6). Elsewhere in the same arc: NativeInstances renamed to TLASInstances (967e1001), FGeometryManagerHandle refactored ahead of upcoming changes (41fadeba), Nanite-tagged ray tracing instance processing consolidated into Nanite::FRayTracingManager (a34192d5), PrimitiveRayTracingFlags/PrimitiveRayTracingDatas and path-tracing invalidation moved into FRayTracingSceneExtension (26233121), and UE_INTERNAL was dropped from RayTracingInstanceBufferUtil.h (767182ba). The real bug fix riding along: skeletal meshes were dropping out of the ray tracing TLAS entirely when r.RayTracing.DynamicGeometry.MaxUpdatePrimitivesPerFrame was enabled (8a51a944).

Why this is important: this is the seventh straight week of the FScene decomposition producing a fresh cluster, and it has now narrowed specifically to ray tracing storage. The UE_INTERNAL removal reads as an API stabilizing rather than still under construction. The TLAS dropout bug is a real correctness issue for anyone using that cvar with skeletal meshes and hardware ray tracing.

Who should care: renderer and engine-core teams, anyone maintaining a hardware-ray-tracing or Lumen HWRT fork.

Urgency: Act now if you run r.RayTracing.DynamicGeometry.MaxUpdatePrimitivesPerFrame with skeletal meshes and hardware ray tracing. Track the broader decomposition.

LumenRef keeps building toward a usable reference path

What changed: LumenRef (Epic’s in-progress hardware-ray-traced Lumen reference path) picked up Light Function, IES profile, and light-end-bias support (29253461), an initial direct-lighting pass (87a30b90), replaced light-miss shaders with the LF atlas (8c748501), added error-diffusion sampling for screen-space sampling (1138bb46), and consolidated shared code across LumenRef, MegaLights, and hardware-ray-traced lighting generally (08eeb37c). Separately, Lumen’s radiance cache got a hardware-ray-tracing performance win by decoupling two passes that no longer need to run in sequence, saving 0.06ms on console at a 100-probe trace budget (cc537df5).

Why this is important: this continues the multi-week hardware ray tracing reopening from the prior two weeks, now in its third consecutive week. LumenRef is explicitly still a prototype, not usable yet, but the pace of feature additions (lighting, sampling quality, shared code with production paths) says Epic is actively building it out rather than letting it sit.

Who should care: graphics and rendering teams tracking hardware-ray-traced Lumen.

Urgency: Track.

Legacy rendering code gets deleted, not just deprecated

What changed: Screen Space Global Illumination (SSGI) was removed entirely (5ca9c633). Hair strands lost their dual-scattering roughness override (d38baa8d). Deprecated code was purged from the RHI, focused on Metal (9cd86845). Shader-system deprecated code was removed “past required window” (52861013).

Why this is important: these are deletions, not deprecation warnings. Anything still calling the removed SSGI path, the hair override, or the purged RHI and shader entry points breaks on sync, not on a future release.

Who should care: teams maintaining renderer forks, especially anyone still using SSGI instead of Lumen screen-space GI, or the removed hair dual-scattering path.

Urgency: Act now if you depend on any of the four removed paths. Otherwise ignore.

UBA correctness work continues into a fourth week, still one engineer

What changed: Unreal Build Accelerator picked up a known-inputs streaming feature for the scheduler’s YAML config, letting common inputs stream to clients ahead of process payloads (f0365f92, e605db48), a fix for RAD OBJ files getting double-compressed on write (29c9b0ef), a COFF-writer padding fix specifically so RAD Linker stops rejecting the output (ab784a2a), removable-cache memory-leak diagnostics (31eece04), invisible folders and per-process overlay directories (422e38eb), a POSIX stat fix for leading parent-relative paths (643b90af), and exact cache-entry offset-vector reallocation during maintenance, replacing an approximation that over- or under-allocated (541ed2ff). All of the above are from the same engineer.

Why this is important: this is the fourth straight week UBA’s correctness surface has rested substantially on one person. The work continues to check out as sound, but a month of concentration in one system, one author, is worth flagging as a standing risk independent of the quality of any individual fix.

Who should care: build and tools teams running distributed builds through UBA, especially anyone tracking RAD Linker and RAD OBJ readiness.

Urgency: Track.

AI assistant’s background tool-call mechanism relands after repeated backouts, plus two module splits

What changed: The AI editor assistant’s mechanism for backgrounding a long-running tool call, letting it keep running past a bounded window while the agent carries on, then posting the result back once it finishes, landed this week at da58b851ec (citing one prior backout) and again at a515a8f521 (citing two prior backouts), under UE-390053. A related crash fix landed cleanly: the test spec backing this feature held its tool promise as a plain member, and a file-scope static destructor tried to fulfill an unset promise in any process that loaded the plugin without running the test, crashing on exit (fc4f1566b5). Separately, AIAssistant and MCPClientToolset were split into standalone editor and runtime module pairs (4bff8240d1), and MetaSound’s agent-tooling integration moved out of an internal FortTech plugin into a standalone experimental engine toolset that loads by default (ec883d85aa).

Why this is important: a feature needing three submission attempts before landing, combined with two module splits widening the toolset’s footprint into audio tooling, says this area is still actively worked, not winding down, even though weekly volume has been lower the last two weeks.

Who should care: editor and tools teams tracking Epic’s in-editor AI agent work.

Urgency: Track.

A crash-guard fix ships to both branches, and a Sequencer fix diverges between them

What changed: An nDisplay crash fix for unresolvable config data, cluster nodes, or viewports (deleting a cluster node could leave a null entry that consumers assumed was always valid) landed, was backed out, and relanded on ue6-main (8f2487ff then backed out bb69dd51 then relanded 55f805e8), tagged as a temporary fix for 5.8.3. The same fix went through an identical land-backout-reland cycle on ue5-main this week (see the 5.8 section below). Separately, a fix releasing Sequencer camera-shake previews on world teardown (previously nothing dropped the FGCObject references, leaving the outgoing world and its package reachable after a map change) was submitted twice and backed out on ue6-main, with no reland anywhere in this week’s commit data (3ebdd277 then ae892dbb6 then backed out at ed25dfc9). The same fix landed successfully on ue5-main this week after one backout (see the 5.8 section below).

Why this is important: the nDisplay fix is confirmed live on both branches as of this week. The camera-shake fix is not live on ue6-main despite two submission attempts, but is live on ue5-main. Anyone checking whether this was fixed needs to check the actual branch, not assume parity between them.

Who should care: nDisplay and virtual-production teams for the crash fix; Sequencer and animation teams tracking the camera-shake preview leak specifically on ue6-main.

Urgency: Track. The camera-shake leak is still present on ue6-main as of August 30.

Worth Tracking

• Persistent Storage Manager, a new quota and budget subsystem tracked under UE-392423, picked up path-conversion fixes for platforms requiring ConvertToAbsolutePathForExternalAppForWrite and CSV-metadata budget stats this week (911d3878, 882f652e, 519d547f, 45fc7d40). Still stabilizing; watch for a broader rollout signal.
• A dynamic-logging refactor continued under UE-392122: tracing support for dynamic logging, a log-category lookup-by-name API, and an atomic-counter-assigned trace log category and log point (5bb0b384, dc6ee08b). Feeds into the multi-week FMsg::Logf and LogV deprecation push from prior weeks.
• AutoRTFM and Verse’s VArrayBase hierarchy went through a same-day (August 28) triple backout and reland loop from one engineer, annotating the type as fully AUTORTFM_DISABLE. Final state as of week’s end: landed (29d26a0b49), after two same-day backouts.
• Ness, the still-unexplained serialization runtime, picked up 26 commits this week, its highest weekly count yet. New this week: a standalone NessRoundtrip continuous-integration test (f3addab8), a “SPOT” table concept with an enumeration API, disabled by default when compiled in (51a9ae20, 73bc73a1), and a real crash fix for a FNativeString optimization-induced nullptr in Verse string binding (ef8fde29). The old table-of-contents implementation was deleted as unused (057110cf), which reads as a migration completing rather than starting.
• The categorizer’s “other” bucket caught 460 of this week’s 885 analyzable commits (52%), including entire real clusters it doesn’t subsystem-tag: Procedural Vegetation Editor (25 commits, a module-move campaign under UE-393874), Mass entity-framework hardening (18 commits), and the Ness serialization work above.

What We Ignored

The bulk of this week’s low-interest volume was routine: single-line dependency and localization-automation bumps against Engine/Build/Commit.gitdeps.xml, Gauntlet and AutomationTool test-infrastructure tuning (device timeouts, coverage-target skipping, RPC relay swaps), a long tail of individual Niagara and Control Rig editor crash fixes each affecting a narrow repro case, and UnrealBuildTool dead-define cleanup, seven commits removing unreferenced global defines like USE_VORBIS_FOR_STREAMING and USE_XMA2_FOR_STREAMING. None of these change runtime behavior, build reliability, or upgrade risk for production teams.

For teams shipping on 5.8

ue5-main saw 174 commits this week (172 analyzable, 35 high-interest). No 5.8.x point release is confirmed as shipping in this week’s commit messages: “5.8.3” appears only as a target label on the nDisplay temporary fix and as a risk note on an unrelated Nanite-landscape material fix, not as a release that has actually gone out. Seven commits carry enough detail to call out:

• The nDisplay config, cluster, and viewport crash-guard fix (see above) landed, was backed out, and relanded this week, tagged as a temporary fix for 5.8.3 (74817dcc, 6a3ef366, 5fb9bb44). Same fix as the ue6-main version.
• The Sequencer camera-shake-preview teardown fix shipped successfully on ue5-main after one backout (0422764d then backed out 6890eb8a then relanded 1262dc72), unlike ue6-main where the same fix remains reverted with no reland this week.
• A Curve Table crash on undo (af9ec00c, CL 57546368): stale pointers to rich curve models after an undo operation now resolve by handle instead, fixing a crash native to this branch.
• A Nanite material-preview crash (46a36579, CL 57538920): selecting an unsupported material domain or blend mode while previewing a Nanite mesh in the material editor no longer crashes.
• A Constraints use-after-free during animation evaluation (00f014cb, CL 57510985): FAnimationEvaluator could be freed while the constraints evaluation graph was invalidated mid-evaluation; now guarded.
• Material Parameter Collections now use persistent shared uniform buffers keyed by ID rather than one buffer per collection instance (0ae1658d, CL 57393741), fixing crashes when the same collection appeared in multiple packages and one was unloaded, leaving stale uniform-buffer references in cached mesh draw commands.
• A Chaos memory leak on copying and scaling geometry was fixed (2ce60b05, CL 57364031).
• A Control Rig crash assigning a Pose Asset to a connected Get Pose Cache node was fixed via an index-swap bug in FRigUnit_PoseAsset (1e883465, CL 57496812).

Closing

A rendering week and a tooling week at the same time: the ray-tracing scene-extension work is visibly heading toward a stable API, and Unreal Build Accelerator and Unreal Toolbox both got a month’s and a week’s worth of concentrated single-author investment respectively. The branch-divergent Sequencer fix is a reminder that “fixed” needs a branch name attached to it.

Commit SHAs are cited inline, in parentheses, next to each claim. They reference the ue6-main branch of EpicGames/UnrealEngine unless the claim is in the “For teams shipping on 5.8” section, which references ue5-main. Some of the highest-interest entries resolve to Commit.gitdeps.xml binary-manifest blobs: the commit message is real, but the code lives in Epic’s internal binaries, which we cannot see.

Week of August 17 - 23, 2026 | 960 commits analyzed on ue6-main, 172 on ue5-main | Branch: ue6-main

Overview

This was an infrastructure-heavy week across build tooling, storage, and rendering, with two notable pieces of new tech (AVBOIT and a batched Mass/SceneGraph entity-creation path) landing alongside a mid-flight Unreal Build Accelerator rebuild and a Zen server bump. Two changes were reverted in the same week they shipped, so neither is live despite appearing in the commit history. On ue5-main, weekly volume roughly tripled from 55 to 172 commits, almost entirely cherry-picks of ue6-main fixes rather than native 5.x work.

Development Trends

Unreal Build Accelerator’s Widening Scope: From Cache Correctness to Full-Stack Rebuild

Pattern: UBA has carried the weekly themes for five of the last six weeks: observability and Zen 5.8.18 (July 13-19), the cache server rewritten under production failure pressure (July 20-26), the cache server dying in production (August 3-9), the cache server becoming multi-tenant (August 10-16), and this week’s three-front rebuild. Build stayed volatile but elevated (0, 3, 98, 87, 61, 85, 121, 117), the second-highest week of the eight-week window. What changed this week is scope: the prior three weeks were a single story (cache server correctness and scale). This week spans three separate workstreams at once: RAD Linker/RAD OBJ bring-up (3c13ab27, daff30cf, 9ffd4c20), Wine remote-build correctness fixes for a CPU-spinning retry loop and a corruption bug (9a5984e2, 59b4672b), and a storage/CAS architecture pass (81ad2c35, e51f565b, c1d09790). About a fifth of this week’s 200 high-interest commits came from one engineer, all inside UBA.

Interpretation: cache-server correctness work appears to have graduated into broader platform investment in UBA itself, new backend targets, new host-platform correctness, and storage architecture, rather than staying scoped to patching the cache service. That reads as sustained engineering investment in UBA as core infrastructure, not a one-off hardening sprint. The single-engineer concentration is worth watching: a fifth of a week’s high-interest volume in one system resting on one person is a bus-factor risk even where the work itself is sound.

Who cares: build and tools teams running distributed builds through UBA, especially Wine-based Linux remote build farms and anyone tracking RAD Linker adoption.

Signal strength: Strong. Five of six weeks of continuous data, widening rather than narrowing in scope.

Renderer Decomposition Reaches Its Sixth Week Since Reopening, Still Finding Real Concurrency Bugs

Pattern: FScene’s decomposition into modular Scene Extensions has appeared in the weekly themes continuously since July 13-19: modular decomposition, then an API break, then scene data being rebuilt underneath consumers, through August 10-16. This week’s evidence is the SceneData migration closing TSAN-caught races: a fix that removes an unvalidated write path and a stale VSM cache-manager read (bb622ce3), double-buffered dirty masks so a locking consumer can defer late marks instead of asserting (0469e076), and the primitive octree moved into its own SceneData extension (afc02eef).

Interpretation: six consecutive weeks since reopening on July 19, and the fixes are still genuine, TSAN-confirmed concurrency bugs rather than cosmetic relocation, consistent with the pattern from prior weeks where each extraction phase turned up real defects the old structure was hiding. Merge cost for anyone carrying renderer patches keeps compounding week over week.

Who cares: renderer and engine-core teams, and any studio maintaining an engine fork with custom renderer code.

Signal strength: Strong. Six weeks of continuous, substantive evidence since reopening.

Hardware Ray Tracing and Nanite RT Work Reopens After a Quiet Month

Pattern: The prior Ray Tracing Productionization trend ran 19 weeks before resolving after July 19, with a note that a single-week revival on August 10-16 (on-demand CLAS reclamation, a LumenRef prototype) would need a second cluster to count as reopened. This week supplies it: AVBOIT ships as the new default OIT method behind an off-by-default support flag (50b9cad9), LumenRef gets an early-termination pass the commit message says roughly doubles its performance on NVIDIA hardware (773bc646), and Nanite ray tracing is restructured for per-instance BLAS support ahead of WPO-driven assembly parts (2eafc68a, e2debb04).

Interpretation: two consecutive weeks of concrete ray-tracing and Nanite RT work after roughly a month of near-silence is enough to treat this as reopened rather than noise. The current phase reads as productionization groundwork, BLAS restructuring and vendor-specific speedups, rather than a finished, ship-ready feature.

Who cares: graphics and rendering teams, particularly anyone using Nanite translucency or hardware-ray-traced Lumen.

Signal strength: Moderate. Two weeks of data, reopening a previously resolved trend.

Mass and SceneGraph Entity Work Returns With a Quantified Frame-Time Win

Pattern: The Actor-Optional Runtime trend (Mass, EntityFramework, and SceneGraph decoupling from AActor) had substantial clusters the weeks of August 2 and August 9 but produced no fresh cluster the week of August 16. This week it returns: six commits over August 19-20 build batched Mass entity creation for the Verse-driven SceneGraph mesh component path, shipping with benchmark numbers attached, an 18% average frame-time drop on a 5,064-entity churn test, a 57% drop in per-entity cost, and a 92% drop in Mass observer-event count (72996da5).

Interpretation: after a one-week gap, the trend returns with its most concrete evidence yet, a quantified architectural win rather than functional-correctness-only work. That suggests the Verse/SceneGraph/Mass integration is maturing from “works” toward “works at scale,” not stalling out.

Who cares: teams building on Verse and SceneGraph with Mass-driven mesh components.

Signal strength: Moderate. A one-week gap breaks strict continuity, but this week’s evidence is stronger than the prior clusters.

TL;DR

• Unreal Build Accelerator is running three workstreams at once: RAD Linker/RAD OBJ is explicitly not ready for use, but Wine remote-build correctness fixes and a CAS/storage overhaul are real, and about a fifth of this week’s high-interest commits came from a single engineer.
• AVBOIT ships as the new default OIT method (behind an off-by-default support flag), LumenRef gets an early-termination pass that roughly doubles its performance on NVIDIA hardware, and a batched Mass/SceneGraph entity-creation path cuts churn-test frame time 18% with real benchmark numbers attached.
• Two changes, an EnablePlugins build warning and an MVVM stale-binding crash fix, were submitted and backed out in the same week: neither is live on ue6-main, and a CL-number discrepancy in both backouts is unresolved.

Highlights

Unreal Build Accelerator’s three-front rebuild: RAD Linker bring-up, Wine correctness fixes, a storage overhaul

What changed: RAD OBJ/RAD Linker support is under active bring-up: initial write support (3c13ab27, CL 57034075), a new UBT -radobj flag (daff30cf, CL 57176650), diagnostics and robustness work (86d0766a, CL 57239920), keeping cache outputs uncompressed (4f5bf804, CL 57255288), and new RADLINKER binaries the commit message describes as “based on two PRs that over time will evolve into the mainline” (9ffd4c20, CL 57296417). Separately, two Wine correctness bugs were fixed: a missing release-build detour caused Wine to reject a UBA-owned address, which made radlink spin at 100% CPU retrying cache eviction indefinitely (9a5984e2, CL 57226851), and a gap between munmap and mmap could let a concurrent mapping silently corrupt a live one (59b4672b, CL 57215747). And a storage/CAS pass landed: optimized compressed storage and CAS creation (81ad2c35, CL 57152245), parallelized session output prep (8c4fe200, CL 57157524), a fix for cache-entry lifetime and corruption during upload and maintenance with new regression coverage (e51f565b, CL 57170243), and fixed CAS/transfer lifetime leaks (c1d09790, CL 57165605). Process racing is now on by default for UbaCli with a scheduler, though the same commit’s own description admits “force-remote being broken” (077b11aa, CL 57306021).

Why this is important: these are three different maturity levels of the same system landing in one week. RAD Linker is explicitly not released yet (“radlink.exe with support for this is not released yet”), the Wine fixes are patching live corruption and hang bugs in mixed Windows/Linux remote-build setups, and the storage overhaul is a genuine architecture pass, not incremental cleanup. Roughly 42 of this week’s 200 high-interest ue6-main commits, about a fifth, came from one engineer, all inside UBA: that’s not disqualifying on its own, but it does mean UBA’s correctness surface this week rests on one person’s work.

Who should care: build/tools teams running distributed builds via UBA, especially Wine-based Linux remote build farms.

Urgency: Act now for the Wine correctness fixes if you run Wine remote helpers. Track the storage overhaul. Ignore RAD Linker/RAD OBJ until it’s out of bring-up.

Zen (DDC) server jumps to v5.8.20: a relay role, an experimental two-tier CAS, and a breaking namespace change

What changed: a single Commit.gitdeps.xml bump (b64b19d3, CL 57118611) carries a large embedded changelog for the Zen server. Two features stand out: a new “relay” server role that turns cache traffic into a durable, replayable S3-backed stream, and an experimental two-tier generational CAS: an NVMe fast-tier read cache that falls back to the primary store, and a separate S3 remote-tier backup mechanism for the primary store. Both are opt-in and fail safe, and the commit does not describe the fast tier as backed by the remote tier, they are independently configured. The same update adds a zen trace stats mode that decodes .utrace files into structured JSON explicitly designed for “tools and LLMs” to consume. It also includes a breaking change: cache requests must now name their namespace explicitly, and the legacy ue4.ddc fallback is rejected with an HTTP 400. Buried in the changelog is a real fix: garbage collection with gc.projectstore.attachment.store enabled could misclassify live project-store attachments as unused and delete them if the oplog changed mid-GC pass; that’s now fixed.

Why this is important: the namespace change will break any pipeline still relying on the ue4.ddc fallback the moment this version rolls out, and the GC bug was a real data-loss path for anyone running that config flag.

Who should care: build/platform teams operating shared DDC/Zen infrastructure.

Urgency: Act now if you rely on the ue4.ddc fallback or the gc.projectstore.attachment.store flag. Track otherwise.

Transparency and ray tracing: AVBOIT ships, LumenRef nearly doubles in speed, Nanite RT restructures for per-instance BLAS

What changed: AVBOIT (Adaptive Voxel-Based OIT, a SIGGRAPH 2025 technique) is implemented for both Nanite and non-Nanite translucency, built on UAV atomics with no raster-ordered views (50b9cad9, CL 57145936, jira UE-354390). It becomes the numeric default for r.OIT.Method, but its shader permutations are gated behind r.AVBOIT.Support, which defaults off at the project level, so it won’t compile into most projects unopted. Separately, LumenRef (Epic’s in-progress hardware-ray-traced Lumen path) picked up early-terminating paths for rays that won’t contribute to the final pixel, which the commit message says “on average doubles LumenRef performance” while also improving diffuse signal quality (773bc646, CL 57221354); the same commit notes this makes LumenRef “dependent on NV SER extension due to lack of GetClusterID in shader model 6.9,” so the speedup is NVIDIA-only for now. The same author also fixed a correctness bug where world-cache entries were skipped during out-of-order removal (fe7ba585, CL 57298728). And Nanite ray tracing is being restructured for per-instance BLAS support: one commit decouples the BLAS cache from RuntimeResourceId, stating the reason as “we will need to support multiple BLAS per resource (assembly parts / per-instance BLAS when using WPO)” (2eafc68a, CL 57018825), followed by a change moving to one BLAS per assembly-part instance (e2debb04, CL 57025687).

Why this is important: AVBOIT is a real default-path change to translucency rendering, even though it’s opt-in for now. The LumenRef speedup is significant but currently NVIDIA-specific. The Nanite RT decoupling is groundwork for WPO-driven assembly parts in ray tracing, not a feature that ships this week.

Who should care: graphics/rendering teams, especially anyone using Nanite translucency or hardware-ray-traced Lumen.

Urgency: Track.

SceneData migration keeps closing real TSAN races, not just moving code around

What changed: the multi-week migration of core scene state into the tracked-access SceneData system continued. One commit explicitly fixes “TSAN races by tightening root-context access,” removing an unvalidated write path and a stale VSM cache-manager read that TSAN had actually caught (bb622ce3, CL 57261239). Another makes dirty masks double-buffered so a locking consumer can defer late marks instead of asserting (0469e076, CL 57146944). A third moves the primitive octree into its own SceneData extension (afc02eef, CL 56998444).

Why this is important: these are confirmed race fixes caught by TSAN, not speculative hardening, which suggests the SceneData migration is finding and closing real concurrency bugs as it proceeds rather than just relocating code.

Who should care: renderer/engine-core teams.

Urgency: Track.

Horde and UGS get bandwidth and reliability fixes that only bite at multi-branch, multi-agent scale

What changed: a new opt-in UGS cross-branch cache lets UGS reuse files already synced in a sibling branch enlistment on the same machine instead of re-fetching identical revisions, matched by Perforce’s own MD5 digest; tested live against FN-Main/UE6-Main it reused 37,694 files (197.71 GB) in one sync with zero mismatches, saving roughly 70 minutes of network transfer at 400 Mbps (f25bb20b, CL 57222891). On the Horde side, pools with AutoSDK disabled were still getting AutoSDK workspaces attached on conform with no view filter, so agents tried to sync the entire AutoSDK depot and failed with an InsufficientSpaceException; the commit notes affected agents “can’t self-heal since the conform that would prune AutoSDK is the one failing” (4702f02c, CL 57222618). Other reliability fixes: full workspace resyncs after Perforce edge-server swaps when only an incremental sync was needed (79deef26, CL 57064448), scheduler parallelization plus protection against a hung Perforce query stalling the whole scheduler (a48474dc, CL 57053336), Redis 5 compatibility restored for Perforce server selection after a Redis-6-only option broke it (d470b800, CL 57061235), and dashboard job-ID queries batched to stop HTTP 414 errors on large pools (b1aaa435), with a follow-up batch-size tuning commit the same day (b7d9f085). A new “Lore” version-control server plugin and job driver for Horde also landed, explicitly flagged as “work in progress and will be changing significantly” (22fd635b, CL 57282454).

Why this is important: the AutoSDK bug is a genuine self-inflicted-outage pattern: affected agents get stuck and can’t recover on their own because the fix path is the same conform step that’s failing. The UGS cross-branch cache is a meaningful bandwidth win for anyone syncing multiple branch enlistments on the same machine.

Who should care: build/platform teams running Horde agent fleets or multi-branch Perforce setups.

Urgency: Act now if you run Horde pools with AutoSDK disabled. Track the UGS cache and other reliability fixes. Ignore the Lore plugin until it stabilizes.

Two changes shipped and reverted in the same week: neither is live

What changed: two ue6-main changes were submitted and then backed out within the same week, with no reland visible anywhere later in this week’s window. An EnablePlugins build warning was added (“warn when a EnablePlugins entry is not built,” ef8066fa, CL 57204382), then disabled days later citing “some existing cases that need to be addressed first” (76ae75de, CL 57279538), then fully backed out (d8867032, CL 57323996). Separately, an MVVM stale-binding crash fix that registers Blueprint classes reachable from a widget’s view-binding path as compile dependencies, fixing a real PIE crash on stale property pointers (0a63dd20, CL 57089686), was backed out three CLs later (c4279e47, CL 57092963).

Why this is important: neither change is live on ue6-main as of the end of this week. The MVVM backout matters most: the underlying PIE crash on stale property pointers is still present upstream, not fixed, despite the initial commit reading like a shipped fix. Both backouts also carry a CL-number discrepancy in their “Original CL Desc” field (57204029 vs. 57204382 for the plugin-warning backout, and 57089520 vs. 57089686 for the MVVM backout): close but non-matching numbers, most likely a Perforce shelve-vs-submit numbering artifact since the file diffs match, but this is unresolved and needs human verification before treating it as settled.

Who should care: build/UBT teams tracking EnablePlugins warnings, UMG/MVVM teams that saw the crash-fix commit go by.

Urgency: Track.

SceneGraph batches mesh-entity creation into Mass, with numbers to back it up

What changed: six commits over August 19-20 build out batched Mass entity creation for the Verse-driven SceneGraph mesh component path. The anchor commit introduces a scoped entity-creation batch that groups scene-add operations and flushes them through one batched creation call instead of paying per-entity archetype moves, and it ships benchmark numbers: on a 5,064-entity churn test, average frame time drops 18% (7.74ms to 6.31ms), per-entity AddedToScene cost drops 57%, and Mass observer-event count drops 92% (4,174 to 334) (72996da5). Follow-on commits add regression tests for teardown/observer edge cases (bf09acfc), bring material/bounds parity with the legacy static render path (95054a1b), fix Mass-rendered meshes freezing at spawn transform under mass.FullyParallel (d5e6f928), and fix signal-ordering correctness during creation (cc28c4c9). A related commit wraps the legacy PSO precache call in AutoRTFM::OnCommit because it’s reached from inside a closed Verse transaction (5b8ad594).

Why this is important: this is a quantified architectural win, not just a functional-correctness pass. The benchmark table is the clearest evidence this week that Epic’s Verse/SceneGraph/Mass integration is maturing from “works” to “works at scale.”

Who should care: teams building on Verse/SceneGraph with Mass-driven mesh components.

Urgency: Track.

MetaSound gets a live-tunable parameter-override system

What changed: three commits from the same engineer, sharing a sync baseline, build a runtime parameter-override store for MetaSound over August 18-21. The first adds the store so config, hotfix, and console commands can seed default values for a MetaSound source’s transmittable graph inputs before future plays (9efc1e0e, jira UE-387478). The second stops the MetaSound builder from applying those overrides while a graph is being actively edited in the editor, so an artist’s authored defaults aren’t clobbered, and rekeys overrides on the asset’s full path instead of a short object name, so a record targets exactly one asset and mistyped or wildcard paths error instead of silently never applying (c9e632f6). The third splits storage into separate config and console “planes” so reapplying a config override only replaces what config contributed, without stomping console-set values (9ec434e9).

Why this is important: this reads as infrastructure for live-tuning MetaSound values in a shipping game without republishing assets: config/hotfix for live-ops sweeps, console for local debugging, with each layer isolated from the others.

Who should care: audio and live-ops teams.

Urgency: Track.

Two crashes worth flagging: a fabricated-buffer bug in Typed Elements, a silent out-of-bounds write in Mass

What changed: FCommandBuffer::GetQueuedDataColumn was fabricating a pending column from a zero-filled, never-constructed buffer; any member with a non-trivial constructor (FText, for example) ended up with a null internal pointer that crashed the next reader, reproduced via the TEDS “Sort unsorted alerts” path (afa3dc42). Separately, Mass entity storage could run out of page space, assert via AddPage, and then continue anyway: because check/checkf compile out in Test and Shipping configurations, those configurations wrote past the end of the entity-page array while still reporting success (ecddb898).

Why this is important: the Mass bug is a silent out-of-bounds write specifically in Test and Shipping builds, the exact configurations where the assert that would have caught it is compiled out. That’s a real memory-safety issue in shipped-build configurations, not a debug-only check.

Who should care: Typed Elements/TEDS users, and any team running Mass at scale in Test or Shipping configurations.

Urgency: Act now.

Worth Tracking

• Storage/memory-budget hardening, coordinated: the persistent storage manager’s quota subsystem picked up hotfixable quota CVars (a47df30e), a fix for QuotaMB incorrectly matching as a substring of OptionalQuotaMB (488ec976), overbudget category/stat accessors (aa3e9093), and a debug HUD panel explicitly modeled on the existing IoStoreOnDemand panel (076183e5). Separately, an Elastic IO Block Cache that borrows free memory for disk caching and gives it back under pressure landed (594f21a4), alongside a five-commit IAS/On-Demand cluster the same week, three of which share one sync baseline (b377ad48, 80b8233c, 49351bcc) and two of which land on their own baselines (2bf1b423, d2795858). A new quota system explicitly copying an existing cache HUD pattern, a new elastic disk cache, and a sprint of IAS hardening landing in the same week reads like coordinated investment in storage/memory-budget tooling, though nothing in this week’s data confirms what platform push it’s aimed at.
• Control Rig “Rig Promises”: a single commit introduces an authored contract describing what a rig will construct before it’s actually constructed, gated behind ControlRig.Promises.Enable (default off) and labeled “first iteration” (972dad21). No user-facing effect yet, but foundational architecture worth remembering before it ships enabled.
• RAD Linker/RAD OBJ remains explicitly work in progress (see the UBA section above): don’t build workflows around it yet.
• AI toolset registry keeps expanding: this week added a diff-based edit_file to replace whole-file writes, because “past the orchestrator output cap the arguments JSON is cut off mid-object” (a6ee1625), a 46-crash telemetry-driven fix rejecting destroyed-object references across every toolset entry point (48951ad8, jira UE-386549), and an asyncio hang fix for a tool call where a user “waited over 90 minutes on a tool call the service had already finished” (4e425d10). The same UE-386549 ticket also shipped as a cherry-pick on ue5-main this week (see the 5.8 section below), so this is an active cross-branch push, not a one-off.
• Minor connective tissue: TEDS adoption continues alongside the SceneGraph/Mass work above: editor viewport piloting moved from a raw actor pointer to a TEDS row handle so non-actor SceneGraph entities can be piloted (84dcfd08), with Outliner tests loosened to match (a54954a5).

For teams shipping on 5.8

ue5-main saw 172 commits this week (171 analyzable, 32 high-interest), up sharply from 55 the prior week (August 10-16). Most of that volume, and most of this week’s high-interest commits, is routine editor-crash-fix maintenance (Sequencer, Curve Editor, landscape, mostly single-line messages with no deeper detail available) and cherry-picks/backports of ue6-main fixes onto 5.8 rather than native 5.x development. No 5.8.x point release is named as shipping in this week’s commit messages, so none should be assumed. Six commits carry enough detail to be worth calling out:

• A heap-use-after-free bug (caught by ASan) in the Unified Animation Framework’s static teardown path (583d0daa): teardown handlers moved from OnEnginePreExit to OnPreExit, and factory containers plus the abstract-skeleton default-bindings cache are emptied during teardown so UObject references release before the UObject system is purged (CL 57268887).
• A landscape editor hotfix (246b4fcd): ULandscapeInfo::GetTargetLayerSettings was const-qualified but implicitly created an undo-buffer entry when none existed, corrupting the undo stack in a specific repro (undo after a landscape resize inside a level instance) and causing a check() crash on PostEditUndo. The fix returns an empty settings struct instead; a full fix (a const pointer return, all callsites updated) isn’t hotfix-compatible, so this minimal version targets 5.8.3 specifically (CL 57265755, jira UE-386585).
• A subsystem-collection GC crash (2248b96a): if an owner is garbage-collected without calling Deinitialize(), the fallback deinitialization path could run mid-purge against an object with a reset internal index. The fix skips deinitialization during purge and logs a warning instead of ensuring, deliberately, since an ensure would just report a known condition on a patch release (CL 57235178, jira UE-385129). The same underlying bug class was also fixed on ue6-main this week.
• A toolset object-parameter validation fix (bf7d3b85, jira UE-386549): a tool call naming an object by path could resolve an actor already destroyed but not yet garbage-collected, and nothing validated it before a full property write, eventually crashing in UWorld::AddPostProcessVolume. This caused 46 crashes across 45 users on 5.8. The fix rejects any resolved object failing IsValid() across every UToolsetLibrary entry point, with 8 new tests added (CL 57226176). Same jira ticket as the ue6-main toolset-registry fix above, part of the same cross-branch push.
• A data layer re-entrancy fatal (b561c015): a data layer track evaluated synchronously from inside UWorld::UpdateLevelStreaming (for example, a Sequence played off an OnLevelAddedToWorld delegate during AddToWorld) could re-enter UpdateLevelStreaming and trip its fatal guard. The fix skips the synchronous flush when already inside UpdateLevelStreaming, gated by a CVar that defaults on (CL 57143995). Cherry-picked from ue6-main.
• A Control Rig Constraints UX performance fix (3a5f7678): a details-panel refresh chain was refreshing anim details every tick, adding 8 to 20ms per tick. The fix tries a cached object-id lookup before falling back to the slower resolution path (CL 57090423, jira UE-387626). Cherry-picked from ue6-main.

What We Ignored

The bulk of this week’s low-interest volume was routine: binary rebuilds with no source change, single-line dependency bumps for internal Fortnite/UEFN content, test-framework wording and log-verbosity tweaks, and test-automation quality-of-life changes. A handful of commits that initially looked notable turned out to be internal build-packaging plumbing or pure dependency churn (a Linux build fix for an Open PBR Material Horde job with no functional change) and were dropped. Backout and reland pairs remain hard to track systematically; we surfaced the two that mattered above but did not attempt to count the rest.

Closing

A week of infrastructure catching up with itself: UBA, Zen, Horde, and UGS all moved in the same seven days, and the two backouts are a reminder to check what actually shipped rather than what was merged. The Mass/SceneGraph batching numbers are the clearest signal that the Verse-era entity work is starting to pay off in frame time, not just correctness.

Commit SHAs are cited inline, in parentheses, next to each claim. They reference the ue6-main branch of EpicGames/UnrealEngine unless the claim is in the 5.8 section, which references ue5-main. Some of the highest-interest entries resolve to Commit.gitdeps.xml binary-manifest blobs: the commit message is real, but the code lives in Epic’s internal binaries, which we cannot see.

Week of August 10 - 16, 2026 | 847 commits on ue6-main, 55 on ue5-main | Branch: ue6-main

Overview

847 commits, 198 worth reading, and the week belongs almost entirely to build infrastructure. Build is the top subsystem at 121, and a single engineer accounts for 47 of those 198.

The through-line is diagnosis. Several long-running build failures got root-caused this week, and in most of them the system had been pointing at the wrong culprit. Farm hosts were freezing whole builds on single filesystem calls that hung for up to 28 minutes, and the resulting timeouts looked like network bugs. Horde agents on streams with moving Perforce pins were producing builds from a mix of old and new files, and the detector written to catch exactly that stayed dormant, because it read pins from a field Perforce never writes @CL revspecs into. A material instance cook fix landed with a six-of-six versus zero-of-six A/B instead of a claim.

The last two weeks were about caches returning wrong answers. This week is about the instruments that name which thing went wrong, and how long a build farm can run without them.

Development Trends

Build has been the top or second subsystem for eight consecutive full-volume weeks, and the work has moved through three distinct phases. July was modernization: C++23 by default, circular dependencies eliminated, EpicClang versioned, the C# BuildGraph VM deleted. Early August was cache correctness: seven independent defects where a cache key was not a function of its inputs. This week is operations. The UBA cache server got sweep-budget scaling, automatic bucket retirement, retention telemetry, per-bucket metadata, and a web console that scales, because the bucket key gained target type plus branch name for the one heavily used target, taking the count from roughly 500 to roughly 5,000 (6e5e1585, 98dccb91). Retirement policy is service work, and Epic is now doing service work on what used to be a build feature.

The UBA cache server has now been hardened under live production failure three weeks running, and the failure class changes each time. Jul 20-26 was throughput and corruption. Aug 3-9 was process death, with SIGBUS on a full filesystem. This week is scale and misattribution: a worker pool that could enter an absorbing state and freeze a build for roughly 26 minutes (26e9b3dd), a torn read on Apple Silicon that segfaulted inside blake3 (5fb5c544), and a stall detector that reclassifies timeouts caused by local disk (b8a0758b). Three consecutive weeks on the same component means the thing is being operated past the design it shipped with.

The cook-determinism campaign is now in its fifth week and produced its most concrete result yet, though the fixes carry three different reviewers and one jira between them, so they read as unrelated one-offs unless you line them up. A material instance parameter strip that mutates the live object mid-save (68070a5d), Blueprint RNG nodes drawing from the process-global stream instead of the deterministic cook stream (3bc9b39d), and a shader AssetInfo sort truncating 8-byte hashes to 4 bytes at an estimated 99% collision probability across 200,000 elements (8f43677d). Two of the three present as incremental-cook validation failures, the mechanism that pushes studios into full recooks; the shader hash truncation surfaces as raw cook indeterminism on large projects.

Backout volume stayed high and clustered on the same two areas as last week: 27 commits tagged [Backout], and five land-backout-reland cycles inside seven days. Material instance parameter stripping alone burned three commits between two engineers on a single day (364f4a0b, e5601e1b, 68eaf5d3), on top of two diagnostic backouts the day before. Cook determinism, dynamic subsystems, an input debug overlay, and the crash reporter statics each completed a full cycle. The input thread default landed and was reverted with no reland. If you track ue6-main closely, mid-week changelists in the material and cook areas are not safe sync points.

TL;DR

• Horde agents on streams with moving import CL pins have been intermittently producing builds from a mix of old and new files. The existing view-change detection stayed dormant for pin moves, because Perforce never emits @CL revspecs in the generated view of p4 stream -o -v, so pins surface only in the computed ChangeView field. That field is now captured, hashed, persisted, and diffed on client recreation (61e34d05).
• The UBA cache bucket key now includes target type and, for one target, branch name, taking bucket count from roughly 500 to roughly 5,000. A fixed sweep budget of one bucket per poll saturates around 3,600 buckets and the backlog then grows forever, so the budget now scales at one per 500 per poll and idle empty buckets auto-retire (6e5e1585).
• A passive disk stall detector landed in UBA after Ntfs event-log history showed farm hosts holding single filesystem calls for 30 seconds to 28 minutes, near daily per affected machine. Timeout warnings whose wait overlapped a detected stall are now downgraded to info with an explanation (b8a0758b).
• The minimum Windows SDK is now 10.0.26100.0, with the commit sweeping in-tree references to 22621 (05d13aec). Build images that only carry the older SDK are now below the floor.
• Material instance cook non-determinism was traced to CleanUpUnusedParameters() mutating the live object during cook-save, validated with an A/B that reproduced the failure on six of six stripping instances with the fix off and zero of six with it on (68070a5d).
• FAssetRegistryGenerator::FinalizeChunkIds went from 187s to 1s, taking a 300s stage down to 114s, by fixing pathological TSet reallocations in the package graph (32e19f61).
• Restricting ICF defeating to only where AutoRTFM needs it cut a large server binary by 10.5% (1f14b550).
• The input thread was enabled by default on August 14 and backed out three hours later. As of this writing input.UseInputThread still defaults to 0 on ue6-main (fbd5d79a, 3ba05293).

Highlights

Horde was building from two changelists at once, and nothing reported it

What changed. Horde agents on streams with moving import CL pins were intermittently producing builds from a mix of old and new files. When a partitioned client is recreated after an edge-server change, the have table is rebuilt with a flush under today’s stream view. If a pin moved since the workspace was last synced, that flush claims files at the new pin that were never written to disk, and incremental syncs never repair them.

Worth reading twice: why the existing safety net never caught it. A previous changelist added view-change detection to reconcile exactly this case, but it read pins from the generated View of p4 stream -o -v, and the server never emits @CL revspecs there. Pins, including ones inherited from parent stream specs, surface only in the computed ChangeView field. The view hash therefore never changed when a pin moved, and the reconcile stayed dormant. ChangeView is now captured, hashed, persisted in workspace state, and diffed on client recreation, reconciled against what can actually be on disk and capped by both the pin and the last-synced CL: forward moves and pin removal flush to the old snapshot and sync only the delta, while backward moves delete the exact set of formerly-versioned stale files and force-sync the new snapshot, so untracked build artifacts survive (61e34d05). A separate fix stops PerforceConfigSource login failures from stranding one native connection per minute-poll with no finalizer (8cec04cf).

Why this is important. A build-correctness failure with no error attached to it. The job succeeds, the artifact is wrong, and the wrongness is a mix of two changelists rather than an obviously old build. The commit describes Epic’s own agents, but the shape generalizes to anyone pinning imports across streams and running edge servers. The detection gap is the transferable lesson: a check that reads the wrong field is worse than no check, because it looks like coverage.

Who should care. Anyone running Horde with pinned stream imports and Perforce edge servers. Release engineers who have ever chased a build that behaved like a stale sync and could not reproduce it.

Urgency: Act now.

The UBA cache server became a multi-tenant service, in one week

What changed. The cache bucket key changed. Target type (client, server, editor, program, game) is now part of the bucket id, and branch name is added for the win64 modular development editor target, with the commit explicitly avoiding wider use to prevent “a permutation explosion (Epic has lots of branches)” (98dccb91, 8af204f5, 11fe8b2d). Bucket count goes from roughly 500 to roughly 5,000. Worth noting the order: the server-side scaling work landed earlier in the week, and the changelist that actually put branch name into the bucket id came last, on August 14. Epic built the headroom first.

Sweep budget now scales at one bucket per 500 per poll, eight times that while a force-deleted wave is pending. The commit shows the math: a fixed budget of one saturates around 3,600 buckets, after which the backlog grows forever, and force-deleted waves took bucketCount/8 seconds to consume while serving failed fetches (6e5e1585). Empty idle buckets retire automatically, since per-branch buckets mean dead branches would otherwise accumulate zombie buckets forever, and the idle grace period doubles as the use-after-free guard for erasing a bucket outside the forced path. Bucket indices now come from a counter rather than map size, so retired indices do not alias logs or round-robin.

Retention became measurable rather than assumed. A Retention column reports the longest-unused entry age, an orange trimmed N marks entries that the last full maintenance pass sacrificed which configured expiration would have kept, since only runs holding the bucket exclusively can compact and enforce, the squeeze step moved from a flat one-hour cut to a proportional 10% per iteration, and a starvation bug was fixed where a bucket left dirty by a non-exclusive run never requeued for maintenance (871534b8, 13adc404, d05288a0). Two metadata paths landed alongside: per-bucket metadata with dedup and eviction past a default of five entries (0ff4cf28), and server-wide key/value metadata (604510d9), with UBT sending the unhashed cache key string as bucket metadata on first use (11fe8b2d), which should make it possible to tell which bucket belongs to which build configuration. The web console moved sorting, filtering, and truncation server-side, because /api/buckets was shipping roughly 1MB per poll at 5,000 buckets and now ships roughly 15KB for the top 50 (ea085af7). Zen server also moved to v5.8.19 (17032ade), though that commit resolves only to Commit.gitdeps.xml, so only the changelog text is verifiable.

Why this is important. Operating a UBA cache is now a different job. Cache buckets used to be a coarse partition you could ignore. Now they are per branch and per target type, they retire on their own, and they report when trimming cost you real cache hits. Learn the orange trimmed N marker: it means the expiration you configured was not the expiration you got, and the recommended response is to split the bucket.

Who should care. Build and CI engineers self-hosting a UBA cache server. Anyone whose cache hit rate has been unexplainably mediocre across many branches.

Urgency: Act now.

Your build farm has been blaming the network

What changed. A passive local disk stall detector landed in UBA, and the commit’s justification is the interesting part. Farm hosts on AWS with EBS storage can hold a single filesystem call for anything from 30 seconds to many minutes while the device otherwise looks healthy, confirmed against Ntfs Operational event 147 history showing Create, Write, and Cleanup calls stuck between 30 seconds and 28 minutes, near daily per affected machine. Those stalls freeze the whole build, and the timeouts they cause downstream looked like network or UBA bugs.

The detector costs two relaxed stores per filesystem call. Wrappers publish the in-flight call in a per-thread slot, and a watchdog scans for calls stuck longer than 15 seconds, logging one line when the stall resolves. The load-bearing part is the reclassification: timeout warnings and errors whose wait overlapped a detected stall are downgraded to info with a suffix naming the stall, covering FetchBegin hangs, WaitForWritten, SendBatchMessages, FetchCompactTable, session ping, and TCP WSAPoll timeouts (b8a0758b).

Two other freezes got root-caused the same way. NetworkServer receive threads could park forever waiting for a worker, and receive threads are where disconnect detection happens, so worker-pool exhaustion was an absorbing state that produced a roughly 26 minute whole-build freeze. PopWorker was changed to wait 10 seconds and then spawn an emergency worker beyond maxWorkerCount, capped at twice the limit, with a warning (26e9b3dd). Do not go looking for that behavior: the same author reverted it hours later, having concluded it would trigger constantly (d97e9372), and shipped a callstack dump for a PopWorker stalled past 15 minutes instead (2ab17b2e). The freeze is diagnosed, not yet fixed. And on Apple Silicon build machines, m_memorySize and m_overlaySize were plain u32 published across threads with no barrier, which is safe on x86 total store ordering and not on weakly ordered ARM, so a reader could see the new size before the bytes were visible and hand a torn filename length to a routine that crashed inside blake3_hasher_update. Both fields are now Atomic<u32> with explicit acquire and release, plus a bounds assert so a future torn write fails loudly instead of segfaulting deep in a hash function (5fb5c544).

A related Mac farm link collapse traced to file-mapping handles carrying the creator’s raw file descriptor, so a close-then-recycle served the wrong file to a live fetch. Handles now carry a monotonic mapping id resolved through a live-mapping registry, the descriptor server thread no longer exits on transient accept errors, and descriptor fetches get 10 second socket timeouts (3d4eb7a3). Throughput work stayed measurement-driven: stall sampling showed roughly 380 of 400 workers parked in FetchSegments.Send, so receive-stall thresholds now reserve the upper half of each connection’s send budget as headroom and segment fetch batching auto-sizes to two batches per connection instead of a fixed eight (4cce4d3b, 75c07a40, bfafea3b). Cold-page faults inside fetch memcpys got an async readahead, with a POSIX madvise(MADV_WILLNEED) implementation added because, as the commit puts it, the production cache servers run Linux (ba435bd5). Trace buffer exhaustion now logs and saves a truncated trace instead of failing silently, with a configurable reserve size (7d10a313).

Why this is important. Three separate classes of report that read as flaky networking were local resource starvation, and the fix in each case was a detector that renames the symptom rather than a retry that hides it. If you operate a build farm on cloud block storage, the specific finding is worth checking on your own hardware before you assume it is an Epic-scale problem: multi-minute filesystem stalls on healthy-looking instances, near daily.

Who should care. Build engineers running distributed builds on AWS or equivalent, anyone with Apple Silicon build machines, anyone who has written off recurring build freezes as network flakiness.

Urgency: Act now.

The cook was baking fresh random numbers into your packages

What changed. Three cook-determinism fixes landed.

UMaterialInstance::Serialize calls CleanUpUnusedParameters() while cooking, which destructively removes unused entries from the instance’s parameter arrays before Super::Serialize writes them. SavePackage serializes each export more than once, a reference-harvest pass and then an export-write pass, and the cooker can save the same instance more than once in a process. Because the strip mutates the live object and is skipped during the reference-collector pass, a later save harvests a smaller parameter set than the first, and the harvested name table then differs between the two saves. IncrementalValidate reported that as a spurious DeclaredUnmodified_FoundModified false positive, described in the commit as the dominant MaterialInstanceConstant spike. The fix snapshots the seven mutated arrays and restores them after serialization, behind r.Material.RestoreStrippedParametersAfterCookSave, default enabled. It shipped with an A/B: with the restore off, six of six stripping instances emit NameMap-is-different and Indeterministic-header-size; with it on, zero of six (68070a5d).

Blueprint RNG nodes in construction scripts were baking a fresh random value into cooked packages on every cook. AActor::ProcessUserConstructionScript already establishes a deterministic cook-seeded scope, but only KismetGuidLibrary::NewGuid consulted it, so RandomIntegerInRange, RandomFloat, RandomRotator, and array Random and Shuffle still drew from the process-global stream. Those nodes now consult the in-scope cook stream when one is active, gated to editor builds, so shipping behavior is unchanged (3bc9b39d, a resubmit of the first attempt 9a961ed9 after it was backed out in af23eb62 for a Linux and Mac compile error, where RAND_MAX + 1 overflowed int because RAND_MAX is MAX_int32 outside the MSVC runtime). And the shader AssetInfo sort was clamping 8-byte FShaderHash values to 4 bytes via GetTypeHash, which the commit puts at an estimated 99% collision probability at 200,000 elements, so large projects specifically got indeterminate output (8f43677d).

Not a determinism fix but from the same author and the same cook path: FAssetRegistryGenerator::FinalizeChunkIds had pathological TSet reallocations in the package graph, and the commit reports 187s dropping to 1s, taking the enclosing stage from 300s to 114s, measured on a NullCook performance run rather than a production cook (32e19f61).

The material instance area also produced the week’s worst thrash. A commit disabling MIC unused-parameter stripping outright, because it was causing issues with texture parameters used in runtime virtual texture rendering, was submitted, backed out, and then restored by backing out the backout, all on August 12 across two engineers (364f4a0b, e5601e1b, 68eaf5d3).

Why this is important. Every one of these presents as an incremental cook validation failure rather than as an error, which is the mechanism that converts incremental cooks into full ones. If your team has concluded that incremental cook validation is noisy and started ignoring it, the material instance finding is a concrete reason it was noisy, with a measurement attached.

Who should care. Anyone running incremental cooks at scale, anyone with a content-addressed artifact cache, technical directors who have stopped trusting cook validation output.

Urgency: Act now if you cook material instances or use Blueprint RNG in construction scripts.

Version floors moved, and one of them will stop your build

What changed. The minimum Windows SDK is now 10.0.26100.0, with the commit noting it fixes all in-tree instances of 22621 found through internal code search (05d13aec). The commit does not spell out the consequence for build machines, but a floor is a floor: an image carrying only the older SDK is now below it. Agility SDK 1.619.5 was added and made the default (90ed17ad, 4875ceb2), 1.619.3 was removed (8811b76a), and two debug-layer suppressions were dropped because the validation false positives they covered are fixed in that SDK (ab6243fe). AMD AGS went from 6.0.1 to 6.3.1, adding RDNA3 and RDNA4 asic detection and DX12 shader clock intrinsics, and replacing VS2017 static libraries with VS2026 (cd727840). New DXC binaries shipped alongside a VulkanRHI fix for an invalid OpStore to OpTypeImage from Interlocked* on copied resources, which the commit says was causing crashes on some drivers (9bbbbb5c, 90a9fcf7).

One toolchain change is worth stealing. Restricting ICF defeating to only the cases AutoRTFM actually needs, rather than applying it blanket, reduced a large server binary by 10.5%. The commit also documents two behaviors the blanket approach was providing by accident, including AddressSanitizer disabling its fake stack for functions containing inline assembly, which the AutoRTFM runtime depended on (1f14b550).

Why this is important. SDK floor changes are the least interesting and most disruptive category of build change. They do not appear in release notes as features, and they turn into a morning of red CI for whoever syncs first.

Who should care. Build engineers, anyone maintaining pinned toolchain images, console and Windows platform teams.

Urgency: Act now.

BuildGraph’s C# authoring API finished collapsing

What changed. Two weeks after the bytecode VM was deleted, the rest of that layer went with it. BgContext, BgThunkDef, and the remaining expression and VM plumbing are gone, the Def-suffixed hierarchy collapses into direct BgGraph, BgNode, and BgAgent types, graph authoring methods moved from BgGraphDefBuilder onto BgAgent and BgNode, authored node delegates now execute directly instead of through reflection-based thunk binding, and unsupported Task<T> node functions are now rejected outright instead of running with their results silently discarded (36037439). All CustomTask implementations migrated to BgTaskImpl and the deprecated base class was removed (61b23381, cf13ef3e).

Horde also spent the week cutting the cost of its own CI. Analyzers moved inside the Docker compile that produces the shipped binary, so only one build runs per change instead of the entire server graph twice (f5da8afd). Interprocedural security rules moved to an opt-in configuration after costing 33 seconds per change while producing zero diagnostics (86e09fb5). Integration tests moved from creating and dropping a MongoDB database per test to a pooled model (775365c6), and test projects now run in parallel (210d5e5d, c4ca5172, 3c1c8e40). Tool deployments now precompute a zstd-compressed tar archive stored as a flat blob, served by presigned redirect straight from the storage backend, so the server spends neither CPU nor bandwidth on it and the artifact extracts with plain tar --zstd -xf while still downloading (db4fe1b3, 9c50776b).

Why this is important. The XML authoring surface looks untouched, which is what most studios actually use, though the commit rewrites XML graph reading and execution onto the consolidated model and CustomTask subclasses have to move to BgTaskImpl. If you invested in C# graph authoring, this is the second breaking pass in three weeks, and the API you migrate to has a different shape as well as a smaller surface. The Horde CI cuts are worth reading as a pattern even if you do not run Horde: two of the three were removing work that produced no output.

Who should care. Anyone authoring BuildGraph in C#, Horde operators, CI engineers looking for cheap wins in their own pipelines.

Urgency: Act now if you author C# BuildGraph. Track otherwise.

The renderer decomposition took Nanite material bins and distance fields

What changed. Two more large migrations moved subsystems off explicit FScene calls and onto dirty-mask tracking resolved inside a defined update window. Nanite material bin lifecycle left FScene and FPrimitiveSceneInfo: PrimitivesNeedingStaticMeshUpdate went from a packed-index TBitArray on FScene to an FDataArrayDirty on FScenePrimitiveDataRenderer, a PostStaticMeshUpdate hook collects the rebuild set, dirty marks can be locked for the remainder of an update, and the mutexes were removed because the update task and the render thread no longer touch the same data (7e6eb874, 374879a1).

FDistanceFieldSceneData became FDistanceFieldSceneExtension, and that migration carried several fixes that have nothing to do with refactoring. Three worth calling out. ShouldPrepareDistanceFieldScene now mirrors ShouldCompileDistanceFieldShaders, so render prep cannot request shaders that are absent from the global shader map when distance fields are disabled. GetDistanceToNearestSurfaceGlobal returns no-surface-in-range instead of distance 0 when no global signed distance field clipmaps exist, which had been pinning Niagara particles at the emitter. And hidden shadow or GI casters keep their distance field while hidden (39fc371d).

The fallout confirms how load-bearing this work is. A use-after-free race had scene extension task handles stored on the scene data object awaited on a worker thread under RDG parallel destruction, racing the render thread replacing handles for the next frame (fa537262). Out-of-band dirty marking from PSO compilation completion asserted on the locked update array (374879a1). A TAtomic was swapped for a transactionally safe mutex to support in-transaction render proxy initialization (37f10060). Separately, occlusion culling got an element-id cache for the occlusion history set, where the lookup had been 43% of sampled cycles on a gen8 mobile console, plus opt-in visible re-test throttling that is off by default, the two together measured at 0.4ms render thread, 0.3ms game thread, and 0.1 RHI (fede2869), and occlusion bounds moved to sparse custom bounds to cut memory (00cdc259).

Why this is important. Seven consecutive weeks of the same campaign, and the pattern has not changed: explicit add and remove calls become dirty flags resolved in a window, which is what makes parallel scene update safe. If you carry renderer patches, these are real conflicts, and the distance field fixes are worth pulling on their own merits regardless of the refactor.

Who should care. Rendering engineers, anyone maintaining an engine fork with renderer changes, anyone using global distance fields with Niagara.

Urgency: Track. Act now if you maintain a renderer fork.

Lumen gained a reference path, and Nanite ray tracing stopped holding everything resident

What changed. A new LumenRef subsystem appeared inside the renderer, with its own world cache, initial sampling, light and material sampling, path resolve, and visualization passes, wired into the deferred shading renderer and scene view state (5e889c76), followed by a world cache freeze visualization fix the same week (209c4705). The commit message is two words, “Initial prototype,” and says nothing more.

The rest is measured performance work. Lumen irradiance field gather now reuses downsampled depth and normal from the stochastic lighting tile classification pass, which itself gains Substrate tile size 16 support and caches translated world position in shared memory. The change also swaps some shared arrays from float3 to float2 plus float because, per the commit, some platforms pad float3 to float4, which increases shared memory usage and reduces occupancy. Measured at 0.51ms saved on console at 900p with the Substrate blendable gbuffer, and 0.88ms with MegaLights enabled (ca72133c). Nanite ray tracing now builds CLAS on demand and reclaims CLAS for unreferenced pages instead of holding everything resident, with streaming requests originating from ray tracing flagged through a previously unused bit and LRU ordering maintained for ray-tracing-referenced pages (e8aa742e), and automatic quality scaling now keys off CLAS pool usage (cbeb9852). Lumen reflections gained optional translucency depth during screen tracing so screen traces hit the frontmost depth-writing translucent layer, at roughly 0.15ms fixed cost at 1080p on console (c7740741). CSM shadow depth reuse gained validity-based invalidation and frustum expansion under r.Shadow.CSMShadowDepthReuse, reusing static and far cascade depth until the light rotates or the cascade footprint leaves the frozen, expanded footprint (50747fde). ACES 2.0 transforms migrated to match OpenColorIO’s adaptive hue and cusp construction, packed into a single 363x1 RGBA32F texture (521db891).

Why this is important. The CLAS change is the practical one: hardware ray tracing memory pressure on Nanite content stops being a function of everything you loaded and becomes a function of what ray tracing actually referenced. The Lumen gather saving is free if you are on Substrate. LumenRef is worth exactly one line in your notes until it does something.

Who should care. Rendering engineers, technical artists on GI-heavy or hardware ray tracing projects, console teams.

Urgency: Track.

A week of crashes that all happen after the useful work is done

What changed. An unusual share of this week’s crash fixes are teardown crashes. The clearest one: a fatal error raised from an atexit destructor died on already-destroyed function-local statics before it could be reported, exiting with a crash-reporter-crashed code and producing no report at all. The fix makes the thread manager singleton, the log output device, the log-filename lock, the error and feedback context devices, and the ApplicationWillTerminate and memory-pressure delegate accessors immortal, and with the singleton immortal the runnable thread destructor always unregisters, so shutdown crash reports keep every thread’s name and callstack. Note the landing sequence: it landed, was backed out, and was restored with the note that the backout did not fix the continuous-integration failure it was meant to fix (a6d3dc77, a3eda6f3, cfc74eef).

A sweep fixed existing use-after-free instances across ContentBrowser, the Niagara editor, Slate accessibility, the virtual shadow map cache manager, and the console, and then FText::ToString was marked lifetime-bound so static analysis catches the same bug going forward (3a42e0b6, then b93c6cea). Sweep plus annotation is worth copying into your own codebase for this class of bug.

Elsewhere: Control Rig had two concurrency crashes, including InitializeFromCDO reading the shared source hierarchy while also writing to it with nothing serializing it, so instances initializing on anim worker threads corrupted the listening hierarchies array (85d0e5b2, 0e9cee80). Async loading’s state dump moved into a commandlet with its use-after-free fixed by taking references rather than relying on package lifetime (d08fb4ca). IoStore container mapped file handles are now kept alive while mapped regions are outstanding, fixing a fatal assert when a game feature plugin unmounts while memory-mapped animation or sound bulk data is still resident (01bc8239). Audio wave instances outliving their active sound left a dangling back-pointer that the staleness check could not see (f9aa5086). And two that are easy to miss: an out-of-bounds read of the hardcoded-name table on Iris name deserialize (841d1f05), and a data race on a bit-packed Visual Logger flag where a concurrent load-mask-store could tear neighboring flags (1b008a1a).

Why this is important. Shutdown crashes get deprioritized because the work is already done, and the crash reporter fix explains part of why: some of them were never producing a report to prioritize. If your crash telemetry shows a suspiciously clean shutdown path, that may be the reason.

Who should care. Engine and tools programmers, anyone shipping plugins that unmount at runtime, anyone triaging shutdown crashes or missing crash reports.

Urgency: Track. The Iris deserialize fix is worth a look if you ship networked builds.

Also worth knowing

• All subsystems became dynamic subsystems, and UDynamicSubsystem is deprecated. The driver is merged modules, where dynamic libraries may carry subsystem definitions without game code opting in everywhere. Subsystems in automatically loaded plugins keep their old behavior, explicitly loaded plugins get dynamic behavior, and a new opt-in restores per-module lifetime. It landed, was backed out, and relanded (c11e8cb7, 783fba87, 9a17b956). Treat it as a source-compatibility item on merge.
• Plugin unmount got several minutes faster. Package unloading no longer loads data unless a rename is actually being performed, tagged for release notes by Epic (5ccdf834). A related fix stops evicted thumbnail scenes from outliving a plugin unload and keeping its packages referenced (ff42b7c2).
• D3D12 enhanced barriers got a correctness pass while the default stays legacy. Layout selection had been picking queue-type-specific layouts from whichever pipe a transition happened to be recorded on, which the commit calls wrong twice over, and shader-resource, unordered-access, and generic-read layouts are now derived from access alone (dd798781). Automatic selection narrowed so it only picks enhanced barriers when the SDK provides the required layout constant (7e0511ae), and a global was exposed specifically so projects can report barrier adoption through their own telemetry (b84bdb47). Correctness fixes plus adoption instrumentation usually come before a default flip.
• CTR encryption landed for plugin and collection encryption, with a deterministic Blake3-derived initialization vector per block so delta patching still works, and the commit says the foundation should later allow a full-project switchover at a one-time patch size cost (aa47a726).
• A black screen in UE Remote is fixed. Signalling server CORS filtering added earlier had a loopback-only allowed-origins default that rejected every UE Remote client, so no codec was ever negotiated (928808b3).
• The CSV profiler changed what it measures by default. csv.UseLegacyFrameTime was renamed to csv.MeasureFrameTimeAtEndFrame and defaulted on, with Windows opting out via ini. Any cross-platform frame-time capture comparison spanning this change is not comparing the same measurement (c3aac366).

Worth Tracking

The input thread default flipped on and back off inside three hours. It was enabled by default on August 14 with input.UseInputThread and -NoInputThread as escape hatches (fbd5d79a), and a backout with the identical description landed the same afternoon (3ba05293). We checked the branch: input.UseInputThread still defaults to 0 on ue6-main, so nothing has changed for you yet. Worth watching, because a default-on input thread changes threading assumptions for anything reading input state off the game thread, and Epic has now tried once.

A new experimental geometry plugin called JOULE appeared at Engine/Plugins/Experimental/JOULE, with core mesh, grid, atlas packing, and cut-face headers. The author describes it as an initial assisted port and a proof of concept to be matured as it is used, and it landed with no reviewer (f7987d2d). The name is the technique: jointly optimized u(v) lattice embeddings, an approach to continuous parameterization with a jointly optimized volumetric step. Two follow-ups the same week are a static analysis pass and a build fix, both housekeeping. The next few weeks of volume will tell you whether this is the seed of a real parameterization pipeline or something that disappears.

An engine-wide logging migration is underway under one ticket. Roughly eight commits this week move UE_LOG and UE_CLOG onto narrow-format UE_LOGF and UE_CLOGF, including the public wrapper macros and the Visual Logger wrappers, with the wide UE_VLOG_UELOG and UE_CVLOG_UELOG variants deprecated and several per-system logging macros migrated onto the narrow-format replacements (a42421cd, 4f1a1165, 28e1dbae, 22070966). Broad mechanical churn across public headers plus a deprecation means a removal step is coming and merge pain with it.

The modular test framework continued at roughly 20 commits for a third consecutive week, adding a standalone hub program that mounts a test plugin with its dependency closure (9a258893), a runner UI with warm-pool visibility and per-worker kill (e37999f9), elision of the reset and travel cycle between suites sharing a resolved environment (4b3252da), an external-session worker mode (d5960e48), and a Verse-facing plugin (b6d2c48f). Three straight weeks at that pace makes this a program.

For teams shipping on 5.8

ue5-main ran 55 commits this week, down from 122, and the mix is narrow: animation work dominates once you count UAF, Control Rig, and PoseSearch together, with the rest split between a procedural vegetation export cluster, localization automation, and isolated fixes.

The one to pull is a heap corruption. UControlRig::InitializeFromCDO reads the shared source hierarchy while also writing to it, registering a listening hierarchy and toggling a cache validity flag, with nothing serializing access, so multiple Control Rig instances of the same class initializing concurrently on anim worker threads corrupted the listening hierarchies array (2da7adde, b3af43db). If you run Control Rig on characters and have ever seen unexplained anim-thread instability at scale, this is a candidate.

Also on the branch: UAF variable refactor phase 1 replaces the binary public and private variable flag with input, internal, and local scopes plus access control, where external callers reach input-scope variables only and inputs are read-only inside UAF (5c3106ac). A PoseSearch fatal check on a database and schema race in completion handling was fixed (d6d94482). Lumen hit-lighting picked up inline ray tracing from ray generation shaders and disabled unused permutations (e3cc02de). Movie Render Queue PIE lifecycle issues were fixed, including a Quick Render crash when a render is aborted because a Blueprint does not compile (420759f4). And a use-after-free from binding a const reference to a temporary returned by FText::ToString() was fixed on the platform text entry path, the same class of bug that got the annotation and sweep treatment on ue6-main (de14038d).

No 5.8.x point release is named in this week’s commits on the branch.

What We Ignored

We passed over roughly 480 commits this week: static analysis and warning cleanup passes, localization automation, formatting, test plumbing, and content asset updates that resolve only to binary manifest blobs. That figure includes the 27 commits tagged [Backout], whose net effect shows up in the changes they landed on or removed.

Closing

A quiet week for anyone shipping content and a loud one for anyone running the machines that build it. Three separate multi-week failures ended the same way: someone added an instrument that names the cause instead of another retry that hides it.

Commit SHAs are cited inline, in parentheses, next to each claim. They reference the ue6-main branch of EpicGames/UnrealEngine unless the claim is in the 5.8 section, which references ue5-main. Some of the highest-interest entries resolve to Commit.gitdeps.xml binary-manifest blobs: the commit message is real, but the code lives in Epic’s internal binaries, which we cannot see.

Week of August 3 - 9, 2026 | 784 commits on ue6-main, 122 on ue5-main | Branch: ue6-main

Overview

784 commits, 174 worth reading, and the ones that matter most are all the same kind of bug. A cache returned the wrong answer, or no answer, and nothing failed. The shader job cache silently lost keys whenever its hash table grew. DDC record bytes changed based on whether debug dumping was on, which is deliberately not part of the key. EpicClang build identifiers differed across machines because of line endings. The UBA cache server ratcheted its own expiration window from three days down to four seconds and kept serving traffic. None of these throw. All of them cost you compile time, cache hit rate, or a shared cache whose records disagree with each other.

The rest of the week ran underneath that: two large decompositions kept moving, HDR output changed for real, and a lifetime check went fatal and took a wave of shutdown crashes with it.

Development Trends

Build is the top subsystem this week at 85 high-interest commits, and for the first time in this run the work is about correctness of the cache rather than the speed of the build. Build has been rising for weeks (50, 76, 71, 98, 87, 61, 85 across the full-volume weeks). The July arc was modernization: C++23 by default, circular dependencies eliminated, EpicClang versioned, the C# BuildGraph VM deleted. This week the same subsystem produced seven independent defects in which a cache, hash, or identifier was not a function of its inputs. Epic is now paying down the correctness debt of the caching layer it spent the summer speeding up. If you run a shared DDC or a distributed cook, this is the week’s actionable content.

The UBA cache server is being hardened under live production failure for the second time in three weeks. The week of July 20-26 covered a UBA cache server rewrite driven by production pressure. This week is the sequel, and the failure mode escalated from throughput to process death: repeated SIGBUS crashes on a filesystem at 99% (1e557470, 65deda8a), maintenance that never compacted busy buckets (3fa18243), and a container-compatibility rewrite of the memory-sharing transport (682d941e). Two consecutive escalations on the same component means Epic is running this at a scale where the old design does not hold. Anyone self-hosting the same component is running the same design.

The renderer decomposition continues, but the pattern has shifted from carving out extensions to changing how they update. For six weeks FScene work meant moving data into a new scene extension. This week FLumenSceneExtension replaced explicit Add/Update/Remove calls with dirty-state-driven updates (9f87848a), and FRayTracingSceneExtension replaced a bCachedRaytracingDataDirty bit on FPrimitiveSceneInfo with FDataArrayDirty (164a546c). The interesting one is 8ffb925b, which moved ISceneViewFamilyExtention derived types from Fork_GameThread to Fork_AnyThread and states plainly that it is groundwork for constructing SceneRenderer on the render thread. Six weeks of extension carving have been heading there.

Backout volume is high and concentrated: 17 explicit backouts plus four first-line reverts. The Mass module decoupling landed, was backed out, landed, was backed out, and relanded (a09993fd, cd2dd396, 8687b20d, a744a595, ba27d4d6). If you track ue6-main closely, this week is a bad week to sync to an arbitrary changelist.

TL;DR

• FShaderJobDataMap::FindOrAdd probed for a free slot before calling Reserve, and Reserve rehashes on block growth, so the key landed off its own probe path and became unfindable. A lost key means every later job with that input hash misses deduplication and the job cache and recompiles for the lifetime of the process. Keys are lost at power-of-two growth boundaries, so larger projects lose proportionally more (40513cd5).
• The UBA cache server crashed repeatedly in production with SIGBUS, because pool files grow sparse and writes allocate blocks at page-fault time with no error path. Extents are now reserved at commit time via fallocate (65deda8a, 1e557470). Separately, bucket maintenance never won its exclusivity race on busy buckets, so compaction never ran and expiration collapsed from three days to four seconds (3fa18243).
• The filmic HDR remap was decoding against the 100 nit SDR reference while paper white normalized against the BT.2408 203 nit reference. Film white sat low and mid-tone chroma drifted, worst on bright lightly saturated colors. If you have graded HDR against current UE6 output, re-check it (ac66493c).
• Delegate lifetime reporting is now fatal on non-shipping builds (a63e30fe). Your CI can start failing on code that has been quietly wrong for years, and the same week produced a dense run of shutdown crash fixes with exactly that shape.
• mimalloc v3.3.2 is now enabled on Windows, Mac, and Linux for the Editor and standalone programs (bd92d641). Two files, and every editor memory measurement from here is against a different allocator.
• On ue5-main, three commits are visibly shaped to stay hotfix-safe and one names the release outright. A 5.8.2 point release is being assembled (d8a2e8e0, c32fe678, 463e23cf).

Highlights

The shader job cache was dropping keys, silently, at every growth boundary

What changed. FShaderJobDataMap::FindOrAdd probed for a free slot, then called Reserve, then wrote the item at the slot it found earlier. Reserve rehashes when it adds a block, which changes HashTableMask, so the slot no longer lay on the key’s probe path. The key became unfindable, and if that slot was occupied after the rehash, it displaced the key already living there. The probe now happens after Reserve, and the search index is scoped to its loop. The commit also removes FShaderJobDataMap::Find and FShaderJobCache::Find, which had no callers and the same class of bug (40513cd5).

Why this is important. The commit spells out the cost: a lost key means every later job with that input hash misses both deduplication and the job cache and recompiles, for the process lifetime. Keys are lost on power-of-two block growth, at 512, 1024, 2048, 4096 unique hashes and up. That means the defect scales with your shader count. A small project might never notice. A large project loses a key at every doubling and pays for it until the process exits. Nothing logs, nothing warns, and the symptom is a shader compile step that is slower than it should be for reasons no profile will explain.

Who should care. Anyone with a large shader permutation count, anyone benchmarking shader compile throughput, anyone who concluded their job cache was underperforming and could not say why. One file.

Urgency: Act now.

The UBA cache server spent the week dying in production

What changed. The largest single cluster of the week is one engineer chasing a repeatedly crashing production cache server, and the fixes are architectural rather than defensive.

When the file-mapping backing ladder falls through to disk files (memfd blocked by seccomp in Docker, /dev/shm too small), pool files grow sparse and writes through the mappings allocate blocks at page-fault time. On a full filesystem that fault is a SIGBUS with no error path. The production box showed a pool file with 1TB apparent size and 4KB actual on a filesystem at 99%. Extents are now reserved at commit time via fallocate, so running out of disk surfaces as a failed map plus a logged error instead of killing the process mid-memcpy (65deda8a, 1e557470).

Bucket maintenance was broken in two independent ways. Exclusivity was only attempted after a multi-second delete pass, so zero-clients maintenance always lost the race against reconnecting clients and compaction never ran on busy buckets. Meanwhile the overflow squeeze triggered on raw table size, which is mostly dead offsets that only compaction can remove, so it re-tightened expiration every pass against its own wreckage. Observed effect: an expiration window ratcheting from three days to four seconds while the tables never shrank (3fa18243). Gating that squeeze then exposed a second bug where an overflowing but busy bucket got re-queued by every sweep tick, producing a 250ms no-op maintenance run every second, forever (3451f7f2).

Transport changed too. Downloading a 1GB cas file sent one RPC per 256KB segment, which is 4,000 messages each dispatched to its own server worker. Batched segment fetching replaces that with a reserved id train, default 8 segments per batch, with a version handshake so old and new cache servers interoperate (5f8e11d0). Worker threads no longer stay pinned for the whole wire drain (8bf4c31d).

pidfd_getfd is gone entirely, replaced by an abstract Unix domain socket handing out memfd descriptors via SCM_RIGHTS, with a SO_PEERCRED uid check, a creator-pid match, and a /proc/self/fd readlink confirming the descriptor is a memfd. The reason is specific: pidfd_getfd requires PTRACE_MODE_ATTACH, which default Docker and Podman seccomp profiles block. The old path silently degraded to /dev/shm or disk inside a container (682d941e). All POSIX platforms moved to anonymous mapping descriptors and the name-based shared memory machinery is deleted (11837995).

Why this is important. If you self-host UBA and run it in a container, you may have been running a disk-backed cache while believing it was memory-backed. If you run it near a full filesystem, you have a crash loop with no error message. If your buckets are busy, your expiration window may not be the number you configured. All three fail quietly, which is the theme of the week.

Who should care. Build engineers and CI infrastructure teams self-hosting UBA cache or storage servers, especially in Docker or Kubernetes.

Urgency: Act now.

Cache keys stopped depending on things that are not inputs

What changed. Five independent commits, all the same shape: something that should be a pure function of its inputs was not.

FinalShaderSource was serialized into ShaderCompileJob DDC records unconditionally, so enabling debug dumping (which is intentionally excluded from the DDC key) changed the record bytes for a fixed key. It now crosses the worker boundary without entering the cache record, and debug dumping was reworked so cache hits still get debug-compilable source (b0070937). Shader debug dumps also stopped differing between two cooks for reasons unrelated to the shader: defines moved out of inlined source comments into a Defines.csv artifact, and hash markers became empty filename-encoded files (60b432af).

EpicClang now normalizes text file line endings when calculating the build hash, which the commit says plainly should keep build identifiers stable across machines (638c39ee). Editor bulk data identifiers are salted with the lowercased owning package name, because byte-identical duplicate packages were sharing persisted identifiers and cache keys (5538b8d6). Nanite fixed build non-determinism for clusters carrying voxels or curves but no triangles, with a note that DDC versions were not bumped because the non-deterministic dwords were never read (1644f558).

And one commit is not a fix at all: an off-by-default console variable that logs the inputs and outcome of the unused-parameter strip gate for each material instance at cook-save time, described as temporary instrumentation to root-cause non-deterministic cooked headers caused by an async-ordering race in cooked resource availability (b4b96e0e). That race is still open.

Why this is important. None of these produce a wrong build. They produce a cache that disagrees with itself, and that shows up as hit rate rather than as failure. For a studio on a shared DDC, a key that shifts based on whether an engineer had debug dumping on is a cost that gets absorbed as “the cache is just not that good.” The EpicClang and bulk data fixes are the same story at a different layer.

Who should care. Anyone running a shared DDC, a distributed cook, or content-hash-based caching. Anyone who has ever tried to explain a cache hit rate.

Urgency: Track, and pull the shader DDC fixes if you run a shared cache.

Horde got two CI reliability fixes worth reading even if you do not run Horde

What changed. A race condition in the Horde agent from incorrect concurrent use of a single AesGcm context (2ea64825). The storage HttpClient timeout went from the default 100 seconds to 300, because the 100 second ceiling cut the retry policy short and caused job step failures where a transient network error had already been recovered from (0df89cad). Separately, PerforceMaterializer did not correctly sync streams with @CL-pinned imports after an edge-server swap, leaving files stale or missing (2947e107), and UnrealCloudDDC made compact partition writes lock-free (fdbf163d).

Why this is important. The timeout one is the useful one to steal. A retry policy nested inside a shorter client timeout means the retries never get to run, and the failure surfaces as a flaky job step rather than as a timeout. That pattern is not specific to Horde, and if you have flaky CI steps that recover on manual retry, it is worth checking whether your own client timeouts are shorter than your retry budget.

Who should care. CI and build infrastructure teams. Horde users should take all four.

Urgency: Act now if you run Horde, track otherwise.

HDR output changed this week, and it is a correctness fix

What changed. The automatic HDR remap of the filmic tone curve was decoding film image against the 100 nit SDR reference while the scene multiplier normalized paper white against the BT.2408 203 nit reference. Film white sat a stop low and mid-tone chroma drifted, worst on bright lightly saturated colors such as pale skin. The remap is now anchored at HDR reference white, decoding to min(203, peak luminance) nits and inverting an output transform whose peak matches (ac66493c).

The inner LUT shaper moved from normalized-PQ index encoding to gamma 2.2, with numbers quoted in the commit: worst-case grayscale interpolation error drops from about 9.0 to about 2.5 10-bit PQ codes at a 4000 nit peak, and from about 1.7 and 4.2 to about 0.4 and 1.0 codes at 1000 and 2000 nit peaks (5f6131cb). A real multi-view performance bug also got fixed: combine-LUT settings caches and ACES 2.0 transform table contexts were function statics shared across every view, so multiple viewports or scene captures rebaked both LUTs and regenerated transform tables every frame. Both now live on the scene view state (e2e9b2d3). The recurring luminance anchors are now named constants (0d458ead).

Why this is important. Few rendering changes move pixels in shipped content. This one does. If you have graded HDR against current UE6 output, your grade was compensating for a known-wrong white point. The multi-view fix is separately worth having for anyone running scene captures or split screen.

Who should care. Graphics engineers, technical artists, cinematics and virtual production teams shipping HDR.

Urgency: Act now if you ship or grade HDR.

A lifetime check went fatal, and the same week paid the bill

What changed. Delegate lifetime reporting is now fatal on non-shipping builds, explicitly so detection is caught in general testing rather than only in dedicated tests (a63e30fe). Alongside it came an unusually dense run of shutdown, exit, and cook-teardown crash fixes with one repeated shape: something holds a raw non-owning pointer, or reads a UClass or UScriptStruct after PurgeAllUObjectsOnExit has already destroyed it.

The canonical case is that FModuleManager::UnloadModulesAtShutdown() runs after PurgeAllUObjectsOnExit, so any ShutdownModule body calling StaticClass()->GetFName() reads freed memory, including indirectly through TSubclassOf<T> (16a52159, 234d7bd9, 9a1da123). The dangling-delegate variants follow the same pattern: TraceInsights managers registered with AddRaw into a delegate that outlived them (e4b44368), UEFN never unregistering BrowseToAssetOverrideForClass on editor cleanup (cd365d9b), the Sequencer playback client capability holding a raw pointer never cleared when the client actor was collected (0a003158).

One is not editor-only. A use-after-free of FNamedShaderLibrary where a GFP unmount plus deferred CloseLibrary could destroy a library while an InstallBundleManager worker was inside a concurrent pak-mount callback, reproduced from a retail callstack and introduced by an earlier lock-contention change (d2866b8d). Also a use-after-free and a leaked FRunnableThread in FAsyncQueryLatestServerChunkInfo in StorageServerClient (e9cc8c74).

Why this is important. A fatal check upstream means CI that was green can go red on code that has been wrong for years. Correct outcome, bad timing if it lands on you unannounced. Plugins that touch statics or delegates in ShutdownModule are the highest-risk surface.

Who should care. All teams. Especially anyone maintaining plugins, and anyone running non-shipping builds in CI.

Urgency: Track, act now if you run non-shipping builds in CI.

Two decompositions, one backout storm

What changed. Lumen data and update logic moved out of FScene and FPrimitiveSceneInfo into FLumenSceneExtension, and the significant part is not the move. Explicit LumenAdd/Update/Remove/InvalidateSurfaceCache calls were replaced by a dirty-state-driven updater, with copy-on-write previous values used to skip no-op changes. One behavior delta is worth knowing: world-origin shifts previously did not update the Lumen scene at all, and now do (9f87848a). The same pattern hit cached ray tracing, where the bCachedRaytracingDataDirty bit was replaced with FDataArrayDirty in FRayTracingSceneExtension and lazy per-view update became eager update during renderer scene update (164a546c). A TSAN race where EnableCopyOnWrite() was called from one extension after another had already spawned a read-only task was fixed by restricting it to the registration phase during FScene construction (595ed7ee).

On the gameplay side, MassEntity’s core types are being decoupled from the Engine module ahead of a move to MassCore, with chunk memory size becoming an ini-settable mass.DefaultChunkMemorySize. It landed, was backed out, landed, was backed out, and relanded, with non-unity include breakage found only by a Linux preflight (a09993fd, cd2dd396, 8687b20d, a744a595, ba27d4d6). The commit message states 80 files moved and roughly 650 in-tree consumers migrated to new include paths in a single changelist.

Why this is important. Both refactors compile clean and then break forks at link or at runtime. The Mass one in particular is a migration event for anyone with a Mass-based gameplay layer, and the double backout says it was not smooth for Epic either.

Who should care. Rendering engineers and engine-fork maintainers for the FScene work. Gameplay tech teams on Mass for the module split.

Urgency: Track. Act now if you maintain a fork with custom scene proxies or a Mass gameplay layer.

Shipping to devices got easier, if you were blocked

What changed. Xcode 27 now passes UBT SDK validation: the Apple MaxVersion was raised to 27.9.0, and the Xcode 27 SDK turning SwiftUI’s @State into a macro is worked around by passing Swift macro plugin search paths explicitly, with platform plugins loaded in-process because swift-plugin-server returns a malformed response under Epic’s build executor. Verified against Xcode 26.1.1, 26.3, 26.6, and 27.0 (5a5295cc).

Two Android packaging bugs that only reproduce in Installed or Launcher builds: Steamworks_APL.xml was never staged so Steam-on-Android packaging failed outright, and the APL’s $S(NDKRoot) and $S(HostPlatform) were never registered so libc++_shared.so was silently skipped (d1c9d5ea). A Main OBB in the assets folder was not added into the APK on basic deploy (fc93d654). AndroidFileClient small-file writes double-optimized the path, so a first-call base-directory change was lost and files could be misrouted while the push still reported success (689e1c6d).

On mobile GPU: a Mali-G68 MP5 crash on the Galaxy A54 fixed by adding --simplify-instructions and --eliminate-dead-code-aggressive to the Android SPIR-V driver-patch scalar-replacement pass (624093bc). An occlusion optimization quoting -0.4ms render thread, -0.3ms game thread, and -0.1 RHI landed, with PrimitiveOcclusionHistorySet::Find measured at 43% of sampled cycles on a gen8 mobile console (ba66ef5f). A commit carrying the identical description was backed out the same day (4ce7efd0), so treat that optimization as in flux.

Why this is important. The Xcode 27 and Android Installed-build fixes are pure unblocks. The AndroidFileClient one is the interesting bug: it reported success while misrouting files, the same silent wrong answer the caching cluster kept producing.

Who should care. Platform engineers, mobile teams, release engineering.

Urgency: Act now for iOS and Android teams.

The editor’s agent layer got a permission model and some API honesty

What changed. The editor-side agent surface (a ModelContextProtocol plugin with an FModelContextProtocolServer, a Toolsets plugin, an EditorToolset, a ToolsetRegistry that generates tool schemas) got the unglamorous work you only do on something you intend to ship.

Session teardown in the MCP server removed sessions without calling Tool->CancelAsync, leaking tool-held external state on any session DELETE or server shutdown and leaving the parked HTTP request to time out with no response (a11ec7ae). Two schema-honesty fixes: ToolsetRegistry now rejects optional tool params carrying a non-None default, because the generated schema published null while the implementation substituted a value, and find_assets declared max_results as int | None = 100, telling callers the search was uncapped (a6246539, 27c219bb). The 80KB read_file limit is gone, and find_assets dropped a redundant in-memory asset registry query that walked the whole UObject heap duplicating the on-disk enumeration (691183cd, d9fec4bc).

The permission work continued from last week: an IToolsetPermissionProvider with GetToolsToHide (1f6f3012), a project-default tool-access permission mode on the agent environment descriptor (1604c0da), and access-level tagging on the skill management tools (11d652a6). A read-only navmesh query toolset landed that registers in cooked dev and test builds, not just the editor (19f14abe).

Why this is important. Two schema fixes in one week, both about the published contract lying to the caller, plus request cancellation on teardown. Epic is maintaining this like a shipping API. The permission work is the second consecutive week of access control rather than capability, and a toolset registering in cooked dev builds moves the agent layer out of the editor.

Who should care. Tools engineers, pipeline TDs, anyone evaluating LLM-driven editor automation.

Urgency: Track.

mimalloc is now the editor allocator on all three desktop platforms

What changed. mimalloc v3.3.2 enabled on Windows, Mac, and Linux for the Editor and standalone programs. Two files, Core.Build.cs and MallocMimalloc.cpp. Test notes list multi-process cooks, editor perf tests, and comprehensive editor tests (bd92d641).

Why this is important. Two files, and it invalidates your baselines. Every editor memory measurement, fragmentation report, and out-of-memory repro from this changelist forward is against a different allocator. If you are carrying an allocator-sensitive bug or a memory budget you defend in CI, this is the commit that moves the numbers.

Who should care. Anyone tracking editor memory, anyone with allocator-sensitive tooling, anyone about to file a memory regression against ue6-main.

Urgency: Track.

Worth Tracking

“Ness”, a serialization runtime nobody is talking about. A module tree at Engine/Source/Runtime/Ness/NessUObject/ is accumulating steady work from three engineers: property binding factories, a linker with FLinkerPropertyBatch, a roundtrip test, a diff implementation, and a -strictsave argument that skips saving and loading UObject payloads with incomplete Ness support while emitting a report of structs that are not yet compatible plus a skipped-object count. Test tags on one commit read “lyra: nesspacks, ness roundtrip.” The expansion of the name appears nowhere in the commit data, so treat it as a literal token. A -strictsave mode, a compatibility report, and validation against Lyra add up to a serialization replacement mid-migration. Helper libraries do not need any of that. If Ness is what it looks like, it eventually touches every cooked package and every DDC key in the engine. Nothing to act on. The struct-compatibility report is the thing to watch week over week (ffb3a7a5, bc0481c8, 71f405ca, f22d0ce7, 02efb0f5, 3e0e8c6b, 04b50198, 06609cc5).

ModularTestFramework is a second automation stack, and it now has a UI. Roughly two dozen commits this week in Engine/Plugins/ModularTestFramework/ and Engine/Plugins/Editor/ModularTestRunnerEditor/, almost all rated low or medium individually. Together they are a full test runner: dockable per-run tabs that freeze into snapshots on completion, a run-config tab that displays backend consequences, a multi-process backend with a warm pool that pre-spawns client slots from the resolved test set’s declared count rather than a hardcoded command-line knob, per-run overrides for timeout and environment recycling, and a resolver API that mounts and unmounts test companion plugins through per-resolver dispatch. One commit is explicit that it skips “the foreign FAutomation test walk” when dispatching editor runs, so this is running beside the legacy automation framework, not replacing it yet. The multi-process backend with declared client counts is aimed squarely at flaky multiplayer tests. Worth watching for whether it becomes the recommended path (86d33ee8, f486ed2d, cf9d90bf, 2f9ded31, caf1ed1f, bc0edb00, de268c78, f6526778, 72f13bcd, 219b85a8, 4cf52b4a, dc53b6ed, b9c3611e, e8291790, 6689ab01, e168a4f9).

SceneGraph is starting to work without proxy actors. The SceneGraph and TEDS commits stopped being infrastructure this week and started being behavior. Duplicate, paste, and alt+drag now work in edit-in-place without proxy actors, and FParticleSystemAssetComponentEditorUtilities dropped its proxy-actor reliance. Proxy actors are the compatibility shim that lets the existing editor manipulate SceneGraph entities. Every commit that removes a dependency on them moves the editor closer to operating on entities natively. That transition eventually changes what a level means for tooling, source control diffing, and anything that walks actors (3a349b8b, ab2e0e3e, 10254923, 2e1bc001, 24bb792b, cfb73504, 73fc199f, 9346b10f, f41b3299).

One merge hazard to plan around. A sweeping UE_LOG to UE_LOGF migration landed, described in its own message as only TEXT() removal, %s to %ls, and %hs to %s (11593724). Mechanical does not mean cheap: for any studio carrying engine modifications, a tree-wide macro and format-specifier migration is a merge-conflict event. Schedule it rather than discover it.

For teams shipping on 5.8: the ue5-main sidebar

122 commits, 118 after noise filtering, against 784 on ue6-main. 54 of those 118 carry #Synced-CL integration markers, so this branch is still taking integrations rather than sitting frozen.

A 5.8.2 hotfix is being assembled. Three commits are visibly shaped by hotfix constraints, which is a stronger signal than any of the fixes individually. One names the release outright: “Note that fix is made to be HotFix compatible for 5.8.2 and a more robust fix may be required for future releases,” and carries a #p4v-cherrypick marker (d8a2e8e0). Another states the constraint plainly while removing an ensure when hashing User Defined Structs with unhashable members: “To avoid changing the hash in a hotfix, the real fix will be pushed in Main” (c32fe678). A third is simply titled “Hotfix for modular vehicle crash” (463e23cf). Two engineers independently narrowing their fixes to stay hotfix-safe points the same way.

Bugs that only exist in cooked builds. The highest-value cluster on this branch, because none of these reproduce in PIE. Anim Mixer suppressed Force Root Lock through FAnimExtractContext::bIgnoreRootLock, which is WITH_EDITOR only, so cooked builds applied the lock during decompression and published the locked constant as root motion. Sections using an anim sequence with both Force Root Lock and Enable Root Motion produced no root motion at all in cooked builds (f3ba9867). A Mover fix is explicitly labeled a regression from 5.7: the stale spring-state reset keys off a blackboard flag only a locally ticking simulation sets, so interpolated sim proxies discarded replicated spring state and restarted every trajectory prediction from zero acceleration, visibly lagging motion matching (4712c3cc). Function references stamped with a stale variant Guid failed to resolve in cooked builds while the editor’s event-name fallback hid it (11a5e03d).

Toolchain and packaging. Xcode 27 support landed here too (92b559b5), plus Android TargetSDK 36 (20741414), the Main OBB packaging fix (3846da3f), and Steam-on-Android for Installed and Launcher builds (1a077aa5). Two UnrealBuildTool manifest bugs shipped: generated UHT outputs missing from installed builds (f246278c) and UHT input cache files wrongly counted as build products (be3a7b30).

Nanite determinism, on this branch too. The same fix class as ue6-main: assertion fixes for assemblies with Keep Triangle Percent below 100 or Trim Relative Error above 0, plus a build non-determinism fix for voxel and curve clusters (5257e679). Pull it if you cache cooked Nanite output.

Also worth pulling regardless of hotfix timing: a quick fix removing SupportsNoOverwriteBuffers() on bone and cloth buffers, which addresses motion blur corruption seen in the wild (b3108674), and a DFAO change that marks sky pixels with negative SceneDepth and rejects them during upsampling, replacing behavior the commit describes as causing a lot of flickering in dark regions (50bf95d2).

Nothing about this branch reads frozen. It keeps taking integrations while a point release gets staged underneath it. New work is landing too: a large editor docking refactor giving every TabManager-managed window a status bar and panel drawer (7cc08fff), a Dynamic Wind tooling series, and a seven-commit Control Rig constraints pass.

What We Ignored

563 of the 737 analyzable commits, plus the 47 filtered as noise before analysis. Mostly localization automation, README additions, tooltip and comment polish, static analysis warning cleanup, test asset repairs, and the ordinary weekly tail of single-file crash fixes in narrow plugins. Also 17 explicit backouts and four first-line reverts, counted in the trends section rather than reported individually. None of it changes runtime behavior, build reliability, or upgrade risk for production teams.

Two from that tail are worth naming anyway because they affect shipped content: a Nanite assembly build crash with Keep Triangle Percent below 100 (39c00366), and a DFAO flicker fix in dark regions (c1cc531e).

Closing

The crashes were the least interesting thing that happened this week. Seven separate places returned a confident answer that was not a function of its inputs, and nothing anywhere logged a complaint. That class of defect never shows up in a crash report or a failing test. It shows up as a build that is slower than it should be, a cache hit rate nobody can explain, and a grade that was compensating for a wrong white point.

Commit SHAs are cited inline, in parentheses, next to each claim. They reference the ue6-main branch of EpicGames/UnrealEngine unless the claim appears in the 5.x sidebar, which references ue5-main. Many of the highest-interest entries resolve to Commit.gitdeps.xml binary-manifest blobs: the commit message is real, but the code lives in Epic’s internal binaries, which we cannot see.

Week of July 27 - August 2, 2026 | 822 commits on ue6-main, 254 on ue5-main | Branch: ue6-main

Overview

A stabilization week with two large refactors running underneath it. 77 of the 165 commits worth reading on ue6-main are crash, hang, deadlock, or teardown fixes, and what connects them is diagnostics rather than volume. Epic kept taking failures that were silent, misattributed, or undiagnosable and making them loud and specific. The crash reporter learned to report its own death (394ead63). Epic built a commandlet that fingerprints Nanite builder output so two changelists can be diffed, because it suspects the builder is not deterministic (10496625). A test harness converted an 1800-second silent hang into a bounded failure that reports in about 240 seconds (e36e274c). UBT stopped printing only the two endpoints of a broken plugin dependency and started printing the whole chain (cc39075c). The counterexample is a one-file commit nobody would stop on: enabling the HTTP server discarded the connection origin filter, leaving the allowed-origins allowlist unenforced on the PixelStreaming2 players signalling server (a62fabd2). A live auth bypass that existed because a failure was quiet.

Development Trends

FScene decomposition has escalated at every full-volume week since early June, and it is no longer additive. Last week it broke public API. This week it changed the storage model itself. 24640f93 converts FScene’s packed parallel arrays (transforms, bounds, occlusion, visibility ids, proxies, scene infos, flags, component ids) to TDataArrayDirect keyed by persistent primitive index inside FScenePrimitiveDataRenderer. Frustum culling now iterates the id-allocator chunk mask, with 64-id chunks mapping to two visibility-map words, and per-view HiddenPrimitivesMap and ShowOnlyPrimitivesMap bit arrays replace per-primitive TSet lookups in the cull loop. Epic carved out two more extensions the same week: reflection environment data into FReflectionEnvironmentSceneExtension (a04f63cf) and the indirect lighting cache plus precomputed light volumes into FIndirectLightingSceneExtension, gated on IsStaticLightingAllowed() (4b44255b). Epic describes the reflection environment move as carrying minimal behavioral change; the indirect lighting move makes no behavior claim either way. The deletions tell you the direction of travel: unused scene proxy APIs (8919180a), unused AddStaticMeshes/UpdateStaticMeshes parameters that “would now lead to unexpected state if used” (8feb62fc), and deprecated HWRT code in FPrimitiveSceneInfo (07f66585).

Build and toolchain work has been running for months: modernization, then correctness under failure, and this week outright deletion of dead layers. The BuildGraph bytecode VM is gone: the compiler and interpreter plus the graph builder path on July 28 (06683fd7, 010bbd83), then the entire expression tree in a 27-file cut two days later (187ddf19). Separately, the bundled DirectX SDK is retired in favor of the Windows SDK across 76 files (9d6d218d). Neither adds capability. Both remove a layer Epic no longer wants to carry, and that only happens late in a modernization program.

The agent toolset arc is now four distinct phases deep: prototype, then crash hardening, then escaping the editor into cooked runtime, and this week a permission model. Twelve commits across July 30 and 31 tagged the toolset families with an AIAccessMode of read, write, or execute, after the ToolsetRegistry schema gold values were updated for annotations.accessMode days earlier (ccd0297c). Nothing this week enforces those access modes yet. What did land is a separate restriction layer, a shared property-write gate backed by FPropertyEditorPermissionList (98a0cf13), and a per-conversation undo manager with a dedicated transaction buffer (969825c7). Typed access levels and rollback semantics show up when someone expects the toolset pointed at a real project.

On volume: the weeks of June 29 and July 6 were Epic’s summer shutdown, not a slowdown in the program. Exclude both weeks when you read the multi-week curves, or you will misread a holiday as a deceleration.

TL;DR

• The PixelStreaming2 players signalling server was silently ignoring its AllowedOrigins allowlist whenever the HTTP server was enabled, which is a live auth bypass and the single cheapest thing to fix this week (a62fabd2).
• FScene converted its packed parallel arrays to persistent-primitive-index keyed storage and removed FSceneInterface::GetPrimitiveSceneProxies and GetScenePrimitiveComponentIds, so renderer forks will not compile without work (24640f93).
• The C# BuildGraph expression API is gone: if you wrote C# BuildGraph scripts against the BgExpr family, they are dead on ue6-main (187ddf19, 010bbd83). The XML path survives, but it is not untouched. The legacy <Notify> and <Report> elements and the -ReportName and -ShowNotifications switches were removed the same week (301f225b).
• Metal 4 landed as a second RHI backend alongside Metal 3, selected once at device init and gated by rhi.Metal.EnableMetal4 and rhi.Metal.ForceMetal3, with the third-party bring-up shipping the same week (8a469fb3, 51da534b).
• On ue5-main, cook validation found that roughly 800 ControlRig and RigVM packages were being re-flagged on every incremental cook, and healed values got re-flagged with new values on the next run (acf33841).

Highlights

A live auth bypass in the PixelStreaming2 signalling server

What changed. Enabling the HTTP server discarded the connection origin filter, so the AllowedOrigins allowlist went unenforced on the players signalling server (a62fabd2, UE-386542). The fix is small. The exposure was not. Separately, 715723eb hardens the MP4 box parsers against malformed box data across 8 files.

Why this is important. If you run pixel streaming with a public endpoint and configured an origin allowlist, you may have been trusting a control that was not running. Nothing failed loudly. The filter ran on every connection, and its rejection was discarded before it could take effect.

Who should care. Anyone shipping PixelStreaming2 with a public or semi-public signalling server. Media pipelines ingesting untrusted MP4 content should pick up 715723eb as well.

Urgency: Act now.

FScene’s scene data is being rebuilt underneath you

What changed. 24640f93 touches 52 files and converts transforms, bounds, occlusion bounds, visibility ids, proxies, scene infos, flags, and component ids to TDataArrayDirect keyed by persistent primitive index in FScenePrimitiveDataRenderer. Frustum culling iterates the id-allocator chunk mask instead of a dense array. Per-view hidden and show-only bit arrays replace TSet lookups inside the cull loop. FSceneInterface::GetPrimitiveSceneProxies and GetScenePrimitiveComponentIds are removed outright. The change reaches Lumen, Nanite, PCG, HairStrands, and the culling paths. Two scene extensions split out the same week (a04f63cf, 4b44255b), 76539c2a adds an IsDrawnChanged dirty array explicitly staged for downstream use, and ae5556ad routes transient renderer arrays through SceneRenderingAllocator to cut per-frame malloc churn.

One real correctness fix hides inside the refactor. ea0392bf replaces inherited task-access-context propagation in SceneData with an explicit copyable FTaskAccessHandle captured via CaptureTaskAccess() and opened with FTaskAccessScope. Under the old inherited model, any task launched from a managed task body could transitively capture the external access table and outlive the contexts it pointed at, producing a dangling-context crash in FBaseAccessContext::BeginReadAccess.

Why this is important. Two removed public accessors on FSceneInterface are enough to break a fork on sync. The storage-model change is deeper than that: if you have custom culling, custom primitive iteration, or anything that walked FScene’s parallel arrays by dense index, the assumption that index N in one array corresponds to index N in another no longer holds the way it did.

Who should care. Anyone maintaining a renderer fork, custom scene extensions, or engine-side culling modifications. Note that c2f51354 moved scene data headers to Engine and RenderCore public to unblock a Renderer refactor and calls the arrangement explicitly temporary, so do not build against it.

Urgency: Act now if you maintain a renderer fork. Track otherwise.

The C# BuildGraph VM is deleted and the DirectX SDK is retired

What changed. BuildGraph’s bytecode virtual machine is gone. 06683fd7 deletes BgCompiler.cs and BgInterpreter.cs. 187ddf19 removes the entire expression tree across 27 files: BgExpr, BgBool, BgInt, BgString, BgList, BgEnum, BgObject, BgFileSet, BgFunc, BgThunk, BgType, BgAgent, BgNode, BgAggregate, BgLabel, BgAnnotation, BgGraph, plus BgOpcode.cs, BgBytecodeWriter.cs, BgObjectDef.cs, and the bytecode-only serializers. 010bbd83 removes the BgGraphBuilder path. C# BuildGraph scripts now construct a BgGraphDef directly through IBgGraphDefBuilder.CreateGraphDef(). The XML path survives, but it is not untouched. 301f225b removes legacy <Notify> and <Report> support, inert under Horde because ExportForHorde() never serialized them, with node-level NotifyOnWarnings surviving. aaed92dc collapses BgOptionDef to its string variant.

Separately, 9d6d218d retires the bundled DirectX SDK in favor of the Windows SDK: 76 files, 117,916 lines, deleting every bundled DirectX import library and the whole Engine/Source/ThirdParty/Windows/DirectX/Include/ header tree, switching DX11, DX12, DirectSound, and Text3DEditor to PublicSystemLibraries. Commit.gitdeps.xml drops 77 lines. XInput.lib stays bundled, with a stated reason: SDKs older than 10.0.28000.0 ship an import library whose exported DllMain symbol ld-lld resolves incorrectly. Related cleanup landed in 08151c83 (DX11Audio third-party module removed), ea46e9da (unused dxerr.lib linkage dropped from Electra media modules), 2f39ad72, and 921dfcf3 (writable DirectX path properties marked obsolete).

Why this is important. Both change a contract you build against. The BuildGraph deletion breaks source compatibility for anyone who invested in C# graph authoring. The DirectX change alters what a Windows build machine has to have installed, and which version.

Who should care. Build engineers, anyone maintaining custom BuildGraph automation, and anyone who owns Windows build machine provisioning.

Urgency: Act now for build engineers.

UBT and the toolchain keep tightening, with a concrete compile-time win to copy

What changed. 8a5771cb is the item worth copying directly. Two include-hygiene cuts identified from ClangBuildAnalyzer captures of UnrealGame Win64 Development rebuilds under clang 20.1.8. PBDRigidsSolver.h dropped from 2455ms to 1210ms average parse, a 43 percent machine-normalized improvement across 29 unchanged consumers, and 71.2 seconds to 35.1 seconds in total. PBDRigidsEvolutionGBF.h fell out of the top-ten most expensive headers. Both removed includes stay behind UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_9, the first clear marker of where the next deprecation gate sits.

Around it: target rules moved onto source-generated readonly wrappers (cf9576a9, c5183cac, the second noting Horde preflights were not rebuilding UAT and were “leading to spurious failures”), duplicate target names now detected with a best-fit pick or an early error (98b0f444), full plugin dependency chains reported in sealed, disallowed, and deprecated validation errors instead of just the two endpoints (cc39075c), full paths allowed in ModuleRules.PublicDelayLoadDLLs on Windows (ff421d8d), and the old UBT solution file deleted (a4d3107e). On Linux, a6887a39 fixes hot reload failing on the import-library stub response file by routing stub creation through a LinkImportLibrary() override, so the stub becomes a declared module output. a0243626 fixes three separate LinuxServer problems: merged modules needing the lib<exe>.so soname form, the merged-module check for EOSSDK missing the Server target type, and a shutdown crash from global destructor ordering.

Cook and packaging picked up two items. 67274713 adds an IoChunkAssigner encapsulating IoChunk splitting, so game teams can route bulkdata payloads to arbitrary containers without deep IoStore knowledge, and it auto-updates the package header’s BulkDataMap. 16646740 downloads previous chunk assignments and writes a comparison diff of assets against prior cooks.

The shader preprocessor (not the shader compiler backend, and not the Verse compiler) got real memory-safety fixes in the vendored stb_preprocess C code (0c116a4d): an unbounded reverse whitespace walk that ran off the front of the buffer into the preceding array header, int length and capacity fields against a size_t API producing near-SIZE_MAX allocations, mis-ordered SSE read padding, and copy_argument failing to write back on three EOF paths. 5248e080 adds unit tests derived from live crash-log asserts, and 31a36269 dumps the pipeline job input hash alongside the stage hash in pipeline shader debug info.

Why this is important. The 43 percent header parse reduction is a template for work you can do yourself today with the same tooling. The UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_9 gate is advance notice.

Who should care. Build engineers, anyone with long iteration times on Chaos-dependent modules, and Linux server teams.

Urgency: Act now on the include hygiene technique. Track the rest.

The crash reporter learned to report its own death

What changed. When the crash reporting thread crashed while handling a crash, every diagnostic for the original crash vanished and exit code 777003 was the only signal you got. 394ead63 writes a last-resort minidump from the inner exception filter using only Win32 APIs and static storage. Because the original crashing thread is still parked in its own exception filter waiting on the reporting thread, a single dump captures both the original crash and the reason the reporter died. Stack-overflow crashes skip it outright. 8cd588f2 makes monitor-mode CrashReportClient attach that dump to the synthetic AbnormalShutdown report, only accepting dumps timestamped after the monitor started so stale dumps are never picked up, and translates the exit code to 777003 (CrashReporterCrashed). 22378fb0 stops the crash-time thread callstack walk from dereferencing threads destroyed during exit, which was itself crashing the crash handler.

Teardown ordering and lock inversion got a matching sweep. ae9683b9 fixes a server hang where DumpAllocatorStats grew a 256-element inline array while holding ClassesLocks, letting a layered malloc re-enter and deadlock. The commit notes servers hit this reliably because one size class commonly holds well over a thousand pools. 7409fd9a fixes a POSIX PTY shutdown deadlock in the Terminal plugin with a self-pipe wakeup, because on Linux the reader’s own reference keeps the open file alive, so closing the master descriptor signals nothing. 723ecc38 stops AddConsoleObject() from deleting a replaced console object that a hot-reloaded module’s static FAutoConsoleObject will later pass to UnregisterConsoleObject() at process exit. 52736778 returns ELoaderType::NotInitialized instead of dereferencing a destroyed async loader during the final purge.

Sequencer got a null-guard sweep across the week from two authors, five of the seven landing on July 30 and 31: Universal Object Locator fragment widgets polling property handles for objects that are gone (0d5ba46e), bound objects with no level where a spawnable template is outered to the UMovieScene (6812bdad), a fatal assert when a track has no registered track editor, seen in the field with a UMovieScenePropertyTrack added through the scripting API (6ac6cecc), AGroupActor::PostLoad dereferencing a null level after conversion to a spawnable (7d8a7f4a), animation with no skeleton (87b69159), keying object-reference array elements read through the enclosing FArrayProperty plus soft object refs being keyed as a null resolved UObject* (ce2539f6), and FValueCache holding its owner as a raw UObject* so every cache built for an actor’s components and instanced subobjects dangled on Blueprint reinstancing (7081461e).

Why this is important. Exit code 777003 with no dump is the worst crash report you can get. It tells you a crash happened and nothing else. If your telemetry has a bucket of unexplained abnormal shutdowns, this change turns part of that bucket into readable data.

Who should care. Anyone operating crash telemetry at scale, dedicated server teams, and Sequencer-heavy productions.

Urgency: Track. Act now if the Sequencer fixes match crashes you are already seeing.

The AI editor toolset gets a permission model and per-conversation undo

What changed. Around 30 commits touch the Python editor_toolset tree, the ToolsetRegistry plugin, and an AIAssistant plugin. About a third of them resolve only to Commit.gitdeps.xml, so the Python-side work is invisible in the public tree. The largest single source-visible change is 969825c7 in Engine/Plugins/Experimental/AIAssistant, which adds FAgentUndoManager with two modes. In global stack mode, agent edits are ordinary transactions and a reject unwinds back to the index at the agent’s first tool call, taking any interleaved user work with it. In per-agent stack mode, each tool call runs inside a capture window with a dedicated transaction buffer swapped over GEditor->Trans, teeing pre-state into a reinstancing-safe tagged record store, with a per-object guard so objects the user hand-edited afterward are skipped on rollback. The commit explains why it cannot simply unwind the buffer: flip-applying engine records can crash on reinstanced objects. It carries two backout tags, ships 1,117 lines of implementation against 1,003 lines of test, and is wired up in 3a4df67e.

The access-mode sweep ran across July 30 and 31 in twelve commits, tagging AI-callable functions with AIAccessMode values of read, write, or execute: EditorToolset (f53a203a), SlateInspectorToolset (ead4ec67), physics and simulation (f0c64976), Gameplay Ability, Tags, and Features (c18941fc), UMG and MVVM (46e75609), PCG (afcdd21c), Niagara (b70033ad), StateTree, WorldConditions, Conversation, and AIModule (8f4d4ba3), diagnostics and testing (7aaaf7cf), Geometry (0dbb7533), and MetaHumanGenerator (a0969299), with a follow-up tagging a new RewindDebuggerToolset function (01667eaf). The ToolsetRegistry schema gold values were updated for annotations.accessMode (ccd0297c). Two commits give those annotations teeth. 98a0cf13 adds a shared UE::PropertyEditor::CheckCanSetProperty gate with FPropertyEditorPermissionList support and routes both ToolsetRegistry and PythonScriptPlugin property writes through it, and 39628b49 adds a UToolsetLibrary::IsClassAllowed helper gating UMG and MVVM toolset object creation in UEFN.

The rest is production plumbing. c3107491 rejects scripts that use long-running blocking operations, with the stated goal of steering models toward non-blocking scripts, and PythonScriptingTools.execute_python went async for the same reason (c06ac6a8). execute_tool_script now takes a CodeBlock rather than a plain string (b4a6cbae). GLB and GLTF now route through Interchange in StaticMeshTools.import_file instead of failing on FbxFactory (587b0878). Getters and setters for SCS component variables, function locals, and inherited members can be recreated again, and list_variables gained an explicit VariableScope (85d33e3b). 9b06e4f4 fixes an enum default that broke JSON schema generation at editor startup. And 03839cb5 fixes four automation tests that keyed a node map on str(guid), which fell back to a struct repr embedding the wrapper’s heap address, so pass and fail “came down to allocator luck.”

The collateral is instructive. cddc9334 backs a no-op guard out of UAssetEditorSubsystem::OpenEditorForAsset and relocates it to the AI toolset entry point, because the subsystem-level guard silently broke Content Browser double-click-to-reload. eb1ad3af fixes a UMG async-load deadlock “when MCP tries to compile and has to sync load data.” 486f5f17 fixes a UMG Toolset crash renaming widgets with a null parent class. And ae501b76 replaces a module-scope import requests with the standard library, after it broke editor Python startup on any machine without a hand-installed package.

Worth noting without speculating: 0111a4cd adds a TPS and license entry for Meta Llama 3 8B Instruct under a tag reading “[Kimodo]”, and 90d4c03d adds an initial Kimodo plugin for something called the “AnimGenOffline framework.” The commit messages do not say what Kimodo is, and we are not going to guess.

The same week, 15 commits added 58 distinct README.md files: Core and CoreUObject (ca134812), four Chaos modules (98689430), seven MetaSound modules (1f1c36c0), 21 Concert modules (6034ea0f), Gameplay Cameras (f6b9545b), StateTree (5f2cff5f), Enhanced Input (5b4f69ac), and TaskGraph (91d54540), plus an async-loading doc that landed as AsyncLoading.md rather than a README (284b2991). The Concert commit spells out the format: YAML frontmatter with name, purpose, and status, canonical sections, and content that is novel, durable, specific, and actionable. Machine-parseable per-module documentation landing in the same week the agent surface gets typed access levels is context plumbing for models, whatever else it does for humans.

Why this is important. Access modes, a property-write permission gate, and per-conversation undo are the three things you need before you let a model touch a real project. Their arrival together is a schedule signal.

Who should care. Tools teams, anyone planning editor automation policy, and UEFN developers, who are already inside the enforcement path via 39628b49.

Urgency: Track.

Metal 4 lands as a complete second backend

What changed. 8a469fb3 adds an MTL4 backend alongside the existing Metal 3 path across 73 files. FMetalDevice gains bIsMetal4Device, set during feature enumeration for Apple7+ GPUs on macOS 26 or iOS 26 and newer, gated by rhi.Metal.EnableMetal4 and rhi.Metal.ForceMetal3 plus the -metal4rhi and -metal3rhi switches. A new IMetalCompiler interface splits into FMetal3Compiler and FMetal4Compiler. Encoding splits into FMetal3CommandEncoder and FMetal4CommandEncoder, both final non-virtual classes over a shared FMetalEncoderCommon. FMetalRHICommandContext becomes an abstract encoder-less base with TMetalRHICommandContext<TEnc> per encoder and if constexpr (TEnc::bIsMetal4) branching. The commit never states the cvar default, and it is not a pure addition either: MetalFence and the dead Intel-Mac paths are deleted outright.

The dependency shipped the same week under a title that gives away nothing. 51da534b reads “Metal RHI” with a five-word body, “Upgrading MSC for Metal 4,” and carries 110 files and 24,478 lines: 41 new headers, 34 of them MTL4*.hpp under Engine/Source/ThirdParty/MetalCPP, including MTL4CommandBuffer, MTL4Compiler, MTL4CommandQueue, MTL4AccelerationStructure, and MTL4ArgumentTable. The rest are edits to existing MetalCPP headers. Five more Metal RHI commits landed in the same window: bindless descriptor limits with loud failure on heap exhaustion (0b220fce), a Mac zero-sized viewport backbuffer assert (a87d34fb), an unavailable-drawable assert plus VSM render-target-array validation error (89c6c04b), and re-enabled concurrent dispatch (5211d317).

Mobile plumbing moved too. e7a4fd6d adds archive-based serialization of Vulkan structures with a Python generator (GenerateVulkanArchive.py) that reads the Vulkan registry, using one shared function for serialize and deserialize to guarantee identical ordering and identical feature structures for device creation in both the app and the service, so the Android PSO compilation service needs less hand-written support for each new extension, though the commit calls itself a first draft. 1a47b49f wires input-latency telemetry through VK_EXT_present_timing and VK_KHR_present_id with a VK_GOOGLE_display_timing fallback into the Android frame pacer, and enables PLATFORM_SUPPORTS_FLIP_TRACKING on Android and Linux. c0b5f55c forces discard to the very end of the GLES mobile base pass pixel shader to dodge Adreno’s “Bary after KILL” crash on a specific character material. 653c7c75 binds a depth-stencil sink in DrawTileMesh’s translucent path to fix a MetalRHI assert. On Apple platforms, ab401d17 moves LLM SetProgramSize() out of BaseAllocator(), which runs before GMalloc exists, into FApplePlatformMemory::Init(); c0167ef9 wraps MarketplaceKit Swift-task completion delegates so game-thread work does not crash; and 8ac39446 adds iOS GameMode via GCSupportsGameMode and LSSupportsGameMode plist values, enabled by default.

Why this is important. A second full RHI backend is a multi-release commitment, and the shape of 8a469fb3 (abstract base, templated context, compile-time branching) says Epic intends to keep both alive rather than migrate and delete. If you have Apple platform RHI modifications, you now have two paths to maintain.

Who should care. Apple platform teams and anyone with Metal RHI forks. Android teams should read e7a4fd6d and 1a47b49f.

Urgency: Act now for Apple platform engineers. Track otherwise.

Nanite and MegaLights get shaken out against real content

What changed. 10496625 adds DumpNaniteFingerprintCommandlet, which builds Nanite data for a UNaniteDisplacedMesh or UStaticMesh and dumps a deterministic text fingerprint (FResources CRCs, per-page CRCs, layout counts, bounds) for A/B comparison across changelists. It is filed under a Nanite non-determinism investigation (UE-381258). One purpose: make a suspected nondeterminism provable.

CLAS allocation got the same treatment. 044f751c makes AllocateClustersCS report allocation results on both success and failure, tracks the actual required blocks per installed page from CLAS build results, and puts the required CLAS buffer size in the on-screen warning. It also fixes the dispatch running one thread per cluster instead of one per page. 870d608c auto-raises MaxGeometryIndex and MaxUniqueGeometryCount from uploaded segment mappings and logs a cvar recommendation when the growth causes expensive invalidations. fbb53907 renames NumAssemblyParts to NumAssemblyTransforms and fixes an off-by-one in GetMaxEmittedClusters.

On the lighting side, f2050b2f force-enables cast shadows on first-person primitives because MegaLights needs the flag for screen traces to pick up weapon geometry, and the commit itself says “in the future we should fix it properly.” 7363fa81 adds per-FViewFamily overrides for sample count, guide-by-history, and reference passes for deterministic rendering, opt-in, and byte-identical to before when there is no override and a single view. 1959981c relaxes stochastic-upsampling normal weights so fewer Nanite foliage voxel pixels lose lighting on disocclusion, offsetting the cost with ALU and shared-memory tweaks (0.62ms to 0.59ms at 540p on one console, unchanged on another). 4ad3bfd7 fixes path tracer Substrate refractive slab handling, where IOR of 0 is now treated as IOR of 1, thin-slab transmittance was using mean free path instead of its inverse, and random-walk SSS is now reserved for the opaque case, plus a thin-surface transmittance visualization mode. c8203568 makes SkyAtmosphere LUT resources persistent instead of recreating them on every component modification.

Three more rendering changes are easy to skim past. 9389850e adds a Substrate Volumetric6AxisBSDF for translucent meshes that works with Lumen and the new material translator, across 19 files including three .ush and one .usf. f57449b7 is a 29-file refactor moving runtime reflection captures under the Ambient Lighting Volume component so they coexist with baked captures, fixing black, flickering, and missing captures. 54abee34 adds a Rendering Quality property (High, Medium, Low) on local lights with per-tier feature fade for mobile deferred (UE-380357).

Why this is important. CLAS allocation used to just fail. Now it prints the buffer size you needed, which turns a bug report into a config change.

Who should care. Anyone shipping Nanite at scale, MegaLights adopters, and mobile deferred teams.

Urgency: Track.

Epic is building a multi-process test harness inside the engine

What changed. 31 commits landed in seven days across the ModularTestFramework plugin, its Runner UI, its test plugins, and a new ModularTestHub program, and no single one of them looks like much. Together they are a pre-booted worker pool for networked end-to-end tests: warm slots that drain mid-transition between claims (1768b994), join-in-progress provisioning exempted from the per-test budget with stale connections drained before claim (3f3456c6), per-role wire-flag heartbeats so a wedged slot is visible during a wait rather than after it (97293749), config-driven extra arguments for spawned server workers (800140d8), and async loading thread enabled for server workers (d17619e2). Suites declare and are scheduled by environment (31bf0d6c, b2eeb1db). Test plugin .uplugin files stage into cooked builds with modules denied from Shipping (ae4f1dae). A standalone ModularTestHub program host appeared at Engine/Source/Programs/ModularTestHub/ (460d1d90). Live run status, phase events, and wait heartbeats landed as a 26-file change (d6b2364c), with a matching Runner UI (28162a47).

Note the failure-mode language running through it. e36e274c converts an 1800-second silent hang into a bounded reset-reaper failure that reports in roughly 240 seconds.

Why this is important. Multi-process client and server test harnesses are usually something a studio builds itself in an external automation layer. Epic is putting one in the engine, staged into cooked builds. If you have your own, it is worth knowing what the first-party version will cover before you invest another year in yours.

Who should care. Automation and QA infrastructure owners on networked titles.

Urgency: Track.

Networking, replication, and the one-off fixes that will bite specific teams

What changed. 89c9f3a6 makes Iris NetObjectFactory IDs independent of module load order. Factory registration is now ordered, core factories are pinned to IDs 0 through 2, and the rest are sorted alphabetically, with per-factory logging on the locked table. This matters specifically for anyone registering replication factories from GameFeature plugins, where client and server load order diverges. a0d09021 fixes an Iris client GC leak of replicated entity components on level unload. e825a46d fixes Game Feature plugin unmount not cancelling in-flight preloads, where the imported package survived GC via the loader refcount. b7548e9c adds a bEngineInitSafe gate with replay because external RPC route handlers could be serviced before FEngineLoop::Init returned.

Four other one-offs are worth naming. ee2a254a fixes Blueprint uber-graph persistent-frame object arrays being kept as hard references, which pinned a level actor and its World and tripped the world-GC-leak fatal on map teardown. It was a side effect of an earlier changelist that stamped all Blueprint object properties as CPF_TObjectPtr, rerouting the frame arrays to an FObjectPtr* collector overload nobody had overridden. 00616fbd moves Material Parameter Collections to persistent shared uniform buffers per ID rather than one per collection instance, fixing crashes when the same collection appears in multiple packages and one gets unloaded, leaving stale references in cached mesh draw commands. 62fa0c6b fixes cook not fully recording shadermap-to-asset info for sibling MICs sharing a configuration, which manifests at runtime as “LibraryInstance is null” when a shaderlib unload takes out a leaf shadermap still in use: a cook-time attribution bug with a runtime-only symptom, which console teams tend to find late. 1504a004 fixes D3D12 reserved-resource LLM tracking to apply the right scope marker on the submission thread and keep reserved buffers on their owner tag instead of RHIMisc and BufferPool, which will change your numbers if you have been chasing unattributed D3D12 memory.

On Control Rig, c47055e4 changes override owner-structs to load via version-gated dynamic imports instead of a StaticLoadObject workaround that deadlocked the cook, and adds a re-entrancy guard on RecompileModularRig fixing random heap corruption from nested recompiles. It was re-landed after a backout. 7b641d6c fixes ImportBones(USkeletalMesh*) indexing the skeleton-to-mesh lookup table with mesh bone indices, broken for several releases but unreachable until a changelist last week started calling it, “which is why the crash does not reproduce in 5.8.”

Several concurrency fixes landed quietly, none of them phrased in a way that would catch your eye on a skim: two TSan races in TraceLog block pool acquire and release ordering and in PThread priority initialization racing the child thread (f9dda313), an ASAN fix in CExprTupleElement (469f88a2), a Niagara ASAN type registry slot rewrite (ca04b423), Verse race arms continuing to run after the race resolved and registering awaiters nothing cancelled, so a later signal resumed a continuation reading an unset result slot (c1fb5194), and a DerivedDataCache pak writer shutdown race (6569c1fe, UE-388315).

Two more with content impact: d65fcac0 fixes an HLOD hash that was order-dependent and dropped caller-accumulated settings, so HLOD setting changes did not trigger rebuilds. Existing HLODs rebuild once (UE-388016). 564735b8 excludes UE_SERVER from UE_ENABLE_DEBUG_DRAWING, so DebugDraw no longer links Renderer into servers (UE-385930). And a63961db fixes ConcertSyncCore.Build.cs adding SQLiteCore unconditionally against its own uplugin deny-list, silently linking it into game clients.

Why this is important. These are the fixes that will not show up in a release-notes skim but will match a bug you already have open.

Who should care. Iris and GameFeature users (act now if you use both together), console teams, and anyone tracking D3D12 memory attribution.

Urgency: Act now for Iris plus GameFeature plugin users. Track the rest.

Horde, test infrastructure, and the ProceduralVegetation plugin

What changed. 91b81d1a stops an issue spanning multiple streams from being marked fix-failed in a stream that has since had a successful run, along with the misleading Slack “Not fixed by” messages that followed. The author is explicit that this is a workaround, not a root-cause fix: doing it properly would mean parsing changelist descriptions for RoboMerge tags or querying RoboMerge directly. 606aa83b publishes TestData to a telemetry sink. Outside Horde proper, a4f79d61 adds building low-level tests for a given module set through UnrealBuildTool. and b8300dbb restricts cloud artifact publish and retrieve in the Foundation Cooker test graph to build machines, fixing a race in the Gauntlet incremental cook test.

The experimental ProceduralVegetation plugin shipped four crash-fix commits and a 255-file preset library in one week. ce587b30 fixes Nanite foliage meshes crashing packaged builds because cooked builds strip the CPU index buffers unless bAllowCPUAccess is set, while GetNumIndices() still returns the cached count, a regression from 5.7.4. 5084a78e fixes an open URange bound asserting during UV generation. 43b603b7 and fa747ac4 add two more. 8352feda adds 255 growth presets converted by script and explicitly notes they are not yet QA’d.

Why this is important. A fix-failed flag that was wrong, plus Slack notifications amplifying the wrong state. If your team has learned to distrust Horde’s fix-failed signal, this is why.

Who should care. Build automation owners running Horde, and anyone maintaining low-level or Gauntlet test graphs. ProceduralVegetation is experimental, and the preset library is explicitly unvalidated, so treat it accordingly.

Urgency: Track.

The 5.x Stabilization Sidebar

ue5-main ran 254 commits, 242 of them worth reading after the routine churn comes out, and nearly 50 mention a crash, assert, out-of-bounds, use-after-free, deadlock, or heap corruption. 152 carry an internal #Synced-CL integration tag and 26 explicitly say cherry-pick, so the branch is absorbing fixes from elsewhere far more than it is originating its own work. Commit counts by subsystem understate where the week actually went. Measured by file touches, the week is Control Rig (roughly 370), the experimental UAF plugin (roughly 300), RigVM (over 100), and RoboMerge (85). Two changes landed, were backed out, and re-landed inside the same week (UE-381080 and the RigVM serialization sort), which matters if you sync ue5-main tip. Seven of 242 commits resolve only to Commit.gitdeps.xml.

One caution on sourcing: no commit message on this branch names ue6-main as a source, so we are not calling any of this a backport. The only literal cross-branch statements are 3d3ff86f (“Bink: Back merge from Main”), the 26 cherry-pick tags, and 1e16ebbe, whose message reads “Avoid usage of UE6 function in cherry picked CL.”

The cook and derived-data layer got audited, and it was worse than it looked

What changed. acf33841 is the headline. Cook IncrementalValidate was flagging roughly 800 ControlRig and RigVM packages on every single run, because a 4-byte FRigVMCallableInfo::FunctionHash in serialized rig bytecode differed between the on-disk artifact and a fresh save, and freshly-healed values got re-flagged with new values on the next run. Three cooperating defects sit underneath it, one of which is async load-order dependence deciding, per package and per run, whether the cooked bytecode embeds persisted data or data recompiled in-session. Around it: 441240aa fixes a rig asset minting a random GUID every cook instead of a deterministic one. 06929408 and 145e603a fix map serialization in raw TMap iteration order, which made byte-identical functions serialize differently across cook processes (1c30e76b is the backout of the first attempt). 2c214150 fixes cooks failing outright with “Compilation data for public function has no instructions.” 1cd565db fixes ComputeHLODHash both dropping settings and being source-component-order dependent, so HLOD setting changes were silently not triggering a rebuild. Existing HLODs rebuild once. d94abc9d fixes a shutdown race in the derived-data pak file cache writer.

Why this is important. If you have been living with incremental cooks that never feel incremental on a Control Rig heavy project, this is a plausible explanation with a fix attached. It also means your incremental cook validation results before this change were not telling you anything real.

Who should care. Anyone shipping on 5.8 with Control Rig or RigVM content, and anyone who owns cook determinism.

Urgency: Act now.

Crashes that only happen in packaged or runtime builds

What changed. 47105f70 fixes ProceduralVegetationEditor-generated static and skeletal meshes crashing the packaged game on asset load in 5.8 when Nanite Foliage is enabled, explicitly a regression from 5.7.4, caused by reading CPU index buffers that cooked Nanite builds strip unless bAllowCPUAccess is set. It renders fine in the editor, which is why it survived. cc080b6f changes the default memory-mapped bulk data alignment from 1 to 16, because animations are memory-mapped on mobile and alignment of 1 violated the ACL anim sequence codec’s requirement, asserting at decompress time in Debug and Development builds. It touches BaseAndroidEngine.ini, BaseIOSEngine.ini, and SavePackage2.cpp, so it changes cooked layout and adds padding. d4b38151 adds a 2GB estimate-based limit to stop ray tracing acceleration structure builds for groom assets too large for scratch memory. c995dddf prevents a runtime crash transitioning into a linked StateTree asset that was recompiled with different parameters after the parent tree compiled. e742b0e0 null-guards landscape grass data deserialized from packages saved before the LandscapeGrassSingleArray format change. 5473a63e guards GPU crash diagnostic dumps against an invalid diagnostic buffer, so a device-removed event stops replacing your real crash report with a fault inside the crash reporter. That one is speculative with no repro in hand, and the commit says so.

Why this is important. Every item here is a defect that passes in the editor and fails in a packaged build, which is the worst place on the calendar to find one.

Who should care. Anyone in cert or approaching it on 5.8. Cherry-pick selectively based on what you actually use, and note that cc080b6f changes cooked layout, so it is not a free pick.

Urgency: Act now, selectively.

A systematic editor crash sweep, mostly Sequencer and the property editor

What changed. A run of near-adjacent Jira tickets (UE-388963, 388964, 388968, 388969, 388971) from two authors over two days, with one pattern throughout: a pointer guaranteed non-null in the common case and not in a Sequencer context. 783795fc (bound objects with no level), 517d4b0f (a track with no registered track editor turning a handled ensure into a hard crash), 966c3146 (a group actor converted to a spawnable, therefore no ULevel outer), 6ac89a27 (animation with no skeleton), e435b5a2 (a locator whose property data went away mid-frame). 8e2c4fa9 is the most structurally interesting: a property change listener held its owner as a raw UObject*, so every cache built for an actor’s components dangled the moment a Blueprint recompile reinstanced them. It is now a TWeakObjectPtr. On Mac, 6075bcee, 3e629390, and 23b2dc0d fix Metal RHI asserts and a129e6f9 raises the bindless descriptor limit. 346641ec fixes buffer stomps and length underflows in the shader preprocessor’s macro argument handling, including an int against size_t mismatch that turned a bad length into a near-SIZE_MAX allocation. That mirrors 0c116a4d on ue6-main.

Why this is important. These are cheap, low-risk picks for a team spending editor time in Sequencer.

Who should care. Cinematics teams and Mac-based editor users.

Urgency: Track.

Control Rig is still getting new features on this branch

What changed. a11fab2a is a 104-file commit introducing an entirely new constraints editing interface in the animation editor mode, gated behind the ControlRig.UseNewConstraintsWidget cvar with the old interface left unmodified as a fallback. Roughly a dozen follow-up commits landed the same week polishing it (70eafe2a, da94cded, f422f8a3, 550013e5), and a parallel rework hit the modular rig editor (d71114f9, 7a81b7b4). The UAF plugin accounts for 43 commits and 298 file touches, including Verse exposure (4329276e) and asset registry data versioning (b60200d8).

Why this is important. Plan around this one. A branch described as post-5.8 maintenance is still receiving a cvar-gated interface replacement and active experimental-plugin development. If your integration policy assumes ue5-main tip equals 5.8 plus safe fixes, that assumption is wrong this week.

Who should care. Anyone with a standing policy of syncing ue5-main tip, and animation teams evaluating the new constraints widget.

Urgency: Track.

Worth Tracking

Frame pacing driven by task-graph timing, gated off by default. 9599726e pulls from GRHIFrameTimingQueue inside UEngine::UpdateTimeAndHandleMaxTickRate to derive a next-frame work forecast and a target deadline (the next vblank flip), then throttles the game thread through the same path t.MaxFPS uses, and adds a “Slack” field in stat unit. c5bfef96 removes FFrameResult and FRHIFrameTiming, computes work and slack directly on the result node, hands the final node reference back to the game thread, and adds a “continuation” flag on prerequisite links explicitly reserved for separating pipeline stages on the critical path later. d31cd58c adds a DynamicRHI hook for reporting input sample time to platform APIs. The whole game-thread path sits behind UE_TASK_TIMING_ENABLE, disabled by default, and requires platform RHI support (UE-306070). Two of the five commits are build fixes for the enabled case (c1b64712, 1a28752c), which means somebody is compiling it regularly. Worth tracking if you own frame pacing or input latency.

The new material translator is in legacy-parity cleanup, which means it is being run against production content. Six commits landed in Engine/Source/Runtime/Engine/Private/Materials/MIR/ and surrounding translator files, all about matching what the legacy translator already does: static switches with disconnected inputs (18014ab9), pixel depth offset (580cbccc), terminating the analytic derivative chain at values with no closed-form derivative (29969f64), collapsing shading models on platforms without per-pixel shading model support (022d7a3e), gating SubsurfaceColor and Refraction on platform-filtered shading models (a684c16d), and Preshader statistics plus op byte count in the material editor, which needed separate stat-gathering code because the new translator uses Preshader2 (bf3822cf). 022d7a3e is the one to read: MIR was keeping every shading model the graph reached, which activated extra shading code in the base pass, kept the feeding textures alive, and pushed some character materials past the 16-sampler limit on Android. Parity bugs at that level of specificity do not come from synthetic test content. The commit stream calls it both “New material translator” and “[MIR]”, and the acronym is never expanded anywhere in the data, so we are not expanding it either.

Convergent scaling work landed across the entity and transactional layers in the same week. 2545a03b replaces EntityFramework’s FExecutionManager full Tarjan rebuild on every register and unregister with incremental insert and remove, then got backed out later the same day (315c94f8). ff707682 adds optional incremental processing-graph invalidation, where previously every new archetype invalidated all graphs. 205e435c replaces processing-queue contention with a lock-free per-chunk 64-bit color mask. 58bec238 makes Mass IsProcessing() reliable across the async pipeline, where on the legacy parallel path (mass.UseProcessingQueue=false) the counter transiently read false between dependent tasks, so callers were picking direct mutation over the command buffer. It was backed out the next day (7845eb56) with no reland inside the week. On the transactional side, f026373a drops a redundant hit-set merge in AutoRTFM nested commit, removing roughly 44 million redundant hash insertions in a single raytracing benchmark run and taking FTransaction::CommitNested from 11.3 percent to 0.6 percent of samples, for 1.05x to 2.06x on named benchmarks. 59a6763d skips AutoRTFM bytecode for single-target client cooks in the Verse compiler, cutting UVerseFunction memory on clients by about 45 percent. And 47f88b39 splits UE_WITH_DSTM and introduces UE_WITH_TRANSACTIONAL_EXECUTION, re-gating ticks, timers, latent actions, RPCs, the control channel, level streaming volumes, async collision, and physics event dispatch across 27 files in Core, CoreUObject, Engine, Chaos, and Iris. That last one changes what a transactionalized build means, so read it before you assume your build configuration is unchanged.

Also on the radar, at lower confidence: Subsonic shipped 12 commits into Engine/Plugins/Experimental/Subsonic/, building out an event, action, and executor audio model with parameter stores, a custom K2 node for setting executor parameters (cbec3c89), custom source parameter authoring (b1f03a14), collection parameter overrides with a type allow-list (198fc0a7), and editor-tab clipboard shortcuts. That volume of editor polish suggests it is past prototype. The Gaussian Splat plugin split out of Niagara into a standalone Engine/Plugins/GaussianSplat/ (7f267510, 39c0feb2), exposed bUseQuantizedFormat (167e4661), and added import and allocation error handling (6b109377). And 7c096c84 is a 92-file, 5,372-line commit exposing UAF systems to Verse and running skeletal_animations as UAF systems, so a uaf_system can now be played as a skeletal_animation from Verse and each skeletal_animation runs as its own system rather than a composited UUAFAnimGraph. It restructures Engine/Plugins/EntityFramework/Source/EntityModifiers/ along the way, deleting IEntityModifierInterface.h and adding IEntityModifierImplInterface.h, with reflection gated behind Verse.EnableVerseUAFSystemClassReflection.

What We Ignored

47 commits on ue6-main were pure noise: content syncs, autogenerated data, and mechanical churn with no reader value. Beyond that, we set aside RoboMerge’s submit-approval work, which ran 19 commits in Engine/Extras/RoboMerge/v3 including a 39-file restructure of changelist filters supporting approval as well as userlist and usertag filter types (f4f95626), an all-or-nothing filter (674e4413), and user tag caching (2373c52b). It is real work, but it is Epic’s internal integration tooling and it does not change anything on your machine. We also set aside the week’s churn of 13 backouts and 13 relands, several of them pairs within days: interesting as a signal about branch churn, not actionable individually. Two other items are worth naming as deliberate omissions rather than oversights. 22 of the 165 commits we read closely resolve to nothing but Commit.gitdeps.xml, and the entire Python editor-toolset and AI-agent workstream lands that way, so much of that section is read from commit messages rather than code. And af12b293 renames “Timing Profiler” to “Timing Insights” and adds a Profile section to the Tools menu, which will confuse exactly one person on your team for exactly one afternoon.

Closing

What matters in a stabilization week is which kind of fixes land, not how many. Epic spent an unusual amount of effort this week on making broken things say so: a crash reporter that survives its own crash, a commandlet whose only output is a fingerprint, an allocator that reports the size it actually needed, a hang converted into a timeout. The PixelStreaming2 origin filter is the argument for why that work matters. One file, no symptom, an allowlist left unenforced on a network-facing server. Nobody was ever going to file a bug against it, because it never said a word.

Commit SHAs are cited inline, in parentheses, next to each claim. They reference the ue6-main branch of EpicGames/UnrealEngine except in the 5.x sidebar, where they reference ue5-main. Some of the most interesting entries resolve only to Commit.gitdeps.xml binary-manifest blobs: the commit message is real, but the code lives in Epic’s internal binaries, which we cannot see.

Week of July 20 - 26, 2026 | 960 commits on ue6-main, 217 on ue5-main | Branch: ue6-main

Overview

The busiest week since mid-May, and most of it is repair work. Close to 40% of the week’s notable commits are crash, use-after-free, hang, or assert fixes, the mix you get when a branch is being driven toward a release. The rest concentrates in two places: the renderer, where FScene is being taken apart into scene extensions on what is now clearly a scheduled architectural project, and build infrastructure, where UBA and the EpicClang toolchain absorbed a week of correctness work with the tone of an incident review. One incidental commit makes the framing official: Engine/Build/Build.version had its branch name updated to UE6 (e4af2492).

Development Trends

The weeks of June 29 and July 6 (75 and 64 commits) are Epic’s summer shutdown, not a decline. Week counts below refer to full-volume weeks.

FScene decomposition has become a scheduled UE6 project, and this week it broke API. The scene-extension refactor has escalated at each of its three full-volume appearances: scaffolding in early June, four extractions on July 19, and five more in one coordinated push this week, with rendering activity hitting its highest count since the branch switched to ue6-main in June (66, against a June and July range of 31 to 53). The API break is the new part. FPrimitiveSceneProxy’s level-added and level-removed render-thread hooks left ENGINE_API entirely (97e8f671). Behavior-neutral refactors do not usually take public API with them, which puts a schedule behind this one. The consistent thread across all three weeks is persistent-primitive-ID indexing and change-set-driven lifecycle.

Build and toolchain work shifted from modernization to correctness under failure. Build has been the longest-running thread since early February, and for two weeks straight it has been the busiest area on the branch. The content changed sharply between the two. July 19 was structural modernization: C++23 as the default standard, the circular-dependency allowlist deleted, UnrealBuildTool moved onto modern .NET. This week is the response to a failure, and the failure was correctness. A cache keyed on a version string instead of on the compiler binary was silently reusing stale PCHs (2699d884). Two quarters of build investment produced a system fast and distributed enough that its bugs now hand you wrong binaries, and Epic is responding by making the whole path fail closed. Banning Clang 21.0.0 through 22.1.3 outright (56b0b3e9) is the version-pin equivalent of the same reflex.

Artifact reproducibility is emerging as a named UE6 shipping requirement. Determinism fixes have surfaced individually for roughly eight weeks, but this is the first week they arrive as a coherent campaign: twelve commits that exist solely to stop cooked packages from serializing differently between runs of the same cook, ten of them from a single author, five citing the same internal validation tool, with one fix already backed out (391a9237). Read alongside the UBA cache-key and EpicClang work, this is one problem rather than two: distributed build and cook infrastructure only pays off if identical inputs reliably produce identical bytes, and Epic is closing both ends of that contract in the same week. A parallel wall-clock pass from a second author (053e3401, 464f299c) says the cook has an owner this quarter.

The editor agent stack is hardening, and starting to leave the editor. This initiative has been visible for roughly twenty weeks, and the phases line up cleanly: infrastructure buildout in March, toolset proliferation and a first-party MCP server through June, a crash-hardening audit on July 19, and now transactional safety and access control. Two details matter more than the volume: the agent undo manager could not stay landed for four days running, and the new audit verbs exist specifically to repair graph corruption left by previously failed agent writes (afef1d65). Separately, a cluster under a single ticket started moving the toolset and MCP surface out of the editor and into cooked runtime builds, which turns an authoring question into an operational one. Details in Worth Tracking below. The hardening arc is well established; the cooked-runtime direction is one week old and worth confirming before drawing conclusions.

TL;DR

• If you self-host a UBA cache server, read the cache section first. A production server wild-wrote up to 512 MB past a maintenance block during compaction, and corrupted entries could turn cache misses into false hits. The bounds-checking and fail-closed fixes are worth pulling regardless of your engine version (92d13a09, d0348830).
• EpicClang now generates a build ID from its own source hash and feeds it into the UBA cache key (2699d884). Before this, a compiler update that changed PCH binary format was invisible to the cache key, so stale intermediates were silently reused. The commit describes the result as compiler crashes and completely UB builds. Clang 21.0.0 through 22.1.3 are now banned outright (56b0b3e9).
• FScene decomposition accelerated into a five-subsystem push, and it broke public API. FPrimitiveSceneProxy::OnLevelAddedToWorld_RenderThread and OnLevelRemovedFromWorld_RenderThread left ENGINE_API entirely (97e8f671). Anyone overriding those hooks breaks at compile time.
• Epic is treating byte-reproducible cook output as a UE6 shipping requirement. Ten determinism fixes landed this week from one author working a backlog, plus two more from other authors, alongside a separate wall-clock pass that removed roughly 21% of a 25-minute game cook in a single commit (053e3401).

Highlights

FScene is being dismantled into scene extensions, and this one breaks API

What changed

Five separate subsystems were lifted out of FScene into dedicated scene extensions in a single coordinated push, mostly by one author. HLOD hierarchy (FLODSceneTree) moved out of FScene and out of SceneVisibility into FLODHierarchySceneExtension (86fab2e2). Lighting attachment groups moved into FLightingAttachmentGroupSceneExtension, with group membership now stored as persistent primitive IDs (34dcf40b). Nanite’s shading commands, raster pipelines, shading pipelines, visibility, and their per-FPrimitiveSceneInfo bin state all moved into Nanite::FMaterialsSceneExtension, touching 26 files across the deferred renderer, Lumen, and virtual shadow maps (ead01072). Ray tracing data started the same migration into FRayTracingSceneExtension (2142af0d).

Underneath it, SceneData grew a TDataArray<bool> bit-per-ID specialization that dirties only on value change, editor primitive selection was rewritten from a packed-index TBitArray on FScene into FEditorSceneDataExtension (c50ee288), and bPendingAddToScene became a dirty array in the same pattern (b68b7b6f).

The API break is in the level command work. When level handling became FLevelCommandSceneExtension, FPrimitiveSceneProxy::OnLevelAddedToWorld_RenderThread and OnLevelRemovedFromWorld_RenderThread were removed from ENGINE_API entirely, with the extension calling SetForceHidden through friend access and an in-commit TODO to replace that with SceneData-tracked visibility (97e8f671).

Why this is important

The recurring pattern in these commit messages is persistent-primitive-ID indexing and change-set-driven lifecycle. You need both before scene updates can be parallelized or driven end to end on the GPU. This has been running for weeks as steady cleanup; at five subsystems in one push it is a scheduled UE6 project. A public API removal inside a refactor described as behavior-neutral is unusual and worth noting on its own.

Who should care

Rendering engineers, anyone maintaining a modified Renderer module, and anyone with a custom FPrimitiveSceneProxy.

Urgency

Act now if you carry renderer patches. This is the week your merge cost went up, and the ENGINE_API removal is a compile-time break, not a silent behavior change. Track otherwise.

Production failures forced a UBA cache server rewrite

What changed

A production cache server SIGBUS’d during bucket compaction, a Mac client SEGV’d fetching entries, clients spun forever on entries the server could never serve, and large caches took ten-plus minutes to boot. The response was structural rather than a patch.

Maintenance moved from a global stop-the-world pass that kicked clients to per-bucket, event-driven work, triggered on a bucket hitting zero clients with new entries, on expiration, on caskey table overflow, or on web request. Cas liveness is now tracked by two refcounts (in-flight transfers and cache entry references), CacheEntry::inputCasRefs replaces inputsThatAreOutputs, and the database moves to v10 with v9 conversion on load (fc5ca41d). A follow-up made the delete pass run without taking the bucket exclusively, using the same per-cache-key locks as fetch and store, so long-lived client sessions no longer starve maintenance (68497718).

The corruption work is the sharp end. Entries whose caskey and path offsets landed mid-entry passed a range-only scrub and resolved garbage, and compaction traversal then did a wild write up to 512 MB past the maintenance block. CompactPathTable::GetString and CompactCasKeyTable::GetKey are now fully bounds-checked, with an explicitly fail-closed policy (92d13a09). A separate pass added a per-boot offset scrub, disconnected clients requesting table data past the table end, and made FetchCompactTable fail as a miss rather than retry forever (d0348830). Boot time for caches with millions of entries was fixed by dropping the v9-to-v10 input ref synthesis that hit casdb for every input of every entry, and moving refcount rebuild into a parallel post-deserialize pass (01d879de). Separately, memfd handles are now tagged in the handle itself rather than trusted from a process-wide env var, so a stale UBA_FILE_MAPPING_MEMFD=1 baked into a Docker image no longer masks the real error as EBADF (74d41354).

Why this is important

The fail-closed policy is the line to read twice: corruption that shrinks an entry’s input set turns cache misses into false hits. It shows up as a flaky product, not as a cache error. Everything else here is availability and boot time, which matter, but the corruption hardening is the part that can hand you a wrong binary.

Who should care

Build engineers, studio infrastructure, and anyone running distributed UE compilation at scale.

Urgency

Act now if you self-host a UBA cache server. The corruption commits are cherry-pick candidates independent of your engine version.

EpicClang stops being a vendored binary and becomes a versioned toolchain

What changed

A compiler update changed the binary format of PCH files, but UBT and UBA keyed their cache on the LLVM version string rather than the compiler binary, so stale intermediates from an older EpicClang were silently reused. The commit describes the result as compiler crashes and “completely UB builds.”

EpicClang now generates a build ID from the hash of all source layered on top of Clang, errors if you use a PCH built by a different source version, and feeds that build ID into the UBA cache key (2699d884). The day before that fix landed, the mitigation was bumping the patch version to try to invalidate the cache (bfd51aae). Clang 21.0.0 through 22.1.3 are now banned outright in MicrosoftPlatformSDK.cs and Windows_SDK.json due to a compiler crash (56b0b3e9).

The toolchain also got real tooling around it: build.go split into packages with a new symbolize tool that resolves non-symbolized Clang crash stacks, since Epic does not commit the debug symbols, plus a BuildGraph pipeline to acquire, build, test, deploy, codesign, and submit toolchain binaries (31a3b9f0, b3e6cb9a). A MergeClangProfData BuildGraph task now resolves llvm-profdata through the same Windows toolchain search used for compilation, which matters because raw PGO profiles must be merged by a tool matching the linked compiler-rt runtime (a2fa541a). Related for anyone on LTO or PGO with merged-module targets: the LLVM IR object parser unconditionally skipped linkonce_odr globals so they could never become export candidates, breaking dllimported template static data members from Verse interop codegen (77366fe1).

Why this is important

Keying a shared build cache on a version string rather than on the compiler binary is a class of bug that any studio with a shared cache should audit for in its own toolchain wrappers. The version-pin ban is the immediate action item; the build ID is the structural fix.

Who should care

Build engineers, anyone using UBA caching with a custom or updated Clang, and anyone doing PGO on Windows.

Urgency

Act now. Check your toolchain pinning before your next Clang update.

Two authors are making the cook byte-reproducible and materially faster, in parallel

What changed

Twelve commits exist this week for one reason: to stop cooked packages from serializing differently between runs of the same cook. Five of them cite the same tool, Cook IncrementalValidate, which double-saves and diffs the on-disk artifact against a fresh save. The failures are the classic non-determinism set. Raw TMap iteration order leaked into serialized bytes for RigVM function compilation data (704306bd, backed out, resubmitted as f55e2715) and into the Niagara compile hash, where NestedPropertiesAppendCompileHash hashed values in map order while sorting only the key labels and then mis-paired the two (46be1f8d). RigVM asset variants with no valid FRigVMVariant::Guid minted random GUIDs on load, now fixed by passing the package path so GenerateGUID uses FGuid::NewDeterministicGuid (4debd224). MakeUniqueObjectName’s process-global per-class counter leaked into cooked PCG GPU compute-graph export tables under multiprocess cooking (859468f6). FTextHistory_Base re-keyed text with FGuid::NewGuid() whenever a duplication archive assigned a package localization namespace during cook, randomizing cooked text keys and breaking the localization pipeline’s key match (b9892d57).

The races are more interesting than the ordering bugs. Landscape Nanite meshes created their UBodySetup in the async build’s completion callback rather than at mesh creation, so a package serialized differently depending on whether it was saved before or after that callback ran (e9337bd6). USplineComponent::GetUsedMaterials ignored bGetDebugMaterials and reported editor debug visualization materials unconditionally, so PreSave’s bHasNoStreamableTextures computation flipped depending on whether those async-loaded debug materials had finished loading, which under unversioned property serialization inserted or removed a one-byte payload and shifted every subsequent byte of the export (5974c3af). Material instance cooking ran unused-parameter cleanup against the parent, which is not guaranteed to be cooked first (a9a6a2d3), and the material translator emitted two byte-different but semantically identical HLSL variants under the same MaterialTranslation cache key (5b1bf314). The heaviest is the ControlRig/RigVM fix (dfee7c15), which documents roughly 800 packages flagged on every validation run, traces it to three cooperating defects including a load-order race over whether a consumer embeds persisted or in-session-recompiled function bytecode, and forces RigVMCompiler to always recompile referenced graph functions during cook at a measured ~3% of cook tick time. Cooker DiffOnly diagnostics now also report BulkDataMap differences in the package header (19d769b3). The campaign is still churning: one RigVM determinism fix was backed out (391a9237).

Running alongside it, a different author spent the week on cook wall clock. FLocalizationCookArtifact::StoreDataInOplog recursively scanned the entire project directory twice for *.locres and *.locmeta at cook shutdown, costing 319 seconds of a 25-minute game cook, now fixed by scanning only registered localization paths (053e3401). UChunkDependencyInfo::BuildChunkDependencyGraph was 64 seconds of a full cook and rebuilt whenever the highest seen chunk id grew, and was rewritten to produce an identical tree (464f299c). Shader DDC keys are now built as UTF-8 end to end with byte-identical output, so existing entries stay valid (f70b8ddb); material shader-map DDC key validation, about 30 seconds of a single-process cook in the DDC-load poll path, moved to a worker task joined in FShaderCompilingManager::FinishAllCompilation (28c6fb99); and ConvertToUTF8 gained an ASCII-run fast path (f77dc4d9). The determinism author contributed one wall-clock fix of their own: the deterministic static mesh lighting GUID moved off the game thread, where recomputing it forced a synchronous wait on the async build and hung the editor during interactive edits (e8c849ac). On the build side, UAT script module rebuilds went from a ~40 second all-modules storm on any shared .cs timestamp change to a content-hash-validated, reference-assembly-gated path, taking a full rebuild from ~17s to ~10s (d22404fe).

Why this is important

Every one of the determinism bugs silently poisons incremental cooking and shared-DDC reuse. A package that serializes differently on each run defeats hash-based artifact caching, so a CI system doing incremental cooks re-uploads and re-stages content that did not change, and content-addressed hit rates degrade in a way that looks like infrastructure flakiness rather than an engine bug. The volume suggests Epic is working a backlog, not chasing one-offs, which is the strongest available signal that byte-reproducible cook output is a UE6 shipping requirement. The wall-clock work is the same story from the other direction, and both authors are measuring in seconds of real cook time rather than microbenchmarks.

Who should care

Anyone running incremental cooks on CI, anyone operating a shared DDC, and studios with rig-heavy or PCG-heavy content.

Urgency

Track, and act now if your incremental cook hit rates have been unexplainably low. dfee7c15 bumps ERigVMCookVersion, so cooked rig packages rebuild once on upgrade.

A TLSF GPU sub-allocator lands, wired into half the renderer, shipped switched off

What changed

Epic added an O(1) two-level segregated fit allocator for GPU memory ranges the CPU cannot address, complete with a defrag planner, a GPU-side compute copy pass, a validation layer, and a test suite. FGpuTlsfAllocator lives in RHI with all block metadata in a CPU-side slot pool, so GPU memory is never touched; allocations are opaque handles that survive pool growth and defrag relocation. BuildDefragPlan does true left-compaction behind a write cursor and is capped at 4 GiB per pool because the copy shader addresses bytes with 32-bit offsets. The companion GpuTlsfCopyPass and GpuTlsfCopy.usf execute batched transfers, running overlapping compaction ops as a single group-cooperative forward copy (8db4a063).

Close to twenty existing FSpanAllocator allocators were then converted: GPUScene instance scene data, instance payload, and lightmap allocators, plus the Nanite material and editor hit-proxy buffers, behind GPUSCENE_USE_TLSF_ALLOCATOR and NANITE_MATERIALS_USE_TLSF_ALLOCATOR (68c85fee); skinning bone and transform buffers with the anim-sequence and anim-bank transform providers (9fe7f2f6); and curve skinning rest/deformed allocators plus the SceneCulling cell-chunk-id allocator (bd67821a). Every conversion is behind a compile define defaulting to 0, and the GPUScene defrag is behind r.GPUScene.Defrag.* CVars defaulting to off. Stats overlay registration was generalized to a getter-based seam so both allocator types report into SpanAllocator.Stats.*.

Why this is important

Nothing changes this week. The defrag is the part to understand now: when enabled, it selects the highest-offset persistent primitives each step and injects force-reallocate updates into the live scene update queue, with SceneCulling and Lumen reconciling through the normal FScene::Update path. Nothing else in the engine slides live GPUScene instances toward lower offsets while the scene is updating. Worth knowing before the flip, not after.

Who should care

Rendering engineers on large open worlds, and anyone who has hit GPUScene fragmentation or span-allocator high-water growth.

Urgency

Track. Infrastructure staged for a later flip, not a change you will see today.

The editor’s AI agent stack is being hardened against its own tool calls

What changed

The work in AIAssistant and ToolsetRegistry this week is almost entirely defensive: undo semantics, input validation, and non-destructive graph edits. FAgentUndoManager gives per-conversation undo for agent tool calls, with a per-agent mode that is explicitly not a stack unwind. Each tool call runs in a capture window with a dedicated transaction buffer swapped over GEditor->Trans, teeing pre-state into a reinstancing-safe record store that rollback replays, because flip-applying engine records can crash on reinstanced objects. It also guards objects the user hand-edited after the agent so rollback does not clobber them (75271521). It was backed out (9162cdf4), re-landed with fixes for divergence between the source stream and Main (3fe14476), and backed out again the same day (0679850b).

Enum properties in ToolsetRegistry had no registered JSON converter, so they fell through to FJsonObjectConverter’s numeric import path, which writes an out-of-range integer to the enum with no range check. An agent passing {"shareType": 7} could drive a tool’s enum switch into a checkNoEntry() path and take down the editor. FToolsetEnumConverter now validates plain enums (range, fractional, int64 overflow, _MAX sentinel, unknown name) and bitmask enums as bitfields (16acb955). write_graph_dsl moved from full-replace to diff-based editing: it re-decompiles the graph, diffs incoming DSL statement by statement, and leaves unchanged statements’ nodes completely untouched including positions, wires, reroute knots, and node ids. It also adds audit verbs (find_disconnected_nodes, find_duplicate_entry_nodes, find_duplicate_graphs) specifically to clean up graph corruption left by previously failed writes (afef1d65). Around the edges: an access-control model with read, write, and execute modes for toolset tools (88cd8fd5), a cross-conversation tool-response contamination fix (8dae6628), a guard against async tool-call completion during exit-time UObject purge (4808a910), and new toolsets for undo history (f87e5a6f), TextureGraph (c2807012), and GeometryTools (03b0e722).

Why this is important

The engineering problem here is reversibility: making it safe for an agent to touch a live editor session and undo what it did. The audit verbs are the most honest detail in the cluster, because Epic is shipping tools to repair graph corruption its own agent left behind. And the undo manager shipping, being backed out, re-landing, and being backed out again inside four days tells you how invasive swapping the editor’s transaction buffer actually is.

Who should care

Tools engineers, technical directors evaluating in-editor agent workflows, and anyone building on ToolsetRegistry.

Urgency

Track. The undo path is not settled, so do not build against it yet.

The actor is becoming optional

What changed

Three separate teams spent the week removing AActor and UActorComponent assumptions from systems that had them baked in. Mover lost its dependency on an actor component in the state machine (71e7bcbf), had MovementMixer converted from an owned UObject-ish thing into a regular C++ class owned by the state machine explicitly to decouple Mover core simulation from the actor framework (4dd1628b), and gained operational mode options so an external system can drive a Mover object and suppress simulation conflict, with attached movement and locally-driven seamless cinematics as the stated use cases (96da392a). ChaosMover picked this up on the physics side: the backend can now take a TScriptInterface<IPhysicsBodyInstanceOwnerResolver> instead of relying on the MoverComponent’s UpdatedComponent, and UNetworkPhysicsComponent::GetController() now walks the owner chain rather than assuming direct ownership by a Controller or Pawn (3cfc7605).

The editor side moved in lockstep. Editor modes can now allow or disallow non-actor selections, with the actor-only IsSelectionAllowed deprecated and unconverted modes defaulting to permitting non-actors behind Editor.ModesAllowNonActorSelectionByDefault (e3d55a9a). IActorPickerMode and FEdModeActorPicker were extended to use HHitProxy::GetElementHandle() so entities, which use HEntityComponentHitProxy instead of HActor, can be picked in the viewport (f6d89ab1). A crash fix confirms this is live rather than aspirational: “Since entity proxy actors were disabled by default, entity element handles go directly into editor selection sets” (eb511c4f). Supporting signals: EntityFrameworkTests and EntityFrameworkEditorTests moved out of NotForLicensees (1b276cf4), SceneGraph per-player custom primitive data callbacks moved off mesh_component, where they allocated two event UObjects per instance, into an opt-in player_primitive_data_component (c3cc53c1), and Mass core continued decoupling from Engine (99c7cab4, 01626205). Mass also removed code deprecated in 5.6 across 22 files (73ebccd3) and replaced the now-deprecated CSubsystem with UE::Mass::CSystem (c290a520).

Why this is important

The compatibility shim that let entities masquerade as actors in editor selection is off, which is exactly why the picker and mode-selection APIs had to be widened in the same week. Epic is rewriting gameplay simulation code so it can be hosted on something that is not an actor. Anything a studio has written against IsSelectionAllowed, IActorPickerMode, or Mover’s assumption that there is a MoverComponent on an AActor is on a deprecation clock, and the Mass removals are already hard breaks.

Who should care

Gameplay engineers using Mover or Mass, tools engineers with custom editor modes or pickers, and anyone tracking SceneGraph.

Urgency

Track, and act now if you have custom editor modes or Mass code that was riding 5.6-era deprecations.

Mobile scalable local lights, Vulkan modernization, and the first bones of a frame-pacing DAG

What changed

r.Mobile.ScalableLocalLights (default off) splits local point and spot lights into three tiers on the mobile deferred path: near keeps the existing per-light volume draw with full shading models, IES, shadows, and light functions; medium uses one instanced draw per light type with simplified diffuse and specular; far is diffuse-only. To make it work, Metallic and AO were swapped in the GBuffer so DiffuseColor needs a single GBufferC sample (8687b3ca), with a follow-up making medium and far instanced local lights respect primitive lighting channel settings (97e96c48).

Vulkan added VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ support for dynamic rendering (ab197057) and VK_KHR_pipeline_binary plumbing (1eac9c6b), consolidated image acquire onto either a semaphore or a fence and removed VULKAN_USE_IMAGE_ACQUIRE_FENCES with desktop still on fences (b525937f), and picked up a real correctness fix: textures with StoreAction::EMultisampleResolve that are not memoryless are now written, fixing lost contents when multiple passes shared MSAA targets, such as the clear in editor selection outlines (60421447).

On latency, an experimental frame-timing DAG landed compiled out behind UE_TASK_TIMING_ENABLE. It builds a per-frame DAG of thread work where the shortest path is the frame’s critical path, intended to extend into GPU work via platform RHIs and eventually drive game-thread throttling to cut input latency, and it adds FRHIPresentArgsWithStats (8e606bd7). Enhanced Input now applies continuous and forced input at consume time, removing a +1 frame latency (3c273389), with the game thread polling the input thread fresh instead of waiting for the next poll (48dc2716). Directional VSM projections can now write directly into the shadowmask texture when the projection is the first writer, eliminating the intermediate texture and the fullscreen composite, which mostly helps low-end platforms (0abadf08). Also here: instanced static mesh GPU LOD selection touching virtual shadow maps (4d2ffa93), dithered LOD transitions for GPU-instance-LOD instanced meshes in bRenderStatic mode driven through the instance culling pass rather than GetDynamicMeshElements so mesh draw command caching is preserved (ba525ddc), PSO precache skipping post-process and translucency-lighting-volume material precaching on low-core PCD3D_ES3_1 (92dc62b8), net receive processing time limits with optional congestion control (4c47cb82), and a client-side CPU-time circuit breaker for Verse <predicts> with per-execution timeout and loop budgets feeding a leaky-bucket breaker (a11f0644).

Why this is important

The mobile direction is the notable one: reduce per-light cost by distance tier rather than by cutting light counts. The GBuffer channel swap is the catch, and it will bite anyone with custom mobile shading code regardless of whether they turn the feature on. The frame-pacing DAG is not usable yet, but it is the first visible piece of an input-latency story.

Who should care

Mobile and platform engineers, Vulkan backend maintainers, and anyone shipping many-light scenes on mid-tier hardware.

Urgency

Track. Act now only if you maintain custom mobile GBuffer or shading code, in which case check the Metallic and AO swap.

The stabilization wave

What changed

Those defect fixes cluster hard: Control Rig (six), Sequencer (six), PCG (five), plus a set of Mac and Linux crashes, one of which had been hiding behind a lucky uninitialized byte on MSVC.

Control Rig is the heaviest. 64874c17 replaces a StaticLoadObject workaround that deadlocked the cook with version-gated dynamic imports, adds a coalescing re-entrancy guard to RecompileModularRig to fix random heap corruption from nested recompiles tearing down module instances mid-initialization, and bounds-checks override copies against a possibly partially-loaded class layout. It was backed out (44f6ba17) and had not re-landed by week’s end. RigHierarchy topology sharing now uses a dedicated refcount behind a transactionally-safe mutex instead of TSharedPtr::IsUnique(), which is unreliable inside an AutoRTFM transaction and was producing a use-after-free (5e7f6f96).

Two cross-platform fixes are worth reading for the root cause alone. 1cc86453 makes the WITH_EXTENDED_TLS singleton immortal via placement-new into static storage, because its function-local-static destructor ran at process exit and freed the per-thread TLS backing store while the allocator and lingering threads still used it, crashing only the Mac-host iOS and tvOS cooks with SIGILL. ebcefa8c traces a Linux editor crash to a SLATE_ARGUMENT bool that was never initialized, where MSVC happened to give it 0 and clang gave it garbage that produced an out-of-bounds slot index.

Elsewhere in the same vein: out-of-bounds crashes from unvalidated transform selections in GeometryCollection Dataflow nodes (8e38d6d0), a Mass entity leak plus a tripped SetPuppetHandle assert from dormant pooled actors staying world-registered (5866fc3e), a silent poison leak in the new material translator that triggered an assert (a8f53b37), a TSAN data race on FNiagaraTypeDefinition’s lazy Size and Alignment cache (cc68d4d5), an AutoRTFM race on FContext::Active when reading CurrentThreadID (034c85dd), and a DynamicWind race with the cook step (4b7275ce). MallocStomp2 was made platform-agnostic with two virtual address reservation strategies (a ring buffer under 1 TB of VA space, multi-block up to 32 TB otherwise), a fixed underrun mode where the payload is page-aligned against an unmapped guard rather than a committed page, double-free and free-of-decommitted detection, and console commands to trigger each error class (8ff06b1e).

Four infrastructure fixes are act-now if they touch you. Horde’s once-a-minute Perforce health probe had no deadline, so a server accepting TCP but never responding wedged the whole tick under a cluster-wide Redis lock and failed server selection fleet-wide after 7.5 minutes; probes are now capped at 30s (5f6c7776). Linux bundled OpenSSL symbols are isolated via a private version script, fixing a crash on cloud-licensing systems where GPU drivers load their own SSL libraries (0ffae966). Steamworks arm64 Android binaries are now staged in Installed and Launcher builds, where Steamworks.build.cs previously threw when packaging any Android project with OnlineSubsystemSteam enabled (1ab38619). And UBA runtime files that were missing from staged and downloaded builds were restored (45abb63e).

Worth a line each: the Renderer got a private PCH after ClangBuildAnalyzer measured SceneRendering.h at 150.5s and BasePassRendering.h at 89.1s of frontend parse across a Win64 Development rebuild, because ~40 unity TUs each re-parsed the private headers (a8b65242); Gauntlet gained -build=cotf, running a cook-on-the-fly server as an implicit editor session role from loose workspace binaries with no staged build and no upfront cook, verified end to end on Lyra (ad825fcd); Aftermath GPU crash failure classification and a crash fingerprint were added to the crash context (53c2f87a); a new .rhiresourcesnapshot format captures RHIGetTrackedResourceStats() for loading into tools like the Render Resource Viewer (240db376); Android TargetSDK 36 changes landed in UEDeployAndroid.cs (4bf0b050); and TPointHashGrid3 now falls back to linear scan when the search region is very large or when modulo binning would bin a distant min and max close together, which is a correctness bug and not only a perf one (8300cbaa).

Why this is important

Individually most of these are unremarkable. Collectively they say the branch is in convergence. The two cross-platform fixes are worth reading because the root causes are patterns you will hit in your own code: a function-local static destructor racing process teardown, and an uninitialized member that only misbehaves under a different compiler.

Who should care

Everyone on ue6-main, specifically animation, Sequencer, and PCG users, Mac and Linux editor users, and self-hosted Horde operators.

Urgency

Act now on the infrastructure four if they apply to you. Track the rest, and pull what matters if you are pinning a build.

The 5.x Stabilization Sidebar: ue5-main

217 commits on ue5-main, 4.5x last week’s 48, but the headline number overstates the engine-facing delta. There is no engine version bump: nothing touched Engine/Build/Build.version, and all five commits titled “Version bump” or “Package bump” (1198f4d6, 264f084d, 5b7dd791, cdc7c60e, 1bd78343) modify Engine/Extras/RoboMerge/v3/package.json, Epic’s internal merge bot. This is bug-fix-and-port work, not release prep.

The largest cluster is engine code rather than tooling: 37 commits touching Engine/Plugins/Experimental/UAF across 185 file touches, including UAF Notify V1: Runtime (3412ea58), initial anim node support for montages (ddc68852), and Proxy Table support (d62e90e8). Two further commits carrying the same UAF integration-stream tag are explicit UE6-to-UE5 cherry-picks into unrelated editor gizmo and Control Rig code (ab3c7edd, f66f093a). Close behind is RoboMerge at 33 commits, 32 from one author, which inflates the count without touching anything a shipping studio consumes.

The 5.8 hotfix line is visibly live in the metadata: df54130f is tagged “(5.8.2 hotfix)”, 715a826f notes “Bug introduced in 5.8.1”, and 4049e80b was tested in both FNMain and Release 5.8 editors. Worth a cherry-pick if you ship on 5.8: a Mass actor spawning top crash, where MassActorSpawnerSubsystem now recovers instead of asserting when a spawned or pool-retrieved actor’s UMassAgentComponent is in an unexpected registration state, with root cause deferred (df54130f); a blueprint rename and redirector data-loss bug where moving a blueprint onto its own redirector caused a fatal error (afaf8482); a DLC cook failure under -basedonreleaseversion from resolving filenames for WorldPartition generated packages that do not exist on disk (62fe53b4); an AssetRegistry gatherer deadlock (83307182); a StateTree heap use-after-free from recursive SelectStateInternal_LinkedAsset calls invalidating an array element held by reference (a2685056); and a global shader recompile assert from recompiled shaders being removed from ShaderMap Content but left in the CodeResource (51dff0ae). Also credible: 4a5b9eaa, d6178fe6, a125ae00, 27986b0c, and the 5.8.1 PCG pin validation inversion (715a826f).

The structural finding is the dual landing. 128 of the 213 ue5-main commits we could compare (60%) have a byte-identical first-line commit message on ue6-main, and about 120 of those land on the same calendar day in both branches. Epic is landing these in both branches at once, not backporting them weeks later. Confirmed same-day pairs include the StateTree fix (a2685056 / ue6 dcb1b670) and the DLC cook fix (62fe53b4 / ue6 f1423aaa). Roughly 60% of the 85 ue5-only commits are the UAF and Proxy Table animation work plus six localization-automation commits; the rest is the 5.8 hotfix traffic covered above. SHAs in this section reference ue5-main unless noted.

Worth Tracking

Toolsets and MCP are escaping the editor into cooked runtime builds. Mostly under a single ticket, PerfToolset was converted from an editor-only plugin to a runtime plugin so its stats and GPU profiler tools can be served from cooked builds (524fc101), the ModelContextProtocol adapter for ToolsetRegistry moved into the base runtime module (7453886e) with a follow-up fixing MCP not seeing ToolsetRegistry due to module load order (683c606a), ToolsetRegistry settings were promoted to a per-project setting explicitly so cooked builds can still use block lists (30c2fb5c), plugin manifest generation moved from writing into the source content directory to generating during cook (0c02acca), and the cvar tool moved out of EditorAppToolset into ConsoleToolset, described as available at cooked runtime (66602199). Most agent commits on ue6-main are editor-facing and easy to file as an authoring feature. This cluster is infrastructure for exposing engine toolsets over MCP from a cooked, shipped build, with a per-project allow and block list as the gate. If the direction holds, the questions are operational: what the block list defaults to, whether the MCP surface is compiled out of Shipping, and what the attack surface looks like on a cooked client.

The derived data cache is being pulled off its process-global singleton. CreateCache was corrected to return ICacheEx* (f1032c6c), ICacheStore was updated to use the index across more of its API (d4241031), the hierarchy tests were migrated to work on FCache (d2ca136f) while tests that operate on the global cache were removed outright (9c92aa7e), the hierarchy constructor dropped an unnecessary OutOwner (ed509870), StopStore coverage was extended (db0b487a), and derived data loading can now take an optional cache override (b37a9e77). Almost all of it is marked #rnx, so none of it will show up in release notes, and the messages are one-liners that reveal nothing about intent. But “remove tests that operate on the global cache” plus “take an optional cache override when loading derived data” points somewhere specific: more than one cache instance in a process, or derived-data loads scoped to a particular cache. If you run a shared DDC, a cook-server topology, or a custom ICacheStore, this is the API that is about to move.

What We Ignored

53 commits were pure noise and got no further reading. Beyond that, we set aside the usual branch churn (at least 15 backout and revert commits among the routine traffic alone), whitespace fixes, P4VUtils binary bumps, Commit.gitdeps.xml-only submissions, Test Automation Hub dashboard iteration, Epic-internal CI plumbing, test-harness fixes, and UBT naming-convention refactors. RoboMerge and ModularTestFramework are genuinely low-signal on both branches. A long tail of individually routine null guards and bounds checks was counted into the stabilization wave rather than listed. Two clusters were read and deliberately deferred: the new material translator rollout (a8f53b37, bd9a63cc, 7377912b, b0c39317, aa759628, 6fee7ad4), which is still converging onto legacy behavior and carries no decision this week, and cooked-server dependency trimming that drops the Renderer module for dedicated servers (64414b0a, 4fbda163, b5ce96ce), which is worth knowing about if you are chasing server build size and otherwise not.

Closing

The busiest week since mid-May, and almost none of it is features. Epic spent it repairing the machinery that ships the game rather than the game. Pull the build-cache fixes before you find them the hard way.

Commit SHAs are cited inline, in parentheses, next to each claim. They reference the ue6-main branch of EpicGames/UnrealEngine except in the 5.x sidebar, where they reference ue5-main.

Week of July 13 - 19, 2026 | 789 commits on ue6-main, 48 on ue5-main | Branch: ue6-main

Overview

This was a systems-plumbing week more than a feature week, and the graph snapped back from Epic’s summer shutdown: 789 commits on ue6-main, and ue5-main off zero to 48 as 5.x maintenance resumed. The dominant thread is Epic hardening its in-editor LLM agent toolsets and, underneath them, modernizing UnrealBuildTool (C++23 by default, circular dependencies gone) and the distributed build cache. The renderer’s FScene continued its slow decomposition into modular Scene Extensions, and a steady stream of crash-class and data-race fixes landed across Mutable, Iris, audio, and material graphs.

Development Trends

Editor AI tooling shifts from buildout to hardening. The in-editor LLM agent toolset thread that first earned its own editorial theme in mid-June has not slowed; this week it entered a defensive audit phase, systematically converting agent-callable entry points from crash-on-bad-input to graceful failure. That Epic is spending a dedicated audit making these paths non-fatal is the strongest signal yet that the agent is live enough for bad tool calls to routinely take down the editor. Roughly four months into this initiative, the direction is unambiguous: the editor is becoming a first-party target for an LLM agent, and the plumbing underneath it is being made production-safe.

Build and toolchain modernization is the sustained through-line on ue6-main. What read as post-cut “polish” earlier in the year has, on ue6-main, become outright modernization: C++23 is now the default standard for engine modules, module circular dependencies are fully eliminated, and UnrealBuildTool’s incremental detection and manifest handling moved onto modern .NET. In parallel, the distributed build cache (UBA observability, Zen 5.8.18 with GC and oplog-import correctness fixes) keeps maturing week over week. This is the most consistent multi-month thread in the data, and its character has moved from cleanup to structural change, so source-build studios should expect real validation work rather than passive upgrades.

Renderer internals are being decomposed into modular Scene Extensions. A Scene Data refactor that looked like single-week scaffolding in early June has returned as a sustained effort to move state off the monolithic FScene into self-contained, dirty-tracking Scene Extensions. Velocity, runtime virtual texture, capsule shadows, and GPUScene invalidation are all being pulled out along the same pattern, with the stated goal of decoupling input from scene updates so the pipeline can eventually be driven by a state stream. This is invisible to shipping behavior but high-blast-radius for anyone carrying custom renderer patches, and its steady cadence points to an architectural direction rather than a one-off cleanup.

Distributed world-sim substrate is quietly firming up its API. RemoteObjects/DSTM transactional infrastructure is consolidating out of #ifdef scaffolding into public functions, the usual tell that a subsystem is stabilizing its surface ahead of wider internal use, and networking activity ticked up to a window high alongside Iris replication hardening. Taken together this reads as investment in server-authoritative large-world and multi-server simulation as a forward substrate. It is early and low-volume, but worth tracking for any studio with large-world or distributed-sim ambitions.

TL;DR

• Engine modules now compile as C++23 by default (48648dad). If you build UE6 from source or pin an older standard, validate now. This is a real state change, not activity noise.
• Epic’s in-editor AI agent toolsets are real enough that bad tool calls were crashing the editor. A systematic audit is converting agent-callable entry points from check()-and-crash to graceful failure, and each fix protects every caller, not just the agent.
• Module circular dependencies are fully removed (8a03506c, 8bc993b6), a structural milestone that is already producing regressions (Engine to UnrealEd decouple crashed on editor exit, 585044e5).
• IoStore On-Demand install/streaming got a full week of production hardening. Studios shipping partial-install titles on write-constrained consoles should expect materially different install pacing.
• Incremental-cook determinism looks unsettled on this branch (a cluster of “native change not picked up” bumps). Lean on clean cooks for cert builds until the cadence quiets.

Highlights

Epic’s in-editor AI agent toolsets and the crash-hardening audit behind them

What changed: Epic is exposing the editor to an LLM agent through Python toolsets (SceneTools, MaterialTools, CurveTableTools, BlueprintToolset, UMGToolSet, PluginToolset, AssetTools) plus a reversible Blueprint-graph text DSL that decompiles a Blueprint to text and recompiles it (read_graph_dsl / write_graph_dsl). Most visible this week is a defensive audit tagged “Audit follow-up to CL 55439527 / UE-385503”: every agent-callable entry point that could feed bad input into an engine subsystem is being converted from check()-and-crash to graceful failure. DSL round-trip correctness landed for comment-box geometry on cold loads (25dac488), native member-function calls resolving to a creatable type_id (5f688b16, 54be5e06), and multi-output pure nodes like Map/Find binding to the right pin (4e43382e, 752be542). Crash-to-non-fatal fixes covered StaticMesh merge with no renderable mesh (7e639551), adding a simple curve to a rich-curve CurveTable (0b346e7e), null material-expression iteration (74f0089a), and find_actors with an interface filter (e54c1a73). New capabilities include containment-checked download_file into a virtual path (b6c25c80) and MaterialTools get_statistics shader-stat exposure (8573def5). Why this is important: The fact that Epic is spending a full audit making these paths non-fatal tells you the agent is live enough that bad tool calls were routinely taking down the editor. Each hardening fix protects every existing caller, including hand-authored Blueprints, not just the agent. Note that much of this lands as Commit.gitdeps.xml-only changes because the Python toolset code is virtualized, so any “build” classification here is misleading. Who should care: Tools engineers, technical designers, and anyone tracking Epic’s LLM-in-editor direction. Urgency: Track. Not something to adopt, but the clearest signal yet of where the editor is heading.

UnrealBuildTool modernization: C++23 by default, circular dependencies eliminated

What changed: The default C++ standard for engine modules is now C++23 (48648dad), with C++26 enum staged (626319cb). Epic finished removing module circular dependencies: the CircularDependenciesAllowList is deleted (8a03506c) and the remaining circular-dependency check is gone (8bc993b6). On Windows, the external cl-filter.exe is replaced by inbuilt MSVC timing parsing (f2e0d9a1, removal 0ccd35f8), and UBT now serializes precompiled manifests and command-line handling through modern .NET (e6c8239f, 958dd158). Incremental detection got smarter: source-file working sets driven by EpicLore indexing, Perforce-opened files, and Horde preflight state (9211ee27, 18da622f), with action ordering partially randomized to raise cross-host cache-hit rates (3f5c9c7d). GraphEditor was decoupled from BlueprintGraph (ba1df3c0). Why this is important: The C++23 default is a genuine state change that source builds and older-standard projects need to validate against now. The circular-dependency removal is a structural milestone, but it is already producing regressions: the Engine to UnrealEd decouple caused an editor-exit crash (585044e5). Toolchain wrappers that shell out to cl-filter need to adapt. One instability signal worth noting: UHT input/output caching was disabled, re-enabled, then disabled again within the week (dc083352, 709218a9, d4a6c530), so that path is not settled. Who should care: Build engineers and engine programmers, especially anyone on tip-of-tree or building UE6 from source. Urgency: Act now if you build from source. Validate your standard-pinning and any cl-filter-dependent tooling.

Distributed build cache grows up: UBA observability and Zen 5.8.18

What changed: UBA got a week of cache-service stats-page work (hit percentage, per-client TCP/NIC stats, crypto-failure counts with remote IPs, hit-rate graphs, CAS download/delete) alongside reliability fixes: agent crash and recovery when the in-process storage proxy goes bad (abd9dc83), the scheduler no longer over-requesting remote help (e799aa8b), and shutdown crashes (174e6431, 751079e9). The Zen storage server jumped to 5.8.18 (67d8080d) with OpenTelemetry throughout, a single-record zen cache drop, and GC and oplog-import correctness fixes that previously could leave a committed op referencing an already-deleted chunk. Per-client bottleneck visibility (81a94db4, b3cbb1bf, 3a19570e) and sortable client history (a72416ff) landed too, and Zen hub mode now scales past its ~1024-instance limit. Why this is important: The Zen GC and oplog-import fixes are correctness, not cosmetics: a committed op referencing a deleted chunk is a data-integrity hazard for a shared cache. The observability work makes per-client bottlenecks visible for the first time. Who should care: Build and infra engineers, and studios running shared Zen/DDC or UBA cache farms. Urgency: Track, and act now if you operate a shared cache farm. The Zen bump is worth scheduling.

FScene decomposition into modular Scene Extensions

What changed: A sustained renderer refactor continues moving state off the monolithic FScene into self-contained Scene Extensions driven by dirty-tracking rather than the scene-update pass. The core change moves instance data out of FPrimitiveSceneInfo into FScenePrimitiveDataEngine/Renderer arrays and switches GPUScene, VSM cache invalidation, and SceneCulling to dirty-flag-driven updates (fd2022a6). Per-system extractions include velocity data to FVelocitySceneExtension (db26d90c), runtime virtual texture to its own extension (55ddf77d), and capsule-shadow caster primitives to an extension (7da3df1b). Skinning gained provider phases so dynamic wind can skin during the render phase while the normal path skins during scene update (f38e3f39). Measured win: roughly 150us off the critical path in CitySample from avoiding FPrimitiveSceneInfo and proxy hits in GPUScene. Why this is important: This is internal plumbing with no behavior change, but it touches GPUScene, VSM invalidation, SceneCulling, and primitive data layout. The stated goal is decoupling input from scene updates so it can eventually be replaced by a state stream. Who should care: Graphics and engine programmers maintaining custom render paths. Urgency: Track. Anyone carrying renderer patches should expect merge pain.

Slate rounded-box shader rewrite

What changed: A significant rewrite of the Slate rounded-box shader landed (3154d3b3, PR #14958). Why this is important: The rounded-box shader is the primitive behind nearly every Slate and UMG element with a corner radius: buttons, panels, cards, borders. A shader-level quality and performance change here has a broader blast radius than most individual rendering commits, touching essentially the entire editor and every shipping UMG UI. It arrived flagged as low-interest, which undersells it. Who should care: UI programmers, tools engineers, and anyone shipping custom UMG. Urgency: Track. Low risk, but visually and performance-relevant everywhere, so worth a smoke test on custom UI.

Hardware ray tracing and Nanite RT continue maturing

What changed: HWRT hardening continued: the ray-tracing instance buffer builder moved to RDG (ebb0d147), Nanite ray tracing gained assembly support in streaming traversal and stream-out (37b99ff2, e6418a54), and D3D12 opacity micromap support got index-format and index-only-linking improvements (20183afa). Several null and stale-pointer crashes were patched (Nanite RayTracingProxy 35c13cd6, GPULightmass 5daa01e0). Why this is important: The OMM improvements matter for foliage and alpha-tested geometry cost in RT. Nanite-in-ray-tracing assembly transforms close a correctness gap that otherwise blocks HWRT adoption on instanced and assembly-heavy scenes. Who should care: Graphics programmers and studios evaluating HWRT or Lumen-HWRT. Urgency: Track.

IoStore On-Demand install and streaming hardening

What changed: The IAD/IAX subsystem (on-demand container mounting, chunk install/eviction, platform write-throttling) saw a coordinated cluster. Eager-defrag correctness now prevents pending defrag chunks from pinning CAS blocks (e44bc911), a dedup path that failed to locate the right chunk was fixed (e83f0e7b), and installer back-pressure was rewritten so “pressure” is driven by estimated time-to-write the download queue to disk rather than raw item or byte count (4088fc55). Write-budget accounting was simplified so subscribers see the full platform rate against a live budget counter instead of static bias-weighted fractions that starved solo subscribers (0332d1fa), plus a Cycles vs Cycles64 mismatch in throttle-delay math was corrected (cb490d5a). New histogram buckets and persistence analytics (231871e5, 5be99bf5) and an iax.DumpMountedContainersToLog diagnostic (009d795c) rounded it out. Why this is important: This is the runtime that decides what installs, what stays resident, and how aggressively the game writes to disk mid-session. The back-pressure rewrite changes install pacing behavior on write-limited targets. Who should care: Studios shipping partial-install or streaming-install titles, especially on write-constrained consoles. Urgency: Track. Worth reading before pinning an engine version for a title heading into cert.

Stability and crash-class fixes

What changed: Two genuine memory-safety fixes stand out: a data race in the Mutable runtime around Task_Mutable_GetMaterials (81bba34e), and a recursion guard threaded through IsResultMaterialAttributes to prevent a stack-overflow crash on cyclic material graphs (2f015c20), a user-reachable content path. Iris fixed a use-after-free class bug where RPCs referenced dynamic replicated objects destroyed the same frame (ad3ce764). A wave-intrinsics undefined-behavior fix corrected GroupMemoryBarrierWithGroupSync executing in divergent control flow when the wave is narrower than the threadgroup (819dbd72), a correctness landmine that can work on one GPU and corrupt or hang on another. Also landed: a StaticMesh async-build fix eliminating a roughly 219-second cook stall behind DDC fetches (69f0d76d), a thread-safe dynamic-import registry on FLinkerLoad fixing load failures for legacy Control Rig override assets (b5f0409e, UE-381080), an AsyncPhysics RootCounts leak (0ec43389), and audio hardening of TCircularAudioBuffer (669ddbba). Why this is important: The Mutable data race and the cyclic-material-graph stack overflow are both reachable from normal content workflows. The wave-intrinsics fix is the kind of bug that passes on your hardware and fails on a customer’s. The 219-second cook-stall fix is a straight cook-time win. Who should care: Anyone on tip-of-tree, plus graphics programmers writing compute shaders and studios using Mutable or Iris replication. Urgency: Act now if you are pinning a build. These are the fixes you want in.

Worth Tracking

Incremental-cook determinism looks unsettled. Multiple standalone “bump cookincrementalversion / native change not picked up” commits landed this week (325468c1, 79de0d09, 852c286f, fc2e7259), plus an IoStore DDC version bump (fff1af6c) and an editor-domain digest lock-contention fix (1a845c10). Each is trivial on its own, but a cluster of “native change not invalidating content that uses it” fixes in a single week points at cook-key and invalidation gaps surfacing during parallel-incremental-cook work. On a build farm these produce stale cooked output without an obvious error. Treat incremental-cook determinism on this branch as not-yet-settled and lean on clean cooks for cert builds until the cadence quiets.

RemoteObjects / DSTM transactional infrastructure is stabilizing its API surface. RemoteExecutor now exposes ConditionalExecuteTransactional so callers stop #ifdef-ing UE_WITH_DSTM (161f9be7), the libpas Remote Object Handle case was removed from CoreUObject because the Remote Heap no longer uses it (e01274f1), and remote-object-id globalization and server-id lifecycle continued tightening (565258b2, e991093a). Consolidating out of #ifdef scaffolding into a public function is the usual tell that a subsystem is firming up its API ahead of wider internal use. This is substrate for large distributed and multi-server world simulation. Track it if server-authoritative large-world sim is on your roadmap.

What We Ignored

Roughly 20 commits were filtered as pure noise (formatting, typo, trivial reverts) before analysis. Beyond that, we set aside several clusters as low-signal for this audience: an animation-runtime allocation-elimination sweep (per-frame heap allocations stripped from anim evaluation, e.g. d0a3ca2d, b0ab9e74) that is a free gain on character-dense scenes with no action needed; a Control Rig Constraints editing UX rewrite gated behind a CVar fallback (f54d5bf1), which is pure UX with the fallback signaling Epic is not yet confident; and a large body of uncategorized Verse, Solaris, and AutoRTFM churn (roughly 37 Verse and 17 AutoRTFM commits), SceneGraph/Entity/Prefab work, and Interchange and Audio Insights activity that did not carry a clear this-week decision for most studios. Skipping these is deliberate.

The 5.x Stabilization Sidebar: ue5-main

ue5-main came back from the shutdown at 48 commits, and the character is exactly what a post-final-release maintenance branch should look like. There was no installer version bump this week, so no structural release event to report, and the single largest cluster (roughly 19 commits) was internal revision-control and backout-restore tooling rather than engine code. A handful of fixes are worth a cherry-pick if you ship on 5.8 today:

• Lumen irradiance field gather got a real optimization: probe interpolation dropped from 0.93ms to 0.76ms (9c140e9e), alongside a correctness fix for miscomputed probe sample-position offsets (26b898da). Free performance for anyone on the irradiance-field path.
• A misaligned read in the stable PSO cache serialization was fixed, triggered by the FShaderHash change from SHA1 to XXH3 (cb1bef43). If you ship a bundled PSO cache, this is the class of serialization bug that fails quietly.
• IOStore chunk install: -createchunkinstall no longer wrongly includes non-chunk-0 .utoc/.ucas/.sig/.uondemandtoc files (f4567b10), relevant to anyone building chunked installs on 5.8.
• FPaths::IsStaged() had its RequiresCookedData() clause restored (b34bd752), a staged-build path-resolution fix worth noting if you saw oddities there.
• Platform fixes: a corrupted-mouse-image fix from a stride miscalculation in FMacCursor on Apple platforms (5305bce1), and a Linux fix for plugin builds against an installed engine failing to link (0e5b877b).

A few changes landed on both branches: the Dynamic Wind work (cardinal batched-animation culling a740c504, reduced low-speed vibration 2dbaec56, and skinning provider phases 8550ce34, the last mirroring the ue6-main skinning-extension change above). Separately, the Composite editor kept gaining virtual-production tooling on 5.x, including a Transform 2D pass with a viewport gizmo (61515299) and per-layer pass-selection persistence (30baf551). Low, fix-and-trickle volume is exactly what 5.x should be doing now.

Closing

A quiet week on the surface, but the build system moved a real notch forward and a handful of the crash fixes are ones you want in before you pin a build.

Commit SHAs are cited inline, in parentheses, next to each claim. They reference the ue6-main branch of EpicGames/UnrealEngine, except the 5.x Stabilization Sidebar, whose SHAs reference ue5-main. Many of the highest-interest entries resolve to Commit.gitdeps.xml binary-manifest blobs: the commit message is real, but the code lives in Epic’s internal binaries, which we cannot see.

Week of July 6 - 12, 2026 | 64 commits on ue6-main, 0 on ue5-main | Branch: ue6-main

Overview

Epic is on its annual company-wide summer shutdown, two weeks off, and the commit graph shows it: 64 commits on ue6-main against a normal week’s ~880, following 75 the week before. One commit message says the quiet part out loud. The author of the Lore rename opens with “You madman! Why are you submitting this during summer break?” (6ba090ed).

Do not read a trend into the volume. This is not a slowdown, not a branch cut, and not a release-cycle signal. It is a holiday, and the graph will snap back.

ue5-main saw zero commits. Not a handful, not a trickle: zero. 5.x stabilization is fully paused for the shutdown, so if you are waiting on a 5.x backport, assume nothing moves until Epic returns.

All 64 commits come from three people and a build bot. Henrik Karlsson has 41 of them. Matt Begoghina has 15. Wouter Burgers has 2. The buildmachine bot has 6. And in a week where almost nobody was working, Karlsson finished a campaign we have been tracking for four weeks: he drove the editor’s circular-dependency allowlist from 13 entries to zero, then shipped a live status page for the UBA build cache. If last week was “the walls keep falling,” this week the last one came down.

TL;DR

• The editor’s circular-dependency allowlist is now empty, down from 13 entries. UnrealEd, Kismet, BlueprintGraph, GraphEditor, KismetCompiler, and AnimGraph no longer form a link cycle, so they can be built and relinked independently. Editor iteration time drops, and forks and plugins that were getting Blueprint headers for free through UnrealEd’s shared PCH break (dae0d248, e03cbcbd, 10e8206a).
• UBA’s cache service now serves a live status web page, and UbaCli cacheproxy tunnels a remote cache host’s dashboard to your machine. Build-cache observability landed in-engine, and it is the biggest new capability this week (5bb6fad7).
• A four-line UBT fix repaired nondeterministic shared-PCH cache keys. If your shared build cache has had an unexplained mediocre hit rate, start here (a18c43ec).
• Slate is being annotated for dynamic invalidation, widget batch by widget batch, including the entire property grid. Nothing changes behavior yet. It is the groundwork for turning invalidation caching on broadly (22432ab7, c5cfe7ab, and thirteen siblings).

Highlights

The editor’s circular-dependency allowlist went to zero

What changed

CircularlyReferencedDependentModules was the long-standing escape hatch that let UnrealEd, Kismet, BlueprintGraph, GraphEditor, KismetCompiler, and AnimGraph reach into each other. It started this week at 13 entries. It ends at zero.

The AnimGraph cut removed all four ("AnimGraph", *) entries and took the allowlist from 13 to 9 (f78a9d69). That commit is Build.cs-only, because three prep commits had already severed or bridged every reference (2709d889, a3766671, 27cd49ad). Note that the prep relocated UAnimPreviewInstance into AnimGraphRuntime behind a class redirect (a3766671), so there is serialized-asset impact.

Then UnrealEd stopped linking Kismet. Kismet moved to DynamicallyLoadedModuleNames, with the DLL kept resident by loading KismetCompiler at UnrealEd startup so the bridge implementations still bind at static-init (dc1f317a). UnrealEd’s link dependency on BlueprintGraph was cut next (2fce5938), followed by UnrealEd to GraphEditor (6474dcc8). The last three entries died in a single 50-file commit that inverted node and pin color lookups, plus roughly 57 context-menu command references, behind new BlueprintGraph-owned interfaces (dae0d248). KismetCompiler was then absorbed into BlueprintGraph, emptying the list (e03cbcbd), and its shim module was deleted in a 74-file cleanup that is mostly Build.cs edits across ControlRig, Chooser, LiveLink, Optimus, and Lyra (6410df6a).

The pattern is consistent and reusable. The lower module owns a pure-virtual interface header (IK2NodeColorProvider, IK2GraphContextCommands, IBlueprintEditorBridge, IAnimBlueprintEditorBridge), the upper module implements it and self-registers at DLL static-init, and the dependency flips from a link edge to a name-loaded module. Providers forward per-call rather than caching, specifically to dodge static-init ordering hazards (dae0d248).

Buried in the KismetCompiler absorption is a small unrelated fix worth a line: EdGraphCompiler.cpp’s FindNodeByClass now skips null entries in Graph->Nodes instead of dereferencing them (e03cbcbd).

Why this is important

A circular link group cannot be built or relinked independently. Touch one module in the cycle and you drag the whole cluster with it. For the Blueprint editor stack, that cluster is six modules sitting directly under the code most editor programmers touch every day, so the cost showed up as editor iteration time on every incremental build.

The sharper consequence is the shared PCH. BlueprintGraph headers came out of UnrealEdSharedPCH.h, which by Epic’s own count was exporting those types into 1,200-plus inheriting modules (10e8206a). Anything that was transitively picking up BlueprintGraph, Kismet, or AnimGraph headers through UnrealEd or its shared PCH will now fail to compile, and will need explicit Build.cs dependencies. Epic fixed its own code pre-emptively: UnrealEd Kismet2 consumers across roughly 70 modules (934e6b00), AssetTools (52eb36a7), LyraEditor (e4307de0), and Chooser.h (79d80a95). Third-party code gets no such courtesy.

Also worth checking: AnimGraph and BlueprintEditorLibrary are now demand-loaded rather than resident. Any code that assumed they are already loaded at editor startup should be revisited.

Who should care

Anyone maintaining a custom engine fork, anyone shipping an editor plugin, and anyone with a game editor module that includes Blueprint or AnimGraph types. Build engineers too, because the payoff is smaller relink units on editor builds.

Urgency

High if you fork. Do not wait for your first merge conflict to discover this. Grep your editor modules for Blueprint, Kismet, and AnimGraph includes and add explicit Build.cs dependencies now, while the change is fresh and the interface pattern is easy to copy. If you only consume released binaries, this is a “know it is coming” item.

UBA got build-cache observability, and a real scheduler bug got fixed

What changed

Nine UBA commits landed this week, and they are easy to miss: most carry a bare [UBA] tag and no message body.

The UBA cache service now serves a live status web page via -http=<port>, and a new UbaCli cacheproxy mode tunnels that page over the UBA cache protocol (a new CacheMessageType_HttpRequest) so you can view a remote cache host’s dashboard locally. It is 1,679 lines across 17 files, and it exposes throughput, hit rate, storage, connected clients, maintenance history, and per-bucket controls (5bb6fad7).

Memory-based scheduling had two real defects (0bcfde5d). A memory-throttled queue pop was indistinguishable from an empty queue, so the host repeatedly spawned local duplicates of processes already running remotely instead of picking up queued work. Your build farm loses throughput and never tells you. Separately, an expensive predicted-memory callback ran while holding the process-entries lock. Both failures make a distributed build look randomly slower under load without ever producing an error.

The rest: the host no longer waits on remotes after it has already won the race (1ce40548), detoured processes killed from outside UBA no longer orphan their children (6194406d), and cacheproxy was fixed against a crypto-enabled cache server, with CAS validation de-prioritized so proxies can still pull during maintenance (22801911). Binaries were rebuilt (5fb183a7).

Separately, a four-line UBT change fixed a shared-PCH cache-key bug (a18c43ec). bUseUnity was part of the shared-PCH cache key, but modules sharing a PCH explicitly set bUseUnity = false, so the key for the same shared PCH differed depending on which module created it first. UBT now takes the target’s unity setting instead of the module’s.

Minor, and a footnote at most: WaitMutex is now settable in BuildConfiguration.xml, which helps shared CI hosts running concurrent UBT invocations (5032fd6c).

Why this is important

Nondeterministic cache-key generation is the worst kind of cache miss. It is invisible, it never errors, and it just looks like your cache is mediocre. Four lines fix it. If your shared or accelerated build cache has had a stubbornly poor hit rate with no explanation, this is a candidate cause, and the cheapest thing you will test all month.

The observability work matters for a different reason. Until now, diagnosing a bad cache meant inferring from build times. A hosted status page with hit rate, throughput, and per-bucket controls, viewable through a proxy from a developer machine, turns that inference into a measurement.

Who should care

Build and CI engineers running UBA, anyone operating a shared build cache, and anyone who has been quietly tolerating a distributed build that is fast most days and inexplicably slow on others.

Urgency

Act now. The shared-PCH key fix and the memory-scheduling fix are both cherry-pick candidates today, and both move numbers you can measure. Stand up the cache status page next.

Worth Tracking

Slate is being annotated for dynamic invalidation

Fifteen commits from Matt Begoghina under one ticket add TWidgetTypeTraits<W>::SupportsInvalidation() specializations across the widget library: core Slate covering docking and tabs (22432ab7), multibox (363cb557), notifications, canvas, and tooltips (344b0e77), popups and title bars (16298b3a), and layout and box widgets (a6595f63); the whole PropertyEditor stack (c5cfe7ab, 2f3fc266, 0836db2b, e02ac01f); EditorWidgets (2aa42eeb, 8f1b07e9); and the Verse EntityPrefabEditor (d3d7391c).

Dynamic invalidation is opt-in per widget type, and a single unmarked widget inside an invalidation panel poisons the cache for that entire subtree, which is why SInvalidationPanel has historically been unusable across most editor UI. Epic is clearing that gate widget by widget, including the property grid, the heaviest Slate surface in the editor.

Nothing changes behavior yet. It only pays off when something downstream turns the caching on broadly. Watch for the commit that enables SInvalidationPanel by default or flips a global invalidation setting. Editor UI framerate moves then, and so does the cost of any custom Slate widget in your project that has not declared SupportsInvalidation: it starts silently forcing repaints of its parent subtree. If you ship editor tooling with custom Slate widgets, add the trait.

“Skein” and “Unreal Revision Control” are both “Lore” now

Epic consolidated both names to Lore (6ba090ed, follow-up 138774cd). Nothing technical changed, and both commits are tiny. Treat this as naming confirmation on Epic’s source-control effort, not a feature landing. It is also the commit carrying the summer-break quote.

What We Ignored

• Five “Horde: Updating schema documentation” commits from buildmachine, plus an automated binaries bump. Bot traffic.
• A Commit.gitdeps.xml binary-manifest blob bump (9d4036d3). It is a blob bump. There is nothing to read.
• Assorted empty-message commits and include-hygiene one-liners, including a spelling fix for InitalizeExtenders (c522f9d2), which we mention only because fixing a typo during your own holiday is a choice.

Closing

A quiet week on the calendar, but the allowlist going to zero and a four-line cache-key fix will both cost you time if you find out about them the hard way.

Commit SHAs are cited inline, in parentheses, next to each claim. They reference the ue6-main branch of EpicGames/UnrealEngine. Many of the highest-interest entries resolve to Commit.gitdeps.xml binary-manifest blobs: the commit message is real, but the code lives in Epic’s internal binaries, which we cannot see.

Week of June 29 - July 5, 2026 | 75 commits on ue6-main, 0 on ue5-main | Branch: ue6-main

Overview

This was the US July 4 holiday week, and the commit graph shows it: 75 commits on ue6-main against the ~880 of a normal week, and ue5-main was completely still. With the offices mostly empty, one engineer kept the lights on, and the week reads as a single coherent story instead of the usual dozen. The UE6 editor-modularization effort we’ve been tracking for three weeks did not pause for the holiday. It came for MaterialEditor, for the Interactive Tools Framework, and for AssetTools. If last week was “an agent going in, the walls coming down,” this week was just the walls, quietly, one load-bearing beam at a time. Nothing here is user-facing or runtime. The audience is build engineers and tools programmers on ue6-main, and anyone maintaining an engine fork who is going to feel these merges.

Development Trends

The UnrealEd decoupling campaign is now a three-week arc, and it’s accelerating. The theme showed up when ue6-main coverage began, and last week it produced the headline change: Engine stopped linking UnrealEd, a ~176-file inversion through provider interfaces. This week, even at a quarter of normal volume, the campaign came straight for the next targets, and the CircularDependenciesAllowList kept dropping, one entry or pair at a time, across more than a dozen modules (SubobjectDataInterface, LevelEditor, the Sequencer and MovieSceneTools split, Kismet, Documentation, MeshBuilder, and more). The MaterialEditor cut alone ejected a 28-module dependency cycle down to 15. This is not scattered cleanup. It’s a disciplined, repeatable playbook (relocate the code to its natural home, replace the hard link with a name-loaded provider or bridge interface, add CoreRedirects so serialized and script references survive, delete the allowlist entry) applied module by module. The through-line from the UE6 announcement is intact: a modular editor is the precondition for the agentic tooling layer Epic is building on top of it, and this is the unglamorous foundation work that makes that possible.

A new module is being born to catch the falling pieces. The EditorViewport module started the week essentially empty and has been accreting the viewport core (camera transform and controller, click and cursor and navigation types, hover effects, and now the FEditorViewportClientBase class) so that tool and gizmo code can be typed against a base that sits below UnrealEd. Watch this one: it’s the extraction target the whole viewport story routes through, and it isn’t finished.

TL;DR

• Holiday week. 75 commits, almost all one engineer’s editor-decoupling campaign, plus a handful of audio and media fixes from others. ue5-main was silent.
• UnrealEd no longer links MaterialEditor. The entire MaterialGraph node and schema cluster moved into the MaterialEditor module, collapsing a 28-module dependency cycle to 15 (762b1941).
• The Interactive Tools Framework (EITF) was severed from UnrealEd, retyped across ~50 files against a new FEditorViewportClientBase in a new EditorViewport module (fbc487ba, b8139326). This is the highest fork-conflict risk of the week.
• AssetTools was ejected from the editor dependency cycle, swapping 32 call sites to name-loaded access and relocating a reflected enum (7f47c982). Under-rated: it touches nearly every editor tool and changes a public API.
• A runtime layering violation got fixed too: Landscape (a runtime module) no longer reaches into editor-only UnrealEd, routing through Engine-owned provider interfaces instead (a3171f31).
• The refactor is landing net bugfixes as it goes: tool-stack lifecycle correctness, multiple null-guards flagged by static analysis, and a same-day fix for a startup crash the work itself introduced (6dbbeaf6).
• Underneath the decoupling, a small amount of real feature and fix work: a Quartz timing out-of-bounds regression fix, media encoder and pixel-streaming reliability fixes, and a net-new PySlate module for authoring editor UI in Python.

Highlights

Build & Tooling: UnrealEd Loses Three More Walls

What changed Three of UnrealEd’s biggest dependency edges came down this week. MaterialEditor was cut loose: the whole MaterialGraph node and schema cluster (the UMaterialGraph, UMaterialGraphSchema, and UMaterialGraphNode_* family) relocated out of UnrealEd into the MaterialEditor module, with include paths preserved and ClassRedirects covering script references, ejecting a 28-module link cycle down to 15 (762b1941). The Interactive Tools Framework was severed in two stages: first a prep pass evacuated the reflected, UnrealEd-coupled tool-stack types out of EITF (b8139326), then EITF was retyped across roughly 50 files against a new FEditorViewportClientBase in a new EditorViewport module instead of UnrealEd’s concrete FEditorViewportClient (fbc487ba). And AssetTools was ejected from the cycle: 32 IAssetTools::Get() call sites swapped to name-loaded module access across the core file-and-package tools, with a reflected enum relocated behind an EnumRedirect and a new public GetPackageLengthForCooking API added (7f47c982). Smaller cuts landed in the same spirit, including MeshBuilder (163abb29) and an EditorStyleSettings relocation with a config-defaults fixup (02cc7197, 41c663da).

Why this is important UnrealEd has been the monolithic module everything links against, and its circular-dependency web is the single biggest driver of editor relink times. Shrinking the strongly-connected component means less of the editor has to rebuild when any one module in the cycle changes. The provider-and-bridge-interface pattern being established here (IMaterialEditorModule, the IEditorXProvider family, ISubobjectDataBridge) is the sanctioned way to reach editor services without taking a hard UnrealEd link. The AssetTools cut is the one to read closely: it sits under nearly the entire content pipeline, it changes call semantics (the module now loads on first menu evaluation), and it moves a reflected enum, so it carries more real regression and fork-conflict risk than the headline MaterialEditor change.

Who should care Build and DevOps engineers who own editor compile times. Tools and plugin programmers, especially anyone building on the Interactive Tools Framework, subclassing an editor viewport client, or linking MaterialGraph or AssetTools symbols out of UnrealEd. And anyone maintaining an engine fork: changes at this surface generate painful, wide merge conflicts.

Urgency Track. Act now if you maintain a fork touching these module boundaries, or ship custom interactive tools or viewport-client subclasses on ue6-main. The EITF retype changes public header types and adds a new virtual to the viewport-client base, so downstream code will recompile and may need re-fixing.

A Runtime-to-Editor Layering Violation Gets Fixed

What changed Landscape, a runtime module, had been reaching into editor-only UnrealEd for its WITH_EDITOR paths: actor selection and deletion, package saving, static-lighting export, name sanitization. That edge is gone, routed through Engine-owned provider interfaces with new verbs added for the editor-time operations (a3171f31). The same pattern reached into the audio runtime, where the Engine to AudioMixer circular dependency was removed (24521a60).

Why this is important Runtime modules that link editor code are a recurring source of packaged-build and cook surprises. This is a categorically different (and arguably more valuable) fix than the editor-internal cycle cuts, because it corrects a real layering violation rather than just untangling two editor modules. It’s also a signal: Epic is actively hunting these, so expect more runtime modules to lose their editor edges in the coming weeks. If you have runtime modules with #if WITH_EDITOR blocks calling GUnrealEd or GEditor directly, this is the pattern to copy.

Who should care Engine programmers and studios maintaining forks with custom runtime modules that touch editor state.

Urgency Track.

Stability & Fixes: The Refactor Is Auditing Itself

What changed The decoupling work is not pure mechanical relocation. It keeps folding in real correctness fixes as it moves code. The EITF prep stage fixed six genuine pre-existing defects in the tool-stack code: a mis-stored identifier that meant editor-scope tool types never unregistered, several unchecked null dereferences in destructors and activation callbacks, .Last() calls on possibly-empty arrays, and a leaked command-list mapping (b8139326). The viewport retype pulled in three more null-guards flagged by static analysis (fbc487ba). And a static-initialization-order crash on editor startup, introduced by the EditorViewport work itself, was caught and fixed the same day in the same synced changelist (6dbbeaf6). Separately, a Quartz timing regression got a fix: an out-of-bounds access in Tick plus a PlayQuantized CoreRedirect resolution (6fd07009).

Why this is important This is what a healthy large-scale refactor looks like. Relocations double as bug audits, and the regressions the work introduces surface and get fixed fast. The Quartz out-of-bounds fix is the one non-refactor stability item worth acting on: if you sync recent ue6-main and use quantized audio, confirm you have it.

Who should care Editor engineers, anyone who has hit flaky tool-lifecycle or startup issues on ue6-main, and teams using Quartz quantized audio.

Urgency Track. Act now on the Quartz fix if you’re on quantized audio.

Media & Streaming: Two Narrow Reliability Fixes

What changed Two small but real fixes landed in the media stack. The WMF audio encoder was emitting multiple output packets per SendFrame call when the contract expects one, now corrected (2639c6d7). And PixelStreaming2 was throwing errors when a frame was requested before the first one had been pushed into the video capture pipeline, an initialization-ordering bug now guarded (052fc56a).

Why this is important Individually minor, but relevant to anyone doing capture-and-encode work or running a pixel-streaming pipeline. They’re also the clearest signal this week that ordinary feature-and-fix work continued underneath the decoupling push.

Who should care Teams with media encoding or pixel-streaming pipelines.

Urgency Track.

Worth Tracking

A new PySlate module. A net-new module landed as an “Initial Commit” (0b279ece): a Python-Slate binding surface for authoring editor UI in Python. It’s a single early commit with nothing built on it yet, but a first-party path to scripting editor UI in Python is a genuinely notable capability, and it fits the broader UE6 direction of making the editor more scriptable. Worth watching whether it accretes real surface area in the coming weeks or stays a stub.

The EditorViewport module. As noted in the trends section, this module is being stood up specifically to host FEditorViewportClient’s base class and the viewport POD types, so tool and interaction code can depend on viewport primitives without linking the editor monolith. Several commits explicitly describe themselves as “prepares” or “stage X of,” and public types are relocating behind CoreRedirects. If you build against viewport internals, the correct include is shifting under you even though forwarding headers keep most code compiling for now.

What We Ignored

We set aside roughly 30 commits this week, most of them the expected fallout of a large refactor: non-unity compile fixes, static-analysis annotations (CA_ASSUME, check(ptr) guards), and a handful of near-identical auto-generated Horde schema documentation updates. None of these affect runtime behavior, performance, or upgrade risk. On a normal week many would not even register; on a 75-commit holiday week they’re a visible fraction of the total, which is itself a fair picture of how quiet the week was.

Closing

A holiday week is a good week to see what a team does when nobody is watching. Epic kept paying down the editor’s oldest architectural debt, carefully, one module at a time. Nothing to act on unless you maintain a fork. Everything to appreciate if you care where the engine is going.

For what it’s worth, this was the shortest read since we started doing this. We keep wanting to say we did something noble with the spare time. Mostly we just enjoyed a quiet inbox and read the diffs slowly for once.

Commit SHAs are cited inline, in parentheses, next to each claim. They reference the ue6-main branch of EpicGames/UnrealEngine. Some entries may resolve to Commit.gitdeps.xml binary-manifest blobs: the commit message is real, but the code lives in Epic’s internal binaries, which we cannot see.

Week of June 22-28, 2026 | 880 commits on ue6-main, 155 on ue5-main | Branch: ue6-main

Overview

Week two on ue6-main carried 880 commits against ue5-main’s 155, holding the divergence we saw when the branch switched. A week ago this looked like a thin new layer riding on ordinary engine work. This week the layer starts to take a recognizable shape. The story is two halves of the same move: Epic is wiring an AI agent directly into the editor, and at the same time tearing out the circular module dependencies and old VM layers that would make that agent hard to build. The loud half (a first-party agentic toolset framework) is mostly invisible to us, sitting behind binary-manifest blobs. The quiet half (Engine no longer links UnrealEd, a type-directed Verse VM fuzzer, AutoRTFM correctness hardening) is fully readable in source, and that’s where the credibility comes from. None of it is production-actionable for teams shipping today. Early Access is targeted for late 2027. If you ship a game now, you stay on 5.8, and the 5.8.1 maintenance sidebar at the bottom is the part that touches you.

TL;DR

• The biggest storyline (Epic’s agentic in-editor toolset framework) is also the least verifiable: most of those commits resolve to Commit.gitdeps.xml binary blobs. The intent is clear from the messages, the implementation is not.
• The agent framework is consolidating from “add a toolset” into shared infrastructure: ToolsetRegistry split into runtime + editor modules and made a singleton so non-editor targets can call it, and MCP server settings enabled in Fortnite/UEFN builds (cee54db2, 13a4ae6e).
• The most important visible change is structural: Engine no longer links UnrealEd. A ~176-file refactor inverts editor calls through ~28 provider interfaces (3ccf3ec3). This is years-of-payoff plumbing, and it will conflict hard against any custom fork.
• The Verse VM got a fuzzer: a type-directed one that generates type-correct programs pushed VM-execution coverage from near-zero to ~99%, running cross-backend with auto-triage (70d06ad5). Usually that comes right before a team flips the default VM.
• AutoRTFM and Verse are hardening as one transactional substrate, with commits on each side referencing the other.
• A cluster of CI and build-farm reliability fixes is the most act-now material this week: a Horde Dashboard hang, an AssetRegistry gatherer deadlock, a ZenCacheStore shutdown race (ecd1ca21, 79564ad3, 4a2e16ad).
• ue5-main bumped to 5.8.1. The sidebar covers the regression and crash fixes worth cherry-picking if you ship on 5.8 today.

The Through-Line: An Agent Going In, the Walls Coming Down

If you read the week as one move instead of a list, it’s this. Epic is bolting an AI agent into the editor and simultaneously removing the architectural debt that would make that agent expensive to maintain. The two efforts are not announced as related, but they fit together. A clean, broadly-callable agent surface is much easier to build once runtime and editor modules stop linking each other in a circle, and once the language the agent reasons about (Verse) has a VM you trust. So the week splits into the loud-but-invisible (the agent) and the quiet-but-visible (the refactors), and the two deserve different grades. We can confirm the refactors from source. We can only read the agent’s intent from commit messages, because the code lives in Epic’s binaries.

The New Layer (UE6-Specific)

An AI Agent Is Going Into the Editor, Toolset by Toolset

What changed. This is no longer one experiment. There’s now a family of “toolsets” being registered for an in-editor agent to call: AssetTools, StateTree, PCG, MetaHuman Generator and a MetaHuman wardrobe toolset, plus a new CrashDiagnostics toolset that lets the assistant fetch and explain prior editor crashes by GUID (1aed1cb3). The plumbing under them matured this week too: ToolsetRegistry was split into runtime and editor modules (fe41b687) and FToolsetRegistry converted to a singleton, explicitly “so we can access it from outside editor in later CLs” (cee54db2), and MCP server settings were enabled in Fortnite/UEFN builds (13a4ae6e). The toolsets themselves are thin Python and Verse wrappers around existing BlueprintCallable APIs, with docstrings written for the agent to discover capabilities and guardrails to keep it from hanging the editor: find_assets gained a max_results cap after agents fired queries returning tens of thousands of results and appeared to hang (c8023dfa), and MetaHuman Generator registration is now gated on optional content because a set_skin_tone call asserted and crashed the editor when that content was absent (c936322e).

Why this is important. The shift from “add a toolset” to “refactor the shared registry so non-editor targets can call it” is what gives this away. Epic is preparing a first-party agentic layer as a stable, broadly-callable API, not a collection of one-off editor panels. The guardrails point the same direction. Result caps and content-availability gates are exactly what you add when the caller is a model retrying against state it can’t fully see.

Who should care. Tools and pipeline teams, technical artists, and studios evaluating UE6 automation. Nobody needs to act, but this is the workstream that would reshape how a tools team thinks about editor automation if it ships.

The honest caveat. Nearly every commit in this theme resolves to a Commit.gitdeps.xml binary-manifest blob. The messages are real and descriptive, but the implementation lives in Epic’s internal binaries we cannot see. Treat the direction as confirmed and the contents as unverifiable.

Urgency Track.

The Engine-to-UnrealEd Wall Comes Down

What changed. Engine no longer links UnrealEd. The ("Engine","UnrealEd") entry is gone from the circular-dependency allow-list, replaced by roughly 28 IEditorXProvider interfaces that invert the editor-time calls Engine used to reach through UnrealEd for (GEditor, asset tools, transactions, selection, save), across about 176 files (3ccf3ec3). PropertyEditor got the same treatment: ~50 call sites inverted through FPropertyEditorHooks, with FPropertyEditorToolkit extracted into a new module (2f9e23de). Smaller untanglings landed in the same spirit, including NiagaraEditor being severed from the experimental toolset-registry plugin so it no longer force-enables it wherever Niagara ships (472b1e83).

Why this is important. UnrealEd has been the monolithic module everything links against. Breaking those edges is a precondition for faster editor iteration builds and for letting tooling depend on editor-framework pieces without dragging in the entire editor. This is the fully-visible, unambiguously-real counterweight to the agent story: it ships no feature, and it pays off for years. It also fits the through-line. A clean agent surface is far easier to build on modules that don’t link each other in a circle.

Who should care. Engine programmers, plugin and module authors, and anyone maintaining a custom fork. Changes at this scale generate painful merge conflicts, so read them before your next integration.

Urgency Track. Act now if you maintain a fork that touches Engine or PropertyEditor module boundaries.

The Verse VM Gets a Fuzzer

What changed. The work around the new Verse VM this week is about confidence, not surface area. A type-directed language fuzzer now generates programs that are type-correct by construction, which pushed VM-execution penetration from effectively zero to around 99%, and runs them across both the legacy BPVM and the new Verse VM with automated crash fingerprinting, delta-debug shrinking, and auto-filed tickets (70d06ad5). Alongside it, a new assert_bytecode facility pins down that specific language constructs compile to the exact expected bytecode (bb02745a), and a toggle_compile_features macro allows per-test compiler-feature opt-in (f2db1e4d). The feature work continued in parallel: a “Verse Animation Phase 2” arc added playback, time, looping, ease-in/out, replication, and async loading (81a5e1bb, 362f1cf4), and CoreRedirects for type aliases appeared (62d488c8), a backward-compatibility path you only bother to maintain once content is being authored against the new VM.

Why this is important. A cross-backend fuzzer and bytecode-equality assertions are what a team builds when it intends to flip the default VM and wants proof the two backends agree first. Read together with the animation phase-2 work and the compatibility redirects, Verse is moving from scaffolding into hardening. If you want to know where UE6’s gameplay-authoring direction actually sits, this is where to look.

Who should care. Verse and UEFN-ecosystem developers, and language-tooling teams.

Urgency Track.

AutoRTFM and Verse Harden as One Transactional Substrate

What changed. Roughly a dozen AutoRTFM commits landed, almost all correctness hardening: more virtual-function-mode violations fixed, support for unbalanced recursive locking in TTransactionallySafeMutex, and AUTORTFM_IMPLICIT_DISABLE / AUTORTFM_OVERRIDE_MAY_DISABLE annotations applied to AutoRTFM::Open() and UCommandlet::Main(). The cross-references to Verse are now explicit, including a verse-clang change to emit AutoRTFM static-local-initializer calls for non-AutoRTFM-enabled functions, and a Verse-side drop of an AutoRTFM::UnreachableIfClosed() from the Solaris runtime link path. Two real runtime fixes also landed: a latent memory leak in the Verse package cache from an unsafe AUTORTFM_OPEN on a TSharedRef (c306b881), and relinquishing Verse heap access across UE::Tasks::Wait to avoid a GC-handshake deadlock (1ee866b5).

Why this is important. AutoRTFM provides the transactional-memory guarantees Verse’s gameplay and replication model leans on, and the commits this week are wiring the C++ side (mutexes, virtual-function modes, static initializers) to satisfy that contract. The two systems are advancing as one substrate, and the activity is hardening rather than new scaffolding. That work, plus the EpicClang gating we noted last week, is what “transactionalize C++” actually amounts to so far.

Who should care. Gameplay programmers evaluating Verse, and engine teams touching threading or transactions.

Urgency Track.

SceneGraph Keeps Weaning Off Actor Proxies

What changed. The SceneGraph and Entity work this week has one consistent sub-theme: removing the dependency on proxy actors. Commits fixed util and Python-exposed functions that were actor-proxy-reliant, removed an unused proxy-reliant SceneGraphUtil function, and made edit-in-place plus step-in and step-out work without proxy actors (8bdf3f43). Around that, editor integration landed: entity-outliner sorting without GUIDs, duplicate-suffix handling, constrained drag-and-drop, and exposing custom depth and custom-depth-stencil values on mesh entity components.

Why this is important. SceneGraph is the entity model Epic has named as the eventual replacement for the AActor proxy system. Severing proxy-actor dependencies makes entities stand on their own representation rather than shadowing the legacy actor model, and the simultaneous outliner and prefab work signals Epic wants entities usable through normal editor workflows, not just as a backend. This is the groundwork for deprecating Actors, and it is years ahead of any actual deprecation.

Who should care. Engine and framework teams, and anyone weighing the long-term actor-versus-entity direction.

Urgency Track.

Ordinary Engine Work That Still Matters

Build & CI Reliability

What changed. A cluster of genuine production-reliability fixes landed in the parts of the stack a studio’s build farm actually depends on. The one most teams will feel is a Horde Dashboard hang: a job page would spin forever (HTTP 200, never repaints) when a summary report packed many <br/> tags into one block and triggered catastrophic regex backtracking in markdown-to-jsx (ecd1ca21). DDC Verify can now split into a priming job and a verification job (fc452788). An AssetRegistry gatherer deadlock where all threads could block was fixed by having the gatherer contribute to directory processing when explicitly waited on (79564ad3), and a ZenCacheStore shutdown race in the perf-monitoring thread was closed (4a2e16ad). On the toolchain side, Epic added a direct, non-VM BuildGraph builder API as the foundation for eventually removing the C# BuildGraph VM (28d001c2), and fixed a data race in UnrealBuildTool’s PCH dependency calculation that could produce a wrong dependency list and a build exception (555da914), plus a ~40% speedup on shared-PCH dependency lookup (253b35aa).

Why this is important. These are the failures that cost a build farm real hours: a dashboard that hangs on a specific report shape, a gatherer that deadlocks, a cache store that races on shutdown. None are dramatic, all are worth pulling into your fork if you run Horde, Zen, or a large DDC at scale. The BuildGraph VM-removal groundwork is worth noting early if you author graphs in C#: the eager-Def API is the future surface, though nothing is deleted yet and the VM stays default.

Who should care. DevOps, build-farm operators, and CI/CD owners.

Urgency Act now for studios running Horde/Zen/DDC at scale. Track for everyone else.

Rendering: Nanite Ray Tracing and TSR

What changed. Nanite ray tracing now keys hierarchy traversal on which pages actually have CLAS allocated, which fixes BLASes with holes when the CLAS pool runs out of memory (fce21cf5), plus a GPU crash fix in the Nanite Voxel rasterizer (a34274e1). TSR split its Guide uncertainty into a dedicated single-channel PF_R16F_FILTER array, removing a redundant full FloatRGBA slice per frame when alpha is enabled (69a9c2b1). A stereo refactor renamed the View uniform buffer (View to VUB) to support a static ViewState alias for instanced stereo, touching about ten files, half of them shaders (1c769f66).

Why this is important. This is correctness-and-cost tuning on a maturing path, not a feature launch. The CLAS-availability traversal stops intermittent corruption under memory pressure, the failure mode that’s painful to reproduce. The View-to-VUB rename will conflict against any custom shaders, so flag it before integrating.

Who should care. Rendering engineers, studios on Nanite with hardware ray tracing, and teams using alpha-channel TSR.

Urgency Track. Note the shader rename if you maintain custom shaders.

Stability: Core Thread-Safety and the New Systems

What changed. A few fixes this week sit below the headline themes but matter because of where they are. A data race was fixed in FNameTokenStore (8190796e), thread-safety in one of the most fundamental engine primitives. The new Verse Animation Framework got a use-after-free fix caught by ASAN, where local stack memory was freed before an update context used it (4b0505d5). The multiserver and RemoteObjects path picked up serialization and shutdown-ordering fixes for the distributed-world tech (80d7dd09, 21775ccc).

Why this is important. The FName data race matters most: that primitive is touched everywhere, so a race there produces rare, unreproducible corruption across unrelated systems. The UAF and multiserver fixes are early-system hardening, which is expected and healthy on a young branch, but worth noting because they sit in the UE6-specific code, not the inherited engine.

Who should care. Engine programmers, and anyone tracking the maturity of UE6’s new animation and distributed-simulation systems.

Urgency Track.

Mass ECS Gets Layered Into a Core

What changed. About a dozen Mass commits this week were structural reorganization rather than features: element-bitset declarations moved from MassEntity into a new MassCore module, fragment access and presence enums plus the requirement-description and error-reporting helpers pushed down into MassCore, and dead editor-only build dependencies stripped from Mass modules. Test replication into a low-level-test target and README and documentation additions landed alongside.

Why this matters. Pulling Mass’s foundational pieces down into a lower MassCore layer and stripping editor-only dependencies usually precedes wider reuse across runtime and server targets. Read together with the SceneGraph entity work, Epic is making the entity and ECS stack a first-class, broadly-depended-on engine layer in UE6. The documentation and test work suggests an API stabilizing for external consumption, the kind of cleanup that follows last week’s MassIrisReplication feature push.

The 5.x Stabilization Sidebar: ue5-main

ue5-main is now bug-fix and regression maintenance only, and this week it bumped the installer version from 5.8.0 to 5.8.1 (3a421871), confirming the branch is feeding a 5.8.1 hotfix release. At ~155 commits against ue6-main’s 880, it’s doing exactly what a post-final-release branch should. If you ship on 5.8 today, these are the fixes worth cherry-picking:

• Nanite crash with translucency disabled (default config). With r.Nanite.AllowTranslucency off (the default), translucent materials still reached translucency and base-pass codepaths and crashed instead of falling back to the default material. Any 5.8 title using Nanite on stock settings could hit this; it now degrades gracefully with a warning (40789343).
• Landscape spline tangent regression. Landscape editor tools were switched back to legacy viewport interactions to fix spline tangent manipulation that broke in 5.8. A real workflow regression for anyone doing landscape, road, or spline authoring (e348bec2).
• Vulkan submission-thread deadlock. Fixes a SubmissionThread deadlock from a recycled “rendering done” semaphore handle, plus a guard that acceleration structures support mutable descriptors before enabling ray tracing. Relevant if you ship Vulkan with RT in the mix (11c1d64a).
• Sequencer crash on stale section pointers (UE-385130). CheckForEdgeInteraction asserted on stale weak pointers when a section was removed before the underlapping-segments list refreshed. An editor-stability fix for heavy cinematics work (256a80f8).
• MegaLights + Forward Rendering missing-shader crash. A compile-versus-use condition mismatch on FFrontLayerTranslucencyClearGBufferPS crashed projects using Forward Rendering with MegaLights enabled. Narrow config, hard crash, mostly the mobile, VR, and forward crowd experimenting with MegaLights (55fc8ae9).

Honorable mentions worth a fork cherry-pick: a Metal breadcrumb crash fix on Apple platforms (dd1c69ab), a non-deterministic AnimationSequence DDC fix from uninitialized curve padding that would otherwise spuriously invalidate a team’s shared cache (6d47614c), and a bindless-uniform-buffer texture-reference fix (5f8f0741). The overall character is what you’d expect from a release winding down: regression patching, crash hardening across editor tooling, and routine plumbing, with the 5.8.0-to-5.8.1 bump the only structural event. Low, fix-only volume is exactly what UE5 should be doing now.

Worth Tracking

Two early signals worth a note. First, incremental cook is getting opt-in multithreaded dependency-key computation, precomputing each wave of ready vertices’ per-package keys across worker threads before the serial loop consumes them, with blueprint hashing made thread-safe behind a reader-writer cache lock (3246bde7). It’s behind a new CVar and off by default, with a couple of cookincremental version bumps landing the same week. Cook-key computation is a known serial bottleneck in large CI pipelines, so if that CVar flips to default-on in a future release it’s a direct iteration-time win. Track whether it stays experimental or graduates.

Second, MetaHuman Crowd is being wired into the Mover plugin’s authoritative simulation, with teleport handling overridden so Mover’s state updates alongside the actor transform (95b02b1a), landing next to a “Mass Characters animation pipeline” update (6feac289). The combination of MetaHuman Crowd, Mover as movement authority, and Mass character animation points at Epic converging its crowd and NPC story onto the Mass framework. If you’re choosing a large-population character solution in UE6, this is the stack to watch consolidate.

What We Ignored

We set aside several hundred commits this week, mostly routine crash-fix hardening (Mutable, PVE foliage, Niagara, Sequencer, MetaHuman import), formatting and comment changes, vendor binary bumps, and the usual integration churn including a dozen straight backouts. These don’t affect runtime behavior, performance, build reliability, or upgrade risk for production teams. The interesting work this week was not at the top of the volume chart; the architecture campaigns above were spread thin across many small commits, which is exactly why they’re easy to miss on a fast skim.

Closing

Week two of UE6 is the week the new layer started to resolve into intent: an agent going into the editor, and the walls coming down to make room for it. Most of it is years from anything you’d ship. If you’re shipping today, read the 5.8.1 sidebar and ignore the rest.

Commit SHAs are cited inline, in parentheses, next to each claim. They reference the ue6-main branch of EpicGames/UnrealEngine unless noted as ue5-main. Many of the highest-interest entries (notably the agentic toolset work) resolve to Commit.gitdeps.xml binary-manifest blobs: the commit message is real, but the code lives in Epic’s internal binaries, which we cannot see.

Here is the short version of why it exists.

Fast builds were not the whole problem

We build games at Ayelet Studio. For a long time, builds were the slowest part of the week. Packaging a build meant running all three platforms sequentially, which cost us 3x the time. Our one build machine was a bottleneck. And producers, QA, and designers had no visibility, so they scrambled for the latest build every morning.

So we built our own CI/CD platform.

That solved the speed and the visibility. It did not solve everything.

But one thing was still broken.

Even with a fast pipeline, starting a build still meant leaving Unreal. You tab out to a web dashboard, or someone opens a terminal and runs the right command with the right flags. So in practice, one person still owned builds. The artists and designers who actually needed a packaged build to test something could not just make one. They had to go find the build wizard. Again.

We had fixed the infrastructure. The workflow still had a person stuck in the middle of it.

What the plugin does

The whole point of the plugin is that you never leave the Unreal Editor.

There is a button in the editor toolbar. Click it, and SpeedrunCI runs your build in the cloud, streams your logs, and delivers the finished artifact, all while you keep working. The live status shows up right there in the editor.

Every platform pipeline and its last build status sit in one view. Anyone on the team can see what passed and what failed, without a CI dashboard tour.

Underneath, the service is built for how Unreal actually works, not retrofitted from a web app tool:

• Game-aware caching for cooked assets, shaders, and derived data, so repeat builds stay fast.
• A parallel build graph that runs across multiple runners instead of one long queue.
• Every UE platform: Windows, Mac, Linux, Android, iOS, and console on Enterprise.
• Artifact storage and distribution, so you are done shipping 100GB builds over Google Drive.

When a build fails, you do not scroll through 2,000 warnings to find the one error that matters. SpeedrunCI reads the logs and suggests fixes, with the file and line to look at.

What changes for the team

A designer can trigger a build to test a level. A producer can see whether the nightly build passed without asking anyone. The build stops being a thing one person owns and becomes something the whole team can reach.

When a build finishes, the artifact is right there to download. A 20 GB console build, no Google Drive link, no waiting on the one person who knows where the builds live.

Try it

The plugin is free on FAB. The service has a free trial, so you can run one of your own builds through it without talking to anyone. Install it, connect your account, and run your first Unreal build in minutes:

1. Install the plugin from FAB.
2. Enable it in your project.
3. Sign in with your SpeedrunCI account.
4. Pick a project preset and trigger your first build.

If your studio still has one person everyone depends on whenever someone asks “Can you make me a build?”, that is the exact thing we built this to fix. Install it, run a build, and tell us what you think.

Week of June 15-21, 2026 | 878 commits analyzed | Branch: ue6-main

Overview

UE 5.8 shipped on June 17 as the last planned major UE5 release, and active mainline development has now moved to ue6-main. The branch switch is the news this week. ue6-main carried 878 commits against ue5-main’s 113, the first genuine divergence in our ledger. Read the diff honestly and week one of UE6 looks less like a clean-slate rewrite and more like incremental re-platforming of the UE5 codebase: the bulk of the work is renderer hardening, build and cook plumbing, and async-loading fixes that would look identical on ue5-main. Nothing here is production-actionable. Early Access is targeted for late 2027, with full release 12 to 18 months after that, so this coverage is forward radar, not a migration prompt. We switched branches because this is simply where the engine is being built now.

TL;DR

• UE6 development is live on ue6-main. Week one is mostly ordinary engine work wrapped around a thin, genuinely-new architecture layer.
• Verse is becoming the gameplay programming layer: VVM heap-correctness fixes, new language semantics (discriminated unions, bitwise ops, closures), and Verse-to-C++ interop wired through UHT.
• A first-party, in-editor MCP server is real and being hardened (chunked streaming, commandlet guards, live URL composition). The AI pillar is shipping as working networked code, not a slide.
• Mass ECS gained replication over Iris (the MassIrisReplication arc), the networking backbone for persistent large-scale worlds.
• The deprecation everyone is reacting to (Blueprints and Actors) has no commit deprecating either one this week. The replacement foundation (SceneGraph, Entity framework, Verse) is landing, but Blueprints still got a week of active fixes. Years out, not months.
• Nothing is production-actionable. This is a 2027+ horizon. If you ship today, you stay on 5.8.

What UE6 Actually Is, So Far

The honest read on week one: UE6 is, for now, an incremental re-platforming of the UE5 codebase rather than a clean-slate rewrite. The vast majority of the 878 commits are routine engine maintenance, the kind of renderer, cook, and loader work that has been landing on ue5-main for years. The branch name is new. Most of the work under it is not.

Epic named three initiatives for UE6: Verse as the gameplay programming model, open standards that make content, code, and economies portable across games and engines, and an AI-driven development pipeline (an MCP layer plus in-engine generative AI via diffusion models). The overarching vision above those is the merge of UE5 and UEFN into one engine. It is worth checking the week’s commits against that announced plan rather than assuming they line up.

Two of the three pillars show up clearly. Verse is being hardened into a first-class gameplay layer: roughly three dozen Verse and VVM commits across the VM and the language, plus the access-control machinery that governs a merged UEFN/UE5 monorepo. The AI pipeline is landing as a first-party Model Context Protocol server, four commits this week, hardened as networked code (the generative-AI half of that pillar produced nothing visible this week). The third pillar, open standards and portability, has no commit footprint yet, which is worth stating plainly rather than glossing: it is the one announced initiative we cannot see moving. The UEFN merge itself is not just a slide: Solaris and Fortnite paths are in-repo and UEFN cook and profiling work is landing alongside engine code. Scene Graph, the new high-level gameplay framework Epic announced, also made its first appearance, in asset-digest commits (5dbc77d8). Add the MassIrisReplication arc and the AutoRTFM toolchain wiring, both read from the commits rather than announced as headline features, and that is the whole of the distinctly-new surface. A few dozen commits in total.

The distinctly-UE6 work is directionally important and architecturally load-bearing, but it is a thin layer riding on top of a large body of ordinary engine churn. One caveat: many of the highest-interest commits are Commit.gitdeps.xml binary-manifest blobs. The commit message is real, but the code lives in Epic’s internal binaries we cannot see, so several claims below rest on a message, not on readable source. We flag those where they matter.

The Blueprints and Actors Question

The loudest reaction to the UE6 announcement is not Verse or AI. It is deprecation. Epic said Blueprints and Actors are both on the way out: the Actor model gives way to SceneGraph and the Entity framework, and gameplay scripting moves to Verse. For a community whose tutorials, Fab assets, and muscle memory are built on Blueprints, that is the headline, and the question under every thread is the same. How soon do I need to care?

The commits give a calmer answer than the announcement does. The replacement foundation is real and landing now: SceneGraph picked up entity-level work this week (a per-entity CanAffectNavigation toggle, 05eb154e, and an asset-digest fix, 5dbc77d8), the Entity framework saw activity (e8c51555), and Verse is being hardened into the gameplay layer as described below. That is the machinery that will eventually stand in for Actors and Blueprints.

But nothing this week deprecates either one. Blueprints, in fact, kept getting active maintenance: crash fixes, agent-facing BlueprintTools work (0b5fb5ad), a Blueprint DSL read-write round-trip (9312dfd5), and module-dependency cleanup. Close to twenty commits touched Blueprint code this week, and not one of them deprecated anything. A system Epic was about to pull would not be collecting a week of fixes. Epic’s own roadmap says early UE6 keeps both Actors and Blueprints, deprecates them only once the replacements mature, and ships conversion tools when it does.

So the honest read for anyone shipping on Blueprints today: the transition is real and the foundation is being poured now, but the commit activity says you have years, not months. Early Access is late 2027, and deprecation comes after that. The panic is running ahead of the code.

The New Layer (UE6-Specific)

Verse Becomes the Gameplay Layer

What changed. The Verse VM and language picked up substantive work this week. A heap-correctness fix corrected NewObject-versus-DuplicateObject behavior in the VVM (74971366), the kind of fix that only matters once Verse objects are first-class engine citizens. The language itself gained semantics: discriminated unions are now VVM-exclusive (40cd7231), bitwise math arrived (561a2f0b), closure and Self capture were addressed (771fd59a), and verse::event delegates landed (23c58057). Verse-to-C++ interop is being wired through the toolchain via UHT support for TVerseFunction (556568ff) and decorated FVerseFunction names (b14aa7ed). Compiler diagnostics are maturing (b6ede72f, fd43d560), including folding non-Verse @deprecated into the diagnostics path (61eda997). The @available and @experimental propagation work continued across modules (c892fe75), and Verse tests are migrating into the engine tree (7dd94112). Notably, CanCallerAccessEpicInternal access-control appeared (44c82bea, bccf67ac): a Verse epic-internal trust boundary that reads as the governance layer for a merged UEFN/UE5 monorepo.

Why it matters. This is the clearest signal of the first pillar. Verse is not being bolted onto the side. The VM is being made heap-correct, the language is gaining the primitives a real gameplay layer needs, and the interop path back to C++ is being formalized. The access-control work, in particular, is what makes one shared codebase across UEFN and the full engine governable.

Who should care. Studios planning multi-year roadmaps who want to understand whether their gameplay code lives in C++ or Verse by the time UE6 ships.

Urgency: Track.

AutoRTFM: Making “Transactionalize C++” Real

What changed. Three small commits, strategically load-bearing. UE_AUTORTFM is now gated behind EpicClang and bUseAutoRTFMCompiler is a build setting (31c208fd), and a ShouldEnableAutoRTFM default was corrected (c8203d63). The transactional substrate (software transactional memory, the mechanism behind the “transactionalize C++” claim) is being wired into the build as a real toolchain dependency.

Why it matters. This is tiny in line count and large in implication. AutoRTFM depends on Epic’s custom compiler, which means external studios will eventually need that compiler in their toolchain to build UE6 with transactional memory enabled. That is a build-system dependency worth understanding early.

Urgency: Track.

A First-Party MCP Server, In the Editor

What changed. Four ModelContextProtocol commits, none of them loud, easy to miss in the week’s volume: chunked Transfer-Encoding streaming (e21014e1), skipping auto-start in commandlets (24e0ba98), dropping the Server affix in favor of live URL composition (300da934), and a guard on the HTTP test spec (5ae33186). Alongside the server, the editor tooling is being designed for agent callers: BlueprintTools was redesigned to be idempotent with self-describing errors built for an LLM caller (0b5fb5ad), an ActorTools.set_parent_component crash was fixed (bdeef4bd), and a Mass editor toolset now lets an agent author configs.

Why it matters. This is the AI pillar shipping as working, networked code rather than a prototype. The detail that matters is the shape of the tooling: idempotent mutations and self-describing errors are what you build when the caller is a model rather than a human. A first-party in-engine MCP server with hardened HTTP transport is a concrete commitment.

Urgency: Track.

Mass ECS Gains Replication (MassIrisReplication)

What changed. A seven-commit arc replicating Mass entities over Iris. It includes INI-driven exclusions, a ReplicateOnce path, a quantized transform net serializer, and the usual correctness, safety, and log-hygiene follow-ups. New framework code plus networking, landing together.

Why it matters. Mass replication over Iris is the backbone for the “persistent large-scale worlds” pitch. Mass already gives you the entity scale; Iris replication is what lets that scale exist on the network. Worth noting: this arc spanned framework and networking changes and was never announced, a fair illustration of how the most important UE6 commits this week sat in the quiet tail, not at the top of the volume chart.

Urgency: Track.

The UEFN Merge Is Real In-Repo

A short note, because it underpins both the Verse and MCP sections. The merge is not aspirational this week, it is in the tree: Solaris and Fortnite paths are present, the UEFN CPU Profiler landed (3d908b3b), and there is concrete UEFN cook and performance work, including a ReparentHierarchies improvement from 31 seconds to 18 seconds (7161346e, 0c0476ce) and a fix excluding non-native Verse classes from incremental cook (205b0219), which was crashing. Incremental export of metadata (533f10a2) and publishing-mutator descriptors from cook (8366092e) also landed. The real measure of merge maturity will be UEFN cook and incremental stability inside the merged repo, and that is now something we can watch commit by commit.

Ongoing Engine Work (On the New Branch, but Not New)

Everything in this section would look identical on ue5-main. It is here for completeness and because it dominates the commit count, not because it signals anything UE6-specific.

Rendering & Performance

Lumen skylight prefilter mip-bias is now default-on (40fbf7d8). TSR re-enabled 16-bit VALU on modern Nvidia hardware (f85b0521). Opacity Micromap reached part two of its D3D12 RHI work (46a4f3f0), and D3D12 static root signatures landed (bf4b30f7). Beyond the feature work, there was the usual crash and correctness churn, plus a telling process signal: the Nanite “one big thread group” rasterizer change went land, backout, backout, re-land across four commits. A fresh development branch churns like this in its first weeks. Read it as process noise, not instability in any feature you would ship on.

Urgency: Track.

Build, Cook & Distribution

BulkDataChunkAssigner gained on-demand, optional, and startup containers sourced from the oplog, and cook-time chunking was disabled in that path. DDC-Verify build-versus-build determinism jobs landed, useful for anyone who cares about reproducible cooks. UBA continued its move onto Wine and Linux (an AlmaLinux-9 UbaWine path plus TCP_MAXRT handling), and UBT can now emit action history as JSON. For studios running build-at-scale and reproducibility-sensitive CI, this is the most directly relevant cluster in the report, even though none of it is UE6-specific.

Urgency: Track.

Stability & Async Loading

ZenLoader picked up real fixes: a circular-flush deadlock was addressed at depth greater than one and again for the already-on-stack case (56610334, 90923462), and hang diagnostics now dump all loading-thread callstacks (95140162). This is genuine C++ and a useful class of fix for anyone who has chased a load-time deadlock. (One note on counting: UAF here is the new Unreal Animation Framework, easy to mistake for use-after-free by name alone. It is not, so the week’s real crash-fix tally is smaller than a keyword scan suggests.)

Urgency: Track.

What You Ship On Now: UE 5.x Stabilization

ue5-main ran 113 commits this week, and it is not dead. Most of it is stabilization for shipping studios: a MetaHuman fix cluster, Sequencer and Anim Mixer regression fixes, Chaos Cloth, and a batch of crash fixes (several cherry-picked to both branches, so they also appear in the ue6-main work above). There was one status graduation: PC GDK plugins moved out of Beta (25e8cfac). UE 5.8 is the last planned major UE5 release, but Epic continues bug-fix and regression support and has said it may add another release if warranted. If you are shipping a game, you stay on 5.8, so from now on we track ue5-main alongside ue6-main: the new branch for where the engine is heading, the old one for the fixes that actually reach the project you ship this year. The UE6 coverage above is forward radar, not a reason to move.

Worth Tracking

The MCP transport is the cluster to watch. This week it gained hardened HTTP framing and live URL composition. The next steps that would matter are authenticated and scoped access plus formal tool definitions appearing in the tree, which is when an in-engine agent moves from “can connect” to “can be trusted with bounded capability.”

Separately, watch the Verse-as-C++-replacement curve: which runtime systems gain Verse-character parity. Chaos Mover already did this week: a mover for Verse characters landed (adb72968), and a temporary editor VerseStateTree was removed (906d87ba). Each system that crosses into Verse parity is a data point on how much of the gameplay layer Epic intends to live in Verse by ship. And keep watching UEFN cook and incremental stability inside the merged repo. That, more than any feature announcement, is the real measure of how far along the UE5/UEFN merge actually is.

What We Ignored

Roughly 700-plus commits of routine work: build hygiene, DDC-to-LegacyDDC renames, include cleanup, MacOS static-analyzer suppressions, Horde CI plumbing, and the usual Perforce backout and stomp noise (around 11 backouts this week). None of it affects direction. One caution, though: on a fresh branch, low volume is not low importance. The most consequential UE6 work this week (Verse, Mass replication, MCP) was quiet, the kind of thing a fast skim files as noise. It rewards reading every commit, not just the loud ones.

Closing

UE6 is a 2027 story, and from this week on we will follow it commit by commit from week one. We are not leaving ue5-main behind either. As long as studios are shipping on 5.x, we will keep tracking its maintenance branch alongside ue6-main, so this report serves both the game you ship this year and the engine you build on next.

Commit SHAs are cited inline, in parentheses, next to each claim. They reference the ue6-main branch of EpicGames/UnrealEngine (GDK is also on ue5-main). Many of the highest-interest entries resolve to Commit.gitdeps.xml binary-manifest blobs: the commit message is real, but the code lives in Epic’s internal binaries, which we cannot see.

Epic open-sourced Lore at State of Unreal. It’s a version control system built for game-scale projects: written in Rust, MIT-licensed, and already running in production as the VCS inside UEFN, where it used to be called Unreal Revision Control.

The headlines wrote themselves. Free, open source, Perforce killer. The reality is more useful than that, and more complicated. Here’s a straight read for studios actually deciding whether to care: the good, the bad, and the costs nobody’s putting in the celebration posts.

The good

Start with what’s genuinely strong here.

• It’s built for binaries. Files are content-addressed and chunked, so editing a few KB inside a multi-GB asset only moves the changed chunks. That is exactly what Git and Git LFS are bad at, and it’s the core reason studios pay for Perforce in the first place.
• It’s free, with no per-seat fee. MIT-licensed, use it however you want. For a studio paying Perforce by the user account (including the bot and integration accounts that quietly add up), that’s a real line item gone.
• Sparse, on-demand checkouts. You pull only the parts of the repo you need instead of syncing the whole terabyte tree. Good for large projects and faster onboarding.
• It works offline. Branching, diffing, and history inspection all work without the server. Perforce can’t do that.
• Access control is built in. Each repo is its own partition and acts as an access boundary, so contractors and NDA’d work can be scoped cleanly. Knowing a file’s hash isn’t enough to pull it.
• It’s Epic, and it’s battle-tested. It has been running under Fortnite and UEFN at scale for years, so it arrives with a track record most version control launches never get. That pedigree is worth something.

The bad

What the launch posts skip.

• It’s a pre-1.0 release. Epic says the storage formats are forward-compatible, but the APIs and protocols can still change before 1.0. You’d be adopting a moving target.
• Locking is informational only. This is the big one, and it’s for the exact teams Lore is meant to serve. A lock tells your teammate you’re editing a file. It does not stop them from editing it too. For binary assets you can’t merge, that collision is the whole problem, and Lore doesn’t solve it yet. Enforced locking is on the roadmap, not in the box.
• No Unreal Editor plugin until 2027. Most artists live inside the editor. Today Lore is a CLI and an API, with a VS Code plugin planned. The in-editor workflow your art team needs is over a year out.
• Unproven outside Fortnite. It scales for Epic. Whether it scales for your team size, your asset mix, and your infrastructure is untested in the wild on this open release.

The hidden costs

Here’s what “free and open source” quietly leaves out.

• Someone has to run the server. Lore is centralized and self-hosted, with a single source of truth. You provision, scale, secure, and back up that server yourself. If you left Perforce partly to stop babysitting a server and a P4 admin, read that sentence again. You’d be trading a Perforce license fee for the cost of running infrastructure: ops time, a cloud bill, backups, someone on call when it breaks. That cost is real, and plenty of teams underestimate it.
• The open version and the Fortnite version aren’t the same yet. The open-source Lore and the hosted Lore inside UEFN currently use different compression formats. Epic plans to converge them (moving to Zstandard) in 2026. So “the thing Fortnite runs” and “the thing you can self-host today” are not the same build.
• Open source doesn’t mean community-run. This is Epic’s project, on Epic’s roadmap, built for Epic’s priorities, which are Fortnite and UEFN at massive scale. If your studio’s need isn’t on that list, it isn’t arriving because you asked. As one example, the roadmap has no CI/CD or build-integration items on it at all.
• Migration is a real project. Moving a studio’s full history off Perforce or Diversion takes planning and time, and Lore’s model works differently (immutable history, no force-push, no rewriting). Budget for the migration itself, well beyond the install.

So should you move?

Depends on where you’re standing.

• On Perforce and sick of the cost and the upkeep: worth a pilot on a non-critical project. Not worth migrating production yet. Wait for enforced locking, the editor plugin, and a 1.0, then reassess. Those are the three things to watch.
• On Diversion or another managed VCS: be clear about the trade. Diversion is managed cloud. Lore is self-hosted, do-it-yourself. You’d be swapping a vendor’s operations for your own. For a team that wants that control, it’s a fair deal. For most, it’s a step backward in convenience.
• Small team on Git or Git LFS and not actually hurting: stay. Lore solves a problem you may not have yet.
• Already deep in UEFN: you’re effectively using it already, and the native path is the obvious one.

The honest summary: Lore is the most promising open version control to land in game dev in years, and it is not ready to be your studio’s production VCS this week. Start a pilot. Watch the roadmap. Don’t rip out Perforce on launch-week enthusiasm.

One thing worth flagging for anyone who cares about build times, since version control is where every build starts. The most interesting part of Lore long term is quieter than the check-in workflow. A content-addressed system knows, by hash, exactly what changed between any two revisions. That’s the signal a build system needs to rebuild only what changed instead of trusting file timestamps. None of that is wired up today, and Epic hasn’t said it’s coming. But it’s the reason we’re watching Lore closely, and it could matter more for your pipeline down the road than for your daily commits.

Week of June 8 to 14, 2026 | 770 commits analyzed | Branch: ue5-main

Overview

This was an infrastructure week, dominated by two themes: Epic building first-party agentic tooling into the editor, and a broad cleanup of the build system. There was no flagship rendering feature, but several quiet correctness fixes in the distributed-build path are more consequential than they look. The 22 backout commits and an active mix of gameplay-systems work suggest a week of churn rather than a clean landing.

Development Trends

Editor AI Tooling: From AI Assistant to First-Party MCP Platform

Pattern: This is the fifteenth consecutive week of editor-AI work, and the first where it shows up as a named editorial theme on its own (“AI & Editor Tooling”). The editor subsystem reversed its multi-week slide, jumping from 40 to 81 commits week-over-week, largely on the back of roughly 30 commits across the Model Context Protocol and editor-toolset layer: MCP servers with stdio transport, an asset-tools layer that now resolves Unreal virtual paths, a CheatsToolset plugin, EditorAppToolset tools, per-toolset analytics with tool-hash mapping, a UnrealConsole -mcp mode, and a pre-release “Unreal Toolbox” app. The AI-in-editor theme also appeared in the Apr 13 and Apr 27 weeks; the line back to the original AI Assistant work is unbroken.

Interpretation: Epic appears to be productizing LLM-driven editor automation as first-party infrastructure rather than an experiment. Prior weeks were about wiring the AI Assistant into Python and Blueprints. This week the energy moved to a standalone MCP layer with its own transport, analytics, and an external app. The path-resolution and snap-to-ground hardening suggest it is being tested against real editor behavior, not just demoed. Shipping an external Toolbox app on a pre-release channel is how you start preparing something for distribution.

Who cares: Tools teams, technical artists, studios evaluating in-editor automation, and anyone building their own MCP integrations against the editor.

Signal strength: Strong. 15 weeks of continuity, with a clear escalation in scope this week.

Build Infrastructure: Quiet Post-Cut Hardening Continues

Pattern: Build commits fell again, from 66 to 50, the lowest in the tracked eight-week window and a long way down from the 251 peak the week of May 17. But the character is consistent with the last several weeks: not features, but correctness and policy. UnrealBuildTool gained a full per-toolchain, per-warning control surface in BuildConfiguration.xml; UBA absorbed an AB-BA lock-ordering deadlock fix in its CAS store; and Epic reverted a prior merged-modules “faster build times” change in favor of serial DLL linking. This extends the build infrastructure trend to roughly nineteen weeks.

Interpretation: Falling volume alongside continued reliability work fits a branch that has already been cut and is now being made reproducible and safe to build at scale. The merged-module revert quietly admits that path had problems. The UBA deadlock fix likely resolves intermittent hangs that distributed-build teams had written off as flaky infrastructure.

Who cares: Build engineers, CI compile-config owners, warnings-as-errors teams, and anyone running UBA at scale.

Signal strength: Strong. Sustained for about 19 weeks, now firmly in low-volume polish mode.

Ray Tracing Productionization: Cross-Vendor and Cross-Renderer Reach

Pattern: Sixteenth week of the ray-tracing modernization arc. Last week removed the r.RayTracing.EnableOnDemand cvar (RT default-on); this week the work pushed outward in two directions. Chaos Cloth components became ray-tracing-visible, so simulated cloth now contributes to RT reflections, RT shadows, and Lumen HWRT, closing a known gap. And NVIDIA shader-extension headers were made SPIR-V-safe with platforms now able to inject their own RT hit-group functions, plus Opacity Micromap support landed as “Part 1” in the D3D12 RHI.

Interpretation: After promoting on-demand RT to always-on last week, the effort this week is about reach: making HWRT portable beyond NVIDIA and D3D12 (the SPIR-V and hit-group injection work) and pulling more of the scene into the RT path (cloth). This is consistent with treating RT as production infrastructure rather than a high-end opt-in. Opacity Micromaps remain early.

Who cares: Graphics engineers shipping HWRT, multi-platform teams on Vulkan/SPIR-V, and teams with dynamic cloth in RT scenes.

Signal strength: Strong. 16 weeks, though this week’s RT volume is moderate.

Pre-Release Stability Sweep: Steady Crash Hardening Amid Churn

Pattern: Thirteenth week of the named stability theme. A run of genuine crash and safety fixes landed across gameplay and media systems (skin-weight slider, Mass representation traits, StateTree transition null deref, LearningAgents NaN assertion, Media IO interlace switch, PRT NaN/Inf JSON export), plus two thread-safety fixes and two OpenXR swapchain crash fixes. Set against 22 backout commits this week, the picture is a release line still working through instability rather than a clean landing.

Interpretation: The fixes cluster around active gameplay-systems work (Mass, StateTree, Mover), which suggests those systems are getting attention and a steadier base at the same time. The 22 backouts are the counter-signal: this was a churny week, not a settled one. Consistent with a maturing release line that is still absorbing change.

Who cares: Teams on Mass, StateTree, Mover, LearningAgents, Media IO, or OpenXR; anyone tracking ue5-main stability before upgrading.

Signal strength: Strong on continuity (13 weeks), moderate on this week’s specific intensity.

TL;DR

• Epic is assembling a real Model Context Protocol (MCP) layer inside the editor, around 30 commits across MCP servers, asset tools, a CheatsToolset, an “Unreal Toolbox” app, and per-toolset analytics. This is first-party LLM-driven editor automation, and the velocity says it has moved past prototype.
• UnrealBuildTool gained a full compiler-warnings control surface in BuildConfiguration.xml (per-toolchain, per-warning), and UBA absorbed an AB-BA lock-ordering deadlock fix in its CAS store, plus a revert of the merged-module link path. If you run distributed builds at scale, this is the most actionable group of the week.
• Nothing this week forces an upgrade. The MCP direction is the thing to watch; the build fixes are the thing to act on if they touch you.

Highlights

🔥 Rendering & Performance

What changed: Substrate Toon shading continued to be built out: matching toon shadow and transmittance across CSM and VSM, streaming-aware ToonProfile textures, cubemap and matcap support, and baking indirect specular into a LUT. A first-pass AmbientLightingVolume system also landed (new shaders, a component visualizer), a tiled-culled ambient lighting primitive that currently only affects diffuse on the non-Lumen path and is explicitly marked for testing. On the ray tracing side, Chaos Cloth components became ray-tracing-visible, so simulated cloth now contributes to RT reflections, RT shadows, and Lumen HWRT. Opacity Micromap support landed as “Part 1” in the D3D12 RHI, and NVIDIA shader-extension headers were made SPIR-V-safe with platforms now able to inject their own RT hit-group functions. Lumen irradiance-field clipmaps bumped to six.

Why this is important: The Substrate Toon work confirms NPR and stylized rendering as a first-class Substrate target rather than a side path. AmbientLightingVolume is an early-experimental signal of where mobile and non-Lumen GI is heading. The cloth RT change closes a known gap, since dynamic cloth was previously missing from RT scenes. (The cross-vendor RT story is covered in Development Trends above.)

Who should care: Graphics engineers shipping HWRT, multi-platform teams (especially Vulkan/SPIR-V), and anyone on stylized or NPR projects.

Urgency: Track. AmbientLightingVolume and Opacity Micromaps are early. The cloth RT change is low risk and worth picking up if you have cloth in RT scenes.

🔧 Build & Tooling

What changed: UnrealBuildTool now exposes every compiler warning through BuildConfiguration.xml and the command line. The monolithic warnings config was split into per-toolchain files (Clang, ClangVC, Intel, MSVC, Performance), replacing per-module flags with a single declarative surface. A header-units toggle was added to BuildConfiguration.xml, and an Intel-toolchain -Wno-error= token bug was fixed. New PreCleanSteps and PostCleanSteps hooks plus a -CleanGenerated flag improve CI build hygiene. On the distributed side, UBA absorbed a fix for an AB-BA lock-ordering deadlock in its CAS store (two locks taken in opposite order under heavy load), which had been surfacing as intermittent hangs on large UbaNinja builds. Epic also reverted a prior merged-modules “faster build times” change and forced merged-module DLL links to run serially.

Why this is important: The warnings overhaul gives build and CI teams one place to define a warnings policy instead of scattering flags across modules. The UBA deadlock fix likely explains hangs that have been written off as flaky infrastructure. And if you turned on merged modules for build speed, the revert is worth knowing about before you upgrade.

Who should care: Build engineers, CI compile-config owners, warnings-as-errors teams, and anyone running UBA or large distributed builds.

Urgency: Act now if you maintain a custom warning policy, a CI lint gate, or run UBA at scale. Track otherwise.

🤖 AI & Editor Tooling

What changed: Epic landed coherent work on an in-editor asset-tools layer driven by Model Context Protocol. Asset tools now resolve Unreal virtual paths (/Game/..., /PluginName/...) instead of mis-mapping to filesystem roots, gained a reload_asset tool, and actor placement got snap-to-ground robustness plus a “placement skill” that teaches the agent when to snap. Around that core, the surface accreted across many authors: a CheatsToolset plugin that lists and calls cheat-manager commands, EditorAppToolset tools for notifications, cached thumbnails and viewport show-flags, MCP client and proxy fixes, stdio transport for local MCP servers, an “Unreal Toolbox” app on a pre-release channel, per-toolset analytics with tool-hash mapping, and a UnrealConsole -mcp mode. Verse VM also renamed its llm_* metadata to ai_*.

Why this is important: The virtual-path resolution and snap-to-ground fixes are the practical part. They mean the agent now addresses assets and places actors the way a human tools engineer would, which is the difference between a demo and something a technical artist can actually drive. (For the multi-week direction read on this workstream, see Development Trends above.)

Who should care: Tools teams, technical artists, and anyone tracking Epic’s AI-in-editor direction.

Urgency: Track closely. Nothing to integrate yet, but this is the workstream most likely to change how editor automation looks in upcoming releases.

🛟 Stability & Fixes

What changed: A run of genuine crash and safety fixes landed across gameplay and media systems: a skin-weight slider crash on commit, a Mass representation-traits crash when no representation subsystem is present, a StateTree null deref in transition pin calculation, a LearningAgents NaN assertion in flow-matching inference, a Media IO assertion when switching interlace and progressive, and a PRT export change to write NaN/Inf as null instead of crashing on JSON export. Two thread-safety fixes also landed: Mover concurrency control over its Rollback Blackboard, and an input device hardware delegate now always executing on the game thread. Two OpenXR swapchain crash fixes and an AnimatorKit deformer race-condition fix round it out.

Why this is important: Each of these quietly removes a reproducible crash from production workflows. The Mass, StateTree, and Mover fixes cluster around active gameplay-systems work this week, so projects on those systems should expect a steadier base.

Who should care: Teams on Mass, StateTree, Mover, LearningAgents, Media IO, or OpenXR.

Urgency: Low. Pick these up on your normal integration cadence.

Worth Tracking

A dedicated input polling thread is taking shape but is off by default. Two commits plus a backout add an input.UseInputThread CVar and a dedicated thread for polling input devices, landing alongside work that removes the game-thread requirement on device connections and adds Unreal Insights CPU trace scopes to the input thread. Adding trace scopes means Epic plans to profile and tune this thread, not throw it away. That makes it a latency play. Watch whether the CVar default flips in a future release.

Two quieter items are worth a line each. A “progressive navdata” navigation cluster (background coverage scan plus per-tile state tracking) uses terms that are not standard shipped UE vocabulary, which suggests an in-progress streaming or adaptive navmesh system rather than maintenance. And the AI tooling trajectory above is the broader thing to keep an eye on: MCP, Unreal Toolbox, AI Assistant, and LearningAgents were all active in the same week, which reads as a sustained workstream rather than a one-off experiment.

What We Ignored

This week we ignored roughly 29 commits, mostly related to formatting, minor refactors, editor UI cleanups, and localization. Worth noting for context: the 22 backout commits this week are themselves a signal of an unstable stretch on ue5-main, and a cluster of around 20 “UAF” commits is Unreal Animation Framework work, not memory-safety fixes, despite the acronym.

Closing

No fireworks this week, but the build-system fixes will save someone a debugging afternoon, and the editor AI tooling is the trend worth reading early. We read every commit so you do not have to.

We read every commit on ue5-main so you don’t have to. Last Week in Unreal is published weekly by SpeedrunCI, CI/CD built for Unreal Engine teams.