acceptodds
Under review as a conference paper at ICLR 2027

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.

Primary area:
infrastructure, software libraries, hardware, systems, etc.
Keywords:
computer vision, 3D vision, synthetic datasets, procedural generation

Reviews

Among:
Shape:
1234this paper, Top 30%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.67 over 3 reviews, above 70% of the others.
Reviewer_xy7pOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

ProcFunc is a Python interface for Blender-based procedural generation. It exposes graphics operations through 497 functions with explicit inputs and outputs, standardizes interfaces for composable generators, and separates deterministic asset construction from random parameter sampling. Its tracer can produce instance-level or distribution-level computation graphs. The accompanying library includes 35 procedural material components, 14 object generators refactored from Infinigen Indoors, and tools for scene layout and ground-truth annotation export. The evaluation covers editing and material creation with VLMs, room-generation efficiency, analytical diversity, geometric detail, and stereo matching trained on 50k synthetic stereo pairs.

Critical strengths

1.The interface addresses concrete obstacles to building reusable procedural generators. Explicit inputs and outputs, a common material interface, and explicit random-number generators make the contribution more substantial than simply simplifying Blender API calls. These design choices support material substitution, composition of effects, and access to parameters without requiring objects to be retrieved from hidden scene state. The material library and program-tracing examples in the appendix demonstrate how the interface can be used beyond isolated primitives.

2.Quantitative results across two different applications support the system's practical utility. In the task of creating materials from scratch, the proportion of editing steps that crash falls from 30.3% to 4.9% for Gemini-2.5-Pro and from 44.7% to 21.4% for GPT-5.2 when using ProcFunc rather than the Infinigen API, with lower visual losses and API costs for both models. The stereo matching experiment provides a separate downstream evaluation: training on 50k synthetic stereo pairs generated with ProcFunc yields an EPE of 1.42 on Booster, compared with 2.04 when training on the 1-million-pair FSD dataset, although FSD still performs better on Middlebury. These results support the practical value of the implementation.

Critical weaknesses

1.The API comparison needs clearer checks of equivalence and reliability. Although the appendix provides prompt templates, the paper does not specify the number of evaluated tasks or independent runs, nor does it include the full backend-specific documentation and in-context examples used in the from-scratch experiments. For Table 1, it would also help to confirm that both backends start from equivalent rendered states. Furthermore, Error % measures the proportion of editing steps that crash, rather than the final task failure rate. Paired task-level results and uncertainty estimates would make the reliability gains easier to assess. The results in Table 1 are mixed: the average material-editing crash rate increases from 1.3% to 2.1%, and GPT-5.2's visual losses on the material tasks worsen when using ProcFunc.

2.The scope of distribution-level tracing is not clearly specified. The paper qualifies static analysis as applicable “in some cases,” whereas Section 3.2 describes capturing all possible discrete combinations, and Figure 33 describes a graph containing all control-flow paths. The appendix explains proxies and decorated functions, but does not specify how the system handles ordinary Python conditionals, data-dependent loops, mutation, or calls outside the decorated interface. It is therefore unclear under what conditions the resulting graph is complete, or when a program would be rejected as unsupported. This also limits the interpretation of the diversity analysis: counting random choices that affect the output is useful, but even such choices can produce the same visual result.

Questions for authors

1.Confirm that corresponding tasks in Table 1 start from equivalent rendered states and explain the parameter differences in Figure 31? And, specify the number of tasks and independent runs, the exact documentation and examples provided to each backend, and how failed edits are accounted for in the final metrics. Reporting the proportion of tasks that yield valid final outputs, or paired task-level results from the existing runs, would help assess the reliability of the reported improvements.

2.Clarify the subset of programs for which complete distribution-level tracing is supported and how unsupported branches or side effects are handled. Identify any tests or existing validation procedures that compare direct execution with tracing and replay, and verify that the semantics of the relevant random choices are preserved.

  1. The figures in this manuscript are worth spending more time optimizing.
2 comments
AuthorsOpenReview ↗

Reply to XY7P

XY7P: The results in Table 1 are mixed: the average material-editing crash rate increases from 1.3% to 2.1%, and GPT-5.2's visual losses on the material tasks worsen when using ProcFunc.

