WorldSweep is a batch script execution framework for Unreal Engine 5 editor workflows. It divides your world into cells, streams each one in turn, runs your scripts against every loaded actor, then unloads and advances. The result is a memory-safe pipeline for large-scale world operations that would otherwise mean loading the whole map or writing streaming boilerplate by hand.

It handles three world architectures and detects which one you have automatically: World Partition (a configurable cell grid over the sweep area), Streaming Levels (each sub-level is a cell), and flat single-level maps (one pass over everything). The same batch asset runs unchanged on all three.

Whether you are validating actor placement, auditing asset references, fixing data in bulk, or profiling cell load times, WorldSweep absorbs the streaming complexity so your script only has to answer one question: what do you want to do with this actor?

KEY FEATURES

FLEXIBLE SCRIPT SYSTEM

• Subclass UWorldSweepScript in C++ or Blueprint. No engine modification required.

• Full BlueprintNativeEvent pipeline: OnBatchStarted, OnPreCellLoad, OnCellStarted, OnActorFound, OnComponentFound, OnCellCompleted, OnBatchCompleted, HasFailed

• EventFlags bitmask (CellEvents, Actors, Components) lets each script opt into only the events it needs. A pass where no script wants actors never streams a single cell.

• Per-script actor tag filtering via ActorTagFilter

• Per-script Priority: scripts sharing a priority sweep the world together in one pass, while different priorities run as sequential full sweeps

SMART CELL ITERATION

• Configurable cell size, defaulting to 25600, the standard World Partition streaming cell

• Per-batch actor class filter (ActorClassFilter) to narrow iteration to relevant types

• Data Layer aware: respects the Data Layers panel visibility state, so actors in disabled layers are excluded with no extra configuration

• Garbage collection after each cell unload, so memory does not accumulate across a large map

• Built on FWorldPartitionReference and FWorldPartitionHelpers::ForEachIntersectingActorDescInstance, the actor-descriptor streaming API that is stable from UE 5.4 through 5.8

• Actors are deduplicated across cells, by GUID for streamed actors and by identity for persistent-level actors, so nothing is processed twice at a cell boundary

SAFE BY DEFAULT

• Dry run first. Every built-in script that modifies data has a bApplyChanges toggle that defaults to off, so you see exactly what would change before anything does.

• The entire batch is wrapped in a single transaction. One Ctrl+Z undoes the whole run.

• Optional auto-save of packages your scripts dirtied, with automatic source control checkout when a provider is active. Packages that were already dirty before the run are left alone.

• Cancel at any point from the progress dialog.

EDITOR INTEGRATION

• Dedicated dockable panel registered with the Level Editor tab manager, so it sits alongside the World Partition Editor and Data Layers like a native panel

• Interactive map view: drag to select the sweep area, mouse wheel to zoom, right drag to pan, hold Shift to snap the selection to the cell grid. Shows world bounds, the cell grid, currently loaded regions, and live cursor coordinates.

• Manual coordinate entry plus a "Use Entire World" button that derives full bounds, including persistent-level actors placed outside the World Partition grid

• Cancellable progress dialog with per-pass and per-cell tracking

• Dedicated LogWorldSweep category and a WorldSweep listing in the editor Message Log

• Toast notifications for misconfiguration, so mistakes are hard to miss

HEADLESS EXECUTION FOR CI/CD

• Ships a WorldSweep commandlet that runs any batch without opening the editor UI

• Uses the same batch assets you built and tested interactively, with no changes

• Exit codes designed for build pipelines: 0 success, 1 bad arguments, 2 cancelled, 3 a script reported failure via HasFailed, so an audit violation can fail your build

SEVEN BUILT-IN SCRIPTS

Ready to use out of the box, and each one doubles as a reference implementation.

• Actor Logger: logs every actor found per cell, with optional world location. The simplest starting point for your own scripts.

• Actor Replacer: swaps all actors of one class for another, preserving transform and optionally tags and label. Collected per cell and applied after iteration so the iterator is never invalidated.

• Collision Profile Setter: audits or applies a collision profile across every primitive component in the world.

• Naming Convention Checker: validates actor labels against a regular expression and reports every violation.

• Nanite Auditor: audits or toggles Nanite on static meshes, deduplicated by asset path so each mesh is evaluated exactly once no matter how many actors use it.

• Null Mesh Auditor: finds Static Mesh and Skeletal Mesh components with no mesh assigned, a common source of invisible geometry.

• Cell Load Timer: measures per-cell load times and reports min, max, and average on completion.

USE CASES

• Validation pipelines: scan every actor in a shipped open world for data integrity before release, and fail the build automatically if anything is wrong

• Asset auditing: find every actor referencing a deprecated asset, across hundreds of cells

• Bulk fixes: locate and correct outliers, such as lights above a brightness threshold, in a single reviewable pass

• Standards enforcement: apply naming, collision, or Nanite conventions across a world touched by many people over time

• Performance profiling: measure cell load times to find slow regions before they become runtime streaming hitches

• Build preparation: tag or modify actors by custom rules as a pre-build step

TECHNICAL DETAILS

• Engine versions: UE 5.4, 5.5, 5.6, 5.7, 5.8. One build per version.

• Platform: Windows (Win64)

• Type: editor only. Single Editor module, excluded from packaged builds, no runtime cost, no network replication, no content.

• Blueprint support: full. UWorldSweepScript and UWorldSweepBatch are entirely Blueprint-accessible, so scripts can be authored, configured, and extended without C++.

• Module dependencies: Core, CoreUObject, Engine, Slate, SlateCore, AssetRegistry, InputCore, LevelEditor, MessageLog, Projects, PropertyEditor, SourceControl, ToolMenus, UnrealEd. All standard engine modules.

• No third-party dependencies.

Note on Blueprint scripts: because WorldSweep is editor only, a Blueprint subclass of UWorldSweepScript is a content asset whose parent class does not exist in a packaged build. Keep batch and script assets in a directory excluded from cooking, and make sure nothing that ships references them.

Full documentation: https://toamig.com/Plugins/WorldSweep/