Evaluating LLM Capabilities in 3D Creation and Interactive Web Delivery

    This article evaluates the capabilities of Large Language Models (LLMs) in 3D creation and interactive web delivery. Using a voxel miniature landscape generation case study, it explores why 3D generation is more complex than pure code generation, establishes a reproducible evaluation framework, and details prompt design, delivery consistency, interactive web performance, and resource quota testing strategies. The article provides actionable best practices for developers to integrate 3D generation into standardized delivery pipelines using cloud services.

    Background: 3D Creation is Becoming a New Focus for LLM Evaluation

    For a while, LLM capability evaluations primarily focused on code generation, text comprehension, and multi-turn conversations. As foundational coding capabilities become ubiquitous, the evaluation focus is shifting toward more complex spatial tasks: 3D modeling, scene reconstruction, spatial reasoning, rendering, and interactive web delivery. These tasks require models not only to understand natural language but also to maintain geometric consistency, visual fidelity, and engineering editability in three-dimensional space, thereby better exposing the model’s true level in complex task chains.

    Recently, a developer conducted a bare prompt test on an LLM platform: without attaching additional skills, only providing a theme, style, and delivery requirements, they asked the model to generate a 3D voxel miniature landscape inspired by a detective agency, and to deliver editable 3D engineering files and rendered images. The model eventually provided two rendered images and a 3D model file. After supplementing the online web delivery requirements, it generated an interactive page featuring drag-and-drop, auto-rotation, scene annotations, camera focus, model download, and image switching. Although small in scale, this case covers the complete pipeline from semantic understanding, 3D generation, and rendering to web interaction, making it an ideal sample for discussing LLM 3D creation and delivery capabilities.

    1. Why 3D Generation is More Complex than Pure Code Evaluation

    The core challenge of 3D generation tasks lies in “satisfying multiple constraints simultaneously.” Text generation only needs to ensure semantic coherence, and code generation can be verified through compilation and unit tests. In contrast, 3D scene generation simultaneously involves semantic restoration, structural integrity, geometric topology, materials and lighting, camera angles, and engineering file organization. Taking a voxel miniature landscape as an example, the model needs to understand the visual style of the “voxel block language,” identify the key structures of the main building—such as side stairs, a second-floor space, a ground-floor shop, and characters at the entrance—organize these elements into an editable scene tree, and output renderable engineering files.

    From an evaluation perspective, 3D generation cannot only focus on “whether it looks right.” A rendered image might look good visually, but if the object naming in the engineering file is chaotic, the hierarchy is missing, and the materials are non-editable, the cost of subsequent secondary creation will be very high. Conversely, if the engineering structure is complete but the rendering angle is poor, it cannot be directly used for display. Therefore, 3D generation evaluation needs to consider both visual quality and engineering usability; both are indispensable.

    2. Establishing a Reproducible Evaluation Framework

    For such tasks, a layered evaluation framework can be established:

    1. Semantic Restoration: Whether semantic elements such as the theme, key buildings, characters, signs, and storefronts appear. In the case study, the main building structure was basically present, but the iconic sign was missing, resulting in insufficient visual anchors.
    2. Structural Integrity: Whether stairs, floors, entrances, and surrounding elements are in reasonable positions, and whether spatial relationships conform to common sense.
    3. Geometric and Topology Quality: Whether the voxel style is uniform, and whether there are issues such as clipping, floating, or disproportionate scaling.
    4. Material and Rendering Quality: Whether lighting, shadows, and color filters serve the thematic expression, and whether the rendered images have display value.
    5. Engineering Editability: Whether the scene tree is layered, whether object naming is readable, whether materials and cameras are adjustable, and whether it is convenient for manual model modification.
    6. Interactive Web Completeness: Whether it includes camera controls, auto-rotation, scene annotations, camera focus, model download, image switching, and first-time user guidance.
    7. Resource Consumption and Reproducibility: Whether the generation time, rendering time, resource quotas, and failure retry costs are acceptable.
    8. Accessibility and Performance: First-screen web loading, model size, mobile adaptation, keyboard operations, and annotation readability.

    The value of this framework lies in breaking down “subjective impressions” into checkable items. For example, a “missing sign” is a semantic restoration issue, an “abstract character hairstyle” is a geometric and semantic boundary issue, and “adding unrequested web features” is a bonus for interactive completeness, but it cannot replace core visual restoration.

    3. Prompt Design: Front-loading Acceptance Criteria

    Bare prompt tests can reflect the model’s default understanding capabilities, but in engineering practice, it is more recommended to write the acceptance criteria into the prompt. An actionable prompt should include: theme and style, key visual anchors, spatial structure, deliverables list, engineering organization requirements, web feature list, and prohibitions. For example:

    1. Theme: Voxel miniature landscape of a detective agency
    2. Style: Unified voxel block language, low poly, clear outlines
    3. Key Elements: Main building, side stairs, second-floor agency, ground-floor shop, entrance characters, iconic sign
    4. Deliverables: Editable 3D engineering file, at least two rendered images from different angles, interactive page openable in a browser
    5. Engineering Requirements: Scene tree layered by building/character/sign/environment, readable object naming
    6. Web Requirements: Drag to rotate, auto-rotation, scene annotations, camera focus, model download, image switching, first-time open guidance
    7. Acceptance: The sign must appear; character proportions are reasonable; the web first screen is interactive

    Hard constraints like “the sign must appear” in the prompt are more effective than “try to restore as much as possible.” In the case study, the developer only requested an online page to open the file, but the model proactively added annotation and focus features, indicating that the model possesses a certain degree of functional extrapolation capability. However, the missing core visual element also reminds us that default generation cannot replace explicit acceptance.

    4. Delivery Consistency is Key to Engineering

    A common problem in 3D generation is that “the rendered image looks good, but the engineering file is hard to use.” During acceptance, you should check whether the rendered images are consistent with the engineering files: whether the subjects, angles, and materials in the rendered images can find corresponding objects in the engineering file; whether the scene tree contains identifiable groups for signs, buildings, characters, and environment; whether cameras and lighting are retained; and whether materials are replaceable. It is recommended to standardize the delivery package as “engineering file + rendered images + web entry + metadata.” The metadata should record the prompt version, generation time, object list, and known defects.

    When deploying in the cloud, you can use Baidu AI Cloud Object Storage to save models and rendered images, use a container platform to host rendering and conversion tasks, and use log services and monitoring alerts to observe task status. This turns “generation—rendering—acceptance—publishing” into a trackable pipeline rather than relying on manual repetitive downloads and checks.

    5. Bonus Points and Performance Boundaries for Interactive Web

    In the case study, the web page featured drag-and-drop, auto-rotation, scene annotations, camera focus, model download, image switching, and first-time guidance. These features have direct value for scenarios such as smart visualization, real estate sand tables, and city modeling. Scene annotations can bind model objects to business information, camera focus can guide presentation paths, and downloads and image switching facilitate delivery reviews. In implementation, general Web 3D rendering capabilities and annotation anchor mechanisms can be used. The pseudo-code example is as follows:

    1. function buildAnnotation(targetId, label) {
    2. anchor = scene.find(targetId)
    3. return {
    4. anchor: anchor,
    5. label: label,
    6. onClick: () => camera.focus(anchor)
    7. }
    8. }
    9. function validateDelivery(pkg) {
    10. assert pkg.hasEditableScene()
    11. assert pkg.renderImages >= 2
    12. assert pkg.sceneTree.contains("Sign")
    13. assert pkg.web.hasCameraControl()
    14. assert pkg.web.hasAnnotation()
    15. assert pkg.web.hasDownload()
    16. assert pkg.performance.firstInteractiveMs < budget
    17. }

    However, interactive features cannot come at the expense of performance. An oversized model, too many annotations, and slow first-screen loading will all affect the experience. It is recommended to set a performance budget: first-screen interactive time, model compression rate, upper limit on annotation count, and minimum mobile frame rate, and automatically check these in the acceptance gate.

    6. Resource Quotas and Testing Strategies

    3D generation and rendering typically consume more resources than text tasks. The case study mentioned that continuous testing was limited by daily quotas, which is very common in actual evaluation. It is recommended to divide testing into smoke tests, core capability tests, and extended scenario tests: smoke tests use fixed prompts to verify delivery completeness; core capability tests cover different themes and structural complexities; extended scenario tests then cover larger scenes such as real estate models and city modeling. For each test, record the prompt, deliverables, defects, and time consumed to form a reproducible evaluation set.

    7. Conclusion and Practical Recommendations

    This voxel miniature landscape generation practice shows that LLMs already possess a usable complete pipeline for 3D creation and interactive web delivery: they can generate editable engineering files and rendered images, and can extrapolate to supplement web features such as annotations, focus, and downloads. However, issues such as missing core visual anchors, abstract character models, and limited resource quotas also indicate that 3D generation still requires the collaboration of “prompt constraints + manual acceptance + engineering gates.” For developers, the safest path is to incorporate 3D generation into a standardized delivery process: define key elements, check engineering structures, verify web interactions, set performance budgets, and use cloud object storage, container platforms, logging, and monitoring capabilities to support a trackable production pipeline. Only in this way can a “good-looking” generation result be transformed into a reusable, acceptable, and iterable 3D application capability.