Hands-On Test of LLM 3D Creation: A Full Workflow from Voxel Modeling to an Interactive Web Page

    This article presents a hands-on evaluation of a large language model's 3D creation capabilities. Using a single unconstrained prompt, we asked the model to build a voxel-style miniature of a street-facing building with a coffee shop, a detective agency, and an exterior staircase. The test covers prompt design, the quality of the generated 3D model files and renders, and an unexpectedly capable auto-generated interactive web page featuring camera fly-to, scene annotations, and onboarding guidance. We conclude with practical prompting tips and engineering considerations for integrating LLM-based 3D generation into real workflows.

    1. The Shift in LLM Evaluation: From Writing Code to Building 3D

    Over the past year, the mainstream paradigm for evaluating LLM capabilities has shifted noticeably. In the early days, benchmarks focused on pure coding tasks: algorithm problem pass rates, front-end page reproduction, and multi-file project refactoring. In recent months, however, the hottest topic in the community has become 3D modeling: giving a model a natural-language description and having it directly produce editable 3D project files, rendered images, or even an interactive web page that can be dragged and rotated.

    This shift is no accident. After multiple iterations of code generation, the gap between top-tier models has narrowed to the point where only extremely fine-grained tasks can distinguish them. 3D creation, by contrast, is a comprehensive capability test: it simultaneously probes spatial reasoning, geometric intuition, material and lighting understanding, and front-end interaction engineering. Whether a model can correctly interpret spatial relationships such as “the second floor is at the top of the stairs” or “the sign hangs on the street-facing exterior wall” reveals far more about its ability to model the physical world than whether it can write a sorting algorithm.

    For this reason, vendors launching new models recently have consistently highlighted 3D creation and spatial reasoning as flagship capabilities. Some model service platforms have even launched dedicated 3D generation channels, supporting one-click selection among deliverables such as 3D model files, interactive web pages, and 3D printing files. Our hands-on test was conducted against this backdrop.

    2. Test Design: A Bare Prompt with No Assistance

    To measure the model’s “true ability,” we deliberately imposed two constraints:

    1. No skills or plugins attached — no reference images, no multi-round corrections, just a single standalone prompt;
    2. A task theme with a clear real-world reference — a street-facing small building: a coffee shop on the ground floor, a detective agency on the second floor, an exterior staircase leading to the second floor on the side, and a couple of figures at the entrance. This kind of scene is rich in elements with explicit spatial relationships, making it ideal for testing fidelity.

    The prompt template we used (reusable) is as follows:

    1. Create a 3D miniature scene themed "street-facing detective agency building"
    2. using voxel block language.
    3. Requirements:
    4. 1. Ground floor: a coffee shop with a storefront sign and display windows;
    5. second floor: the agency, with a large street-facing window;
    6. 2. An exterior staircase on the side of the building leading to the second floor;
    7. 3. Two human figures placed at the entrance as decoration;
    8. 4. Deliver an editable 3D modeling project file and rendered images.

    The model ultimately delivered two rendered images and one editable modeling project file.

    3. Result Analysis: Good Fidelity, but a Key Element Missing

    The conclusion first: overall fidelity is acceptable, but it does not deserve full marks.

    What it got right: The building structure was essentially complete. The side staircase, the second-floor room, and the layered relationship of the ground-floor shop were all correctly expressed. The proportions and color palette of the voxel blocks were well coordinated, and the model even proactively added two figures at the entrance. This shows the model has developed reliable reasoning for spatial structures such as “multi-story building + exterior staircase.”

    Where it lost points: The most recognizable visual anchor of the scene — the agency sign hanging on the wall — was not generated. This exposes a typical weakness of current 3D generation: models are good at reproducing structural elements (walls, floors, staircases), but their recall of identifying elements (signs, text decals, decorative details) is noticeably lower. The reason is not hard to understand: voxel language inherently struggles with continuous curved surfaces and text, and an element like a “sign” in the prompt has no geometric prototype for the model to analogize from, so it was silently dropped.

    The practical takeaway: key visual elements must be described explicitly and executably in the prompt. For example, rewriting “agency sign” as “use red and white voxel blocks to form a rectangular sign on the street-facing exterior wall of the second floor” significantly improves the model’s adherence.

    4. A Pleasant Surprise: The Self-Completion Ability of the Interactive Web Page

    The truly impressive part of this test was the interactive web page the model generated on its own initiative, without being explicitly asked to do so. The prompt only mentioned “open the model in a web page,” but the delivered page included a full set of features beyond expectations:

    • Basic interaction: drag-to-rotate, zoom, and auto-cruise showcase — the standard toolkit;
    • Scene annotation: label anchors attached to key elements in 3D space, with positions updated in real time as the viewpoint changes;
    • Camera focus: a sidebar lists the scene elements; clicking one smoothly flies the camera to the corresponding element and highlights it. The core logic can be abstracted into the following pseudocode:
    1. // General approach for camera focus
    2. function focusOn(elementId) {
    3. const box = getBoundingBox(elementId); // compute the element's bounding box
    4. camera.flyTo({
    5. target: box.center, // look at the element center
    6. position: box.center.offset(dir, distance), // step back along a suitable direction
    7. duration: 600
    8. });
    9. highlight(elementId); // outline or brighten the element
    10. }
    • Deliverable integration: the modeling project download entry and the rendered-image preview toggle were integrated into the same page, forming a complete delivery loop;
    • First-time onboarding: a drag-operation guide appears on first open, lowering the barrier for users unfamiliar with 3D interaction.

    The practical value of this feature set should not be underestimated. In business scenarios such as real-estate sandboxes, smart campuses, and urban planning visualization, “scene annotation + camera focus” happen to be the two most commonly used features. An interaction layer that previously required a front-end engineer to hand-write for days on top of a WebGL rendering library can now be prototyped from a single prompt — an order-of-magnitude efficiency gain during early-stage project validation.

    5. Practical Recommendations and Engineering Considerations

    Based on this hands-on test, we summarize four actionable lessons:

    1. Evaluate 3D capability by “spatial relationships,” not “element count.” Fidelity in layered structures, occlusion relationships, and directional descriptions distinguishes strong models from weak ones far better than piling on details.
    2. Key elements must be written out with explicit geometric features — do not expect the model to infer identifying decorations on its own.
    3. Leverage the model’s “self-completion” tendency. For interaction requirements, give only the minimum goal; the model will often fill in value-added features such as annotations, focus navigation, and onboarding guides. Trimming from there is more efficient than enumerating every requirement.
    4. Pay attention to asset management during production deployment. Generated model files are large; hosting them in object storage and distributing them via CDN is recommended. Pairing the interactive page with logging services and monitoring alerts provides availability assurance, enabling you to quickly set up a lightweight 3D visualization delivery pipeline.

    The only caveat is usage quota limits. A single complex 3D task consumes far more tokens than an ordinary conversation, and batch-generating multiple design variants can easily hit the ceiling. It is advisable to prioritize tasks in your orchestration and reserve quota for the most critical validation rounds.

    6. Conclusion

    Judging from this test, current first-tier LLMs have crossed the “usable” threshold for 3D creation: spatial structure reasoning is reliable, interactive web page delivery is complete, and they already offer practical value for prototype validation. The weaknesses are concentrated in the recall of identifying details and the inherent expressive limits of voxel language — both of which can be partially compensated for through more refined prompt engineering. For developers working in visualization, digital twins, and smart-space domains, now is the right time to bring LLM-based 3D generation into the toolchain: use it to rapidly lay out prototypes, then let humans handle the fine polishing. The boundary of human-machine division of labor is becoming clear.