Surya: Inside the NASA & IBM Foundation Model That Predicts the Sun’s Fury

Introduction

The Sun looks serene from the backyard. Up close, it’s noisy, fast, and a little rude to anything with electronics. A single outburst can scramble GPS, knock out radio on polar flights, and push satellites off their lanes. For decades we treated space weather like art, part physics, part intuition. Now there’s a disciplined way forward. NASA Surya, a heliophysics foundation model co-built with IBM foundation model, learns from years of high-resolution solar images and predicts what the star will do next. It is research grade, open to the community, and already pushing benchmarks in solar flare prediction. If you care about satellites, aviation, or power grids, this is a genuine step.

1. What NASA Surya Is

NASA Surya is a heliophysics foundation model, a large neural network trained to understand solar dynamics directly from data. Instead of solving one narrow task, it learns a general representation of the Sun’s behavior, then adapts to many jobs. It ingested nine years of Solar Dynamics Observatory imagery across multiple instruments and wavelengths, at native 4096 by 4096 resolution with a regular cadence. That gives NASA Surya a stable view across an entire solar cycle, which is rare and powerful.

Under the hood, NASA Surya uses a spatiotemporal transformer that pays attention to both space and time. It tracks evolving magnetic structures, brightness patterns, and flows, then rolls those patterns forward to forecast the near future. The result isn’t just a score. NASA Surya can render what a patch of the Sun will look like a couple of hours ahead, which makes the forecast inspectable by scientists and operators.

2. Why This Model Matters

2.1 The Stakes For A Space Weather Forecast

When the Sun gets rowdy, the ionosphere changes, GPS drifts, and radio links vanish. Coronal mass ejections induce currents in long power lines and can trip protection systems. Airlines reroute polar flights. Operators of low Earth orbit satellites raise orbits to fight atmospheric drag. The faster you see it coming, the less you lose. NASA Surya pushes prediction into a timeframe that matters for real operations. It helps predict solar flares, gives context to satellite drag predictions, and supports better risk calls for critical infrastructure.

2.2 The Dataset That Makes It Possible

The Solar Dynamics Observatory is the quiet hero here. It has produced a continuous, calibrated record since 2010 with multiple EUV channels from AIA and magnetic maps from HMI. That consistency is gold for machine learning. NASA Surya learns from the same star, through the same glass, in the same geometry, for years. Less noise from instrument changes means more signal from physics. The model learns subtle precursors that shorter, patchy datasets would bury.

2.3 From Research To Operations

NASA Surya is a research model today, not an official forecaster. That said, the path is clear. The architecture supports fine tuning on downstream tasks, which means space weather centers can adapt it to their pipelines. You can imagine a service that blends NASA Surya predictions with real-time data assimilation and physics models, then produces an ensemble that reduces misses and false alarms. This is how serious forecasting gets built, layer by layer.

3. How NASA Surya Learns

NASA Surya is designed for scenes that evolve. The core is a transformer that uses two complementary ideas. First, spectral gating recalibrates features in the frequency domain, which helps separate meaningful structures from noise. Second, long-short attention captures both local detail and global context. Sunspots, loops, and active regions are local. The magnetic environment that frames them is global. The model keeps both views aligned over time.

Training followed a simple plan. Teach one-step prediction first, then roll forward for longer horizons. The loss emphasizes correct structure, not just pixel-wise closeness, so the model learns to preserve physical shape. The payoff shows up when NASA Surya renders two-hour visual forecasts that look like what the observatory actually records later. That is the kind of result you can vet with your own eyes before you trust a number.

4. What NASA Surya Can Do Today

NASA Surya isn’t a one-trick system. It can predict solar flares, segment active regions, estimate solar wind speed at L1 with lead time, and model extreme ultraviolet spectra. The table below summarizes reported benchmarks against strong baselines. Treat numbers as moving targets as the community retrains and extends the work.

4.1 Reported Performance At A Glance

Benchmarks are only part of the story. The practical win is that NASA Surya produces interpretable outputs, including images you can overlay with observations. That lets scientists judge failure modes, not just celebrate scores.

5. Getting Hands On With NASA Surya

NASA Surya is open, so you can run it yourself. Here’s a simple, reliable path.

5.1 Prerequisites

• Python 3.11 or newer.
• A CUDA capable GPU, recommended for speed.
• Disk space for pretrained weights and sample data.
• The uv package manager, recommended by the repository.

5.2 Install In Three Steps

1. Clone and enter the GitHub repo.
2. Create the environment. Use uv to sync dependencies, then activate the virtual environment.
3. Run the end-to-end test. The test downloads weights and data, runs a short forecast, and writes an image file named surya_model_validation.png. You’ll see a clean PASSED [100%] when everything works.

# Step 1. Clone and enter the repo
git clone https://github.com/NASA-IMPACT/Surya.git
cd Surya

# Step 2. Create the environment with uv, then activate it
curl -LsSf https://astral.sh/uv/install.sh | sh
# Reload your shell so "uv" is on PATH
source ~/.bashrc 2>/dev/null || source ~/.zshrc 2>/dev/null

# Sync deps and create .venv
uv sync
# Activate the virtual environment
source .venv/bin/activate

# Step 3. Run the end to end test
python -m pytest -s -o log_cli=true tests/test_surya.py
# This downloads weights and sample data, runs a short forecast,
# and writes ./surya_model_validation.png. Expect "PASSED [100%]".

# Step 1. Clone and enter the repo
git clone https://github.com/NASA-IMPACT/Surya.git
Set-Location Surya

