The recent success of text-to-image synthesis has been driven by diffusion models and autoregressive models. Despite the ability of GANs to generate high-quality images through efficient feed-forward inference, they have not been able to scale up to match the performance of these newer approaches in complex, open-domain text-to-image generation. Can GANs continue to be scaled up and potentially benefit from vast computational resources, or have they plateaued? This work presents GigaGAN, a new GAN architecture that far exceeds the previously established scaling limits, demonstrating that GANs remain a viable architecture for text-to-image synthesis.

GigaGAN offers three major advantages. First, it is orders of magnitude faster at inference than diffusion and autoregressive models, generating a 512px image in 0.13 seconds. Second, it can synthesize ultra high-resolution images, e.g., 16-megapixel pixels at 4096x4096 in 3.66 seconds. Third, it supports various latent space editing applications such as latent interpolation, style mixing, and vector arithmetic operations. GigaGAN achieves a zero-shot FID of 9.09 on the COCO2014 dataset, lower than DALL-E 2, Parti-750M, and Stable Diffusion.

Generative adversarial networks (GANs) have long been the dominant paradigm in image synthesis. The StyleGAN family, in particular, has excelled at modeling single or multiple object classes, producing remarkably realistic images of faces, cars, and other categories. However, the recent emergence of diffusion models such as DALL-E 2, Imagen, and Stable Diffusion, as well as autoregressive models like Parti, has dramatically shifted the landscape. These models, trained on billions of text-image pairs, have achieved unprecedented quality and diversity in open-domain text-to-image generation, seemingly leaving GANs behind.

This raises a fundamental question: can GANs continue to be scaled up and potentially benefit from such resources, or have they plateaued? The authors find that naively increasing the capacity of the StyleGAN architecture quickly becomes unstable. Simply making the network wider or deeper does not yield improvements and often leads to training collapse. To address this, the paper introduces several key modifications to the GAN architecture that together enable stable training at a scale 36 times larger than StyleGAN2 and 6 times larger than StyleGAN-XL, with a total of 1 billion parameters.

Beyond competitive generation quality, GANs offer several unique advantages that diffusion and autoregressive models struggle to match. First, GAN inference is orders of magnitude faster — a single forward pass versus hundreds of iterative denoising steps. Second, GANs naturally support ultra high-resolution synthesis through their upsampling architecture, producing 4096x4096 images in 3.66 seconds. Third, GANs maintain a well-structured, controllable latent vector space that enables powerful editing applications including style mixing, prompt interpolation, and prompt mixing — capabilities that remain challenging for diffusion models due to their iterative and stochastic nature.

Text-to-image synthesis has been studied extensively. Early GAN-based approaches such as StackGAN and AttnGAN were trained on relatively small datasets such as CUB-200 (12k training pairs), MSCOCO (82k), and LN-OpenImages (507k). The field was transformed by large-scale autoregressive models like DALL-E and CogView, followed by diffusion models including GLIDE, DALL-E 2, Imagen, and Stable Diffusion. These methods leverage billions of text-image pairs and large pretrained language models to achieve unprecedented quality. GigaGAN represents the first expedition toward training a large-scale GAN for text-to-image generation on a vast amount of web-crawled text and image pairs.

The StyleGAN family of architectures has been the dominant approach for GAN-based image synthesis. StyleGAN2 introduced weight demodulation and path length regularization for improved training stability. StyleGAN-XL extended the approach to ImageNet-scale generation by leveraging a pretrained classifier for progressive growing. However, these architectures have struggled with scaling to complex datasets, much less an open world. The fundamental challenge is that the same convolution filters must handle all possible text conditions across all spatial locations, an increasingly difficult task as the domain broadens.

Image super-resolution has been a longstanding task in computer vision. Classical approaches use convolutional neural networks trained with pixel-wise and perceptual losses. More recently, diffusion-based upscalers such as LDM and SD Upscaler have shown strong results but remain computationally expensive, performing the reverse process in low-dimensional latent space over many steps. Real-ESRGAN uses a GAN-based architecture with a compact model but cannot incorporate text conditioning. GigaGAN's upsampler serves a different purpose: enabling text-conditioned, ultra high-resolution synthesis in a single efficient forward pass.

