Uploaded November 2026 | Updated November 2026, 17 hours ago
TrixiParticles.jl on GPUs: A Deep Dive into Simulating Fluid Dynamics of Carbon Fiber Fins by Erik Faulhaber
PreTalx: pretalx.com/juliacon-2026/talk/Y7LGHP
flyer-Y7LGHP: pretalx.com/media/juliacon-2026/submissions/Y7LGHP/resources/Y7LGHP_OEgnpTf.png
[TrixiParticles.jl](https://github.com/trixi-framework/TrixiParticles.jl) is an open-source framework for accessible particle-based multiphysics. In this talk, we demonstrate how to leverage modern, GPU-centric HPC hardware for complex fluid–structure interaction (FSI) simulations. Using a carbon-fiber freediving fin as a case study, we discuss the numerical challenges of extremely stiff and thin blades, and present performance benchmarks across different CPU and GPU architectures to showcase cross-platform efficiency.
[TrixiParticles.jl](https://github.com/trixi-framework/TrixiParticles.jl) is an open-source numerical simulation framework designed for accessible particle-based multiphysics simulations and implemented in Julia as part of the Trixi Framework. Two years after [introducing the package at JuliaCon 2024](youtu.be/ReLkKUV4kTw?is=aEQmXo9GWj3d36dI), we return to demonstrate how the framework leverages modern HPC hardware to support both rapid prototyping and complex applications.
In the first part of the talk, we present the latest developments in GPU usability and performance.
As modern clusters become increasingly GPU-centric, simulation software must adapt to utilize this hardware effectively. We show how TrixiParticles.jl allows users to seamlessly run simulations on GPUs with minimal code changes, and present benchmarks comparing modern dual-socket CPU nodes against various GPU architectures.
In the second part, we take a "deep dive" into a challenging real-world application: the hydrodynamics of a carbon-fiber freediving fin. Simulating the propulsion generated by a foot-driven, extremely stiff, and thin blade presents significant numerical difficulties, particularly regarding Fluid-Structure Interaction (FSI). We will discuss numerical instabilities caused by the high stiffness and thin geometry of the carbon-fiber blade.
TrixiParticles.jl on GPUs: A Deep Dive into Simulating Fluid Dynamics of Carbon Fiber Fins by Erik Faulhaber
PreTalx: pretalx.com/juliacon-2026/talk/Y7LGHP
flyer-Y7LGHP: pretalx.com/media/juliacon-2026/submissions/Y7LGHP/resources/Y7LGHP_OEgnpTf.png
[TrixiParticles.jl](https://github.com/trixi-framework/TrixiParticles.jl) is an open-source framework for accessible particle-based multiphysics. In this talk, we demonstrate how to leverage modern, GPU-centric HPC hardware for complex fluid–structure interaction (FSI) simulations. Using a carbon-fiber freediving fin as a case study, we discuss the numerical challenges of extremely stiff and thin blades, and present performance benchmarks across different CPU and GPU architectures to showcase cross-platform efficiency.
[TrixiParticles.jl](https://github.com/trixi-framework/TrixiParticles.jl) is an open-source numerical simulation framework designed for accessible particle-based multiphysics simulations and implemented in Julia as part of the Trixi Framework. Two years after [introducing the package at JuliaCon 2024](youtu.be/ReLkKUV4kTw?is=aEQmXo9GWj3d36dI), we return to demonstrate how the framework leverages modern HPC hardware to support both rapid prototyping and complex applications.
In the first part of the talk, we present the latest developments in GPU usability and performance.
As modern clusters become increasingly GPU-centric, simulation software must adapt to utilize this hardware effectively. We show how TrixiParticles.jl allows users to seamlessly run simulations on GPUs with minimal code changes, and present benchmarks comparing modern dual-socket CPU nodes against various GPU architectures.
In the second part, we take a "deep dive" into a challenging real-world application: the hydrodynamics of a carbon-fiber freediving fin. Simulating the propulsion generated by a foot-driven, extremely stiff, and thin blade presents significant numerical difficulties, particularly regarding Fluid-Structure Interaction (FSI). We will discuss numerical instabilities caused by the high stiffness and thin geometry of the carbon-fiber blade.
![Deep Adaptive Experimental Design for SciML | Strouwen, Micluța-Câmpeanu | JuliaCon Global 2026
Deep Adaptive Experimental Design for SciML by Arno Strouwen, Sebastian Micluța-Câmpeanu
PreTalx: https://pretalx.com/juliacon-2026/talk/SFWUKP/
Slides: https://github.com/arno-papers/CDC2026/blob/main/presentation/slides.pdf
Real-time adaptive experimental design for ODE models is hard: each step requires costly posterior inference and optimization. We train a neural network policy offline to amortize this cost. The Julia SciML stack makes this practical: Enzyme.jl differentiates through ODEs, Lux.jl defines the policy network, and Reactant.jl compiles everything to a single GPU program. On a bioreactor benchmark, the learned adaptive policy beats Bayesian D-optimal static designs with a 99.5% win rate.
Model-based design of experiments (MbDoE) is a fundamental methodology in engineering and the sciences: given a mechanistic model with unknown parameters, choose experimental conditions that yield the most informative data [1]. Adaptive designs use the information in the already gathered experiments to guide the remainder of the experiment. However, conventional adaptive MbDoE requires solving a computationally expensive optimization problem between every measurement, which is infeasible when experiments run in real-time [2].
Deep Adaptive Design (DAD) addresses this by training a neural network policy offline to map experimental histories to optimal designs [3]. Once trained, the policy requires only a forward pass at deployment, enabling real-time adaptive decisions. We apply DAD on a differentiable mechanistic model, i.e., dynamical systems described by ODEs with known structure but uncertain parameters.
## The SciML stack: Lux + Enzyme + Reactant
The core contribution of this talk is showing how three pillars of the Julia ecosystem compose to solve a problem that would be difficult in any other framework.
Enzyme.jl differentiating through ODE solvers.
Lux.jl defining the policy network.
Reactant.jl GPU compilation of the full training loop.
The key insight is that none of these packages needed special adaptation to work together. Writing the ODE solver, the neural network, and the loss function in plain Julia was sufficient for Enzyme to differentiate through all of it and for Reactant to compile the result to GPU.
## Application and results
We primarily demonstrate the approach on a fed-batch bioreactor with Monod growth kinetics. The goal is to estimate the maximum growth rate and substrate affinity constant by adaptively choosing feed rates over a 14-hour experiment based on noisy substrate concentration measurements.
The trained policy is compared against a Bayesian D-optimal static design. The adaptive policy achieves a 99.5% win rate over this optimized static baseline.
Besides the bioreactor with Monod kinetics, an overview of several other applications is showcased.
## Who should attend
This talk is relevant to anyone interested in differentiable programming in Julia, scientific machine learning, Bayesian experimental design, or composing the SciML ecosystem for non-standard workloads. No prior knowledge of experimental design is assumed.
## References
[1] Franceschini, G. & Macchietto, S. (2008). Model-based design of experiments for parameter precision: State of the art. Chemical Engineering Science, 63(19), 4846-4872.
[2] Ryan, E.G., Drovandi, C.C., McGree, J.M., & Pettitt, A.N. (2016). A review of modern computational algorithms for Bayesian optimal design. International Statistical Review, 84(1), 128-154.
[3] Foster, A., Ivanova, D.R., Malik, I., & Rainforth, T. (2021). Deep Adaptive Design: Amortizing Sequential Bayesian Experimental Design. International Conference on Machine Learning, 3384-3395. Deep Adaptive Experimental Design for SciML | Strouwen, Micluța-Câmpeanu | JuliaCon Global 2026](https://i.ytimg.com/vi/owA7IAFWFVc/mqdefault.jpg)



![ReproducibleJobs.jl enables practical and reproducible workflows in SingleCellProjections.jl
ReproducibleJobs.jl enables practical and reproducible workflows in SingleCellProjections.jl by Rasmus Henningsson
PreTalx: https://pretalx.com/juliacon-2026/talk/8Z8UFG/
Reproducibility in scientific analyses is often hampered by insufficient tooling. Large data and slow computations force users to save partial results to disk, and the actual steps to reproduce the entire chain from raw data to end results are lost. Here we present ReproducibleJobs.jl - a computational framework that enables natural workflows and fast turnaround, while still achieving reproducibility and show how it works in practice for single cell expression data in SingleCellProjections.jl.
In this talk, we will describe how ReproducibleJobs.jl is structured, and show how it is used in SingleCellProjections.jl to achieve reproducible and practical workflows for large single cell expression data.
ReproducibleJobs.jl is a framework for reproducible analyses of scientific data, that is based on the following ideas:
* The burden of reproducibility should be moved from the user to the packages they use for analysis, when possible.
* Memoization/caching is a good strategy because while the raw data can be large, the computed results are in essence much smaller.
* It is possible to create succinct specifications of how to perform analyses.
Results in ReproducibleJobs.jl are lazy. Consider a simple but standard single cell workflow that look something like this:
```
counts = load_counts([paths/to/large/files])
transformed = sctransform(counts)
normalized = normalize_matrix(transformed)
reduced = pca(normalized; nsv=100)
```
To actually retrieve the result of the PCA (Principal Component Analysis) computation, the user then needs to call `fetch!(reduced)`. This is what enables ReproducibleJobs.jl to work under the hood. The lazy result is in fact a *specification*, a recipe, of what to compute. And if the computation was already memoized (cached), even in an earlier Julia session, ReproducibleJobs.jl can load the result from disk directly, without accessing any data for the earlier analysis steps. Importantly, several steps are taken to standardize the specifications, such that only changes that actually affect the results cause recomputations.
The talk also describe some of the technical challenges and solutions relating to:
* Specification design
* Specification metaprogramming/preprocessing - going from intent to implementation
* Hashing and caching
* Canonical representations of specifications and why they are important
* Strategies for handling high-level data types (such as tables, DataMatrices (matrix + variable & observation annotations)) in specifications
* Stability across Julia sessions and package versions
* How specification metaprogramming enables projections of one dataset onto another in SingleCellProjections.jl
**SingleCellProjections.jl** is a package for analyzing Single Cell expression data in Julia, with support for loading, transforming, normalizing, filtering, doing dimension reduction, performing statistical tests and more. Internally, SingleCellProjections.jl uses matrix expressions built from sparse and low rank matrices, thus avoiding speed and memory problems that competing (R/python) packages face when using large dense matrices. ReproducibleJobs.jl enables practical and reproducible workflows in SingleCellProjections.jl](https://i.ytimg.com/vi/pr-Qj2cVtcw/mqdefault.jpg)