# Step 2. Create the environment with uv, then activate it
irm https://astral.sh/uv/install.ps1 | iex
uv sync
.\.venv\Scripts\Activate.ps1

# Step 3. Run the end to end test
python -m pytest -s -o log_cli=true tests/test_surya.py
# This downloads weights and sample data, runs a short forecast,
# and writes .\surya_model_validation.png. Expect "PASSED [100%]".

5.3 Try A Downstream Task

NASA Surya ships with examples that fine tune the foundation on specific jobs. Start with flare forecasting. Download the prepared data, then run the training script with torchrun. The scripts use parameter-efficient fine tuning, so you adapt a 366M parameter model without rewriting your compute budget.

5.4 What To Expect

On a modern workstation GPU, verification completes in a few minutes. You’ll get console logs that confirm device detection, weight loading, and completion of a short inference roll. The validation image will show the model’s two-hour prediction next to the ground truth. If you’re building a pipeline, that image doubles as a quick visual regression test.

6. The Engineering Behind The Scenes

6.1 Representation Over Recipes

The big idea is to learn reusable solar representations, not hand craft features for a single product. NASA Surya treats solar imagery as a coupled field that evolves across wavelengths and time. That’s exactly the place where deep sequence models shine. You get a common backbone that supports many heads, each tuned to a mission task.

6.2 Physics Meets Data

The model isn’t a physics simulator, and it doesn’t need to be. It captures the statistical shape of solar dynamics learned from consistent observation. That lets it predict the near future with useful fidelity. Teams can fuse these outputs with physics based models for longer horizons or risk-aware ensembles. Data and physics are complements, not rivals.

6.3 Inspectability By Design

NASA Surya renders futures. That matters because inspection is part of trust. Operators want to see a loop form, watch an active region twist, and compare the model’s story with real frames. When predictions fail, you get a chance to learn why, then improve the pipeline or flag regimes where you shouldn’t act.

7. Open Source Science AI, At Full Speed

NASA Surya lives where it should, out in the open. Code on GitHub, weights and datasets on community hubs like Hugging Face, and documentation that invites contribution. This is open source science AI used as it should be used. Researchers can verify claims, add tasks, and publish better baselines. Students can learn real heliophysics by running hands-on experiments. Industry teams can test integration ideas for operations and share what works.

IBM’s role is clear in the engineering and tooling. The IBM foundation model experience shows up in training discipline, packaging, and the design choices that keep the system practical. NASA brings the mission focus and the dataset stewardship. The National Artificial Intelligence Research Resource pilot helps with compute and access. This is how you build public infrastructure for science.

8. Limits To Respect, Opportunities To Grab

This is early software, so treat it with discipline. NASA Surya isn’t a drop-in replacement for an operational forecaster. It shines as a fast learner and a strong source of features. It will still make confident mistakes in rare regimes. The responsible path is to use it in a layered architecture with guardrails, monitors, and clear human oversight. Build dashboards that track both skill and calibration. Keep drill logs for the moments when the Sun throws a curveball.

On the opportunity side, the door is wide open. You can pair NASA Surya with ground based magnetograms, with coronagraph streams, or with new instruments. You can blend it into routing tools for flights that cross the poles. You can use it to support satellite drag predictions during stormy weeks. Each use case strengthens the model and the community around it.

9. A Short Field Guide To Extensions

9.1 Solar Flare Operations

Fine tune NASA Surya on your labeled flare catalog and plug it into a decision engine that sets alert levels. Wrap visual outputs with simple explanations that point to the active region and the timeline.

9.2 Active Region Segmentation At Scale

Use the segmentation head to map polarity inversion lines and track their evolution. Feed those features into flare risk models or event catalogs. The output meshes with the way many forecasters already think.

9.3 Solar Wind With Lead Time

Train the solar wind head on L1 targets with four day lead time. Blend it with physics models to get a more stable forecast across quiet and active periods.

9.4 EUV Spectra Modeling For Atmosphere Teams

Model the EUV spectra across bands that matter for thermosphere heating. That supports teams estimating satellite drag during high activity windows.

10. Editorial Notes On Style And Results

NASA Surya doesn’t try to be clever for its own sake. The design is clean, the training story is direct, and the outputs are useful. The claim to pay attention to is simple. A foundation model for heliophysics trained on a long, stable record can predict short-term solar dynamics in a way that is both accurate and interpretable. The reported two hour visual forecasts look close to truth. The flare prediction improvements over older baselines are credible. As retraining continues, the numbers will change, and that’s healthy.

If you work in AI, this is a great example of domain-aware modeling that still embraces generality. If you work in heliophysics, this is a new instrument that learns from your instruments. If you build products in aerospace, energy, or telecom, this is a chance to fold space weather into your reliability models with less pain.

11. The Next Move

Spin up a clean environment, pull the repo, and run the verification test. Look at the validation image and decide where NASA Surya fits in your stack. If you handle satellites, try the active region and solar wind heads. If you’re in aviation, test flare prediction tied to route planning. If you’re a student, pick a downstream task and replicate a result with your own notes. Every run improves the community’s understanding.

NASA Surya started as a simple idea, learn the Sun from the Sun. It’s now a working system that helps predict solar flares, segments active regions, estimates solar wind, and models spectra. It’s also a signal that open source science AI is ready for serious, mission-aligned work. The Sun will keep giving us puzzles. Let’s build the tools that solve them.

Appendix: Where To Learn More, Without Getting Lost

• NASA Science
• sdoisgo.blogspot.com
• Hugging Face
• SDO mission page
• AI News hub