fastplotlib is a new GPU-accelerated fast and interactive scientific plotting library that leverages WGPU

Introduction

Scientific visualization is hard — but it doesn’t have to be.

What makes scientific visualization so challenging?

• High-dimensional, massive datasets — often spanning terabytes of information
• Computational bottlenecks — efficiently utilizing resources is non-trivial
• Limited interactive tools — most are designed for static plotting or do not scale to large data
• Real-time analysis barriers — visualization lags behind modern data generation speeds

Enter fastplotlib, which is built for high-performance, interactive scientific visualization.

fastplotlib is a very new open source Python-based GPU-accelerated scientific plotting library.

What can you do with fastplotlib?

• GPU-accelerated visualization (a modern integrated GPU is sufficient for most use cases)
• Rapid prototyping and algorithm design
• Exploration and fast rendering of large-scale data
• Creation of real-time acquisition systems for instruments

Note: this is by no means an exhaustive list, merely just the highlights :)

Agenda

In the remainder of this article, I am going to cover the following topics that highlight why fastplotlib is a powerful tool that can be used to drive scientific discovery through data visualization:

• Scientific visualization is more than just static plots
• API design matters
• Leveraging new hardware is critical

Scientific visualization is more than just static plots

While scientific visualization has traditionally relied on static plots, dynamic and interactive visualizations are the key to enhancing data exploration and analysis.

For example, consider the interactive plot depicted below.

This plot shows a simple interactive visualization of a covariance matrix in fastplotlib. As a formal definition, a covariance matrix gives a measure of how pairs of random variables change together.

In the left subplot, the covariance matrix for the Olivetti faces dataset is shown. In this case, each entry in the covariance matrix indicates how the intensity of any two pixels varies. In the right subplot is the reconstructed row image from the currently selected row of the covariance matrix. We can easily change what row of the covariance matrix we are looking at by simply moving the selector.

It is very clear visually that looking at the reconstructed image for each row of the covariance matrix is much more informative than having a static plot of just the covariance matrix by itself. By looking at the reconstructed row image, we can get a sense of how the pixel intensity is changing across faces in the dataset.

The purpose of displaying this plot is not to conduct a detailed analysis of the covariance matrix but to demonstrate how even a small degree of interactivity can enhance our understanding of the data, ultimately transforming the types of analysis we may pursue in the future.

The goal of fastplotlib is to expand the field of scientific visualization by providing a mechanism that allows the creation of high-level interactive plots, ultimately driving scientific discovery.

API design matters

The ecosystem for scientific visualization has come a long way since the early 2000s.

These days, there are many open-source Python visualization tools available. However, one limiting factor for scientists and other users is the high barrier to entry in learning how to use some of these libraries. Often, users are forced to learn complicated APIs that make it difficult to focus on their data or research questions.

In fastplotlib, we aim to provide fast interactive visualization via an easy-to-use and intuitive API.

1) Data interaction

The premise behind our API design is that you should never have to think of your data as anything but an array.

If the data in our visualization maintains an array-like structure we are familiar with, interacting with the visualization becomes much easier.

Consider the following example:

Suppose we want to plot a simple sine wave.

import fastplotlib as fpl
import numpy as np
# generate some data 
xs = np.linspace(-10, 10, 100)
ys = np.sin(xs)
data = np.dstack([xs, ys])[0]
# create a figure
figure = fpl.Figure(