---
title: Procedural Compact Graph (PCG)
url: https://www.emergentmind.com/topics/procedural-compact-graph-pcg
type: topic
---

# Procedural Compact Graph (PCG)

A Procedural Compact Graph (PCG) is a directed acyclic graph-based formalism for representing 3D models, introduced to enable interpretable, editable, and parameterized procedural generation of geometric content. Each node in a PCG encodes either a geometric primitive, a signal transformation, a combinatory operation, or a control structure, and exposes its computational and semantic parameters for real-time manipulation. This design enables direct parametric editing and language-driven generation, providing efficiency and flexibility that is not achievable with mesh- or point-cloud-based representations [2601.12234].

## 1. Formal Structure and Semantics

A procedural compact graph is defined as a DAG \( G=(V,E) \) together with:

- **Operation types:** Each node \( v \in V \) has an operation \( \mathrm{op}(v) \) (e.g., Input, cube, cylinder, Transform, join, switch, extrude, instance-on-points).
- **Attributes:** Each node is associated with a tuple of named, typed attributes \( A(v) = \{ a_1{:}\tau_1, ..., a_k{:}\tau_k \} \), with scalars, booleans, or vectors as types.
- **Input edges:** Zero or more ordered input edges \( e = (u \to v) \) connect compatible outputs to inputs, aligning strictly by data type.
- **Output value:** Each node produces exactly one primary output \( \mathrm{out}(v) \) (a 3D geometry, vector, scalar, or boolean).

Type discipline is enforced: geometry-producing nodes propagate to further geometry-processing nodes; numeric nodes only connect where scalars/vectors are expected. The directed acyclic structure maintains a unidirectional, parallelizable, and single-pass dataflow. The graph must have one designated Output node representing the complete geometry [2601.12234].

Evaluation proceeds by topological sort—each node computes its output using its operation, attribute values, and available input data.

## 2. PCG Extraction from Hierarchical Meshes

PCGs can be synthesized from hierarchical or segmented 3D objects using an automated traversal and mapping procedure:

- **Primitive Extraction:** For each leaf segment, a primitive PCG node is emitted, with transformation parameters computed via PCA (translations as centroid, rotations from eigenvectors, scales as extents along principal axes).
- **Switches:** Boolean parameters are introduced at leaves to toggle subtree presence.
- **Structural Recursion:** Internal nodes combine child PCG nodes using join or instance-on-points, merging repeated semantics into reusable patterns.
- **Label Mapping:** Each node’s semantic path (from hierarchy) determines parameter names, exposing intuitive control to users.
- **Graph Construction:** After recursive traversal, the resulting mapping connects nodes into a DAG terminating at a global Output node.

This decomposition allows both fine-grained and high-level edits, as all editable parameters—sizes, positions, presence of subparts—are accessible in the graph structure [2601.12234].

## 3. Exposed Parameters and Real-time Editing

Every PCG exposes a collection of parameters at its nodes, directly mapping to GUI controls:

- **Scalars:** Represent geometric or semantic quantities, rendered as sliders.
- **Booleans:** Represent subpart toggles, rendered as checkboxes.
- **Vectors:** Typically for transformations, with each component adjustable.

Parameter ranges can be specified by the user or inferred (e.g., by mesh extents during import). Editing is highly responsive: moving a slider or toggling a checkbox updates the corresponding parameter, marks affected subgraph nodes as dirty, and triggers topological re-evaluation and hot-swapping of only the impacted components. Update times are typically under 10 ms due to the limited graph depth and local recomputation [2601.12234].

## 4. Graph Evaluation and 3D Model Generation

PCG-based generation of a 3D model follows a single-pass parallelizable pipeline:

1. **Topological sorting** determines node evaluation order.
2. **Evaluation:** Each node computes its output,
   - For primitives: calls shape construction routines with parameters.
   - For transforms: applies geometric transformations.
   - For combiners: performs boolean union, merging, or instantiation.
3. **Resulting mesh:** The Output node yields the completed mesh, which is then handed to the rendering or export pipeline.

This eliminates the need for global mesh regeneration on local edits and allows for efficient real-time design and text-driven shape modification [2601.12234].

## 5. Canonical Example and Expressiveness

A representative example is the table PCG:

```none
Input table_width=2.0, table_length=1.0, leg_height=0.75, leg_radius=0.05
cyl_legs   = cylinder(radius=leg_radius, depth=leg_height)
rect_pts   = rectangle(width=table_width-0.2, height=table_length-0.2)
legs_inst  = instance_on_points(points=rect_pts, instance=cyl_legs)
legs_trans = T(0,0,-leg_height/2)(legs_inst)
tbl_top    = rectangle(width=table_width, height=table_length)
fillet_crv = fillet_curve(curve=tbl_top, radius=0.1, count=20)
filled     = fill_curve(curve=fillet_crv)
extruded   = extrude_mesh(mesh=filled, offset_scale=0.05)
table_mesh = join(legs_trans, extruded)
Output table_mesh
```

Each line represents a node, with clear parameter mapping. This structure demonstrates both the minimal verbosity and the high manipulatability—the width, length, leg properties, and top details are exposed directly as controls [2601.12234].

## 6. Comparative Advantages and Current Limitations

A summary of empirical advantages relative to mesh, point-cloud, or scripted representations:

| Aspect             | PCG                 | Mesh/Point-Cloud/Script |
|--------------------|---------------------|------------------------|
| Editability        | Instantaneous (≤10ms)| Requires full regeneration |
| Compactness        | 4–10× fewer tokens  | Large, verbose         |
| Interpretability   | Human-readable      | Opaque                 |
| Engine Portability | Yes                 | Often no               |
| LLM Compatibility  | High (concise grammar) | Low (risk of context overflow, syntax errors) |

Reported benchmarks show a 400× speedup in editing operations and 28% improvement in ULIP scores for text-to-3D specification tasks when using PCG [2601.12234].

Limitations include: restriction to primitive-based geometry (no freeform surfacing), dataset bias due to training on limited object classes, lack of photorealistic detail, and potential responsiveness drops for highly complex DAGs (large/deep scenes) [2601.12234].

## 7. Significance and Impact

The introduction of procedural compact graphs provides an efficient intermediate representation for editable, interpretable, and large-language-model-compatible 3D content synthesis. This approach bridges the gap between generative AI models—which excel at creating plausible designs from high-level prompts—and practical requirements for downstream editing, CAD interoperability, and multi-platform deployment. By exposing parameterized controls, PCG enables both manual and automated (e.g., language-driven) refinement loops, promoting a more iterative, customizable 3D generation pipeline [2601.12234].

The procedural nature of the representation also supports efficient recomputation for local edits, accelerating the design process and facilitating novel applications such as real-time shape manipulation, text-aligned image editing, and accessible 3D content authoring for non-expert users.

Source: https://www.emergentmind.com/topics/procedural-compact-graph-pcg