Pith. sign in

REVIEW 4 major objections 5 minor 4 cited by

LL3M: Large Language 3D Modelers

T0 review · 4 major / 5 minor · reviewed 2026-08-05 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read This paper claims that a crew of pretrained language-model agents can generate complete, editable 3D assets by writing Blender code, without any training, finetuning, or specialized 3D dataset.

desk verdict A credible multi-agent Blender-code system with an honest limitations section; the headline 5x/26% numbers are self-measured and shouldn't be used as evidence until there's an external metric or human eval. read the letter →

arxiv 2508.08228 v1 pith:DFYQAFTN submitted 2025-08-11 cs.GR cs.AI

Sining Lu , Guan Chen , Nam Anh Dinh , Itai Lang , Ari Holtzman , Rana Hanocka This is my paper · ORCID
classification cs.GRcs.AI MSC 68T4268U05
keywords 3Dassetgenerationlargelanguagemodelsmulti-agentsystemsBlendercoderetrieval-augmentedinterpretableshapeprogramstext-to-3Diterativeediting
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

LL3M tries to establish that text-to-3D generation can be recast as a code-writing task solved by orchestrating several off-the-shelf LLM agents, each with a narrow role, rather than by training a new generative model on 3D data. The paper argues that representing a shape as modular, commented Python code inside Blender gives three properties at once: open-vocabulary geometry with appearance, native editability by users or by agents, and a mechanism for iterative refinement through visual critique. The central design bets are a shared code context across all agents and a retrieval-augmented knowledge base of Blender documentation (BlenderRAG), which the paper claims increases the use of advanced Blender operations fivefold and reduces code errors by 26 percent. A sympathetic reader would care because if this works, it points to a cheap, training-free path to artist-usable 3D assets that can be tweaked by changing a parameter or a few lines of code, in contrast to one-shot neural generation.

What carries the argument

The central object is the shared code context: a single, cumulative, human-readable Blender Python script that every agent reads and that is updated by localized edits rather than rewritten. The second load-bearing component is BlenderRAG, a retrieval-augmented generation database built from 1,729 official Blender 4.4 documentation pages, which gives the coding agent examples, function signatures, and version-specific error fixes. The multi-agent loop itself—plan, retrieve, code, execute, render, critique, verify—is the mechanism that turns a single-shot code generator into an iterative design process.

What would settle it

Replace the LLM-based evaluation with human raters: render a matched set of prompts' outputs from LL3M and from the no-RAG ablation and the single-LLM baseline, then have raters blind-score geometric completeness, part connectivity, and prompt fidelity. If human scores do not track the reported 5x complex-operation increase or the 26% error reduction, the quantitative claim fails. Also, programmatically checking mesh connectivity after auto-refinement, e.g., counting connected components of the watering-can handle in Fig. 18, would directly test whether spatial errors are actually fixed.

Watch

Extended reading notes

Core claim

LL3M is a multi-agent system that generates complete 3D assets from text by having a planner decompose the prompt into subtasks, a retrieval agent pull Blender API documentation from BlenderRAG, a coding agent write and execute bpy scripts, a critic agent render the result and use a vision-language model to propose visual fixes, and a verification agent check that the fixes were applied. The paper's central claim is that this coordination produces complex, editable, open-vocabulary 3D assets without any training or finetuning, and that the code-based representation is itself a generative medium that enables user-driven iterative editing through follow-up prompts or direct parameter changes.

Load-bearing premise

The headline comparisons rest on the assumption that an LLM's judgment of code complexity and an LLM's visual judgments of rendered shapes are faithful proxies for real 3D asset quality and spatial correctness.

Editorial extensions

If this is right

  • If LL3M's central claim holds, text-to-3D generation no longer requires collecting or training on 3D shape datasets; the geometry and appearance emerge from an LLM's world knowledge plus Blender documentation.
  • Generated assets become editable artifacts: users can change a variable, tweak a shader node, add a line of code, or issue a natural-language follow-up prompt without regenerating the whole object.
  • The same pipeline can maintain identity across successive edits—adding a wig, glasses, ice cream, and a pose change to one character—because the code context preserves what was already built.
  • Because the representation is standard Blender Python, outputs can drop directly into artist workflows, version-control, and existing graphics pipelines without format conversion.
  • BlenderRAG's design implies the system can track Blender version changes: updating the documentation database lets the agents use the latest API regardless of the LLM's training cutoff.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • A testable extension the paper leaves implicit: the code itself could be scored by executors and human raters, or by rendering both LL3M and baseline outputs to images and running a blind comparison, to check whether the 5x complexity and 26% error reduction actually translate into perceived geometric quality.
  • If the code representation is as reusable as the paper claims, an obvious next step is to mine the shared code context across prompts to build a library of parametric part generators, letting users compose new assets by recombining previously generated legs, handles, materials, or scene graphs.
  • Because the critic and verification agents use a VLM (Gemini) to judge spatial correctness, and the paper reports that spatial edits sometimes need 3–4 follow-up prompts, a natural improvement would be adding geometric verification tools—e.g., checking mesh connectivity or bounding-box intersections algorithmically—rather than relying on visual semantics alone.
  • The paper's own numbers suggest a ceiling: with complex operations rising 5x but errors only falling modestly, the error-prone frontier is where RAG helps least; future work might focus on automated repair of spatial errors rather than documentation retrieval.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

4 major / 5 minor

Summary. The paper presents LL3M, a multi-agent system that generates 3D assets by writing and executing Blender Python code from text prompts. Six specialized agents (planner, retrieval, coding, critic, verification, user) are coordinated by an external orchestrator, with a BlenderRAG knowledge base built from 1,729 Blender 4.4 documentation files. Generation proceeds in three phases: initial creation, automatic visual refinement, and user-guided refinement. The paper claims that this design enables open-vocabulary, editable, and interpretable 3D asset generation without training or finetuning, and that BlenderRAG yields about 5x more complex Blender operations and a 26% reduction in cumulative errors relative to the same pipeline without retrieval, and higher-fidelity output than the single-LLM baseline BlenderMCP.

