ProcFunc: Function-Oriented Abstractions for Procedural 3D Generation in Python

Abstract: We introduce ProcFunc, a library for Blender-based procedural 3D generation in Python. ProcFunc provides a library of easy-to-use Python functions, which streamline creating, combining, analyzing, and executing procedural generation code. ProcFunc makes it easy to create large-scale diverse training data, by combinatorial compositions of semantic components. VLMs can use ProcFunc to edit procedural material and geometry code and can create new procedural code with significantly fewer coding errors. Finally, as an example use case, we use ProcFunc to develop a new procedural generator of indoor rooms, which includes a collection of new compositional procedural materials. We demonstrate the detail, runtime efficiency, and diversity of this room generator, as well as its use for 3D synthetic data generation. Please visit https://github.com/princeton-vl/procfunc for source code.

• The paper introduces a function-oriented system using atomic Python primitives that streamline procedural 3D asset creation in Blender.
• The methodology leverages a nodegraph transpiler and static analysis tools to reduce code complexity and errors while achieving 31x faster generation.
• It demonstrates practical implications by enabling efficient synthetic dataset production, scalable content creation, and integration with LLM/VLM workflows.

ProcFunc: Function-Oriented Abstractions for Procedural 3D Generation in Python

Motivation and Context

Procedural 3D generation has become an essential technique for generating assets in computer vision, simulation, and content creation. Its advantages stem from the ability to represent 3D assets as modular code, enabling precise controllability and extensive compositional diversity. Existing systems, such as Blender and Infinigen, provide robust procedural generation tools but suffer from cumbersome APIs designed primarily for GUI workflows rather than efficient Python-centric development. These APIs introduce complexity through implicit dependencies, dynamic UI field indices, and lack of standardized interfaces, severely hindering scalability, modularity, and automated manipulation.

ProcFunc addresses these shortcomings by introducing a library of atomic Python functions for procedural 3D generation in Blender. This system provides streamlined abstractions, explicit function interfaces, and tools for composition, analysis, and execution. The design is tightly aligned with the needs of large-scale synthetic dataset generation, content creation, and agent/LLM-driven code editing.

Figure 1: ProcFunc exposes atomic Python primitives with explicit arguments, eliminating the complexity of GUI-centric APIs.

System Design

Primitives API

ProcFunc defines a comprehensive set of 497 Python primitives encapsulating the full suite of procedural operations in Blender. Each primitive expresses a single graphics operation with all dependencies exposed as explicit arguments, featuring type annotations and runtime assertions. Interface clarity is achieved by separating ambiguous fields and removing implicit state. Automatic data type inference further reduces cognitive overhead, and argument/return-value conventions mirror Pythonic standards for modular function specification.

Execution is managed through isolated Blender contexts, ensuring that primitives behave as independent atomic operations. This design enables predictable, stateless operation and compatibility with typical Python workflows, including automated analysis and composition.

A nodegraph transpiler bridges the gap between Blender nodegraphs and Python procedural code, supporting LLM/VLM workflows for editing and generation. The transpiler converts nodegraph assets into concise Python code, facilitating code editing, static analysis, and GUI-assisted workflows.

Module Composition Framework

Asset generators are implemented as functions with standardized interfaces, enabling seamless composition and parameter accessibility. The framework distinguishes between deterministic and random generator modules, with random samplers requiring explicit np.random.Generator inputs for reproducible randomness and precise control of dataset distributions.

A program tracer, inspired by PyTorch's fx.symbolic_trace, enables static analysis of generator graphs without executing expensive procedural operations. This static analysis supports both instance-level and distribution-level graph extraction, permitting inspection, optimization, and transformation of generator distributions for dataset design or training signal analysis.

Compositionality and Semantic Coverage

ProcFunc maximizes compositionality via reusable procedural modules that can be hierarchically combined into tens of thousands of semantically rich material and scene variants. The system supports multi-level modularity not previously realized in public procedural generation libraries.

Figure 2: Combining base materials, shapes, and layer masks enables exponential compositional diversity.

Application: Procedural Indoor Room Generator

ProcFunc’s power is demonstrated via a sophisticated indoor room generation pipeline. Pre-implemented material modules cover 22 semantic categories (e.g., Concrete, Fabric, Glass, Wood, various tile and brick shapes, masks like cracks and smudges). These can be composited into highly detailed and varied materials. Scene layout tools provide efficient object alignment, collision handling using Python-FCL, and mesh arrangement utilities for creating full rooms.

