PCG Has Grown Up

When Epic first introduced the Procedural Content Generation (PCG) framework in Unreal Engine 5.2, it was promising but rough. The node-based graph system could scatter meshes and modify landscapes, but it required significant technical knowledge, lacked artist-friendly controls, and had real performance limitations at scale.

Three years and several engine releases later, UE 5.7's PCG framework is a different tool entirely. The core graph system is more performant, the node library has expanded dramatically, and the addition of the Procedural Vegetation Editor provides a visual, art-directable interface that doesn't require touching a single graph node for common vegetation workflows.

This post covers what changed in 5.7, how to use the new vegetation tools, and a step-by-step outline for building a production-quality forest biome using PCG.

What Changed in 5.7

The Procedural Vegetation Editor

This is the headline feature and the reason PCG is now accessible to level designers and environment artists who previously avoided it. The Procedural Vegetation Editor is an editor mode (accessed from the mode selector, alongside Landscape, Foliage, and other modes) that provides direct painting and parameter controls for vegetation placement.

Key capabilities:

• Biome painting — define biome types (forest, meadow, wetland, alpine) and paint them directly onto your landscape, similar to landscape layer painting
• Density and distribution brushes — paint vegetation density with artist-controllable falloff, scale variation, and clustering parameters
• Species management — define vegetation species with individual placement rules (slope tolerance, altitude range, preferred soil type, spacing requirements)
• Real-time preview — see placement results update live as you adjust parameters, without needing to regenerate the full graph
• Nanite and World Partition integration — automatic LOD, proxy mesh generation, and streaming-aware placement for large worlds

Under the hood, the Vegetation Editor generates PCG graphs. This means you can start with the visual editor and then switch to the graph for advanced customization. It's the same system, with an accessible front-end.

Performance Improvements

UE 5.7's PCG runtime is significantly faster than previous versions:

• Hierarchical generation — PCG graphs can now generate at multiple levels of detail, placing high-detail content only near the camera and proxy content at distance
• Async generation — graph execution can happen asynchronously across multiple frames, eliminating the frame-rate spikes that plagued earlier versions during generation
• Partition-aware execution — PCG natively understands World Partition cells, only generating content for loaded cells and properly cleaning up unloaded ones
• Instanced Static Mesh improvements — better batching and draw call management for PCG-placed instances, with automatic Nanite proxy generation

In practical terms, this means PCG-populated worlds that previously struggled at 30 FPS now maintain 60 FPS with the same content density. The performance headroom lets you add more detail without hitting the same budgets.

Expanded Node Library

The node library has grown substantially:

• Spline-based distribution — place content along splines with controllable density, offset, and rotation. Useful for paths, rivers, hedgerows, and fence lines.
• Landscape query nodes — sample landscape height, normal, layer weights, and material information. This lets placement rules respond to the actual terrain — steep slopes get cliff face meshes, flat areas get grass, painted "forest" layers get trees.
• Physics-based settling — optional post-placement physics simulation that drops meshes onto uneven terrain, tilts them to match slopes, and resolves interpenetration. This eliminates the floating-tree problem that plagues naive scatter approaches.
• Exclusion volumes and splines — mark areas where PCG should not place content, with soft falloff at boundaries for natural-looking transitions.
• Blueprint-callable PCG — execute PCG graphs from Blueprint at runtime, enabling use cases like dynamically growing vegetation, destruction-based regrowth, or season changes.

Hands-On: Building a Forest Biome

Here's a practical walkthrough for creating a mixed forest using the new PCG tools. This covers the workflow from an empty landscape to a populated biome.

Step 1 — Define Your Species

Before touching the editor, plan your vegetation layers:

Canopy layer (large trees):

• Oak: slope tolerance 0-25 degrees, altitude 100-800m, spacing minimum 8m
• Pine: slope tolerance 0-35 degrees, altitude 400-1200m, spacing minimum 6m
• Birch: slope tolerance 0-20 degrees, altitude 100-600m, spacing minimum 5m

Understory layer (small trees and large shrubs):

• Hazel: clustered placement, prefers shade (proximity to canopy trees), spacing 3m
• Holly: scattered placement, slope tolerance 0-30 degrees, spacing 4m

Ground cover layer (grass, ferns, flowers):

• Forest grass: high density (3-5 per square meter), height variation 0.3-0.8m
• Fern clusters: medium density, prefers north-facing slopes and proximity to water
• Wildflowers: low density, prefers clearings (distance from canopy trees > 10m)

Forest floor (rocks, logs, debris):

