Pith. sign in

REVIEW 3 major objections 4 minor 1 cited by

MoGraphGPT: Creating Interactive Scenes Using Modular LLM and Graphical Control

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

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

Pith's one-line read MoGraphGPT claims that splitting LLM code generation by element, with a central module for interactions plus graphical control, makes creating 2D interactive scenes significantly easier, and the user study reports large reductions in…

desk verdict A solid integrative HCI systems paper whose modular-LLM design is plausible and useful, but the controlled study's simple tasks don't support the abstract's 'complex interactive scenes' claim. read the letter →

arxiv 2502.04983 v1 pith:XZDA2YK4 submitted 2025-02-07 cs.HC cs.GR

Hui Ye , Chufeng Xiao , Jiaye Leng , Pengfei Xu , Hongbo Fu This is my paper · ORCID
classification cs.HCcs.GR
keywords CodeGenerationModularizationLargeLanguageModelsChatGPTGraphicalControlInteractiveScenes2DGamesNaturalInterface
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

MoGraphGPT is a system for creating 2D interactive scenes, such as small games and animated demos, without writing code. The paper's claim is that its design, one LLM session per scene element plus a central session that wires interactions, fixes three failures of ordinary ChatGPT-style coding: generated code for one element accidentally changes others, spatial information is hard to express in text, and fine-tuning effects demands endless prompt rewording. To back this, the system adds graphical control, letting users draw points, lines, curves, and regions, reference them by name in prompts, and adjust parameters with automatically generated sliders. In a within-subject study against Cursor Composer, the paper reports significantly faster completions with significantly fewer and shorter prompts, and higher subjective ratings for easiness, controllability, and refinement.

What carries the argument

The load-bearing object is a two-level module hierarchy: individual LLM modules per element plus one central LLM module, linked by a context information repository that stores each element class's variables and functions. The individual modules generate and update class code independently, so refining one element does not rewrite another element's behavior. The central module reads the repository to generate interaction code, but it is instructed to keep element-specific variable and function definitions inside their own classes and to call them from the central code, preserving separation while retaining context.

What would settle it

Run the same three tasks with tool order counterbalanced and the baseline's generated code visible to participants, as in normal use of an AI code editor; if the completion time, prompt count, prompt length, and rating advantages of MoGraphGPT shrink or disappear, the reported improvement would be traced to ordering and hidden code rather than to modularization and graphical control.

Watch

Extended reading notes

Core claim

The paper introduces element-level context-aware modularization for LLM-based scene creation. Each scene element gets its own LLM module that generates and maintains a class for that element's properties and behaviors, while a central LLM module instantiates all elements, coordinates communication, and scripts interactions, calling functions that remain defined inside each element's class. A context information repository passes each class's variables and functions to the central module, so the central module knows what is available without entangling the code. On top of this, MoGraphGPT provides graphical controls: users draw point, line, curve, and region proxies that are labeled P1, L1, C1, and R1 and can be mentioned in prompts, and sliders extracted from generated variables enable precise parameter tuning. The paper's central claim is that this combination makes coding-free creation of complex 2D interactive scenes easier, more controllable, and easier to refine than a state-of-the-art AI coding tool.

Load-bearing premise

The comparison assumes that the baseline was not artificially handicapped, yet every participant used MoGraphGPT first and the baseline's generated code was hidden, so part of the measured advantage may be practice or setup rather than the system itself.

Editorial extensions

If this is right

  • Non-programmers can create complete 2D scenes with four to eight elements in ten to thirty minutes, as demonstrated by the open-ended study.
  • Modifying one element's behavior no longer rewrites another element's behavior, because each element's variables and functions live in its own class and the central module only calls them.
  • Spatial specifications such as exact positions, paths, and regions can be expressed by drawing and then referencing P1, L1, C1, or R1 in a prompt, avoiding laborious coordinate guesswork.
  • Effect parameters like speed, radius, and amplitude can be tuned with sliders instead of re-prompting the model with comparative words.
  • Task completion time, number of prompts, and prompt length all drop significantly compared with Cursor Composer on the three benchmark tasks.

Reading between the lines

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

  • The same element-level split could apply to any multi-component LLM code generation beyond 2D scenes, such as web applications or IoT automation, where independent modules with explicit interfaces would prevent cross-component breakage.
  • The hidden-code interface trades away a learning path; a version that reveals code after successful generations could turn the tool from a scene generator into a programming tutor, but the current evaluation does not test that.
  • Because the authors note context loss with long sessions, a scaling test that increases element count and measures how often the central module generates correct interactions would show where the modularization starts to fail.
  • Adding geometric primitives such as circles and rectangles, plus automatic background segmentation, which participants requested, would likely extend the same graphical proxy idea to richer spatial constraints.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

