FourCastNet on GB10: AI Weather Forecasting with Earth2Studio

01What you will learn

• What an AI weather model does and how it differs from a classic numerical model.
• What Earth2Studio is and what parts a workflow consists of (data → model → output).
• How to run a first forecast with FourCastNet 3 following the official example.
• How to download the ERA5 reanalysis from Copernicus.
• How to look at the result and crop the area of Bulgaria.
• Why the result is not an official forecast and where the real ones are.

02Before you start

• A machine of the NVIDIA GB10 class with DGX OS (Ubuntu 24.04, Arm64) and a working PyTorch with GPU. The documentation recommends Python 3.13, CUDA 13.0 and uv as the package manager; PyTorch must be installed correctly first.
• Memory: the Earth2Studio catalogue lists a recommended GPU memory of 80 GB for FCN3. The machine has 128 GB of memory shared by the processor and the graphics card, so on paper it fits, leaving about 48 GB for the system and everything else — ⚠️ we have not tried it. Do not run other large models (for example Ollama) at the same time.
• Free space: the hardware documentation indicates about 128 GB of disk.
• GFS data (NOAA) needs no account. ERA5 needs a free account at the Copernicus Climate Data Store with a personal token.
• The model and its weights download automatically on first run. ⚠️ We have not checked the weights' licences — Earth2Studio is an interface to third-party models and data and warns you to check the usage rights of each.

03Steps

1. How an AI weather model works

   A classic (numerical) model computes the equations of atmospheric physics step by step. An AI model is trained on historical data (the ERA5 reanalysis) and learns how the state of the atmosphere changes over one step; then it repeats that. This does not make it more accurate — it makes it cheap to run and handy for experiments. That is why you always compare it with verified sources.

   In Earth2Studio a workflow is a chain of four parts:

   Part	What it is	In the example
   Data source	Where the initial state of the atmosphere comes from	GFS()
   Prognostic model	Takes a step forward in time	FCN3
   Output	Where the results are written	ZarrBackend
   Workflow	Connects them and runs the steps	run.deterministic

2. Install Earth2Studio

   The documentation recommends uv and a fresh clean environment. The commands are from the official guide (version 0.19.0):

   bash · on the machinecopy

   mkdir earth2studio-project && cd earth2studio-project
   uv init --python=3.13
   uv add "earth2studio @ git+https://github.com/NVIDIA/earth2studio.git@0.19.0"
   
   uv run python -c "import earth2studio; print(earth2studio.__version__)"

   The base install contains only the core — most models and data sources need extra package groups. The guide has an install selector where you choose the model (FCN3) and the data. By analogy with the example for another model (earth2studio[aifs,data]) the groups are probably called fcn3 and data — ⚠️ confirm in the selector, do not take it as true.

   💡

   Alternative: a container

   The documentation also shows a route through NVIDIA's PyTorch container (nvcr.io/nvidia/pytorch:26.04-py3) in which the same library is installed. ⚠️ We have not checked whether this image version has an Arm64 variant or how GPU access is passed — see the guide.

3. A first forecast

   This is the example from the Earth2Studio home page. Four lines prepare the parts, the fifth runs the workflow: start date, 10 steps forward, model, data, output.

   python · forecast.pycopy

   from earth2studio.models.px import FCN3
   from earth2studio.data import GFS
   from earth2studio.io import ZarrBackend
   from earth2studio.run import deterministic as run
   
   model = FCN3.load_model(FCN3.load_default_package())
   data = GFS()
   io = ZarrBackend("outputs/fcn3_forecast.zarr")
   run(["2025-01-01T00:00:00"], 10, model, data, io)

   First run: the model weights are downloaded. The date 2025-01-01T00:00:00 is from the official example — for another date, check that GFS has data for it (⚠️ we have not checked). How much time one step covers, see like this:

   pythoncopy

   # how much time one model step covers
   step = model.output_coords(model.input_coords())["lead_time"][0]
   print(step)

   The result is in the folder outputs/fcn3_forecast.zarr.