Significance. If the system performs as demonstrated in the gallery, this is a useful contribution to code-based 3D content creation: it shows that a coordinated team of pretrained LLMs, augmented with Blender documentation, can produce complete, executable, editable 3D assets without learning from 3D collections. The emphasis on interpretable, parameterized code as a generative medium is genuinely valuable, and the paper provides a detailed pipeline description and several convincing qualitative demonstrations (e.g., Fig. 4, Fig. 13, Fig. 12). However, the quantitative claims in Sec. 4.4 are not yet established. The main evaluation uses LLM-based counting of hand-defined operation categories and LLM-assigned error counts, with no human ground truth, no significance tests, and unresolved inconsistencies in the reported number of objects and scripts. The comparison to BlenderMCP is supported by only a single qualitative figure. These issues do not invalidate the existence claim that LL3M can generate editable code-based assets, but they do mean that the specific design-choice claims (5x complexity, 26% error reduction, superiority over BlenderMCP) should be treated as unverified.

major comments (4)
  1. [Sec. 4.4 / Tab. 1 / Tab. 2 / Appendix C] The quantitative claims that BlenderRAG increases complex operations by ~5x and reduces errors by ~26% rest on an evaluation whose validity is not established. The complexity counts are generated by GPT-4o using a hand-written taxonomy (Appendix C), with no human-annotated ground truth, no inter-annotator agreement, no variance estimates, and no paired significance test. Error counts are also LLM-assessed from scripts rather than instrumented execution logs, although the text says the code is executed in Blender. Moreover, the manuscript is internally inconsistent: Sec. 4.4 says 17 objects, Appendix C says 34 scripts, and Tab. 2's caption says 30 scripts, while Tab. 2 actually lists 16 object rows. The average 'Complex w/o RAG' also differs between Tab. 1 (1.20) and Tab. 2 (1.21). These inconsistencies must be resolved, and the evaluation should be supplemented with human annotation, pai
  2. [Sec. 4.4 / Fig. 14 / Sec. 2] The claim that LL3M produces 'superior quality assets' relative to BlenderMCP is supported only by a single qualitative comparison (Fig. 14). There is no fixed prompt list, no control for number of iterations or compute budget, no human preference study, and no objective mesh-quality metric. Since BlenderMCP is identified as the most relevant baseline, this comparison needs to be made systematic before the paper can claim higher-fidelity output than the baseline. At minimum, report the prompts, the execution settings, and independent human ratings, or explicitly scope the claim to the illustrated examples.
  3. [Sec. 3.2 / Sec. 3.3 / Fig. 18 / Appendix E] The paper's own limitations and appendix weaken the fidelity/refinement claims. Fig. 18 shows that the auto-refinement phase leaves the watering-can side handle disconnected and the top handle in an incorrect pose, and Appendix E shows a long chain of user follow-up prompts (17 instructions after the initial prompt in the listed sequence) for the humanoid example. The main text states that 59% of user-edit examples were obtained with a single edit instruction, but no denominator or selection protocol is given, and the spatial-edit examples in Appendix E require many corrections. Since the authors explicitly identify VLM spatial-awareness errors, the claims of 'closely aligns with the user's initial input' and 'accurate' automatic refinement need to be supported by a systematic human evaluation or by clearly distinguishing which examples succeed automatically and which require user interv
  4. [Sec. 4.4 / Tab. 1 / Appendix D] The 'error rate' metric is actually a cumulative count of errors per generation, not a rate, so comparing 2.43 vs 3.29 as a 26% reduction is not meaningful without normalizing by script length or number of operations. The paper also notes in Appendix D that without BlenderRAG the coding agent often deletes buggy lines, which reduces error counts at the cost of quality. This makes the raw error-count comparison especially difficult to interpret. The authors should report normalized error rates, distinguish execution errors from logical errors, and provide the actual execution logs so that a reader can verify that errors are corrected rather than avoided by simplifying the code.
minor comments (5)
  1. [Sec. 4.1 / Appendix A.2.4 / A.2.5] The model assignments are inconsistent. Sec. 4.1 says Gemini 2.0 flash powers the critic and verification agents, while Appendix A.2.4 and A.2.5 say the critic and verification agents use gpt-4o and only call a VLM (Gemini) through a tool. Please clarify which component is the agent LLM and which is the VLM.
  2. [Appendix C / Tab. 2] Please fix the sample-size statements: the main text says 17 objects, Appendix C says 34 scripts, Tab. 2's caption says 30 scripts, and Tab. 2 lists 16 rows. A reader cannot reconstruct the actual dataset from these conflicting numbers.
  3. [Sec. 4.4] The evaluation section does not state whether the prompts, generated scripts, and renders are released. The project page is mentioned, but the paper should explicitly state what artifacts will be available for reproducibility.
  4. [Sec. 4.4 / Fig. 16] The agent ablation is presented only as a qualitative figure. If the contribution of each agent is a central design claim, please add a quantitative measure or at least specify the prompts and criteria used for the illustrated examples.
  5. [Sec. 3.1 / BlenderRAG] The BlenderRAG construction is described only briefly (1,729 HTML files converted to PDFs, injected into RAGFlow). Since retrieval quality likely affects the results, please provide details on chunk size, embedding model, retriever settings, and the query formulation used by the retrieval agent.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: LL3M's central generation claims rest on executable Blender code and direct rendering; the LLM-judged metrics are validity concerns rather than circular reductions.

full rationale

Walking the derivation chain, the system's central claim is a constructive existence claim: given a text prompt, a multi-agent LLM pipeline emits Blender Python code that executes and produces 3D assets. This is supported by the pipeline description (Sec. 3), real Blender execution, and the render/gallery figures; it does not reduce to its inputs by any equation. The quantitative evaluation of BlenderRAG (Sec. 4.4, Appendix C) is the only place where a circularity objection could attach: the paper says 'All scripts were then submitted to an LLM to assess the type and frequency of the operations performed, along with the error rates,' and the complex/simple taxonomy is hand-written by the authors. However, this is an evaluation-validity issue, not a formal circular step: 'complex operation' is defined independently of the RAG condition, the counts are not fitted parameters, and no claim is derived from the metric by construction. The critic/verification loop uses Gemini for both critique and verification, which is self-referential, but the paper itself concedes the VLM misses spatial artifacts (Fig. 18 and Appendix E), so the limitation is disclosed rather than hidden. There is no load-bearing self-citation: the authors' own prior work appears only in related work. Internal inconsistencies (e.g., 34 vs. 30 scripts, 17 vs. 16 objects) are rigor concerns, not circularity. Accordingly, no circular step meeting the required bar is present; the weaknesses are about metric validity, statistical support, and baseline comparability, not circularity.

