WeatherNext Pre-Trained Models: Complete Guide to GraphCast and GenCast Checkpoints

WeatherNext provides seven publicly available pre-trained models across two families—three GraphCast models and four GenCast models—each distributed through separate packages with distinct resolutions, training data, and operational capabilities.

The WeatherNext repository by Google DeepMind offers production-ready weather forecasting checkpoints that researchers and practitioners can load immediately without training from scratch. This guide covers every available model, their specifications, and the exact code patterns used to load and run them in weathernext.

GraphCast Models (WeatherNext 1 Graph)

GraphCast models implement graph-based neural network architectures for deterministic weather prediction. All three variants share the same underlying architecture defined in weathernext/weathernext1_graph/graphcast.py.

GraphCast (High-Resolution ERA5)

• Resolution: 0.25° global
• Pressure levels: 37
• Training data: ERA5 reanalysis (1979–2017)
• Use case: Research-grade high-resolution forecasting

This is the flagship GraphCast model published in the original Science paper, offering the highest vertical resolution for detailed atmospheric modeling.

GraphCast_small (Lower-Resolution ERA5)

• Resolution: 1° global
• Pressure levels: 13
• Training data: ERA5 reanalysis (1979–2015)
• Use case: Faster inference, reduced memory requirements

GraphCast_small trades spatial and vertical resolution for computational efficiency, making it suitable for experimentation and resource-constrained environments.

GraphCast_operational (HRES-Fine-Tuned)

• Resolution: 0.25° global
• Pressure levels: 13
• Pre-training: ERA5 (1979–2017)
• Fine-tuning: HRES analysis (2016–2021)
• Use case: Operational forecasting with realistic initialization

This model bridges research and operations by fine-tuning on High-Resolution Single (HRES) data, enabling predictions initialized from operational weather analyses.

GenCast Models (WeatherNext 1 Gen)

GenCast introduces diffusion-based probabilistic forecasting. All four models use the architecture in weathernext/weathernext1_gen/gencast.py, which implements a denoising diffusion model with learned sampler.

GenCast 0p25deg <2019

• Resolution: 0.25° global
• Pressure levels: 13
• Mesh refinement: 6× icosahedral
• Training data: ERA5 reanalysis (1979–2018)
• Use case: High-resolution probabilistic forecasting

The standard GenCast model for research applications requiring fine spatial detail with uncertainty quantification.

GenCast 0p25deg Operational <2022

• Resolution: 0.25° global
• Pressure levels: 13
• Fine-tuning: HRES-fc0 (2016–2021)
• Use case: Operational probabilistic forecasting

Matches the resolution of the base 0.25° model with operational initialization capabilities from HRES first-guess forecasts.

GenCast 1p0deg <2019

• Resolution: 1° global
• Pressure levels: 13
• Mesh refinement: 5× icosahedral
• Training data: ERA5 reanalysis (1979–2018)
• Use case: Balanced resolution and computational cost

Reduces memory footprint while maintaining probabilistic capabilities for ensemble applications.

GenCast 1p0deg Mini <2019

• Resolution: 1° global
• Pressure levels: 13
• Mesh refinement: 4× icosahedral
• Training data: ERA5 reanalysis (1979–2018)
• Use case: Colab demos, educational purposes, minimal resource requirements

The Mini variant is explicitly designed for free Google Colab environments with strict memory limits.

Loading and Running GraphCast Models

The checkpoint.load utility in weathernext/utils/checkpoint.py handles deserialization. Model-specific metadata is stored in graphcast.CheckPoint objects.

from weathernext.utils import checkpoint
from weathernext.weathernext1_graph import graphcast
from weathernext.utils import autoregressive
from weathernext.utils import typed_graph
import numpy as np

# Load checkpoint from Google Cloud bucket download

with open("graphcast/GraphCast_small.ckpt", "rb") as f:
    ckpt = checkpoint.load(f, graphcast.CheckPoint)

# Instantiate model with saved hyperparameters

model = graphcast.GraphCast(**ckpt.config)

# Wrap for autoregressive rollout with gradient checkpointing

predictor = autoregressive.Predictor(model, gradient_checkpointing=True)

# Create input TypedGraph (replace with actual ERA5 data)

inputs = typed_graph.TypedGraph(
    nodes=np.random.randn(ckpt.graph_shape[0], ckpt.node_feature_dim),
    edges=np.random.randn(ckpt.graph_shape[1], ckpt.edge_feature_dim)
)