3 major / 4 minor

Summary. This paper presents MoGraphGPT, a system for creating 2D interactive scenes using modular large language models (LLMs) combined with graphical control. The system maintains independent LLM sessions for each scene element and a central session for interactions, and provides graphical proxies (points, lines, curves, regions), direct manipulation of element positions, and automatically generated sliders for parameter refinement. The authors report a formative content analysis of online tutorials, a within-subjects comparative study with 10 participants against Cursor Composer on three fixed tasks, and an open-ended usability study with 6 participants. The abstract claims that MoGraphGPT significantly improves easiness, controllability, and refinement in creating complex interactive scenes with multiple visual elements in a coding-free manner.

Significance. The system is a thoughtful and potentially valuable contribution to end-user development of interactive visuals. The element-level modularization with context sharing is a plausible response to the identified limitations of conversational LLMs, and the graphical control features (drawing proxies, direct manipulation, sliders) directly address usability gaps. The comparative study shows large, statistically significant differences on objective measures and all subjective items for the three tasks used, and the open-ended study demonstrates the system's expressiveness in creating diverse games and animations. The strengths are the clear implementation, the concrete modular architecture, and the attempt at a controlled comparison with a state-of-the-art baseline. However, the generalizability of the empirical claims is limited by the task scope, sample size, and design choices, which are detailed in the major comments.

major comments (3)
  1. [Section 6.3 and 6.6] The abstract claims that MoGraphGPT significantly improves easiness, controllability, and refinement in creating complex 2D interactive scenes with multiple visual elements. The controlled evaluation, however, uses three tasks that are one- or two-element animations with no user interaction: Task 1 is a single fish moving between two points, Task 2 is a single fish moving along a drawn curve, and Task 3 is a sun and earth with self-rotation and orbit. None of these tasks involve keyboard, mouse, touch, collision, scoring, or more than two elements. Thus the Wilcoxon results reported in Section 6.6 support a narrower claim about simple animations, not the abstract's scope. The open-ended study (Section 7) contains scenes with 4–8 elements and real interactions, but it is not comparative and reports only SUS and qualitative feedback, so it cannot support the claim of significant improvement for that task class.
  2. [Section 6.4] The procedure always presents MoGraphGPT before Cursor Composer for each task. The authors state this was to avoid learning effects of their system, but it introduces a systematic order confound: participants may carry over task familiarity, prompt strategies, or fatigue from the first condition to the second. This makes it impossible to attribute the observed differences solely to the tool. A balanced within-subject design or a between-subjects component is needed to support the causal claim of improved performance with MoGraphGPT.
  3. [Section 6.1] The baseline setup for Cursor Composer hides the code view and instructs participants to focus only on text input, context selection, and result rendering. Since Cursor is fundamentally a code editor, removing its code view may disadvantage it relative to MoGraphGPT, which is designed to hide code. This asymmetry on the primary workflow could inflate the subjective and objective differences. The authors should either justify this setup or discuss it explicitly as a threat to fairness in the comparison.
minor comments (4)
  1. [Section 6.2] The comparative study uses a convenience sample of 10 participants, and the paper does not report effect sizes or confidence intervals alongside the p-values. Adding Cohen's d or equivalent would help readers gauge the magnitude of the observed differences.
  2. [Section 6.5] The paper conducts multiple Wilcoxon signed-rank tests on subjective questionnaire items without any correction for multiple comparisons. Reporting adjusted p-values or clearly labeling the results as exploratory would be more appropriate.
  3. [Section 7] The open-ended study reports an overall SUS score of 85 from 6 participants, but no variance or per-item statistics are shown, and 3 of the 6 participants had already taken part in the comparative study. This should be acknowledged as a limitation when interpreting the usability result.
  4. [Table 1] Table 1 contains typographical errors such as 'Interacitve' in the tool names and missing definite/indefinite articles in the descriptions; these should be corrected in a final polish.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the claims are supported by an external comparative evaluation with Cursor Composer and by usability measures, with no fitted parameters, imported uniqueness theorems, or load-bearing self-citations.

full rationale