Assumptions & free parameters 0 free parameters · 5 assumptions · 2 invented entities

The paper introduces no fitted scalar parameters or physical postulates. Its assumptions are pragmatic engineering premises about LLM code-writing ability, VLM visual judgment, RAG retrieval quality, and the validity of an LLM-counted complexity metric. The most fragile premises are the VLM's spatial reasoning and the self-assessed metric, both of which the paper itself partially refutes.

assumptions (5)
  • domain assumption Pretrained LLMs (GPT-4o, Claude 3.7 Sonnet) can write valid Blender 4.4 bpy code when guided by RAG snippets and execution error feedback.
    Central to the method; if LLMs cannot bridge natural language to Blender API calls, the pipeline fails. The retrieval error loop is designed to mitigate this, but it remains an empirical premise. Sections 3.1-3.2.
  • domain assumption Rendered Eevee images (5 views) provide sufficient signal for the VLM critic to identify geometric and appearance errors.
    The critic and verification agents depend on this. The paper concedes in Fig. 18 and Appendix E that VLMs miss spatial artifacts (disconnected handles, ice-cream-in-hand), so the assumption is only partially met.
  • ad hoc to paper The frequency of 'complex' Blender operations, counted by GPT-4o using a hand-authored taxonomy, is a valid proxy for asset quality.
    The quantitative table rests entirely on this. Appendix C shows the counting is delegated to an LLM with no human verification or correlation with human-rated quality.
  • domain assumption BlenderRAG retrieval returns relevant, version-correct documentation snippets in enough context for the coding agent.
    Built from 1,729 Blender HTML docs injected into RAGFlow; retrieval quality is assumed, no retrieval accuracy evaluation is reported. Section 4.1.
  • domain assumption The AutoGen orchestrator order and shared context preserve asset intent across phases.
    Requires that shared context does not degrade with length and that agent ordering is sufficient. No robustness analysis is given. Section 3 and Appendix A.
invented entities (2)
  • Multi-agent framework (planner, retrieval, coding, critic, verification, user agents)
    purpose: Decompose prompts, retrieve Blender docs, write and debug code, visually critique, verify fixes, and ingest user edits.
    Software architecture whose benefit is evidenced only by the paper's own qualitative and self-assessed quantitative results. No external benchmark or third-party replication yet.
  • BlenderRAG knowledge base
    purpose: Injects Blender 4.4 API documentation and error solutions into LLM context via RAGFlow.
    The database is not released; no retrieval quality metrics or ablation on document selection are given. Its contribution is measured through the same LLM-based complexity counts.

how reviews work

0 comments
Cite this review

Pith. "Pith review of LL3M: Large Language 3D Modelers." pith.science (2026). https://pith.science/paper/DFYQAFTN

@misc{pith2026250808228,
  author       = {Pith},
  title        = {Pith review of: LL3M: Large Language 3D Modelers},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/DFYQAFTN}},
  note         = {Machine review of arXiv:2508.08228}
}
read the original abstract

We present LL3M, a multi-agent system that leverages pretrained large language models (LLMs) to generate 3D assets by writing interpretable Python code in Blender. We break away from the typical generative approach that learns from a collection of 3D data. Instead, we reformulate shape generation as a code-writing task, enabling greater modularity, editability, and integration with artist workflows. Given a text prompt, LL3M coordinates a team of specialized LLM agents to plan, retrieve, write, debug, and refine Blender scripts that generate and edit geometry and appearance. The generated code works as a high-level, interpretable, human-readable, well-documented representation of scenes and objects, making full use of sophisticated Blender constructs (e.g. B-meshes, geometry modifiers, shader nodes) for diverse, unconstrained shapes, materials, and scenes. This code presents many avenues for further agent and human editing and experimentation via code tweaks or procedural parameters. This medium naturally enables a co-creative loop in our system: agents can automatically self-critique using code and visuals, while iterative user instructions provide an intuitive way to refine assets. A shared code context across agents enables awareness of previous attempts, and a retrieval-augmented generation knowledge base built from Blender API documentation, BlenderRAG, equips agents with examples, types, and functions empowering advanced modeling operations and code correctness. We demonstrate the effectiveness of LL3M across diverse shape categories, style and material edits, and user-driven refinements. Our experiments showcase the power of code as a generative and interpretable medium for 3D asset creation. Our project page is at https://threedle.github.io/ll3m.

Figures

Figures reproduced from arXiv: 2508.08228 by the authors.

