True 3D pathfinding for Unreal Engine 5

See 3D pathfinding running in UE5

A showcase of volumetric navigation, flying AI pathfinding, Mass Entity crowds and tactical 3D EQS inside Unreal Engine 5.

Why Unreal Engine's navmesh can't do 3D pathfinding

Recast, the navigation system that ships with Unreal Engine 5, voxelizes your level and then extracts the walkable surfaces from it — the result is a set of polygons draped over the floor. That is exactly the right representation for a soldier, and completely the wrong one for a dragon. A flying AI has no floor to walk on, so a Recast navmesh gives it nothing to query.

The usual workarounds all leak. Raycast-and-steer looks fine in an open field and gets stuck the moment there is a concave building. Hand-placed waypoint graphs are expensive to author and go stale the instant a level artist moves a wall. Stacking navmeshes at several altitudes turns 3D navigation into a set of disconnected 2D floors, and still can't route diagonally through a shaft.

Volumetric navigation solves it properly by inverting the question. Instead of storing where geometry is, it stores where it isn't, in a Sparse Voxel Octree — and pathfinds through that empty volume in full 3D.

How volumetric 3D pathfinding works

A Sparse Voxel Octree of the empty space

Drop a single LcmNavigationManagerSVO actor into the level and it owns the octree, the pathfinder and every query. The manager subdivides the playable volume only where geometry actually exists: a wide-open sky becomes a handful of large nodes, while a cluttered hangar interior subdivides down to the minimum voxel size. Cost therefore tracks how busy your level is rather than how big it is. Voxelization runs on the GPU with an automatic CPU fallback, and the defaults — a 100 cm minimum voxel inside a 200 m world cube — are tuned to be sane on a first build.

Three pathfinding solvers, three smoothing modes

Pick the trade-off that fits the agent: A* for raw throughput, Theta* for true any-angle routes that cut the corners a grid would force you around, and Lazy Theta* for near-Theta* path quality at close to A* cost. Then choose smoothing — Raw, Linear Shortcut or Curved Spline — each validated against level geometry, so a smoothed path never slices through a wall.

Macro / micro routing and infinite worlds

Long-distance routes solve coarsely across chunks first, then finely within them, which keeps a cross-map flight from paying full-resolution search cost end to end. Finite worlds build their octree once at BeginPlay; infinite worlds stream chunks in around agents and discard them behind, so open-world 3D navigation in UE5 stays inside a fixed memory budget.

Dynamic obstacles that restamp

Moving geometry writes its own footprint back into the octree as it travels, so lifts, blast doors, destructible cover and patrolling capital ships all change routing live — and in multiplayer that change is multicast to every peer.

Infinite worlds, not a bounded volume

Almost every volumetric navigation implementation for Unreal — including the open-source ones — starts by asking you to place a bounds volume and builds its octree inside it. For an arena or a level-sized map that is perfectly fine, and LCM 3D Navigation AI supports exactly that model: a finite world builds once at BeginPlay and stays put.

It stops being fine in an open world. A bounds volume has to be big enough to contain everywhere an agent may ever fly, memory scales with that box whether or not anything is happening inside it, and the moment your player crosses the edge, navigation simply ends.

Infinite mode removes the box. Navigation chunks stream in around agents and are discarded behind them, so memory stays flat no matter how far the map extends — the same reason you stream level geometry rather than loading a continent. Long routes use macro/micro routing: the path solves coarsely across chunks first and finely within the chunk the agent is actually in, so a cross-map flight never pays full-resolution search cost end to end.

That combination — unbounded streaming navigation with hierarchical routing on top — is what makes 3D pathfinding usable in an open-world or World Partition project rather than only inside a hand-placed box.

Pathfinding is the easy half

A pathfinding plugin hands you a list of points. Turning that into an agent that flies convincingly, is authored by your AI designers, scales to a crowd and survives a multiplayer session is the rest of the work — and in practice it is where the integration time actually goes. That gap is what LCM 3D Navigation AI is built to close.

Flying AI, drones, submarines and space combat

Anything that moves through a volume rather than across a surface is a candidate for 3D pathfinding in Unreal Engine 5:

Works with every Unreal Engine AI system

Whichever way your team authors behaviour, the same navigation data is available through three surfaces:

• Behaviour Tree — drop-in tasks, decorators and services including FlyTo, line-of-sight and chunk-loaded checks, with seven documented stock-node patterns showing where an LCM node earns its place over an engine one.
• StateTree — the identical flight behaviour authored as StateTree tasks, so state-driven agents get the same routing with no Behaviour Tree in the stack.
• Mass Entity (ECS) — two traits, per-agent asynchronous pathfinding or a shared CPU flow field sampled in O(1) by an entire swarm, driven by three auto-registered processors for request, solve and steer. You never call the solver yourself.
• Tactical 3D EQS — generators and tests that score real volume: volumetric line-of-sight, cover, threat exposure, height advantage and true path distance, so a sniper perch is chosen in 3D rather than on a floor plane.
• AI Perception and the Gameplay Debugger — threat tracking, nav links, area modifiers and a live in-editor debugger for inspecting the octree and solved routes.

Everything is exposed to Blueprint: 517 reflected symbols, every one carrying a tooltip, so a complete flying AI can be built without opening Visual Studio. The C++ API is there when you want it.

Server-authoritative multiplayer 3D navigation

Clients request a route, the server solves it and delivers it back through Client_DeliverPath, and moving obstacles replay their navigation footprint to every peer over a multicast. CPU compute is bit-deterministic, which keeps replays and lockstep viable, and a headless validation suite (-LcmMpTest) exercises the sanity, replicated-request, multicast-transport and digest-chain paths so regressions surface in CI rather than in a playtest.

Shipping-ready on Windows PC, PlayStation 5 and Xbox Series X|S, with the C++ core held to the same standard on every target. Nintendo Switch support is in progress.

Adding 3D pathfinding to a UE5 project

1. Install the pluginAdd LCM 3D Navigation AI from Fab to your Unreal Engine 5.2–5.8 project and enable it in the plugin browser. Installation is chapter 1 of the manual.
2. Place the navigation managerDrop one LcmNavigationManagerSVO into the level and set the world bounds and minimum voxel size. It builds the Sparse Voxel Octree and owns every navigation query from then on.
3. Give the agent a bodyAdd LcmFlightMovementComponent to the pawn and pick an archetype — Multirotor, Bird, Fish or Generic 6-DOF — then tune thrust, lift, drag, buoyancy and the attitude PID. An animation-drive struct feeds your blendspaces.
4. Author the behaviourUse the FlyTo Behaviour Tree task, the equivalent StateTree task, or a Mass trait for crowds. Chapter 3 of the manual walks through a first flying agent end to end.
5. Scale upAdd dynamic obstacles, tactical 3D EQS queries, hybrid Recast levels for ground units, and switch to infinite chunked worlds when the map outgrows a single volume.

Documentation is a 128-page manual across 17 chapters, not a plugin dump: every setting is listed with its verified default and limits, and every reflected symbol is documented. Read the full documentation online →

Specifications