unity

3D game development remains prohibitively high-barrier due to its reliance on programming, 3D modeling, and engine-specific configuration. Existing automated approaches are limited to 2D content, require manual integration, struggle with interactive logic and state management, and lack end-to-end support for mainstream engines (e.g., Unity, Unreal). Method: We propose the first zero-code, multi-agent collaborative framework for 3D game generation, leveraging multimodal large language models to orchestrate specialized agents for planning, code generation, automation, and debugging—enabling full pipeline translation from natural language specifications to executable C#-based Unity/Unreal projects. Contribution/Results: Evaluated on three prototype games, our framework reduces average development time by 91.4% and eliminates hand-written code entirely, marking a significant breakthrough in automating interactive 3D game creation.

VR development lacks quantitative, evidence-based criteria for selecting between Unreal Engine and Unity. Method: This study establishes a multidimensional empirical evaluation framework integrating rendering fidelity, computational efficiency, cross-platform compatibility, workflow productivity, and AI-enhanced capabilities (e.g., DLSS, LLM-assisted debugging), validated through systematic benchmarking and large-scale industrial case studies. Crucially, it pioneers the incorporation of AI-driven optimization techniques into engine performance attribution analysis and proposes a demand-aware, dynamic engine selection model grounded in project characteristics—such as immersion priority, hardware constraints, and team size. Contribution/Results: Findings indicate that high-fidelity VR applications favor Unreal Engine, whereas rapid-iteration or lightweight scenarios benefit more from Unity. The framework reduces selection-related trial-and-error costs by 37% and improves development efficiency by 2.1×, establishing a reusable, data-driven paradigm for engine selection in industrial VR deployment.

Existing code-generating agents lack effective evaluation benchmarks within real-world, stateful, real-time C++ systems such as game engines. This work proposes the first evaluation platform built on Unreal Engine 5, comprising 110 C++ tasks extracted from nine real game repositories, spanning critical dimensions including game logic, networking, AI, and rendering. The framework employs behavior-driven testing and a multi-dimensional categorization scheme to automatically assess models via pass@1, measuring their ability to generate correct, compilable code within executable projects. Experimental results show that the best-performing model achieves a pass@1 rate of 55.5%, yet 31 tasks remain unsolved, highlighting significant challenges faced by current agents in deeply integrated development within complex C++ systems.

This work addresses the challenges of automatically generating complete, executable 3D games within commercial game engines—namely, procedural complexity and high technical barriers—by proposing AutoUE, a multi-agent system that coordinates multiple specialized agents to end-to-end produce functional 3D games, encompassing scene construction, gameplay logic, and interactive code synthesis. The approach innovatively integrates retrieval-augmented generation to mitigate tool hallucinations in large language models, while incorporating constraints from Unreal Engine documentation and established game design patterns to ensure code correctness. An automated testing mechanism is further introduced to validate dynamic game behaviors. Evaluated on a newly curated dataset for game generation, experiments demonstrate AutoUE’s effectiveness in producing fully functional 3D games and confirm the overall system performance.

Large language models (LLMs) struggle to generate industrial manufacturing simulation scenes that satisfy precise dimensional and spatial constraints. Method: This paper proposes an encoder-based agent framework for industrial scene generation. It innovatively transforms LLMs into C# code-generation agents, integrating structured layout planning, automated constraint validation, and iterative refinement. We construct SceneInstruct—a domain-specific instruction-tuning dataset for industrial scenes—and perform lightweight fine-tuning on Llama3.1-70B. Contribution/Results: The approach enables computationally grounded, verifiable, and iterative scene modeling. On real-world industrial tasks, it achieves an 81.0% scene generation success rate—approaching the performance of GPT-4o—while significantly improving geometric and spatial fidelity. All code and data are publicly released.

Existing 3D generation models struggle to produce assets with well-defined semantic structures that can be directly deployed in interactive applications. This work proposes the first 3D mesh generation framework supporting open-vocabulary inputs and user-defined part structures, enabling explicit control over semantic composition during inference through text prompts and a part list. The method employs a two-stage architecture that decouples global shape synthesis from part-level decoding and introduces a text-to-part semantic alignment mechanism. Additionally, the authors curate a large-scale 3D dataset annotated with part labels. The resulting assets can be directly imported into game engines and readily support animation and scripting without any post-processing, significantly enhancing both controllability and practical utility.

Existing visualization tools suffer from fragmentation between static and interactive paradigms as well as between desktop and web environments, hindering write-once, run-anywhere reusability. This work proposes Pluot, a novel architecture that establishes a unified rendering core implemented in Rust and automatically generates language bindings for Python, JavaScript, and other ecosystems. Pluot enables cross-platform, cross-interactivity reproducible execution while unifying publication-quality static graphics with dynamic interactive experiences—an integration previously unachieved. The system delivers both high performance and high-fidelity visual output, addressing a critical gap in the visualization landscape. The implementation is open-sourced at https://pluot.dev.

Existing text-to-3D scene generation methods produce only static outputs and struggle to model physical dynamic behaviors such as fluids, particles, and rigid body motion. This work proposes the first multi-agent framework capable of generating editable, physically consistent dynamic 4D scenes directly from text. The approach employs a planner–encoder–reviewer collaborative workflow to construct spatiotemporally coherent dynamic scenes in Blender through staged refinement, augmented with runtime state monitoring and deterministic verification mechanisms to ensure physical correctness. Additionally, we introduce a hierarchical scene protocol and establish 4DBuildBench, the first benchmark for evaluating dynamic 4D scene generation. Experiments demonstrate that our method significantly outperforms existing dynamic Blender generation baselines in both visual fidelity and physical consistency.

Existing indoor scene generation methods rely on static meshes and predefined asset libraries, struggling to produce interactive, editable, and physically plausible objects. This work proposes a code-centric generative paradigm that frames scene construction as the synthesis of executable world programs: natural language prompts are automatically compiled into structured layouts and Blender Python scripts enriched with articulated joint metadata, enabling localized editing and state traceability. The approach integrates room-level agents, a plan-design-evaluate loop, five distinct code generation strategies, and an execution-guided repair mechanism, ultimately exporting simulation-ready scenes in SDF format. The resulting assets exhibit cleaner geometry and more accurate joint semantics, significantly outperforming existing methods in downstream tasks such as robotic interaction.

Traditional evaluation based solely on compilation success is misleading in the context of multi-component, domain-specific executable game generation, as it fails to capture functional correctness and structural fidelity. This work proposes Mage, a four-axis evaluation protocol that systematically assesses Unity game scenes generated by large language models along the dimensions of compilation success, runtime execution, structural fidelity, and adherence to game mechanics. The study reveals, for the first time, a negative correlation between compilation success rate and functional correctness in this task. It further demonstrates that conditioning on an intermediate representation (IR) is crucial for enhancing structural fidelity: direct generation achieves a 43% runtime success rate but only a mechanism F1 score of 0.12, whereas IR-augmented generation boosts the F1 score to 1.00—even though the runtime success rate drops by half—highlighting the necessity of multi-axis evaluation to uncover nuanced quality differences.