WeLM-Image

Tencent WeChat Vision's WeLM-Image is a 31.7B-parameter unified visual generation model designed to collapse text-to-image synthesis, instruction-guided editing, and multi-reference composition into a single architecture. Rather than chaining separate text-to-image backbones, inpainting models, and reference adapters like ControlNet or IP-Adapter, WeLM-Image handles generation and manipulation natively inside one unified transformer backbone.

The architectural centerpiece is a sparse Mixture-of-Transformers (MoT) framework. While the model holds 31.7 billion parameters in memory, it activates only roughly 5.4 billion parameters per target latent token during generation. This routing mechanism lowers the per-step compute ceiling to the level of a mid-sized dense model while retaining the expressiveness, prompt fidelity, and capacity of a 30B-plus parameter network.

In internal benchmarks reported by Tencent, the 1536-resolution model ranks first among evaluated open-source systems on PRISM-Bench, Qwen-Image-Bench, and UnicBench. For teams looking to run WeLM-Image locally, the release represents a major step toward consolidation: a local AI model 31.7B parameters 2026 stack that replaces fragmented image-generation pipelines with a single local deployment.

WeLM-Image abandons traditional monolithic diffusion backbones in favor of a dual-path Mixture-of-Transformers design. This layout isolates text and visual understanding from generation, mitigating the task interference that typically degrades multi-task image models.

• Dual-Path MoT Backbone: The network divides operations into an understanding path (activating 2.2B parameters) and a generation path (activating 5.4B parameters). The understanding path processes conditioning signals, cross-attention contexts, and reference features, while the generation path handles latent denoising.
• Sparse MoE Routing: Each path uses sparse Mixture of Experts (MoE) layers. Routing latent tokens dynamically through expert blocks gives WeLM-Image high structural capacity without incurring the quadratic latency costs of a 31.7B dense transformer.
• Native 1.5K Resolution: Trained directly at 1536x1536 resolution, the latent space avoids the artifacting and compositional drifting commonly seen when smaller models (trained at 512px or 1024px) are upscaled via tiling or post-hoc high-resolution fix passes.
• WeLM-Image MoE Efficiency: Because only 5.4B parameters execute per token, the arithmetic intensity during inference is significantly lower than that of equivalent 30B dense models. However, the full 31.7B parameter footprint must still reside in VRAM to avoid catastrophic bus bottlenecks.

Tencent also engineered a distilled variant, WeLM-Image-Turbo. By compressing the sampling trajectory to eight guidance-free steps, the Turbo variant renders a 1024x1024 frame in 4.98 seconds on a single NVIDIA H20 GPU.

WeLM-Image is built for production environments requiring unified image processing rather than pure artistic text-to-image prompting. Its weights natively address three major operational workloads:

• Instruction-Guided Editing Across 27 Action Types: The model executes zero-shot natural language image manipulations without requiring user-drawn masks. This covers local insertion, item removal, in-scene text replacement, global restyling, viewpoint modifications, and character pose changes directly through text directives.
• High-Density Bilingual Typography: By integrating dedicated understanding layers, WeLM-Image natively renders complex Chinese and English typographic elements into target scenes. It accurately handles signage, branded posters, layout-constrained graphic design, and annotated maps where standard diffusion models introduce illegible glyphs.
• Multi-Reference Composition: The backbone can ingest two to three reference images simultaneously to resolve identity transfer, product placement, and style blending. This bypasses the need to fine-tune custom LoRAs for every product or subject.

Deploying WeLM-Image on self-hosted infrastructure requires balancing massive parameter residency with modest active compute. Understanding WeLM-Image VRAM requirements is critical before configuring your rig.

Because all 31.7B parameters must be stored in memory to prevent offloading penalties, the raw memory footprint dictates your GPU requirements:

• 16-bit (BF16/FP16): Requires ~68 GB to 72 GB of VRAM. This tier requires an 80GB enterprise card (NVIDIA A100, H100, H20) or a dual 48GB setup (such as two RTX 6000 Ada cards).
• 8-bit (FP8/INT8): Requires ~36 GB to 40 GB of VRAM. Fits comfortably on a single 48GB workstation GPU like the RTX 6000 Ada, RTX A6000, or a dual RTX 3090/4090 cluster.
• 4-bit (Q4_K_M/AWQ): Requires ~18 GB to 22 GB of VRAM. This is the optimal configuration to run a 31.7B model on consumer GPU hardware with 24GB of frame buffer.

• Best Consumer GPU Setup: A single NVIDIA GeForce RTX 4090 (24GB) or RTX 3090 (24GB) running a 4-bit quantized build (such as AWQ or Q4_K_M). This fits the base weights and the latent buffers directly in memory, preventing system RAM spilling over the PCIe bus.
• Best Workstation / Multi-GPU Setup: Dual RTX 4090s (48GB combined via tensor parallelism) or a single RTX 6000 Ada (48GB). This allows 8-bit FP8 weights to execute at higher fidelity without gating router precision.
• Apple Silicon Support: For macOS users, an M3 Max or M4 Max with 64GB or 128GB of unified memory can load the full 31.7B model with zero memory pressure, serving as a silent, self-contained local workstation engine.
• Best Enterprise Inference Card: The NVIDIA H20 (96GB memory, high bandwidth) represents the benchmark hardware cited by Tencent, running the distilled Turbo variant in under five seconds per frame.

The best quantization for WeLM-Image is AWQ or FP8 where hardware supports it. In MoE architectures, quantizing routing gates too aggressively leads to routing instability and visual degeneration. Keep the router layers in FP16/FP32 and quantize only the expert weights to 4-bit or 8-bit.

In pure generative pipelines, measuring WeLM-Image tokens per second translates directly to denoising step latency. On an RTX 4090 running 4-bit quantization:

• WeLM-Image-Turbo (8 steps, 1024x1024): Expect complete renders in approximately 6 to 9 seconds.
• WeLM-Image Base (30 to 50 steps, 1536x1536): Expect generation cycles between 35 and 65 seconds depending on prompt token length and reference image counts.

For developers seeking an accessible entry point, community packaging inside local inference engines like Ollama or custom ComfyUI backends remains the fastest route to get started without manually writing custom Diffusers pipelines.

Evaluating WeLM-Image requires comparing it to top-tier open weights at similar scales, notably the FLUX.1 family and SD3.5 Large.

FLUX.1 operates as a dense 12B parameter model. In terms of VRAM, FLUX.1 is significantly easier to host at FP16/FP8, running on standard 16GB to 24GB hardware without aggressive compression. However, FLUX.1 is primarily a generation-first model; complex multi-image composition and targeted instruction editing require secondary tooling like ControlNet or IP-Adapter. WeLM-Image carries more VRAM overhead due to its 31.7B total parameters, but its 5.4B active MoE execution makes per-step compute comparable to FLUX.1, while delivering native instruction editing across 27 distinct tasks directly out of the box.

SD3.5 Large runs as an 8B dense model with predictable memory usage and broad community integration. While SD3.5 is easier to fine-tune on consumer setups, WeLM-Image surpasses it on native bilingual text generation (specifically Chinese and English scripts) and complex multi-object scene planning at native 1536x1536 resolutions. If your priority is a lean generation-only pipeline, SD3.5 Large fits smaller budgets; if your workflow demands automated editing and multi-reference composition in a single engine, WeLM-Image is the superior architecture.