Uploaded November 2026 | Updated November 2026, 2 days ago
Sketch me an HPC program: Stencils with Dagger.jl by Julian P Samaroo, Felipe Tomé, Rabab Alomairy
PreTalx: pretalx.com/juliacon-2026/talk/YGSNMR
Stencil operations are a cornerstone in many fields, including fluid and gas flow simulations, machine learning/AI, computer graphics, image processing, and many more. Stencil operations (also known as windowed operations) allow a normal elementwise operation to additionally access neighboring elements, instead of just the currently-selected element. The are a number of stencil computation libraries in Julia, such as ImageFiltering.jl, ParallelStencil.jl, Stencils.jl, and now Dagger.jl (the focus of this talk). Dagger in particular makes it easy to define stencil operations that run across multiple CPUs, multiple GPUs, and across multiple nodes, and supports many kinds of boundary conditions, arbitrary numbers of dimensions, and flexible neighborhood sizing. We will discuss and compare the differences between the various stencil libraries, and see how easy it is to write parallel stencils in each library. We will also look at Dagger’s stencil performance in a variety of microbenchmarks.
Sketch me an HPC program: Stencils with Dagger.jl by Julian P Samaroo, Felipe Tomé, Rabab Alomairy
PreTalx: pretalx.com/juliacon-2026/talk/YGSNMR
Stencil operations are a cornerstone in many fields, including fluid and gas flow simulations, machine learning/AI, computer graphics, image processing, and many more. Stencil operations (also known as windowed operations) allow a normal elementwise operation to additionally access neighboring elements, instead of just the currently-selected element. The are a number of stencil computation libraries in Julia, such as ImageFiltering.jl, ParallelStencil.jl, Stencils.jl, and now Dagger.jl (the focus of this talk). Dagger in particular makes it easy to define stencil operations that run across multiple CPUs, multiple GPUs, and across multiple nodes, and supports many kinds of boundary conditions, arbitrary numbers of dimensions, and flexible neighborhood sizing. We will discuss and compare the differences between the various stencil libraries, and see how easy it is to write parallel stencils in each library. We will also look at Dagger’s stencil performance in a variety of microbenchmarks.

, built on byte-precise lowering and abstract interpretation. This year, we focus on the core design behind it: loading parts of user code to reuse Julias macro handling and compiler type inference. We compare this runtime-integrated approach with the overhauled LanguageServer.jl/JuliaWorkspaces.jl stack and demo its progress on real-world code.
At JuliaCon 2025, we introduced [JETLS.jl](https://github.com/aviatesk/JETLS.jl), then an early-alpha Julia language server built on [JET.jl](https://github.com/aviatesk/JET.jl)s abstract interpretation and [JuliaLowering.jl](https://github.com/JuliaLang/julia/tree/master/JuliaLowering)s byte-precise, provenance-tracking lowering. One year later, this talk goes beyond a progress report to examine the core design that makes this compiler-grounded analysis possible.
JETLS selectively loads parts of the target program into its analysis process. This runtime integration enables JuliaLowering to execute the program’s actual macros while preserving byte-precise source provenance, and JET to reuse Julia’s compiler inference to derive type information for source-level developer tooling.
We compare this design in depth with the [LanguageServer.jl](https://github.com/julia-vscode/LanguageServer.jl)/[JuliaWorkspaces.jl](https://github.com/julia-vscode/JuliaWorkspaces.jl) stack, which has undergone a major overhaul over the past year. Rather than presenting JETLS simply as a replacement, we place the two approaches on a spectrum of runtime integration: JETLS aims to provide precise information about macro expansion and lowering, together with compiler-inferred types, while the largely static approach prioritizes responsiveness and safety and benefits from greater production maturity.
These architectural differences become concrete in a live demo using real-world code from CSV.jl and JuliaFormatter.jl. We show how JETLSs runtime-integrated design translates into practical editor features, most of which were either early prototypes at last years talk or did not yet exist.
Finally, we summarize JETLSs current feature coverage, installation and environment isolation, and editor setup. We also briefly show how the same analysis is exposed through a CLI for CI and AI-agent workflows, showcasing agentic bugfixes drawn from a [Julia Base audit with JETLS](https://github.com/JuliaLang/julia/issues/62526).
Time permitting, we share performance measurements before outlining future work. JETLS: Bringing Julia’s runtime into language-server analysis | Kadowaki, Pfitzner](https://i.ytimg.com/vi/m-K5Wij8Q38/mqdefault.jpg)







 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](https://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](https://i.ytimg.com/vi/oo75NelKMho/mqdefault.jpg)
![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)