LLM 3D Generation in Practice: From Prompt Design to Deliverable Evaluation
This hands-on evaluation tests an LLM’s 3D generation ability using a bare prompt, asking it to create a Blender voxel miniature and then an HTML/Three.js interactive page. It assesses structural fidelity, detail quality, deliverable completeness, and proactive completion, highlighting missing iconic elements and the model’s unprompted interaction features. The article concludes with prompt-design guidance, application scenarios, and practical quota and availability considerations.
1. Background: 3D Creation Is Becoming a New Focus for Model Evaluation
Over the past year or so, the focus of large-model evaluation has shifted noticeably. Early comparisons concentrated on pure text-based coding tasks such as code completion and algorithm problem solving. As models gradually converged on code quality, simply asking whether a model could write correct code was no longer enough to differentiate them. A more popular way to test models now is to have them produce visual and interactive outputs, with 3D modeling and Three.js web interactions being especially representative.
The reason is not hard to understand: 3D creation is a composite task that tests several underlying model capabilities at once.
- Spatial reasoning: The model must construct a three-dimensional scene structure in its “mind” and understand the relative positions of floors, stairs, and storefronts.
- Code generation: Blender relies on Python scripts, while web interaction depends on a combination of Three.js, CSS, and JavaScript.
- Aesthetics and detail restoration: Color choices, proportions, and trade-offs around iconic elements directly determine whether the deliverable “looks right.”
- Task planning: A single generation often involves modeling, rendering, packaging, and web wrapping. The model must break down the workflow on its own.
For this reason, 3D tasks have become a touchstone for evaluating a model’s overall capabilities, and they are also a key promotional direction when vendors release new versions. Many platforms have begun to follow suit on the product side, for example by offering dedicated 3D generation channels that let users directly choose outputs such as Blender projects, interactive webpages, or printable model files.
2. Test Design: Using a Bare Prompt to Reflect Real Capability
2.1 Why Use a Bare Prompt
This test deliberately avoided any preset skills, external tool mounting, or complex multi-turn guidance. It used only a simple original prompt. The reason is that the value of evaluation lies in reproducing the first-hand experience of an ordinary user. If a large amount of engineered prompt technique is added, what gets tested is “prompt engineering” rather than the model itself.
The core prompt used was as follows (example):
Create a 3D voxel miniature landscape in Blender themed around a classic animated scene.Use an iconic building as the visual highlight and express it in a voxel block language.Deliver an editable Blender project file and rendered images.
The prompt was intentionally kept short. It constrained only the theme, style (voxel), tool (Blender), and delivery format, leaving all other details to the model. Another purpose of this approach is to observe the model’s “proactive completion” ability: whether it can make reasonable or even unexpectedly good design decisions in places the user did not explicitly specify.
2.2 Evaluation Dimensions
For 3D generation tasks, I suggest a four-dimensional evaluation framework:
| Dimension | What to Examine | Weight |
|---|---|---|
| Structural fidelity | Whether core scene elements are complete and proportions are reasonable | High |
| Detail quality | Iconic elements, character modeling, materials, and color palette | High |
| Deliverable completeness | Editability of project files and render quality | Medium |
| Proactive completion | Valuable functions that were not requested | Medium |
3. Test Results Analysis
3.1 Model Deliverables: Acceptable Structural Fidelity, Missing Key Details
The model ultimately delivered a Blender project file and two rendered images. Structurally, the fidelity was acceptable: the main frame of the target building, the outdoor staircase leading to the second floor, the office space on the second floor, the ground-floor storefront, and even two character models at the entrance were all present. The voxel style was also fairly consistent, and the block granularity and color palette basically matched the theme’s atmosphere.
The problem was that the most recognizable element in the scene—the prominent signboard on the building’s exterior wall—was missing. For a task whose core goal is “theme restoration,” this is a serious flaw. The signboard is exactly the visual anchor of this scene. Without it, the model’s “looks like” score is discounted.
This case reveals a general pattern: when making trade-offs about elements in 3D generation, large models often base decisions on “how prominent the element is in the training data” rather than “how important the element is in the task.” Elements such as text signboards, which require precise layout and font modeling, are precisely the model’s weak spot and are easily dropped silently during generation. Therefore, during evaluation, it is necessary to list the “iconic element checklist” in advance and check each item, rather than scoring based on overall impression.
Another detail issue appeared in character modeling: the hairstyle of one female character was clearly distorted and difficult to identify. This shows that under voxel-style constraints, fine-grained character feature expression remains difficult. The model tends to approximate with simplified geometry, sacrificing recognizability.
3.2 Web Deliverable: Proactive Completion Is the Biggest Highlight
Because the original prompt did not explicitly request a webpage, I added the instruction “open in HTML.” This part unexpectedly became the highlight. The interactive page generated by the model included:
- Basic interaction: Drag-to-rotate and auto-rotate display, which are standard features.
- Scene annotations: Automatic text labels for key elements in the scene. This feature is very practical in smart visualization projects such as real-estate sandboxes, city modeling, and park management dashboards. The model proactively added this layer of “business understanding.”
- View focus: A sidebar lists key elements in the scene, and clicking one smoothly transitions the camera to the corresponding view. In Three.js, this type of feature requires camera interpolation and target-point calculation, so it has a certain level of implementation complexity.
- Deliverable integration: The Blender file download entry and rendered-image preview switching are packaged into the page, forming a complete delivery loop.
- Onboarding guidance: The drag-operation guidance shown on first open reflects consideration for user experience.
// Core logic for view focus: interpolate camera position and look-at targetfunction focusOn(target) {const from = camera.position.clone();const to = target.viewPosition.clone();const lookFrom = controls.target.clone();const lookTo = target.lookAt.clone();animate(from, to, lookFrom, lookTo, 600); // 600 ms easing}
It is worth noting that my prompt did not mention these features at all. Based on the task context of “3D scene display,” the model independently inferred a complete and reasonable interaction scheme. This ability to reason from a vague requirement to a complete solution is more practical than models that only do as well as the prompt is detailed—because in real business settings, stakeholders often can provide only vague descriptions.
3.3 Rendering Quality
The composition and filter effects of the two rendered images were good, and the light-and-shadow layers were natural. As deliverables, they were fully usable. This shows that the model has already formed a relatively mature strategy for “rendering parameter selection,” including light source placement, camera angle, and color grading.
4. Implications for Developers
4.1 Prompt Design Recommendations
Based on this test, here are three prompt lessons for 3D generation tasks:
- Explicitly list iconic elements: Do not assume the model will automatically preserve the most important visual anchor. State directly that “the XX signboard must be included.”
- Specify deliverable types: Declare project files, rendered images, and interactive webpages separately to avoid omissions.
- Make style constraints specific: “Voxel style,” “low-poly,” and “photorealistic” differ greatly, so be explicit.
4.2 Application Scenario Outlook
This combination of “model generation + web interaction” naturally fits several types of business:
- Smart city / real-estate sandbox: Quickly generate interactive scene prototypes and use view focus and scene annotations for proposal demonstrations.
- Game level prototyping: Voxel style is itself a game art language and can be used directly for level layout validation.
- Culture, tourism, and exhibitions: Miniature landscapes plus annotated tours enable low-cost digital exhibition prototypes.
5. Open Issues: Quota and Availability
The test also encountered real-world limitations: when calling the model through a third-party integration platform, the daily quota was limited. The original plan to continue testing more complex real-estate sandboxes and smart city scenes had to be postponed. In addition, the tight invocation quotas widely reported by the community during the early release of new models also reminds us that quota strategy and cost model need to be included in evaluation dimensions during model selection. Beyond technical capability, availability is also part of engineering decisions.
Overall, this hands-on test validates a trend: large models are moving from “writing code” to “delivering works,” and the combination of 3D creation and interactive webpages already has a practical prototype. For developers, now is a good time to add these capabilities to the prototyping toolbox—but remember to prepare your “iconic element checklist” before evaluation.