# Generate single-step prediction

output = predictor(inputs)
print(f"Prediction shape: {output.nodes.shape}")

Loading and Running GenCast Models

GenCast checkpoints follow an identical loading pattern but use gencast.CheckPoint and gencast.GenCast classes.

from weathernext.utils import checkpoint
from weathernext.weathernext1_gen import gencast
from weathernext.utils import autoregressive
from weathernext.utils import typed_graph
import numpy as np

# Load GenCast checkpoint (diffusion denoiser + sampler config)

with open("gencast/GenCast_0p25deg_2019.ckpt", "rb") as f:
    ckpt = checkpoint.load(f, gencast.CheckPoint)

# GenCast includes internal sampling; gradient checkpointing often disabled

model = gencast.GenCast(**ckpt.config)
predictor = autoregressive.Predictor(model, gradient_checkpointing=False)

# Prepare graph-structured input matching checkpoint dimensions

inputs = typed_graph.TypedGraph(
    nodes=np.random.randn(ckpt.graph_shape[0], ckpt.node_feature_dim),
    edges=np.random.randn(ckpt.graph_shape[1], ckpt.edge_feature_dim)
)

# Probabilistic output requires multiple sampler steps internally

output = predictor(inputs)
print(f"Ensemble mean shape: {output.nodes.shape}")

Key Implementation Files

File	Purpose
weathernext/weathernext1_graph/graphcast.py	GraphCast architecture: encoder-processor-decoder graph network
weathernext/weathernext1_gen/gencast.py	GenCast architecture: diffusion denoiser with learned sampler
weathernext/utils/checkpoint.py	checkpoint.load() for model state deserialization
weathernext/utils/autoregressive.py	autoregressive.Predictor wrapper for rollout and gradient checkpointing
weathernext/utils/typed_graph.py	TypedGraph container for node/edge features and metadata
docs/weathernext1_graph/README.md	Checkpoint download links and GraphCast documentation
docs/weathernext1_gen/README.md	Checkpoint download links and GenCast documentation

Model Selection Guide

• Highest resolution deterministic: GraphCast
• Fastest deterministic inference: GraphCast_small
• Operational deterministic: GraphCast_operational
• Highest resolution probabilistic: GenCast 0p25deg <2019
• Operational probabilistic: GenCast 0p25deg Operational <2022
• Memory-constrained probabilistic: GenCast 1p0deg <2019
• Colab/restricted environments: GenCast 1p0deg Mini <2019

Summary

• Seven pre-trained WeatherNext models are available: three GraphCast (deterministic) and four GenCast (probabilistic)
• GraphCast models differ in resolution (0.25° vs 1°), pressure levels (37 vs 13), and training data (ERA5-only vs HRES-fine-tuned)
• GenCast models vary in resolution, mesh refinement (4× to 6×), and operational readiness
• Common loading pattern: checkpoint.load() → instantiate model class → wrap in autoregressive.Predictor → pass TypedGraph inputs
• Source files: weathernext/weathernext1_graph/graphcast.py and weathernext/weathernext1_gen/gencast.py contain the core architectures

Frequently Asked Questions

Where can I download the WeatherNext pre-trained models?

Checkpoint files are hosted in Google Cloud Storage buckets referenced in docs/weathernext1_graph/README.md and docs/weathernext1_gen/README.md. The documentation provides direct download links and checksums for each model variant. No authentication is required for public research access.

What hardware is required to run these models?

GraphCast and GenCast 0p25deg models require substantial GPU memory (typically 32GB+ for inference, more for training). GraphCast_small and GenCast 1p0deg variants run on 16GB GPUs. GenCast 1p0deg Mini is explicitly optimized for free-tier Google Colab with approximately 12GB GPU memory. CPU-only execution is possible but impractical due to autoregressive rollout costs.

Can I fine-tune these pre-trained WeatherNext models on my own data?

Yes. The autoregressive.Predictor wrapper in weathernext/utils/autoregressive.py supports gradient computation and loss evaluation. Load a checkpoint, modify the model architecture if needed (preserving compatible tensor shapes), and use standard JAX optax optimizers. Fine-tuning from GraphCast_operational or GenCast 0p25deg Operational <2022 is recommended when your target domain resembles operational weather analyses.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}