From-scratch procedural generation in Table 2 is the primary evidence of ProcFunc’s benefits, and the difference in crash rate is significant (44% vs 21%). Table 1’s visual metrics are improved when averaged across multiple frontier models. We acknowledge Table 1 is only a slight improvement, but we state this is significant due to ProcFunc being used in zero-shot with no prior training, and no documentation provided for this setting, as opposed to Infinigen which the models are able to use based only on knowledge from pre-training. That is, despite a significant disadvantage, ProcFunc is still comparable or a slight improvement.

XY7P: paper does not specify the number of evaluated tasks or independent runs

Our experiments use the full material and geometry task suites from BlenderGym, which has 45 material tasks and 55 geometry tasks. We evaluate each combination of model and backend interface on this task-suite once. We did not repeat the full suite for additional trials due to the very high API cost of multi-round editing over a hundred tasks.

We did repeat specifically the gemini2.5flash and gemini2.5pro material evaluations for 3 repeats on the material tasks. For these repeats, gemini2.5pro achieved 8.22 ± 0.31PL and 12.43 ± 0.80 NCLIP with infinigen, compared to 3.14 ± 0.33 PL and 7.52 ± 0.42 NCLIP with procfunc. gemini2.5flash achieved 4.64 ± 0.65 PL and 10.69 ± 0.67 NCLIP with infinigen versus 4.14 ± 0.93 and 10.18 ± 0.53. We report ± to mean half the range of the differences across seeds, i.e. the maximum across seeds minus minimum, halved.

XY7P: include the full backend-specific documentation and in-context examples used in the from-scratch experiments

We have added Appendix Fig. 40 to show the format of our auto-generate backend-specific documentation. The full plaintext files can also be found in our supplement code e.g. experiments/prompts/reference_code/pf_shader_interface.py. These were auto-generated from the interface of each system: by simply removing the function bodies for ProcFunc, and enumerating Nodes and printing their inputs and outputs for Infinigen.

For in-context examples, we used the “bone”, “nose”, “snakeplant” and “tongue” materials from the system/blender_scripts/material_examples of BlenderGym’s codebase. The bone example was included as Appendix Fig. 31, but we will revise to explain this and our exact recipe. The code files are also included in the supplement code under experiments/prompts/reference_code/. These files were auto-generated by executing BlenderGym’s code to get a blender file, then using both Infinigen and ProcFunc’s transpilers to get code in their respective interfaces.

XY7P: it would also help to confirm that both backends start from equivalent rendered states

The backends produce exactly equivalent Blender nodegraphs, but had two minor visual discrepancies. One is nonreproducible randomness: in the geometry46-geometry50 tasks, there is a dense layer of sugar crystals on a candy, and Infinigen vs ProcFunc trigger a different random rotation of these crystals while preserving the same overall effect. The other is a small difference in shading - ProcFunc is implemented using Blender4.2, which produces darker images for subsurface scattering materials, but the same overall material details. In all cases, we use start code and goal images from the same backend, so a pixel-perfect solution is similarly achievable for both. We believe neither issue makes tasks any easier or harder.

AuthorsOpenReview ↗

Reply to XY7P continued

XY7P: Error % measures the proportion of editing steps that crash, rather than the final task failure rate

Our BlenderGym evaluation does not consider any tasks to have a “final task failure” - if the final editing step fails, we instead use whichever previous render succeeded to compute metrics. We believe this mirrors real-world use: the user can access the LLM’s last successful .png artifact, or make an edit to revert its changes. We believe per-step error % is a useful metric, as it indicates the amount of LLM tool calls and editing steps wasted.

XY7P: Identify any tests or existing validation procedures that compare direct execution with tracing and replay, and verify that the semantics of the relevant random choices are preserved.

We have verified the tracer by executing it across all existing ProcFunc procedural generators. This verification is (1) by tracing the graph of every existing procfunc material and object, and verifying that the executed graph is the same as the original asset and (2) by tracing a short autogenerated program containing every available procfunc primitive and verifying it is captured by the tracer.

XY7P: Scope of distribution level tracing is not specified… in some cases vs all discrete combinations. Does not specify how the system handles Python conditionals, data-dependent loops, mutation, or calls outside the decorated interface.

Thank you for the insightful questions. We will include the clarifications below in the final paper.