In standard StyleGAN, the same convolution filters are applied to all generated images regardless of the input text condition. As the model is required to handle an increasingly diverse and open-ended set of text prompts, these shared, static filters are challenged to model the general image synthesis function for all text conditioning across all locations. This fundamental bottleneck limits the model's capacity to scale effectively and is a key reason why naively increasing the network width or depth leads to training instability rather than improved quality.

To address this, the authors propose sample-adaptive kernel selection. Instead of using a single convolution filter, they instantiate a bank of N filters {K_1, K_2, ..., K_N}. The style vector w predicted from the text conditioning is used to compute a set of softmax weights that dynamically average across the filter bank, yielding the final convolution kernel: K = sum of K_i multiplied by softmax(W_filter^T w + b_filter)_i. Crucially, this filter selection process is performed only once per layer and is independent of spatial resolution, meaning it adds negligible computational overhead while dramatically expanding the model's expressiveness. This approach shares the spirit of dynamic convolutions but explicitly instantiates a larger filter bank for greater capacity.

Incorporating self-attention into GANs has been a persistent challenge due to training instability. A key insight is that standard dot-product self-attention is not Lipschitz continuous, which is problematic for GAN training where maintaining Lipschitz constraints is crucial for stable adversarial optimization. To address this, the authors adopt L2-distance instead of dot product as attention logits, which provides a more stable attention mechanism. They also match architectural details of StyleGAN such as equalized learning rate, tie the key and query matrices, and apply weight decay to further stabilize training.

The attention layers are interleaved with the convolutional backbone rather than replacing it. At each generator block, the feature map passes through an adaptive convolution layer, followed by a self-attention layer, and then a cross-attention layer. The cross-attention mechanism uses local word embeddings (t_local) from the CLIP text encoder, allowing the generator to attend to specific words in the prompt and spatially localize their effects. The synthesis network at each layer can be expressed as: f_(l+1) = g^l_xa(g^l_attn(g^l_adaconv(f_l, w), w), t_local), where each function operates sequentially on the feature representation.

The text conditioning pipeline uses a pretrained CLIP text encoder to extract embeddings from the input prompt. The authors apply additional attention layers T to the raw CLIP embeddings for greater flexibility. The processed embeddings are then separated into two components: t_local, consisting of individual word embeddings (dimension C-1 x 768), which provides fine-grained spatial conditioning through cross-attention; and t_global, the aggregated end-of-text (EOT) component (dimension 768), which captures the overall semantic meaning of the prompt.

A mapping network M transforms the noise vector z and global text embedding t_global into a style vector w = M(z, t_global), following the StyleGAN paradigm. The final image is then generated as x = G(w, t_local), where the style vector w modulates the generator through adaptive convolution and style-based normalization, while the local word embeddings condition the generator through cross-attention at each block. This dual conditioning approach preserves the well-structured latent space of StyleGAN, enabling the powerful editing applications that are a hallmark of GANs.

A critical problem encountered during scaling is that early, low-resolution layers of the generator become inactive as the model grows larger. The gradients from the discriminator primarily flow to the later, high-resolution layers, leaving the early layers undertrained. To address this, the authors introduce multi-scale input/output (MS-I/O) training. The generator produces a pyramid of outputs {x_i} with L=5 levels at spatial resolutions {64, 32, 16, 8, 4}. Each level of the pyramid makes real/fake predictions at multiple scales, resulting in L(L+1)/2 total predictions that supervise multi-scale generations.

The multi-scale objective is formulated as: V_MS-I/O(G,D) = sum over all i and j where i < j ≤ L of [V_GAN(G_i, D_ij) + V_match(G_i, D_ij)]. Here, G_i represents the generator output at pyramid level i, and D_ij denotes the discriminator prediction at scale j given input from level i. The matching-aware loss V_match ensures the discriminator considers not only image realism but also whether the image matches its text condition, by pairing real images with randomly sampled, mismatched conditions as additional negative examples. This comprehensive multi-scale supervision activates all layers of the generator and enables stable training at billion-parameter scale.

