Back to Blog
    Last Week in Unreal

    Last Week in Unreal: Epic Ported Its Agent Tools With an LLM (September 21 to September 27, 2026)

    Venkat S25 min read
    Last Week in Unreal: Epic Ported Its Agent Tools With an LLM (September 21 to September 27, 2026)

    Unreal Engine Weekly: Epic Ported Its Agent Tools With an LLM

    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.

    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.

    Share this article

    Keep Reading