Bilibili AI Infinite Arena: Local Deployment Extreme PK of Three MOE Models

On Bilibili, the AI Infinite Arena is becoming a popular way to evaluate large model capabilities. Many creators pit models against each other with complex scenario tasks, but online evaluation is often costly. To reduce costs and explore the feasibility of local deployment, I used my own equipment to conduct a horizontal comparison of three MOE models. The test focuses not only on generation speed but also on the models' performance and stability in complex 3D modeling tasks.

Test Environment and Model Selection

The core hardware for local deployment is an RTX 3060 GPU (specific VRAM capacity not explicitly given in the source material) and dual-channel memory (total capacity not provided in the source). The GPU runs on a PCIe 4.0 x16 channel, providing the basic compute power for model inference. The inference framework uses the latest version of LlamaCBP as of now, and all models use the IQ4 quantized versions provided by Anslot to balance VRAM usage and inference speed.

The three models participating in the PK are all MOE architectures at the 30B parameter level, but with different active parameters:

• Gemma 4: 26B total parameters, 4B activated each time
• GLM 4.7 Flash: 30B total parameters, 3B activated each time
• Qwen 3.6 35B A3B: 35B total parameters, 3B activated each time

Due to local device limitations, the context length is capped at 128K, and model inference speed is roughly 20-30 tokens per second. To avoid context overflow from overly long single outputs, all models reference JS libraries online and are required to write JS code separately. The Agent framework uniformly uses the latest version of DeepSeek^Ad Hanis to ensure consistent test conditions.

MOE (Mixture of Experts) architecture is an important design paradigm in the large model field today. Unlike traditional dense models that activate all parameters for every inference, MOE models contain multiple "expert" sub-networks and use a gating network (Router) to dynamically select and activate only a few experts for each token. Therefore, MOE models can have very large total parameter counts but compute only a small fraction in a single inference, thereby greatly reducing compute and memory bandwidth requirements while maintaining relatively high capability. The three models in this article have total parameters between 26B and 35B, while active parameters are only 3B to 4B, which reflects this characteristic. Note that the total parameter count still determines the VRAM occupied when the model is loaded, while active parameters mainly affect inference speed; the two should be viewed separately.

Quantization refers to representing model weights with lower-bit data types (such as 4-bit or 8-bit integers) to reduce VRAM usage and memory bandwidth pressure, thereby enabling large models to run on consumer-grade GPUs. The IQ4 mentioned in the article is a type of 4-bit quantization, usually combined with specific quantization algorithms (such as importance matrix quantization in the llama.cpp ecosystem) to preserve model accuracy as much as possible. Quantization introduces some quality loss, but 4-bit quantization still maintains good performance on most tasks and is a common compromise for local deployment. Related to this is context length, i.e., the maximum number of tokens the model can process in a single pass. The 128K cap in the article means the model can accommodate longer conversations and code, but beyond that it needs truncation or segmentation.

Modeling Task Design: Rainy Night Convenience Store Street Corner

The task in this test is to generate a "rainy night convenience store street corner" 3D scene, requiring a complete square base with all elements built on the base, compact composition, clear layering, and a small, exquisite collectible model feel. Specific elements include: a Japanese-style convenience store at the visual center, with exterior signage, display windows, automatic doors, eaves awnings, as well as street corner props such as vending machines, bicycles, and streetlights. No people are needed in the scene, and information such as shelves inside the store can be simplified—local models generally perform weakly on interior details.

This task places extremely high demands on spatial modeling ability and detail control, and can intuitively reflect the model's understanding and execution of complex instructions.

The Agent framework plays the role of a "scheduling layer" here: the large model itself is only responsible for generating text or code, while the Agent framework organizes prompts, calls tools (such as executing code, reading and writing files), maintains multi-turn conversation state, and retries or repairs when model output errors occur. The article uniformly uses the same Agent framework to eliminate interference from framework differences and make the comparison focus more on the models' own capabilities. In addition, the requirement to "reference JS libraries online" and write JS code separately is to prevent the model from inlining large amounts of library code directly into the output, thereby saving context and reducing the probability of syntax errors. This is also a common technique for controlling output length during local deployment.

Actual Performance of the Three Models

Gemma 4: Fast Generation, Weak Optimization

Gemma 4's first generation took only 9 minutes and 7 seconds, which is impressive speed. In the initial version, the convenience store's main structure was complete, and elements such as automatic doors, vending machines, and streetlights were all present. But the automatic doors had obvious problems, the streetlights were placed separately, and overall detail was insufficient.