4. Optional: ERA5 data from Copernicus

   ERA5 is ECMWF's global reanalysis, provided free by the Copernicus Climate Data Store. You need an account; the token goes in the file ~/.cdsapirc (readable only by you — chmod 600). Do not write it in scripts or Git.

   ~/.cdsapirccopy

   url: https://cds.climate.copernicus.eu/api
   key: <personal-token-from-CDS>

   The terms of use of each dataset are accepted manually on its page (at the bottom of the download form). The example from the documentation:

   pythoncopy

   # pip install "cdsapi>=0.7.7"
   import cdsapi
   
   client = cdsapi.Client()
   
   dataset = "reanalysis-era5-pressure-levels"
   request = {
       "product_type": ["reanalysis"],
       "variable": ["geopotential"],
       "year": ["2024"],
       "month": ["03"],
       "day": ["01"],
       "time": ["13:00"],
       "pressure_level": ["1000"],
       "data_format": "grib",
   }
   target = "download.grib"
   
   client.retrieve(dataset, request, target)

   Earth2Studio also has ready-made ERA5 sources — see the catalogue of data sources in its documentation.

5. Look at the result

   The Zarr file is read with xarray. First print the contents — the variable names follow the Earth2Studio lexicon and may differ from those here.

   pythoncopy

   import xarray as xr
   import matplotlib.pyplot as plt
   
   ds = xr.open_zarr("outputs/fcn3_forecast.zarr")
   print(ds)   # first see which variables and axes exist
   
   t2m = ds["t2m"].isel(time=0, lead_time=-1) - 273.15   # kelvin -> °C
   t2m.plot(cmap="RdYlBu_r")
   plt.title("Temperature at 2 m, last step (°C)")
   plt.savefig("t2m_last_step.png", dpi=150)

   For Bulgaria, crop a rectangle by coordinates (as a guide: roughly 41–44.5° N and 22–29° E).

   pythoncopy

   # crop to the area of Bulgaria (if the lat axis is descending, the slice order is reversed)
   bg = t2m.sel(lat=slice(44.5, 41.0), lon=slice(22.0, 29.0))
   bg.plot(cmap="RdYlBu_r")

   ⚠️ The code in this step has not been run; the lead_time axis and the names follow the structure described in the Earth2Studio documentation — if you get an error, start with print(ds).

6. One forecast is one possible development

   FourCastNet 3 is a probabilistic model: with a different "seed" (the seed parameter) it gives different plausible developments. One run does not tell you how likely something is. For probabilities you run many developments (an ensemble) — Earth2Studio's example gallery has "Running Ensemble Inference". We do not do it here.

7. What this is not

   Limits you should know: the grid is 0.25° (about 25 km) — mountains, coasts and individual storms stay below it, which is exactly the topic of the next lesson; AI models make mistakes, especially with precipitation and extreme events, and the error grows with time ahead; the initial data (GFS, ERA5) carry errors of their own. For any real decision, read NIMH.

   ⛈️

   Do not make decisions from this output

   This lesson does not give an official forecast and does not replace one. It shows how an AI weather model works. Official forecasts and warnings for Bulgaria are issued by NIMH (the National Institute of Meteorology and Hydrology): meteo.bg; warnings by municipality are at weather.bg/obshtini, and for Europe at meteoalarm.org. Do not make decisions about safety, farming, events or energy from this lesson's output.

04Check

• import earth2studio works and the version prints.
• The script forecast.py finishes and outputs/ holds a Zarr file.
• print(ds) shows the variables and axes of the result.
• The Copernicus token is only in ~/.cdsapirc.
• You can explain why the result is not an official forecast and where the official ones are.

Test

05What next

06Sources

1. NVIDIA Earth2Studio (GitHub) — the FourCastNet 3 example, version and Apache 2.0 licence; checked 03.10.2026.
2. Earth2Studio: install — uv, version 0.19.0, recommended environment and hardware.
3. Earth2Studio: the FCN3 model · the FCN model — model descriptions; the paper: arXiv 2507.12144.
4. Earth2Studio: deterministic workflow — example and parameters of run.deterministic.
5. build.nvidia.com: fourcastnet 🌐 global — the model page in NVIDIA's catalogue; the model licence is on that page.
6. Copernicus CDS: API setup 🌐 global — address, personal token, cdsapi.
7. NIMH: meteo.bg · warnings by municipality · meteoalarm.org — official forecasts and warnings.