Figure 1
Figure 1. LL3M leverages a team of large language models to write Python code that creates and edits 3D assets in Blender. The agents [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗
Figure 3
Figure 3. Iterative creation. LL3M enables multiple successive edits of the same 3D asset. The modifications are faithful to the user’s instructions, editing only the specified element while pre￾serving the character’s identity. A notable feature of our system is that it enables user￾driven, iterative, co-creative 3D modeling. Instead of gen￾erating a 3D shape in a single step, our system optionally enables users to iterative… view at source ↗
Figure 4
Figure 4. Gallery of results. LL3M is capable of diverse shape generation. The results showcase detailed parts (e.g. tassels on the bottom of the lantern, architectural features of the windmill) in intricate arrangements (e.g. grouping and spacing of keys on the piano), and rich appearance (e.g. gradient color on the skateboard) and material properties (e.g. the glossy lamp base). A notable feature of our approach is that eac… view at source ↗
Figures from the paper (17 more)
Figure 6
Figure 6. Figure 6: Intermediate results for each phase in LL3M. Our system enables generating and refining the mesh iteratively. First, the initial creation phase produces a preliminary version of the mesh from the input text (left). Second, the mesh is automati￾cally improved and enhanc…
Figure 5
Figure 5. Figure 5: Method overview. Our system uses a team of LLM￾powered agents to write Blender code that generates a 3D asset according to a text prompt and additional user instructions. Our method includes three phases: initial creation, automatic refine￾ment, and user-guided refinem…
Figure 7
Figure 7. Figure 7: Variations. Due to the inherent stochasticity of language model sampling during inference, identical inputs may yield diverse outputs. This variability also reflects different plausible interpretations of the prompt, often resulting in distinct yet high-quality mesh ge…
Figure 9
Figure 9. Figure 9 [PITH_FULL_IMAGE:figures/full_fig_p005_9.png]
Figure 10
Figure 10. Figure 10: Interpretable edit parameters. By generating shapes through Blender code, LL3M enables intuitive user edits via in￾terpretable parameters, such as those exposed by geometry and shader nodes. For example, when generating a material, our sys￾tem creates a full set of Bl…
Figure 11
Figure 11. Figure 11: Material editing. Given an initial mesh produced by our system, our system is capable of editing the materials on a specific part of the mesh (the blade of the knife), by creating com￾prehensive procedural materials via shader nodes. If the 3D model is not approved by…
Figure 12
Figure 12. Figure 12: Consistent stylization. Starting from different initial meshes produced by LL3M and the same refinement prompt “change the style to steampunk,” LL3M successfully interprets and applies the same style concept to each hat. Each stylized mesh produces distinct variations…
Figure 13
Figure 13. Figure 13: Interpretable code. Our method generates Blender code that is easy to understand and follow. The code is well￾documented with descriptive comments, clear variable names, and structured logic. This interpretable code makes it easy to poten￾tially change variables (e.g.…
Figure 14
Figure 14. Figure 14: Baseline comparison. We compare the Blender MCP module (left) with our method (right) [1]. Our method produces higher-quality meshes with more detailed geometry and closer alignment to the input text prompt compared to the baseline. We attribute the improved quality o…
Figure 15
Figure 15. Figure 15: The importance of BlenderRAG. By incorporating a database of Blender API documentation, we enable the coding agent to use more complex functions that improve mesh quality (right) when compared against the lack of such a database (left). For example, the rocket generat…
Figure 17
Figure 17. Figure 17: Without the shared context, the coding agent is still able to create the required asset, such as the UFO and the glasses. While the asset is of high quality, it is substantially different than the initial one. In contrast, the shared context enables the coding agent t…
Figure 18
Figure 18. Figure 18: Limitations. LL3M relies on the accuracy of VLMs to provide automatic visual feedback on the generated shape. How￾ever, VLMs may still struggle to accurately identify spatial arti￾facts, leading to imperfect results after the auto-refinement phase (second column). Our…
Figure 19
Figure 19. Figure 19: Workflow logic. This diagram is a high-level representation of the agent order logic. The inputs, outputs, and execution conditions are labeled as described in Sec. 3. The white diamond and green box below the coding agent of the second and third columns represent the…
Figure 20
Figure 20. Figure 20: Geometry Refinement. Given a an initial mesh produced by our system, LL3M may additionally modify the geometry based on user instructions in the form of text prompts. Our method applies flexible geometric edits, like changing the shape’s outline (“Midcentury”, “Scandi…
Figure 21
Figure 21. Figure 21: Hierarchical scene graph. The coding agent estab￾lishes logical parenting relationship when the input prompt ex￾plicitly asks for such a relationship. Doing so generates shapes with a human-readable hierarchical structure by creating parent￾child relationships between…
Figure 22
Figure 22. Figure 22: Render function example. A chair from the initial creation phase is rendered from five angles that together capture a holistic overview of the object. These renders are then passed into an external VLM by the critic agent for evaluation. We use the eevee rendering mod…
Figure 23
Figure 23. Figure 23: Verification agent. The coding agent in the auto￾refinement phase may not always address all the issues on its first attempt, hence requiring the presence of a verification agent to check the implementation. In the figure, only the second and third critiques were addr…

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 4 Pith papers

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

  1. GS-Agent: Creating 4D Physical Worlds With Generative Simulation

    cs.RO 2026-07 conditional novelty 6.0 of 10

    Three LLM agents write physics-engine code from text, review rendered frames, and correct errors, turning prompts into physically simulated 4D worlds with camera control.

  2. Nova3D: Code-Native Generation of Programmable 3D Assets

    cs.GR 2026-07 conditional novelty 6.0 of 10

    Nova3D generates 3D assets as executable Blender source, yielding named parts, assembly hierarchies, measurable constraints, and native joints that mesh-native generators do not expose.

  3. Recursive Self-Improvement in AI: From Bounded Self-Refinement to Autonomous Research Loops

    cs.AI 2026-07 conditional novelty 6.0 of 10

    A survey of 1,250 papers organizes AI self-improvement along two axes—what is improved and loop closure—finding that demonstrated self-improvement strength tracks a verification hierarchy from formal verifiers down to...

  4. WorldClaw: Agentic 3D Open-World Generation at Scale

    cs.AI 2026-08 conditional novelty 4.0 of 10

    WorldClaw generates globally coherent, locally detailed, editable 3D worlds from open-ended text using a coarse-to-fine agentic pipeline.

Reference graph

Works this paper leans on

73 extracted references · 53 canonical work pages · cited by 4 Pith papers

  1. [1]

    Blen- derMCP - Blender Model Context Protocol Integration

    Siddharth Ahuja and BlenderMCP Contributors. Blen- derMCP - Blender Model Context Protocol Integration. https://github.com/ahujasid/blender-mcp ,

    work page

  2. [2]

    Polydiff: Generating 3d polygonal meshes with diffusion models

    Antonio Alliegro, Yawar Siddiqui, Tatiana Tommasi, and Matthias Nießner. Polydiff: Generating 3d polygonal meshes with diffusion models. CoRR, abs/2312.11417, 2023. 3

    arXiv 2023

  3. [3]

    Claude sonnet

    Anthropic. Claude sonnet. https://www.anthropic. com/claude/sonnet, 2025. 8

    work page 2025

  4. [4]

    MagicClay: Sculpting Meshes With Generative Neural Fields

    Amir Barda, Vladimir G. Kim, Noam Aigerman, Amit H. Bermano, and Thibault Groueix. Magicclay: Sculpt- ing meshes with generative neural fields. arXiv preprint arXiv:2403.02460, 2024. 3

    work page Pith review arXiv 2024

  5. [5]

    Kim, Noam Aigerman, Amit H

    Amir Barda, Matheus Gadelha, Vladimir G. Kim, Noam Aigerman, Amit H. Bermano, and Thibault Groueix. In- stant3dit: Multiview inpainting for fast editing of 3d ob- jects. In Proceedings of the IEEE/CVF Conference on Com- puter Vision and Pattern Recognition (CVPR), pages 16273– 16282, 2025. 3

    work page 2025

  6. [6]

    Meshanything: Artist-created mesh generation with autoregressive trans- formers

    Yiwen Chen, Tong He, Di Huang, Weicai Ye, Sijin Chen, Jiaxiang Tang, Xin Chen, Zhongang Cai, Lei Yang, Gang Yu, Guosheng Lin, and Chi Zhang. Meshanything: Artist-created mesh generation with autoregressive trans- formers. In arXiv preprint arXiv:2406.10163, 2024. 3

    arXiv 2024

  7. [7]

    Meshany- thing v2: Artist-created mesh generation with adjacent mesh tokenization

    Yiwen Chen, Yikai Wang, Yihao Luo, Zhengyi Wang, Zilong Chen, Jun Zhu, Chi Zhang, and Guosheng Lin. Meshany- thing v2: Artist-created mesh generation with adjacent mesh tokenization. arXiv preprint arXiv:2408.02555, 2024. 3

    arXiv 2024

  8. [8]

    Kim, Matthew Fisher, Noam Aigerman, Hao Zhang, and Siddhartha Chaudhuri

    Zhiqin Chen, Vladimir G. Kim, Matthew Fisher, Noam Aigerman, Hao Zhang, and Siddhartha Chaudhuri. Decor-gan: 3d shape detailization by conditional re- finement. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR) , page 15740–15749, 2021. 3

    work page 2021

Show all 73 references
  1. [9]

    Text-to-3d using gaussian splatting

    Zilong Chen, Feng Wang, Yikai Wang, and Huaping Liu. Text-to-3d using gaussian splatting. arXiv preprint arXiv:2309.16585, 2023. 3

    2023 arXiv

  2. [10]

    3d-gpt: Procedural 3d modeling with large language models

    Sun Chunyi, Han Junlin, Deng Weijian, Wang Xinlong, Qin Zishan, and Gould Stephen. 3d-gpt: Procedural 3d modeling with large language models. arXiv preprint arXiv:2310.12945, 2023. 2, 5

    2023 arXiv

  3. [11]

    Blender - a 3D modelling and rendering package

    Blender Online Community. Blender - a 3D modelling and rendering package. Blender Foundation, Stichting Blender Foundation, Amsterdam, 2025. 8

    2025

  4. [12]

    3d paintbrush: Local stylization of 3d shapes with cascaded score distillation

    Dale Decatur, Itai Lang, Kfir Aberman, and Rana Hanocka. 3d paintbrush: Local stylization of 3d shapes with cascaded score distillation. In Proceedings of the IEEE/CVF Confer- ence on Computer Vision and Pattern Recognition (CVPR) , pages 4473–4483, 2024. 3

    2024

  5. [13]

    Geometry in style: 3d stylization via sur- face normal deformation

    Nam Anh Dinh, Itai Lang, Hyunwoo Kim, Oded Stein, and Rana Hanocka. Geometry in style: 3d stylization via sur- face normal deformation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 28456–28467, 2025. 3

    2025

  6. [14]

    Huang, Xianghao Xu, R

    Aditya Ganeshan, Ryan Y . Huang, Xianghao Xu, R. Kenny Jones, and Daniel Ritchie. Parsel: Parameterized shape edit- ing with language. In SIGGRAPH Asia, 2024. 4

    2024

  7. [15]

    Gemini 2.0 flash

    Google. Gemini 2.0 flash. https://cloud.google.com/vertex- ai/generative-ai/docs/models/gemini/2-0-flash, 2025. 8

    2025

  8. [16]

    Daya Guo, Qihao Zhu, Dejian Yang, Zhenda Xie, Kai Dong, Wentao Zhang, Guanting Chen, Xiao Bi, Y . Wu, Y . K. Li, Fuli Luo, Yingfei Xiong, and Wenfeng Liang. Deepseek- coder: When the large language model meets programming – the rise of code intelligence, 2024. 2

    2024

  9. [17]

    Romero, Tsung-Yi Lin, and Ming-Yu Liu

    Zekun Hao, David W. Romero, Tsung-Yi Lin, and Ming-Yu Liu. Meshtron: High-fidelity, artist-like 3d mesh generation at scale. arXiv preprint arXiv:2412.09548, 2024. 2, 3

    2024 arXiv

  10. [18]

    Turbo3d: Ultra-fast text-to-3d generation

    Hanzhe Hu, Tianwei Yin, Fujun Luan, Yiwei Hu, Hao Tan, Zexiang Xu, Sai Bi, Shubham Tulsiani, and Kai Zhang. Turbo3d: Ultra-fast text-to-3d generation. arXiv preprint arXiv:2412.04470, 2024. 3

    2024 arXiv

  11. [19]

    Blender- alchemy: Editing 3d graphics with vision-language models

    Huang Ian, Yang Guandao, and Guibas Leonidas. Blender- alchemy: Editing 3d graphics with vision-language models. arXiv preprint arXiv:2404.17672, 2024. 2, 5

    2024 arXiv

  12. [20]

    3d shape gener- ation with grid-based implicit functions

    Moritz Ibing, Isaak Lim, and Leif Kobbelt. 3d shape gener- ation with grid-based implicit functions. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), 2021. 3

    2021

  13. [21]

    InfiniFlow. Ragflow. https://ragflow.io/, 2025. 8

    2025

  14. [22]

    A survey on large language models for code generation, 2024

    Juyong Jiang, Fan Wang, Jiasi Shen, Sungju Kim, and Sunghun Kim. A survey on large language models for code generation, 2024. 2 13

    2024

  15. [23]

    Oss- bench: Benchmark generator for coding llms, 2025

    Yuancheng Jiang, Roland Yap, and Zhenkai Liang. Oss- bench: Benchmark generator for coding llms, 2025. 2

    2025

  16. [24]

    Gpt4motion: Scripting physical motions in text-to- video generation via blender-oriented gpt planning

    Lv Jiaxi, Huang Yi, Yan Mingfu, Huang Jiancheng, Liu Jianzhuang, Liu Yifan, Wen Yafei, Chen Xiaoxin, and Chen Shifeng. Gpt4motion: Scripting physical motions in text-to- video generation via blender-oriented gpt planning. arXiv preprint arXiv:2311.12631, 2023. 4

    2023 arXiv

  17. [25]

    Kenny Jones, Theresa Barton, Xianghao Xu, Kai Wang, Ellen Jiang, Paul Guerrero, Niloy J

    R. Kenny Jones, Theresa Barton, Xianghao Xu, Kai Wang, Ellen Jiang, Paul Guerrero, Niloy J. Mitra, and Daniel Ritchie. Shapeassembly: learning to generate programs for 3d shape structure synthesis. ACM Trans. Graph. , 39(6),

  18. [26]

    Kenny Jones, David Charatan, Paul Guerrero, Niloy J

    R. Kenny Jones, David Charatan, Paul Guerrero, Niloy J. Mitra, and Daniel Ritchie. Shapemod: macro operation dis- covery for 3d shape programs. ACM Trans. Graph., 40(4),

  19. [27]

    Kenny Jones, Paul Guerrero, Niloy J

    R. Kenny Jones, Paul Guerrero, Niloy J. Mitra, and Daniel Ritchie. Shapecoder: Discovering abstractions for visual programs from unstructured primitives. ACM Trans. Graph., 42(4), 2023

    2023

  20. [28]

    Kenny Jones, Renhao Zhang, Aditya Ganeshan, and Daniel Ritchie

    R. Kenny Jones, Renhao Zhang, Aditya Ganeshan, and Daniel Ritchie. Learning to edit visual programs with self-supervision. In NeurIPS, 2024. 4

    2024

  21. [29]

    Shap-e: Generating condi- tional 3d implicit functions

    Heewoo Jun and Alex Nichol. Shap-e: Generating condi- tional 3d implicit functions. In NeurIPS (2023), 2023. 3

    2023

  22. [30]

    3d gaussian splatting for real-time radiance field rendering

    Bernhard Kerbl, Georgios Kopanas, Thomas Leimkuehler, and George Drettakis. 3d gaussian splatting for real-time radiance field rendering. ACM Trans. Graph., 42(4), 2023. 3

    2023

  23. [31]

    Kosiorek, Heiko Strathmann, Daniel Zoran, Pol Moreno, Marta Garnelo, Yee Whye Teh, and Danilo J

    Adam R. Kosiorek, Heiko Strathmann, Daniel Zoran, Pol Moreno, Marta Garnelo, Yee Whye Teh, and Danilo J. Rezende. Nerf-vae: A geometry-aware 3d scene generative model. arXiv preprint arXiv:2111.12514, 2021. 3

    2021 arXiv

  24. [32]

    Ln3diff: Scalable latent neural fields diffusion for speedy 3d generation

    Yushi Lan, Fangzhou Hong, Shuai Yang, Shangchen Zhou, Xuyi Meng, Bo Dai, Xingang Pan, and Chen Change Loy. Ln3diff: Scalable latent neural fields diffusion for speedy 3d generation. In ECCV (2024), 2024. 3

    2024

  25. [33]

    Retrieval-augmented gen- eration for knowledge-intensive nlp tasks

    Patrick Lewis, Ethan Perez, Aleksandra Piktus, Fabio Petroni, Vladimir Karpukhin, Naman Goyal, Heinrich K¨uttler, Mike Lewis, Wen-tau Yih, Tim Rockt¨aschel, Sebas- tian Riedel, and Douwe Kiela. Retrieval-augmented gen- eration for knowledge-intensive nlp tasks. In Advances in ...

    2020

  26. [34]

    Sp-gan: Sphere-guided 3d shape generation and manipula- tion

    Ruihui Li, Xianzhi Li, Ka-Hei Hui, and Chi-Wing Fu. Sp-gan: Sphere-guided 3d shape generation and manipula- tion. ACM Transactions on Graphics (Proc. SIGGRAPH) , 40(4), 2021. 3

    2021

  27. [35]

    Sparc: Sparse representation and construc- tion for high-resolution 3d shapes modeling

    Zhihao Li, Yufei Wang, Heliang Zheng, Yihao Luo, and Bihan Wen. Sparc: Sparse representation and construc- tion for high-resolution 3d shapes modeling. arXiv preprint arXiv:2505.14521, 2025. 3

    2025 arXiv

  28. [36]

    Dreampol- isher: Towards high-quality text-to-3d generation via geo- metric diffusion

    Yuanze Lin, Ronald Clark, and Philip Torr. Dreampol- isher: Towards high-quality text-to-3d generation via geo- metric diffusion. arXiv preprint arXiv:2403.17237, 2024. 3

    2024 arXiv

  29. [37]

    Treemeshgpt: Artistic mesh generation with autoregressive tree sequenc- ing

    Stefan Lionar, Jiabin Liang, and Gim Hee Lee. Treemeshgpt: Artistic mesh generation with autoregressive tree sequenc- ing. In Proceedings of the IEEE/CVF Conference on Com- puter Vision and Pattern Recognition (CVPR), 2025. 5

    2025

  30. [38]

    Black, Derek Nowrouzezahrai, Liam Paull, and Weiyang Liu

    Zhen Liu, Yao Feng, Michael J. Black, Derek Nowrouzezahrai, Liam Paull, and Weiyang Liu. Meshd- iffusion: Score-based generative 3d mesh modeling. In International Conference on Learning Representations (ICLR), 2023. 3

    2023

  31. [39]

    Mapcoder: Multi-agent code genera- tion for competitive problem solving

    Islam Md., Ashraful, Ali Mohammed, Eunus, and Parvez Md, Rizwan. Mapcoder: Multi-agent code genera- tion for competitive problem solving. arXiv preprint arXiv:2405.11403, 2024. 2

    2024 arXiv

  32. [40]

    Srinivasan, Matthew Tancik, Jonathan T

    Ben Mildenhall, Pratul P. Srinivasan, Matthew Tancik, Jonathan T. Barron, Ravi Ramamoorthi, and Ren Ng. Nerf: representing scenes as neural radiance fields for view synthe- sis. Commun. ACM, 65(1):99–106, 2021. 3

    2021

  33. [41]

    Introduction to model context pro- tocol, 2024

    Model Context Protocol. Introduction to model context pro- tocol, 2024. 5

    2024

  34. [42]

    3d-ldm: Neural im- plicit 3d shape generation with latent diffusion models

    Gimin Nam, Mariem Khlifi, Andrew Rodriguez, Alberto Tono, Linqi Zhou, and Paul Guerrero. 3d-ldm: Neural im- plicit 3d shape generation with latent diffusion models. In arXiv preprint, 2022. 3

    2022

  35. [43]

    Ali Eslami S

    Charlie Nash, Yaroslav Ganin, M. Ali Eslami S. and Peter W. Battaglia. Polygen: An autoregressive generative model of 3d meshes. In Proceedings of the International Conference on Machine Learning (ICML), 2020. 3

    2020

  36. [44]

    Efros, Sergey Tulyakov, and Jun-Yan Zhu

    Jiayi Ni, Yuwei Guo, Zekun Hao, Kai-En Lin, Angjoo Kanazawa, Alexei A. Efros, Sergey Tulyakov, and Jun-Yan Zhu. Kiss3dgen: Repurposing 2d diffusion for efficient 3d generation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), 2025. 3

    2025

  37. [45]

    Gpt-4o system card

    OpenAI. Gpt-4o system card. https://openai.com/ index/gpt-4o-system-card/ , 2024. 8

    2024

  38. [46]

    Geocode: Interpretable shape programs

    Ofek Pearl, Itai Lang, Yuhua Hu, Raymond A Yeh, and Rana Hanocka. Geocode: Interpretable shape programs. In Com- puter Graphics Forum, page e15276. Wiley Online Library,

  39. [47]

    Dreamfusion: Text-to-3d using 2d diffusion

    Ben Poole, Ajay Jain, Jonathan T Barron, and Ben Milden- hall. Dreamfusion: Text-to-3d using 2d diffusion. arXiv preprint arXiv:2209.14988, 2022. 3

    2022 arXiv

  40. [48]

    Codeelo: Benchmarking competition-level code generation of llms with human-comparable elo ratings, 2025

    Shanghaoran Quan, Jiaxi Yang, Bowen Yu, Bo Zheng, Day- iheng Liu, An Yang, Xuancheng Ren, Bofei Gao, Yibo Miao, Yunlong Feng, Zekun Wang, Jian Yang, Zeyu Cui, Yang Fan, Yichang Zhang, Binyuan Hui, and Junyang Lin. Codeelo: Benchmarking competition-level code generation of llms...

    2025

  41. [49]

    Meshgpt: Generating triangle meshes with decoder-only transformers

    Yawar Siddiqui, Antonio Alliegro, Alexey Artemov, Ta- tiana Tommasi, Daniele Sirigatti, Vladislav Rosov, Angela Dai, and Matthias Nießner. Meshgpt: Generating triangle meshes with decoder-only transformers. In Proceedings of the IEEE/CVF Conference on Computer Vision and Patte...

    2024

  42. [50]

    Pytorchgeonodes: En- abling differentiable shape programs for 3d shape recon- struction

    Sinisa Stekovic, Arslan Artykov, Stefan Ainetter, Mattia D’Urso, and Friedrich Fraundorfer. Pytorchgeonodes: En- abling differentiable shape programs for 3d shape recon- struction. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR) , pa...

    2025

  43. [51]

    Meshllm: Direct polygon mesh generation with large language models

    Mengmeng Tao, Cheng Wang, Bo Dong, Jiaming Huang, Haotian Liu, Yuwei Lin, Yi Zhou, Pan Zhou, Hujun Bao, 14 and Guofeng Wang. Meshllm: Direct polygon mesh generation with large language models. arXiv preprint arXiv:2508.01242, 2024. 2, 5

    2024 arXiv

  44. [52]

    Cg3d: Compositional generation for text-to-3d via gaussian splatting

    Alexander Vilesov, Pradyumna Chari, and Achuta Kadambi. Cg3d: Compositional generation for text-to-3d via gaussian splatting. In arXiv preprint arXiv:2311.17907, 2023. 3

    2023 arXiv

  45. [53]

    Sketchagent: Language-driven sequential sketch generation

    Yael Vinker, Tamar Rott Shaham, Kristine Zheng, Alex Zhao, Judith E Fan, and Antonio Torralba. Sketchagent: Language-driven sequential sketch generation. In Proceed- ings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 23355–23368, 2025. 4

    2025

  46. [54]

    Wong, Dongdong Chen, and Jing Liao

    Can Wang, Menglei Chai, Mingming He, Yajie Zhao, Chen Cao, Kwan-Yee K. Wong, Dongdong Chen, and Jing Liao. Clip-nerf: Text-and-image driven manipulation of neural ra- diance fields. arXiv preprint arXiv:2112.05139, 2021. 3

    2021 arXiv

  47. [55]

    Rodin: A generative model for sculpting 3d digital avatars using diffusion

    Tengfei Wang, Bo Zhang, Xingang Pan, Xintao Wang, Chen Change Loy, and Ziwei Liu. Rodin: A generative model for sculpting 3d digital avatars using diffusion. arXiv preprint arXiv:2210.10865, 2022. 3

    2022 arXiv

  48. [56]

    Nautilus: Locality-aware au- toencoder for scalable mesh generation

    Yuxuan Wang, Xuanyu Yi, Haohan Weng, Qingshan Xu, Xiaokang Wei, Xianghui Yang, Chunchao Guo, Long Chen, and Hanwang Zhang. Nautilus: Locality-aware au- toencoder for scalable mesh generation. arXiv preprint arXiv:2501.14317, 2025. 2, 3

    2025 arXiv

  49. [57]

    Llama- mesh: Mesh generation using autoregressive language mod- els

    Zekun Wang, Jiayuan Li, Weili Liu, Hujun Yuan, Yixin Zhang, Lingjie Liu, Kaiyu Wang, and Yuwei Yu. Llama- mesh: Mesh generation using autoregressive language mod- els. arXiv preprint arXiv:2411.09595, 2023. 2, 5

    2023 arXiv

  50. [58]

    Livebench: A challenging, contamination- free LLM benchmark

    Colin White, Samuel Dooley, Manley Roberts, Arka Pal, Benjamin Feuer, Siddhartha Jain, Ravid Shwartz-Ziv, Neel Jain, Khalid Saifullah, Sreemanti Dey, Shubh-Agrawal, Sandeep Singh Sandha, Siddartha Venkat Naidu, Chinmay Hegde, Yann LeCun, Tom Goldstein, Willie Neiswanger, and M...

    2025

  51. [59]

    Autogen: Enabling next-gen llm applica- tions via multi-agent conversations

    Qingyun Wu, Gagan Bansal, Jieyu Zhang, Yiran Wu, Beibin Li, Erkang Zhu, Li Jiang, Xiaoyun Zhang, Shaokun Zhang, Jiale Liu, et al. Autogen: Enabling next-gen llm applica- tions via multi-agent conversations. In First Conference on Language Modeling, 2024. 8

    2024

  52. [60]

    Textsplat: Text-guided semantic fusion for generalizable gaussian splatting

    Zhicong Wu, Hongbin Xu, Gang Xu, Ping Nie, Zhixin Yan, Jinkai Zheng, Liangqiong Qu, Ming Li, and Liqiang Nie. Textsplat: Text-guided semantic fusion for generalizable gaussian splatting. In Proceedings of the 33rd ACM Inter- national Conference on Multimedia (ACM MM), 2025. 3

    2025

  53. [61]

    Xingguang Yan, Han-Hung Lee, Ziyu Wan, and An- gel X. Chang. An object is worth 64×64 pixels: Gen- erating 3d object via image diffusion. arXiv preprint arXiv:2408.03178, 2024. 3

    2024 arXiv

  54. [62]

    Gaussiandreamer: Fast generation from text to 3d gaussians by bridging 2d and 3d diffusion models

    Taoran Yi, Jiemin Fang, Junjie Wang, Guanjun Wu, Lingxi Xie, Xiaopeng Zhang, Wenyu Liu, Qi Tian, and Xinggang Wang. Gaussiandreamer: Fast generation from text to 3d gaussians by bridging 2d and 3d diffusion models. arXiv preprint arXiv:2310.08529, 2023. 3

    2023 arXiv

  55. [63]

    L3go: Language agents with chain-of-3d-thoughts for generating unconventional objects

    Yamada Yutaro, Chandu Khyathi, Lin Yuchen, Hessel Jack, Yildirim Ilker, and Choi Yejin. L3go: Language agents with chain-of-3d-thoughts for generating unconventional objects. arXiv preprint arXiv:2402.09052, 2024. 5

    2024 arXiv

  56. [64]

    Lion: Latent point diffusion models for 3d shape generation

    Xiaohui Zeng, Arash Vahdat, Francis Williams, Zan Gojcic, Or Litany, Sanja Fidler, and Karsten Kreis. Lion: Latent point diffusion models for 3d shape generation. In Advances in Neural Information Processing Systems (NeurIPS), 2022. 3

    2022

  57. [65]

    3dshape2vecset: A 3d shape representation for neural fields and generative diffusion models

    Biao Zhang, Jiapeng Tang, Matthias Nießner, and Peter Wonka. 3dshape2vecset: A 3d shape representation for neural fields and generative diffusion models. ACM Trans. Graph., 42(4), 2023. 3

    2023

  58. [66]

    Blendergym: Eval- uating the procedural 3d modeling skills of large language models

    Zekai Zhang, Jiarong Li, Kaiyu Wang, Qianhui Lyu, Yunfan Zhu, Ziyu Wu, Wenwu He, Hang Zhao, Yilun Du, Dahua Lin, Yixin Zhang, and Dejia Huang. Blendergym: Eval- uating the procedural 3d modeling skills of large language models. arXiv preprint arXiv:2504.01786, 2024. 4

    2024 arXiv

  59. [67]

    Sdf-stylegan: Implicit sdf-based stylegan for 3d shape generation

    Xin-Yang Zheng, Yang Liu, Peng-Shuai Wang, and Xin Tong. Sdf-stylegan: Implicit sdf-based stylegan for 3d shape generation. In Proceedings of the Symposium on Geometry Processing (SGP), 2022. 3

    2022

  60. [68]

    COMPLETE

    Hu Ziniu, Iscen Ahmet, Jain Aashi, Kipf Thomas, Yue Yisong, Ross David, A., Schmid Cordelia, and Fathi Alireza. Scenecraft: An llm agent for synthesizing 3d scene as blender code. arXiv preprint arXiv:2403.01248 , 2024. 2, 5 15 LL3M: Large Language 3D Modelers Supplementary Ma...

    2024 arXiv

  61. [69]

    1.2 Move the hands slightly backward along the nega- tive x-axis to attach them to the arms

    Create a mini cartoon character 1.1 Move the eye pupils outward along the x-axis. 1.2 Move the hands slightly backward along the nega- tive x-axis to attach them to the arms

  62. [70]

    2.2 Move the wig upward along the z-axis to place it on top of the head

    Add a blonde wig on the head 2.1 Scale the wig smaller. 2.2 Move the wig upward along the z-axis to place it on top of the head

  63. [71]

    3.2 Move the glasses along the negative x-axis to posi- tion them closer to the face

    Add a pair of glasses to the face 3.1 Rotate the glasses 90◦ around the y-axis so they at- tach to the legs. 3.2 Move the glasses along the negative x-axis to posi- tion them closer to the face. 3.3 Move the glasses upward along the z-axis to align with the eyes

  64. [72]

    4.2 Add more sprinkles and make them larger and denser around the ice cream

    Add a sprinkled ice cream to the left hand 4.1 If the ice cream is not attached to the cone, move it slightly downward along the z-axis. 4.2 Add more sprinkles and make them larger and denser around the ice cream. 4.3 If the ice cream is on the character’s arm, move it slightl...

  65. [73]

    5.2 Rotate only the arms so both hands are positioned to hold the ice cream

    Make the character sit down and eat the ice cream with both hands 5.1 If the legs are overlapped, move them outward slightly to separate them. 5.2 Rotate only the arms so both hands are positioned to hold the ice cream. 5.3 Rotate the ice cream along the z-axis so the camera c...

Pith tools

Reviewed August 5, 2026 · model on record in the stance chip above.