# WeatherNext 2: running Google DeepMind's forecast model locally

> The weathernext repository ships WN2, WeatherNext Cyclones and the older GraphCast and GenCast code under Apache-2.0. Here is what the install actually pulls in, how the rollout works, and where the model is the wrong tool.

**google-deepmind/weathernext** — weathernext

- Repository: https://github.com/google-deepmind/weathernext
- Stars: 7,692 · Forks: 997
- Language: Python
- License: Apache-2.0
- Published: 2026-08-17 · Updated: 2026-08-18 · Language: en
- Canonical page: https://hysenlabs.com/projects/google-deepmind-weathernext

## What WeatherNext 2 is and who the repository is for

WeatherNext 2 (WN2) is a global, medium-range atmospheric and cyclone forecasting model developed by Google DeepMind and Google Research. The repository at google-deepmind/weathernext holds the code to run it, plus the code and documentation for two earlier generations, GraphCast (WeatherNext Graph) and GenCast (WeatherNext Gen). The README describes the repository as the primary home for the whole family.

The intended user is not someone who wants a weather forecast. It is a researcher or engineer who wants to run the model. The README is explicit that this is research code provided as-is for running and experimenting with the published models, with no guarantees of API stability and possible breaking changes without notice; it recommends pinning to a specific release. setup.py classifies the package as Development Status :: 3 - Alpha and Intended Audience :: Science/Research. If you want forecasts rather than a model, the README points elsewhere: Google Cloud (Earth Engine, BigQuery, Vertex AI), WeatherLab, and OpenMeteo, the last of which offers an API and an interactive builder.

## The checkpoints, their resolutions and what separates them

The repository provides several pretrained checkpoints, and the differences matter more than the naming suggests. WeatherNext2_<2025 runs at 0.25 degree resolution, roughly 30 km, is fine-tuned on ECMWF HRES data, and is designed to be initialized directly from operational HRES initial conditions rather than ERA5 reanalysis. It was trained on data through 2024 and ships as four weight files, WeatherNext2_<2025_model{1,2,3,4}.npz.

The WeatherNext Cyclones checkpoints come in three vintages: WeatherNextCyclones_<2025, the model that ran live during the 2025 Atlantic hurricane season and is publicly referred to as FNV3, with NHC's postprocessed version called GDMI; WeatherNextCyclones_<2024; and WeatherNextCyclones_<2023. Each is 0.25 degree and ships as four .npz files.

Then there is WeatherNextCyclones_Mini. At 1 degree resolution it is the lightweight option for lower memory and compute constraints, and the README names local testing and single TPUs or GPUs as the intended setting. It forecasts the same variables as WeatherNext2_<2025, cyclones included. The README states plainly that it is not expected to match the performance of the larger versions. Two vintages exist, WeatherNextCyclones_Mini_<2024 and WeatherNextCyclones_Mini_<2023, each a single .npz file.

One detail worth reading twice: the only difference between WN2 and WeatherNext Cyclones is that WN2 can also predict 100 m wind. WN2 forecasts cyclones with the exact same algorithm. The weights differ because the training runs were independent.

## Installing weathernext and running the first forecast

The README gives a single install command, pinned to a release tag. Run it in a Python environment you are willing to rebuild, because the dependency list is long and includes a package installed straight from git.

```bash
pip install git+https://github.com/google-deepmind/weathernext.git@v0.3.0
```

The package name is weathernext and setup.py reports version 0.3.1.dev on the default branch, so installing without a tag will not give you the same code as the tagged release. The install_requires list pulls in jax, dm-haiku, fiddle, chex, dinosaur-dycore, jraph, dask, h5netcdf, xarray capped at <=2026.2.0, xarray_tensorstore, and gdm-xarray-jax from a git URL pinned at v0.1.1. That git dependency is the one most likely to break a locked build, since it resolves against a moving repository rather than a package index.

The README's recommended path is not a script. It is the interactive Colab notebook at docs/weathernext2/wn2_demo.ipynb, which defaults to WeatherNext Cyclones Mini and is meant to be run on the v5e-1 runtime, available as a free Colab runtime. The other models in the list require a v5p accelerator. The notebook is where the weights are loaded automatically from the Google Cloud storage bucket, so you do not fetch the .npz files by hand for a first run.

According to the README, the notebook walks through loading model weights, loading initial state weather data such as HRES initial conditions, initializing the WN2 (FGN) architecture, running auto-regressive rollout steps, visualizing temperature, wind speed and geopotential height, running the direct tracker on model outputs to get cyclone track data, and computing the training loss on predictions and targets before taking a gradient step. That last item is the signal that this is a research artifact, not an inference-only service.

## Hardware: the TPU assumption and the GPU attention switch

The README recommends running WeatherNext 2 on TPU where possible, because the implementation has been optimized for it. That is a design constraint, not a preference, and it shapes who can use the code at all.

Running on GPU is possible but requires a code change: the attention implementation must be switched, as shown in the demo notebook. The README does not describe the switch as a configuration flag, so plan on editing the notebook or your own copy of the model code. Memory requirements are stated per tier. The non-Mini models require an H100 for sufficient VRAM. The Mini models should manage inference on a P100.

Put together, the practical ladder is: P100 or a free v5e-1 Colab runtime for the 1 degree Mini checkpoints, H100 or v5p for the 0.25 degree operational checkpoints. If your only accelerator is a consumer GPU, the README does not claim the non-Mini models will fit, and the Mini path is the one it points to.

## Where weathernext is the wrong choice

The clearest failure mode is treating this as a forecast service. The README's own note says the code is provided as-is for running and experimenting with the published models, with no API stability guarantees and possible breaking changes without notice. There is no documented rollback procedure, no compatibility promise between releases, and no support commitment. If you need an operational feed, the README routes you to Google Cloud, WeatherLab or OpenMeteo instead, which is an admission that the repository is not that product.