• Fallen logs: very low density, random rotation, physics-settled
• Rock clusters: medium density, placed on slopes > 15 degrees
• Leaf litter decals: high density ground projection

Step 2 — Set Up the Landscape Layers

Paint landscape layers that will drive PCG placement:

• Forest floor — the base soil/ground layer
• Meadow — open areas with grass and wildflowers
• Rocky — cliff faces and boulder fields
• Wetland — areas near water features

These layers provide the data that PCG landscape query nodes sample to determine what species to place where.

Step 3 — Create the PCG Graph

Create a new PCG Graph asset. The high-level structure:

Landscape Sample → Filter by Layer Weight → Per-Species Branch
                                              ├── Oak (density, spacing, scale)
                                              ├── Pine (density, spacing, scale)
                                              ├── Birch (density, spacing, scale)
                                              └── ... additional species

For each species:

1. Surface Sampler node — generates candidate points on the landscape at your target density
2. Landscape Data node — reads layer weights, slope, altitude at each point
3. Filter nodes — remove points outside the species' tolerance ranges
4. Spacing node — enforce minimum distance between instances of this species
5. Transform Randomization — add scale variation (typically +/- 15-20%), random Y-axis rotation, and slight pitch variation (1-3 degrees) to break visual repetition
6. Static Mesh Spawner — place the final instances with the configured mesh and material

Step 4 — Use the Vegetation Editor for Art Direction

This is where the new workflow shines. Switch to the Procedural Vegetation Editor mode and use the painting tools to art-direct the results:

• Increase tree density along ridge lines for a more dramatic silhouette
• Thin out canopy near paths and points of interest so players have clear sightlines
• Add clustering to create natural-looking groves rather than uniform distribution
• Paint exclusion around buildings, roads, and other man-made structures

The painting tools override the procedural rules locally, giving you artist control over the algorithmic base. This is the hybrid approach that makes PCG viable for shipped games — procedural coverage for the 90% of terrain players walk past, and hand-directed refinement for the 10% they actually look at.

Step 5 — Optimize for Shipping

Before shipping your PCG-populated world:

• Enable Nanite for all tree and large shrub meshes — this is essential for draw call performance at scale
• Configure HLOD generation — set up Hierarchical LOD for PCG-placed content so distant forests render as merged proxy meshes
• Set up streaming distances — ensure PCG generation distances align with your World Partition streaming distances
• Profile on target hardware — PCG generation cost should be tested on minimum-spec machines, not just your development workstation
• Bake where possible — for areas that won't change at runtime, consider baking PCG results to static instances to eliminate generation cost entirely

Combining PCG with Custom Placement Tools

PCG is excellent at large-scale coverage but has limitations for specific placement scenarios. Some common situations where you might want complementary tools:

• Art-directed hero areas where every tree and rock placement matters for composition and gameplay
• Gameplay-critical placement where props need precise positioning relative to cover, sightlines, and navigation
• Biome transition zones that need careful blending between different vegetation types
• Interactive vegetation that needs to respond to player actions, weather systems, or time-of-day changes

For these cases, combining PCG's broad coverage with a dedicated scatter and placement tool gives you the best of both approaches — algorithmic efficiency for the bulk work, and fine-grained control where it matters. The Procedural Placement Tool is designed for exactly this kind of art-directable, gameplay-aware placement that complements PCG's strengths.

You can also use MCP-connected AI to manipulate PCG parameters through natural language. The Unreal MCP Server can adjust PCG graph parameters, trigger regeneration, and modify placement rules through conversational interaction — which is particularly useful when you're iterating on density, spacing, and distribution parameters and want to see results quickly without manually navigating parameter panels.

PCG in 2026 and Beyond

UE 5.7's PCG framework has crossed the threshold from "interesting experiment" to "ships in real games." The Procedural Vegetation Editor lowers the barrier for artists, the performance improvements make it viable at scale, and the expanded node library handles most common placement scenarios.

The ecosystem around PCG is also growing. Marketplace plugins extend the node library, community tutorials cover increasingly advanced techniques, and studios are sharing their PCG workflows publicly.

If you've been waiting for PCG to mature before investing time in learning it, this is the release where it makes sense to start. The fundamentals you learn now — biome definitions, layered placement, landscape-driven distribution, art-directed overrides — will carry forward as the framework continues to evolve.

Start with the Procedural Vegetation Editor for your next environment. Build a simple forest. Then open the generated graph and start understanding the nodes. That progression from visual tool to graph understanding is the learning path Epic has designed, and in 5.7, it finally works smoothly.