Skip to main content

Roadmap

Last update: 14.10.2026

The tasks in this roadmap are listed roughly in the order we plan to work on them. If you urgently need one of these problems solved, or you need a feature that isn't on the roadmap, contact us via email or Discord to discuss custom development.

1. More examples in the ErrantPathsAssetLibrary​

We'll be adding more examples to the Asset Library to showcase existing plugin features. This includes more variants of the asphalt roads, with different intersections, transitions between the 1-, 2- and 3-lane variants, additional turn lanes and more.

New examples we plan to add include a subway, various highway intersections and interchanges, bridges, pipelines, dirt trails, and more fences and walls.

We'll also keep developing each of the existing Path types, adding detail and automation. For the existing roads, this means elements such as road signs, lamp posts, decals and graffiti.

Most importantly, we plan to move beyond placeholder meshes and textures and provide game-ready, high-quality assets.

2. MultiPointSplineMesh​

When adding meshes to a PathTemplate, we sometimes want to place long meshes that span the entire template. This is especially common in intersections, where lane markings often need to run across the whole intersection and bend together with the asphalt meshes underneath.

Unfortunately, Unreal's SplineMeshComponent has only two control points, which makes it impractical for this scenario. We need a mesh that supports any number of control points and repeats along the spline. These control points can then be anchored to the meshes underneath so that the mesh bends correctly.

This feature will also require additional UI and visualizations.

3. Bendable intersections​

Intersections can already be bent using the main and secondary PathSplines. However, there are no tools or visualizations that let you control how each part of the intersection bends with a given PathSpline (blend weights, similar to skinning weights in skeletal animation). Blend weights are currently calculated with a simple distance-based heuristic, which isn't sufficient.

We plan to add tooling for painting skinning weights onto the components of an intersection, so that these components move and bend together with the selected PathSplines.

We also need ways to ensure that certain parts of the intersection stay attached to each other. For example, a curb on a street corner shouldn't fall apart when you change the shape of the intersection. This is the same problem we need to solve to improve Smart Scaling, where parallel meshes need to stay connected as the Path gets wider or narrower.

4. Improving Smart Scaling (variable-width Paths)​

Errant Paths 1.2 added support for scaling Paths with spline point scale. However, bending parallel SplineMeshes often creates gaps between them, because we only control their start and end points and have limited control over their curvature in between. We plan to keep investigating solutions to this problem.

5. City streets​

We plan to improve Errant Paths for building city streets. Unlike roads in open terrain, city streets often have precisely defined dimensions that must match the surrounding buildings, sidewalks and squares. This requires more precise control over the width and placement of the Path and its components.

6. Workflow improvements​

  • A tool for generating all Paths in the map, or within a region, that automatically saves progress during the process.
  • The ability to assign SpawnConditions to multiple components at once.

7. Performance improvements​

Long Paths currently take too long to generate. We have several optimizations planned, including:

  • Multi-threaded spawning
  • Regenerating only the part of the Path the user modified (when adjusting a spline)
  • General streamlining and optimization of the code

8. Advanced Path Labels that affect landscape/biomes/width/tilt and much more​

Path Labels, used for conditional spawning, can currently have only two states at any position along a Path: true or false. This limits them to binary choices. We'd like to support storing any kind of data in Labels, including floats and custom structures, and to let you customize how a Label is visualized and edited depending on the data it stores.

With these improvements, Labels would become a universal way to control every aspect of a Path, including its width, landscape adjustment, tilt/roll, the number of spawned objects, dirt, snow and much more.

9. Integration with PCG​

We plan to integrate with PCG at various stages of Path generation.

10. Pathfinding​

Pathfinding already exists, but it is disabled by default (in Editor Preferences) because its performance, reliability and user interface aren't good enough yet. We plan to significantly improve all three.

11. Dividing HISMs into smaller components for better culling​

Within a SubActor, we currently group all instances of a StaticMesh into a single HISM (Hierarchical Instanced Static Mesh Component), even when the instances are very far apart. This produces large HISMs that may not work well with culling and other rendering optimizations. We plan to introduce a mechanism that groups only meshes that are close to each other.

12. Spawning/placing Paths at runtime (in-game)​

As part of our effort to make all of our plugins work at runtime, Errant Paths will undergo architectural changes that allow Paths to be spawned during gameplay.

13. Using different mesh variants depending on the Path shape​

On curvy Paths, SplineMeshes are sometimes overstretched, which looks unnatural. We plan to add a SplineMesh and StaticMesh type that holds several variants of the same mesh for different shapes (straight, 90° left turn, 45° right turn, etc.). Errant Paths would then pick the variant that best matches the spline's curvature, avoiding overstretching.

14. Better placement of UI for conditional spawning in PathTemplate blueprints​

Currently, to edit a mesh's spawn condition, you need to click the actor in the PathTemplate blueprint, which displays the list of spawn conditions in a separate UI panel. We would prefer to show these conditions in the mesh's Details panel or directly in the viewport. We haven't found a way to do this yet, but we'll keep working on making this UI more intuitive.

15. Auto-conversion of straight-line spline-meshes to static-meshes​

Spline-meshes that end up straight after spawning can be replaced with static-meshes without any loss of visual fidelity. This improves the rendering performance of Paths, because static-meshes are cheaper to render than spline-meshes.

Errant Paths already performs this conversion automatically when spawning meshes, but currently only for meshes with no attached children. We plan to extend it to meshes with children.

Note that this feature is disabled by default. To use it, enable it both in the Path properties and in the PathTemplateStaticMesh/PathTemplateSplineMesh properties.

16. Complex Paths - combining multiple Paths into one​

We'd like to support combining different Path types into a single Path type. For example, the "Asphalt", "BikeLane" and "SideWalk" Paths could be combined into a single "Street" Path.

This can already be achieved with Dependant Paths, but we'd like to explore the idea in much greater depth.