# Is WeatherNext Suitable for Real‑Time Forecasting? Architecture Constraints and Practical Limits

> Discover if WeatherNext supports real-time forecasting. Explore its architecture and practical limits for operational weather predictions. Learn about its update cycles.

- Repository: [Google DeepMind/weathernext](https://github.com/google-deepmind/weathernext)
- Tags: architecture
- Published: 2026-08-16

---

**WeatherNext is not designed for true real‑time (< hour) forecasting but works well for near‑real‑time operational forecasting with daily or 6‑hourly update cycles.**

The **WeatherNext** repository by Google DeepMind delivers state‑of‑the‑art medium‑range global weather prediction. However, its neural architecture, hardware dependencies, and autoregressive inference pattern impose latency floors that rule out ultra‑low‑latency "nowcasting." This article examines the source code to explain exactly where WeatherNext fits on the real‑time spectrum and how to deploy it operationally.

---

## Primary Use Case: Medium‑Range Global Forecasting

According to the source code and documentation, WeatherNext targets **global, medium‑range (up to ~10 days) atmospheric and cyclone forecasting**. The production‑grade **WeatherNext 2 (WN2)** model runs at **0.25° (~30 km) resolution** using a deep **icosahedral mesh Graph Neural Network (GNN)** with multiple encoder/decoder stages.

In [`weathernext/weathernext2/architecture.py`](https://github.com/google-deepmind/weathernext/blob/main/weathernext/weathernext2/architecture.py), the `ForwardPass` class constructs this multi‑stage pipeline:

- **Points‑to‑mesh encoder** – projects spherical grid data onto an icosahedral mesh
- **Mesh GNN processor** – performs message passing across mesh nodes
- **Mesh‑to‑grid decoder** – maps back to latitude‑longitude output

This architecture prioritizes **predictive accuracy over inference speed**, making it unsuitable for sub‑hourly latency requirements.

---

## Inference Latency: Hardware and Timing Benchmarks

### TPU Optimization as a Requirement

The README explicitly recommends **TPU for inference**: *"We recommend running WeatherNext 2 on TPU where possible."* GPU inference demands alternative attention implementations and substantial VRAM—**H100‑class hardware for non‑Mini models**. This hardware lock‑in inherently limits deployment flexibility for edge or rapid‑response scenarios.

### Autoregressive Rollout Timing

Forecasts generate through **autoregressive rollout**: each timestep requires a complete forward pass through the mesh GNN. The [`weathernext/utils/rollout.py`](https://github.com/google-deepmind/weathernext/blob/main/weathernext/utils/rollout.py) module implements this stepping loop.

Typical latencies on **TPU v5e‑1**:
- **Single 6‑hour lead**: ~10–20 seconds
- **Full 10‑day rollout**: 2–5 minutes

The Colab demo notebook (`docs/weathernext2/wn2_demo.ipynb`) demonstrates these timings empirically.

---

## Training Lead Times Exclude Nowcasting

In [`weathernext/utils/data_utils.py`](https://github.com/google-deepmind/weathernext/blob/main/weathernext/utils/data_utils.py), the data utilities construct training samples with **6‑hour minimum lead times**, extending to several days. The model never sees sub‑hourly dynamics during training—the frequency domain required for true nowcasting (precipitation nowcast, severe weather warning, etc.).

This architectural decision reflects WeatherNext's design philosophy: **substitute numerical weather physics with learned neural representations for medium‑range prediction**, not replace radar‑based nowcast systems.

---

## Operational Deployment Options

### Self‑Hosted Inference

For organizations requiring custom forecasts, the repository supports:

```python
import weathernext.weathernext2.architecture as wn2
from weathernext.utils import checkpoint, predictor_base
import xarray as xr
import numpy as np

# Load pretrained weights (Mini model example)

ckpt_path = "gs://dm_graphcast/WeatherNextCyclones_Mini_2024_model1.npz"
params = checkpoint.load_checkpoint(ckpt_path)

# Build the forward pass architecture

forward = wn2.ForwardPass(
    latent_dense_kwargs=dict(output_size=256, activation="gelu"),
    output_dense_kwargs=dict(output_size=128, activation="gelu"),
    mesh_num_splits=4,
    points_to_mesh_model_ctor=wn2.points_to_mesh_default_ctor(),
    mesh_model_ctor=wn2.mesh_default_ctor(),
    mesh_to_grid_model_ctor=wn2.mesh_to_grid_default_ctor(),
)

# Minimal predictor wrapper

class WeatherNextPredictor(predictor_base.Predictor):
    def __call__(self, inputs, targets_template, forcings, **kwargs):
        return forward(
            inputs=inputs,
            targets_template=targets_template,
            forcings=forcings,
            is_training=False,
        )

predictor = WeatherNextPredictor()

# Mock input (replace with real ERA5/HRES initialization)

inputs = xr.Dataset(
    {"temperature": (("batch", "lat", "lon"), 
                    np.random.rand(1, 3, 4).astype(np.float32))},
    coords={
        "lat": xr.DataArray([0, 1, 2], dims="lat"),
        "lon": xr.DataArray([0, 1, 2, 3], dims="lon"),
        "batch": [0]
    },
)

# Generate forecast

forecast = predictor(inputs, inputs, xr.Dataset())

```

**Key implementation notes from [`architecture.py`](https://github.com/google-deepmind/weathernext/blob/main/architecture.py):**
- `ForwardPass` encapsulates the full GNN pipeline
- `latent_dense_kwargs` and `output_dense_kwargs` configure MLP dimensions
- `mesh_num_splits=4` controls icosahedral mesh refinement level

### Pre‑Computed Data Feeds

For operational users who accept **daily forecast refresh cycles**, Google Cloud, WeatherLab, and OpenMeteo host **pre‑computed WeatherNext forecast feeds**. The README's "Accessing Forecast Data Feeds" section documents these endpoints—eliminating inference infrastructure entirely.

---

## Real‑Time Suitability Decision Matrix

| Scenario | WeatherNext Fit | Recommended Approach |
|----------|---------------|----------------------|
| Sub‑hourly nowcasting (0–6 hours) | **Poor** | Radar‑based CNNs (e.g., DGMR, MetNet) |
| 6‑hourly operational updates | **Good** | TPU inference with [`rollout.py`](https://github.com/google-deepmind/weathernext/blob/main/rollout.py) |
| Daily forecast refresh | **Excellent** | Pre‑computed data feeds |
| Research/exploratory forecasting | **Excellent** | Colab demo + custom checkpoint loading |

---

## Summary

- **WeatherNext's mesh GNN architecture** in [`architecture.py`](https://github.com/google-deepmind/weathernext/blob/main/architecture.py) prioritizes 10‑day forecast accuracy over inference speed
- **TPU dependency** and **2–5 minute rollout latency** for full forecasts preclude true real‑time (< hour) applications
- **6‑hour minimum training lead times** mean the model lacks sub‑hourly atmospheric dynamics
- **Near‑real‑time operational use** (daily/6‑hourly cycles) is fully supported via self‑hosted TPU inference or pre‑computed feeds

---

## Frequently Asked Questions

### How long does a WeatherNext forecast take to generate?

A single 6‑hour lead takes **10–20 seconds on TPU v5e‑1**, while a complete 10‑day autoregressive rollout requires **2–5 minutes**. GPU inference is possible but needs H100‑class hardware and modified attention implementations.

### Can WeatherNext run on consumer GPUs?

**No.** The repository explicitly targets TPU acceleration. GPU inference requires code modifications for attention kernels and substantial VRAM beyond consumer cards. The Mini models offer reduced memory footprints but still need datacenter‑class hardware.

### What is the fastest lead time WeatherNext can predict?

The model accepts **6‑hour minimum lead times** as configured in [`data_utils.py`](https://github.com/google-deepmind/weathernext/blob/main/data_utils.py). It cannot produce sub‑hourly or even hourly forecasts natively—specialized nowcast models trained on radar data are required for those horizons.

### Where can I get WeatherNext forecasts without running the model?

Google Cloud, WeatherLab, and OpenMeteo provide **pre‑computed forecast feeds** refreshed on a daily schedule. This eliminates infrastructure costs and latency entirely for operational users who don't need custom initialization times.