Chinese Flagship Multimodal Model Tested: Code and 3D Capabilities Improve, Aesthetic Control Still Lags

    A practical evaluation of a new-generation Chinese flagship multimodal model through end-to-end tasks rather than leaderboard scores. The article examines vector animation generation, code-based interior scene rendering, and 3D prototype capabilities, finding that the model can produce runnable interactive front-end demos and stronger spatial and geometric results, but still struggles with lighting realism, material differentiation, spatial subtlety, and aesthetic detail. It proposes a layered evaluation framework covering basic usability, functional completeness, engineering quality, visual quality, and iterative repair, and discusses how such models change developer workflows while remaining dependent on human review and engineering standards.

    As Chinese large models continue to iterate, competition is shifting from “can it answer a question?” to “can it complete a complex task?” This is especially true in code generation, multimodal understanding, interactive page construction, and 3D content creation. Whether a model is truly engineering-ready cannot be judged only by public leaderboard scores; it also needs to be tested through continuous tasks, real projects, and reproducible results.

    Recently, a flagship multimodal model from China opened preview access. Official public information did not disclose the full parameter scale, training data composition, or all benchmark results, but from its product positioning, the main improvement areas appear to be world knowledge, multimodal perception, code generation, and agentic task execution. For developers, whether these capabilities translate into real productivity still needs to be validated through specific cases.

    This article does not discuss a specific brand or product. Instead, it takes a general technical perspective to analyze how new-generation Chinese flagship models perform in code, animation, 3D scenes, and visual aesthetics, and further discusses the potential impact of such models on development workflows and the industry ecosystem.

    Why Evaluate Models on Real Tasks, Not Leaderboards

    Large model evaluation usually includes knowledge Q&A, mathematical reasoning, code completion, long-text understanding, and multimodal recognition. These metrics help compare models horizontally, but they do not fully represent the daily experience of developers.

    For example, if a model can generate the correct answer to a single-turn code problem, that does not mean it can complete a real project. Actual development often includes the following steps:

    1. Understanding vague requirements;
    2. Choosing an appropriate technical route;
    3. Organizing the project directory;
    4. Writing multiple interdependent files;
    5. Running the code and locating errors;
    6. Continuously revising based on visual effects or user feedback;
    7. Handling compatibility, performance, and security issues.

    Therefore, when testing flagship models, it is better to use a complete “requirement-to-result” chain rather than only extracting a snippet of code that looks correct.

    This kind of testing is particularly useful for observing four capabilities:

    • Task decomposition: Can the model break a complex goal into executable steps?
    • Code implementation: Can it generate clear, runnable, and maintainable code?
    • Visual and spatial understanding: Can it correctly handle layout, lighting, materials, and hierarchy?
    • Iterative correction: When errors occur, can it make effective improvements based on the results?

    Animation Generation Test: From Static Pages to Interactive Work

    A common test task is to generate an animation of an animal riding a bicycle. On the surface, the task is simple, but it actually examines graphics drawing, animation timing, geometric transformation, and interaction design at the same time.

    The model needs to do more than draw a subject. It also has to handle details such as:

    • The rotation of the bicycle’s two wheels;
    • The relative position between the animal’s body and the frame;
    • The periodic motion of the feet or legs;
    • Dynamic effects for accessories such as a scarf and hat;
    • Continuous background scrolling or parallax changes;
    • Interactive controls for play, pause, and speed adjustment;
    • Standalone operation in an offline environment.

    In actual tests, the current generation of models can already generate a relatively complete vector animation page. It usually uses browser-native graphics capabilities, splits the subject into multiple graphic elements, and then controls rotation, translation, and opacity changes through time functions. For developers, this means the model is no longer limited to generating a static sample snippet; it can preliminarily complete an interactive front-end mini-application.

    For vector animation, a reasonable implementation usually includes the following structure:

    1. <svg viewBox="0 0 900 500">
    2. <g id="background">
    3. <!-- Coast, sky, and decorative elements -->
    4. </g>
    5. <g id="vehicle">
    6. <!-- Frame, wheels, and pedal structure -->
    7. </g>
    8. <g id="character">
    9. <!-- Main body, hat, and scarf -->
    10. </g>
    11. </svg>
    12. <script>
    13. let speed = 1;
    14. function updateAnimation(time) {
    15. const cycle = (time * speed) % 1000;
    16. const wheelAngle = cycle / 1000 * 360;
    17. document.querySelectorAll('.wheel')
    18. .forEach(item => {
    19. item.style.transform = `rotate(${wheelAngle}deg)`;
    20. });
    21. requestAnimationFrame(updateAnimation);
    22. }
    23. requestAnimationFrame(updateAnimation);
    24. </script>

    Of course, a truly usable implementation still needs to handle transform origins, coordinate systems, animation synchronization, and browser compatibility. Code generated by the model often “moves visually,” but hidden issues may remain, such as an offset wheel rotation center, inconsistent animation cycles across elements, or missing style definitions after export.

    Therefore, testing should not rely only on the preview effect in the chat window. The files should be exported and run separately, and the following questions should be checked:

    • Does it depend on external resources?
    • Can it still play after the network is disconnected?
    • Does it behave consistently across browsers?
    • Is the animation stable after adjusting playback speed?
    • Does the page contain a large number of invalid nodes?
    • Is the code easy to modify further?

    This test shows that the new model already has strong ability in “turning an idea into a runnable work,” but there is still a gap between it and professional animation engineering.

    Code-Based Drawing Test: Correct Implementation Is Not Excellent Presentation

    The second type of test asks the model to use code to generate an interior scene with complex lighting relationships. This task exposes the model’s weaknesses more clearly than ordinary page development because it involves programming design, geometric modeling, lighting calculation, and artistic expression at the same time.

    Test goals usually include:

    • An interior space with a window;
    • Afternoon sunlight slanting into the room through window panes;
    • Clear spatial relationships among walls, floor, and furniture;
    • Light gradually transitioning from bright areas to dark areas;
    • Shadow direction, edges, and softness matching real-world rules;
    • An overall quiet and natural atmosphere.

    The model may take multiple technical routes.

    The first is to use 2D drawing APIs to simulate lighting through polygons, gradients, and transparency masks. This approach runs quickly and is suitable for visual effects in web pages, but it easily leads to harsh shadow edges and inaccurate spatial perspective.

    The second is to use 3D graphics APIs to build a room, window, furniture, and light source in the browser, and then generate the image through real-time rendering. This method can express more realistic spatial relationships, but it places higher demands on the model’s geometric modeling, material settings, and lighting parameters.

    The third is to write a simplified ray tracing or path tracing program. In theory, this can achieve more natural lighting results, but the computational cost is high, and it requires attention to sampling count, bounce count, denoising strategy, and material models.

    From actual results, Chinese flagship models are already fairly mature at “drawing a room,” but there is still a gap when it comes to “drawing a room with photographic quality and artistic appeal.” Common issues include:

    • Wall corners are too sharp;
    • Contact shadows between objects are insufficient;
    • Plants, furniture, and floors lack material differences;
    • The transition from bright to dark lighting is not natural enough;
    • The composition is reasonable, but delicate atmosphere control is missing;
    • Objects are positioned correctly but look like assembled geometric models.

    This shows that code capability and aesthetic capability are not the same dimension. The model can correctly understand semantic elements such as “window, sunlight, chair, floor,” and it can generate a runnable program, but that does not mean it has mastered the detailed rules of photography, painting, and visual design.

    In other words, the model may know that “there should be a beam of light,” but it cannot necessarily decide accurately:

    • From which angle the light should enter to look most natural;
    • How far the shadow should extend;
    • How soft the shadow edge should be;
    • How different materials should reflect light;
    • Where the visual subject should be placed;
    • Which areas need negative space;
    • How to use color temperature to create an afternoon atmosphere.

    Technical Reasons for Improved 3D Capabilities

    Progress in 3D-related tasks usually comes from several factors working together.

    First, multimodal training makes it easier for the model to build correspondences among “image—text—geometry.” The model does not only recognize the name of an object; it can also try to understand the object’s orientation, hierarchy, and spatial position.

    Second, code training data includes many examples of front-end graphics, 3D scenes, and game development, enabling the model to reuse common geometric modeling patterns. For example, it can organize complex objects through rotation, translation, scaling, and hierarchical nodes.

    Third, agentic execution mechanisms allow the model to continue running, checking, and modifying code after generation, rather than outputting a final answer in one shot. This “generate—execute—observe—correct” loop is especially important for 3D tasks.

    However, stronger 3D capabilities do not mean the model already has complete professional production ability. Complex 3D projects also involve:

    • Asset management;
    • Topology;
    • Material nodes;
    • Lighting baking;
    • Collision detection;
    • Animation rigging;
    • Rendering performance;
    • Multi-device compatibility.

    For these issues, the model is currently better suited to prototype design, script generation, and local optimization, rather than completely replacing experienced art and graphics programming teams.

    The Most Obvious Weakness: Aesthetics and Detail Control

    Code generation is relatively straightforward to evaluate: Does it run? Is it correct? How is performance? How high is maintenance cost? Aesthetics is more complex because it involves cultural experience, visual order, emotional expression, and detail consistency.

    Common aesthetic issues in current large models can be summarized at three levels.

    1. Correct Composition but No Focal Point

    The model can usually put all requested elements into the frame, but it does not necessarily know what should become the visual center. The result may be complete in information, but the subject is not prominent, and the image feels evenly weighted.

    2. Complete Structure but Lack of Material Differentiation

    Walls, wooden floors, metal, glass, and fabric require different reflection, roughness, and texture expressions. The model can often generate these objects, but it tends to use similar colors and lighting methods, making the scene lack realism.

    3. Atmosphere Present but Lacking Subtle Variation

    Descriptions such as “quiet,” “warm,” and “afternoon” are relatively abstract. Excellent work needs to express them through color temperature, contrast, shadow softness, depth of field, and composition together. Model-generated results sometimes simply overlay a warm filter and cannot form a complete emotional hierarchy.

    How to Design a More Reliable Model Evaluation Workflow

    For developers and enterprise users, it is advisable to build a layered evaluation system rather than drawing conclusions from a single case.

    The first layer is basic usability testing: confirm whether the model can generate runnable code and check syntax, dependencies, and file structure.

    The second layer is functional completeness testing: verify interactive controls, state management, exception handling, and offline operation.

    The third layer is engineering quality testing: focus on code readability, modularity, duplicate logic, performance, and security.

    The fourth layer is visual quality testing: conduct human evaluation of composition, lighting, materials, spatial relationships, and style consistency.

    The fifth layer is iterative capability testing: after the first result, request modifications and observe whether the model can accurately locate the problem rather than regenerate a completely different solution.

    In enterprise environments, these indicators can also be incorporated into internal acceptance criteria, such as:

    • First-generation success rate;
    • Average number of repair rounds;
    • Stability after requirement changes;
    • Code review pass rate;
    • Maintainability of generated results;
    • Human intervention time;
    • Final delivery quality.

    Impact on the Development Ecosystem

    When Chinese flagship models reach a daily usable level in code, pages, and 3D prototypes, development workflows will change noticeably.

    Front-end developers can complete interactive prototypes faster, designers can validate visual solutions through natural language, product managers can directly generate concept pages, and educators can produce interactive demonstration content at lower cost.

    But this does not mean professional developers will be completely replaced. Instead, developer value will shift more toward:

    • Defining problems;
    • Designing system architecture;
    • Judging technical routes;
    • Reviewing generated results;
    • Handling edge cases;
    • Ensuring quality and security;
    • Establishing reusable engineering standards.

    Models are good at rapid generation and combination, while professionals are responsible for judgment, constraints, and final accountability. A more realistic way of working in the future is not “the model independently completes the entire project,” but “the model handles a large amount of low-value coding while humans own the goals, standards, and acceptance.”

    Conclusion

    Overall, new-generation Chinese flagship models have already demonstrated strong practical value in code generation, interactive animation, and 3D prototyping. They are especially suitable for quickly validating ideas, building demo pages, and generating technical drafts.

    However, in complex lighting, material expression, spatial realism, and aesthetic control, there is still a gap between them and truly mature professional creation workflows. Code that runs is only the first step; reaching a deliverable, maintainable, and visually compelling level requires a more complete evaluation system, a longer iteration chain, and continuous verification by professionals.

    For developers, the most reasonable way to use these models is as high-efficiency technical collaborators, not as unreviewed automated production lines. Only by combining model generation capabilities with engineering standards, visual design, and human acceptance can “can write code” truly become “can complete projects.”