Meta has published the official PyTorch/GPU implementation of WaiT, its wavelet-aware image Transformer. The facebookresearch/WaiT repository provides training and evaluation instructions for class-conditional ImageNet generation, giving researchers a concrete implementation to inspect and attempt to reproduce.
The release is a separate implementation event from the research announcement. Meta’s page for WaiT for the Signal: Simple Frequency-Aware Flow-Matching is dated August 4, 2026. That earlier work describes a model that builds coarse image structure before spending computation on fine detail, reporting ImageNet results with up to 50% lower sampling compute. Those are the authors’ research claims, not new measurements accompanying the code release. (Meta research page)
Developers also have a licensing decision to make before reuse: the README labels WaiT CC BY-NC 4.0, while identifying MIT-licensed components inherited from JiT. Publicly available code here comes with a noncommercial boundary.
How WaiT Delays Fine Detail
WaiT changes how an image generator allocates work across spatial frequencies. Low-frequency information describes broad shapes and structure; high-frequency information captures finer changes, including edges and texture.
Meta’s explanation starts with an observation about image generation: fine detail becomes indistinguishable from noise earlier than coarse structure during the noising process. WaiT builds that difference into its training and sampling schedules, allowing high-frequency bands to remain pure noise while coarse structure develops. (Meta research page)
The implementation uses a single-level Haar wavelet transform. This lossless transform separates an image into a low-frequency band and high-frequency bands. The low-frequency representation has half the width and height of the original image.
Each frequency group follows a separate schedule:
- Low frequency:
t_LF = t - High frequency:
t_HF = max(0, (t - t*) / (1 - t*))
Here, t is progress along the generation trajectory, and t* determines when high-frequency generation begins. Before that threshold, sampling runs only on the low-frequency band. At the threshold, the model combines the coarse band with fresh high-frequency noise through the inverse wavelet transform, then refines the full-resolution image jointly. One resolution-conditioned model handles both phases. (WaiT README)
For the documented 512 × 512 setup, the coarse phase therefore operates at 256 × 256. That is one-quarter as many spatial positions, although the reduction cannot be translated directly into an equivalent reduction in total model compute or elapsed time.
The repository says WaiT builds on JiT, retaining its architecture, training recipe, image prediction, and velocity-based loss. The central intervention is the frequency-dependent generation path, making the scheduling choices especially important for anyone comparing results.
Two Settings Control Different Things
The README’s example uses --t_star 0.25 and, during evaluation, --rho 0.6. These values serve different purposes:
| Setting | What it controls |
|---|---|
t_star | The point along the trajectory when high-frequency bands join generation |
rho | The fraction of sampling steps allocated to the coarse phase |
With 50 sampling steps and rho set to 0.6, the stated allocation puts 30 steps in the coarse phase and leaves 20 for full-resolution refinement. A threshold of 0.25 does not mean that only 25% of sampling steps must be coarse. (WaiT README)
I’d keep those settings separate in any reproduction notes. Changing the threshold changes the frequency schedule; changing the step allocation changes how much numerical work each phase receives. Matching only the total step count can leave a consequential difference between two experiments.
What Researchers Can Run
The repository targets class-conditional ImageNet generation: generation conditioned on ImageNet categories. Its documented workflow is not a general text-prompt image application.
The README provides this installation sequence:
git clone https://github.com/facebookresearch/WaiT.git
cd WaiT
conda env create -f environment.yaml
conda activate wait
These commands download the repository and create and activate its specified Conda environment. They do not download ImageNet or train a model. The dataset must be supplied separately, with the configured ImageNet directory containing train/. (WaiT README)
The published training example gives a clearer picture of the intended scale:
| Training detail | README example |
|---|---|
| Model | WaiT-B/16 |
| Image resolution | 512 × 512 pixels |
| Distributed setup | Two nodes, eight GPU processes per node |
| Batch size | 64 per process, 1,024 effective batch |
| Training duration | 600 epochs, including five warmup epochs |
| Noise scales | 1.5 for low frequencies; 1.0 for high frequencies |
| High-frequency threshold | 0.25 |
The command launches main_wait.py through torchrun. A two-node run needs each node’s rank, a shared master address and port, and valid dataset and output paths. These are distributed-training settings that must be configured for the researcher’s own machines. (WaiT README)
Supported model names span B, L, XL, H, and G, with patch sizes of 16 or 32. The README specifies additional attention and projection dropout for H and G, and scales the low-frequency noise setting with image resolution.
This is a research-scale example, not evidence that every experiment requires 16 GPUs. The instructions do, however, make clear that reproducing the published training recipe involves substantially more than installing a package.
The README also does not link pretrained checkpoints. Its evaluation command expects a checkpoint directory, so the documented route is not a ready-to-run download-and-generate experience.
What the Reported Results Mean
Meta’s research page reports the following results:
| Published setting | Author-reported result |
|---|---|
| ImageNet, 512 × 512, pixel-space generation | FID of 1.43 |
| Largest model, 2 billion parameters, ImageNet 512 | FID of 1.3 |
| Sampling compute | Reduction of up to 50% |
These figures come from Meta’s research abstract. This article analyzes that abstract and the repository documentation; it does not report a code run or an independent benchmark.
Frequently Asked Questions
3 questions
1Can WaiT Generate Images From Text Prompts?
The released workflow is for class-conditional ImageNet generation. The README does not document a general text-to-image pipeline.