Currently, the only supported data-dependent controlflow for distribution-level tracing is pf.control.choice construct. This makes a weighted random choice over control paths, which is a common operation in procedural generation, e.g. picking between random furniture materials according to approximate realworld frequency. This makes the set of distribution-level traceable code essentially equal to a generative grammar, which is also a common and general approach to procedural generation .

Usage of this function is visible in Fig. 33 but description was otherwise omitted - we apologize for the oversight. Restricted controlflow is essential to static analysis, and is also present in torch.compile and jax’s limited controlflow constructs. We anticipate our supported controlflow could be expanded in future e.g. to add iteration similar to jax.lax.scan.

Tracing is not restricted to be used within a decorated function. Decorators instead mark functions that should be atomic to the tracer, with blackbox internals. A primitive or asset that needs arbitrary controlflow can do this within a function decorated as atomic, and can therefore remain fully traceable. This could also be used to encapsulate external code (e.g. cuda or C code) or expensive operations, so that static analysis still applies correctly and is cheap.

Distribution-level tracing (instantaneous analysis of all controlflow paths for all assets) and instance-level tracing (analysis and parameter reporting for one controlflow path for a specific asset) are both independent and optional. ProcFunc is useful even with no tracing due to its general ease-of-use relative to raw Blender. This is our intended meaning for “in some cases” - tracing is not always applicable, as ProcFunc can be used in non-traceable ways if this is more helpful to the user. However, Section 3.2 is correct that it captures all possible discrete combinations, since for our off-the-shelf provided materials, we implemented them to all be distribution-level traceable.

XY7P: Explain the parameter differences in Figure 31?

We have now corrected the figure. It is intended to show the code length and interface differences between ProcFunc and Infinigen. The different random values do not affect this, as the interface calls are the same regardless of the values of the numeric values. The cause is that the underlying “infinigen_bone_example.py” provided by BlenderGym’s source-code is not deterministic, so produced different values for each autogenerated example.

Reviewer_M6YQOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

PROCFUNC introduces a Blender-based Python library for procedural generation, enabling the creation and composition of materials, geometric objects, and complete indoor scenes through code. It encapsulates cumbersome, context-dependent operations into Python functions with explicit parameters. Its core contribution is to unify the inputs and outputs of different generation modules, making them easier to compose while simplifying the authoring, reuse, and randomization of generation programs. In practice, PROCFUNC rapidly combines existing modules and randomly samples parameters such as colors and dimensions, allowing the same program to generate a large number of diverse instances.

Critical strengths
  1. Replacing Blender workflows that rely on context, node sockets, and multi-step operations with Python functions that have explicit inputs and outputs facilitates writing, debugging, and reusing generation programs, rather than merely adding a batch of assets.

  2. Decoupling and modularizing base materials, structures such as bricks/tiles/planks, and effects such as scratches/stains makes it possible to expand the appearance space through composition and reduces the cost of implementing a separate generator for each final material.

  3. The application results are quite convincing.

Critical weaknesses
  1. The contributions are primarily in system and tool design, including functional encapsulation, interface standardization, and module composition. However, the paper does not clearly distinguish the benefits of interface abstraction from those of specific implementations, leaving its generalizable methodological contributions unclear.

  2. Program diversity does not necessarily imply visual diversity or effective data coverage. The proposed metrics measure parameter space, control-flow complexity, and program entropy, but do not directly assess visual variation, plausibility, or coverage of useful real-world scenes.

  3. The downstream experiments validate the overall system but lack component-wise ablations. Table 5 does not disentangle the contributions of material composition, geometric transformations, and scene/object distributions, leaving the effectiveness of the proposed composition mechanism insufficiently established.

  4. Interface-based reliability improvements are inconsistent across tasks. While beneficial for creating material programs from scratch, the approach increases the average error rate for material parameter editing from 1.3% to 2.1% and yields little change for geometric parameter editing. The paper should clarify the scope of its advantages and analyze task-specific failure modes.

  5. How do the parameter count, control-flow complexity, and program distribution entropy reported in Table 4 translate into actual visual diversity? Have the authors evaluated visual redundancy across different program combinations, as well as the plausibility of generated compositions and their coverage of real-world scenes?

Questions for authors

see weaknesses.

2 comments
AuthorsOpenReview ↗

Reply to M6YQ