This paper makes no derived quantitative prediction: it reports an implemented system and comparative, within-subject measurements against an external baseline (Cursor Composer with GPT-4o Mini). The central claim, that MoGraphGPT 'significantly improves easiness, controllability, and refinement,' is supported by collected task time, prompt counts, prompt lengths, and questionnaire ratings (Section 6.6), not by a derivation from assumptions that already contain the conclusion. There is no equation or fitted parameter renamed as a prediction, and no statistical quantity is forced by construction: the Wilcoxon comparisons are between two tools on the same tasks, so the measurements are external to the system's own design. The only self-citation is reference [74] (ProInterAR), listed among related visual-programming platforms in Section 2.3; it is descriptive context, not evidence for the central claim, so it is not load-bearing. No uniqueness theorem, ansatz, or known result is imported from the authors' prior work. The evaluation does have validity concerns, noted in the reader's take: the fixed tasks involve at most two elements and no user interaction, so the abstract's 'complex interactive scenes with multiple visual elements' is broader than the controlled evidence, and the always-MoGraphGPT-first ordering may bias the comparison. Those are scope and methodological fairness issues, not circularity in the derivational sense defined for this analysis. Accordingly, the circularity score is 0.

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

The paper introduces a software system, not a physical or formal entity. The central module and individual modules are software components, not postulated entities needing independent evidence. There are no fitted numerical parameters in the derivational sense; the evaluation reports means and test statistics, but no parameter is tuned to make a derivation work.

assumptions (5)
  • domain assumption GPT-4o Mini reliably generates syntactically correct class code and interaction code when prompted with element context and graphical information.
    The entire MoGraphGPT architecture depends on the LLM's code output being parseable and insertable via flags (Section 5.2). The paper provides examples but no reliability statistics.
  • domain assumption The flag-based code insertion positions (e.g., //variable start, //function end) remain stable across regenerations and edits.
    Section 5.2 states insert positions are determined by predefined or guided-maintained flags; if the LLM omits or renames flags, independent refinement breaks.
  • domain assumption The context information repository provides enough variable and function summaries for the central module to generate correct interaction calls.
    Section 4.1 relies on this context distillation to avoid losing context between modules; the paper notes token limits remain a limitation (Section 8.3).
  • domain assumption The Wilcoxon signed-rank tests validly compare the two systems despite the fixed order and small sample.
    Section 6.4 always presents MoGraphGPT before Cursor; this violates the usual counterbalancing assumption of within-subject tests.
  • domain assumption The content analysis of 56 videos provides a representative set of challenges for LLM-based interactive scene creation.
    Section 3.1 relied on a convenience corpus of English video tutorials; coding was done by two of the authors.

how reviews work

0 comments
Cite this review

Pith. "Pith review of MoGraphGPT: Creating Interactive Scenes Using Modular LLM and Graphical Control." pith.science (2026). https://pith.science/paper/XZDA2YK4

@misc{pith2026250204983,
  author       = {Pith},
  title        = {Pith review of: MoGraphGPT: Creating Interactive Scenes Using Modular LLM and Graphical Control},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/XZDA2YK4}},
  note         = {Machine review of arXiv:2502.04983}
}
read the original abstract

Creating interactive scenes often involves complex programming tasks. Although large language models (LLMs) like ChatGPT can generate code from natural language, their output is often error-prone, particularly when scripting interactions among multiple elements. The linear conversational structure limits the editing of individual elements, and lacking graphical and precise control complicates visual integration. To address these issues, we integrate an element-level modularization technique that processes textual descriptions for individual elements through separate LLM modules, with a central module managing interactions among elements. This modular approach allows for refining each element independently. We design a graphical user interface, MoGraphGPT , which combines modular LLMs with enhanced graphical control to generate codes for 2D interactive scenes. It enables direct integration of graphical information and offers quick, precise control through automatically generated sliders. Our comparative evaluation against an AI coding tool, Cursor Composer, as the baseline system and a usability study show MoGraphGPT significantly improves easiness, controllability, and refinement in creating complex 2D interactive scenes with multiple visual elements in a coding-free manner.

Figures

Figures reproduced from arXiv: 2502.04983 by the authors.