A second optimization was then performed, taking about 4 minutes, but the result was disappointing: the newly added traffic lights were not installed on the streetlight poles, the storefront optimization was almost ineffective, and multiple detail adjustments still produced no obvious improvement. This indicates that Gemma 4 has a relatively low ceiling on this task and limited optimization ability.

GLM 4.7 Flash: Rich Detail but Worrying Stability

GLM 4.7 Flash's first generation was also completed in about 10 minutes. The initial version was richer in detail than Gemma 4, with elements such as utility poles and connecting wires reflected. However, the second optimization took 17 minutes and introduced basic syntax errors—parentheses were not properly closed. Fixing that problem then took another 30 minutes, during which a variable-not-declared bug also appeared.

In terms of final effect, although the first version had chaotic internal structure and the automatic door was blocked by a wall, at least the convenience store outline was recognizable; after the second optimization it was actually worse, with the model overall shrunk, the automatic door turned into a wooden door, and a large amount of detail lost. GLM 4.7 Flash's stability problems are prominent, and the optimization process is full of uncertainty.

Qwen 3.6 35B A3B: One-Shot Success, Details in Place

Qwen 3.6 35B A3B's performance was completely different: the first generation was basically complete, with no need for a second optimization. The environment around the convenience store in the scene was well developed, with air conditioning units, traffic lights (able to automatically switch between red, yellow, and green), trash cans, streetlights, vending machines, roads, and other elements all present. Although the bicycle still had flaws, it was clearly better than the previous two. The starry sky background added atmosphere; the only shortcoming was the lack of a rainy-night feel.

Overall, Qwen 3.6 35B A3B performed strongest among the three models, achieving one-shot success with rich detail and stability far exceeding its competitors.

The difference between "one-shot success" and "second optimization" essentially reflects the model's self-consistency and error-correction ability in long-form code generation. 3D scene code often contains a large number of nested structures (such as scene trees, geometry, materials, animations), and any parenthesis or variable name error may prevent the entire scene from rendering. During second optimization, the model needs to make local modifications to existing code, which is more likely to introduce regression errors than generating from scratch—the unclosed parentheses and undeclared variables that appeared in GLM 4.7 Flash are examples of this. Therefore, when evaluating such tasks, the first-generation success rate and stability after multiple rounds of modification often explain the model's engineering usability better than single-generation speed.

Ranking and Unexpected Findings

Overall performance ranking: Qwen 3.6 35B A3B first, GLM 4.7 Flash second, Gemma 4 last. Although GLM 4.7 Flash had bugs, its first version's detail was still better than Gemma 4, so it ranked second. Gemma 4 ranked last due to weak optimization and missing details.

Beyond the test, I also tried Qwen 3.8 Flash Next—a model with a larger parameter count. Local deployment required substantial memory and SSD, but it still ran on the same hardware. Its generation quality was far ahead: utility poles were highly realistic, the convenience store name was clear, the glass door allowed seeing the shelves inside, bicycle details were in place, and the overall result far exceeded the previous three models. Although it did not participate in the evaluation, the quality improvement brought by four times the parameters was obvious and provides a new reference for local deployment.

This test shows that MOE models can already complete complex modeling tasks under local deployment, but stability, detail handling, and optimization ability differ significantly among models. Qwen 3.6 35B A3B demonstrated the best balance, while the larger-parameter model revealed the potential of hardware upgrades.

One-line Summary

Local testing on an RTX 3060 of three 30B-class MOE models shows Qwen 3.6 35B A3B performs best with one-shot success in a 3D modeling task.

Paragraph Summary

In a local RTX 3060 environment, the author used the LlamaCBP inference framework and IQ4 quantized versions to compare three 30B-class MOE models: Gemma 4, GLM 4.7 Flash, and Qwen 3.6 35B A3B. The test task was to generate a "rainy night convenience store street corner" 3D scene, examining spatial modeling, detail control, and multi-round optimization stability. Results show that Qwen 3.6 35B A3B was basically complete on first generation, with all elements present and traffic lights able to switch automatically, making it the best overall; GLM 4.7 Flash had more detail in its first version but introduced syntax errors and variable-not-declared bugs during second optimization, showing insufficient stability; Gemma 4 generated quickly but optimization was almost ineffective and details were missing, ranking last. The author also tried the larger-parameter Qwen 3.8 Flash Next, whose quality improved significantly but required memory and SSD, so it did not participate in the evaluation.