Enjoy a gentle introduction to Python for folks who are completely new to it and may not have much experience programming. Learn how to write Python while practicing loops, if’s, functions, and usage of Python’s built-in features in a series of fun, interactive exercises inside Jupyter Notebooks. By the end you’ll be ready to write your own basic Python -- but most importantly, I want you to learn the form and vocabulary of Python so that you can understand Python documentation, interpret code written by others, and get the most out of other SciPy tutorials.
Installation Instructions: https://github.com/jiffyclub/scipy-2026-intro-to-python#setup-instructions
This tutorial is for anyone who works with data in Python notebooks. marimo is a reactive notebook that can serve as a personal data environment. Cells run in a deterministic order based on their dependencies, interactivity is built in, and notebooks are self-contained Python scripts you can share, version, and deploy. We start with a tour of marimo: its execution model, interactive elements, SQL, plotting, and sharing. From there, we get practical, composing off-the-shelf UI elements to build interactive tools for your data, then creating your own custom widgets with anywidget when you need something tailored to your workflow.
Installation Instructions: https://github.com/manzt/scipy-2026-anywidget
Through the construction of a Deep Research Agent, tutorial participants will learn the fundamental building blocks of LLM-driven applications. Starting with in-context learning and prompt design, we will progress through memory management, tool integration via the Model Context Protocol (MCP), and planning workflows. Participants will build a working agent that can query a Zotero citation library, synthesize literature summaries, and engage in multi-turn research conversations. We will also discuss failure modes, limitations, and the role of such agents in an age of coding assistants.
Installation Instructions: https://github.com/ericmjl/build-deep-research-agent/
GPU-powered math libraries are the core of accelerated scientific computing. The nvmath-python package aims to provide intuitive pythonic APIs giving users full access to all features offered by NVIDIA's libraries in a variety of execution spaces. It is your one-stop shop for Pythonic math libraries on the GPU.
Installation Instructions: We will provide Nvidia Brev cloud instances. Attendees will only need their laptops and an Internet connection.
Bridging the gap between new scientific findings and an accessible decision-support tool often requires researchers to either hire a web developer or self-navigate a likely unfamiliar and fragmented landscape of JavaScript frameworks, HTML templating, and CSS. Tethys Platform, a free and open source Python software package, helps bridge that gap by providing a Python-heavy development stack designed specifically for geoscientific and environmental web applications.
This tutorial introduces the latest evolution of Tethys Platform: Tethys Component Apps. By integrating ReactPy, Tethys Platform builds on the shoulders of giants to facilitate the development of rich, robust, and reactive user interfaces entirely in Python—eliminating the need for separate scripts and frontend languages. If you have enough Python prowess to write code for your scientific workflows, you can harness it to develop web applications that leverage and showcase these existing workflows.
In this hands-on session, participants will learn basic concepts of Reactive, Pythonic component web app development while building a basic, scientific app, step-by-step. These basic concepts include:
- Reusable Web Components and UI Design
- User Interactions and Event Handling
- Application State Management
- User Experience (UX)
- Integrating 3rd Party Web Component Libraries
Prerequisites
An intermediate knowledge of Python is recommended. Familiarity with basic web development concepts is helpful but not required.
Install and deploy a local Tethys Portal using Conda or Pip (see Tethys Quickstart). Time estimate: <10 minutes.
Clone and install the Component Playground application (GitHub clone link) into your local Tethys Portal (see Development Installation). Time estimate: <10 minutes.
Installation Instructions: https://gist.github.com/mwcraig/1baeeee30055e6deb8b5addc4846b702
With everything from microscopes to telescopes to satellites, scientists produce image data in countless formats, shapes, sizes, and dimensions. Python provides a rich ecosystem of libraries to make sense of them. napari is a Python library for multidimensional image visualization, but it does double duty as a standalone application that can be easily extended with GUI tools for analysis, visualization, and annotation. In this tutorial, we'll start with the basics of image visualization and analysis in napari, then show how to extend the napari user interface to make analysis workflows as easy as pushing a button, and finally show how to share these extensions as plugins, which can be easily installed by users and collaborators. If you work with images (particularly multidimensional images), and especially if you work with scientists who may not be comfortable with Python, this tutorial might be for you!
Installation Instructions: https://napari.org/workshops/extend/setup/
Large Language Models (LLMs) are transforming how we build applications, but the path from "cool demo" to "production-ready tool" is littered with challenges: hallucinations, verifiability, and more. This tutorial covers the basics of how to build AI apps that avoid these challenges, yet are still effective and simple to build.
We'll start with querychat, an open-source package that lets users explore data through natural language. querychat demonstrates a powerful pattern: rather than letting an LLM access raw data directly (where it can hallucinate calculations), it constrains the LLM to generate SQL queries that are displayed and executed by a proper database engine. This "tool-based" architecture ensures reliability through transparency and precision -- users see exactly what query was executed along with it's exact results.
From there, we'll peel back the layers to reveal chatlas, the foundation powering querychat. chatlas provides a unified, provider-agnostic interface to 19+ LLM providers (OpenAI, Anthropic, Google, local models via Ollama, and more). You'll learn how chatlas makes it trivial to:
- Build multi-turn conversations with history management
- Stream responses in real-time for responsive UIs
- Switch between providers with minimal code changes
- Define custom tools that let LLMs interact with external systems (safely)
- Extract structured data using Pydantic models
By the end of this tutorial, we'll have built two complete apps: a data exploration chatbot (using querychat with your own data) and a custom AI assistant with tools you define. You'll leave with practical patterns for constraining LLM behavior, validating outputs, and building apps that are genuinely useful, maintainable and production ready.
Installation Instructions: Go to dev.workshop.posit.team and sign in prior to the workshop. This will ensure you can access the provided computing environment for the tutorial. Once logged in, click "New Session", then "Launch". You may see a blank page for a minute before being directed to a hosted Positron session (https://positron.posit.co/). If you run into issues, or have any questions, please email carson@posit.co.
Scientific researchers need reproducible software environments for complex applications that can run across heterogeneous computing platforms. Modern open source tools, like Pixi, provide automatic reproducibility solutions for all dependencies while providing a high level interface well suited for researchers.
This tutorial will provide a practical introduction to using Pixi to easily create scientific and AI/ML environments that benefit from hardware acceleration, across multiple machines and platforms. The focus will be on CUDA applications, such as machine learning frameworks and use of CUDA Tile, as well as using pixi-build to construct bespoke CUDA enabled conda packages.
Installation Instructions: https://matthewfeickert-talks.github.io/reproducible-cuda-workflows-with-pixi-scipy-2026/setup/
This tutorial session is intended to give attendees a gentle introduction to applying causal thinking and inference using python. Causal data analysis is very common in many academic domains (e.g. in social psychology, epidemiology, macroeconomics, public policy research, sociology, and more) as well as in industry (all of the largest Silicon Valley tech companies employ teams of scientists who answer business questions purely with causal inference methods).
The tutorial will involve a combination of presentations with open Q&A and hands-on exercises contained in Marimo notebooks. This session will cover the difference between correlation and causation, the pitfalls of conducting an analysis using observational data, how causal inference can help get around these pitfalls, and examples of common, modern modeling approaches using the latest python causal inference frameworks (e.g. DoWhy). After the tutorial, the attendees should have a good foundational understanding of causality and the ability to confidently explore the topic on their own. Causal inference can be a very theory-heavy topic, making it impenetrable to novices. In this tutorial, we'll aim to take a more practical perspective on causal inference, while still occasionally touching on the theory.
Tutorial participants are not expected to be familiar with causal inference before attending, but we hope they have an earnest curiosity to learn about it! To get the most out of the session, the participants ought to have experience working with the common python data stack: matplotlib, numpy, pandas, and scikit-learn. Attendees should have some experience conducting classic machine learning modeling using the scikit-learn API, although having advanced machine learning expertise is absolutely not a prerequisite. A very basic understanding of statistics would be helpful (e.g. understanding what a mean is, what confidence intervals represent).
Materials and installation instructions can be found here: https://github.com/ronikobrosly/scipy_2026_causal_inference_tutorial
Installation Instructions: https://github.com/ikrommyd/2026-07-14-scipy2026-tutorial-thinking-in-arrays
Please do the setup before the tutorial.
Python has become the dominant language in scientific computing, even in domains that demand high performance. This is largely due to the power of array-oriented programming, which separates complex problems into two parts: lightweight bookkeeping and heavy numerical computation. The latter is handled efficiently by vectorized operations that rely on fast, precompiled libraries.
This tutorial introduces array-oriented programming as a distinct mindset that encourages new ways of structuring problems. Rather than focusing on any one library, we’ll cover general techniques that apply to any array library with a particular focus on NumPy and JAX. You'll work in groups on some short puzzles and three class projects: Conway's Game of Life using arrays just-in-time (JIT) compilation for the Mandelbrot set, and exploring data in ragged arrays. This tutorial focuses on the thought process: all of the problems are to be solved in an imperative way (for loops) and an array-oriented way.
Shiny is a framework for building web applications and data dashboards in Python.
In this workshop,
you will see how the basic building blocks of shiny can be extended to create
your own scalable production-ready python applications.
In particular, this workshop covers:
- Overview of the basic building blocks of a Shiny for Python application
- How to refactor applications into shiny modules
- How to write tests for your shiny application
- Deploy and share your application
At the end of this course you will be able to:
- Build a Shiny app in Python
- Refactor your reactive logic into Shiny Modules
- Identify when to write Shiny modules
- Write unit tests and end-to-end tests for your shiny application
- Deploy and share your application (for free!)
Installation Instructions: https://chendaniely.github.io/scipy-2026-shiny/setup.html
Have you ever been frustrated when an LLM generates outdated or deprecated code? It's more common than you'd think. LLMs are trained up to a certain point, but software keeps moving forward. Functions get deprecated, new versions drop, APIs change, old patterns get replaced, and your model has no idea any of it happened.
RAG, or Retrieval-Augmented Generation, is the fix. Instead of relying solely on what a model learned during training, RAG lets you supply it with current, curated information at the moment it generates a response.
In this 4-hour, hands-on workshop, you'll build a RAG-powered SciPy coding assistant from the ground up. Here's what that looks like in practice:
RAG Fundamentals: You'll start by getting familiar with the core ideas behind RAG: what embeddings are (numerical representations of text that capture meaning), how vector similarity works, and how ChromaDB (a lightweight vector database) stores and retrieves that information.
Building the Knowledge Base: From there, you'll build the SciPy knowledge base itself. That means scraping SciPy's documentation, chunking it into digestible pieces, and processing it in a way that's aware of code structure, not just plain text.
Wiring Up the Pipeline: Once the knowledge base is ready, you'll wire up the full pipeline: querying it intelligently, engineering prompts that produce reliable code, and integrating with both OpenAI and Ollama (a tool for running models locally) so you're not locked into one provider.
Evaluation and Deployment: Finally, you'll wrap everything up by evaluating your system using real retrieval and generation metrics, and deploying a Gradio web app, a simple tool for building interactive UIs in Python, so your assistant is actually usable by people who aren't staring at a Jupyter notebook.
By the end, you'll have a working SciPy assistant and, more importantly, a solid understanding of every moving part inside it.
Installation Instructions: https://github.com/cynthiiaa/scipy-RAG#quick-start
As GPU acceleration becomes essential for scaling Python workloads, many developers face new challenges: understanding installation, managing dependencies, and deploying GPU-enabled environments. Even experienced Python users can struggle to integrate GPUs effectively or troubleshoot performance issues.
This tutorial addresses those barriers by walking participants step-by-step through the process of getting started with GPUs. Using NVIDIA’s RAPIDS ecosystem and familiar python tools, we’ll demonstrate how to set up, monitor, optimize and debug GPU-powered workflows—turning what often feels like complex infrastructure work into an approachable, reproducible process.
Installation Instructions: https://developer.nvidia.com/nsight-systems/get-started
Through the use of NetworkX's API, tutorial participants will learn about the basics of graph theory and its use in applied network science. Starting with a computationally-oriented definition of a graph and its associated methods, we will progress through the following concepts: path and structure finding, visualization, and graph storage on disk. We will also offer tutorial participants the option of one advanced topic overview, including the use of graphs alongside LLMs for knowledge retrieval, scalable alternatives to NetworkX including cuGraph, and the use of linear algebraic translation of graph problems to speed up computations.
Installation Instructions: https://github.com/ericmjl/Network-Analysis-Made-Simple/
Xarray provides data structures for multi-dimensional labeled arrays and a toolkit for scalable data analysis on large, complex datasets. Many real-world datasets fit this structure. However, a common roadblock for users is knowing how to load the data in Xarray and then how to best use Xarray’s tools to represent the structure of the data. In this hands-on tutorial we will showcase how to work with Xarray, various ways to get real-world data into Xarray (with examples from geosciences and biology) and finally how to easily make complex selections on data using community developed custom indexes.
Installation Instructions: https://tutorial.xarray.dev/workshops/scipy2026/index.html
This tutorial will show you how to use the Pandas, Dask, or Xarray APIs you already know to interactively explore and visualize your data, even if the data is gigabyte or petabyte sized or is in non-columnar scientific formats such as multidimensional arrays, networks, or unstructured grids. As soon as you have something you like, you can then share a live app as HTML+WASM or backed by a live Python server, by simply replacing your expression arguments with widgets so that users can explore it on their own. These tools let you focus on your data rather than the API, and let you build linked, interactive drill-down exploratory apps without having to run a web-technology software development project, which you can then share without becoming an operations specialist.
Installation instructions: https://holoviz.org/tutorial/Setup.html
The quality of the retrieval component is what drives Retrieval-Augmented Generation (RAG) systems. Therefore, a well-structured, measurable, and robust retrieval pipeline is critical to building effective large language model (LLM) applications.
Working through guided code examples and hands-on experimentation, attendees will collectively develop, optimize, and enhance the performance of a complete RAG pipeline by improving retrieval in three stages: Pre-Retrieval, Mid-Retrieval, and Post-Retrieval. We will also cover structured and multimodal document parsing with Docling, systematic evaluation with RAGAS, and a capstone Agentic RAG demo using LangGraph. The toolkit integrates Qdrant for vector search and the LangChain ecosystem for orchestration and experimentation.
During the hands-on session, attendees will use Jupyter notebooks to learn about, experiment with, and benchmark techniques that produce significant improvements to retrieval quality using production-ready open-source libraries. At the end of the session, each participant will be equipped with a reusable “Retrieval Playground” framework that can be leveraged to design, evaluate, and continuously improve RAG systems across various application domains.
Installation Instructions: https://github.com/mahimaarora/retrieval-playground/tree/main/setup-guides
This tutorial demonstrates how to accelerate agent-based simulations using modern Python tools. Using Thomas Schelling's classic segregation model as a running example, participants will learn to transform readable but slow Python code into high-performance implementations using NumPy and JAX. The tutorial explores how mild individual preferences can lead to extreme aggregate outcomes through simulation, while teaching practical techniques for leveraging modern hardware (including GPUs) to make realistic large-scale simulations computationally feasible. Participants will gain hands-on experience with performance optimization strategies applicable to economic modeling, urban planning, epidemiology, and other domains requiring large-scale agent-based simulations.
Installation Instructions: https://github.com/QuantEcon/scipy_tutorial_2026
Remote Sensing has proved to be an important tool in monitoring our earth's ecosystem. Satellite imaging is a vital part of Remote Sensing. Predominantly, Satellite Imaging of the earth has been done in the optical domain and optical Images serve the majority of purpose for earth monitoring. But, these satellites do not have all-weather acquisition capability and this lacuna is filled by the satellite sensors working in the Microwave domain of the Electromagnetic spectrum. Synthetic Aperture Radar(SAR) is an Imaging Radar that acquires images of a particular area on Earth in the microwave region of electro-magnetic spectrum. This workshop deals with the processing of SAR Images and how these images can be beneficial in a variety of geographical applications.
Installation Instructions: Participants should use a computer or cloud compute with at least 16GB of memory. Downloads of approximately 1-2GB will be needed during the tutorial.
Join fellow SciPy attendees for a casual, self-organized dinner at The Market at Malcolm Yards (501 30th Ave SE), a lively food hall with tacos, Asian cuisine, pizza, vegan options, desserts, and beverages, including local craft beer and non-alcoholic options.
This is an informal, community-organized meetup. Attendees are responsible for purchasing their own food and drinks.
Schedule
- 6:30 PM: Walk departs from the Graduate Hotel (led by Ed Rogers)
- 6:45 PM: Passing the Days Hotel for anyone staying nearby
- 7:00 PM: Arrival at Malcolm Yards
Food Hall:
https://malcolmyards.market/food/
Directions:
https://maps.app.goo.gl/z33DMx8QJfkuDKKG6
Matplotlib Project Lead and Computational Scientist at Brookhaven National Laboratory
A session featuring updates and roadmaps from maintainers of core Scientific Python libraries and tools.
In 2004, Matthew Brett asked me a provocative question born of frustration with existing fMRI tools: "Why don't we rewrite them in Python?" That question led to a 2005 meeting that brought together a small group of core Scientific Python tool builders from astronomy, neuroscience, physics, and statistics, and then to a series of follow-up meetings alternating between Berkeley, Enthought's offices, and other locations. This talk traces how that ground-up, cross-disciplinary collaboration helped turn SciPy from a workshop curiosity into the backbone of today's ecosystem, and how the same people and patterns later shaped the Scientific Python project.
Are you a first time SciPy attendee? Confused about what the conference elements are or how to get the most out of your experience? Come join us for a casual chat, orientation, and suggestions for maximum fun and learning!
For scientists wanting to work with and analyse earth science data, the standard remains delivering tooling via python packages, and data via HPC or the cloud. For data siloed on an HPC system, this presents a barrier to findability and accessibility. However, with agentic AI now widely available, the cost of learning a new tech stack or toolchain to deliver this data has plummeted.
In this talk, I'll outline how we utilised agentic AI to translate an intake catalog into an interactive, single page web application, maximising data discoverability whilst leaning on our existing data infrastructure and established Python API's to constrain the scope, keep the wrapper thin, and the code from becoming spaghettified, unmaintainable AI slop.
Bioimaging generates massive datasets in fragmented, proprietary formats that are difficult to share and align with FAIR principles. ngff-zarr is a lightweight, open-source Python toolkit implementing the OME-Zarr specification -- the community-driven, cloud-native bioimaging standard. With minimal dependencies and a simple pipeline interface, ngff-zarr converts, validates, and generates multiscale representations of extremely large images out-of-core via Dask. Features include multiple downscaling methods, OME-Zarr Zip archives (.ozx), RFC-4 anatomical orientation, and High Content Screening support. This talk also covers ngff-zarr's Model Context Protocol (MCP) server, which enables AI agents to perform bioimaging tasks through natural language, and lessons learned from its deployment at EMBL.
If you messed around with Python's command line options or read the official documentation, you might wonder what the -Xgil option or the PYTHON_GIL environment variable did to your scripts, and whether setting either affects performance. The hubbub on popular wheels such as pyo3, python-zstandard, numpy, uv, cffi, and cython supporting the free-threaded interpreter is no passing fad either. For Pythonistas that don't read PEPs in their spare time or contribute to the cpython project itself, an adventure that delves into a less known, yet jaw-dropping aspect of Python awaits!
Python's Global Interpreter Lock, which determines which single thread can execute native Python code and call C API functions, simplifies writing multithreaded code. However, sticking with this execution model leaves out extra performance afforded by modern multicore CPUs with hyperthreading, as automatic locking and unlocking of the GIL does not scale well with thread counts, especially in performance-sensitive workloads.
The newfangled free-threaded interpreter promises salvation when running either pure Python code or with compiled extensions. General multithreading rules apply (prefer thread-local variables, using locks to prevent simultaneous access of shared data), but when dealing with projects containing compiled extensions that directly or indirectly interface with Python's C API, more porting rules also apply.
Key porting tips, including projects using the Limited API, include: port native code away from C API functions that avoid borrowed references because they aren't thread-safe; modify unit tests to catch concurrency bugs arising from assuming the presence of the GIL; and extend CI coverage of Python interpreters both for testing and to build free-threaded compatible wheels.
Outline:
- Introduction (2-3 min.)
- What is the -Xgil option?
- What is the GIL?
- What is the free-threaded interpreter? (6-8 min.)
- Global Interpreter Lock: downsides of automatic serialization of parallel workloads
- How to try out the free-threaded interpreter
- Increased parallelism with the no-GIL interpreter with multi-core CPUs
- Porting tips (15-18 min)
- Adding a trove classifier in pyproject.toml
- Marking your extension module as supporting no-GIL
- Limited API (and PEP 803)
- Bumping key dependencies, including FFI wheels
- Using locks, mutexes, and atomics in native code to prevent concurrency bugs
- Including pytest-run-parallel to catch threading bugs
- Closing Remarks (2 min.)
- Q&A (2 min.)
Automated data enrichment, filling missing fields in structured records from unstructured sources, is the canonical case for pointing an autonomous agent at a database and letting it fill every blank. In high-stakes data that instinct is dangerous. A confidently wrong value is worse than a blank, and retrieval-grounded extraction reduces but does not remove the tendency to assert what the source never stated. An LLM can extract these fields; this paper asks where agentic judgment earns its place and where it becomes a liability.
We study this on the Texas Justice Initiative's police shooting databases, where nearly two thousand records are missing the weapon, the subject's race, or the outcome, whose fields volunteers typically recover by hand, fifteen to thirty minutes each. Our LangGraph pipeline, deterministic in its control flow, searches, validates, extracts, and escalates hard cases to a human. It completes 92% of officer and 70% of civilian records and invents zero facts across twenty fabricated incidents. The recovery itself came from a deterministic prompt fix without any agent. An autonomous agent pointed at the same fabricated incidents, with more freedom, commits a wrong-article fabrication the pipeline escalates.
If the deterministic core does the recovering, the agentic layer earns its place by making those recovered values trustworthy. Agency lives only in this thin judgment layer above extraction, and its components act in one of two ways. One acts on the pipeline's control flow: a relevance judge reads the retrieved articles and, when none actually report this incident, routes the record to a human instead of completing it. The other two pass judgment on what extraction produced: one deletes a value the source never states, and the other explains to the reviewer why the sources disagree on a value. Extraction calls an LLM too, but because it only proposes values for these judges to rule on, we do not count it as agentic. Every judge had to clear a reward-hacking-resistant evaluation gate before it shipped. The main contribution of this paper is a discipline, an "earn-it" protocol, for drawing the line between what a high-stakes pipeline should settle deterministically and where it is worth granting agentic judgment.
The Ecosystem Services Market Consortium (ESMC) is expanding its agricultural sustainability programs to include biodiversity outcomes across the United States. To support this effort, we developed a Python-based Biodiversity Metric Module that estimates biodiversity gains associated with agricultural best management practices. The module integrates national land cover data, species occurrence records, protected lands datasets, and soil microbial biomass information within a unified geospatial workflow to generate standardized biodiversity unit estimates. This presentation outlines the ecological framework, computational architecture, and lessons learned while scaling biodiversity assessment across thousands of spatially explicit agricultural fields.
In the past year Xarray has seen increased usage across various sub-fields of biology, revealing interesting challenges. It can be difficult to determine the best way to represent a data structure (e.g. anndata, NGFF-Zarr) as an Xarray object. Furthermore, some use cases such as whole brain imaging require the use of lesser known Xarray features such as custom indexes.
In this talk I will showcase examples of how to encode common biological data structures as Xarray objects. Finally, I will demonstrate how the custom index infrastructure has expanded what types of data can be usefully encoded in Xarray.
Field inspections in agriculture and science face a common problem: hands are full, data needs structure, and decisions require both inspection history and domain expertise. I built HiveGuide, an open-source field inspection system with three main components: (1) voice transcription for hands-free data entry, (2) AI extraction to structured data and action items, and (3) an AI assistant that provides intelligent advice by routing between personal inspection history and authoritative domain literature. For the assistant, I tested 7 routing strategies on 500+ queries to solve a dual-source problem: when to query your data versus domain references. The LLM classifier approach balanced accuracy and speed without requiring training data. The architecture is transferable to any inspection domain where you need minimal device interaction and intelligent advising.
Upgrading your organization’s dependencies on open source libraries can be daunting. Major version releases promise bug fixes, new features, and security improvements, but these upgrades often require so much more work than just bumping a few numbers and letting your package manager sort out the rest.
From planning to deployment, this talk is a step-by-step guide to upgrading your dependencies on open source libraries. We will offer practical strategies for scoping, coordinating, debugging, testing, releasing, and communicating major version upgrades -- all with as little pain for developers and users as possible.
Whether you're maintaining internal extensions, forking core packages, or just trying to stay current, you'll learn real-world strategies to make major upgrades less painful, and maybe even routine.
UChicago's Data Science Institute (DSI) partners with 11th Hour Project to turn data insights into action. In this talk, I'll focus on our collaboration with Occidental Arts & Ecology Center (OAEC)'s Fuels to Flows program, which stabilizes upland waterways by adding brushwood that would otherwise fuel forest fires. Gullies are hidden by trees, so we used publicly available LiDAR to cleanly identify gullies by shape with a lightweight convolutional model. I'll show how Numba made it possible to convolve hundreds of gigabytes of images with unusually large kernels and how we delivered these map layers via static hosting using PMTiles, even with interactive features like computing elevation profiles along hand-drawn lines.
At CERN's Large Hadron Collider, we collide protons at near light-speed to discover new particles and understand fundamental physics. Python is becoming the primary language for analyzing this data, marking a significant evolution from the Fortran and C++ workflows of previous decades.
This talk explores the modern Python-based analysis pipeline of High-Energy Physics (HEP) and the technical challenges it addresses. We'll present how we handle nested, jagged data structures and work with data at the petabyte scale using the community-driven Scikit-HEP ecosystem of specialized tools for efficient and high-performance data analysis.
We'll show how we're building a Python stack that integrates with distributed computing frameworks and leverages GPU acceleration. Beyond domain-specific analysis tools, HEP's transition to Python has driven improvements to the broader Python packaging ecosystem, including contributions to cibuildwheel, the development of scikit-build-core, and advances in pybind11, benefiting anyone building Python packages with compiled extensions.
Modeling and simulation enable iterative hypothesis testing and encoding subject matter expertise into reusable tools. While the Python community has a variety of libraries for modeling, few exist for system dynamics, a paradigm for top-down analysis of material and information flows over time. Reno is an open-source package combining creation, visualization, and analysis of system dynamics models with techniques for Bayesian inference through integration with PyMC, supporting probability distributions in system variables and MCMC sampling to produce posterior distributions based on observed values. This approach enables simulation and refinement of time series models where variables, policies, or knowledge are uncertain, and data/observations are sparse.
As funding levels have fallen in both the public sector and startup investing, many in the SciPy community are facing uncertain career futures or even job loss. Others may simply dream of being their own boss. This session will guide participants through a personalized analysis of the feasibility of securing paid work outside of formal employment, including solo consulting, building a product or service business with a team, or joining an existing tech startup. The session will also touch on tips for starting with limited funding, reducing unnecessary risk, leveraging open-source community resources, and pursuing next steps.
Geospatial analysis relies on raster data — n-dimensional arrays where each cell holds a spatial measurement. The scale of modern remote sensing data makes CPU-based workflows impractical, but raster operations are naturally parallelizable and well suited for GPU acceleration. This talk walks through a GPU-accelerated end-to-end workflow to classify satellite imagery into land cover types, covering data access via STAC, preprocessing (cloud masking, compositing, spectral index computation), training a Random Forest classifier on millions of pixels, and running inference on unseen tiles. The pipeline uses familiar APIs from Xarray, Dask, pandas, and scikit-learn, accelerated with RAPIDS. No prior geospatial or GPU experience is required.
Quantum computers promise to tackle strongly correlated molecular systems that defeat classical electronic-structure methods, but realizing quantum utility depends on every stage of the pipeline, not just the quantum algorithm. QDK/Chemistry, an open-source package in the Microsoft Quantum Development Kit, treats this entire pipeline as a single, modular Python framework. Immutable data classes and stateless algorithms with fixed interfaces let researchers swap backends without changing application code. This talk introduces QDK/Chemistry's composable architecture, shows how classical and quantum stages interoperate to minimize quantum resources, and offers design patterns applicable beyond quantum computing.
AI tooling is moving fast, but many Python developers are unsure where to start or how today’s AI patterns fit into systems they already know how to build. This talk is a practical, hands-on overview of modern AI development patterns in Python, focused on what you need to know to go from zero to hero.
We’ll walk through a real-world coding example broken into parts that illustrate the core building blocks of modern AI applications, and explain when each pattern makes sense. This example is designed in a way that doesn’t require any prior machine learning experience, and attendees will leave with an understanding of how AI systems work, what problems they’re good at solving, and how to maintain and observe what has been built.
Topics we’ll cover:
The modern AI stack in Python: LLM APIs, embeddings, tools, and agents
Common Python AI patterns: prompts, function calling, RAG, and simple agents
When to use a script vs an agent vs a service (and when not to)
How to get something working quickly without sacrificing reliability or safety
Practical guardrails: handling errors, controlling outputs, and protecting data
How to generally stand up common AI workflows, such as LLM-powered scripts to lightweight AI agents / MCP-style services.
Attendees will leave with a clear map of the AI landscape, working Python patterns they can reuse immediately, and the confidence to start building AI features without needing a machine learning background.
Your GPU is fast, so why does your Python code still feel slow? This talk shows a practical, Python-first profiling workflow with Nsight Systems, Nsight Compute, and NVTX for CuPy, Numba, PyTorch, JAX, and CUDA extensions. We will use timelines to find launch overhead, hidden synchronizations, and host-device copies, then drill into kernel bottlenecks like memory throughput and occupancy. You will leave with a repeatable loop for turning profiles into measurable speedups.
The advent of multimodal large language models (mLLMs) provides new opportunities for automated data exploration tasks on multi-petabyte atmospheric data sets. In this presentation, we present Nepho, a Python package for parallel mLLM prompting on collections of atmospheric quicklook data plots. We then evaluate the accuracy of several mLLMs in answering questions about Atmospheric Radiation Measurement (ARM) atmospheric datasets. We demonstrate that the GPT 4/5 and llama3-vision models were the most accurate models for quicklook plot exploration and recommend prompt engineering and retrieval-augmented generation for such data exploration workflows.
Many scientific workflows rely on derivatives of complex models: Fisher forecasts, sensitivity analysis, gradient-based inference, and emulator construction. In practice, these derivatives are often difficult to compute reliably and integrate into end-to-end inference pipelines.
DerivKit is an open-source Python toolkit that provides a unified framework for derivative-based scientific inference. It supports multiple derivative backends and connects model evaluation directly to downstream inference tools, including Fisher analyses and higher-order likelihood approximations. The framework also provides diagnostics and visualization tools for exploring parameter sensitivities and degeneracies.
Originally developed for cosmological forecasting pipelines, DerivKit is designed to be domain-agnostic and easily integrated into scientific Python workflows.
Scientific breakthroughs don’t happen in plain text, they live inside multi-column research papers, dense data tables, and intricate simulation diagrams. Yet the moment standard AI and Retrieval-Augmented Generation (RAG) pipelines encounter these layouts, they fail. Tables are flattened into meaningless strings. Figures are ignored. The structural signals that drive scientific reasoning disappear.
In this talk, we show how to rescue scientific knowledge from the “text-flattening” trap using Docling, an open-source document understanding library designed to preserve layout, hierarchy, and element boundaries. Instead of reducing everything to text, we treat tables, figures, and sections as first-class data structures. Attendees will experience a live demo of a realistic scientific R&D workflow: uploading multiple dense technical PDFs, executing cross-document natural language queries, and successfully retrieving synthesized insights from text, structured tables, and scientific images
This talk showcases a complete Python-based data pipeline for capturing and analyzing test data from electric motors powering BETA Technologies' fully electric CTOL (Conventional Takeoff and Landing) and VTOL (Vertical Takeoff and Landing) aircraft. We demonstrate how Python's open-source ecosystem enables seamless integration from edge to analytics: custom loggers decode machine data; a home-built data service batches and stores raw data in Apache Iceberg on AWS; dbt defines transformations that load into Redshift for analytics; Trino supports querying and joining to data from other sources; and Grafana serves visualizations, all provisioned via AWS CDK in Python. By leveraging modern data infrastructure and cloud solutions, we built an accessible, maintainable solution that handles terabyte-scale test data.
Adapt v0.1 is a real-time, reproducible data-analysis framework developed to support adaptive radar scanning within the U.S. Department of Energy Atmospheric Radiation Measurement (ARM) facility. It implements a declarative, store-driven architecture that separates acquisition, processing, and visualization into independent, thread-safe components. A continuous ingestion worker registers incoming radar data, while processing workers poll a central DataStore for newly available items and execute configured analysis chains. Visualization and external systems interact only with completed outputs, preventing interference with internal logic. The framework is built on the Scientific Python ecosystem, including Py-ART, Xarray, Scikit-learn, OpenCV, and SciPy, and is designed for maintainability and extensibility through well-defined input–output protocols.
Adaptive radar scanning enables real-time response to evolving convective storms, overcoming limitations of fixed, omnidirectional volume scans that often miss rapid microphysical transitions. Because radar beam physics constrains full-volume update rates, dynamically focusing on sectors of interest can significantly improve temporal resolution. Achieving this requires low-latency analysis, forecasting, and decision support integrated directly into operational workflows. While legacy systems such as TITAN demonstrated real-time storm tracking decades ago, most modern Python-based radar and tracking tools were designed for offline analysis. Campaign-driven ARM operations require continuous ingestion, event-driven execution, streaming outputs, flexible configuration, and robust integration with operational infrastructure. Adapt addresses these needs through a lightweight, modular design that cleanly separates orchestration, scientific logic, and downstream consumers.
The architecture consists of three loosely coupled layers. The scientific layer contains deterministic modules for detection, analysis, projection, and tracking that operate on structured inputs and produce explicit outputs. The orchestration layer manages item lifecycles, scheduling, and metadata state transitions including creation, queuing, processing, completion, or failure, enabling recoverability and preventing race conditions. The data access layer provides a client abstraction over the repository so downstream systems query structured metadata rather than raw files. Configuration files and CLI arguments define algorithm selection, runtime parameters, radar sources, and product definitions, supporting campaign-specific objectives.
To prevent silent numerical corruption, Adapt enforces algorithm contracts that validate outputs immediately after execution. Segmentation products are checked for dimensional consistency, contiguous labeling, and mask integrity; projection products are verified for spatial alignment, finite motion vectors, and forecast horizon consistency; analytical outputs undergo schema and metadata validation. Violations halt processing for that item and record diagnostic state in the catalog, ensuring fail-fast behavior and reproducible debugging.
The processing pipeline operates as an external script transitioning toward modular CLI tools. A downloader thread monitors configured sources and constructs items containing scan metadata, input paths, and expected outputs. Processor threads consume queued items, resolve dependencies through the catalog, execute scientific modules, validate outputs, write results atomically, and update state. Threads communicate exclusively through queues without shared mutable state, and algorithm modules remain stateless. The orchestrator supervises queue depth and dependency conditions without directly controlling thread execution.
Multidimensional grids are stored in NetCDF, while tabular analysis and tracking outputs use Parquet for efficient columnar access. Partitioned directory structures enable scalable time-range queries. A metadata catalog records radar inventories, processing runs, product definitions, and lineage relationships. A data client supports batch queries and streaming mode, polling for newly completed products so dashboards can visualize segmentation masks, projected motion, and lifecycle metrics without disrupting active processing. Each execution is registered as a uniquely identified run storing configuration, radar selection, and product relationships, enabling deterministic replay of historical datasets using the same logic as real-time operation.
Xarray provides labeled multidimensional data structures that preserve spatial coordinates and metadata, preventing index misalignment common in raw array workflows. Pydantic enforces strict configuration schemas and validates runtime parameters before execution. Dense motion fields are estimated using OpenCV’s Farnebäck optical flow on consecutive reflectivity frames, and cell geometries are derived using SciPy spatial triangulation methods. Py-ART provides Level-II decoding, coordinate transforms, and radar-specific processing foundations.
Adapt remains in an alpha stage. Key development priorities include stronger dataset versioning and provenance tracking within the repository layer, improved support for concurrent reads during active writes, exploration of structured streaming and event-driven orchestration models, and development of interactive dashboards for operational visualization. Future work will also address containerized and distributed deployment for cloud-native scalability and object-storage–first architectures. The modular separation between orchestration, scientific computation, and data APIs allows independent evolution of components and invites community contributions in data management, streaming frameworks, visualization systems, distributed execution, and reproducibility practices.
In summary, Adapt provides a modular, real-time architecture for adaptive radar scanning that enforces deterministic state management, contract-based validation, and repository abstraction. By eliminating thread entanglement and clearly separating system layers, it supports both historical reprocessing and operational guidance for live adaptive radar campaigns.
Genomic workflows remain tightly coupled to specialized file formats, forcing researchers to build brittle pipelines of format-specific CLI tools. We present projects that help shift this emphasis away from file parsing and towards declarative querying. Oxbow is a library that projects common genomic formats into Apache Arrow, enabling zero-copy integration with data frame libraries and analytics engines. GIQL (Genomic Interval Query Language) is an extended SQL dialect supporting genomic interval operations and semantics that transpiles to standard SQL, making genomic queries composable, readable, and backend-agnostic. Together, this architecture also facilitates the integration of genomic data into data warehouse and lakehouse platforms as well as agentic MCP workflows.
Optical character recognition (OCR) has been a long standing method of extracting text data from images. Traditional OCR models rely on pattern recognition and feature extraction using computer vision techniques and specialized Python libraries. Recently, large language models (LLMs) and generic AI assistants have provided an alternative method of text extraction. This talk explores the efficacy of using LLMs and VLMs for information extraction in production data pipelines and a data-driven approach for evaluating them against traditional OCR methods in terms of accuracy, reliability, latency, and cost.
Awkward Array is a Python library widely used in high-energy physics for representing and manipulating nested, variable-length data. As analysis workloads increasingly rely on GPU acceleration, there is a need for solutions that deliver high performance while remaining accessible to Python developers. In this joint talk between the Awkward and the NVIDIA teams, we present recent developments in GPU execution for Awkward Array using the new native Python CUDA support for CCCL called cuda.compute. This novel Python interface for CCCL that enables users to achieve state-of-the-art GPU performance without dropping down to C++ when building new GPU algorithms.
Our approach fuses sequences of Awkward operations into a minimal set of CUDA kernels, reducing kernel launch overhead and improving memory efficiency. Lazy execution allows entire expression graphs to be optimized before kernel generation, which benefits workflows involving jagged arrays, combinatorial operations, and reductions. In addition, the design enables user-defined Python code to be incorporated into GPU execution paths with minimal boilerplate, lowering the barrier for extending Awkward with custom GPU-accelerated logic.
cuda.compute is a new component in the CUDA Python ecosystem that provides native access to optimized algorithms, such as transforms, reductions, and scans. It also provides a collection of iterators that defer execution of operations and enable fusing multiple operations. We demonstrate performance improvements using this approach over an eager GPU execution strategy for representative analysis patterns and show how it integrates into the existing Python workflows. These developments provide a practical, user-friendly path toward high-performance GPU-accelerated data analysis in Python.
We thank NVIDIA for support and collaboration in developing the CUDA kernels and providing guidance on GPU optimization strategies. Their contributions are gratefully acknowledged.
Artificial Intelligence (AI) is reshaping meteorological science across two distinct frontiers. On one end, foundation-scale generative models, large-scale distributed training, and massive ensembles push the limits of high-performance computing and big-data orchestration. On the other, a "democratized edge" is emerging, where lightweight, heterogeneous inference workflows broaden access for experimentation. This dual expansion introduces a new class of software challenges spanning distributed training, ensemble-scale orchestration, and efficient, flexible inference pipelines.
This talk will introduce Earth2Studio and PhysicsNeMo from NVIDIA, two software packages designed to enable and scale AI weather forecasting. By exploring their architectures, we will discuss the broader development journey of building AI-driven meteorological tools and share key lessons learned in managing the intersection of high-performance computing, data science and operational reliability.
Engineering enzymes with improved catalytic activity remains a central challenge in biotechnology. In this research, we focus on engineering PETase, a plastic-degrading enzyme, as a testbed for developing a simulation-informed machine learning workflow. We present a Python framework that integrates molecular simulations, docking, and structural analysis with modern machine learning methods to predict enzyme activity from sequence and structure. By combining simulation-derived descriptors—including active-site geometry, electrostatics, stability metrics, dynamics, and docking scores—with sequence embeddings, we generate interpretable predictions that guide rational mutation strategies. While developed for PETase engineering, the workflow is extensible to broader de novo enzyme design efforts.
Lightning talks are 5-minute talks on any topic of interest for the SciPy community. We encourage spontaneous and prepared talks from everyone, but we can’t guarantee spots. Sign ups are at the NumFOCUS booth during the conference.
The Poster session will be in University Hall from 6:00-7:00pm. Meet with the poster authors to ask questions and learn about the posters that will be on display throughout the main conference.
The Virtual Poster session will be hosted on Gather from 6:00-7:00pm. Gather is a browser-based virtual conference platform that allows participants to move around a digital conference space using customizable avatars. As attendees walk through the poster hall, they can view poster thumbnails, open full-size posters, and start video or audio conversations with presenters nearby. No software installation is required; Gather runs directly in your web browser.
Research Director at the Metagovernance Project and founder of The Calm Tech Institute
A session featuring updates and roadmaps from maintainers of core Scientific Python libraries and tools.
Did you know that waffles were invented in the 14th century? Is Acetaminophen gluten free? If you said "yes" to both questions, you must have seen Damon McDougall's legendary SciPy 2014 lightning talk.
Let's distill the lore of lightning talks and touch on SciPy culture over the years and "make sure we get all the history" (or a yeast squares sparse low rank approximation of it)
Gather 'round, slithering scientists, and ye shall hear
a beer-ful of stories, of yesteryear
The Spirit of SciPy is the Track
MC Pi (that's me), has got your back
Been coming to the conference since 2009
Sharing memories and photos, which we'll all combine
some will be profound, others asinine
Honey, do you mead more proof?
How do we build competent data analysis agents? Data analysis requires a willingness to pause, question conclusions, and dig into subtleties. Frontier LLMs, however, are optimized to push tasks toward completion, not to slow down when something seems off. This tendency works well for coding agents, where success is often verifiable. But for data analysis, verification is more complicated, and autonomous work by the agent can be at odds with the spirit of the discipline. Drawing on our experience building data analysis agents, we'll share evaluations that expose where LLM-driven analysis goes wrong and design patterns that keep analyses correct, transparent, and reproducible.
In Fall 2025, the UConn School of Mechanical, Aerospace, and Manufacturing Engineering launched Open Source Experiences, an elective course developed in partnership with six NumFOCUS-supported projects (napari, BiocPy, Blosc, MNE-Python, mlpack, JuliaHub). The course embedded students directly into active open source communities, where they contributed to the codebases, collaborated with project maintainers, and learned about community-driven open source software development. In this talk, we will share the lessons learned from piloting this collaboration model, and how these experiences benefit students, open source and open science communities, and educators alike. Attendees will take away actionable insights for integrating open source contributions into their own classrooms and programs.
After 3 years, Pixi is widely adopted in the scientific Python ecosystem. At SciPy 2026, we want to show why.
Scientific Python has specific challenges that Pixi can solve well; a lot of our beloved packages contain C, C++, Rust, CUDA or even Fortran code. With Pixi, a single tool can install the compilers, different Python versions and other build tools in one go, thanks to piggy backing on the years of development that the Conda ecosystem has seen.
Thanks to Pixi’s task system and native multi-platform capabilities, the contributor experience is also enhanced. Daunting tasks like running CMake, installing the correct Rust version or C++ compilers are all hidden away behind a magical: pixi run foobar.
Are you interested to see how you could improve your own workflow and learn from what these big open-source projects are doing? Then you should join this talk! You'll be amazed by what is possible these days.
Scientists apply rigorous methods to their research, but rarely to the AI tools they use to write code. We tested different LLM models in combination with domain-specific tools (including MCP servers and skills) to find the optimal combination for writing complex domain-specific code. We created a quantitative proficiency test for Starsim, a disease modeling framework, and evaluated different combinations of models and tools. While Claude Opus outperformed other models, access to tools improved performance more than choosing the best model. Thus, to improve LLM performance on domain-specific problems, we recommend developing a set of tools with the help of quantitative evaluation.
Introducing novel software tools into the classroom is increasingly challenging. Fortunately, the richness of the modern web platform, and the proliferation of free static web hosting, provides a low friction way to introduce powerful software into the classroom. Coupled with the maturity of the Pyodide project, the possibilities of introducing scientific Python powered web-apps into classroom are limitless. This presentation demonstrates these possibilities through a case study of the open-source EngineeringPaper.xyz project that gives students instant access to the SymPy library. The unique interactive capabilities enabled by the web platform, such as math expression editing, will also be discussed.
Instro is an open-source Python library that puts one typed API in front of power supplies, DAQs, multimeters, oscilloscopes, and more. Write your test once, swap the driver, and your code stays put. We drive a power supply live using the built-in simulator, no hardware required, and show how to add your own.
Imbalanced datasets are common across science and industry: most screened molecules are inactive and most batted balls in baseball result in outs. One standard practice is to downsample the majority class or avoid collecting more of it. But majority-class examples are not interchangeable. Some are closely related to other examples, while others are distinct from any other example in the dataset. Others define the boundary between success and failure.
This talk asks two practical questions:
- How much majority-class data is actually necessary for a performative machine learning model?
- If we cannot collect all of it, which majority-class examples should we collect?
Using three wildly different datasets—antibacterial molecular screening, sandwich taste ratings, and Major League Baseball at-bat outcomes—I compare random downsampling to strategies that retain harder or more diverse majority-class examples, and evaluate the impact on generalization and performance for real-world machine learning models.
Few of us come to scientific computing with an understanding of how to write a system kernel or build a transistor. But we often downplay the benefits of going just one or two layers of abstraction below our comfort zone, strengthening our foundations and expanding our options.
This talk explores the meaning, utility, and optimization of vectorized array operations, fundamental to NumPy, from Python bytecode down to x86 assembly. We'll build a physical intuition for how array operations work, when they turn out to be less performant than we might expect, and how to find the right balance between effort and performance for your needs.
When early programmers needed to share code on punch cards and magnetic tape in the 1970s, they needed to explain how to use it, warn about bugs, and provide context. The code on its own wasn't enough, so the README file was born. But READMEs have never been entirely utilitarian forms of documentation. Instead they became (and remain) very human. A 1974 README ends with "Good luck!", and in 1978, The Jargon File connected the name itself to Alice in Wonderland, suggesting that "Read Me" should stand beside "Eat Me" and "Drink Me" in a surreal, hidden world.
This talk reveals how READMEs have always been where developers get to be human. Be it an exasperated warning from the 1970s, a 2009 README that became a complete fairy tale, or today's projects built solely to help developers add jokes to their docs, the pattern holds across five decades: READMEs are where we connect, welcome, and guide each other.
You'll leave with practical principles for writing READMEs that invite contribution and build community, grounded in this history. If you want contributors to your open source project, your README is likely their first impression and invitation. Make it count.
Deploying deep learning models for time-series forecasting at retail scale presents a fundamental tension between prediction accuracy and computational cost. This talk presents a Python-based framework combining structured pruning, quantization-aware training, and knowledge distillation to compress LSTM networks for demand forecasting. Using NumPy, TensorFlow/Keras, and scikit-learn, we achieved 47% accuracy improvement over baseline models while reducing model size by 73% and inference costs by 92%. We discuss practical implementation patterns, reproducibility considerations, and how these compression techniques generalize beyond retail to any domain requiring efficient sequential prediction at scale.
JupyterLite takes the simplicity of the Jupyter notebook interface and hosts it entirely in the browser, eliminating the need to setup a JupyterHub, making the Jupyter notebook environment much more accessible to users. In this talk we'll explore how our team harnessed JupyterLite and web components to make the distance between browsing for data and coding against that data 10 seconds and a new tab.
Open source maintainers are the lifeblood of the cloud-native ecosystem, balancing the rapid pace of technical innovation with the crucial need for project stability and sustainable community growth. Having served in leadership roles for foundational projects like XGBoost, KServe, Kubeflow, Argo, and the Kubernetes, this session moves beyond technical deep-dives to share the hard-won, non-obvious lessons of maintaining and scaling a successful open source project.
The Atmospheric Radiation Measurement (ARM) User Facility Data Center (ADC) capable of supporting scalable, secure, and reproducible engagement with atmospheric research data is evolving towards AI-ready ecosystem. We will discuss architectural designs utilized in production scientific data setting including open-source technologies to further multi-agent coordination, agentic retrieval-augmented generation (A-RAG), shared contextual memory via vector stores, and model-agnostic inference orchestration within Kubernetes infrastructure. We will go over ARM's foundational stack designed to support agentic AI workflows for data discovery, metadata research, reasoning, and user engagement. Additionally, we will go over architectural decisions, trade-offs, and security measures pertinent to research computing environments with some demonstrations.
dagster-slurm is an open-source Python integration that allows data scientists and research software engineers to run Dagster pipeline assets on both a laptop and Slurm-managed HPC supercomputers without making any code changes. It automatically handles SSH transport, environment packaging via pixi-pack, and Slurm job submission, while streaming logs and scheduler metrics back to the Dagster UI in real time. The talk covers the full workflow, from local development to staging and production deployment on a real HPC cluster, using a live demo with a self-contained Docker Compose environment. It has been validated on VSC-5 in Austria and CINECA Leonardo in Italy.
The tidyverse is a collection of R packages designed to facilitate data science. My team and I have been working on it for nearly 20 years, and in this talk, I’ll share some of what we’ve learned about software development and open source community building in that time.
It’s very clear that AI is having a profound impact on how we develop software and do data science, so I’ll also offer a look into the (near) future, discussing how we’re updating our thinking about how people will do data science, and speculating on what work is likely to have the biggest impact.
Lightning talks are 5-minute talks on any topic of interest for the SciPy community. We encourage spontaneous and prepared talks from everyone, but we can’t guarantee spots. Sign ups are at the NumFOCUS booth during the conference.
"The Scientific Python project aims to support maintainers and grow the maintainer community.
We do so via, e.g., the Scientific Python Ecosystem Coordination process (https://scientific-python.org/specs/), by building tools (https://tools.scientific-python.org/: spin, lazy-loader, web theme, etc.), and by hosting annual developer summits. When an impactful opportunity presents itself, we take on bespoke technical initiatives such as the SciPy Sparse Array API refactor, or maintaining the myst documentation engine.
This Birds of a Feather session will bring together developers, users, researchers, and educators interested in GPU-accelerated Python. The discussion will explore the current state of the ecosystem, new library developments, and strategies for making GPU acceleration more accessible to a broader scientific audience. Topics may include performance optimization, debugging and profiling, education and training, and opportunities for collaboration across projects and communities.
Open source software has fueled every major scientific discovery of the last two decades. Yet as scientific practice races toward agentic workflows, no-code interfaces, and AI-driven hypothesis testing, the open source infrastructure (and the maintainer communities who keep it alive) remain systemically underfunded and not yet designed for AI-native use.
The scientific Python community, like the rest of the world, faces a set of interlocking crises. Longstanding questions over how to sustainably develop, fund and maintain open-source scientific software, open data, reproducible research and collaborative training are being magnified by a variety of forces from the AI boom, to government disinvestment, to economic disruption. Combining a short panel with audience discussion and Q&A, this virtual BoF will reflect on these challenges and crowdsource ideas for how the SciPy community (including future conferences) can serve as a vehicle for bolstering scientific open ecosystems.
This is a virtual Birds of a Feather section. It will take place on the virtual platform for the conference, Airmeet. All attendees will have access to Airmeet. NOTE: This session will observe Chatham House rules.
Hybrid committee co-chairs Puneet Kollipara and David Nicholson will host and moderate this panel discussion.
Supply chain attacks on Python, including recent compromises of popular packages and CI workflows, have exposed structural weaknesses in the scientific Python ecosystem. This BoF will bring together library maintainers, downstream users, and security practitioners to discuss practical strategies for securing scientific Python stacks, from core packages (NumPy/SciPy) to domain libraries and analysis workflows. We will share current efforts (e.g., SPEC 8, Trusted Publishing, SBOM generation, GitHub Actions hardening), identify pain points and gaps, and brainstorm actionable steps the community can take over the next year to make scientific Python releases more trustworthy by default. Join us to share your experiences, challenges, and ideas on fortifying our open-source projects against potential threats and ensuring the integrity of scientific research.
Generative AI seems like it’s everywhere and attendees of this very conference have built the technical foundations that have enabled its explosive growth. However, unlike the scientific computing software that we typically build, the rapid adoption of generative AI has not been met with the type of rigorous quality control that is required of powerful systems and expected of scientific endeavors. While there are many efforts around assessing the performance of generative AI systems, (e.g., benchmarks, human-in-the-loop AI red teaming, etc.) these methods often lack the rigor and context to make them truly scientific evaluations. In this BoF, we will host a community conversation to discuss the requirements to claim that a generative AI evaluation is scientifically sound while also maintaining subject matter expertise, relevance, and actionability. The SciPy Conference is an excellent forum for this discussion, bringing together scientists, developers, and practitioners.
Staff Scientist at the Alaska Satellite Facility
A session featuring updates and roadmaps from maintainers of core Scientific Python libraries and tools.
Canvas Chat is a browser-based tool that combines Python's data science stack with large language model connectivity, enabling natural language interaction with data. Built on Pyodide, it runs entirely in the browser with no server-side computation required. Users bring their own API keys for LLM access, while all session data persists locally in IndexedDB. The visual, non-linear interface represents conversations as nodes on an infinite canvas, supporting branching, merging, and stateful exploration of data analysis workflows. This talk demonstrates how browser-based Python plus LLMs can democratize data science by removing infrastructure barriers while preserving privacy and reproducibility.
Graduate textbooks in applied mathematics are notoriously inscrutable, dense with symbolic derivations never connected to intuition, application, or executable code. This talk presents a teaching pattern: Motivate, Symbolize, Derive, Lambdify, Simulate, Validate. The infrastructure is stable self-contained marimo notebooks with tests and automated publishing via GitHub Actions. Within the notebook, SymPy handles the symbolic stages; NumPy, SciPy, and matplotlib handle numerics and visualization. We demonstrate the pattern through a complete interactive treatment of Isaacs' Homicidal Chauffeur, a classical pursuit-evasion differential game, and close with an invitation to collaborate on open-source educational content in advanced applied mathematics.
Nobody loves writing release notes... and it only gets worse when multiple institutions are editing the same file. We learned the hard way that using a single file, manual RST editing, and no validation leads to repeated merge conflicts every release cycle. In response, we built Brassy, a CLI tool that replaces single-file changelogs with per-change YAML files, assembles them into formatted release notes, and lints entries in CI. We also built PinkRST (an RST formatter) and a Python-based Sphinx build system to tie our large multi-institution and many repo software documentation together. This talk covers the tools, the integration, and what we learned about getting scientists to actually write documentation.
Computational narratives like Jupyter, MyST Markdown, R-Markdown, and Quarto are amazing for doing science. You can combine narrative, code, data and images, conducting your analysis while also creating information to share. However, the workflow has been that notebooks are where you do the work, but you need to publish a pdf article to advertise the work, and this is the research output that most people see. That process not only creates extra work, but we're losing key information, amazing graphics, interactive visualizations, and a connection to the code and data.
Flattening science into a published pdf sacrifices reproducibility and valuable context for others to build on the research. We’re continuing to share our science in 19th century ways, as if we need to send printed, physical copies of our work to people in the mail. This is both a boring and ineffective way to communicate science and also reduces the visibility and value to the modular components of research. The data, images, and code all have individual value, especially as we think about new ways for humans and machines to build on existing science for new impact.
The Open Exchange Infrastructure (OXA, https://oxa.dev) is a community standard for scientific publishing built for modular and computational science. Initial contributors include Stencila, eLife, Posit, PLOS, openRxiv, Curvenote, NeuroLibre, and Creative Commons — representing a new document format that brings together the best of Jupyter Notebooks, Quarto, MyST Markdown, and publishing/archiving standards to enable new scientific publishing experiences and workflows. OXA additionally allows many tools and existing formats to connect with each other and into traditional publishing workflows, like Journal Article Tag Suite (JATS XML) and Manuscript Exchange Common Approach (MECA). This means that what you share is interactive and engaging and your research products, like large scale microscopy images (e.g. OME-Zarr), are first-class citizens where image datasets, notebooks, and other research products are highlighted not hidden.
In this talk we’re sharing more on the technical architecture of the format and a pilot between openRxiv (the non-profit organization behind the largest biomedical preprint servers: bioRxiv and medRxiv) and Curvenote (a scientific content management system that also hosts the SciPy Proceedings) to migrate 500k preprints (8.1TB) to OXA and show real-world examples of interactive scientific content, modular attribution, and what’s possible when the pieces are connected and scientific research can be open, engaging and match what’s possible with our current technology - to change the way we share and do science. This isn’t a future vision, this is what is already happening today.
Improving automatic speech recognition (ASR) for children is needed to enhance education and early childhood development. When ASR fails for children, reading assessments mis-score, speech therapy tools become unreliable, and many classroom tools cannot be built at all. The ASR gap exists because data sensitivity complicates the collection and sharing of transcribed child audio.
In this presentation, we’ll share how to unblock progress by creating public useful AI infrastructure even when data can’t be shared openly. We’ll discuss what makes child ASR so hard, how we advanced the field with an AI modeling competition, and best practices for sharing pretrained models.
Foundational Python libraries provide critical functionality that diverse communities of downstream developers and users depend on. Often, gaps in awareness between a core project and its broader community silently erode trust, collaboration, and sustainability. This talk shares lessons from a community-driven initiative to (re)-connect napari—a foundational library for multi-dimensional image viewing built on the scientific Python stack—with its ecosystem of over 580 community-developed plugins. Through a working group of core contributors, plugin developers, and end users, the napari plugin sustainability initiative discovered that creating new avenues for communication and collaboration leads to shared ownership of ecosystem progress.
What is the best way to study materials for modern devices? For example, designing better batteries means understanding how lithium ions move at the atomic level. This, in turn, requires building a model of the electrolyte and the electrodes, and observing how the system evolves along a dynamic trajectory. Until a few years ago, we would have approached this problem by first oversimplifying it into its core components and then using quantum mechanical simulations. However, these calculations are computationally very demanding: for a system like this, it could take hours on a supercomputer just to analyze a single trajectory step!
With the AI boom, machine-learning interatomic potentials (MLIPs) have become one of the most promising alternatives. Instead of running expensive quantum-mechanical calculations at every step, we can now perform only a small number of them and use the results as a training set for neural networks. Once trained, the MLIP can look at the complex atomic configuration of a system and immediately predict the energies and forces acting on each atom, without solving the underlying physics equations. This allows the simulation to evolve in milliseconds rather than hours, opening the door to simulations that were previously impractical.
Without the Scientific Python ecosystem, the development of machine learning methods in quantum chemistry would have a very hard time, since libraries such as PyTorch, Scikit-learn, and TensorFlow, combined with atomistic workflow tools like the Atomistic Simulation Environment (ASE), form the backbone of these methods. Importantly, most MLIPs are also open-source projects, whether developed by universities (MACE, CHGNet, and M3GNet) or by research groups at large technology companies such as Google DeepMind and Meta FAIR (UMA).
In this talk, we will explore how Scientific Python libraries power modern MLIP workflows, from dataset generation and model training to large-scale atomistic simulations. We will introduce the key ideas behind them in an intuitive way and discuss the current state of the field. Finally, we will highlight where current research is heading: from predicting how atoms move to learning the behavior of electrons, which ultimately determine those motions as well as many other fundamental properties, a much more challenging task.
Visualization libraries like Altair are based on the Grammar of Graphics (GoG), a theory of visualization that moved beyond fixed chart types towards a composable graphical language. But while the GoG makes simple charts easy, custom graphics still require low-level libraries like matplotlib. We present GoFish, a grammar of more graphics! GoFish formalizes patterns of visual structure (like connecting shapes with lines or spreading them out in space) letting you create diagrams, annotated charts, and infographics piece by declarative piece. In this talk, we'll see some fun and funky GoFish charts, and I'll uncover the hidden structure behind everyday visualizations.
Building software is often presented as the ultimate in asynchronous collaboration - open a PR, wait for a review, work on something else, and come back when it's a good time for you. The reality can often be... messier.
As someone who lives in UTC+8, works in UTC+10, and collaborates globally, I'll share my experience of why 7AM meetings aren't all bad, how to deal with the itch to respond to reviews on a Saturday morning, and how I finally learnt to listen to my wife and learn to switch off when there was no good reason to be on.
You're staring at a plot in a notebook. A subset of points doesn't look right. You want to select them, inspect them, understand why. In a traditional notebook, that means stopping to write more code and re-run cells. The exploration becomes an exercise in programming, not insight.
This talk comes in two parts. First, I introduce two primitives: reactive cell execution (marimo) and widgets (anywidget) that bridge Python and the browser. A brush stroke on a scatter plot becomes a Python selection. A slider flows through your analysis.
Second, I build intuition for composing these primitives—from quick explorations to reusable, domain-specific instruments that let you craft the interaction to match your scientific question.
Most scientific python maintainers build for users who will pip install the code. In civic tech, your community members are policy researchers, journalists, or NGO advocates who may never touch a Python environment. This cross-disciplinary context changes maintainership: traditional open source practices serve double duty as engineering and social infrastructure. I'll share lessons learned in maintaining the CIB Mango Tree, a civic tech Python toolkit for detecting inauthentic behavior in social media. I’ll show how in civic tech context familiar practices, like release cycles and continuous integration, can be repurposed to surface the otherwise invisible developer work to the broader community.
LLMs are powerful, but their knowledge is frozen — they can't access your private documents or recent information. Retrieval-Augmented Generation (RAG) solves this by searching relevant documents and including them in the prompt, grounding responses in real information. But building a good retrieval system involves many steps: reading diverse file formats, chunking text at sensible boundaries, computing embeddings, and combining search strategies. This talk introduces raghilda, a Python framework that handles the full retrieval pipeline. We'll cover how RAG works, how to build a retrieval system with raghilda, and how to connect it to an LLM with a practical example.
Tiled is a full-fledged data management service designed specifically to help scientists store, find, and access scientific data at scale easily.
The concept of data structures is the cornerstone of Tiled; it allows us to abstract the inherent diversity of various file formats and data storage types to a handful of scientifically meaningful representations: arrays, tables, nested hierarchies, and even awkward, ragged, and sparse arrays. Tiled provides a consistent API to such disparate datasets and naturally integrates with the SciPy ecosystem, including NumPy, pandas, xarray, Dask, and more. The users can slice, convert, and retrieve only the data they need, or even subscribe to live streams from external instruments and send updates to a dashboard. Importantly, Tiled supports operations with rich metadata – including search – making the data registered in Tiled discoverable and interactable with minimal overhead, by the human users and AI agents alike. Tiled runs equally well on a private laptop or in a large facility’s data center. Its built-in authentication and authorization mechanisms make the data access controllable and secure. Finally, Tiled is a fully open-source project developed under a multi-institutional governance model, which reflects our commitment to open science and the FAIR principles in scientific computing.
In this talk we will introduce Tiled’s architecture, demonstrate its most popular use cases using the native Python client, discuss deployment and integration strategies, and show how it can simplify practical scientific data workflows.
MNE-Python is open-source software for analyzing electrophysiological data in neuroscience. Like many projects, we struggle to retain maintainers. Finding maintainers in our user community is hard; most have little formal training in programming. To address this, we organized progressive training sprints with open applications and a participation stipend. Currently, we are onboarding four alumni of those sprints as new maintainers. We’ve seen positive outcomes from this approach, but at a high cost. We are now developing a curriculum for future onboarding efforts. We hope to spark discussions with other project leaders about their efforts toward educating and retaining talented maintainers.
Lightning talks are 5-minute talks on any topic of interest for the SciPy community. We encourage spontaneous and prepared talks from everyone, but we can’t guarantee spots. Sign ups are at the NumFOCUS booth during the conference.
AI tool adoption is outpacing our ability to thoughtfully decide how, when, and whether to use it. Researchers, maintainers, and contributors are reacting in real time both to the use of AI tools in open source development and to the flood of AI-assistance contributions that continue to strain human open source infrastructure. Peer-review programs like pyOpenSci and JOSS, along with maintainer teams across the ecosystem, are being forced to react by creating guardrails and protection systems on the fly. The result of this is a difficult combination of introduced technical debt caused by the unguided use of AI tools in software development, burnout across volunteer teams who are fielding rapid AI-assisted contributions, and polarization around whether AI tools have a productive place in open source community at all.
Come share your ideas for next year's SciPy. Participants will have an opportunity to sign up to be on next year's organizing committee.
You'll be randomly paired with another conference attendee for a 5-minute chat. Non-cheesy icebreakers will be provided. Virtual and in-person attendees welcome!
Zoom link will be provided in the SciPy 2026 conference Slack team
Come join the BoF to do a practice run on contributing to a GitHub project. We will walk through how to open a Pull Request for a bugfix, using the workflow most libraries participating at the weekend sprints use (hosted by the sprint chairs)
Until very recently, producing and using reproducible scientific software environments required advanced knowledge and a strict adherence to best practices (e.g. DOI: 10.25080/majora-212e5952-028). Now, with the advent of modern tooling with lockfile-first workflows (i.e. Pixi and uv), and the emergence of lockfile standards across scientific open source, applications can be made reproducible at the digest level through tooling decisions. As this technology and practices become increasingly common there is an opportunity to define common best practices around lockfile based software development that can further reduce developer overhead and maintenance burden. This Birds of a Feather panel will focus on how experienced developers are leveraging lockfiles across software development, applications, and deployment while providing best practices and practical recommendations, while also highlighting continuing challenges and opportunities for improvement.
Google Form for questions for the panel: https://forms.gle/1YP4951Yb9U4r2md6
This session will be a community discussion centered around developing interdisciplinary relationships between academic research institutions and non-academic institutions (industry, government, etc.). Using a new initiative from the Center for Interdisciplinary Exploration and Research in Astrophysics (CIERA) at Northwestern University as a model to build upon, develop, and learn from, we hope to build a shared understanding of how those engaged in scientific and technological development broadly would benefit from such efforts. The initiative – CIERA’s Tech Council – brings together a group of professionals (many of which with academic backgrounds) to serve as scientific collaborators, technical experts, community liaisons, and mentors. Starting from this point, we ask: What does it mean to create a rich and thriving ecosystem around an academic institution that translates technological expertise into scientific progress, increases accessibility of advanced tools and research, and builds community across varying career paths? As the SciPy Conference is a hub for interdisciplinary knowledge and skill sharing, it is a perfect place to hold such a discussion.