The discriminator adopts a multi-scale input/output (MS-I/O) architecture that processes each pyramid level independently. For example, the full-resolution output x_0 makes predictions at all L=5 scales, the next level x_1 makes predictions at 4 scales, and so on. Feature extractors phi_i->j extract features at different scales to produce the discriminator's predictions. In addition to the adversarial loss, the authors incorporate a CLIP contrastive loss: L_CLIP = -E[log(exp(E_img(G(c_0))^T E_txt(c_0)) / sum_n exp(...))], which directly optimizes the alignment between generated images and their text conditions using pretrained CLIP embeddings.

The final discriminator objective further incorporates a vision-aided GAN loss. This uses a pretrained CLIP image encoder as a backbone, extracting features from intermediate layers and processing them through a simple network with 3x3 convolutional layers to produce auxiliary discriminator predictions. The complete training objective combines all components: V(G,D) = V_MS-I/O(G,D) + L_CLIP(G) + L_Vision(G). This multi-faceted loss landscape provides diverse training signals — adversarial realism from MS-I/O, text-image alignment from CLIP contrastive loss, and perceptual quality from vision-aided discrimination — each addressing a different aspect of the generation task.

To enable ultra high-resolution image synthesis, the authors design a dedicated GAN-based upsampler as a second stage. The upsampler follows an asymmetric U-Net architecture with 3 downsampling residual blocks followed by 6 upsampling residual blocks, connected by skip connections at matching resolutions. It takes the 512px output from the base generator and upsamples it to 2048px or 4096px. The upsampler is conditioned on the same text embeddings and style vectors as the base model, enabling text-aware detail synthesis during upsampling.

The upsampler is trained with the same adversarial losses as the base model, along with an additional LPIPS perceptual loss computed with respect to the ground-truth high-resolution image. Moderate Gaussian noise augmentation is applied to the low-resolution input during training to improve robustness. The upsampler contains 359.1 million parameters, bringing the total GigaGAN system to approximately 1 billion parameters (652.5M for the base generator plus 359.1M for the upsampler). Despite this large parameter count, the entire upsampling process for a 4096x4096 image takes only 3.66 seconds, demonstrating the efficiency advantage of feed-forward GAN inference.

GigaGAN is trained on a large-scale dataset formed by the union of LAION2B-en and COYO-700M. The data is preprocessed by filtering for CLIP score above 0.3, image resolution at least 512 pixels, and aesthetic score above 5.0. The base generator has 652.5 million parameters and the upsampler has 359.1 million parameters, totaling approximately 1.0 billion parameters. Training is conducted on 64 to 128 NVIDIA A100 GPUs. The total training cost is approximately 4,783 A100 GPU days, which is comparable to Stable Diffusion v1.5 (6,250 A100 GPU days) and Imagen (~4,755 TPUv4 days).

The ablation study at 64px resolution systematically evaluates each architectural contribution. Starting from a baseline StyleGAN2 with FID-10k of 29.91, naively increasing capacity by 5.7x actually degrades performance to FID 34.07, confirming that simple scaling fails. Progressively adding components yields consistent improvements: attention (FID 23.87), matching-aware loss on both G and D (FID 21.66), adaptive convolution (FID 19.97), deeper architecture (FID 19.18), CLIP loss (FID 14.88), multi-scale training (FID 14.92, with improved CLIP score from 0.280 to 0.300), vision-aided GAN (FID 13.67), and finally full scale-up to GigaGAN (FID 9.18, CLIP 0.307, 652.5M parameters).

On the COCO2014 benchmark, GigaGAN achieves a zero-shot FID-30k of 9.09, outperforming DALL-E 2 (FID 10.39), Parti-750M (FID 10.71), and Stable Diffusion (FID 9.62). In terms of inference speed, GigaGAN generates a 512px image in 0.13 seconds, compared to GLIDE at 15.0 seconds, LDM at 9.4 seconds, and Imagen at 9.1 seconds. When compared against distilled diffusion models, GigaGAN with a single forward pass achieves FID-5k of 21.1 and CLIP score of 0.32 in 0.13 seconds, outperforming Stable Diffusion distilled with 2 steps (FID 37.3), 4 steps (FID 26.0), and 16 steps (FID 28.8, 0.88s).