Figure 1
Figure 1. We introduce MoGraphGPT to facilitate the easy creation of interactive scenes using a graphical user interface powered with modular LLMs. Users can input the text descriptions for individual element properties or behaviors, or interactions among multiple elements, along with the directly specified or drawn graphical information into our system. The code for each element and interactions among elements is generated f… view at source ↗
Figure 2
Figure 2. The framework of our context-aware LLM modularization technique. The central LLM module generates and maintains central code. It manages individual LLM modules to generate individual class codes. The contextual information is extracted from individual codes and input to the central LLM module for reference. 4.1 Element-level Context-aware LLM Modularization 2D interactive scenes contain elements in various forms. We… view at source ↗
Figure 3
Figure 3. MoGraphGPT workflow. When users input text prompts for individual elements, our system integrates graphical information into prompts and sends them to individual modules to generate class codes (Top). For interactions (Bottom), prompts with the integrated graphical information go to the central LLM, which creates the central code. It then notifies individual LLM modules to update their codes with new variables and f… view at source ↗
Figures from the paper (8 more)
Figure 4
Figure 4. Figure 4: Four ways to create elements in our system. (a) Upload an image. (b) Draw a sketch. (c) Add a group and let LLM generate a group of elements (with a user-uploaded element image), either explicitly mentioning “group” in text prompt or not. (d) Ask LLM to generate elemen…
Figure 5
Figure 5. Figure 5: We allow users to specify four types of graphical inputs: (a) point, (b) line, (c) curve, and (d) region. Users can refer to [PITH_FULL_IMAGE:figures/full_fig_p008_5.png]
Figure 6
Figure 6. Figure 6: MoGraphGPT user interface. Element Pane contains the buttons and preview images for all the created elements in the scene. Canvas Area shows all the elements that can be manipulated by users directly. Once users press the “Generate” button, the result is generated or u…
Figure 7
Figure 7. Figure 7: Three tasks in the comparative study [PITH_FULL_IMAGE:figures/full_fig_p010_7.png]
Figure 8
Figure 8. Figure 8: We then conducted semi-structured interviews with them [PITH_FULL_IMAGE:figures/full_fig_p010_8.png]
Figure 8
Figure 8. Figure 8: Subjective ratings on MoGraphGPT and Cursor Composer. For the scores, the higher, the better. only soft constraints, causing interaction code and individual be￾havior code to become intertwined, leading to inconsistent updates and chaotic modifications. Prompt numbers …
Figure 9
Figure 9. Figure 9: A gallery of selected results in the open-ended study. (a) Two-player Rescue Game (P2). (b) Squirrel Guard Game (P1). (c) Scavenger Hunt Game (P4). (d) Airplane War Game (P4). (e) Sea Fishing Game (P6). (f) Interactive Animation Demo (P3). (g) Website Ad Design Demo (P…
Figure 10
Figure 10. Figure 10: SUS score distribution. The question description is the key points from the full SUS questions. [PITH_FULL_IMAGE:figures/full_fig_p013_10.png]

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 1 Pith paper

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

  1. MapStory: Prototyping Editable Map Animations with LLM Agents

    cs.HC 2025-05 conditional novelty 6.0 of 10

    Natural language scripts can be turned into editable, geospatially grounded map animations through MapStory's dual-agent LLM architecture.

Reference graph

Works this paper leans on

83 extracted references · 47 canonical work pages · cited by 1 Pith paper

  1. [1]

    [n. d.]. Flutter - Build apps for any screen. https://flutter.dev/. Accessed: 2024- 11-26

    2024

  2. [2]

    [n. d.]. Python Playground - Online Python IDE. https://programiz.pro/ide/ python. Accessed: 2024-11-26

    2024

  3. [3]

    Tyler Angert, Miroslav Suzara, Jenny Han, Christopher Pondoc, and Hariharan Subramonyam. 2023. Spellburst: A node-based interface for exploratory creative coding with natural language prompts. In Proceedings of the 36th Annual ACM Symposium on User Interface Software and Technology . 1–22

    2023

  4. [4]

    Asad Anjum, Yuting Li, Noelle Law, Megan Charity, and Julian Togelius. 2024. The Ink Splotch Effect: A case study on ChatGPT as a co-creative game designer. In Proceedings of the 19th International Conference on the Foundations of Digital Games. 1–15

    work page 2024

  5. [5]

    Ian Arawjo, Priyan Vaithilingam, Martin Wattenberg, and Elena Glassman. 2023. ChainForge: An open-source visual programming environment for prompt en- gineering. In Adjunct Proceedings of the 36th Annual ACM Symposium on User Interface Software and Technology. 1–3

    work page 2023

  6. [6]

    Claude Artifacts. 2024. Claude Artifacts. https://madewithclaude.com/ Accessed: 2024-12-10

    work page 2024

  7. [7]

    Maciej Besta, Nils Blach, Ales Kubicek, Robert Gerstenberger, Michal Podstawski, Lukas Gianinazzi, Joanna Gajda, Tomasz Lehmann, Hubert Niewiadomski, Piotr Nyczyk, et al. 2024. Graph of thoughts: Solving elaborate problems with large language models. In Proceedings of the AAAI Conference on Artificial Intelligence , Vol. 38. 17682–17690

    2024

  8. [8]

    Giorgio Bimbatti, Daniela Fogli, Luigi Gargioni, et al. 2023. Can ChatGPT sup- port end-user development of robot programs?. In CEUR Workshop Proceedings, Vol. 3408

    work page 2023

Show all 83 references
  1. [9]

    Stephen Brade, Bryan Wang, Mauricio Sousa, Sageev Oore, and Tovi Gross- man. 2023. Promptify: Text-to-image generation through interactive prompt exploration with large language models. In Proceedings of the 36th Annual ACM Symposium on User Interface Software and Technology . 1–14

    2023

  2. [10]

    Kathy Charmaz. 2008. Constructionism and the grounded theory method. Hand- book of constructionist research 1, 1 (2008), 397–412

    2008

  3. [11]

    Liuqing Chen, Shuhong Xiao, Yunnong Chen, Yaxuan Song, Ruoyu Wu, and Lingyun Sun. 2024. ChatScratch: An AI-Augmented System Toward Autonomous Visual Programming Learning for Children Aged 6-12. In Proceedings of the CHI Conference on Human Factors in Computing Systems . 1–19

    2024

  4. [12]

    Mengyu Chen, Marko Peljhan, and Misha Sra. 2021. Entanglevr: A visual pro- gramming interface for virtual reality interactive scene generation. InProceedings of the 27th ACM symposium on virtual reality software and technology . 1–6. MoGraphGPT: Creating Interactive Scenes Usi...

    2021

  5. [13]

    CodePen. 2012. CodePen. https://codepen.io Accessed: 2024-09-11

    2012

  6. [14]

    Cursor. 2023. Cursor - The AI Code Editor. https://www.cursor.com/ Accessed: 2024-11-30

    2023

  7. [15]

    Hai Dang, Lukas Mecke, Florian Lehmann, Sven Goller, and Daniel Buschek. 2022. How to prompt? Opportunities and challenges of zero-and few-shot learning for human-AI interaction in creative applications of generative models. arXiv preprint arXiv:2209.01390 (2022)

    2022 arXiv

  8. [16]

    Fernanda De La Torre, Cathy Mengying Fang, Han Huang, Andrzej Banburski- Fahey, Judith Amores Fernandez, and Jaron Lanier. 2024. Llmr: Real-time prompt- ing of interactive worlds using large language models. In Proceedings of the CHI Conference on Human Factors in Computing Sy...

    2024

  9. [17]

    Exploratorium. 1993. Exploratorium. https://www.exploratorium.edu Accessed: 2024-09-11

    1993

  10. [18]

    GitHub. 2021. GitHub Copilot. https://github.com/features/copilot Accessed: 2024-09-11

    2021

  11. [19]

    Glitch Team. 2017. Glitch. https://glitch.com Accessed: 2024-09-11

    2017

  12. [20]

    Tracy G Harwood and Tony Garry. 2003. An overview of content analysis. The marketing review 3, 4 (2003), 479–498

    2003

  13. [21]

    Yihan Hou, Manling Yang, Hao Cui, Lei Wang, Jie Xu, and Wei Zeng. 2024. C2Ideas: Supporting Creative Interior Color Design Ideation with a Large Lan- guage Model. InProceedings of the CHI Conference on Human Factors in Computing Systems. 1–18

    2024

  14. [22]

    Chengpeng Hu, Yunlong Zhao, and Jialin Liu. 2024. Generating Games via LLMs: An Investigation with Video Game Description Language. arXiv preprint arXiv:2404.08706 (2024)

    2024 arXiv

  15. [23]

    Di Huang, Ziyuan Nan, Xing Hu, Pengwei Jin, Shaohui Peng, Yuanbo Wen, Rui Zhang, Zidong Du, Qi Guo, Yewen Pu, et al. 2024. ANPL: towards natural programming with interactive decomposition. Advances in Neural Information Processing Systems 36 (2024)

    2024

  16. [24]

    Peiling Jiang, Jude Rayan, Steven P Dow, and Haijun Xia. 2023. Graphologue: Ex- ploring large language model responses with interactive diagrams. InProceedings of the 36th Annual ACM Symposium on User Interface Software and Technology . 1–20

    2023

  17. [25]

    Rubaiat Habib Kazi, Fanny Chevalier, Tovi Grossman, and George Fitzmaurice

  18. [26]

    Rubaiat Habib Kazi, Fanny Chevalier, Tovi Grossman, Shengdong Zhao, and George Fitzmaurice. 2014. Draco: bringing life to illustrations with kinetic textures. In Proceedings of the SIGCHI Conference on Human Factors in Computing Systems. 351–360

    2014

  19. [27]

    Khan Academy. 2008. Khan Academy. https://www.khanacademy.org Accessed: 2024-09-11

    2008

  20. [28]

    Tae Soo Kim, Yoonjoo Lee, Minsuk Chang, and Juho Kim. 2023. Cells, generators, and lenses: Design framework for object-oriented interaction with large language models. In Proceedings of the 36th Annual ACM Symposium on User Interface Software and Technology. 1–18

    2023

  21. [29]

    Chong Lan, Yongsheng Wang, Chengze Wang, Shirong Song, and Zheng Gong

  22. [30]

    Baiqi Li, Zhiqiu Lin, Deepak Pathak, Jiayao Li, Yixin Fei, Kewen Wu, Xide Xia, Pengchuan Zhang, Graham Neubig, and Deva Ramanan. 2024. Evaluating and Im- proving Compositional Text-to-Visual Generation. InProceedings of the IEEE/CVF Conference on Computer Vision and Pattern Re...

    2024

  23. [31]

    Fu Li, Jiaming Huang, Yi Gao, and Wei Dong. 2023. ChatIoT: Zero-code Generation of Trigger-action Based IoT Programs with ChatGPT. InProceedings of the 7th Asia-Pacific Workshop on Networking. 219–220

    2023

  24. [32]

    Yujia Li, David Choi, Junyoung Chung, Nate Kushman, Julian Schrittwieser, Rémi Leblond, Tom Eccles, James Keeling, Felix Gimeno, Agustin Dal Lago, et al. 2022. Competition-level code generation with alphacode. Science 378, 6624 (2022), 1092–1097

    2022

  25. [33]

    Jingyuan Liu, Hongbo Fu, and Chiew-Lan Tai. 2020. Posetween: Pose-driven tween animation. In Proceedings of the 33rd annual acm symposium on user interface software and technology . 791–804

    2020

  26. [34]

    Vivian Liu, Rubaiat Habib Kazi, Li-Yi Wei, Matthew Fisher, Timothy Langlois, Seth Walker, and Lydia Chilton. 2024. LogoMotion: Visually Grounded Code Generation for Content-Aware Animation.arXiv preprint arXiv:2405.07065 (2024)

    2024 arXiv

  27. [35]

    Vivian Liu, Han Qiao, and Lydia Chilton. 2022. Opal: Multimodal image genera- tion for news illustration. In Proceedings of the 35th Annual ACM Symposium on User Interface Software and Technology . 1–17

    2022

  28. [36]

    Yue Liu, Thanh Le-Cong, Ratnadira Widyasari, Chakkrit Tantithamthavorn, Li Li, Xuan-Bach D Le, and David Lo. 2024. Refining chatgpt-generated code: Characterizing and mitigating code quality issues. ACM Transactions on Software Engineering and Methodology 33, 5 (2024), 1–26

    2024

  29. [37]

    Zhijie Liu, Yutian Tang, Xiapu Luo, Yuming Zhou, and Liang Feng Zhang. 2024. No need to lift a finger anymore? assessing the quality of code generation by chatgpt. IEEE Transactions on Software Engineering (2024)

    2024

  30. [38]

    Damien Masson, Sylvain Malacria, Géry Casiez, and Daniel Vogel. 2024. Direct- gpt: A direct manipulation interface to interact with large language models. In Proceedings of the CHI Conference on Human Factors in Computing Systems . 1–16

    2024

  31. [39]

    MIT Media Lab. 2003. Scratch. https://scratch.mit.edu Accessed: 2024-09-11

    2003

  32. [40]

    Brad Myers, Sun Young Park, Yoko Nakano, Greg Mueller, and Amy Ko. 2008. How designers design and program interactive behaviors. In 2008 IEEE Symposium on Visual Languages and Human-Centric Computing . IEEE, 177–184

    2008

  33. [41]

    Erik Nijkamp, Bo Pang, Hiroaki Hayashi, Lifu Tu, Huan Wang, Yingbo Zhou, Silvio Savarese, and Caiming Xiong. 2022. Codegen: An open large language model for code with multi-turn program synthesis.arXiv preprint arXiv:2203.13474 (2022)

    2022 arXiv

  34. [42]

    Nintendo. 1986. The Legend of Zelda. https://en.wikipedia.org/wiki/The_ Legend_of_Zelda Accessed: 2024-09-11

    1986

  35. [43]

    OpenAI. 2023. ChatGPT. https://chat.openai.com Accessed: 2024-09-11

    2023

  36. [44]

    Pajitnov, Alexey. 1984. Tetris. https://en.wikipedia.org/wiki/Tetris Accessed: 2024-09-11

    1984

  37. [45]

    Phaser Team. 2013. Phaser. https://phaser.io Accessed: 2024-09-11

    2013

  38. [46]

    Project Jupyter. 2014. Jupyter Notebook. https://jupyter.org Accessed: 2024-09- 11

    2014

  39. [47]

    Chen Qian, Wei Liu, Hongzhang Liu, Nuo Chen, Yufan Dang, Jiahao Li, Cheng Yang, Weize Chen, Yusheng Su, Xin Cong, et al. 2024. Chatdev: Communicative agents for software development. InProceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Vol...

    2024

  40. [48]

    Nico Ritschel, Felipe Fronchetti, Reid Holmes, Ronald Garcia, and David C Shep- herd. 2022. Can guided decomposition help end-users write larger block-based programs? a mobile robot experiment. Proceedings of the ACM on Programming Languages 6, OOPSLA2 (2022), 233–258

    2022

  41. [49]

    Karl Toby Rosenberg, Rubaiat Habib Kazi, Li-Yi Wei, Haijun Xia, and Ken Perlin

  42. [50]

    Baptiste Roziere, Jonas Gehring, Fabian Gloeckle, Sten Sootla, Itai Gat, Xiao- qing Ellen Tan, Yossi Adi, Jingyu Liu, Tal Remez, Jérémy Rapin, et al. 2023. Code llama: Open foundation models for code. arXiv preprint arXiv:2308.12950 (2023)

    2023 arXiv

  43. [51]

    Mohammed Latif Siddiq, Lindsay Roney, Jiahao Zhang, and Joanna Cecilia Da Silva Santos. 2024. Quality Assessment of ChatGPT Generated Code and their Use by Developers. In Proceedings of the 21st International Conference on Mining Software Repositories. 152–156

    2024

  44. [52]

    Snap. 2023. Lens Studio. https://ar.snap.com/en-US/lens-studio Accessed: 2024-09-11

    2023

  45. [53]

    Shyam Sudhakaran, Miguel González-Duque, Matthias Freiberger, Claire Glanois, Elias Najarro, and Sebastian Risi. 2024. Mariogpt: Open-ended text2level genera- tion through large language models. Advances in Neural Information Processing Systems 36 (2024)

    2024

  46. [54]

    Penny Sweetser. 2024. Large language models and video games: A preliminary scoping review. In Proceedings of the 6th ACM Conference on Conversational User Interfaces. 1–8

    2024

  47. [55]

    Haoye Tian, Weiqi Lu, Tsz On Li, Xunzhu Tang, Shing-Chi Cheung, Jacques Klein, and Tegawendé F Bissyandé. 2023. Is ChatGPT the ultimate programming assistant–how far is it? arXiv preprint arXiv:2304.11938 (2023)

    2023 arXiv

  48. [56]

    Graham Todd, Sam Earle, Muhammad Umair Nasir, Michael Cerny Green, and Julian Togelius. 2023. Level generation through large language models. In Pro- ceedings of the 18th International Conference on the Foundations of Digital Games . 1–8

    2023

  49. [57]

    Tiffany Tseng, Ruijia Cheng, and Jeffrey Nichols. 2024. Keyframer: Empowering Animation Design using Large Language Models. arXiv preprint arXiv:2402.06071 (2024)

    2024 arXiv

  50. [58]

    Unity Technologies. 2005. Unity. https://unity.com Accessed: 2024-09-11

    2005

  51. [59]

    University of Colorado Boulder. 2002. PhET Interactive Simulations. https: //phet.colorado.edu Accessed: 2024-09-11

    2002

  52. [60]

    Unreal Engine. 2023. Introduction to Blueprints. https://docs.unrealengine.com/ 4.27/en-US/ProgrammingAndScripting/Blueprints/GettingStarted/ Accessed: 2024-09-11

    2023

  53. [61]

    Vercel. 2024. v0 by Vercel. https://v0.dev/ Accessed: 2024-12-10

    2024

  54. [62]

    Zhijie Wang, Yuheng Huang, Da Song, Lei Ma, and Tianyi Zhang. 2024. PromptCharm: Text-to-Image Generation through Multi-modal Prompting and Refinement. In Proceedings of the CHI Conference on Human Factors in Computing Systems. 1–21

    2024

  55. [63]

    Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Fei Xia, Ed Chi, Quoc V Le, Denny Zhou, et al. 2022. Chain-of-thought prompting elicits reasoning in large language models. Advances in neural information processing systems 35 (2022), 24824–24837

    2022

  56. [64]

    Wikipedia contributors. 2023. Super Mario. https://en.wikipedia.org/wiki/ Super_Mario Accessed: 2024-09-11

    2023

  57. [65]

    Chenfei Wu, Shengming Yin, Weizhen Qi, Xiaodong Wang, Zecheng Tang, and Nan Duan. 2023. Visual chatgpt: Talking, drawing and editing with visual foun- dation models. arXiv preprint arXiv:2303.04671 (2023)

    2023 arXiv

  58. [66]

    Tongshuang Wu, Ellen Jiang, Aaron Donsbach, Jeff Gray, Alejandra Molina, Michael Terry, and Carrie J Cai. 2022. Promptchainer: Chaining large language model prompts through visual programming. InCHI Conference on Human Factors in Computing Systems Extended Abstracts . 1–10. Co...

    2022

  59. [67]

    Tongshuang Wu, Michael Terry, and Carrie Jun Cai. 2022. Ai chains: Transparent and controllable human-ai interaction by chaining large language model prompts. In Proceedings of the 2022 CHI conference on human factors in computing systems . 1–22

    2022

  60. [68]

    Haijun Xia, Bruno Araujo, Tovi Grossman, and Daniel Wigdor. 2016. Object- oriented drawing. In Proceedings of the 2016 CHI Conference on Human Factors in Computing Systems. 4610–4621

    2016

  61. [69]

    Shishi Xiao, Liangwei Wang, Xiaojuan Ma, and Wei Zeng. 2024. TypeDance: Cre- ating semantic typographic logos from image through personalized generation. In Proceedings of the CHI Conference on Human Factors in Computing Systems . 1–18

    2024

  62. [70]

    Jun Xing, Rubaiat Habib Kazi, Tovi Grossman, Li-Yi Wei, Jos Stam, and George Fitzmaurice. 2016. Energy-brushes: Interactive tools for illustrating stylized elemental dynamics. InProceedings of the 29th Annual Symposium on User Interface Software and Technology. 755–766

    2016

  63. [71]

    Zihan Yan, Chunxu Yang, Qihao Liang, and Xiang’Anthony’ Chen. 2023. XCre- ation: A Graph-based Crossmodal Generative Creativity Support Tool. InProceed- ings of the 36th Annual ACM Symposium on User Interface Software and Technology. 1–15

    2023

  64. [72]

    Daijin Yang, Erica Kleinman, and Casper Harteveld. 2024. GPT for Games: A Scoping Review (2020-2023). arXiv preprint arXiv:2404.17794 (2024)

    2024 arXiv

  65. [73]

    Shunyu Yao, Dian Yu, Jeffrey Zhao, Izhak Shafran, Tom Griffiths, Yuan Cao, and Karthik Narasimhan. 2024. Tree of thoughts: Deliberate problem solving with large language models. Advances in Neural Information Processing Systems 36 (2024)

    2024

  66. [74]

    Hui Ye, Jiaye Leng, Pengfei Xu, Karan Singh, and Hongbo Fu. 2024. ProInterAR: A Visual Programming Platform for Creating Immersive AR Interactions. In Proceedings of the CHI Conference on Human Factors in Computing Systems . 1–15

    2024

  67. [75]

    Ryan Yen, Jiawen Zhu, Sangho Suh, Haijun Xia, and Jian Zhao. 2023. Colad- der: Supporting programmers with hierarchical code generation in multi-level abstraction. arXiv preprint arXiv:2310.08699 (2023)

    2023 arXiv

  68. [76]

    Enes Yigitbas, Jonas Klauke, Sebastian Gottschalk, and Gregor Engels. 2023. End- user development for interactive web-based virtual reality scenes. Journal of Computer Languages 74 (2023), 101187

    2023

  69. [77]

    JD Zamfirescu-Pereira, Richmond Y Wong, Bjoern Hartmann, and Qian Yang

  70. [78]

    Lei Zhang and Steve Oney. 2020. Flowmatic: An immersive authoring tool for creating interactive scenes in virtual reality. In Proceedings of the 33rd Annual ACM Symposium on User Interface Software and Technology . 342–353

    2020

  71. [79]

    Quanjun Zhang, Tongke Zhang, Juan Zhai, Chunrong Fang, Bowen Yu, Weisong Sun, and Zhenyu Chen. 2023. A critical review of large language model on software engineering: An example from chatgpt and automated program repair. arXiv preprint arXiv:2310.08879 (2023)

    2023 arXiv

  72. [81]

    In Proceedings of the 2023 CHI Conference on Human Factors in Computing Systems

    Why Johnny can’t prompt: how non-AI experts try (and fail) to design LLM prompts. In Proceedings of the 2023 CHI Conference on Human Factors in Computing Systems. 1–21

    2023

  73. [2014]

    In Proceedings of the 27th annual ACM symposium on User interface software and technology

    Kitty: sketching dynamic and interactive illustrations. In Proceedings of the 27th annual ACM symposium on User interface software and technology . 395–405

  74. [2023]

    Future Internet 15, 9 (2023), 300

    Application of ChatGPT-Based Digital Human in Animation Creation. Future Internet 15, 9 (2023), 300

    2023

  75. [2024]

    arXiv preprint arXiv:2401.05631 (2024)

    DrawTalking: Building Interactive Worlds by Sketching and Speaking. arXiv preprint arXiv:2401.05631 (2024)

    2024 arXiv

Pith tools

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