Evaluating LLMs for Code Generation and 3D Rendering: Capability Progress and Aesthetic Gaps

    This article reviews a preview of a next-generation general-purpose large language model through hands-on technical evaluation focused on code generation, interactive animation, 3D rendering, and aesthetic expression. It examines how the model converts natural-language requirements into runnable code, structured interactions, and visual scenes, while identifying weaknesses in physical realism, visual reasoning, and iterative refinement. It also outlines practical evaluation criteria and prompt strategies for developers who want to move from demos to reliable production workflows.

    A next-generation general-purpose large language model preview has entered public testing. Unlike earlier rounds that emphasized language understanding and Q&A, this round moves closer to real development workflows: the model is expected not only to describe a solution, but also to produce runnable code, interactive pages, visualizations, and even some level of agentic task orchestration. For developers and enterprises, this shift suggests that LLMs are moving from assisted Q&A tools toward programmable task executors.

    However, whether such models can enter production processes cannot be judged by demo appeal alone. The more important questions are whether they can complete complex tasks reliably and whether the output is maintainable, reproducible, and evaluable. In tasks involving code generation, 3D scene construction, lighting, and materials, the model must do more than produce syntactically valid content; it must also account for visual aesthetics, physical laws, and engineering constraints. This article evaluates current capabilities from three angles—code ability, 3D rendering ability, and aesthetic expression—to help readers understand the boundaries and optimization priorities of today’s LLMs.

    1. Evaluation Background: From Text Output to Deliverable Artifacts

    Earlier LLM evaluations often focused on knowledge Q&A, text summarization, and code completion. These tasks tend to have relatively short-lived outputs and strong verifiability. For example, one can judge whether a question was answered, whether the correct function was completed, or whether the paragraph meaning was understood.

    The newer model capabilities push evaluation into a more complex layer: the model is expected to generate a complete application, an interactive animation, a scene with lighting and materials, or an executable workflow. This raises the bar:

    1. Semantic understanding: extract goals, constraints, priorities, and implicit requirements from natural language.
    2. Code organization: generate complete programs that are structured, runnable, and extensible, not just isolated snippets.
    3. Visual expression: understand space, lighting, materials, composition, and aesthetic atmosphere in graphic tasks.
    4. State management: handle runtime logic such as animation, interaction, asynchronous tasks, and error recovery.
    5. Engineering constraints: consider offline operation, dependency control, resource usage, compatibility, and performance limits.

    Therefore, this evaluation does not only ask whether the model can generate content. It also examines whether it can turn vague requirements into executable engineering artifacts, maintain stable output under multiple constraints, and produce results that are genuinely usable.

    2. Classic Interactive Animation Test: Clear Improvement in Code Structure

    The first test selected a typical interactive animation task: generate a runnable animated scene, such as a character riding a dynamic object, with playback, pause, speed adjustment, and day/night switching. The final output should be exportable and runnable offline without network access.

    This task looks simple but involves several engineering details. The model must not only generate graphics but also handle:

    • hierarchical organization of graphical objects;
    • timeline or frame-driven animation logic;
    • speed control variables and user interaction entry points;
    • state transitions such as pause, resume, and reset;
    • day/night mode or environment switching;
    • self-contained execution after export.

    The results show strong structured generation. The model can proactively split functionality into modules and generate code containing state variables, a render loop, event listeners, and control panels. For example, it may define separate variables for speed, running state, and time offset, update the scene through a unified rendering loop, and bind interactive controls to animation state so users can adjust playback behavior in real time.

    A simplified example of the generated logic:

    1. let speed = 1;
    2. let playing = true;
    3. let phase = 0;
    4. function update(delta) {
    5. if (playing) {
    6. phase += delta * speed;
    7. }
    8. render(phase);
    9. }
    10. function loop(timestamp) {
    11. update(0.016);
    12. requestAnimationFrame(loop);
    13. }
    14. requestAnimationFrame(loop);

    The example is simple, but it illustrates the model’s path from requirement to code: abstract the animation into a time phase, treat speed as an independent control parameter, and update the scene continuously in a loop. Such code may not be suitable for large engineering projects, but it is practical for prototype validation, interactive demos, teaching examples, and rapid page building.

    More importantly, the model shows some “delivery awareness.” It tends to avoid relying on external image assets and tries to embed drawing logic directly in the code. It also tends to provide parameter controls so users can adjust runtime behavior. This suggests the model is not merely stacking syntax; it is attempting to satisfy a practical engineering goal: runnable output.

    There are still potential issues. Whether the code is readable, whether variable naming is reasonable, and whether the logic supports secondary development still require human review. The generated structure may appear complete at first glance, but complex projects may still need refactoring, testing, and permission controls. In scenarios involving user data, network requests, or file uploads, the generated result should not be assumed to be secure by default.

    3. Complex Lighting Scene Test: Physical Realism Becomes the Dividing Line

    The second test is more challenging: use code to draw a scene with afternoon lighting. The goal is not to generate an image directly, but to construct space, light sources, shadows, materials, and perspective through code, producing a visual result close to real photography or offline rendering.

    This task is harder than interactive animation because correct code is not enough; the model must also understand visual physics. A believable image usually requires simultaneous handling of:

    • Light sources and direction: direct light, ambient light, reflected light, caustics, etc.;
    • Shadow quality: hard shadows, soft shadows, contact shadows, penumbra transitions;
    • Material response: diffuse reflection, specular reflection, roughness, metalness, subsurface scattering;
    • Spatial layering: occlusion and perspective between foreground, middle ground, and background;
    • Color management: color temperature, contrast, tone mapping, gamma correction;
    • Post-processing atmosphere: depth of field, noise, glow, atmospheric perspective, grain.

    In this test, the model can quickly build a room or indoor scene with basic spatial structure and generate elements such as windows, walls, floors, and furniture through code. Its advantages are fast generation, clear structure, and the ability to express an initial layout and lighting setup. The effect of window light entering the room at an angle can already show basic spatial perspective and light direction.

    However, compared with the frontier level, the gap remains obvious. The problem is not simply whether the image was produced, but whether the result has realism and aesthetic persuasiveness. Common shortcomings include:

    1. Harsh shadow transitions: some shadow edges are too sharp and lack soft shadows and indirect light influence.
    2. Weak material differentiation: the reflections of walls, floors, wooden furniture, and metal objects are not sufficiently natural.
    3. Flat spatial layering: objects appear placed independently in the scene, lacking realistic occlusion and lighting interaction.
    4. Weak lighting narrative: the image has light, but does not create a clear sense of time, mood, or compositional focus.
    5. Insufficient detail: subtle changes in real scenes, such as corners, edges, seams, dust, and reflections, are underrepresented.

    The root cause is insufficient visual aesthetics and physical reasoning. Code can generate geometric shapes, but the model may not understand why a shadow should be softer, why a material should attenuate under certain lighting, or why a scene needs a more natural contrast. In other words, the model has crossed the threshold of “can produce it,” but has not fully crossed the threshold of “is it attractive and convincing?”

    4. Aesthetic Gaps: The Missing Piece Is Visual Reasoning, Not Code

    Overall, the model shows clear improvement in code generation, interaction logic, and 3D scene construction. It can decompose complex tasks into structured steps and refine results over multiple prompts. Yet aesthetic expression remains a noticeable weakness.

    This weakness appears in three areas.

    4.1 Limited Understanding of Abstract Aesthetic Goals

    User prompts often include abstract phrases such as “serene,” “interplay of light and shadow,” “perfection,” or “ultimate refinement.” These terms cannot be directly mapped to code parameters. The model must translate them into concrete visual strategies, such as lowering saturation, strengthening soft shadows, optimizing warm-cool contrast, or controlling brightness near the center of the image.

    Current models often tend to stack visual elements—adding more objects, more lights, and more decorations—rather than making tradeoffs around a core mood such as “a serene afternoon.” Mature visual generation should know which elements to strengthen, which to weaken, where to leave blank space, and which lighting should become the visual focus.

    4.2 Incomplete Understanding of Physical Realism

    In 3D rendering, realism comes not from the number of details but from consistency with physical laws. Under the same light source, different materials should reflect light differently. Within the same space, distant objects should be affected by atmospheric perspective. In the same image, shadows should not be simply pure black; they should be influenced by ambient light.

    The model can more easily generate scenes that “look shaped,” but remains unstable in material response, indirect lighting, soft shadows, and reflection falloff. This is one reason its scenes can look like stage sets rather than believable environments.

    4.3 Limited Self-Correction Across Multiple Rounds

    High-quality visual tasks usually require a closed loop: generate, observe, tune parameters, re-render, and compare. For example, developers may first define the camera angle, then adjust the main light source, soften shadows, add ambient light, and finally perform tone mapping and detail enhancement.

    The current model can accept multiple prompts, but its ability to identify problems autonomously is limited. It is better at executing explicit instructions than proactively pointing out that shadows are too hard, reflections are too strong, or the composition is off-center. Therefore, human aesthetic judgment remains essential in practical use.

    5. A Developer-Focused Evaluation Method: Do Not Rely on Demos Alone

    For enterprises and technical teams, evaluating these models should not rely on one or two impressive demos. A more reasonable approach is to build a layered evaluation system that breaks tasks down from easy to difficult and defines clear metrics.

    Evaluation can be organized across the following levels:

    5.1 Runnability

    Can the generated code run directly? Are there syntax errors, missing assets, path errors, or dependency issues? Can it work in offline or restricted environments?

    5.2 Interactivity

    If the task includes interaction, did the model implement necessary state management? Are pause, resume, reset, and parameter adjustment functions complete? Is interaction feedback timely?

    5.3 Maintainability

    Is the generated code well structured? Are naming conventions reasonable? Are modules properly separated? Is the code easy to extend and maintain in team settings?

    5.4 Visual Completeness

    For graphic tasks, evaluate composition, proportions, lighting, materials, color, details, and overall atmosphere. The question is not only whether something exists, but whether it looks good.

    5.5 Stability and Reproducibility

    If the same prompt is run multiple times, are the results stable? Are there obvious random fluctuations? After parameter changes, is the original structure preserved? For enterprise use, stability often matters more than a single impressive output.

    5.6 Security and Compliance

    Could the generated code introduce unsafe logic? Does it involve sensitive data processing? Does it require permission isolation or sandbox execution? In cloud-hosted environments, the generation process should be audited and tracked with general capabilities such as container platforms, object storage, logging, and monitoring/alerting.

    6. Prompt Design: From Vague Description to Verifiable Requirements

    In complex code and visual generation tasks, prompt quality directly affects output quality. Compared with a simple request such as “draw me an afternoon room,” a more effective prompt should include goals, constraints, structure, and acceptance criteria.

    A reference prompt structure is:

    1. Please generate a standalone visual demo program with the following requirements:
    2. Goals:
    3. - Show an indoor afternoon lighting atmosphere.
    4. - Use windows, walls, floors, and chairs as the main elements.
    5. - Emphasize a calm, soft, and realistic lighting experience.
    6. Technical constraints:
    7. - Generate everything with code only; no external images.
    8. - Run directly in a local browser.
    9. - Output a single file or a small number of necessary files.
    10. - Do not rely on complex external services.
    11. Visual requirements:
    12. - Window light enters the room at an angle.
    13. - Shadow edges are soft and influenced by ambient light.
    14. - Wooden floor and wall materials are visually distinct.
    15. - The image has clear light and dark layering.
    16. - The color tone is warm but not oversaturated.
    17. Interaction requirements:
    18. - Support switching between day, dusk, and night.
    19. - Support adjusting light intensity.
    20. - Support pausing and resuming animation.
    21. - Start automatically after page load.
    22. Acceptance criteria:
    23. - The page opens without errors.
    24. - All interactions work.
    25. - The scene has clear spatial layering.
    26. - Shadows do not show obvious hard-edge breaks.
    27. - The overall effect is close to a realistic indoor photography atmosphere.

    The advantage of this approach is that it turns aesthetic requirements into observable and verifiable indicators. For example, “soft shadows” can be assessed by checking edge transitions, “material differentiation” can be checked through highlights and reflections, and “calm atmosphere” can be evaluated through saturation and contrast control. The model may not satisfy every point in one attempt, but evaluators can identify the gaps more clearly.

    7. Engineering Practice: How Enterprises Can Use These Capabilities

    For enterprises, progress in code and visual generation does not mean unattended deployment. A safer approach is to integrate the model into the development workflow rather than replace engineers entirely.

    In prototype development, the model can help generate page skeletons, interactive components, animation scripts, and visual demos. For example, a product manager may need to validate a dashboard layout, a designer may need to explore lighting options quickly, an education team may need interactive courseware, and a marketing team may need an initial event page. In these cases, the model reduces the cost of moving from idea to prototype.

    For complex engineering, generated results require stricter validation. Recommended practices include:

    1. Static checks: scan generated code for syntax, style, dependencies, and vulnerabilities.
    2. Sandboxed execution: run model output in an isolated environment to protect production systems.
    3. Automated regression: preserve historical test cases as an evaluation set to detect capability regressions after version updates.
    4. Human aesthetic review: visual tasks cannot rely only on automated metrics; professionals must judge aesthetic quality.
    5. Version comparison: generate multiple outputs for the same prompt and compare versions to observe stability and improvement.
    6. Log tracking: record input prompts, outputs, runtime status, and errors for later analysis.
    7. Permission control: when code execution, file access, or network calls are involved, apply least-privilege principles.

    When building similar capabilities in the cloud, general cloud infrastructure can support evaluation and release workflows. For example, container platforms can run sandboxed environments for generated artifacts, object storage can store code, images, render results, and evaluation records, logging services can capture call traces, and monitoring/alerting can observe failure rates, latency, and resource consumption. This improves efficiency while keeping the process traceable, auditable, and reviewable.

    8. Capability Leap and Aesthetic Gaps Coexist

    Overall, the model shows clear progress in code generation, 3D scene construction, and interaction logic. It can no longer be described as merely producing text fragments; it can output relatively complete program structures around complex tasks. In interactive animation, parameter control, page prototyping, and visualization demos, it already has practical value.

    However, the gap remains clear in advanced visual creation. Complex lighting, realistic materials, spatial layering, and aesthetic atmosphere cannot be solved by code volume alone. They require stronger visual reasoning, physical understanding, and aesthetic alignment. The current model can “complete tasks,” but is still far from “creating works.” It can “build scenes,” but is still far from “creating realism.”

    Therefore, the rational judgment is this: the model is already an efficient assistant for developers, especially for prototype validation, teaching demos, interactive component generation, and rapid creative exploration. But for high-precision visual presentation, professional rendering, complex engineering architecture, and final artistic quality, deep human involvement and toolchain support remain necessary.

    From an industry perspective, the combination of LLMs with graphics rendering, 3D content, and agentic tasks is deepening. Future competition will not be based only on parameter scale or benchmark scores. The key question is whether models can deliver reliably in real development workflows. Enterprises should care not only about whether a model can generate output, but whether it can continue producing usable results under safe, controllable, and maintainable conditions. For developers, the best strategy at this stage is not to wait for perfection, but to establish evaluation systems, prompt standards, and engineering loops early, then gradually unlock the model’s value in real projects.