Procedural Content Generation in Unreal Engine PCG: A Beginner’s Guide

What you’ll learn in this guide

Unreal Engine’s Procedural Content Generation Framework (PCG) provides a toolset for creating procedural content by processing spatial data through a graph. Epic Games’ documentation includes examples ranging from asset helpers, such as buildings or biomes, to larger worlds. This guide covers how PCG graphs work, which plugins are required, how to create your first graph, and how PCG might fit into architecture, interior design, and archviz workflows.

Rather than thinking of PCG as a tool that generates a finished scene in one step, it’s more useful to see it as a graph system where inputs and operations can be defined. Spatial data is fed into the graph; the system generates points from that data, processes them through nodes, and can use the results to create content or position assets. When a graph is assigned to a PCG Component and used for generation, changes can update in real time in the editor viewport.

Requirements and project setup

To use PCG, the Procedural Content Generation Framework plugin must be enabled in the project. If you need to sample points on Static Meshes, you’ll also need the Procedural Content Generation Framework Geometry Script Interop plugin. The second plugin isn’t required for every workflow; it’s only needed if you plan to sample from meshes.

The source documentation doesn’t specify a particular Unreal Engine version, account type, or pricing requirements. As a result, this guide doesn’t provide steps tied to a specific version number. Before starting a project, check that the required plugins are enabled and whether your planned sampling method requires an additional plugin.

Points used in a graph represent locations in 3D space where operations will take place. Along with position information, they can carry data such as transforms, bounds, color, slope, density, and seed; custom attributes can also be added when needed. The density value determines the probability of a point being generated at a given location. PCG’s debugging view displays this value using a visual gradient: zero appears black, while one appears white.

Create your first PCG graph

1. Check the plugins. Make sure Procedural Content Generation Framework is enabled in the project. If you’re sampling from Static Meshes, enable the Geometry Script Interop plugin as well. Then decide which spatial data the graph will use as its input.

2. Create a graph asset. Right-click in the Content Drawer or Content Browser. Go to Create Advanced Asset > PCG > PCG Graph, name the new asset, and press Enter. The resulting PCG Graph can be edited in the PCG Graph Editor.

3. Set up the data flow. At the heart of the graph is a sequence of nodes that takes in spatial data and processes it. You can drag nodes from the Node Palette into the editor view, or add them from the context menu. First, define the source data and the intended output; then add the operations in between in small steps.

4. Choose node categories that suit the task. PCG nodes are grouped by the tasks they perform. For example, Sampler nodes can generate points from spatial sources such as volumes, surfaces, or meshes. Filter nodes filter data based on defined criteria, while Point Ops process point attributes. Spawner nodes can create new data or place actors at point locations. When choosing among these categories, focus on the role a node will play in the graph rather than just its name.

5. Inspect the result in the editor. When you assign the graph to a PCG Component and use it to generate content, you can watch edits update in the viewport. The editor’s debugging tools and Attributes list can help you inspect the graph’s data. As you evaluate the output, also keep track of the operations applied and the data attributes being used.

6. Create templates for graphs you reuse. You can mark a frequently used graph as a template to use as a starting point for new graphs later. Open the graph, click the Graph Settings button in the toolbar, and enable Is Template in the Asset Info section of the Details panel. When creating a new graph, select the template in the Create Graph From Template window and click Initialize From Template. To close this selection window, disable Show Template Picker on New Graph in the PCG Editor settings under Edit > Editor Preferences.

Workflows for architecture, interiors, and archviz

PCG’s potential in architectural production lies in turning repetitive content creation into an editable graph-based workflow. Epic’s documentation lists building and biome generation among its use cases, and describes the system as a toolset that ranges from asset helpers to large-scale worlds. Teams looking to generate content based on scene data or place assets at specific points can therefore explore adapting PCG to their workflows. The sources don’t describe a specific architecture plugin, ready-made building rules, or a dedicated archviz integration.

For offices and visualization teams, practical applicability depends closely on how clearly the inputs and desired output are defined. Attributes let you store graph data with a name and type; the documentation explains static and dynamic attributes as well as different metadata domains. Keeping the graph small in early tests can make it easier to track what each node does. As the graph grows, comments, reroute nodes, and templates can help keep it organized.

The available sources don’t provide details about hardware requirements, licensing fees, or compatibility with other software. So it isn’t possible to draw conclusions about PCG’s performance on a particular system or whether it will work seamlessly with other tools. Before planning a project, test the plugin setup, sampling method, and intended output. If you plan to sample Static Meshes, be sure to account for the Geometry Script Interop requirement.

What to check and next steps

When setting up your first graph, verify the plugin requirements, the data source you’ll use, and the expected output. Geometry Script Interop isn’t required for every graph; it’s only needed for projects that sample points from Static Meshes. Don’t treat density as a direct quality or visibility setting either: the documentation defines this value in terms of the probability that a point will be generated at a location.

Instead of adding a large number of nodes at once, break the data and operations into stages. Checking the result at each stage makes it easier to see which part is producing the expected output. Next, you can explore attributes and metadata, then move on to the Shape Grammar, GPU Processing, PCG Biome, and debugging runtime generation topics in Epic’s PCG documentation.

When testing in an architectural or interior scene, starting with a limited group of content lets you observe the data flow and placement results. The goal isn’t to use the same graph in every project, but to build repeatable operations in a clear, editable structure. Deciding who will edit the graph within the team and which stages can be reused will also help clarify whether templates are useful.

Source and license

This guide is adapted into Turkish from Epic Games’ Procedural Content Generation Overview and Procedural Content Generation Framework in Unreal Engine documentation. The source information is presented as freely licensed, but the specific license name isn’t given.