Supercomputing Tech Demo Schedule

Meta Title: NASA Supercomputing 2026 Tech Demos: What the Schedule Preview Shows

Meta Description: NASA’s Supercomputing 2026 tech demo schedule preview highlights Fortran templates, software versioning, and the practical work behind scientific computing.

URL Slug: nasa-supercomputing-2026-tech-demo-schedule

Excerpt: NASA plans to showcase supercomputing software and scientific computing expertise at Supercomputing 2026. The available schedule preview points to sessions on type-safe Fortran templates and managing multiple software versions—topics that can shape the reliability and longevity of NASA’s research codes.

## NASA’s Supercomputing Tech Demo Schedule: What Is Known

NASA’s published item, titled “Supercomputing Tech Demo Schedule,” describes planned presentations by NASA experts in the exhibit hall at Supercomputing 2026, also known as SC26. The agency lists Booth #4038 as the location for its demonstrations.

The source material is a schedule preview rather than a detailed account of individual demonstrations. It identifies several Tuesday, November 17 sessions, including repeated presentations on “Type-safe Templates in Fortran 2028” by Tom Clune and a session titled “Mixing and Matching and Multiple Versions, Oh My!” by Brad Richardson.

These may sound like highly specialized programming topics. But they address a core challenge for NASA, national laboratories, universities, and weather centers: keeping complex scientific software reliable as computers, programming languages, and research requirements evolve.

The supplied source carries a publication date of November 6, 2026. Because event schedules can change, attendees should confirm the final times, speakers, and session descriptions through NASA and the official Supercomputing conference channels before making plans.

## The Schedule Preview at a Glance

The available NASA schedule excerpt lists the following Tuesday programming:

### Tuesday, November 17

– **10:00 AM:** “Type-safe Templates in Fortran 2028” — Tom Clune
– **10:30 AM:** “Type-safe Templates in Fortran 2028” — Tom Clune
– **11:00 AM:** “Type-safe Templates in Fortran 2028” — Tom Clune
– **1:00 PM:** “Mixing and Matching and Multiple Versions, Oh My!” — Brad Richardson
– **1:30 PM:** A further session in the same “Mixing and Matching” series is indicated in the supplied excerpt, but its complete listing is not available.

The repetition of the Fortran presentation may mean NASA intends to offer short, recurring demonstrations for visitors throughout the exhibit period. However, the excerpt does not explain whether the sessions are identical, progressive, or tailored to different audiences.

Likewise, the source does not provide abstracts, technical requirements, recorded presentations, or a complete multi-day agenda. That missing context matters, especially for visitors deciding whether the sessions are intended for software developers, computational scientists, students, or general conference attendees.

## Why NASA Is Discussing Fortran Templates

Fortran has been central to scientific and engineering computing for decades. It remains common in numerical weather prediction, climate models, fluid dynamics, astrophysics, aerospace simulations, and other fields where researchers must process large arrays of numbers efficiently.

NASA uses a broad ecosystem of scientific codes, including legacy programs that may have been refined for many years. The longevity of that code is a strength, but it also creates maintenance challenges. Researchers need ways to modernize software without compromising validated calculations or making code harder to understand.

The phrase **“type-safe templates”** suggests a discussion of programming-language features that could allow developers to write reusable code while retaining strong checks on the kinds of data being passed through it.

In software, a type system distinguishes, for example, an integer count from a floating-point measurement or a complex number. Type safety helps catch certain errors before a program runs. Templates, broadly speaking, let developers write a generalized algorithm that can work with different data types or numerical precisions.

For scientific software, that combination could be useful. A simulation team may want one implementation of an algorithm that can operate on single-precision or double-precision values, or on specialized numerical data structures, without maintaining many nearly identical copies of the same code.

It is important not to overstate what the session title confirms. “Fortran 2028” appears to refer to a possible future revision or direction for the language, rather than a guarantee that a particular feature is already part of a finalized standard. Language standards evolve through technical proposals, committee review, implementation work, and eventually compiler support.

A conference demonstration can therefore be valuable even before a feature is widely available. It gives the scientific-computing community a chance to examine potential tools, discuss design tradeoffs, and consider how future language changes might affect long-lived research codes.

## Why Software Versioning Is a Supercomputing Problem

The second named presentation, “Mixing and Matching and Multiple Versions, Oh My!,” points to another everyday reality of high-performance computing: large scientific workflows depend on many interconnected pieces of software.

A climate, Earth-observation, or engineering workflow might include:

– A simulation model
– Mathematical libraries
– Input and output tools
– Visualization software
– Compilers and build tools
– Job scheduling systems
– Python, Fortran, C, or C++ components
– Containers or package-management systems

Each dependency can have multiple versions. One research group may need a newer library release for improved performance, while another code component may rely on older behavior. A change that appears minor can affect reproducibility, numerical results, security updates, or compatibility with a new supercomputer architecture.

Managing these combinations is not merely an administrative task. Scientific results must be reproducible: other researchers should be able to understand how a computation was produced and, where possible, repeat it using comparable data and methods.

NASA’s work frequently involves long-running data records and models used by researchers, operational partners, and decision-makers. In that setting, dependable software environments are part of scientific infrastructure.

The session title alone does not identify the specific system or tool Brad Richardson will discuss. It could concern software packages, shared libraries, compiler versions, runtime environments, or deployment strategies. NASA’s complete agenda or session abstract would be needed to make that distinction.

## The Connection to Earth Science

The schedule appears on NASA’s Earth Science website, underscoring how computational technology supports observations of the planet.

Earth science is increasingly data-intensive. Satellites, aircraft instruments, ground stations, ocean sensors, and computer models generate large and varied datasets. Scientists use high-performance computing to process observations, run models, test hypotheses, and produce products that can be shared with the wider research community.

Examples include:

– Simulating atmospheric circulation and weather patterns
– Modeling oceans, ice sheets, and land surfaces
– Processing satellite observations into usable geophysical measurements
– Studying natural hazards and environmental change
– Comparing models with long-term observations

In all of these areas, better hardware alone is not enough. Scientists also need software that can scale across many processors, remain maintainable, use data efficiently, and produce results that can be checked.

That is why programming-language design, package compatibility, and development practices deserve attention alongside more visible supercomputing milestones such as processor speed or machine size.

## What Visitors Should Watch For

If NASA releases fuller session information, several details would help explain the practical importance of the demos.

First, attendees may want to know whether the Fortran session includes working code examples, compiler demonstrations, or discussion