NVIDIA Earth-2 Workflow 2026: Nowcasting From Your Own Radar

NVIDIA has quietly shipped the thing every operations meteorologist has been asking for: a documented NVIDIA Earth-2 nowcasting workflow that takes live radar and satellite observations and returns hyperlocal, kilometer-scale forecasts for the next few hours — over an API call, not a supercomputer allocation. The new Earth-2 blueprint wires StormCast and CorrDiff together behind NIM microservice endpoints, so a Python script on a laptop can produce the kind of convective nowcast that used to require a dedicated HPC cluster and a research team to babysit it. For anyone who makes money or loses it based on what the sky does in the next six hours — utilities, construction, aviation ground ops, outdoor events, agriculture, logistics — the barrier just dropped from “hire a modeling group” to “read the docs and write fifty lines of code.” Teams that move first will quote weather risk while their competitors refresh a public forecast page.

What’s actually new in the NVIDIA Earth-2 nowcasting workflow

Earth-2 is not new. NVIDIA has published AI weather models — FourCastNet, CorrDiff, StormCast — for a couple of years, mostly as research artifacts with weights on NGC and a paper attached. What changed is packaging. The 2026 workflow guide treats nowcasting as a product pipeline rather than a research demo: ingest observations, condition a model on them, downscale the output, hand back a decision-ready field. Each stage is a callable NIM endpoint, and the chain is orchestrated from earth2studio, NVIDIA’s open-source Python package that abstracts away the data plumbing.

The two models doing the work are worth separating. StormCast is built for convection. It trained on HRRR analysis data at 3 km resolution over the central United States and steps forward autoregressively in roughly one-hour increments, capturing the mesoscale behavior — storm initiation, cold pool dynamics, squall line organization — that coarse global models smear into mush. CorrDiff is a generative diffusion model that performs super-resolution downscaling: feed it a coarse field from a global forecast and it produces a physically plausible kilometer-scale field, including derived variables like 10 m winds and radar reflectivity that the coarse input never contained. CorrDiff downscaling makes a 25 km global forecast useful for deciding whether to keep a crane up.

The operational unlock is the NIM wrapper. An Earth-2 NIM is a containerized inference microservice with a stable HTTP interface — call NVIDIA’s hosted endpoint on build.nvidia.com with an API key, or pull the container and run it on your own GPU behind your own firewall with the identical interface. That second option matters more than it sounds. Utilities and airports frequently cannot ship operational data to a third-party cloud, and running the same model locally with the same client code turns a compliance blocker into a deployment choice. The blueprint also formalizes the observation-conditioning path, which is what makes this nowcasting rather than forecasting. You are not running a model on the last global analysis; you are initializing it on what your radar saw fifteen minutes ago.

Why the Earth-2 nowcasting workflow matters

• The latency gap closes. Traditional convection-allowing NWP runs on a fixed cycle and takes tens of minutes to hours of wall clock. StormCast inference takes seconds on a single GPU, so you can re-run on every radar volume scan instead of waiting for the top of the hour. For a storm moving at 40 mph, that difference is miles of warning.
• Hyperlocal becomes affordable. CorrDiff turns coarse, cheap global forecasts into kilometer-scale fields without a nested dynamical model. Organizations that could never justify running WRF now get comparable spatial detail for the cost of an inference call.
• Ensembles stop being a luxury. Because CorrDiff is generative, sampling it repeatedly gives you a spread — a real probabilistic picture rather than a single deterministic line. Fifty members of a diffusion model cost less than one member of a physics model, which flips the economics of uncertainty quantification.
• Your own observations become an asset. If you operate a private radar, a mesonet, or a fleet of instrumented vehicles, that data has mostly been decorative. Observation-conditioned nowcasting gives it a direct path into a forecast that beats the public one for your specific footprint.
• On-prem deployment is a first-class path. The same NIM container runs in your data center, making AI weather nowcasting viable for regulated sectors — grid operators, defense, insurance — that cannot use a hosted API.
• The bar drops for weather-aware products. A logistics SaaS, an insurance underwriting tool, or a drone-operations platform can embed real nowcasting without hiring a meteorologist. Expect a wave of vertical apps built on exactly this stack.

How to use the Earth-2 NIM API today

Here is the practical path from zero to a nowcast. You need a Python 3.10+ environment and either an NVIDIA API key (free tier available at build.nvidia.com) or a local GPU with at least 24 GB of VRAM for self-hosting.

