Procedural Compact Graph (PCG)

• Procedural Compact Graph (PCG) is a directed acyclic graph-based formalism representing 3D models where each node encodes geometric primitives, transformations, operations, or control parameters.
• PCG extraction from hierarchical meshes involves primitive extraction, topological sorting, and localized real-time editing with update times typically under 10 ms.
• PCG offers enhanced editability, compactness, and interpretability over traditional mesh or point-cloud approaches, supporting LLM-driven design and CAD interoperability.

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 (Raji et al., 18 Jan 2026).

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 (Raji et al., 18 Jan 2026).

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 (Raji et al., 18 Jan 2026).

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 (Raji et al., 18 Jan 2026).

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 (Raji et al., 18 Jan 2026).

5. Canonical Example and Expressiveness

A representative example is the table PCG:

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 (Raji et al., 18 Jan 2026).

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 (Raji et al., 18 Jan 2026).

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) (Raji et al., 18 Jan 2026).

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 (Raji et al., 18 Jan 2026).

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.