M6YQ: the paper does not clearly distinguish the benefits of interface abstraction from those of specific implementations, leaving its generalizable methodological contributions unclear.

We do distinguish these benefits: Our LLM results depend only on our interface improvements, and not on the specific implementations of our contribution of pre-implemented procedural generators. We also believe the case study of implementation of our compositional procedural generators is a useful demonstration of the interfaces, rather than just being a tool to demonstrate stereo performance in Table 5.

M6YQ: Table 5 does not disentangle the contributions of material composition, geometric transformations, and scene/object distributions, leaving the effectiveness of the proposed composition mechanism insufficiently established.

We were not able to complete a full dataset-regeneration and retraining during the rebuttal period to directly ablate the effect of materials. Among our other experiments, we believe dataset generation is still useful as it shows the overall ProcFunc system can very efficiently create datasets which are promising for stereo training. Figure 5 shows an effect specifically due to the materials, which is to increase the geometric surface detail that is then used for depth GT.

M6YQ: Interface-based reliability improvements are inconsistent across tasks. While beneficial for creating material programs from scratch, the approach increases the average error rate for material parameter editing from 1.3% to 2.1% and yields little change for geometric parameter editing.

Our main claim for usability improvements is supported by Table 2 in from-scratch procedural generator creation, since only this setting leverages key improvements such as explicit input arguments. Editing existing procedural generators does not capitalize on this, as the node inputs/outputs are largely pre-configured. We acknowledge Table 1 is only a slight improvement, but we state this is significant due to ProcFunc being used in zero-shot with no prior training, and no documentation provided for this setting, as opposed to Infinigen which the models are able to use based only on knowledge from pre-training. That is, despite a significant disadvantage, ProcFunc is still comparable or a slight improvement.

AuthorsOpenReview ↗

Reply to M6YQ continued

M6YQ: The paper should clarify the scope of its advantages and analyze task-specific failure modes.

We have added a new breakdown (Table 6) of what errors LLMs made when using each API. In parameter editing, Infinigen crashes were primarily editing blocks of code which configure color interpolation curves (0.6% of steps) and linking shader nodes incorrectly (0.4%), whereas ProcFunc’s errors were primarily in specifying RGB vs RGBA color literals incorrectly (0.5%) and using nonexistent keyword arguments (0.4%). For From-Scratch creation, LLMs using Infinigen very often accessed ShaderNode inputs / outputs which were disabled (16.8% of steps) or nonexistent (another 16.4% of steps) e.g. via incorrect dictionary keys. Whereas ProcFunc’s errors were approximately 2.5% each of: wrong color constants, accessing nonexistent functions, or rejected by ProcFunc assertions (e.g. using literal data_type=float instead of data_type=”FLOAT”). This will inform further design development.

During this investigation, we discovered a bug which under-reported errors in some cases, due to cases where the agent’s code failed but the render appeared to have completed. We have updated Table 1 and 2 to correct this - the most significant change is that gpt5.2 went from 44.7% to 58.8% error when using Infinigen and 21% to now 23% when using ProcFunc (in Table 2).

M6YQ: How do the parameter count, control-flow complexity, and program distribution entropy reported in Table 4 translate into actual visual diversity? Have the authors evaluated visual redundancy across different program combinations, as well as the plausibility of generated compositions and their coverage of real-world scenes?

Our claim is that compositional procedural components (which can be recombined in many ways) result in more visual coverage than isolated non-compositional procedural generators. Given high-level components (Sec3.3) e.g.“brick” “marble” and “stone”, a system which can produce every combination gains new coverage, e.g. by allowing “marble brick” and “concrete brick”, rather than providing the original categories by themselves. Table 4 measures only this type of random combination, not arbitrary Python control-flow complexity. Our Figure 2 example shows that many useful random combinations are plausible, even atypical combinations such as glass bricks, fabric with metal dreams, or cracks filled with lava.

Parameter count is useful as each parameter is a manually created axis of variation e.g “scratch length” or “brick width”. This also shows that compositionality increases the continuous degrees of freedom of procedural generators, since more effects and parameters can be scalably combined without additional effort by the implementer / curator. Our contribution is not to achieve coverage of particular portions of the real world (e.g. Infinigen). Instead our objective is a relative improvement of coverage, for a fixed set of starting components, by ensuring they are compositional. This is complementary to work like Infinigen which aims to achieve coverage of large portions of the world.

