SC25 Trame TutorialHPC-Enabled Web, Jupyter, and Desktop

Creation of Bespoke Scientific Visualization Applications for Simulation, Experiment, and AI Data

Python virtual environments

This tutorial can be done using local Python virtual environments for demonstrations and exercises. This track is prefered as it allow you to use your common dev tools and IDE when exploring trame.

Jupyter Lab

This tutorial can be done using a local setup of Jupyter Lab. A special track with dedicated notebook has beed created and available to ease demonstrations and exercises.

Schedule

Evolving Peacock into a more robust interface for MOOSE modeling and simulation

MOOSE facilitates the coupling of multiple physical phenomena, essential to reactor simulation. Nuclear reactors involve several physical phenomena provided by NEAMS codes that are coupled and correlated with each other through MOOSE. We will present the trame-based evolution of Peacock and how it is enabling a more capable interface for modeling and simulation.

Interactive Dashboards for the Beam, Plasma & Accelerator Simulation Toolkit (BLAST) with trame

The Beam, Plasma & Accelerator Simulation Toolkit (BLAST) is a comprehensive suite of simulation codes for modeling particle accelerators, beams, and plasmas. This talk presents our experience leveraging trame to develop interactive dashboards for the BLAST codes WarpX and ImpactX.

Skip the process bloat and run your CFD anywhere with M-Star & trame

M-Star CFD is a GPU-based fluid simulation tool designed to accelerate model development for industrial systems. When trame is coupled to M-Star using ArrowFlow, those capabilities become accessible to a larger set of users. In this talk we show how organizations are able to cut through common barriers to put the predictive abilities of CFD in more peoples’ hands.

Real-Time Simulation Control and Visualization through trame

We present a system for real-time control and visualization of scientific simulations using Trame, enabling seamless interaction between users and running simulations. Through an intuitive web interface, users can steer simulation parameters during execution and immediately observe the effects via in situ visualization. This bidirectional communication model supports dynamic exploration and lays the foundation for responsive, interactive digital twins. By integrating simulation control and visualization in a unified workflow, we enable faster insight generation and more adaptive scientific experimentation.

4D Genome Visualization: Prototype to Web Application with Paraview and trame

Complex datasets often require a mix of novel software development and visualization design -- in collaboration with domain scientists -- to achieve truly useful visualizations. Scientists and vis experts need to work with data and try things out in order to design effective tools. How can we make the most of the time we have with scientists to develop truly useful visualizations? In this talk, we will discuss an example of using ParaView and Trame to effectively and efficiently work with domain scientists to prototype visualizations for complex data artifacts, filter and fuse data for visualization, and develop a web-based end user application.

Natural Robustness Testing and Model Explainability for AI Test and Evaluation

AI is everywhere, but how much could we trust it? In this talk we'll go over the concerns of DoD and how Kitware is addressing some of those concerns with two Open Source projects. First we'll cover the Natural Robustness Toolkit (NRTK) and then the Explainable AI Toolkit (XAITK). Finally we'll explain how trame is helping those toolkits with its interactive data exploration approach.

Content description

In this hands-on tutorial, participants will learn to create bespoke scientific visualization applications using Trame, a powerful Python framework for building interactive, web-based visualization frontends. Trame simplifies web-based application development by managing UI layout, state, events, and widgets entirely in Python—abstracting away the need to write HTML, CSS, or JavaScript. Trame wraps popular visualization engines like VTK and ParaView, allowing users to rapidly develop rich applications that run seamlessly across web browsers, Jupyter notebooks, and desktop environments—ideal for HPC-enabled simulations, experimental workflows, and AI-driven data analysis. The tutorial will introduce how to design responsive and modern GUIs using Vuetify through Trame’s declarative Python syntax, enabling sophisticated layouts, widgets, and event handling. We will present how to integrate 3D visualization using VTK and ParaView, showcasing different rendering modalities for the interactive exploration of complex datasets. Together, we will explore integrating Markdown content and common Python plotting libraries—including Matplotlib, Altair, PyVista, and Plotly—into Trame applications to support a broad spectrum of scientific visualization needs. We will cover both intermediate and advanced topics, leveraging modern examples drawn from simulation, experimental science, and AI-driven analysis to ground the material in real-world workflows. By the end, participants will be equipped to build tailored visualization applications that bridge HPC backends with intuitive, interactive frontends, all from within the Python ecosystem.

Requirements

For this tutorial we are expecting to have the following software available on your computer.

git for downloading the hands-on material. (Home page)
uv for handling Python versions and virtual environments to ensure isolation. (Home page)
ParaView for running some visualization examples. (Download page)
IDE or Text editor for editing Python files. (i.e. VSCode)

Duration

The total content will be deliver over 6 hours in 30 minutes chunk with blocks of 1 hour and 30 minutes.

Getting hands-on material

bash

git clone https://github.com/Kitware/sc25-trame-tutorial.git
cd sc25-trame-tutorial

Tutorial goals

Introduce Trame as a modern, Pythonic solution for building interactive scientific visualization applications across web, desktop, and Jupyter environments.
Demonstrate integration of rich visualization backends (VTK, ParaView) with GUI elements and plotting libraries.
Provide hands-on experience designing custom apps that can handle data from simulations, experiments, and AI workflows—especially in HPC contexts.

For Beginning Attendees

Understand the basic architecture of a Trame application.
Learn how to launch a simple app in the browser or Jupyter using Python only.
Use basic widgets (buttons, sliders, layouts) to control visualization parameters.
Integrate interactive 3D visualizations using VTK or ParaView.
Understand Trame’s state management system and how to link UI controls with visualization logic.
Embed plotting libraries like Matplotlib, Altair, PyVista, and Plotly in multi-panel apps.

For Intermediate Attendees

Explore multiple rendering modalities and advanced 3D interaction patterns (e.g., linked views, LOD control, client/server rendering).
Customize Vuetify components and extend the UI with advanced interactions.
Learn to structure more complex applications with custom layouts and multiple views.

For Advanced Attendees

Integrate HPC or AI data pipelines and enable dynamic data loading or streaming.
Optimize performance for large datasets and explore strategies for scalability.
Deploy Trame applications to the desktop, Jupyter, and cloud.