1. Install earth2studio. This is the orchestration layer. It handles data sources, model loading, coordinate systems, and output writing so you are not hand-rolling NetCDF readers.

   python -m venv .venv
   source .venv/bin/activate    # Windows: .venv\Scripts\activate
   pip install "earth2studio[data,perturbation]"
   pip install xarray netCDF4 matplotlib zarr

2. Set your API credentials. Get a key from build.nvidia.com, then export it. earth2studio reads this automatically for hosted NIM calls and for pulling model weights from NGC.

   export NGC_API_KEY="nvapi-xxxxxxxxxxxxxxxxxxxxxxxx"
   export NVIDIA_API_KEY="nvapi-xxxxxxxxxxxxxxxxxxxxxxxx"
   export EARTH2STUDIO_CACHE="$HOME/.cache/earth2studio"

3. Smoke-test the hosted endpoint. Before wiring anything complex, confirm your key works against a NIM. A plain HTTP call tells you immediately whether the problem is auth or code.

   curl -X POST "https://integrate.api.nvidia.com/v1/earth2/nim/status" \
     -H "Authorization: Bearer $NVIDIA_API_KEY" \
     -H "Accept: application/json"

4. Pull observations for your domain. earth2studio ships data connectors for HRRR, GFS, ERA5, and GOES. A StormCast run wants HRRR analysis as the initialization state — the substitute for “your own radar” until you swap in a private feed.

   from datetime import datetime, timedelta
   from earth2studio.data import HRRR
   
   ds = HRRR(cache=True)
   t0 = datetime.utcnow().replace(minute=0, second=0, microsecond=0) - timedelta(hours=2)
   
   state = ds(t0, ["u10m", "v10m", "t2m", "refc"])
   print(state.shape, state.coords)

5. Run the StormCast nowcast. This is the core loop: load the model, hand it the initial state, step forward. Twelve steps at roughly one hour each gives you a half-day convective outlook; for true nowcasting, use the first four to six.

   import torch
   from earth2studio.models.px import StormCast
   from earth2studio.io import ZarrBackend
   from earth2studio.run import deterministic
   
   package = StormCast.load_default_package()
   model = StormCast.load_model(package).to("cuda")
   
   io = ZarrBackend(file_name="nowcast.zarr")
   io = deterministic([t0], 6, model, ds, io)
   
   print(io.root.tree())

6. Downscale with CorrDiff for the last mile. If your upstream field is coarse — a global model rather than HRRR — run CorrDiff for kilometer-scale detail. Sampling more than once gives you an ensemble spread instead of a single answer.

   from earth2studio.models.dx import CorrDiff
   
   cd_package = CorrDiff.load_default_package()
   corrdiff = CorrDiff.load_model(cd_package).to("cuda")
   corrdiff.number_of_samples = 16    # ensemble members
   corrdiff.number_of_steps = 12      # diffusion steps
   
   hi_res = corrdiff(state)
   print(hi_res.shape)   # (members, vars, lat, lon)

7. Turn fields into a decision. A forecast array is not an answer. Reduce it to the threshold your operation cares about — gust over 35 kt, reflectivity over 40 dBZ within 10 km — and compute the probability across ensemble members.

   import numpy as np
   
   gust = np.sqrt(hi_res[:, 0]**2 + hi_res[:, 1]**2)   # m/s
   threshold = 18.0                                     # ~35 kt
   prob = (gust > threshold).mean(axis=0)
   
   if prob.max() > 0.30:
       print(f"STAND DOWN ADVISORY: peak gust prob {prob.max():.0%}")

8. Self-host if the data has to stay put. The NIM container exposes the same interface locally. Point your client at localhost and nothing else in your code changes.

   docker login nvcr.io -u '$oauthtoken' -p "$NGC_API_KEY"
   
   docker run --rm --gpus all \
     -e NGC_API_KEY \
     -v "$HOME/.cache/nim:/opt/nim/.cache" \
     -p 8000:8000 \
     nvcr.io/nim/nvidia/corrdiff:latest
   
   curl -s localhost:8000/v1/health/ready

9. Schedule it. Nowcasting is worthless as a one-off. Run it on a cadence that matches your observation refresh — every 15 minutes is a sane default for radar-driven workflows.

   */15 * * * * /opt/wx/.venv/bin/python /opt/wx/nowcast.py \
     --domain kansas_ops --lead-hours 6 \
     --out /var/wx/latest.zarr >> /var/log/nowcast.log 2>&1

How it compares