Reviewer_R6GaOpenReview ↗
Rating
3
Confidence
2
Informativeness
3
Presentation
3
Soundness
3
Read review
Paper summary

This paper proposes ProcFunc, a Python library for procedural 3D generation based on Blender. It introduces a carefully designed API that encapsulates low-level graphics operations into atomic functions, simplifying procedural generation code. Its modular framework enables reusable and composable generators, while the program tracer allows for the analysis and modification of generation parameters and distributions. Experiments demonstrate advantages in diversity, quality, and efficiency in both geometry and material generation. The synthetic data also shows competitive performance in downstream stereo matching tasks.

Critical strengths

(1) Building such a foundational tool is practical for 3D data generation. This paper proposes a new Python library for procedural generation based on Blender, which offers higher efficiency and quality than the previously widely used method, Infinigen. Its atomic API and modular design are reasonable and effective. In the current era of LLMs, such techniques can facilitate large-scale data generation and reduce manual labor.

(2) The experiments are solid and convincing. They cover multiple tasks and various metrics for procedural generation. Furthermore, a downstream task demonstrates the practical utility of the proposed approach. The results show a clear advantage over existing methods, and the qualitative results are impressive. These findings provide sufficient support for the paper’s main claim.

Critical weaknesses

Some experimental evaluations are missing. Geometry generation is evaluated only in the parameter-editing setting. It remains unclear whether the improvements observed in from-scratch material creation also generalize to procedural geometry creation. Although the tracer is used for analytical diversity evaluation and demonstrated through examples, it lacks a systematic quantitative evaluation of its correctness, reliability, and computational overhead.

Questions for authors

(1) How does ProcFunc perform on VLM-based from-scratch procedural geometry creation compared with Infinigen?

(2) Can the authors provide quantitative evaluations of the tracer’s correctness and efficiency?

(3) The paper uses VLM-based programming experiments as a proxy for human understandability. Are there any direct human-related usability metrics or evaluations? Alternatively, can the authors clarify the scope of their human usability claims?

1 comment
AuthorsOpenReview ↗

Reply to R6GA

R6Ga: How does ProcFunc perform on VLM-based from-scratch procedural geometry creation compared with Infinigen?

We did not evaluate BlenderGym’s geometry tasks in the From-Scratch setting as they are not fully procedural - they contain pre-made meshes like leaves and books which are arranged with code but cannot be recreated from scratch. We believe this experiment is not essential to prove the usefulness of our system - Blender’s material and geometry systems use the same conventions of stateful creation and linking of nodes, and ProcFunc’s overhaul of that interface is the same in both cases. We will add this explanation to the paper.

R6Ga: Can the authors provide quantitative evaluations of the tracer’s correctness and efficiency?

We have verified the tracer by executing it across all existing ProcFunc procedural generators. This verification is (1) by tracing the graph of every existing procfunc material and object, and verifying that the executed graph is the same as the original asset and (2) by tracing a short autogenerated program containing every available procfunc primitive and verifying it is captured by the tracer.

The tracer’s design allows it to be extremely efficient. To benchmark this, we iterated over all procfunc assets and traced 7 random seeds of each. We observed 8.95±5ms runtime for instance-level graphs, and 34±100ms for distribution-level graphs. Distribution-level graphs are slower as they record all possible combinations modules that could occur for an asset. This is a deliberate outcome of our design: we implemented a tracer precisely because it can analyze a procedural graph quickly, without executing expensive graphics operations. An eager graph execution system (such as default Pytorch) has to execute real operations to determine the graph, which make analyzing a procedural distribution very expensive.

R6Ga: Are there any direct human-related usability metrics or evaluations? Alternatively, can the authors clarify the scope of their human usability claims?

We expect ProcFunc to be useful based primarily on concrete changes in API design: (1) we reduce lines of code while preserving full functionality of the procedural operations, (2) we eliminate several classes of bugs such as incorrect input dictionary keys and (3) changing from a function-oriented design to a UI-oriented design means at an interface level our system is more similar to NumPy, which we expect is familiar to many users. We believe the benefits of our design are evident in Figure 1 and the longer codesample in Figure 31.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.