The second limitation is the initialization dependency. WeatherNext2_<2025 is designed to be initialized from operational HRES initial conditions rather than ERA5 reanalysis. That is a deliberate choice for forecast quality, but it means your pipeline has to supply HRES-format initial states. The README does not document what happens if you substitute a different analysis product, and the notebook's sample data is the path of least resistance for a first run.

The third is the checkpoint naming. The angle brackets in names like WeatherNext2_<2025 and the model{1,2,3,4} suffix on the weight files are easy to misread as literal filename characters. The README presents them as family labels for training cutoffs and ensemble members; the actual .npz filenames are not spelled out in full for every checkpoint. Expect to confirm the exact strings against the storage bucket before writing a download script.

Finally, the Mini checkpoints are a deliberate downgrade. At 1 degree they are coarse for local or regional work, and the README says outright that they are not expected to match the larger versions. Using Mini to draw conclusions about WN2's skill would be a mistake.

## weathernext vs graphcast and gencast, and the hosted alternatives

The repository answers this comparison itself by hosting all three generations side by side. WeatherNext Graph is deterministic medium-range forecasting using graph neural networks, published as GraphCast. WeatherNext Gen is diffusion-based ensemble forecasting for medium-range weather, published as GenCast. WeatherNext 2 is the current model, with a cyclone variant that shares its algorithm.

The approaches differ in what they produce. GraphCast is a single deterministic forecast. GenCast is an ensemble built on diffusion, which is what you want when the question is about risk and spread rather than a most likely state. WN2 is trained on data through 2024 and fine-tuned for HRES initialization, which is the practical difference from the earlier generations: the older models were built around reanalysis-style inputs, while WN2 is aimed at operational initial conditions. The FGN/WN2 technical report is titled Skillful joint probabilistic weather forecasting from marginals, which is the reference for how the probabilistic side is constructed.

If you do not want to run any of them, the alternatives are hosted: Google Cloud, WeatherLab (which includes cyclone tracks) and OpenMeteo (an API and interactive builder). The trade-off is the usual one. Hosted feeds remove the accelerator requirement and the dependency churn, and in exchange you get someone else's update cadence, coverage and retention policy rather than a checkpoint on your own disk.

## Licence, maintenance and the cost of upgrading

The repository is Apache-2.0, and setup.py declares the same licence for the package. That is a permissive licence, and it is worth noting that the weights are distributed separately through a Google Cloud bucket rather than as part of the pip package, so the terms attached to the weights are a separate question from the terms attached to the code. This is not legal advice; if the distinction matters for your use, read the licence file and the bucket's terms yourself.

On maintenance, the last push was on 2026-08-06, the same date as the v0.3.0 release. Before that, v0.2 landed on 2026-03-30 and v0.1.1 on 2024-10-09. The gap between v0.1.1 and v0.2 is roughly seventeen months, so release cadence has not been steady, and the README's warning about breaking changes without notice should be read against that history.

The upgrade cost is concentrated in two places. First, the pinned release tag in the install command: the README recommends pinning, which means moving to a new version is a deliberate act of re-pinning and re-testing. Second, the git-based dependency gdm-xarray-jax at v0.1.1 and the xarray<=2026.2.0 cap. Either can conflict with the rest of your environment when you bump the weathernext version, and neither is under this repository's release control.

## Conclusion

Adopt weathernext if you already work with HRES initial conditions and have TPU or H100 capacity, and start from the wn2_demo.ipynb notebook rather than the pip install alone. Do not adopt it if you want a hosted forecast feed, a supported API, or something that fits on a laptop: the Mini checkpoints at 1 degree are the only low-memory path, and the README states they are not expected to match the larger versions. Verify three things before committing: that your accelerator matches the checkpoint you intend to run, that the pinned release tag you install still resolves its git-based dependency, and that you have a plan for the model weights, which are not part of the pip package.

## FAQ

### What is Google WeatherNext?

It is a family of weather forecasting models from Google DeepMind and Google Research. The google-deepmind/weathernext repository holds the code for WeatherNext 2, the global medium-range atmospheric and cyclone model, plus the earlier GraphCast and GenCast models.

### How to access WeatherNext 2?

You can run the model yourself from the repository, or use daily data feeds of WN2 model outputs that the README says are provided on Google Cloud, WeatherLab and OpenMeteo. The Google Cloud option covers Earth Engine, BigQuery and Vertex AI.

### how to use weathernext 2

The README points to the interactive Colab notebook at docs/weathernext2/wn2_demo.ipynb, which defaults to WeatherNext Cyclones Mini on the free v5e-1 runtime. The notebook loads weights, loads initial state data, initializes the WN2 (FGN) architecture and runs auto-regressive rollout steps.

### weathernext 2 vs graphcast

Both live in this repository. WeatherNext Graph is deterministic medium-range forecasting with graph neural networks, published as GraphCast. WeatherNext 2 is the current model, trained on data through 2024 and designed to be initialized from operational HRES initial conditions rather than ERA5 reanalysis.

### gencast vs weathernext

GenCast is hosted here as WeatherNext Gen, described as diffusion-based ensemble forecasting for medium-range weather. WeatherNext 2 is the newer model, and the README notes that WN2 also forecasts cyclones with the exact same algorithm as WeatherNext Cyclones, differing only in training runs.

## Sources

- [Official README](https://github.com/google-deepmind/weathernext#readme)
- [Project repository](https://github.com/google-deepmind/weathernext)
- [Release notes](https://github.com/google-deepmind/weathernext/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/google-deepmind-weathernext