For the super-resolution task (128 to 1024 upsampling on LAION), GigaGAN achieves significantly better results than existing methods. With 693M parameters and 0.13 seconds inference time, GigaGAN reaches FID-10k of 1.54 and Patch-FID of 8.90, substantially outperforming Real-ESRGAN (FID 8.60, Patch-FID 22.8) and SD Upscaler (FID 9.39, Patch-FID 41.3, 7.75s). On ImageNet unconditional 64-to-256 upsampling, GigaGAN achieves Inception Score of 191.5 and FID of 1.2, outperforming SR3 and LDM variants. These results demonstrate that GAN-based upsampling can deliver superior perceptual quality at a fraction of the computational cost of diffusion-based alternatives.

A key advantage of GigaGAN over diffusion models is its disentangled latent space that enables rich editing applications. Style mixing allows blending the coarse style of one sample with the fine style of another by splicing latent codes at different layers of the synthesis network. This produces a style-swapping grid where rows and columns represent different style sources, and each cell shows the combined result. This capability directly inherits from the StyleGAN architecture and demonstrates that scaling up GANs preserves their characteristic latent space structure.

Prompt interpolation is achieved by interpolating text embeddings t and style vectors w between two different prompts. Using the same noise vector z for both endpoints results in similar layouts, enabling a smooth, semantically meaningful transition between different text descriptions. For example, one can smoothly morph between "a photo of a cat" and "a photo of a dog" while maintaining consistent spatial structure. This capability highlights the continuous and well-organized nature of GigaGAN's latent space, where nearby points correspond to semantically related images.

Prompt mixing applies different text prompts to different layers of the generator, enabling creative compositions such as "an object X with the texture of Y." The cross-attention mechanism automatically localizes the style effects to appropriate spatial regions. Additionally, GigaGAN supports a text-conditioned truncation trick: w_trunc = lerp(w_mean_c, lerp(w_mean, w, psi), psi), which trades diversity for fidelity by interpolating the style vector toward its text-conditional mean. The CLIP score increases with stronger truncation at the cost of reduced diversity, with the optimal truncation value between 0.8 and 0.7. These applications collectively demonstrate that GigaGAN brings back key editing capabilities that became challenging with the transition to autoregressive and diffusion models.

This work demonstrates that GANs can be successfully scaled up to one billion parameters for text-to-image synthesis, challenging the prevailing assumption that diffusion and autoregressive models are the only viable path forward. GigaGAN introduces several architectural innovations — sample-adaptive kernel selection, L2-distance attention, multi-scale input/output training, and a combined loss framework — that together enable stable training at unprecedented scale. The resulting model achieves competitive FID scores while being orders of magnitude faster at inference, supports ultra high-resolution synthesis up to 4K, and maintains a structured latent space for rich editing applications.

The authors honestly acknowledge several limitations. The visual quality of GigaGAN's results is not yet comparable to production-grade models like DALL-E 2 in terms of photorealism and fine detail. The model struggles with compositionality — correctly generating complex scenes with multiple objects and their spatial relationships as described in the prompt. Text-to-image alignment remains imperfect, with some prompts producing results that do not fully match the described content. However, the authors expect performance to improve with larger models, as suggested by the consistent scaling trends observed in the ablation study.

Looking forward, the authors argue that GigaGAN opens up a whole new design space for large-scale generative models. The architecture demonstrates that no quality saturation regarding model size has been observed, suggesting significant room for further scaling. GigaGAN brings back key editing capabilities — style mixing, prompt interpolation, prompt mixing — that became challenging with the transition to autoregressive and diffusion models. As the field continues to advance, the complementary strengths of GANs (speed, editability, resolution) and diffusion models (quality, compositionality) may lead to hybrid architectures that combine the best of both paradigms.