- 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.
- The figures in this manuscript are worth spending more time optimizing.
2 comments
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.
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 enumeratingNodesand 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_examplesof 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 underexperiments/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-geometry50tasks, 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.