Camera arrangement primitives and ground truth extraction interfaces simplify the creation of synthetic datasets with diverse views, trajectories, and annotation utilities. The system supports direct rendering with Blender's EEVEE engine and post-process compression via FFmpeg for efficient storage and distribution.

Figure 3: ProcFunc produces complex, high-detail indoor rooms suitable for synthetic dataset generation within minutes of CPU time.

Empirical Evaluation

Ease of Use and LLM/VLM Editing

ProcFunc was evaluated against Infinigen APIs in BlenderGym’s procedural asset editing benchmarks. Using VLMs to edit procedural parameters, ProcFunc demonstrated consistently lower photometric loss (PL), negative CLIP distance, and code error rates across models, despite being at a disadvantage due to reduced pretraining exposure. Notably, ProcFunc required 33% fewer code characters per task, contributing to improved model efficiency and context utilization. In the challenging scenario of creating materials from scratch (without starter code), coding error rates with Infinigen were 30–44%, while ProcFunc reduced errors to single digits in most cases.

Diversity and Analytical Complexity

ProcFunc’s compositional structure measurably increased generator diversity:

Strategy	Cont. Params (mean)	Discrete Params (mean)	Cyclomatic Complexity	Entropy (bits)
Base Materials	25.5	1.80	45	81.3
Multi-level Composition	41.7	3.71	448	134

This substantial increase in cyclomatic complexity and entropy directly translates into richer and more varied dataset coverage.

Runtime Efficiency and Resource Usage

ProcFunc’s scene generation tools produced comparable triangle density and object counts versus Infinigen-Indoors but at dramatically reduced CPU runtime, memory consumption, and disk usage. High-detail scenes require less than one minute of CPU time, enabling generation at the start of GPU training jobs rather than requiring separate preprocessing pipelines. Disk storage for generated scenes and rendered outputs was reduced by up to 90% due to efficient mesh representation and automated compression.

Figure 4: Runtime, memory, and storage statistics demonstrate ProcFunc’s superior efficiency and predictable resource utilization compared to Infinigen.

Geometry Detail and Dataset Quality

ProcFunc’s compositional displacement shaders yielded richer variation in surface normals, supporting tasks requiring dense geometric annotation. Stereo datasets generated with ProcFunc provided strong baseline performance in RAFT-Stereo training, outperforming several widely-used datasets and matching or exceeding the performance of larger datasets such as FSD, despite smaller sample size. Generation efficiency was 31x faster than comparable indoor dataset producers.

Theoretical and Practical Implications

ProcFunc’s function-oriented procedural abstractions instantiate a paradigm shift in how procedural dataset generators can be developed, analyzed, and integrated with modern AI workflows. The explicit, modular interfaces facilitate research in inverse procedural generation, program-based training supervision, and automated dataset optimization. Compositionality and static graph analysis align well with transformer-based LLM/VLM systems, permitting editable and optimizable procedural code.

Practically, ProcFunc enables scalable generation of synthetic data for large-scale vision tasks, domain adaptation, and model robustness evaluation, with unprecedented efficiency and semantic coverage. Integration into LLM/VLM-assisted content creation pipelines is simplified via explicit interfaces and automatic nodegraph transpilation.

Theoretically, ProcFunc bridges the gap between traditional graphics APIs and modern data-driven research, enabling software abstractions for synthetic data generation analogous to the impact of deep learning libraries in model development.

Future Directions

ProcFunc’s abstractions pave the way for extension to more complex asset types, advanced scene layouts, and cross-domain integration. The library can be expanded with new modules and application-specific procedural generators, combined with learned components or external assets. Enhanced static and dynamic analysis can facilitate automated dataset optimization and closed-loop training systems where dataset distributions are adapted based on downstream learning signal.

Program tracing and compositional graph analysis have potential for supporting hybrid procedural-neural training regimes, reinforcement-based procedural asset optimization, and data-driven scene composition for simulation environments.

Conclusion

ProcFunc introduces a systematic approach to procedural 3D generation in Python, centered on atomic function abstractions, modular composition, and analytical tooling. The library demonstrably increases development efficiency, compositional diversity, and resource performance for procedural content creation and dataset generation. These innovations support both practical deployment in synthetic dataset pipelines and theoretical advances in automated procedural generation workflows, marking ProcFunc as a robust foundation for future research and application in procedural graphics and AI-driven content generation.