Preview LLM Code and Rendering Limits: A Dynamic SVG and WebGL Light-Shadow Test

    This article reports two hands-on tests of an anonymous preview LLM: generating an animated SVG of a pelican riding a bicycle, and producing a pure-code light-and-shadow rendering. It documents the outputs, code structure, visual quality, missing test conditions, and reproducibility limits. It also offers a practical selection checklist and discusses a cloud architecture for offloading compute-intensive rendering workloads.

    Preview LLM Code and Rendering Limits: A Dynamic SVG and WebGL Light-Shadow Test

    Introduction

    Preview LLMs usually disclose limited information. Vendors may not publish parameter counts, benchmark scores, or training data, so external readers can only judge capability through actual tasks. This article uses two fixed scenarios to record the process, results, and limitations. The model is referred to as “the model under test,” and its specific name and version are not disclosed. The conclusions therefore apply only to this sample and should not be directly generalized to other versions of the model or other prompts.

    The vendor says this generation strengthens underlying world knowledge and multimodal perception, with a focus on code generation and agent capabilities. These are vendor statements. This article does not independently verify parameters or training details and discusses effects only on the basis of test outputs.

    The test conditions recorded here are incomplete. Full prompts, browser versions, and hardware configurations were not saved, so strict reproduction is not possible. Missing information is noted in the relevant sections below.

    Test 1: Dynamic SVG Generation

    The prompt asked for an animated SVG of “a pelican riding a bicycle.” This task is often used to observe whether a model can decompose natural language into graphic elements, animation, and interaction logic. The output from the model under test included a pelican wearing a red hat riding a bicycle by the seaside. The wheels rotated, the scarf fluttered in the wind, the page still displayed when offline, the speed could be adjusted from 1× to 1.75×, and the scene could switch between day and night.

    From the code structure, graphics, animation, and interaction logic were largely organized in layers. Wheel rotation used <animateTransform>, and interaction was handled by external JavaScript, including event listeners for speed adjustment and day/night switching. One highlight of the output was that the model automatically completed content not explicitly stated in the prompt. The prompt only mentioned riding a bicycle, but the model added a seaside background and a fluttering scarf, suggesting that it could understand reasonable scene extensions.

    This result only shows that a single output was usable. To judge stability, it would be necessary to count the success rate across multiple generations, record the types of errors in failures, and measure how many rounds of repair were needed. These data were not recorded in this test, so it cannot be concluded that the model’s agent capability has stably improved.

    Test 2: Pure-Code Light-and-Shadow Rendering

    The prompt asked for code to draw an image described as “interlaced light and shadow, a quiet afternoon, perfection.” This test examines the choice of rendering algorithm and the model’s understanding of lighting physics.

    As a reference, the author cited the result from another mainstream model. That model wrote a path tracer in C++, with a rendering time of about three hours. In the output image, window-frame shadows swept across the wall, chair, and wooden floor, with natural transitions between light and dark. The author did not specify the hardware configuration, resolution, or sample count, so this reference can only indicate a general direction, not serve as a precise performance comparison.

    The model under test chose WebGL and built a three-dimensional room scene. WebGL is a browser graphics interface, and shader calculations are usually executed on the GPU. In the output image, the slanted window light had some sense of volume, and the light beam passed over a small round stool and reached the lower edge of the frame. However, harsh black lines appeared at the boundaries of wall-corner shadows. The potted plant and floor materials had an obvious staged look, lacking diffuse reflection and indirect lighting. The author also tested another mainstream model in a similar tool and found that its result was better, but this was likewise a single sample.

    Path tracing uses Monte Carlo methods to simulate multiple light bounces and can produce global illumination close to physical reality, at the cost of high computation. A rasterization pipeline is efficient in real-time scenes, but producing soft indirect lighting usually requires additional techniques such as multiple rendering passes, shadow maps, or baked lighting. The output from the model under test suggests that it did not complete these additional steps in this task, or that the result did not reach the expected quality.

    This test cannot determine the cause of the difference. Possible factors include the model’s algorithm knowledge, the wording of the prompt, output length limits, and generation timeouts. To distinguish these causes, one variable would need to be fixed while comparing results across versions, prompts, or time limits. The author did not run such controlled experiments, so this article does not offer a causal conclusion.

    Selection Advice and Acceptance Checklist

    Developers can use the following methods to judge whether a model suits their task:

    1. Whether the code runs directly and whether the console reports errors.
    2. Whether each interaction function passes, including boundary cases such as window resizing and offline mode.
    3. Whether performance is within budget, recording first-screen load time, frame rate, and memory usage.
    4. Whether compatibility has been tested in the target browser.
    5. Whether the same task has been generated at least three times, with the success rate counted.

    This checklist turns subjective judgments such as “adequate” or “good” into items that can be checked one by one. When selecting a model, these checks should be performed with real tasks rather than relying only on a single demonstration.

    Cloud Compute Collaboration

    Compute-intensive tasks such as path tracing are not suitable for completion within a single model inference. One feasible approach is to have the model generate rendering code and then hand the task to cloud compute resources for execution. The article uses Baidu AI Cloud as an example to explain how such an architecture can be organized:

    A container platform can start GPU or CPU instances on demand to run rendering programs. Temporary files and high-resolution images produced during rendering can be stored in object storage for long-term preservation and version management. Logging services and monitoring alerts can record task progress, duration, and resource usage, and notify when a task fails.

    The benefit of this approach is that model generation and compute execution are separated. The model writes code, and compute resources run the code; the two can scale independently. This architecture does not depend on a specific product from one cloud vendor, and readers can substitute other cloud platforms or self-hosted clusters. Baidu AI Cloud is mentioned only as an architectural example, not as a recommendation.

    Conclusion

    The two tests show that the model under test is usable for common front-end interaction code and can complete implicit requirements in a prompt. In physical lighting and visual detail, it still has a clear gap from the reference cited by the author, but the test conditions for the reference result are incomplete, and the size of the gap cannot be measured precisely. For selection, decisions should be based on one’s own tasks, runtime environment, and data from multiple tests, rather than on a single demonstration.