Approach	Resolution	Update cadence	Cost profile	Best for
Earth-2 StormCast + CorrDiff	~1–3 km	On demand (seconds)	Per-inference or one GPU	Convective nowcasting, on-prem ops
Google DeepMind nowcasting / GraphCast line	~0.25° global, higher for radar nowcast	Cycle-based via partners	Mostly research access	Global medium range, research
NOAA HRRR (public)	3 km	Hourly, ~50 min latency	Free	Baseline truth, US only
Self-run WRF	Configurable to sub-km	Hours per run	Cluster + staff	Custom physics, research
Commercial weather API (Tomorrow.io, DTN)	Vendor-defined	Minutes	Subscription per seat/call	Turnkey alerts, no ML team
ECMWF AIFS	~0.25°	Operational cycles	Open data	Global AI forecasting benchmark

The honest read: Earth-2 is not the most accurate forecast on the planet for every variable, and it does not replace a national weather service. It uniquely offers kilometer-scale output, seconds-level inference, and the ability to run the whole thing inside your own network. No one else currently gives you all three in a documented, copy-paste form.

What’s next

The near-term thing to watch is geographic coverage. StormCast’s training domain is the central United States, a hard constraint — it is not a global convective model, and applying it outside its training region will produce confident nonsense. NVIDIA has signaled that regional CorrDiff variants (Taiwan, plus additional partner-trained domains) are the template for expansion, and national met services and private operators are already fine-tuning their own CorrDiff models on local high-resolution reanalysis. Expect a small ecosystem of domain-specific weights rather than one global model, and expect earth2studio to grow a registry for them.

The second thread is direct observation assimilation. Today’s practical workflow conditions on gridded analysis products; the research direction is ingesting raw radar volumes, satellite radiances, and surface station reports without an intermediate analysis step. That is the difference between nowcasting from HRRR’s view of your radar and genuine nowcasting from your own radar — the capability that would let a private operator with dense local instrumentation systematically beat the public forecast in their footprint. Watch for observation-encoder work landing in the Earth-2 model catalog.

Third, verification will become the battleground. Diffusion models produce beautiful, sharp, physically plausible fields, which is exactly why they are dangerous in operations — plausible is not the same as correct. Any team putting this into a decision loop should stand up its own verification harness against local observations before trusting a single output, and should assume regulators and insurers will eventually ask to see it. Build the scorecard on day one, not after the first bad call.

Frequently Asked Questions

Do I need an NVIDIA GPU to use the Earth-2 NIM API?

Not for the hosted path. Calling NIM endpoints on build.nvidia.com works from any machine with Python and an API key — the GPU is on NVIDIA’s side. You need local hardware only if you self-host the container, in which case plan on a modern data-center or high-end workstation GPU with 24 GB or more of VRAM. Most teams start hosted and move on-prem once data-residency or cost per call justifies it.

Is this actually free, or is there a bill waiting?

build.nvidia.com offers free API credits that cover evaluation and light use, and earth2studio plus the model weights are open. Sustained operational volume will eventually require paid credits or your own hardware. The data sources the workflow pulls from — HRRR, GFS, GOES — are public and free.

How far out can StormCast actually forecast?

It is built for the convective-scale window, which in practice means useful skill out to roughly six hours, with the strongest value in the first two to three. Beyond that, error growth in the autoregressive rollout compounds and a global model serves you better, optionally with CorrDiff downscaling applied to it. Do not treat StormCast as a day-ahead product.

Can I use my own radar data instead of HRRR?

Partially, today. The supported path is to regrid and assimilate your observations into the model’s expected input format — real work, not a config flag. Direct raw-observation conditioning is the announced direction rather than a finished feature. Start with HRRR initialization, build your verification harness, then invest in custom ingest once the pipeline has proven it earns its keep.

How does CorrDiff downscaling differ from simple interpolation?

Interpolation smooths existing values and cannot invent structure that was not in the coarse field. CorrDiff is a generative model trained on paired coarse and fine data, so it produces physically consistent fine-scale features — terrain-driven wind channeling, convective cells, reflectivity cores — that the input genuinely does not contain. That power is also the caveat: it generates a plausible realization rather than measuring one, so use ensembles and verify locally.

What is the biggest mistake teams make deploying this?

Running it outside the training domain and believing the output. These models do not fail loudly — they return a clean, well-formed, entirely fictional field. The second most common mistake is skipping ensembles and treating a single deterministic run as truth. Sample the diffusion model, compute probabilities, set thresholds tied to actual operational decisions, and score yourself against observations every day.