JuliaCon 2026

High-Performance Computing (HPC) empowers modern science and engineering by enabling the simulation and analysis of complex systems at unprecedented scales on cutting-edge supercomputers. Julia, as a dynamic programming language designed for scientific computing, uniquely combines the ease of high-level syntax with near C and Fortran execution speed, making it a compelling vehicle for performance engineering on supercomputers.

This workshop offers a hands-on introduction to performance engineering with Julia on modern HPC systems, guiding participants through the workflow of analyzing, optimizing, and scaling Julia codes on a real HPC environment. Using interactive Jupyter notebooks backed by the Otus system at the Paderborn Center for Parallel Computing (PC2), participants will experiment with live Julia code and performance analysis tools to gain practical proficiency in optimization techniques.

The three parts of the workshop will first introduce the organization of modern HPC clusters that influences Julia code performance, then examine the performance engineering workflow that identifies and solves optimization problems and finally present a case study of the workflow applied to a real scientific application.

Through the combination with hands-on exercises, participants will not only understand the core principles of performance engineering but also actively practice optimizing and scaling Julia programs on the Otus HPC system at PC2.

What if engineers could go from concept to validated simulation model through conversation alone? DyadAgent, built on Julia and Dyad, makes this possible by combining generative AI with the SciML ecosystem to construct, compile, and rigorously validate high-fidelity physical models from natural language. It handles planning models, creating them, validating them, debugging them and using them in downstream applications such as parameter estimation, model discovery and more. This workshop demonstrates how DyadAgent is reshaping the modeling workflow across engineering domains.

Julia offers the best of both worlds: high-level expressiveness combined with low-level performance, allowing developers to leverage modern hardware accelerators without needing expertise in hardware-specific languages. This workshop demonstrates how Julia makes high-performance computing (HPC) accessible by covering topics such as distributed GPU computing, GPU code optimization, and scalable workflows.

The Julia language is a proven technology for technical computing. So it is only natural for people to build engineering-related tools on top of it. In this workshop, we'll discuss our Dyad platform for system modeling and how this utilizes both Julia and ModelingToolkit to deliver Scientific Machine Learning (SciML) to engineers in industry.

Debugging performance and memory issues in Julia often requires combining multiple tools and correlating their outputs. Participants will learn how to use a runtime-level instrumentation approach to analyze and resolve performance issues in real code, including cases that are difficult to diagnose using existing tools.

While strong in sciences and technical tasks, Julia has traditionally lacked the kinds of "application frameworks" many other languages offer for bundling and deploying applications as servers.

The JuliaServices GitHub organization has steadily been building up just the kinds of utility/support packages that facilitate "productionalizing" your Julia code:

• Servo.jl: Utility package providing auth middleware, JSON logging, background metric/observability tracking, and endpoint route-defining macros
• OAuth.jl: full, pure-Julia implementation of OAuth 2.0; client and server functionality
• Tempus.jl: cron-style scheduler/job executor with abstract storage options
• Harbor.jl: powerful docker image/container managing from Julia; enables robust testing scenarios with precise "services" providers via docker containers.
• CloudStore.jl: cloud-agnostic "object store" package, enabling easy CRUD operations across cloud storage locations

This workshop will walk through building an entire Julia application from scratch, utilizing JuliaServices packages, resulting in a fully deployed, publicly accessible application.

Welcome to Mainz and JuliaCon Global 2026! We are here to provide an open, welcoming, and safe place for sharing knowledge, fostering collaborations, and binding people together. Let's enjoy!

Haskell is an unusual survivor in the Darwinian landscape of programming languages: it is long-lived (36 years old), yet not mainstream; it is both a research platform and a production tool; it pushes the boundaries of what you can do with static types; and (anecdotally) it inspires joy as well as offering utility. In this talk I'll describe how Haskell came to be, and what (in retrospect) I think are its most important contributions. I'll talk about how it has evolved, especially in response to the demands of companies using Haskell in production.

Compilation latency is one of top asks Julia users have and have had over the years. But why is it so hard to make significant leaps on that area. Or even keep the performance the same.
Since 1.10 there have been significant regressions in (pre)compilation time. What caused those and can we recoup or even get better than 1.10 performance?
The talk will go through why compiling Julia quickly is hard, what are we doing to improve that and what users can do to make their code compile faster.

tbd

The Julia SciML ecosystem is a collection of hundreds of packages. Keeping the whole system up to date can be quite the task, with dependencies releasing breaking versions weekly and having to track down CI failures. Over the last year a multi-agent system was developed to help with a lot of the maintenance burden. The goal of this talk is to share the details of this system so that other Julia package ecosystems can iterate on the idea and adopt similar mechanisms.

Global grid systems (DGGS), or non-planar grids, are the new hotness - but how can you get data onto them and analyze? In this talk, we'll show the high-level way to do this, which packages you'll need, as well as how to handle issues like geometries on the boundaries of faces, regridding error, and more.

In all likelihood you are familiar with DGGS already - in simulation, tripolar and cubed-sphere grids are common, as are HEALPIX and other formulations.

The spectroscopy of exotic hadrons enables probing the dynamics of the strong interaction beyond the conventional quark–antiquark and three–quark picture. Measurements at the LHCb experiment revealed the doubly charmed tetraquark Tcc⁺ and provided new high-precision data relevant for understanding the structure of the X(3872). Interpreting such near-threshold systems requires accurate modeling of threshold effects, multi-body dynamics, and technically advanced statistical inference.

We present a Julia-based analysis ecosystem developed for studies of these states using LHCb data. The workflow combines established Julia packages for statistical modeling and minimization with specialized tools tailored for hadron spectroscopy. Core functionality relies on packages such as Distributions.jl, NumericalDistributions.jl and Minuit2.jl, extended by domain-specific probability distributions implemented in DistributionsHEP.jl.

Several dedicated physics packages provide modular building blocks for amplitude models and line-shape calculations. These include X3872Flatte.jl, X3872ThreeBodyLineshape.jl, and xDDPhaseSpace.jl, implementing threshold line shapes, three-body kinematics, and phase-space constructions relevant for near-threshold charm systems. Complete analyses are developed in separate private repositories operating on collaboration-internal data and likelihood models; the software is released publicly once the corresponding analyses are published.

A key component of the workflow is BuildConstructors.jl, a framework providing long-awaited granular control over complex fitting strategies. It enables structured construction of likelihood fits with systematic parameter management, including controlled fixing and releasing of parameters during iterative block likelihood fits.

Together these packages support complex spectroscopy analyses while extending the Julia ecosystem with tools for amplitude modeling and likelihood-based inference. They simplify the development of advanced analysis strategies and make Julia more accessible for future analyses in experimental particle physics.

This talk explores algebraic methods for quantum control polynomial optimization problems. We show how degeneracy, numerical stability and scalability are central issues in quantum control and how ConicSolve.jl has been extended to use face reduction and symmetry reduction (via the Wedderburn decomposition).

We close with open questions and further work so such tools may become a practical reality. We hope that this work acts as a foundation for further research, new tools and methods for realizing quantum control systems where certification and high precision are paramount.

Points on or near the Earth can be represented in many coordinate systems - e.g. LatLonAlt, ECEF Cartesian or WebMercator to name just three. Without careful design, the amount of code required to convert between these systems scales quadratically and therefore quickly becomes unmanageable. In this talk, I will show how MapMaths.jl leverages Julia's type system and metaprogramming features to eliminate this and related sources of combinatorial explosions in coordinate conversion libraries.

Whilst the majority of Universities have pivoted increasingly to Python as the primary (and in some cases, only) teaching language for Undergraduate Physics, there are compelling reasons to introduce Julia as a target language.
This is not without precedent: Engineering departments in multiple countries (Germany, USA...) have used Julia as a teaching language for some years, due to the ease of porting mathematical expressions to it, and its similarity to MATLAB.
I discuss the motivations for doing so in Physics, and some experiences of introducing Julia in a structured way to undergraduate students at the University of Glasgow (although not in a formal course).

I present Giac.jl, a Julia interface to Giac, the open-source computer algebra system behind Xcas, GeoGebra and HP Prime. Giac.jl relies on libgiac-julia-wrapper for FFI (ie foreign function interface) bindings to the C++ library. Around it, companion packages extend Giac into the notebook world:
MathJSON.jl handles the MathJSON interchange format, PlutoMathInput.jl provides a WYSIWYG MathField widget for Pluto, and MathJSONComputeEngineBridge.jl connects them. I demonstrate this
workflow live in a reactive Pluto notebook.

Julia aggressively transforms your code during compilation and execution, which can make it difficult to see what actually runs. This can introduce subtle performance and memory costs that are not directly visible in existing tools. In this talk, we show a compiler and runtime instrumentation approach that provides a runtime-level view of program execution, links runtime behavior back to source code, and show how hidden costs can be uncovered and performance assumptions validated.

Quantitative Systems Pharmacology (QSP) is a fast-growing discipline in model informed drug development. We simulate virtual patients to enhance decisions across the pharmaceutical pipeline to get the right medicines to the right patients faster. QSP models are large and often stiff differential equation systems. Workflows include intensive simulations such as parameter optimization and sensitivity analyses. In this talk, we will discuss how we utilize Julia for QSP workflows.

AI Agent software has proliferated in the last year. What started out as simple chatbots has evolved into deeply capable personal AI assistants and agent "swarms".

Agentif.jl provides a set of agent "primitives" to enable building and configuring agent harnesses in pure Julia.

• LLMProviders.jl: model provider abstraction; unifies Anthropic, OpenAI, OpenRouter, and other LLM providers under common models/"stream" functionality
• Agentif.jl: core Agent, Tool, Channel, Session, Compaction, and middleware definitions that form the core "agent loop" functionality
• LLMTools.jl: Sets of predefined tools that can be provided to agents, including: subagents, pty sessions, web search, Julia worker processes, and basic bash tools (ls, grep, read, write, edit, etc.)
• Vo.jl: an example "personal assistant" setup using above primitives bundled together

Discrete Global Grid Systems (DGGS) allow minimizing spatial distortions in geospatial image processing, among others. Here we present DGGS.jl, a Julia package to work with DGGS native data cubes using Zarr.jl and YAXArrays.jl. It transforms any raster image from a traditional projection into memory-efficient N-dimensional arrays, following one unified global coordinate system without overlapping tiles, e.g., for bounding box queries, spatial aggregation, or visualization in QGIS.

The Julia JetReconstruction.jl package was released in 2024 and provides a
high-performance native Julia implementation of serial jet reconstruction in
high-energy physics, inspired by the FastJet C++ package. In serial mode the
code outperforms FastJet by 14-40%, depending on the exact parameters used.

Until now, no systematic testing and benchmarking of the code had been done
when running in a parallel, multi-threaded, mode. In this paper we present the
first results of doing this. The initial parallel performance of
JetReconstruction.jl, compared to an equivalent multi-threaded version of
FastJet, showed increasingly poor performance, with the advantage of
JetReconstruction.jl quickly evaporating and becoming about a x10 deficit at
high thread counts in the worst case.

We performed an investigation of the underlying reasons for this poor
performance, looking at thread scheduling parameters, physics code scaling, and
memory allocations and garbage collection issues. We review this performance
investigation, and the profiling tools which we used, and how we finally
understood the source of the problem: memory allocations and garbage collection.

We have now designed a new approach to reuse already allocated memory, with
much better parallel scaling. We discuss ergonomics of this new interface, which
now allows users to run in a highly parallel mode with excellent performance,
tested up to 64 parallel threads, which consistently maintains the advantage of
JetReconstruction.jl over FastJet.

We present CertifiedHomotopyTracking.jl, a Julia package for certified homotopy tracking. Homotopy path tracking has been used as an effective method across diverse fields, but its outputs are not certified. Our package ensures correctness using interval arithmetic (via Nemo.jl). The package uses Symbolics.jl to construct systems via SLPs. Based on this, it automates monodromy group analysis through GAP integration. Finally, we discuss interaction with HomotopyContinuation.jl and Pandora.jl.

The most popular modeling framework in pharmacometrics is nonlinear mixed-effects modeling. In the pharmacometric application of the model framework, the time dimension is typically a solution to a dynamical system. The combination of the nonlinearity of the statistical model and the computational costs of numerically solving differential equations has made the use of staged programming necessary in all available software packages. The staged programming requirement has historically been associated with a large maintenance burden, but staged programming is also what Julia was designed for. In this talk, I outline the modeling class most popular in pharmacometrics, give an overview of how historical solutions are used, and explain how Julia is well suited for pharmacometrics.

Earth system science needs user-friendly access to global observations. MetopDatasets.jl is a package to read native-format products from the Metop satellites, which play a key role in current global weather models through data assimilation. MetopDatasets.jl also demonstrates how the CommonDataModel.jl interface can be used to build a user-friendly reader for custom binary formats common in Earth sciences.

Due to the nature of data in computer algebra, the storage of such data requires a more sophisticated format. The mrdi file format is a JSON based file format with the necessary structure for saving and loading common types among computer algebra software.

The first implementation for serializing mrdi files has been written in the computer algebra system Oscar.jl. We present the format as well as some design decisions for the implementation in Oscar.lj

NoLimits.jl is a flexible open-source Julia framework for nonlinear modeling and parameter estimation with random effects. It supports ODE-based mechanistic models, hidden Markov models, hybrid mechanistic-machine learning components, normalizing flows, and nested random-effect structures within a unified interface. By leveraging Julia’s composability, it enables scalable frequentist and Bayesian inference beyond the constraints of traditional open-source mixed-effects software.

In this talk, we present techniques for implementing efficient GPU-based random sampling
algorithms, including rejection sampling and multi-stage sampling pipelines using
KernelAbstractions.jl. We discuss strategies to avoid costly synchronizations between host
and device, manage divergent execution flows, and schedule heterogeneous
workloads entirely on device. Particular attention is given to structuring rejection
sampling and sequential transport algorithms in ways that preserve GPU occupancy while
maintaining statistical correctness.

To demonstrate the applicability of these techniques, we present results from two Julia
packages developed for plasma and high-energy physics applications. The first,
QEDevents.jl, focuses on Monte-Carlo event generation for high-multiplicity
scattering processes in quantum electrodynamics, building on the generic sampling
framework RejectionSamplers.jl and the QuantumElectrodynamics.jl ecosystem. The second,
PhotonTransport.jl implements a Monte-Carlo photon transport code for warm-dense matter.
Together, these case studies illustrate how Julia enables both the expressive
implementation of parallel sampling algorithms and near-peak accelerator performance,
while maintaining portability across hardware backends.

The world of AI agents is changing constantly - every couple of weeks, it seems there is some new thing. In this talk, I'll try to sum up the current state of the art when using AI agents with Julia - from which agents to use, MCP servers, skills and whatever else comes up between now and then. If you have only dipped your toes into using AI with Julia so far, this talk is for you!

The advent of convenient automatic differentiation has made gradient-based optimization the default strategy for many challenging problems and has revolutionized statistical practice.
At the same time, MixedModels.jl uses a gradient-free approach to optimization and remains best in class for linear mixed models.
Using MixedModels.jl as a case study, we will explore the tradeoffs of using the gradient and why gradient-free approaches remain relevant even in a world of easy autodiff.

The SpatialTreeInterface defined in GeometryOps.jl provides an efficient way for geometrical queries of polygons that share a crs by relying on search trees whose branches are characterized by rectangular bounding boxes. However, when working across different projections, for example when trying to identify intersecting polygons from different projections on the sphere, rectangles in one projection do not translate into rectangles in another projection, so the tree traversal will not be accurate.

To solve this problem, we extended the SpatialTreeInterface in SphericalSpatialTrees.jl by replacing rectangular bounding boxes with SphericalCaps, using these to characterize the extent of all branches in a spatial tree. This enables users to do combined tree searches across polygons based on different projections, as is common e.g. in Discrete Global Grid System. The presentation will demonstrate the basic concept of the SphericalSpatialTrees.jl package as well as a few downstream applications.

I order to solve the problem of

OSCAR is a general-purpose computer algebra system written in julia that builds on the four cornerstones GAP, polymake, Singular, and Antic (Hecke, Nemo) and has capabilities for dealing with problems in number theory, group and representation theory, tropical and polyhedral geometry, algebraic geometry, commutative algebra, non-commutative algebra, and many more areas of computer algebra. It is being developed as part of the SFB-TRR 195 "Symbolic Tools in Mathematics and their Application", which is supported by the German Research Foundation (DFG).

In the first part of the talk, we will give an introduction to the philosophy behind OSCAR and discuss questions like "What is computer algebra and why do I need it?", "Why yet another computer algebra system?", "Why did you choose julia?", and "How does OSCAR compare to other similar tools like Symbolics.jl and HomotopyContinuation.jl?"
In the second part, we show some very introductory examples of how to use OSCAR. These are not intended to be mathematically interesting at all. Instead, any listener with an introductory course of algebra should be able to easily follow the mathematics involved, so that we can put more emphasis on the key usage principles and syntax.

Bundling applications into native installers such as MSIX, Snap, or DMG usually requires the target platform access and host system utilities. This creates a maintenance burden: each platform needs special setup, and compatibility must be preserved as operating systems evolve and utility behavior changes. AppBundler eliminates this burden by using cross-compiled, open-source utilities distributed through Julia’s Yggdrasil registry. From a single UNIX host (Linux, FreeBSD, or macOS)—with MSIX support on Windows—developers can generate native installers through a consistent, reproducible pipeline.

In this talk, I will explain the architecture behind AppBundler and walk through each supported installer format. I’ll provide an overview of the open-source pipelines that replace host system utilities, then review the configuration files and common options that control application behavior after installation. I will then introduce the AppBundler API design and show how surgical customizations via native override files are supported.

The session continues with a live demo showing how any application exposing @main can be bundled locally with minimal effort. We’ll add an icon, experiment with configuration options, and iterate on the bundle. I’ll then demonstrate how the same application can be packaged automatically on GitHub Actions, including a walkthrough of the Actions panel and release workflows that build installers across platforms with a single click.

Next, I’ll showcase several larger applications that have been successfully bundled with AppBundler. We’ll discuss common pitfalls that make applications non-relocatable and how to resolve them. I’ll cover JuliaC integration, including a demo of a command-line application using the --trim option. I’ll also touch on asset inclusion and referencing via pkgdir(@__MODULE__), and explain how calling AppEnv.init() in @main populates pkgorigins to enable relocation.

The talk will conclude with future directions beyond the 1.0 release, including how AppBundler could evolve to package not only Julia applications, but software written in other programming languages.

In this talk physics informed neural networks are presented to predict the plasma concentration time profiles of preclinical species and human after i.v. bolus administration. The predictions are based on the numerical representation of chemical structures or amino acid sequences and compartmental modeling is used as the physical part to describe the pharmacokinetic profiles.

Wouldn’t it be great if Julia could program itself?
You simply tell it what you want, Julia magic happens, and you get correct-by-construction code.
In this talk, we introduce Herb.jl, a unifying program synthesis library written in Julia, that gets us closer to this goal.
While we are not fully there yet, we have significantly progressed since our last talk at JuliaCon 2024.

Spatial machine learning has become increasingly crucial for environmental prediction tasks. Yet, current workflows in R and Python face challenges when scaling to high‑resolution, national‑level mapping and when integrating modern uncertainty‑aware methods. In this talk, I present a new Julia‑based spatial machine learning framework for digital soil mapping, focusing on national soil organic carbon (SOC) prediction in Estonia. The approach combines Random Forest models, stacked meta‑learning, and conformal prediction through the MLJ ecosystem, while developing an integration port to Julia of the IGEO7 discrete global grid system (DGGS) to impose a hierarchical spatial structure.
This approach targets persistent issues in spatial ML, such as autocorrelation, multi‑scale dependencies, and computational efficiency. It implements DGGS‑based multi‑resolution covariate aggregation, spatially aware cross‑validation, Shapley values, and area‑of‑applicability (AOA) assessment using the Dissimilarity Index method. Initial results demonstrate improved spatial fidelity, scalable high-resolution prediction, and more transparent communication of uncertainty.
This work showcases how Julia’s speed and composability enable a modern, reproducible, and scalable approach to spatial machine learning in comparison to what conventional Python/R workflows currently offer.

A quick overview of the new Raytracing backend, with live demos, technical insights and how it can be used for JuliaHEP.

Virtual Populations (VPops) are widely used in Quantitative Systems Pharmacology (QSP) to represent variability in patient responses to therapy using parameterized dynamical models. Unlike traditional modeling approaches that focus on average treatment effects, VPop methods aim to reproduce the full distribution of clinical outcomes observed in trials.
We introduce VPopMIP, a Julia package implementing a Mixed-Integer Programming (MIP) formulation for generating VPops that match clinical endpoints. In contrast to many existing approaches that require individual-level patient data, VPopMIP enables calibration to published clinical summary statistics (e.g., response rates, medians, and confidence intervals), which are more commonly available in practice.
The method formulates virtual patient selection as a constrained optimization problem that enforces agreement with multiple outcome measures across therapies.
We demonstrate the methodology using a solid tumor model with multiple efficacy endpoints across treatment regimens. The results illustrate how MIP-based selection provides an efficient way to construct clinically consistent virtual populations.

Reading and writing geospatial vector data is the bread and butter of any spatial ecosystem. In this short talk we present GeoDataFrames.jl, the default entrypoint for spatial vector data in the JuliaGeo organisation. We discuss recent and planned updates, such as support for native drivers and metadata passthrough, but also spatial indexing and lazy reading of datasets in the cloud.

We present a Julia-based workflow for the analysis of exclusive multibody processes in collider data with the LHCb experiment. The pipeline covers ROOT I/O with UnROOT.jl, transformation of event data into tabular representations, construction of physics-motivated kinematic variables for multibody final states such as invariant masses and helicity angles, and statistical fitting. We also demonstrate reproducible analysis infrastructure in Julia, including composable scripts, environment and dependency management, artifact handling, and systematic reruns of the full analysis chain.

Graphical models encode dependencies between variables through graphs whose implied statistical models obey algebraic constraints. We show how symbolic computation in the Julia package OSCAR enables causal effect estimation in such models. Using Groebner basis elimination, we resolve linear parameter identification beyond classical criteria and demonstrate a reproducible Julia workflow on a real data example.

The Julia Registrator bot has been quietly running in the background, listening to registration comments and making PRs to the General registry. It is the de facto tool for Julia package registrations. Hi, my name is Nishanth. I am one of the core contributors to Registrator.jl and have been responsible for keeping the Registrator server operational ever since it was first deployed in 2019. In this talk, I would like to share with you all the internal details of Registrator server setup and configuration. The talk will cover:

• Registrator deployment process
• Configuration & GitHub settings
• Logging, Troubleshooting & Debugging
  This talk will be useful for contributors interested in helping out with development and maintenance. I hope this talk motivates more members of the community to contribute to Registrator for the years to come! Thank you!

I will present AlphaConformers, a Julia package to model alternative protein conformations using AlphaFold. This will showcase Julia as an incredible glue language for developing reproducible bioinformatics pipelines. In particular, we will focus on the use of JLL packages as a way to include versioned, cross-platform command-line tools. We will describe the current bioinformatics JLL ecosystem and show how developers in other languages can make their binaries available for Julia users.

Hyperparameter optimization is a core workflow in machine learning and scientific computing, yet the Julia ecosystem has lacked a mature, production-ready framework comparable to the robust, battle-tested tools available in other languages. In order to bridge this gap, we present Optuna.jl a package that brings the full functionality of Optuna (by Preferred Networks, Inc.), one of the most widely adopted hyperparameter optimization frameworks, into Julia.

I've been talking about this for the last two years - but GeometryOps.jl is now finally on the sphere! This talk will give a brief update about GeometryOps with a focus on how the spherical capabilities have materialized, both in native Julia and by calling Google's s2 library. We'll also mention some new cool downstream applications, like ConservativeRegridding.jl and SphericalSpatialTrees.jl, and specifically how they relate to GeometryOps.

The Large Enriched Germanium Experiment for Neutrinoless $\beta\beta$ Decay (LEGEND) experimental program is dedicated to the search for the neutrinoless double-beta ($0\nu\beta\beta$) decay of $^{76}\mathrm{Ge}$ with isotopically enriched high-purity germanium (HPGe) detectors and a discovery sensitivity beyond a half-life of $10^{28}$ years. The project's first phase, LEGEND-200, has stably accumulated physics data at the Laboratori Nazionali del Gran Sasso (LNGS). The first unblinding revealed a new best global limit of $T_{0\nu}^{1/2}>1.9\cdot{10}^{26}\, \mathrm{yr}$ (90% confidence level). We present an update on our ongoing end-to-end analysis of the experiment with the Julia LEGEND Software (JuLeS). This session will focus on the advancements of JuLeAna (Julia LEGEND Analysis) and its application to the current LEGEND data. Key subjects will include performance evaluation, data management, the GPU-accelerated Digital Signal Processing (DSP) framework, calibration and spectral fitting routines, event reconstruction, as well as IO performance. Additionally, we will provide a brief demonstration highlighting the enhancements within our customized SLURM-based parallel processing environment.

This work is supported by the U.S. DOE, and the NSF, the LANL, ORNL and LBNL LDRD programs; the European ERC and Horizon programs; the German DFG, BMBF, and MPG; the Italian INFN; the Polish NCN and MNiSW; the Czech MEYS; the Slovak RDA; the Swiss SNF; the UK STFC; the Canadian NSERC and CFI; the LNGS and SURF facilities.

In 1987, Eugenii Shustin published an article titled "A New M-Curve of Degree 8". This article contains the construction of a polynomial in two variables, whose set of zeros forms a so-called M-curve. In this talk, we will go into detail of the problems we encountered, when attempting to reproduce this construction using Oscar.jl in Julia.

JuliaSubtyping is a new implementation of Julia's core subtyping (and intersection / type-subtraction) algorithms. This talk will motivate the new implementation and explore the theory behind its operation.

Despite being built on complex theory (SAT solvers, QBF, and more), the new design attempts to be more performant and transparently correct than Julia's existing implementation, while also being straightforward to extend with new kinds of reasoning. At the heart of the design a "logical core" is combined with a "type logic" to form the basis of the algorithm and provides semantics rich enough to describe many interesting subtyping algorithms.

You can of course expect many challenges along the way. Every theoretician's favorite enemy (undecidability) will rear its head along our journey, along with other practical engineering trade-offs. We'll investigate performance and demonstrate how the new algorithm stands with respect to the old. Finally we'll speculate about what new types of compiler reasoning this kind of typing algorithm may one day support.

BaseModelica is a subset of the Modelica standard that defines a simpler and more portable intermediate representation of full Modelica models. BaseModelica.jl brings this standard to Julia, enabling models from industry-standard Modelica tools to be imported into the SciML ecosystem and used with its rich set of solvers and analysis tools.

Parametric linear matrix inequalities (LMIs) arise in optimization and control. A key question, motivated by the automation of convergence analysis of numerical optimization schemes, is to understand how their feasibility depends on parameters. In this talk, I present an approach that turns parametric LMI feasibility into parametric polynomial equations with constraints. The resulting parameter space can then be analyzed using real root classification based on Hermite's quadratic forms. I will show how this approach is implemented in Julia (notably Nemo.jl and AlgebraicSolving.jl, with real-geometry backends where appropriate), with efficient techniques such as multivariate rational interpolation. Finally, I will show that our implementation cleanly detects regions of parameter space where convergence properties change, for parametric LMIs arising from convergence analyses of first-order optimization methods.

Virtual Screening of phytocompounds in drug discovery has surged over the years. We present juDock, a ML-Driven dockerized Linux application built in Julia. juDock automates the pipeline from the preparation of ligands to the prediction of potential compounds for a specific protein integrating AutoDock Vina, RDKit and Scikit-Learn via PythonCall.jl and Genie.jl. Furthermore, juDock is an open source project attracting researchers to contribute using the established ML pipeline for various proteins.

Rigid registration seems like a simple task, on the first glance: If you have two objects, described as sets of points, how should you rotate and translate one to optimally match the other? However, it can be quite involved to do it reliably and efficiently. In this talk, I will present a new Julia package that provides a go-to solution to tackle not only rigid point cloud registration, but also non-rigid registration and other typical point cloud tasks.

Julia has demonstrated strong potential for high-performance scientific computing, and the JuliaHEP community is rapidly expanding across simulation and data analysis in high-energy, hadron, plasma, and nuclear physics. This moderated panel will discuss what comes next: how can we move beyond individual success stories and wrapping existing frameworks towards building a sustainable software ecosystem for these communities?
The discussion will address scaling challenges, the balance between integrating existing tools and developing native solutions, and the role of interoperability in established scientific software landscapes. Beyond technical aspects, the panel will explore opportunities for collaboration, community growth, and lowering barriers to adoption. The goal is to identify concrete next steps to strengthen JuliaHEP and support the wider use of the Julia programming language.

Parametric polynomial systems can be represented as dominant maps between irreducible algebraic varieties of the same dimension, where symmetries correspond to automorphisms of these maps. Galois, or monodromy, groups provide a numerical tool for detecting the existence of such symmetries in solution sets. A central computational challenge, however, is to recover explicit formulas for these automorphisms in order to better understand and more efficiently solve the systems. We combine numerical homotopy continuation with multivariate rational function interpolation to compute candidate symmetries, implemented in the Julia package DecomposingPolynomialSystems.jl.

For structured systems with many variables, such as minimal problems in computer vision, the resulting Vandermonde-like interpolation matrices become prohibitively large, leading to expensive nullspace computations and numerical instability. We address this by exploiting equivariance of minimal problems with respect to matrix Lie group actions. The interpolation space of bounded-degree polynomials decomposes into isotypic components as a representation of the Lie symmetry group, allowing a substantial reduction of the problem size. This representation-theoretic decomposition is implemented in the Julia package DecomposingGroupRepresentations.jl. Together, these tools provide a scalable Julia-based framework that integrates monodromy and computational representation theory to recover closed-form symmetries of polynomial systems.

Protein structure minimization is a crucial step before running molecular pipelines with the aim to arrive at the lowest potential energy conformation. We introduce a mini-batching strategy for ML-based optimization algorithms. Leveraging the unified framework of Optimization.jl, we present a study to systematically assess the performance of different optimization algorithms with our molecular modeling framework BiochemicalAlgorithms.jl. This work provides the framework for identifying optimal algorithms for refinement of protein structures.

What if using Plots, ModelingToolkit was instantaneous, the first time on a fresh Julia installation? What if your students, users, and/or colleagues could run a command to install something and then everything "just worked"? julia was never really good at this; we optimized the vanilla distribution for flexibility, which is somewhat at odds with a smooth first-time experience. But this flexibility doesn't fit everyone. We'll present a set of tools to curate Julia distributions for your specific user base, replacing some flexibility with a more reasonable green-path experience.

Heart rate time signals are one of the most readily available and cost effective biosignals for the study of human behavior. Their availability and ease of use make them ideal for open science. Many programming languages provide libraries that enable the manipulation of the time series generated by measuring the time in milliseconds between each heart beat: the Inter-Beat-Interval (IBI). However advanced functionality is only provided by private software, and many of opensource libraries seem to be designed as simple feature extraction libraries, and many have fallen into disuse. In this work we present the HeartRateLab: a new, powerful, and complete computational framework, written in julia, for the processing, analysis, modeling, and evaluation of human heart IBIs. The Julia language enables the ideal environment for explicit scientific management of operational, data-driven definitions of features used to define heart rate variability, and their physiological statistical relevance in several different domains.
With the use of Julia's rich and interconnected scientific modeling environment, and the open scientific community, the HeartRateLab enables the most complete set of processing functions for IBI timeseries. Complete sets of features can be extracted from entire recordings, or using resampling or rolling window approaches with the overpowered capabilities of the language. Using Julia's DifferentialEquations.jl, Turing.jl, and other scientific libraries, the HeartRateLab provides the tools for modeling complex systems, including data-driven models for parameter recovery.
The HeartRateLab showcases the stable complexity management environment that the Julia language and its community provide for scientific programming, while demonstrating intricate, applicable, but also very simple and embodied principles about the rhythms to which our hearts beat.

In this talk, we present the current state of our static DAG optimization and scheduling package ComputableDAGs.jl. The package allows to represent computations as static computational graphs. These graphs can be procedurally generated, automatically analyzed and optimized, and finally scheduled, and executed with no runtime overhead. The optimization can exploit domain specific knowledge about the computational problem, provided through meta information on the graph, without requiring an actual domain-specific language. Depending on available hardware, parts of the graph are automatically scheduled to accelerator devices if possible.
We present the current capabilities and design of the package, using a high-energy physics application as a case study. Furthermore, we report about ongoing challenges, and invite discussions about usability and improvements.

ATLAS is a global atmospheric chemistry and transport model with a focus on stratospheric chemistry, and in particular anthropogenic ozone depletion (the "ozone hole"). It was originally written in Matlab (starting in 2009) and has been rewritten in Julia in the last 5 years, resulting in a 10x speedup. We give an overview of the implementation and of the scientific results published in the last 15 years.

Structured light in interaction with matter has been of interest, particularly as it relates to the production of high intensity gamma beams. In our package, ElectronDynamicsModels.jl, we developed a way to efficiently compute the radiated field resulting from the scattering of a Laguerre-Gauss laser beam off a thin sheet of electrons. The electrons are represented as relativistic classical particles whose motion is integrated using DifferentialEquations.jl. ModellingToolkit.jl was used to formulate the model, allowing us to take advantage of its compiler to generate efficient Julia code. Moreover, this also enables an easy scaling to parallel ensemble simulations on the CPU and GPU. Besides performance, this approach is also useful for enabling higher precision computations, which naturally leverage Julia's multiple dispatch. Once the trajectories are known, the far electromagnetic field can be computed over a grid of pixels from the Lienardt-Wiechert potentials, and finally we compute their Fourier transform.

We introduce Corleone.jl, a package for solving optimization problems related to dynamic processes. It aims at leveraging the full SciML ecosystem to model, integrate, and solve the resulting nonlinear optimization problem. We showcase Corleone's integration inside scientific machine learning, how it can be used via ModelingToolkit, and recent results from academic and industrial use cases.

The snow cover plays a central role in many Earth system processes, for example influencing climate feed-back, the hydrological cycle, as well as glacier and ice sheet mass balance. Widely used snow cover models such as SNOWPACK (C++) and Crocus (Fortran) show strong performance in operational forecasting and scientific modeling. However, their still tightly entangled code bases make it difficult for the community to modify model components efficiently. This is due to technical dept as well as limitations of the programming languages itself. Recent advances in snow physics parameterizations have highlighted structural limitations in those models, underscoring the need for a more flexible modelling framework.

To address these challenges, we present Helmut, a modular snow cover model implemented in Julia. Helmut combines a state‑of‑the‑art snow process equation solver within a design that emphasizes flexibility, and quick experimentation. Julia’s multiple dispatch allows Helmut users to extend or replace individual components—such as parameterizations, boundary‑conditions, or physical process formulations - efficiently. This enables domain scientists to contribute easily and test new advances with minimal friction.

Helmut successfully reproduces simulations from existing snow models while offering a much more accessible framework for modifying model physics, testing new parameterizations, and experimenting with alternative numerical formulations. We further demonstrate how the structure enables exploration of the impacts of different parameterizations and physical configurations, making such investigations considerably easier.

Matching the swimming efficiency and agility of fish has remained an elusive goal in underwater robotics — one that demands accurate simulation of complex vortex interactions between a robot's body and the surrounding fluid. These dynamics, governed by coupled ordinary and partial differential equations, pose far greater computational challenges than the multi-body dynamics of classical rigid robotic systems.

We present Aquarium 2.0, a Julia framework for simulating strongly coupled fluid-robot multiphysics as a unified optimization problem. The coupled manipulator and incompressible Navier-Stokes equations are derived together from a single Lagrangian using the principle of least action, and we employ discrete variational mechanics to obtain a stable, well-conditioned, and physically accurate scheme for jointly simulating articulated bodies and their surrounding fluid. Derivatives of the fully coupled dynamics are computed via the implicit function theorem, making the simulator directly amenable to gradient-based optimization within Julia's scientific computing ecosystem.

We showcase various swimming demonstrations of a bioinspired swimming robot, including forward undulation and a highly dynamic, optimized C-start escape maneuver. Both gaits are validated on physical hardware, demonstrating successful sim-to-real transfer.

Macroeconomic debt cycles evolve over time through interacting growth, inflation, and fiscal pressures. This study compares India, Sri Lanka, and Argentina using Physics-Informed Neural Networks (PINNs) and Universal Differential Equations (UDEs) to model continuous economic dynamics. By embedding economic structure into neural differential systems, we evaluate their ability to reconstruct national macroeconomic trajectories under sparse annual data conditions.

PinCFlow.jl is a fully Julia-based idealized atmospheric flow solver, primarily developed for gravity wave research. The model is highly efficient and integrates the Boussinesq, pseudo-incompressible, and compressible equations over arbitrary topography. Either high-resolution, wave-resolving simulations can be conducted, or simulations with parameterized gravity waves using the parameterization scheme MS-GWaM, where both transience and horizontal propagation of gravity waves are accounted for.

How do you run Julia programs on a machine that is not your own, a machine that is not the one where program was originally developed on? This simple question leads to a surprising array of opinions and options. In this talk, I present some of the hard earned lessons from over a decade of deploying Julia applications to production services.

Radiomic features extracted from medical images are fundamental for computer-aided diagnosis and treatment planning.
Radiomics.jl is a new, pure-Julia open-source library for high-performance extraction of quantitative imaging biomarkers.
Developed across multiple international institutions, it provides an efficient and scalable workflow by leveraging Julia’s speed.
The library ensures seamless integration with machine learning pipelines for advanced clinical research and precision medicine.

Reseau.jl is a modern, pure Julia IO package that provides platform-native primitives for multithreaded event loops, unified socket interfaces, and TLS. It can be a drop-in replacement for the Sockets stdlib while providing a breadth of functionality and native platform integration (apple, linux, windows) for TLS mechanisms and trust stores. The async IO primitives can serve as foundational building blocks for a number of higher-layer application protocols, all in a multithread-friendly, performant package.

Physical effects in oceans span a vast range of both temporal and spatial scales, making it difficult to ensure that a single numerical model resolves all relevant processes within realistic computational limits. To capture effects that occur outside of the resolved scales, models need to include parameterizations that approximate the missing physics. In this work, we explore the use of online learning for parameterizations in a Julia based shallow water model.

Here we use ShallowWaters.jl, a single layer ocean model, to test the capabilities of online learning for eddy backscatter parameterizations. Backscatter parameterizations represent the influence of geostrophic eddies, small-scale turbulent processes that play a large role in ocean energy dynamics. In particular, eddies facilitate the transfer of kinetic energy from small to large scales, an essential process for general ocean circulation. In the online learning framework our backscatter parameterization is given by a neural network (NN), converting ShallowWaters into a hybrid ocean model based on both physics and machine learning. To train the NN parameterization to capture sub-grid scale physics we use data assimilation techniques, and in particular this relies on the automatic differentiation (AD) tool Enzyme.jl to compute full-model gradients. This further expands ShallowWaters to be a fully differentiable shallow water model. Different loss functions are implemented, both spectral and state, to determine which most effectively improves the parameterization, and the resulting NN parameterizations are compared to an equation-discovery closure. This work expands on prior online learning research and further advances hybrid approaches for gradient-based model calibration in comprehensive, differentiable, ocean general circulation models.

FewBodyToolkit.jl is a Julia package for solving quantum few-body problems with two and three particles in one to three dimensions. It supports pair interactions of general shape, bound and resonant states, and on-the-fly calculation of observables. The package has been applied in research on ultracold atomic systems and hadron physics, providing a unified framework for diverse few-body applications.

Decisions often affect the dynamics of a system. DecisionSystem is a unified way of capturing both dynamics and decisions of complex systems.
Real systems don't just evolve, they respond. DecisionSystems is a unified way of capturing physics simulation and decision-making, letting you model the full cycle: simulate dynamics, observe state, decide, act, repeat.

When snow falls, the landscape transforms into a sparkling white marvel. Beyond its beauty, snow is essential to human sustenance across large regions: it replenishes drinking water supplies, moderates our planet's temperature, drives hydropower production, and feeds irrigation systems. Yet snow also brings hazards. Avalanches pose a persistent threat in mountainous terrain, rapid snowmelt combined with heavy rainfall can trigger devastating floods, and intense snowfall events regularly disrupt road and air traffic at considerable economic cost. Preparing effectively for such events demands reliable forecasts of snow conditions. In Switzerland, where a substantial fraction of precipitation falls as snow, the WSL Institute for Snow and Avalanche Research (SLF) provides such forecasts using a physics-based snow modelling system recently implemented in the Julia programming language. These forecasts support avalanche and flood forecasting as well as weather-related hazard alerts. Our model is also used across a range of research projects, including efforts to improve inflow forecasts for Norwegian hydropower reservoirs and to better characterize snow dynamics on glaciers in high-mountain regions. Here, we present a brief overview of the operational use cases of this newly developed system alongside its research applications, together with a more detailed account of our technical implementation and the challenges encountered so far. We welcome feedback on our technical implementation and are eager to explore potential collaborations in which the model could be coupled with other Earth system models.

Medical image reconstruction for modalities such as magnetic resonance imaging (MRI) and magnetic particle imaging (MPI) involves solving computationally intensive inverse problems. The MRIReco.jl and MPIReco.jl reconstruction packages feature a shared, modular optimisation backend that provides efficient and reusable solvers for various imaging modalities. In this talk, I will present how we extended this backend with vendor-agnostic GPU acceleration, which enables efficient reconstruction across both different imaging modalities and different GPU backends.

Lattice QCD simulations are restricted by both massive computational costs and high memory requirements. To simulate large physical volumes, distributing the lattice across multiple GPUs is essential. We present JuliaQCD, a native Julia ecosystem designed for computations on HPCs. By integrating JACC.jl for vendor-neutral GPU kernels and MPI.jl for lattice decomposition, we enable simulations on lattices that exceed the memory capacity of a single device while maintaining high performance.

Automatic Differentiation (AD) methods present an efficient way for computing function derivatives, however the sheer amount of the implemented methods can be overwhelming.
Chosing the correct method for the task can have crucial impact on the performance[1], hence understanding the differences between them and their use cases is beneficial.

Traditionally, climate models are difficult to run for end users, and even harder to customize or interface with machine learning. We want to change that. Here, we present the ongoing development of SpeedyWeather.jl: A general circulation model that’s differentiable, GPU-capable and ready for machine learning integration. SpeedyWeather.jl is a spectral atmospheric general circulation model with an everything-flexible attitude. In this talk, we will give an overview of SpeedyWeather.jl’s development of the last year, in which we worked towards differentiability with Enzyme, GPU-capability with KernelAbstractions and Reactant and rewrote our parametrizations for better performance and more customisability.

Lattice Quantum Chromodynamics (Lattice QCD) is a first-principles approach to strongly interacting gauge theories and requires large-scale high-performance computing. Production codes in this field have traditionally been written in C, C++, or Fortran.
JuliaQCD is a Lattice QCD simulation framework written entirely in Julia, developed to explore whether a high-level language can support both rapid development and large-scale HPC simulations. The framework provides distributed-memory parallelism via MPI and achieves competitive performance on modern CPUs and GPUs while keeping lattice field operations and data structures modular and expressive through multiple dispatch.
In our recent work [1], we extend JuliaQCD by introducing compiler-level reverse-mode automatic differentiation for the first time. Using LLVM-based AD, Hybrid Monte Carlo (HMC) force terms are generated directly from the action code, removing the need for separately derived and manually maintained force implementations. We validate the correctness of the automatically generated forces and examine their performance relative to conventional hand-written implementations.
This work demonstrates how Julia can support both conventional HPC-style implementations and more modern compiler-based techniques within a single, coherent framework for large-scale scientific computing.
[1] Yuki Nagai, Akio Tomiya, Hiroshi Ohno, "Lattice Gauge Theory via LLVM-Level Automatic Differentiation", arXiv:2602.20516

Type-piracy is often said to be "defining foreign behavior over foreign types".

Sounds intuitive, but in practice things get complicated quickly: A basic type like ForeignType{Float64} may be "obviously foreign", but how do we extend that notion to Julia's full type language including Union and where? Are all forms of type-piracy equally bad, or is "type-privateering" a thing? Most importantly, how does this affect your code in practice?

This talk will attempt to construct a mathematically precise definition for the "essence" of type-piracy. We'll discuss how determining type-piracy might be automated and what it would mean to make this a "first-class" restriction in Julia. Do we lose expressivity, gain performance? What designs would this affect in practice?

Along the way, we'll examine cases of "type-piracy in the wild" in the community (and even in Julia's own standard libraries!). These controversial case studies will serve as a litmus test to see if we can conquer the type seas, or if the age of the type-privateer continues.

Magnetic fields are vital in numerous applications, including the medical imaging modality magnetic particle imaging, where field-related artifacts affect image quality. A good approximation of these fields is essential and can be done via spherical harmonic expansions derived from calibration measurements. The Julia package SphericalHarmonicExpansions.jl facilitates representation, transformations, and fast numerical evaluation, providing efficient tools for accurate magnetic field analysis.

The cut norm of a matrix measures the largest imbalance, given by the maximum absolute sum of its entries over any choice of row and column subsets. Computing this norm amounts to a combinatorial optimization problem that is NP-hard. It originates in graph theory and it plays a central role in the theory of graph limits, where it defines a notion of distance between large networks.

We first present an integer program, modeled in JuMP.jl, and highlight the limitations in scalability. We then introduce a heuristic based on repeatedly solving a bilinear relaxation of the cut norm problem. Along the way, we utilize NLPModels.jl to efficiently represent the problem and solve the resulting nonlinear program using TRON from JSOSolvers.jl. To explore the solution space effectively, we employ a multi-start strategy initialized via a Sobol sequence generated with Sobol.jl.

Through benchmarks, we show that the heuristic recovers optimal solutions on small instances and scales to significantly larger matrices than the exact formulation. We also illustrate how the algorithm can be used in the context of graph limit theory to measure the distance between large networks.

Chaotic neural dynamics resist equation discovery because parameter sensitivity creates intractable optimization landscapes. Using the SciML ecosystem, we combine prediction-error methods with universal differential equations (PEM-UDE) and multiple shooting to tame chaos during learning. In spiking networks, we derive novel mean-field equations for sparse cortical connectivity that predict frequency shifts and synchrony patterns, validated by intracranial recordings.

The Antarctic and Greenland Ice Sheets have experienced significant volume loss over the last decades, with a contribution of 0.1 m to sea-level rise that is bound to become significantly larger over the coming millennia. Under high-emission scenarios, they could contribute by as much as 18 mSLE by the year 3000, with dramatic consequences for coastal livelihood. Ice-sheet models are the central tool to produce such projections but generally present many limitations: they are not easily extensible by the user, they are difficult to couple to other Earth System model components, they lack interactivity and easy visualisation, they are sparsely documented, and they are often incompatible with modern software and hardware advancements, like automatic differentiation and GPU computing. To address this, we develop Pagos.jl, a continental ice-sheet model written in Julia that follows the philosophy paved by Oceananigans.jl and SpeedyWeather.jl: running simulations should be as easy and fun as playing Lego. Besides reducing the time to first plot compared to traditional models, this also offers a privileged framework to develop and test new physics and parameterisations. The user-friendliness of Pagos.jl allows a simple coupling to other Earth System model components and goes hand in hand with its computational efficiency. This allows the user to run simulations at the continental scale with resolutions of a few kilometres and address important scientific questions around grounding-line dynamics.

In MRI, radiofrequency (RF) pulses steer spins and shape the signal they produce. In this talk, I will show how we used RF pulses to “draw” the Julia logo inside a water bottle using a real MRI scanner. Behind this demo is a faster approach to RF-pulse design. By combining reverse-mode automatic differentiation (AD) with GPU-accelerated MRI simulations, we reduced a 2D RF-pulse optimization from ~10 minutes to ~1 second, making subject-specific RF design clinically feasible for applications such as imaging near metal and fat suppression.

ConvolutionInterpolations.jl offers methods for high-order interpolation, differentiation, integration and smoothing on discrete grids. Query times are similar to those of popular Julia packages for interpolation. Grids can be uniform, non-uniform, or a mixture. Supports mixed per-dimension interpolation, differentiation and integration. Extends naturally to multi-dimensional applications.

Global land surface and hydrological models are crucial components of Earth System Models (ESMs). In addition to providing realistic boundary conditions for the atmosphere and ocean components, they also play a key role in understanding Earth’s changing energy imbalance and the response of the terrestrial carbon and water cycles to anthropogenic climate change. Unlike atmosphere and ocean models, however, land models lack a fluid dynamical core and rely heavily on empirical parameterizations to represent many key processes. As such, there is a continued need for a new generation of land models which can facilitate the incorporation of data-driven components. Here we present Terrarium.jl, a Julia-based land modeling framework for GPU-accelerated and automatically differentiable simulations of soil, snow, and vegetation dynamics, along with their corresponding land-atmosphere exchange fluxes. We highlight how Julia’s key features enable unprecedented modularity in the model design and seamless GPU parallelization through KernelAbstractions.jl. We further demonstrate the value of GPU acceleration and differentiability through a series of performance benchmarks and sensitivity analyses. We also detail our initial experiments in achieving stable coupling to a reduced-complexity atmosphere model, SpeedyWeather.jl.

I rebuilt my PhD ray-tracing code for higher-dimensional black objects from MATLAB to Julia, resolving numerical issues and achieving major performance gains. Julia’s language features and ecosystem let me simplify the architecture, improve performance, and achieve previously inaccessible results. I’ll show key techniques and performance tricks that made the rewrite both faster and cleaner.

This talk presents recent advances in efficient boundary value problem solving within the SciML ecosystem, focusing on extending collocation-based and nonlinear programming formulations implemented in BoundaryValueDiffEq.jl. We demonstrate how BVPs can be reformulated as structured optimization problems, enabling seamless integration with SciML’s differentiable programming stack and modern optimization tools. Building on this perspective, we introduce strategies for improving performance and scalability, including structure-aware discretizations, GPU-parallel ensemble solving, and algorithmic techniques that bridge differential equation solvers with optimal control and dynamical optimization pipelines. We further show how these methods enable new application workflows, where differential equations, parameter estimation, and optimal control problems are solved within a unified composable framework.

TrixiAtmo.jl is there: a Trixi.jl spin-off, bringing Discontinuous Galerkin methods and Adaptive Mesh Refinement to Earth system modeling. We aim at kilometer-scale resolutions to resolve key physical processes and address historical stability concerns using entropy-conserving split-forms. Currently, we are on our way to extend TrixiAtmo.jl to handle realistic applications, and integrate with Julia's rich geoscience ecosystem.

The Carpentries is a nonprofit organization that teaches software engineering and data science skills to researchers worldwide through hands-on workshops.

Since 2021, I have maintained a Carpentries Incubator lesson focused on teaching Julia, which I also integrate into my university courses. In this talk, I will talk about strengths and weaknesses of the current lesson design as well as presenting a new different lesson. I will also highlight opportunities for the Julia community to participate in collaborative lesson development.

Lattice QCD is one of the most computationally demanding problems in theoretical physics, requiring large-scale parallel computation and sophisticated numerical algorithms.
JuliaQCD is an open-source project that implements lattice QCD simulations in Julia, with an emphasis on performance portability across different computer architectures. By leveraging Julia’s abstraction mechanisms and multiple dispatch, the framework enables rapid prototyping, flexible algorithm development, and high-performance execution on a wide range of computing platforms.
In this project, we focus on the domain-wall fermion formulation and construct a numerical optimization framework to tune its free parameters by minimizing selected physical observables, such as the effective mass. We discuss how this approach can be implemented efficiently within the JuliaQCD code base while maintaining readability and flexibility of the code.
To enable large-scale simulations, we employ MPI-based parallelization and demonstrate production runs on the Fugaku supercomputer, where Julia is not pre-installed. We address practical challenges of deploying Julia on such systems, including building the Julia runtime, integrating with the system MPI libraries, and preparing job scripts and execution environments.
We will present the physical motivation, software architecture, implementation strategies on Fugaku and related HPC systems, scaling and performance results for domain-wall fermions, and plans for the open-source release of these developments within JuliaQCD.

In this talk we will present how DyadModelOptimizer is solving free final time problems using ModelingToolkit, BoundaryValueDiffEq and OptimizationMadNLP, showing the full julia stack that powers the Dyad analyses. Specifically we examine the solution in the context of minimum lap time optimization for a race car. The solution assumes a continuous lap optimizing throttle and braking under dynamical constraints.  We formulate the problem as a nonlinear optimal control problem with free terminal time, where the objective is to minimize total lap time subject to coupled vehicle dynamics, tire force limits, and path constraints along a prescribed track centerline. The vehicle model captures longitudinal and lateral dynamics, load transfer effects, and tire saturation through nonlinear algebraic relationships, resulting in a differential-algebraic system expressed symbolically. The talk walks through the entire process end to end: building the symbolic model, converting it into a boundary value formulation, choosing a discretization strategy, assembling the nonlinear program, and configuring the solver. We will also share practical lessons on mesh refinement, scaling for numerical stability, and what solve times and convergence actually look like in practice.

The SINDBAD framework, with Sindbad.jl, SindbadTEM, OmniTools.jl, TimeSamplers.jl, and ErrorMetrics.jl packages offers a user‑friendly, Julia‑based system for terrestrial model–data integration. It enables scalable, differentiable experiments across spatial and temporal scales, supporting next‑generation understanding of vegetation–water–carbon interactions.

This talk considers the features Julia includes, and more importantly, omits, in service of a speedier implementation, as well as how the language might grow in the future.

As JuliaHealth continues to expand, maintaining clarity and reliability across packages becomes essential. Supported by a NumFOCUS Small Development Grant, this project advances three goals: attracting new contributors, highlighting JuliaHealth workflows, and strengthening ecosystem robustness. A reproducible audit of documentation and CI pipelines led to repository improvements, website updates, structured workflow examples and modernized documentation deployment.

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.

JustRelax.jl (de Montserrat et al., (2026)) is an open-source, highly portable, and high-performance package designed for geodynamic modeling. It employs the Accelerated Pseudo-Transient (APT) method to solve the Stokes and diffusion equations, making it well-suited to exploit Graphics Processing Units (GPUs). It incorporates a wide range of features critical to computational geodynamics, including complex and highly non-linear rheologies, free surface, and a particle-in-cell method to advect material information.

Open-source software (OSS) is a practical way to ensure reproducibility and avoid reinventing the wheel in computational physics. In particular, few-body systems physics has various targets and various software requirements, so we are building an open-source ecosystem in Julia as a shared infrastructure with reusability and extensibility. In this talk, we introduce the architectural design and development roadmap derived from system-level testability and report the current development status.

Scientific modeling often forces a choice between flexible but opaque neural networks and interpretable process-based models that can be too rigid for real-world data. Hybrid modeling bridges this gap by combining mechanistic structure with machine-learning flexibility. In this talk we introduce EasyHybrid.jl, a user-friendly Julia package that makes hybrid modeling accessible across disciplines. We demonstrate the approach on a concrete problem: partitioning eddy-covariance net carbon fluxes into photosynthesis (a CO₂ sink) and ecosystem respiration (a CO₂ source), while estimating how strongly respiration responds to temperature. Temperature sensitivity is summarized by Q10, the factor by which respiration changes for a 10 K warming (e.g., Q10 = 2 means doubles per 10 K). We present cross-site results across hundreds of FLUXNET eddy covariance towers and show that, even when inferred jointly with hybrid flux partitioning, the learned temperature sensitivity exhibits a relatively narrow convergence across ecosystems.

Static analysis for Julia is still an underdeveloped domain. The linting ecosystem is looking especially barren – practically one package is used for writing and running linting rules, StaticLint, even though it is difficult to extend with new rules or features. ReLint was built to address some of StaticLint's limitations, improving upon extensibility and interoperability. However, it too suffers from shortcomings, especially in terms of flexibility. Argus, mainly a pattern matching framework for Julia syntax, offers a powerful and expressive language for writing code patterns and linting rules. This presentation shows the result of combining ReLint and Argus into a new version of ReLint that provides a built-in set of rules, a DSL for extending the default set with custom rules and CI/CD integration.

This talk discusses two complementary directions in scientific machine learning for geophysics. The first uses DeepONet surrogates to accelerate magnetotelluric forward modelling and transdimensional probabilistic inversion, making uncertainty analysis more practical. The second uses implicit neural representations for three-dimensional gravity inversion, where the subsurface model is learned under physics-based machine learning.

MovingBoundaryMinerals.jl (Stroh et al., 2025) is a Finite Element package to model diffusion-limited growth. The package combines grid refinement together with a moving boundary in order to resolve sharp gradients next to the interface of growing crystals. The moving boundary is treated via a thermodynamically-consistent diffusion solver. We provide benchmarks and examples that can be used in petrology and materials science.

In order to improve the tooling around --trim, we've developed JuliaC.jl. It's a package similar to PackageCompiler, but with a focus on bundling trimming applications.
It has features like bundling, setting rpaths and more interestingly. Privatization, allowing a JuliaC library to be loaded by Julia

Since 2020, the JuliaHealth community has experienced steady growth. This talk will highlight the continued development of the JuliaHealth ecosystem, reflecting on where the community has been, where it is today, and where it is headed.

BestieTemplate.jl is a template for creating packages following opinionated package development practices, first presented at JuliaCon 2024. This time, I'll talk about what has changed since then and try to attract some collaborators by talking about the process of adding a new question.

Hybrid climate modelling combines numerical models with machine-learned components. We present the development of multiple machine-learned surface climate processes and their integration into the climate model SpeedyWeather.jl using PyTorch and Lux.jl. Despite the offline training, the hybrid model is designed to generalise in space and to different climates. We address speed vs. accuracy tradeoffs using SymbolicRegression.jl and discuss online learning with Enzyme.jl.

Inside atomic nuclei, "empty space" is not empty: the strong force comes from a gluon field that fluctuates and binds quarks into protons and neutrons. Lattice QCD computes this by simulating QCD on a grid in space and time, usually on supercomputers. VisualizingQCD.jl, a JuliaQCD package, turns your own configuration files into 3D movies of local observables, so Julia users can see, debug, and share the quantum vacuum.

Symbolic computation is inherently very dynamic. It needs to support representing arbitrary function calls, on arbitrary symbolic types. Older versions of Symbolics.jl and SymbolicUtils.jl were notoriously type-unstable. This talk goes over the methods used and challenges involved in making the latest major versions of those packages type-stable and precompilation-friendly. The techniques and insights discussed are generally applicable to other packages as well.

We’ll explore the interoperability of the Go programming language and Julia, from the angle of filling Julia’s capability gaps in Julia’s web and networking stacks by calling out to Go. The talk is based on the experience of leveraging Go’s gRPC client library within a Julia-based web server, and will focus on the nuances of the interoperability of the languages (e.g. how to pass data between the languages, handling Go’s asynchronous programming features, garbage collector).

RayTraceHeatTransfer.jl is a package for thermal radiation heat transfer calculations in Julia. The package features new methods which guarantee energy conservation and physically correct results, across the wavelength spectrum and for user-specified domains. In 1D and 2D the package handles volumetric radiation, relevant in combustion, climate sciences and astrophysics and in 3D it handles surface radiation, relevant in engineering design.

There are hundreds of ODE solvers in DifferentialEquations.jl. Which is the best one for your problem? In this talk we go through the many classes and types of solvers and build a map to help you understand when to use various choices. We start by highlighting the basics, the core solvers that tend to do well for all problems, and then start to showcase more specialized methods and detail when they are likely to be improvements.

Black holes were once thought to be unobservable. In 2019, the Event Horizon Telescope (EHT) changed that by producing the first horizon-scale image of M87*. That breakthrough was not only an achievement in astronomy, but also in scientific computing: every step, from building a planet-sized telescope to reconstructing the final image, depended on extensive computation. In this talk, I will show how Julia is helping push black hole imaging into its next era. Its combination of speed, flexibility, and composability has made it a core part of the EHT software stack, powering modern workflows for imaging, modeling, and uncertainty quantification. Julia is also helping define the future of black hole astronomy. The Black Hole Explorer (BHEX), a NASA space mission concept, aims to produce the highest-resolution images of black holes ever made, resolving regions of spacetime where light can orbit the black hole itself. In the final part of the talk, I will highlight how Julia will form the foundation of the BHEX analysis pipeline and demonstrate its potential as the primary software platform for a next-generation scientific instrument.

Sponsor Talk from Aeolus Labs by Mason Lee from Aeolus Labs.

Quantum computing progress depends as much on software as on hardware. In this keynote, we’ll start with a practical view of how high-quality code supports the development and use of quantum devices—through simulation, compilation, verification, benchmarking, and control. We'll also stress the value of state of the art classical methods to delineate where a quantum computer is genuinely required, versus where well-designed classical software is the right (and often faster) choice. We will then zoom in on PauliPropagation.jl, a Julia package we have been developing for efficiently simulating quantum circuits. We will outline the core abstractions and implementation details in the package, and what problems it is meant to make easy. A central thread will be "why Julia". Beyond performance, Julia lets us offer a fully extensible package with custom gates, data structures, and evolving types. We’ll end with an honest account of building Julia tools as a scientist: what has worked well, what has been surprisingly hard, and what we have learned about presenting research software to a community that often defaults to Python expectations.

We will do a deep dive how we modernized the core of the language server with an incremental computation engine, multi environment support and runtime analysis features. We will also highlight how these features are now easily exposed to command line and other users. Furthermore, we will introduce the new test item runner system that supports efficient parallel test execution and integrates into various workflows.

The BioJulia organization began as Bio.jl circa January 2014 (julia v0.2 era) and has grown into a loosely organized collection of packages for computational biology, from plotting protein structures (BioMakie.jl) to performing matrix manipulations on single-cell RNA sequencing data (SingleCellProjections.jl) to low-level biological file type I/O (Automa.jl, FASTX.jl, XAM.jl). Here, we will provide a brief history of the Org and recent efforts to provide more structure for the community, as well as growth areas and a vision for the future.

Following the initial presentation of the package RealTimeAudioDiffEq.jl, we present a use case demonstrating how the package is used to control a saxophone model in real time with a custom interface. This interface consists of a regular saxophone mouthpiece instrumented with sensors, and the whole setup serves as a basis for virtual instrument design in Julia, as well as for studying instrument behavior and/or player actions in performance situations.

We present an approach for building a Reactant backend for ParallelStencil, a Julia package for high-performance stencil computations. The approach includes the generation of kernel code and data structures that are pre-optimized to serve as optimal input for Reactant to generate efficient and correct GPU, TPU, and CPU code. We report performance of representative stencil mini-apps on recent hardware platforms, including NVIDIA H100 GPUs, evaluate it in absolute terms, and compare it with performance obtained with straightforward implementations using CUDA.jl, KernelAbstractions.jl, and other Julia packages that enable explicit GPU kernel programming.

Basic computer arithmetic operations, such as +, ×, or ÷ are correctly rounded, whilst mathematical functions such as ex, ln(x), or sin(x) in general are not, meaning that separate implementations may provide different results when presented with an exact same input, and that their accuracy may differ. We present a methodology and a software tool that is suited for exhaustive and non-exhaustive testing of mathematical functions of Julia in various floating-point formats. The software tool is useful to the users of Julia, to quantise the level of accuracy of the mathematical functions and interpret possible effects of errors on their scientific computation codes that depend on these functions. It is also useful to the developers and maintainers of the functions in Julia Base, to test the modifications to existing functions and to test the accuracy of new functions. The software (a test bench) is designed to be easy to set up for running the accuracy tests in automatic regression testing. Our focus is to provide software that is user friendly and allows to avoid the need for specialised knowledge of floating-point arithmetic or the workings of mathematical functions; users only need to supply a list of formats, choose the rounding modes, and specify the input space search strategies based on how long they can afford the testing to run. We have utilized the test bench to determine the errors of a subset of mathematical functions in the latest version of Julia, for binary16, binary32, and binary64 IEEE 754 floating-point formats, and found 0.49 to 0.51ULPs in binary16, and 0.5 to 2.4ULPs of error in binary32 and binary64. The functions that may be correctly rounded (error of 0.5ULP) in all the three formats are sqrt and cbrt. The following functions may be correctly rounded only for binary16: sinh, asin, cospi, sinpi, atanh, log2, tanh.

Julia is a fantastic language for bioinformatics. But why? What about bioinformatics makes Julia so suitable? On which bioinformatics problems have Julians focused their efforts to far? And if Julia is so useful for bioinformatics, why isn't it more popular? This talk presents the state of affairs of programming in modern bioinformatics and where Julia fits into that.

Turing.jl, a probabilistic programming language, has been undergoing rapid development towards a v1.0 release.

Many new features, fixes, and improvements will have been visible to users — but arguably the most important things I've learnt are not about code!

In this talk I'll reflect on what it’s really like to work on open source software, contextualised throughout with recent examples from Turing.jl’s codebase.

The first time you implement lowering, it takes parsed code, expands macros, and compiles it to linear, untyped IR. But then you get users. Users have questions like "can I figure out what code this IR came from so I can make essential tools like Revise.jl?" and "can we write macros without so much manual escaping?" and "why are errors after lowering so cryptic?" and "not a question, but Revise works now because I've written a program that correctly reverses lowering about 80% of the time."

This talk is about the second time you implement lowering.

"Practical Artificial Intelligence in Julia: Build Neural Networks, Genetic Algorithms, and Neuroevolution From Scratch" is a new book published by APress and Springer.

The book is divided into three parts:

• Neural networks are a technique inspired by a simplification of neurons in the brain. Neural networks are useful for identifying complex patterns, classifying data, and predicting outcomes.
• Genetic Algorithms are a computational metaphor for the biological evolution of species, inspired by the Darwinian principles. Genetic algorithms are useful for finding near-optimal solutions to complex, large-scale, and non-linear optimization and search problems.
• Neuroevolution is a combination of the two previous parts: a genetic algorithm evolves a neural network. Neural networks produced by Neuroevolution can solve complex problems without being trained using gradient-based methods.

This talk gives a highlight of these techniques and will demonstrate several applications using the Julia REPL, in particular:

• evolution of an artificial organism able to walk and climb;
• building an artificial player for a Mario Bros-like game;

The talk aims to showcase innovative machine learning techniques and applications within the Julia ecosystem.

Chmy.jl is a Julia package for developing scalable, architecture-agnostic finite-difference codes. It provides modules for structured staggered grids, differential and interpolation operators, and boundary conditions. Chmy.jl v0.2 introduces functionality for expressing equations in a coordinate-independent tensor form and automatically generating kernels from lists of expressions, with kernel reordering and fusion to maximise memory throughput.

We present recently developed iterative methods for approximating matrices and tensors with structural constraints such as rank and sparsity level and pattern, extending to settings where data is incomplete or indirectly observed, with or without noise. These methods aim to solve canonical problems of numerical (multi-)linear algebra, namely approximate matrix inversion and low-rank matrix and tensor approximation, when structural constraints are imposed on the approximation. While the presented results revolve around aspects of sparsity, if time permits, we extend the presentation to other structural features such as non-negativity. We also present how this work contributes to the ongoing development of the repositories ApproximateMatrixInverses.jl, StructuredLowRankMatrices.jl, and StructuredLowRankTensors.jl.

Despite being a high-performance language, Julia's I/O functionality has been designed for convenience, and is neither robust nor efficient. I present an alternate I/O interface in BufferIO.jl, which has more well-defined semantics, and permits low level, high performance I/O operations.

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.

Protein-DNA binding can depend on sequence changes even outside direct complex contact regions. While an MD-based protocol can capture this indirect readout with high correlation to experiment, its cost limits large-scale use. We present a Julia package to estimate DNA deformation free energies with practical analytical models optimized from simulation trajectories. These models aim to explain these affinity differences at much lower cost, enabling broader screening or sequence optimization.

EEG topoplots are a central visualization tool in computational neuroscience and biological signal analysis. However, they typically display only mean effects while omitting uncertainty arising from subjects, trials, and model variability. Our qualitative user study with domain experts shows that researchers consider uncertainty visualization essential for interpretation, yet report lacking appropriate tools and established methods to implement it in practice.

In this talk, I present ten uncertainty visualization prototypes developed in UnfoldMakie, a Julia-based ecosystem for regression-based EEG analysis. Several approaches, such as bivariate and value-suppressing topoplots, introduce entirely new visualization strategies. Some are already available, while others are in active development.

We are currently conducting a quantitative user study to systematically assess which of these plots most effectively support accuracy and interpretability in typical EEG analysis tasks. By empirically comparing these designs, we aim to identify best practices rather than proposing yet another visualization variant.

As tool developers, we argue that enabling appropriate uncertainty representations is a responsibility: without accessible methods, researchers lack the means to communicate variability, which directly impacts research integrity and reproducibility in computational biology.

Caenorhabditis elegans, a small roundworm, is widely used as a model for studying how cells and tissues develop and function. Using a form of light‑sheet imaging that records the embryo from two views (dual‑view selective plane illumination microscopy, diSPIM), we capture three‑dimensional movies of late embryogenesis. From these data, we build a smooth, time‑resolved anatomical model of the embryo’s surface and interior. We first mark a set of easily identifiable “seam” cells along the body wall and fit a flexible mesh to the organism’s surface. To ensure continuity and accuracy, we represent shapes and motions with smooth curves and periodic functions (natural cubic B‑splines and Fourier series), which provide robust interpolation across space and time. We also developed Julia‑based software that “untwists” each worm by transforming the 3D mesh into a cylindrical coordinate system centered on the embryo’s anterior–posterior axis. Individual models are then averaged over time and registered to a shared coordinate frame to create a common reference. Positions of tracked, fluorescently labeled cells can be mapped into this reference, yielding a four‑dimensional (3D + time) cellular atlas of C. elegans embryogenesis. When combined with single‑cell transcriptomics, the atlas can support spatially and temporally resolved maps of gene expression during development. Overall, these tools provide a flexible and accurate modeling framework with fast runtimes that enable rapid analysis and feedback.

https://github.com/JaneliaSciComp/ShroffCelegansModels.jl (currently public)
https://github.com/JaneliaSciComp/Transcriptome4D (currently private)

Automatic differentiation (AD) is deeply embedded in the Julia ecosystem. Thanks to dual numbers and generic programming, derivatives often “just work” across packages. However, this is not always the case. In certain situations (e.g., when transcendental functions are evaluated via partial fraction expansions) propagating dual numbers through the implementation may fail, and for good numerical reasons.

In this talk, we present the case of beta_inc and beta_inc_inv from SpecialFunctions.jl. Their original implementations relied on partial fraction expansions carefully designed for Float64 evaluation. While this approach yields numerically stable function values, it does not automatically provide correct derivatives under AD. Crucially, differentiating the partial fraction expansion is not equivalent to computing the partial fraction expansion of the derivative — the latter being significantly more involved.

Drawing from the numerical analysis literature (this challenge is not Julia-specific), we implemented exact derivatives for these functions, as proposed in pull request #506. This work enables the standard automatic differentiation tools to handle these functions seemlessly.

These derivatives are central to e.g. statistical computing: they are used in the Beta cumulative distribution and quantile functions, the Student’s t cumulative distribution and quantile functions, and most importantly for us the multivariate Student’s t distribution, which has been asked about several time on discourse. Prior to this work, fully differentiable implementations of these models were not available in Distributions.jl.

This talk goes through the story of SpecialFunctions.jl's pull request #506 titled “Exact chainrules derivatives for beta_inc and beta_inc_inv”, which solves all these issues and will hopefully be merged by Juliacon.

Effective partitioning is important for the scalability of agent-based modeling (ABM) on HPC systems, but existing methods do not meet the specific challenges of complex ABMs. These usually involve heterogeneous agent types with phase-based execution, dynamic population changes, and moving agents. This talk presents ongoing research developing specialized partitioning algorithms for distributed ABMs, including a benchmark framework and the development of specialized Julia packages.

This presentation discusses the development of MatrixEquations.jl, a comprehensive Julia package for solving specialized matrix equations, including Lyapunov, Sylvester, and Riccati types. While these equations are fundamental to control systems analysis and synthesis, their utility extends across numerous scientific domains. The package’s impact is substantial: it serves as a critical dependency for over 60 packages within the Julia ecosystem and averages over 2,000 monthly downloads.

Reflecting on its status as my most successful software project to date, I look forward to sharing insights into its development—specifically regarding two distinct implementation challenges: achieving peak numerical performance by leveraging optimized, hardware-specific libraries, and providing generic functionality that supports Julia’s abstract type system to work seamlessly with arbitrary-precision and non-standard number types.

Julia for VSCode now offers automatic Julia installation for seamless onboarding and integrates JETLS -- a new language server powered by JET.jl and JuliaLowering.jl. JETLS brings type-aware diagnostics, macro-aware go-to-definition, enhanced completions, and a CLI for AI agent and CI integration. We demonstrate how these features improve everyday Julia development through live comparisons with the existing language server.

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.

X-ray Free Electron Lasers (XFELs) are the latest generation of light sources, designed specifically to create coherent x-ray radiation for scientific experiments. During these experiments it's critical to get feedback in real-time to assess how the experiment is proceeding. In this talk we will describe how Julia is used for doing such real-time analysis at the European XFEL.

Efficient simulation of multiphase flows remains a major challenge, particularly for cloud microphysical processes in which interactions between turbulent airflow and suspended droplets must be resolved in detail. We present a novel asynchronous two-way coupled Euler–Lagrange simulation framework that exploits heterogeneous computing architectures to achieve unprecedented scalability.

The proposed method executes Eulerian field calculations on CPUs using the OpenFOAM software package, coupled asynchronously to Lagrangian particle tracking on GPUs implemented in Julia, minimizing computational idling times and synchronization barriers. Data transfers are initiated immediately upon data availability, with Eulerian source terms predicted from previous time steps and subsequently corrected to ensure conservation of mass and momentum. Particles are organized into cache-friendly chunks with maintained bounding boxes, enabling dynamic load balancing across GPUs and optimized CPU-GPU data transfers.

Comprehensive testing on a local workstation and on a EuroHPC JU supercomputer revealed dramatic improvements: the algorithm achieves excellent scalability up to 256 billion droplets. The overall time-to-solution improved by a factor of 4.5, while energy efficiency improved 3.4 times compared to established methods. Weak and strong scaling tests demonstrated very good efficiency and speedup using up to 2500 cores paired with 256 GPUs.

The software is available in a public GIT repository at https://github.com/Wikki-GmbH/SCALE-TRACK

Spatial transcriptomics (sTx) is a cutting edge technology combining microscopy and high-throughput sequencing or molecular probes to measure transcription in the context of cells within their tissue context, enabling researchers to achieve single-cell resolution and identify spatial relationships between cell types. While this technology opens up many new avenues for investigation, proprietary analysis applications provided by the manufacturers of sTx machines are typically slow (often requiring cloud-based compute), feature-poor, and do not generalize across technologies. SpatialOmics.jl is a new package that combines functionality from JuliaImages, JuliaGeo, and JuliaData to offer open source and extensible end-to-end analysis tools for spatial 'omics applications.

PETSc is a widely used scientific computing library that allows you to write software that runs on massively parallel supercomputers. PETSc is written in C but provides interfaces for Fortran and Python. Its Julia interface,
PETSc.jl , has been around for some time but only ported a small part of the library. Recently, this has changed and since version 0.4.0 it provides an interface to (nearly) the full PETSc library.

There are a number of advantages compared to other attempts:

• It can be very easily installed by typing "add PETSc" in the Julia package manager and is distributed with both precompiled PETSc binaries PETSc_jll (for linux and Mac) and MPI.

• We provide both a high-level and a low-level interface. The low-level interface automatically wraps nearly the full PETSc library with over 3000 functions, whereas the high-level interface gives a more Julia-like experience but is currently limited to part of the library.

• Automatic testing and CI/CD is performed with currently >50’000 tests.

• Users can combine features from Julia, the Julia ecosystem, such as automatic differentiation and plotting with PETSc solvers. The resulting codes are much more compact than their counterparts in lower-level languages; yet, users still have access to all PETSc features, such as multigrid solvers for DMDA or DMStag grids.

• It allows running code on both a local workstation and on a large HPC system.

In the presentation, I will summarise some of the work done to achieve this and show scalability results of typical codes. I will also compare the timing with native compiled code.

Solving large matrix equations can be very expensive. For many applications, however, the dense solutions can be well approximated by low-rank factorizations: products of two or three matrices with a substantially smaller inner dimension. And certain quantities can yet again be computed as a linear function of the solution, meaning one does not even need to assemble the low-rank factors. DifferentialRiccatiEquations.jl is a package to cater all these use cases for differential and (continuous-time) algebraic Riccati and Lyapunov equations.

SmallCollections.jl provides variable-length vectors, sets and dictionaries which in their immutable versions don't allocate memory. Using these types often results in significant speed-ups for performance-critical code. I will illustrate this with the package SmallCombinatorics.jl.

Biology is driven by interactions: between transcription factors and genes, receptors and ligands, and pre- and post-synaptic neurons. To gain insights about complex systems, embedding methods are commonly used to represent pairwise similarity relationships; however, we lack tools for coembedding two or more classes of interacting objects. I will present new machine learning tools for coembedding interacting systems. A distinguishing feature is the representation of entities by Gaussian probability distributions rather than points, which results in a quadratic compression of dimensionality, enabling quantiatively-accurate visualization of more complex systems than is possible by traditional techniques.

Structural Equation Models (SEMs) are a powerful statistical framework for disentangling complex relationships between multiple factors that affect empirical data. StructuralEquationModels.jl implements SEMs in Julia, offering greater efficiency and extensibility compared to implementations in other languages. Improved efficiency enables the application of SEM to large networks of variables (such as in genetics) and to fit many models in parallel (such as in neuroimaging). Improved extensibility permits adapting SEMs to specific use cases by modifying loss functions or integrating with various numerical optimization backends.

We present Spry.jl, a package for high performance networking natively in Julia. Traditional HPC has long used abstractions like MPI or SHMEM to manage communication. Spry.jl directly interfaces with the low level Libfabrics and UCX libraries enabling fast, scalable networking that complements Julia's dynamism, performance, and workflow flexibility rather than limiting it. We also provide an overview of the high level interfaces of Spry like distributed arrays, channels, and object stores.

Phylogenetic reconstruction and comparative analysis are fundamental to understanding evolutionary relationships and biological diversity. Traditional algorithms rely heavily on multiple sequence alignments and statistical modelling, which face significant computational challenges with large-scale datasets. Furthermore, integrating information from multiple data sources, such as sequences, structures, and functional annotations, at the time of reconstruction, remains technically challenging, limiting the feasibility of phylogenetic reconstruction using today’s diversity of biological annotations.

Hyperdimensional computing (HDC) is a novel computational paradigm that employs high-dimensional representations of atomic entities (e.g., amino acids) and combines them via algebraic operations to represent more complex data structures (e.g., proteins). This paradigm, parallel to connectionist modelling, is characterised by modelling the brain's distributed memory and the operations underlying its processing. HDC exhibits several properties advantageous for biological data analysis: robustness to noise, holographic information distribution, and the ability to integrate heterogeneous data sources seamlessly. Recent applications in DNA sequencing, pattern matching, and molecular classification have demonstrated HDC's potential in bioinformatics, where its computational efficiency, interpretability, and natural capacity for multimodal data fusion make it particularly well suited to complex phylogenetic analyses.

In this talk, we showcase the potential of HDC for phylogenetic reconstruction and comparative analysis. Here, we present PhyloHD.jl, a Julia package for representing biological data as hypervectors and reconstructing phylogenetic trees from these representations. We will showcase how to calculate branch support using the HDC paradigm and present a multimodal tree reconstruction approach that integrates multiple heterogeneous data sources, including sequences, structures, and functional annotations. Finally, we will showcase how HDC learning techniques can be used for family-based phylogenetic tree reconstruction and ancestral sequence reconstruction. This work represents the first attempt to use hyperdimensional computing as a computational paradigm for phylogenetics and opens new avenues for research in this field.

We implemented a mixed-precision, nested recursive Cholesky algorithm for GPU Matrix Processing Units (NVIDIA H200, AMD MI300X) using Julia. With a hierarchical precision method, we maximize throughput while maintaining numerical stability. Our recursive SYRK achieves a 14x speedup over cuBLAS, leading to a 5.32x overall speedup for Cholesky over cuSOLVER FP64. The solver leverages Julia’s multiple dispatch to provide a portable interface for HPC.

The Dyad language and ecosystem provides a modern approach to model-based systems engineering leveraging the symbolic-numeric advances of ModelingToolkit.jl. This talk presents the Dyad FluidComponents and HVACComponents libraries which are a suite of pre-built models for 1D thermal-fluid flow. We present unique features of Dyad such as path variables that simplify modeling, discuss approaches to translating existing libraries and conclude by providing industrial examples.

Julia has great tools for simulating and analyzing many kinds of dynamical systems.
However, discrete, finite-state systems, i.e., systems made of many interacting parts that each have a small number of possible states, are less well supported. The class of GDS includes many well-known formalisms, such as Boolean networks, cellular automata, and sequential dynamical systems.
These models have a long history of use in the biological setting.
Boolean networks, for example, were originally introduced to model genetic regulatory networks.
More recent generalizations of Boolean networks, qualitative networks, have allowed experts to build and reason about large, complex models of signaling pathways.

GraphDynamicalSystems.jl provides a common backbone for constructing, learning, executing, and analyzing GDS. As these models are 1) dynamical systems, 2) graphs, and 3) compositional in their behavior, they make for a great use case for recombining different packages and ecosystems to create something new—something Julia excels at. In this case, the package hooks into the JuliaDynamics,
JuliaGraphs, and soon, the AlgebraicJulia, JuliaReach, and SciML ecosystems. With this package, we hope to stimulate the implementation and development of new methods for learning and analysis of this broad class of systems.

Symbolic learning is a branch of machine learning focused on building classifiers that can be translated into logical rules, making them far more readable than neural networks or other statistical models. While training a symbolic model is a necessary first step, it is the post-processing stage that yields the most relevant insights. We present a live walkthrough of SolePostHoc.jl, a SOLE package dedicated to post-processing, allowing for rule extraction, boosting and model simplification.

While Julia’s Dagger.jl provides a productive framework for task-based parallelism using Directed Acyclic Graphs (DAGs), its default reliance on TCP-based Distributed.jl limits performance on low-latency HPC interconnects. To bridge this gap, we developed MPIAcceleration, a strategic extension that replaces standard transport with an MPI-aware backend. By leveraging MPI.jl and non-blocking communication, we enable Dagger to use specialized hardware such as InfiniBand and Slingshot while maintaining a simple, high-level API.

Open discussion for the community attending the mini, not to be recorded.

Identifying genuine protein-protein interactions from mass spectrometry data requires disentangling real biology from experimental noise. BayesInteractomics.jl tackles this by fitting three complementary Bayesian models (detection, enrichment, and dose-response) and combining their evidence through copula mixture models. Built on RxInfer.jl and Copulas.jl, it leverages Julia's type system, multiple dispatch, and threading to analyze thousands of proteins in minutes.

We present a Bayesian calibration framework built on Turing.jl for statistically rigorous data assimilation. To scale inference with Gaussian Processes, we employ a Bayesian Committee Machine approach, and exploit parallelism across both CPU and GPU backends.
We demonstrate the framework on both analytical and real-world data from accelerator physics, highlighting speedups.
The result is a practical, flexible toolkit designed for rapid model updating and calibration.

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.

We present the Jlpigraf package for interacting with the Epigraf API. Epigraf is an open-source research platform designed for the collection, annotation, linking, and publication of multimodal text data. Its data model supports research databases ranging from epistolary editions to social media corpora. Currently, Epigraf is primarily used for editing epigraphic data — inscriptions in connection with the objects to which they are attached. The platform includes a publication system for various document formats, such as Word and TEI, as well as structured JSON, XML, and CSV data and triples in TTL, JSON-LD, and RDF/XML. Thus, Epigraf is building a bridge between traditional editorial work and computational humanities.

Until now, the Rpigraf R package is provided to interact with the Epigraf API. The Jlpigraf package brings a significant portion of Rpigraf's functionality to the Julia programming language. The goal is twofold. Firstly, implementing the package leverages the performance and syntax advantages of Julia for data analysis and processing in the humanities. Secondly, Epigraf originated in a specific humanities research context, and we are working to open the platform up to other disciplines and research communities.

Epigraf uses the Relational Article Model (RAM) to internally manage the database content. The basic building blocks are articles grouped into projects and subdivided into sections that contain items. Items hold the specific data such as text, image file names or references to categories. Articles are linked to category systems directly via tagging them in items or via in-text annotations. Examples of category systems include bibliographic references, persons and locations, authority data, and in-text annotation vocabularies. The RAM's building blocks are then mapped to the specific research domain.

The Jlpigraf package has the following core tasks (work in progress):
1. Interacting with the Epigraf API, including authentication, data fetching, and data manipulation.
2. Extracting, joining and transforming RAM data.
3. Handling hierarchical data and tree structures.
Thus, the package relieves users of frequently recurring tasks. It provides easy access to the corpora stored in Epigraf. A basic understanding of the Relational Article Model's structure is sufficient to work with the data. In the proposed talk, we will provide a brief introduction to the topic and the Relational Article Model. Then, we will explain the objectives of the package using application examples. Finally, we will discuss the process of translating from R to Julia, emphasizing relevant language features and the Julia package ecosystem.

DynamicalSystems.jl is an internationally acclaimed general purpose library for nonlinear dynamics and nonlinear timeseries analysis. It encompasses a vast array of features that, despite the established age of dynamical systems theory, no other software has attempted so far. In this talk I will review the state of the DynamicalSystems.jl library in 2026: what's there, what's new, what is going well, what parts need more love, and what is planned for the future, and what you can do to help. I will then highlight recent successes and additions to the library, based primarily on ComplexityMeasures.jl and Attractors.jl, while also highlighting recent additions to the library: CriticalTransitions.jl, TransitionsInTimeseries.jl, and RecurrenceMicrostatesAnalysis.jl.

Interfacial water waves are governed by complex Euler equations, that satisfy non-trivial nonlinear travelling and standing wave solutions. Analyzing these solutions and their stability is important for understanding oceanic dynamics, from coastal impacts to mysteries like rogue waves. To streamline this, we introduce InterfacialWaves.jl, a Julia package that enables researchers to easily generate nonlinear wave equilibriums and analyze their stability to decode the secrets of breaking and rogue waves

Efficiently obtaining high-accuracy data for molecules and materials is one of the major challenges in quantum chemistry. We present ElemCo.jl, an efficient, user-friendly, modular, open-source Julia package for performing quantum-chemical calculations, including Hartree-Fock (HF) and post-HF methods, with a focus on Coupled Cluster theory. Particular emphasis will be placed on tensor-decomposed Distinguishable Cluster methods to treat extended systems at substantially reduced computational cost.

Multi-GPU execution is the future - as data sizes grow, and as more work is pushed to the GPU, a single GPU no longer suffices. Unfortunately, programming an algorithm for multi-GPU is more complicated than single-GPU - you now have to deal with the complexity of multi-device data movement and multi-stream synchronization, which puts more burden on the algorithm author and takes away from just writing the algorithm in the simplest, most readable manner. Thankfully, Dagger.jl makes programming multi-GPU algorithms much easier with its Datadeps framework, which lets you focus on writing the algorithm at a high level while Dagger handles the details of managing multiple GPUs.

This talk will explain the problems around multi-GPU programming, and show how Dagger handles them. We will show how the Datadeps framework makes it much easier to write algorithms which naturally support multi-GPU execution, and show the tools that Dagger and Datadeps provide to make algorithm design a breeze.

We have long wanted to be able to count unique clients using Julia and various packages, but privacy concerns have prevented us from doing so. A new protocol combining two magical technologies—HyperLogLog cardinality estimation and RSA public key encryption—allows accurate estimation of client counts while provably preserving anonymity. This protocol, dubbed "HyperLogLog Over RSA" is now built into Julia's Pkg client, allowing us to finally get reliable client counts.

Decision-Focused Learning (DFL) is a field at the intersection of machine learning and combinatorial optimization. It integrates prediction with combinatorial decision-making by embedding optimization algorithms directly into machine learning pipelines. This talk presents the JuliaDecisionFocusedLearning ecosystem, focusing on DecisionFocusedLearningBenchmarks.jl and DecisionFocusedLearningAlgorithms.jl, two new packages that provide a high-level and generic interface for using state-of-the-art DFL methods.

I present GeothermalWells.jl, an open-source Julia package for full three-dimensional simulation of deep borehole heat exchangers (DBHEs) and well arrays. Through an operator splitting strategy combining ROCK2, ADI, and semi-Lagrangian methods with vendor-agnostic GPU acceleration, making multi-year well array simulations computationally tractable on a single GPU. Previously considered prohibitively expensive, these simulations open new possibilities for systematic design optimization of geothermal well systems.

This talk introduces a new package called CoolPDLP.jl, which implements state-of-the-art parallel algorithms for large-scale linear programming. Thanks to Julia's flexible GPU ecosystem, these algorithms run on various kinds of accelerators, accepting arbitrary matrix and number types.

The DynamicalSystems.jl library allows analyzing nonlinear dynamical systems in Julia. However, functionality for systems with random or time-dependent forcing has been limited. Extending the existing interface to include coupled stochastic differential equations and nonautonomous systems, we introduce CriticalTransitions.jl: a user-friendly, well-documented package of numerical methods from large deviations and dynamical systems theory to simulate and understand critical behavior, e.g. tipping.

For specific classes of time-dependent PDEs it can become handy to split the full problem up into simpler to handle subproblems, such that we can exploit the specific structure of each subproblem during time integration. To achieve this goal we introduce https://github.com/SciML/OrdinaryDiffEqOperatorSplitting.jl  a library that allows user to split ODEs and DAEs into sub-problems, where we allow problems to be recursively split. The library coordinates in which order the sub-problems need to be integrated, while each of the sub-problems can be solved which a suitable solver from OrdinaryDiffEq.jl .

I would like to show you how I combine Python- and Julia-based machine learning models into a scalable molecular dynamics (MD) simulation workflow using the NQCDynamics.jl package.
My research focuses on simulating light-driven chemistry on metal surfaces, where non-adiabatic coupling between electronic and nuclear motion requires custom MD methods.
If you are in the field of non-adiabatic / excited state dynamics, I hope I can show you why this might be interesting for your own simulations.

The modular compiler of Julia allows non-standard compilation flows and heteregeneous targets. Field Programmable Gate Array (FPGAs) are one of them, and Julia is an excellent fit for High-Level Synthesis (HLS). We present an HLS toolchain that takes advantage of the MLIR tracing system Reactant.jl and CIRCT HLS flow. This approach enables flexible design-space exploration and rapid prototyping of FPGA designs.

As the pharmaceutical industry shifts toward Model-Informed Drug Development (MIDD) and complex pharmacometric simulations, the Julia programming language has emerged as a frontrunner due to the availability of specialized ecosystem for Pharmacometrics (Through Pumas, SciML and JuliaDiff packages) and support for High Performance Computing, and interoperability.

However, deploying Julia in a GxP-regulated environment requires more than just efficient algorithms; it demands strict adherence to software validation, reproducibility, and data integrity standards such as FDA 21 CFR Part 11 and GAMP 5.

This talk outlines a strategic framework for making Julia code "pharma-ready." We explore the use of Julia’s native packages to maintain Reproducibility, the implementation of testing suites for the generation of validation reports and we will also explore how to use literate programming in Julia to generate documentation and reports . By leveraging Julia’s unique features, we show how developers can create high-performance workflows that satisfy both computational demands and regulatory scrutiny.

CounterfactualTraining.jl leverages CounterfactualExplanations.jl to make opaque machine learning models like artificial neural networks more 1) explainable, 2) sensitive to actionability constraints and 3) adversarially robust. The package is part of the Taija ecosystem for Trustworthy AI in Julia and the engine behind our IEEE SaTML 2026 paper titled Counterfactual Training: Teaching Models Plausible and Actionable Explanations.

For better or worse, we live in a world where being online is essential for being known. This applies not only to people, but also to ideas, algorithms, and software created by Julia programmers. Your research may be groundbreaking and your algorithms elegant, but if they are not accessible online, they are unlikely to be seen or used.

Many researchers recognize this and try to publicize their work through papers, talks, and blog posts. However, the most effective way to communicate a computational idea is not just to describe it, but to let people interact with it. A web app allows users to explore a model, test an algorithm, or visualize results directly, making the value of the work immediately clear.

The problem is that most scientists and researchers lack the time or expertise to build web applications. Traditional web frameworks lower the barrier somewhat, but they still require knowledge of web development concepts and introduce friction when all you want is a simple, interactive interface to your Julia code.

Magic.jl is designed to remove this friction. Aimed at scientists and researchers, it provides a simple, Julia-native way to turn algorithms and solutions into interactive web apps, in the same spirit that Streamlit does for Python.

This talk introduces AlgorithmAnalysis.jl, a Julia package that automates the worst-case analysis of black-box algorithms. Analyzing the performance of an algorithm by hand is both tedious and error prone. This package enables users to express algorithms in a natural way using a high-level domain-specific language. This symbolic description is then transformed behind the scenes into a semidefinite program that is solved numerically to construct tight numerical bounds on the worst-case performance. The package implements the performance estimation problem (PEP) and control theoretic frameworks, both of which have been used to analyze a wide variety of first-order methods in optimization.

TrixiAtmo.jl is a numerical simulation package for atmospheric flows, implementing modern discontinuous Galerkin methods in a composable and unified Julia framework. Users can set up complex simulations, from idealized benchmarks to global circulation models, with minimal boilerplate, and easily integrate new formulations, tracers, or microphysics. The package supports multiple formulations of the compressible Euler equations, including the effects of rain and clouds. I present efficient and high-performance implementations and highlight challenges and solutions from both the discretization and coding perspectives.

Transport coefficients are quantities measuring sensitivities in various fluxes for equilibrium molecular systems subject to thermodynamic forcings driving them out of equilibrium. Typical examples are diffusivity, shear viscosity or thermal conductivity, which enter as parameters in macroscopic models of fluids and materials. Unfortunately, these are notoriously difficult to compute, and there is still a need to develop more efficient algorithms.

We will present three algorithms to compute transport coefficients in stochastic MD: the Green-Kubo method, the nonequilibrium molecular dynamics (NEMD) method, and the constant-flux approach recently proposed in this work.

We discuss how Molly.jl, with its highly extensible design, allows to rapidly implement these methods and assess their relative performance. This leads in particular to discover promising properties of the constant-flux approach, narrowing the gap between mathematical ideas in statistical physics and applications in computational science.

This is joint work with Gabriel Stoltz.

QuantumKitHub's various packages provide low- and high-level tooling for the implementation of (among other things) tensor network algorithms. These algorithms are highly amenable to GPU-based acceleration, but there are many stumbling blocks along the way. In the past year we have been actively working to add GPU support to the whole stack of TN-related packages, and in this talk we will discuss the performance benefits and challenges thus far, our roadmap, and how this work can benefit the wider JuliaGPU developer and user community.

Evolutionary game theory has traditionally employed deterministic models to describe population dynamics. These models, due to their inherent nonlinearities, can exhibit deterministic chaos, where population fluctuations follow complex, aperiodic patterns. Recently, the focus has shifted towards stochastic models, quantifying fixation probabilities and analysing systems with constants of motion.
Yet, the role of stochastic effects in systems with chaotic dynamics remains largely unexplored within evolutionary game theory. This study addresses how demographic noise -- arising from probabilistic birth and death events -- impacts chaotic dynamics in finite populations. We show that despite stochasticity, large populations retain a signature of chaotic dynamics, as evidenced by comparing a chaotic deterministic system with its stochastic counterpart. More concretely, the strange attractor observed in the deterministic model is qualitatively recovered in the stochastic model, where the term deterministic chaos loses its meaning. We employ tools from nonlinear dynamics using Julia to quantify how the population size influences the dynamics. We observe that for small populations, stochasticity dominates, overshadowing deterministic selection effects. However, as population size increases, the dynamics increasingly reflect the underlying chaotic structure. This resilience to demographic noise can be essential for maintaining diversity in populations, even in non-equilibrium dynamics. Overall, our results broaden our understanding of population dynamics, and revisit the boundaries between chaos and noise, showing how they maintain structure when considering finite populations in systems that are chaotic in the deterministic limit.

Macchiato.jl is designed to eliminate the need for traditional meshes in physics simulations. Instead, it operates on unstructured point clouds, which define the boundary of the region of interest. The package aims to provide a user-friendly yet robust environment enabling scientists and engineers to conduct meaningful simulations with minimal pre-processing effort. By bypassing the complexities of mesh generation, users are free to focus on their research and applications.

SpeedRand.jl is a fully-implemented alternative toy PRNG that implements (more or less) the full suite of Julia's informally-documented AbstractRNG interface, with a terrible, humorous twist.

Handles can be used instead of explicitly using pointers or references to access objects. This is done by storing the objects of a given type in a Memory or Vector and using the handle as an index. With a suitable abstraction, which Handles.jl provides, it turns out that this combines attractive properties like being faster than object references in certain situations and being safer than regular indexing for a static set of objects. Therefore, handles provide a pattern which might be interesting to use in large parts of the Julia ecosystem where efficiency matters and certain constraints hold.

MicroSwimmers.jl is a package for simulating the dynamics of flagellated microswimmers in low-Reynolds-number fluid environments where geometry and actuation determine global behaviour. Built on the boundary-element regularised Stokeslet method, it provides a composable framework for constructing time-dependent swimmer morphologies and exploring parameter-driven transitions in trajectories and flow fields, integrated with the Julia scientific computing ecosystem.

Seebeck coefficient, electrical conductivity, and thermal conductivity are key parameters for thermoelectric design. BoltzTraP.jl is a Julia port of BoltzTraP2, the standard tool for computing these via the Boltzmann transport equation, ensuring numerical equivalence with Julia-native optimizations. It accepts input from major DFT codes and DFTK.jl, enabling an all-Julia workflow from electronic structure to transport properties. In-memory calculations show over 2x speedup over BoltzTraP2.

GPU vendor libraries like cuBLAS deliver excellent performance but come with hard constraints: limited type support, fixed operators, and single-vendor hardware. The Julia GPU ecosystem addresses portability through an abstraction layer: KernelAbstractions.jl lets developers write kernels that compile across CUDA, AMD, Intel, and Apple backends. But abstraction currently comes at a cost: KA.jl lacks the intrinsics needed for fully optimized performance. Warp operations on extended types, vectorized memory access, and explicit memory ordering for inter-workgroup communication are missing. We introduce KernelForge.jl, a Julia package proving that portable GPU code can match vendor-optimized performance. To make this possible, we developed KernelIntrinsics.jl, which exposes the missing primitives (currently CUDA-only, though the approach extends to other backends). KernelForge.jl provides kernels for matrix-vector and vector-matrix products with arbitrary operators and bitstype elements, mapreduce over 1D and 2D arrays, prefix scan, and copy operations. Each is implemented as a single kernel using vectorized loads/stores to saturate memory bandwidth as much as possible, warp-level reductions, and strong memory ordering for correct inter-workgroup synchronization. Benchmarks show that KernelForge.jl matches or exceeds both proprietary CUDA functions and NVIDIA's CUB library. The kernels are stable and tested, though views and strided arrays are not yet supported. The goal is straightforward: open-source GPU code that is efficient, flexible, and eventually portable.

In this talk, I reflect on my experience designing, delivering, and openly releasing a university course - High Performance Computing in Julia - whose materials have since found an audience beyond my own students.

I will begin with the story behind the course: why Julia was the natural choice for teaching high performance computing, and how the course developed over the years of teaching. From there, I will offer a practical account of what it takes to build an online course, the software choices considered and used, along with alternative approaches that other educators may prefer.

Whether you are an educator considering Julia for your own teaching, or a community member thinking about sharing your expertise through educational material online, this talk should have something interesting for you.

We introduce the inner workings and use of ReSiE, a new package for the simulation of sector-coupled energy systems with complex non-linear control schemes on the scale of city districts. The package is based on a different mathematical approach than comparable tools in the field of energy system modelling, which typically use MILP. The strengths and weaknesses of this approach are discussed. Furthermore we present some "lessons learned" and how Julia was leveraged to implement the package.

Hybrid and multiscale modeling gives rise to complex systems that are often difficult to simulate. Such models are integral to many areas of biology, where simple mechanisms can induce complex emergent phenomena across scales. We have developed Sirens.jl, in which complex systems can be treated as components (models) and connections between them. We demonstrate the power of this approach through a range of examples, from the scale of single proteins to entire populations.

We couple Trixi.jl and deal.II in parallel and adaptively on a shared p4est mesh for simulating multiphysics systems that allow a splitting into two (or more) PDEs coupled via source terms depending on each other's state variables following a common Eulerian formulation.

The Density-Functional ToolKit (DFTK) is a Julia package providing routines to compute
the electronic structure of a bulk material and related properties,
using plane-wave density functional theory (DFT).
Many material properties of interest can be expressed as derivatives of simulation outputs
wrt. input parameters, and typically only specific combinations are implemented by DFT codes,
as a result of great programming effort to hand-implement all the required derivative terms.
In DFTK however, derivatives of any output quantity wrt. any input parameter can be computed,
using algorithmic differentiation (AD) combined with density-functional perturbation theory (DFPT).
This results in a general AD-DFPT framework [1] that can only be used to compute both standard and novel derivatives,
with promising applications including gradient-based optimization and error propagation.

In the first part of this talk, I will discuss the key ideas behind this implementation,
showing how we offload tedious derivative computations to the AD framework,
while keeping the numerics under control thanks to the underlying DFPT solver.
The overall strategy is quite general, and should be applicable in other fields as well.
In the second part of this talk, I will present new research directions enabled by AD-DFPT.
In particular, I will focus on the propagation of model parameter uncertainty
and estimated numerical errors all the way to predicted physical quantities.

This package provides a collection of functions which can be written in a form separated by coordinates.
An example is a multidimensional Gaussian, a parabolic potential or a complex valued plane wave.
Typically the separable functions are combined by a multiplication but there are also examples using other operators to combine them. Upon construction the separable parts are pre-calculated and a Julia-generic Base.Broadcast.Broadcasted object, which behaves a bit like a lazy array. It seamlessly merges with other broadcasting operations. The package, albeit being CUDA-agnostic, is fully capable of working with CuArray objects, creating a pre-calculated 1-dimensional CuArray for each dimension which then takes part in the broadcasting. The use of SeparableFuctions.jl significantly speeds up calculations and saves on-board memory. It is currently used in a number of other packages, for example StructuredIlluminationMicroscopy.jl which reconstructs optical images supported by acceleration via CUDA.jl(See also the Computational Physics Minisymposium).

JuliaCheck.jl is an extensible, rule-based static code analyzer for Julia, developed by TIOBE (in collaboration with ASML). Built on JuliaSyntax.jl, it enforces configurable coding standards (from style and structure to security) and integrates with TIOBE's TiCS quality framework, bringing enterprise-grade code quality measurement to Julia for the first time.

This talk will give an overview on WIAS-PDELib, a github organization which emerged from the development of the finite volume solver VoronoiFVM.jl and the finite element solver ExtendableFEM.jl. These "top level" packages depend on a number of infrastructure packages which have been moved to WIAS-PDELib in order to allow for sustainable joint maintenance. The talk will focus on the main features and usage examples of VoronoiFVM.jl and ExtendableFEM.jl. It will introduce common infrastructure packages, focusing on ExtendableGrids.jl for grid management, SimplexGridFactory.jl for mesh generation via Triangulate.jl and TetGen.jl backends, ExtendableSparse.jl for straightforward and efficient sparse matrix assembly, and GridVisualize.jl for grid function visualization with backends for Makie.jl, PythonPlot.jl, PlutoVista.jl and others. Particular emphasis will be given on the level of integration with the SciML ecosystem (CommonSolve.jl, LinearSolve, OrdinaryDiffEq). Options for interoperability with other PDE relevant packages will be discussed.

Here we present, LightMatter.jl, a flexible and efficient framework for simulations of nonequilibrium electron dynamics triggered by light. By leveraging Julia’s powerful metaprogramming capabilities, it dynamically assembles and propagates scattering equations for different physical processes, offering fine control over accuracy and computational cost. Herein, I present its application in the study of laser-driven electron and phonon equilibration in metals showcasing it's power to model complex nanoscale materials.

Fortran climate models are being adapted to GPUs by automatically translating loop-by-loop into a kernel. In Julia, we have more flexibility to develop the climate model SpeedyWeather.jl for the GPU. Many parts are easy to accelerate, leverage multiple dispatch on the GPU and a high level of kernel fusion for modularity and performance, while being optionally hardware-specific. The spherical harmonic transforms remain a complex bottleneck but we employ a multi-algorithm approach with custom linear algebra kernels using Reactant, Fourier and Legendre transforms.

Many important networks have beyond-binary relations that make graph structures inefficient or insufficient representations. Hypergraphs, the generalizations of traditional graphs, are needed to study such complex networks. In this talk, we will discuss hypergraph modeling in Julia, primarily focusing on SimpleDirectedHypergraphs.jl, a recently developed package for complex networks with n-ary directional relations.

StatsOP.jl is a Julia package for (sequential) hypothesis testing in time series using ordinal pattern analysis. The methodology builds on the seminal work of Christoph Bandt and Bernd Pompe (2002), who introduced complexity measures for time series derived from ordinal comparisons of neighboring values.

Designed with usability in mind, the package provides a streamlined interface for extracting ordinal patterns and conducting statistical inference. A central goal of StatsOP.jl is full compatibility with ComplexityMeasures.jl.

CUDA is well known for its SIMT programming model, available in Julia through CUDA.jl. This year, NVIDIA introduces cuTile, a new tile-based programming model for writing high-performance GPU kernels, with automatic tensor core utilization. cuTile.jl brings this model to Julia, compiling Julia kernels through a custom pipeline to Tile IR bytecode. In this talk, we'll cover the programming model, the compiler design, and performance benchmarks on Blackwell GPUs.

Following our introduction of ORTools.jl, this session focuses on the specialized integration of Google’s CP-SAT solver within the JuMP ecosystem. We move beyond the general package overview to examine the specific implementation of CP-SAT for Julia users. The talk covers the technical mapping of constraints to the solver’s interface and discusses the development challenges encountered when bridging CP-SAT with Julia.

From power grids to hydrogen pipelines and diffusion processes, dynamic flow networks are ubiquitous in science and engineering. In this talk, we present NetworkDynamics.jl, a Julia package for modelling such systems, along with PowerDynamics.jl, a domain-specific library for power grid simulations built on top of it.
Both packages have been around for many years. However, over the last 1-2 years we have essentially rewritten both from the ground up, fully embracing ModelingToolkit.jl as the primary way to define component models and deepening our integration with the broader SciML ecosystem.
NetworkDynamics.jl enables users to model inhomogeneous network systems in terms of components: dynamical systems on nodes (e.g. generators or pumps) and on edges (e.g. power lines or pipelines). Component models can be defined using ModelingToolkit.jl and are then placed on a graph. The interconnection between components is handled by our performance-oriented backend. This clear separation between dynamic models and network topology enables efficient scaling for large networks. Rather than symbolically analyzing the entire system—which may contain hundreds of thousands of equations—we compile each component type once and reuse it across all instances.
The resulting system is simply a right-hand side function for a differential equation, making it fully compatible with the SciML ecosystem: OrdinaryDiffEq.jl for time integration, SymbolicIndexingInterface.jl for accessing network states and observables, and SciMLSensitivity.jl for parameter optimisation.
We will present the underlying mathematical model, demonstrate applications in hydrogen networks and power grids, and show how Makie.jl, Bonito.jl, and GraphMakie.jl can be used to build interactive dashboards for exploring simulation results.

This is a panel/podium discussion on the general topic of what is missing the Julia PDEs ecosystem.

Questions covered:

• Performance
• Tooling
• Joint infrastructure, interfaces between PDE packages
• Multitude of PDE and visualization packages
• Recent developments

Panelists: Kristoffer Carlsson, Christopher Rackauckas, Hendrik Ranocha, and Gregory Wagner

Moderation: Dennis Ogiermann, Jürgen Fuhrmann

I will present QCEngine.jl, an extension to the NQCDynamics.jl ecosystem that enables on-the-fly electronic structure theory calculations that couple to a library of efficient non-adiabatic dynamics methods. QCEngine.jl integrates with NQCModels.jl to enable the evaluation of molecular dynamics on electronic potential energy surfaces of interacting many-body Hamiltonians. I will highlight its use-case by presenting its applications to my research on spin-resolved surface scattering.

Even more improvements and features have been since this package was discussed last year at JuliacCon 2025. This talk will highlight some of the more meaningful user-facing feature additions, performance and quality of life improvements, as well as significant bug fixes.

Since 2022, Copulas.jl has provided native support for dependence modeling in Julia. Copulas are multivariate distribution functions on the unit hypercube that allow practitioners to model dependence structures separately from marginal behavior. By building on the Distributions.jl framework, Copulas.jl integrates seamlessly with Julia’s probabilistic and statistical ecosystem.

In this talk, we review the major design improvements and new features introduced since the first public releases of Copulas.jl. The package now offers a broad collection of classical parametric copula families, along with tools for evaluating distribution functions and densities, computing dependence measures such as Kendall’s tau and Spearman’s rho, estimating parameters via inversion of moments or maximum likelihood, and fitting models to data.

A key feature of the package is the Sklar type, inspired by Sklar’s Theorem, which enables users to construct full multivariate models by combining copulas with arbitrary marginal distributions. These composite models are fully compatible with the Distributions.jl API, making them directly usable in downstream tools such as Turing.jl for Bayesian inference.

We conclude with practical examples showcasing how the new features of Copulas.jl enable advanced dependence modeling workflows entirely in native Julia.

Predicting the response of a system to a specific input is a very important task in engineering and nature in general. To accurately predict the response, we developed a closed-loop algorithm to perform model selection based on the output of a reference system obtained following a known input. We applied our algorithm to identify the most accurate model to predict the output of a lab experiment, which consists of light sensitive cells. Using light signals, one can control the output current of the cell. We integrated the experiment in a closed-loop framework, which brought up a constraint on the computation time. Indeed, the recordings of the output current is limited in time, meaning that the model selection has to be performed as fast as possible. To do that, we leveraged the Julia package Sockets.jl and the high speed intranet to export the computation on a server, where the required code had been precompiled. This allowed us to efficiently identify the most accurate model to use for our experiment.

Plane-wave density-functional theory (DFT) is one of the most widely employed simulation approaches for modelling materials atomistically, taking an accurate quantum-mechanical description of electrons. Since 2019 we develop the Density-Functional ToolKit (DFTK, https://dftk.org), a Julia-based code for plane-wave DFT. Right now, with about 10k lines of code, the code remains tractable, despite we recently managed to considerably expand its features. Noteworthy recent extensions is the scaling to multiple GPUs as well as advanced and expensive electronic structure models, such as Hybrid DFT or DFT with Hubbard corrections. I will sketch the challenges with respect to keeping code concise despite the feature extension and why we believe this is the right direction in the age of differentiable scientific computing. Despite our goal to avoid hand-optimised code and custom kernels, our code has state-of-the-art performance, which I will illustrate with some recent benchmarks.

This talk reports on work that has been conducted over the past two years jointly with many DFTK contributors, including Augustin Bussy (ETH Zürich), Bruno Ploumhans (EPFL), Antoine Levitt (Université Paris-Saclay), Tobias Schäfer (TU Vienna), Niklas Schmitz (EPFL), Francesco Sicignano (Scuola Normale Superiore, Pisa).

Major improvements and features have been implemented in Metal.jl since this package was last discussed at JuliaCon. This talk will highlight some of the more meaningful user-facing feature additions, performance and quality of life improvements, as well as significant bug fixes.

Peridynamics.jl is a Julia package for dynamic fracture simulations that supports multithreading and MPI for high-performance computing. This talk focuses on how researchers in peridynamics can adapt the package to their own models rather than on the internal development of the code base. We show how Julia's multiple dispatch and type system make it straightforward to implement custom material models, damage criteria, and boundary conditions, while the package handles parallelism and I/O. The goal is to give researchers a practical starting point for their own extensions, attracting more users to the package and to the Julia ecosystem in general.

Computational Science and Engineering (CSE) integrates engineering, applied mathematics, and computer science to enable model-based design, knowledge generation, and decision support. While CSE has become a key enabler of sustainable products and operations, sustainability is still often treated as an afterthought in computational method development. This talk reflects on sustainability as a core design principle for CSE—one that aligns naturally with scientific relevance, long-term usability, and enduring research value. Drawing on representative examples, we present a holistic perspective spanning resource consumption, digital infrastructure, and organizational practices. We examine how these aspects interact in modern computational research and conclude with directions for impact through sustainable CSE.

This is the poster session for all posters! It will take place at 19:00 13 August 2026. Come see all the great posters we have this year and enjoy some refreshments.

Sponsor Keynote: Boeing and JuliaHub.

Breaking the non-recurring cost curve requires a fundamental shift in how complex systems are designed, analyzed, verified, and integrated. Traditional development approaches often discover design defects late in the lifecycle, when correction is more expensive, schedules are more constrained, and integration risk is highest. Model Based Development (MBD) changes this dynamic by moving defect discovery earlier and extending the verification window through the use of high-fidelity design models, executable simulations, early functional prototyping, and model-driven validation. This presentation explores how model-based methodologies enable earlier requirements validation, improved design maturity, greater standardization, earlier verification test readiness, and higher-fidelity system integration. By placing detailed system design models at the center of the development process, organizations can reduce late-cycle rework, improve first-pass quality, accelerate integration maturity, and ultimately reduce non-recurring engineering cost while improving delivery confidence.

Subsequently, this session will showcase Dyad, by Juliahub, demonstrating how Dyad enables easy and efficient model based development, leveraging and agentic UI and the Julia programming language.

Professional Julia use requires industrial security. This challenge is unique because risks often hide in binary dependencies (JLLs) that standard tools ignore. This talk, following the launch of the Julia Security Working Group, shows how Trivy was adapted to scan the entire Julia dependency graph. We explore the implementation of this workflow within JuliaHub to provide automated security auditing and SBOM generation for any Julia project, ensuring safety for all.

The Dyad platform allows engineers to leverage the power of Julia and SciML via a graphical system modeling environment. The models created by engineers are translated into Julia and harness Julia's just-in-time compilation along with ModelingToolkit's symbolic manipulation capabilities to provide world class simulation performance. But what happens when you want to integrate these models into engineering workflows or wish to leverage the symbolic representations in different ways? In this talk, we'll describe Dyad analyses and how they provide a gateway to the expansive Julia ecosystem.

Building and understanding complex models is easier when you can see them come to life. At JuliaHub, we have been creating interactive dashboards that show simulation results, allow live, interactive analysis, and some which even show real world data, for quite some time now. In this talk, I will go through some of the paradigms we've developed and how those have played out, as well as showing some cool examples for inspiration.

We report on recent progress in the numerical optimisation of quantum control systems using OptimalControl.jl. Although the package is designed to optimise general control systems governed by ordinary differential equations, it naturally accommodates quantum problems described by finite-dimensional Schrödinger equations evolving on Lie groups — specifically, bilinear dynamical systems whose state trajectories lie on unitary groups and are expressed compactly in terms of tensor products of complex matrices.

A well-established Julia ecosystem for quantum optimal control already exists, with packages such as QuantumControl.jl, Krotov.jl, and GRAPE.jl providing mature, quantum-tailored implementations of the GRAPE and Krotov algorithms. These methods are effective for a broad class of problems and can accommodate extensions such as free final time or path constraints on controls and states, typically via penalisation of the cost functional. However, penalisation-based approaches offer no rigorous guarantee of constraint satisfaction and can introduce significant ill-conditioning. Our motivation is complementary: to leverage state-of-the-art nonlinear programming solvers that treat such constraints directly, as genuine algebraic equalities and inequalities arising from the transcription of the continuous-time optimal control problem — including additional optimisation variables such as free final time or parameters of the system.

OptimalControl.jl offers a high-level, expressive modelling interface that allows users to specify dynamics, objectives, and constraints in a form close to mathematical notation, with no compromise on performance. Problems are transcribed via direct methods into large-scale sparse nonlinear programmes, which are solved using interior-point methods on both CPU and GPU, exploiting automatic differentiation through ExaModels.jl and MadNLP.jl. Crucially, the framework also supports the combination of direct and indirect methods: direct transcription is used first to identify the qualitative structure of the optimal solution, after which indirect shooting methods — based on the Pontryagin Maximum Principle — can be applied to refine the solution to arbitrary numerical precision.

We present preliminary results on the optimisation of small quantum systems modelling nitrogen-vacancy (NV) centres in diamond. These systems, comprising an electron spin coupled to one or more nuclear spins via hyperfine interaction, are naturally described with bilinear dynamics driven by bounded microwave controls. The combination of hard amplitude constraints, partial controllability (nuclear spins are driven only indirectly through the electron spin), and the need for various costs functionals for gate synthesis makes NV centres a compelling benchmark for our approach. We discuss the formulation of these problems within OptimalControl.jl, and compare the results and computational performance against existing quantum-specific methods.

ASML builds the lithography machines that enable the world’s most advanced microchips. For our newest DUV systems, Julia has become part of the control software stack—directly participating in algorithms that influence wafer quality and overall system performance.

At JuliaCon 2025 we shared our early exploration and our intention to use Julia in production. One year later, we are excited to report concrete results: we successfully exposed wafers on a prototype machine using a Julia library built with juliac/PackageCompiler, and the performance, stability, and developer experience were all very promising.

In this talk, we will share how we designed, optimized, and deployed time‑critical Julia code in an environment where algorithms must complete within strict millisecond‑level deadlines, remain predictable, and integrate with a large, safety‑critical control system written in multiple languages.

We will highlight the architecture patterns we adopted, the trade‑offs we had to make, and a collection of “unexpected lessons” from working with Julia in a real industrial setting.

Electron Probe Microanalysis (EPMA) is an imaging technique for the quantitative analysis of solid material samples relying on measurements of characteristic X-ray emission induced by electron irradiation.
The determination of the material constitutes an inverse problem, hence an efficient reconstruction requires differentiability of the forward model.
The mathematical model employed in EPMA is governed by a linear transport equation that for heterogeneous materials is commonly approximated using Monte Carlo simulation, where statistical noise complicates the computation of gradients.
For reconstruction, there exist surrogate models that are well tested in practice, but are very restrictive in the parametrization of the material, allowing only homogeneous or depth-layered materials, which ultimately limits the spatial resolution of quantitative analysis in EPMA.

In this short talk, we present an implementation of a deterministic, heterogeneous, and differentiable model for EPMA in Julia.
Reconstruction can then be implemented as a gradient-based optimization using the model as a PDE constraint.
Compatibility with algorithmic differentiation allows us to tailor the material parametrization to a set of quantities of interest, depending on the requirements of a specific sample.
Reconstruction results using realistic as well as synthetic measurements demonstrate potential for further development.

Additionally, we briefly discuss a structural similarity of the forward model in EPMA to the structure in which adjoint methods can be effectively applied for gradient computation. It allows us to "apply adjoints twice" leading also to a more efficient computation of the forward problem, ultimately accelerating reconstruction approaches.

The Brazilian National Institute for Space Research (INPE) is developing Amazonia 1B, an Earth observation satellite with an enhanced-resolution camera for environmental monitoring. Although its bus is nearly identical to Amazonia 1, launched in 2021, the new payload requires a different orbit, demanding the redesign of several mission aspects. The mission design phase was conducted using the Julia ecosystem, with core algorithms encapsulated in the public packages SatelliteToolbox.jl and SatelliteAnalysis.jl. This presentation covers how Julia was leveraged for orbit selection, eclipse duration and beta angle computation, and ground station access and gap estimation. The results were incorporated into the Amazonia-1B Critical Design Review (CDR), which occurred in November 2025, and validated by the review board without issues, demonstrating the maturity and reliability of the Julia ecosystem for operational space mission design.

Our paper develops a nonlinear bi-objective optimization model to analyze cost-emission
trade-offs in maritime fleet operations. The model minimizes total fleet cost and total fleet
emissions through interactions between fuel share choices, digitization adoption, regulatory
frameworks, and operational decisions. We implement the model using the Julia program-
ming language with the JuMP modeling framework, employing the ε-constraint method
to generate a discrete approximation of the Pareto frontier. Results demonstrate that cost-
effective maritime decarbonization emerges from coordinated fuel transition, universal adop-
tion of digitization technologies, and regulatory-driven fleet reallocation, rather than from
isolated interventions. Sensitivity analysis across different digitization adoption modes re-
veals that unconstrained digitization serves as a low-cost enabler of emissions reduction.

I will present PauliStrings.jl, a package for quantum many-body simulations, which performs fast operations on the Pauli group by encoding Pauli strings in binary. When combined with various truncation methods, this representation provides performance advantages for solving certain kinds of problems.
PauliStrings.jl also allows for symbolic calculations, is a natural platform to take advantage of symmetries and is a fun and pedagogical tool to visualize quantum algebra.

FluxOptics.jl is a Julia framework for differentiable optical inverse design. It enables both rapid prototyping relying on automatic differentiation with Zygote.jl and production performance through algorithmic differentiation and custom gradient rules. The framework provides memory-efficient optimization through controlled buffer management, while maintaining a composable architecture. Benchmarks against JAX show competitive performance while handling larger problems, demonstrating Julia's strengths for computational physics applications.

When Julia was first introduced, its creators aimed to directly address the "two language" problem where coders were forced to switch between a programming language that is performant and one that can be easily understood. In this talk, we'll explore how they accidentally created the perfect language for the emerging "no language" problem where code is increasingly not being written by humans at all!

This talks will demonstrate Julia in an embedding setting with Petoi Bittle robots. We show how to run a state estimation using adaptive kalman filter implemented with RxInfer.jl and communicate with Petoi Bittle Dog robot using PetoiBittle.jl, all of this autonomously on Raspberry PI.

This talk is about RadioClock.jl, a Julia package to encode and decode time signals such as the DCF77.

The name means small, so we made it smaller. Piccolo.jl 1.0 consolidates five quantum optimal control packages into one -- one language, one package, just using Piccolo. A unified Julia codebase that AI coding agents can thrive in -- accelerating feature development, performance work, and letting users go from system parameters to optimized pulses naturally. We demonstrate real-world impact through robust control theory (arXiv:2602.10349) and experimental studies of universal dynamics in Rydberg arrays (arXiv:2508.19075).

Automatic differentiation (AD) is gaining ground as a technique for optimization of tensor networks (TN), which are widely used simulation tools in quantum computing, condensed matter, and high energy physics. In this talk we will provide an overview of the ongoing work to add support for end-to-end AD in our large, complex set of physics simulation packages at the "QuantumKitHub". Efficient AD of these networks involves differentiation through complex linear algebra, complicated tensor operations, and other constructs that push the boundaries of what Julia's AD frameworks are capable of.

Many modern manufacturing techniques rely heavily on lasers and more often than not, the behavior of heat in these systems plays a key role in determining whether a finished product is of acceptable quality. In this talk, I present how it's possible to construct a bespoke finite-element method solver for the heat equation, starting from first principles and building on the work of Ferrite.jl and DifferentialEquations.jl. The solver is then validated against experimental results and I show how access to the inner workings facilitates the extension of the code base to tackle related problems such as computing surface hardness after laser processing.

Formal linear combinations are ubiquitous in Mathematics. The package LinearCombinations.jl provides an easy and efficient way to deal with them, as well as with linear and multilinear maps.

Computational Fluid Dynamics (CFD) has traditionally suffered from the "Two-Language Problem": researchers develop new physical models in high-level environments like Python or MATLAB, only to face an extensive rewrite in C++ or Fortran for production-scale runs. This "viscous" development cycle slows down innovation across the aerospace, automotive, and energy industries. In this talk, we present XCALibre.jl: a new Julia package designed to eliminate this friction. XCALibre.jl provides a "Laminar" workflow, allowing for rapid prototyping of complex Multiphysics, and a "Turbulent" runtime performance with native GPU acceleration. XCALibre.jl handles industry-relevant geometries and complex physical solvers, proving that in the Julia ecosystem, developer productivity and fast simulation runtime are not mutually exclusive.

We present an update on the synchronous programming capabilities in the Dyad modeling language. A synchronous program (discrete-time dynamical system), can now be implemented in a graphical block-diagram editor together with an acausal model of a continuous-time system, simulated, and code generated to a juliac/trim executable or C code. Under the hood, Dyad compiles to ModelingToolkit, which in turn lowers the synchronous program to the new domain-specific language SynchJulia.jl, which in turn generates C code or executable julia code compiled with JuliaC.

We present MLThermoProperties.jl, a Julia package that provides a variety of state-of-the-art thermodynamic models that combine modern machine learning methods with physical knowledge. These hybrid models obey hard physical constraints while being more accurate and applicable to a wider scope of substances than established models. MLThermoProperties.jl is built upon the Clapeyron.jl package, leveraging its rich thermodynamic solver ecosystem. The MLThermoProperties.jl models significantly improve molecular property prediction in various applications in science and engineering, e.g., chemical process engineering. Exemplary applications will be demonstrated in the talk by coupling MLThermoProperties.jl with Julia's rich ecosystem for scientific modelling and simulation.

Technical systems become increasingly complex, optimizing their processes by adapting to external conditions. Such self-adaptive systems (SAS) need software that dynamically adapts its behavior.
Context-Oriented and Role-Oriented Programming simplify defining dynamic behavior. Hence, implementing these concepts in Julia is beneficial for SAS development. The library Contexts.jl provides infrastructure for using these paradigms in Julia. This talk introduces its structure and key features.

We introduce qruise-toolset, a differentiable quantum simulation toolbox with a Python interface and a Julia simulation backend. The toolbox enables researchers and companies to build faithful digital twin models of their hardware for fast calibration and prototyping via closed-loop quantum optimal control strategies at the pulse level. Moreover, the realistic behaviour of the control stack and the pulse delivery via the signal chain is an indispensable part of the toolbox, allowing the user to explore the limitations of the control stack components.

Over five years of professional projects, I introduced and supported Julia across a variety of different projects. I have maintained closed-ecosystem packages, and taught a variety of colleagues. I’ll share what worked, what didn’t, and what surprised me most about adopting and promoting Julia in a professional setting.

Climate models rely on parameterizations that are traditionally tuned manually. We present a differentiable calibration framework using Enzyme.jl to compute exact reverse mode gradients of energy-balance diagnostics in SpeedyWeather.jl. By batching single- timestep gradients across chaotic dynamics, we enable systematic, reproducible optimization of shortwave radiation parameters, establishing an extensible workflow for objective calibration in Earth system models.

We want to show off the most exciting developments in Makie over the past year: a new GPU-enabled ray tracing system for beautiful renderings written entirely in Julia, the compute pipeline refactor that replaced Observables in many internals and fixed the age-old multiple updates conundrum, and the upcoming complex recipe system that could change how most users write plotting functions in Makie.

RailToolKit is an emerging ecosystem for open railway research. TrainRuns.jl is our showcase package for running time calculations. Today, railway studies often rely on siloed spreadsheets, proprietary tools, and non-reproducible workflows. We have built TrainRuns.jl as the first component. Now we are designing interfaces to enable data exchange and reproducible workflows across packages. Share your workflows and use cases to help shape this ecosystem!

Julia has great tools for computation, but if you want to build an interactive desktop application with maps, real-time overlays, and custom visualizations, your options are limited. The usual answer is to reach for a web framework or Electron, which means maintaining a split codebase with a server layer in between.

That's what we did initially for SHERPA, a mission planning tool for NASA's lunar surface operations. We had a React frontend talking to a Julia backend over a local server, and it was clunky. Two languages, constant serialization, and every UI change meant context-switching between JavaScript and Julia. So we scrapped it and rebuilt the entire GUI in Julia using Dear ImGui (via CImGui.jl) for the interface and Mirage.jl, a custom OpenGL wrapper I wrote that gives you an HTML5 Canvas2D-style API for 2D and 3D rendering. No shader code or buffer management, just draw_image() and fill_rect() calls.

The real win is how this integrates with Julia's REPL. Our workflow is: start the GUI, use it, close the window, edit a function, reopen the GUI with all your state intact. Maps stay loaded, camera position is preserved, your scenario is right where you left it. This made it possible for a small team to go from nothing to a production tool in a few months, iterating on the GUI the same way you'd iterate on any Julia code.

This approach isn't specific to aerospace. Anything that needs interactive visualization on top of a Julia computation backend (lab instruments, geospatial tools, simulation dashboards, data exploration) could use the same stack. This talk covers how it all fits together, a live demo of the tools, and practical advice for building your own.

Functional Mock-up Units (FMUs) are widely used in industry for exchanging dynamical system models, but their black-box binary nature makes them inaccessible to traditional AD tools. Built-in derivative support in the FMI standard is limited in scope and often relies on slow finite differences. We present a novel approach: by embedding LLVM bitcode into FMU binaries during compilation, we make them accessible to Enzyme.jl, enabling fast, automatic differentiation of virtually any FMU function.

JuliaGNSS is an open-source software stack for processing Global Navigation Satellite System signals entirely in Julia. With all core packages now at version 1.0, the ecosystem has reached production readiness. This talk demonstrates real-time GNSS positioning by connecting JuliaGNSS to a Software Defined Radio, acquiring satellite signals, and computing position and time live. I show how Julia's performance and composability enable a complete GNSS receiver that rivals traditional C/C++ implementations.

Reasoning with temporal and spatial data is crucial in many real-world applications; however, this data is often characterized by uncertainty and unclear boundaries. In this talk, we will see how we can extend spatial and temporal modal logics offered by SOLE through a new submodule, namely ManyValuedLogics, offering support for fuzzy and many-valued logics. Moreover, we will explore a new package called SoleReasoners.jl, offering a reasoning tool for many-valued spatial and temporal logics.

We investigate the problem of partitioning graph states for distributed quantum computing. Graph states are a way of representing certain quantum entangled states as graphs. Due to the nature of entanglement, it's far better to partition graphs to minimize the size of the maximum matchings between partitions rather than the number of edges, as traditional algorithms do. We provide an algorithm for this in our Julia software package for graph state partitioning evaluation, QuantumHamlets.jl.

Harmoniqs is a startup building quantum control infrastructure entirely in Julia. Our open-source stack, Piccolo.jl, and its private extension Piccolissimo.jl share one language from API to numerics. We discuss compiling and delivering Julia without exposing source code, deploying on HPC resources including GPU clusters, and how Julia's single-language design makes AI coding agents unusually effective for a small team. A case study in why Julia is ready for startups.

Ocean models simulate complex physics, but struggle from inherent limitations and under-resolved phenomena. This motivates the use of inverse and machine learning methods to inform models with data. We have implemented automatic differentiation in the Ocean modeling package Oceananigans.jl, through the use and enhancement of compiler tools Enzyme.jl and Reactant.jl. Using these open-source packages, we generate gradients for applications like parameter estimation and embedded ML techniques.

DyadAgent is an AI coding assistant for generating and debugging Dyad code across modelling and simulation workflows, enabling engineers to express complex model requirements in natural language. Evaluating the performance of such an agent requires verification of generated simulation results against standards of physical correctness and numerical accuracy. DyadAgentBench is an evaluation infrastructure designed to measure the agent's modelling and simulation capabilities in a systematic and reproducible manner. In this talk, we present the infrastructure and evaluation framework developed for DyadAgent, covering how agent performance is assessed and how the resulting insights are used to benchmark and guide iterative improvements.

It is estimated that by 2030 Germany will produce around 20 TWh of green hydrogen per year, highlighting the need for suitable storage. One possible solution is storing the hydrogen in porous underground media. In this work we analyse the reliability of such a potential storage site.

Reliability analyses typically require tens to hundreds of thousands of model evaluations for accurate results, especially when imprecise probabilities are involved due to limited data availability and input variables are modelled as intervals or probability boxes. The true model in this study has an associated runtime of around three days rendering a direct reliability analysis virtually impossible.

We use Julia to train an accurate surrogate model on which we are then able to perform our analyses. Propagating the imprecise input quantities through the surrogate model we obtain bounds on the probability of failure of the system. All algorithms used in this study are implemented in the UncertaintyQuantification package.

Using the Functional Mock-Up Interface (FMI), we can handle and exchange big simulation models. It seems only logical to integrate this standard into our favorite programming language. Our open-source journey of FMI.jl started almost exactly 5 years ago with this goal in mind: Blur the boundaries between Julia and FMI. In this talk, we want to give a broad overview over what is possible with FMUs in Julia today – with live programs that fit a single slide each.

This talk presents JADE (Julia Analytics Decision Engine), a production system serving a wide variety of companies, that resolves BI development tension through rapid model development alongside dynamic Julia package generation, intelligent precompilation, and cache-first architecture.

JADE generates complete Julia packages at runtime from domain-specific analytical models. Each generated package contains 10K+ lines of Julia code implementing hundreds of analytical functions, multi-dimensional data structures, dependency graphs, and model-specific formula chains. The system currently serves enterprise clients with production models processing gigs of data and supporting thousands of function calls per evaluation with minimal query latency for warm queries.

The core innovation is our three-stage precompilation strategy that balances compilation overhead against runtime performance. First, we precompile reusable function templates once and distribute them via a shared depot, covering hundreds of analytical functions relevant to financial modeling, statistical analysis, and multi-dimensional array operations.
Second, when models change, we generate model-specific code and combine it with precompiled templates without triggering full recompilation.
Third, we maintain a hash-based cache of compiled packages that delivers instant results for cache hits while compiling updated packages in the background.

We support two deployment patterns with different performance characteristics. In local mode, Julia processes run on workstations or servers, achieving fast cold starts and near instant warm queries.
In Hub mode, distributed Julia processes use shared Registries and caches, delivering low latency queries with horizontal scaling.

Performance optimization is central to JADE's architecture. We employ automatic multi-threading for large array operations with custom chunking strategies, coordinate remapping systems that precompute dimension maps to avoid allocations in hot loops, smart dirty state tracking via dependency graphs that reduces recomputation, and union splitting macros to limit reliance on type dispatch while maintaining flexibility for heterogeneous data.

The talk will cover practical engineering challenges we solved: managing Julia depot paths across deployment environments, implementing intelligent cache invalidation strategies, optimizing precompilation workloads with custom compile statements, handling package versioning and upgrades in production, along with debugging performance issues in generated code. We'll share performance measurements, code examples, and lessons learned from a year of production deployment.

This work demonstrates Julia's readiness for enterprise-critical systems and provides an inspiration for organizations building dynamic code generation platforms and formula chain engines. The techniques we present—precompilation strategies, caching architectures, and performance optimization patterns—are broadly applicable to any domain requiring flexible, high-performance analytics.
Our experience shows that Julia's combination of performance, metaprogramming capabilities, and ecosystem maturity enables production systems that were previously impractical.

Target audiences include enterprise developers integrating Julia into business intelligence platforms, developers building code generation systems for domain-specific languages, performance-focused Julia users, and organizations evaluating Julia for production analytics workloads.

Geophysical surface flow phenomena such as avalanches, landslides, and floods pose significant risks to infrastructure and human safety. Recently, surface flow simulators are used to predict flow dynamics, inundation zones and develop hazard maps, allowing for effective disaster management strategies and safer engineering designs. While existing simulators (e.g. Openfoam-Avalanche, Avaframe, and r.Avaflow) are robust; they lack the differentiability required to efficiently perform uncertainty quantification tasks like sensitivity analysis, parameter calibration, etc., or discover new constitutive relations from observed data.

We introduce GlissADe.jl, developed for differentiable Finite-Area-Method (FAM) simulations, which enables the integration of physical simulations into gradient-based workflows and scientific machine learning. It is built upon the mathematical framework of surface-aligned depth-integrated shallow water equations [1]. By leveraging Julia’s automatic differentiation (AD) ecosystem, including ForwardDiff.jl and Enzyme.jl, GlissADe.jl enables the direct computation of gradients across all model inputs. This allows for sensitivity analysis with respect to geometry, initial conditions (e.g., release height), and physical process parameters (e.g., friction coefficients and bulk density).

This talk explores the software architecture of GlissADe.jl, addressing the challenges of maintaining numerical stability while ensuring compatibility with operations that typically pose difficulties for AD, but are essential for geophysical simulators. These operations include differentiating through iterative time-stepping schemes, handling non-smooth flux limiters, and managing in-place memory mutations. We demonstrate how this framework is used for topographic uncertainty quantification. Finally, we discuss the potential application of such differentiable simulators to solve inverse problems in geophysical flow.

[1] M. Rauter, Ž. Tuković, A finite area scheme for shallow granular flows on three-dimensional surfaces,
Computers & Fluids, Volume 166, 2018, Pages 184-199, ISSN 0045-7930,.

We aim to illustrate the initialization features of Dyad by trimming the Nonlinear F-16 model dynamics using NLSQ for desired altitude and cruise speed. We will then use the analysis features of Dyad by designing an LQR for longitudinal stabilization under trim and demonstrate a dashboard that enables real time tuning and response behavior visualization.

The plant model is written in Dyad, a new declarative acausal modeling language. The F-16 model encodes full six-degree-of-freedom rigid-body dynamics: translational and rotational equations of motion with coupled aerodynamic force and moment coefficients, ISA atmosphere density, and Euler angle kinematics. Dyad's RealInput/RealOutput connectors and analysis_point annotations expose the model's control and measurement interfaces for downstream analysis without modifying the physics..

Controller design uses DyadControlSystems' LQGAnalysis, which automatically linearizes the closed-loop Dyad model at the trim operating point and solves the dual Riccati equations. The 12-measurement, 5-control, 8-controlled-output problem yields a 12-state observer-based feedback controller. An interactive GLMakie GUI with a plugin architecture (Gang of Four, Nyquist, step response, pole-zero map) allows real-time tuning of LQR weights and Kalman filter covariances. A GLMakie animation engine renders the 3D trajectory alongside user-selected state and control variable time histories.

The key contribution is demonstrating that Dyad's declarative syntax unifies what are traditionally separate modeling, analysis, and design stages into a single reproducible project. The same .dyad files that define the physics also declare the trim analysis, the LQG synthesis problem, and the simulation scenarios. Julia's composability: ModelingToolkit for symbolic-numeric transformations, DyadControlSystems for control theory and GLMakie for visualization eliminates the toolchain fragmentation typical of aerospace control workflows.

The talk details how Julia is used for the simulation and modelling of PHASA-35, an unmanned persistent stratospheric solar-powered aircraft developed by Prismatic Ltd, a subsidiary of BAE Systems plc. PHASA-35 can stay airborne year-round to provide communications services, wildfire detection, or ISR.
Julia is used both in standalone simulation tools as well as in FMUs, which are built using JuliaC to perform system-level Software-in-the-Loop simulations.

Structured Illumination Microscopy is a method in which a fluorescent sample is illuminated with a number of patterns containing high spatial frequencies. This encodes super-resolution information into the classical light microscopy image which is the successively recovered by Fourier-space based reconstruction methods.
This talk will introduce into the topic and then highlight some of the concepts behind StructuredIlluminationMicroscopy.jl, which supports some of the fastest algorithms for reconstructing images measured by structured illumination. The package features Fourier-space reconstruction approaches including upsampling, reconstruction and noise-reduction steps. It exploits rFFTs and SeparableFunctions.jl, wherever possible, minimizes the memory footprint by working on pre-allocated arrays and fully supports GPU acceleration via CUDA.jl.

We introduce multivariate multicycle (MM) codes, a new family of quantum error correcting (QEC) codes that unifies and generalizes many of the established families of QEC codes and possess record-breaking capabilities by measure of confinement for single-shot decoding. Our work is enabled by Open Source Computer Algebra Research (OSCAR.jl) which provides capabilities for computations in commutative and homological algebra and QuantumClifford.jl, an open source package for stabilizer tableaux algebra which provides tools for working with graph states and vast array of error correction codes and capabilities.

This presentation reviews the evolution and application of model-based design in Boeing’s Vertical Lift Vehicle Management Systems (VMS). It highlights the long-standing use of MATLAB/Simulink for requirements development, built-in test implementation, component modeling, and software/hardware-in-the-loop testing, while also exploring the emerging potential of Julia/Dyad for acausal physics-based modeling, reusable libraries, and faster execution. The presentation includes a recent IRAD effort demonstrating parallel modeling in Simulink and Dyad and discusses how these tools may support future aircraft development processes aligned with ARP-4754B.

MemlsRetrieval.jl is a Julia reimplementation of the Microwave Emission Model of Layered Snowpacks (MEMLS). It leverages Julia’s type system and generic input types to evaluate typical forward simulations in microseconds with zero allocations while remaining fully differentiable. MemlsRetrieval.jl has been successfully combined with other models in an optimal estimation framework for the retrieval of geophysical parameters from satellite observations.

The rapid spread of AI into all aspects of society has led to a corresponding surge in data centers to support the exploding computing demand. Data centers are complex interconnected physical systems with thermal power generation, electrical power conversion, and cooling systems for the compute chips. The compute load that the data center can effectively deliver is a function of the complex response of these systems including the associated controls for the load dispatch strategy and cascaded controls of the various subsystems. System modeling with representation of the physical systems and key controls is a critical tool for understanding the physical response and operation of data centers.

This talk presents two different uses cases for system modeling in data centers. The first case focuses on data center operation. High level transient models in Dyad, Julia, and ModelingToolkit of the data center load, power generation, and electrical system are shown focusing primarily on power demand and supply and high-level control and dispatch. These models are meant to capture the critical interactions between the total power demand from the compute side of the data center and the required power generation provided by the turbines and generators. Different operational strategies for turbine scheduling will be demonstrated to assess their impact on system performance and robustness over different load profiles. These models can address questions regarding the optimal dispatch strategy for the turbines and the impact of different load management strategies on system performance. Models including the effects of battery energy storage systems are developed to assess the impact of battery sizing and control strategies on the data center operation. The impacts of various failures can also be simulated with these models. These system models are suitable for simulations over multiple time scales. Shorter simulations are shown to focus on load planning and the resulting transient power dynamics. Long time horizon simulations (hours, weeks, months) support operational and economic optimization of data centers with SciML techniques.

The second use case focuses on multi-physics models for data center cooling. Transient models for data center cooling are demonstrated that capture the thermal interactions between the CPU and GPU and the resulting cooling system. Built from reusable components in Dyad, these models are full physical models that capture the lumped thermal dynamics of the chips and cooling system at the server and rack level. They can provide temperature predictions at the lumped chip level to support a higher level of fidelity in the system simulations and for load planning. These models are still suitable for long time horizon simulations as they are lumped but discretized.

A common task in solid mechanics is to select and calibrate a constitutive model for a specific material. Constitutive model discovery seeks to automate this task. The framework statFEM-EUCLID.jl provides an unsupervised approach for constitutive model discovery from sparse and noisy measurements and global reaction forces. Using UMBridge.jl, the framework treats the finite element solution as a black box, such that any finite element solver can, in principle, be linked to it.

The explosion in the number of submitted quantum physics papers is placing the scientific publication system under extreme stress. In an effort to address this challenge, I have been experimenting with end-to-end pipelines for the automated numerical verification of claims in quantum physics papers. Given an arXiv preprint, LLM coding agents extract mathematical assertions into a structured knowledge graph, then generate Julia code to numerically check each claim. I will demonstrate this pipeline across three domains: topologically ordered many-body quantum systems (using, e.g., TensorCategories.jl), quantum information theory, and quantum optics (using QuantumOptics.jl). In practice, this system routinely catches small sign errors and gaps in every paper I have studied. LLM coding agents enable automation of workflows that previously would have involved much yak shaving and frustration. As a consequence, time-poor persons with little software engineering expertise (such as myself!) can now employ the amazing cutting-edge tools the Julia community have developed. I will directly address practical challenges including LLM hallucinations in mathematical reasoning, ensuring correctness of generated code, and the gap between symbolic assertions and finite-dimensional numerics.

Digital twins are evolving from simulation models into adaptive, continuously improving representations of real systems. This talk introduces Ansys TwinAI™, part of the Synopsys portfolio, and outlines how the integration of JuliaHub's Dyad brings Scientific Machine Learning (SciML), differentiable programming, and physics-informed artificial intelligence into digital twin workflows. We will highlight the value of hybrid digital twins and present representative engineering use cases.

This BoF is a roundtable discussion on differentiable computational models and their applications, open to anyone using or developing them in Julia or other languages. We'll discuss:

Experiences, challenges, and solutions from working with differentiable models
Whether existing differentiation packages provide straightforward explanations of their uses and how to implement them in real work
Limitations in current differentiation packages that future development could address
The potential for an org page to consolidate and showcase community efforts and best practices in this space

A triangular shell finite element formulation is implemented in for use with the popular open-source finite element software package Ferrite.jl. Both elastic and geometric stiffness matrices are available, allowing for the calculation of elastic deformations, stresses, and buckling in thin-walled structures. The shell element formulation utilizes linear shape functions to interpolate for membrane deformations, and considers additional quadratic shape functions to predict bending deformation while avoiding shear locking. The triangular shell element is shown to perform accurately when compared to Abaqus shell element and analytical solutions in a series of thin and thick plate examples which consider elastic deformation and elastic buckling.

With this talk, GoMeta will be released. This package finally implements a vastly matured offspring of a [my] half-baked idea proposed at JuliaCon2025.

The core concept remains the same: Add interpretable meaning to comments within a Julia file by means of brief, simple, expressive and extendable metadata. The crux of the idea lies in its potential to serve a wider variety of different packages and even facilitating interactions between them.

However, in order to truly fulfill what had been promised, in particular to allow for the desired expressiveness and extensibility, language-like features had to be incorporated in the proposed schema.

Moreover, metadata needs to be absorbed, i.e.: parsed and interpreted, from somewhere before it can be applied somewhere. Thus far, both tasks had been executed on a Block-level [a section of consecutive lines]. BLS now provides a distinctly finer granularity by introducing Components such as Block, Line and Segment. This not only necessitated a complete overhaul of GoMeta's implementation but also of the grammar being used.

Quantum computing, communication, and sensing technologies rely on precise knowledge of quantum states. Quantum states cannot be directly measured. Quantum state tomography (QST) reconstructs these states from indirect measurements, similar to how CT imaging combines multiple 2D projections into a 3D model. In QST, the goal is to minimize the statistical discrepancy between experimentally observed data and predictions from quantum theory. This optimization problem is nonlinear and subject to physical constraints on the states. We present a Julia implementation that efficiently and robustly minimizes this statistical distance while enforcing these constraints. Our work provides a practical, extensible toolkit for QST and a comparative guide to choosing optimizer based on accuracy, speed, and robustness.

Guidance, Navigation, and Control (GNC) for geostationary satellites is traditionally built with a patchwork of tools: MATLAB for analysis, C/C++ for flight software, and custom scripts for simulation and verification. This session details a case study in replacing those various toolsets with a single Julia-based workflow that runs from early design to orbit.

There has been a rapid spread of AI agents into all aspects of society. The exponential increase in capabilities of these agents has led to new ways of working across nearly every profession. While the adoption of LLMs and agentic workflows has been more common in computer science and software development, the integration of these technologies into engineering system simulation tools is at its infancy. As an engineer with over 25 years of experience in model-based systems engineering across different engineering domains, I have had no previous experience with agentic workflows in my daily work prior to the last few months. Speaking with engineering simulation colleagues in different fields, many of them are in the same situation given that their traditional tools did not offer these capabilities but are now ready and interested to explore possibilities of these emerging technologies.

This talk will offer practical perspectives on agentic workflows focused on engineering system simulation use cases. Using the Dyad AI agent, these use cases will be explored using Dyad, Julia, and ModelingToolkit. The focus of this talk is to provide practical perspectives on agentic workflows in model creation, system model assembly, debugging, testing, and simulation and analysis. The examples will also explore different methods for providing resources to the agent to support the tasks required. Examples in different engineering domains will be presented. Various workflows are critically evaluated to assess effectiveness and accuracy. The focus of this talk is to provide practical perspectives demonstrating use cases that work well, those that are still developing or not yet mature (though certainly might be in future versions of the underlying LLMs), and effective prompting techniques based on personal experience. This talk will be presented via slides documenting the workflows along with live demonstrations within the time constraints of the talk.

The capabilities of engineering simulation tools are rapidly changing and are fundamentally redefining the human and machine interface. Engineers need to quickly adapt to utilize new technologies effectively and responsibly. Though it is certainly impossible to gain a deep understanding of agentic workflows within the duration of a single talk, the hope is that this talk demystifies the use of agentic workflows in system simulation within the Julia ecosystem, inspires critical thinking within the context of an engineer’s unique workflows and simulation needs, and provides practical perspectives that can lead to more effective usage as engineers start to adopt these new technologies.

Infectious disease models that integrate multiple data sources provide better evidence for outbreak response than chains of separate models, but building them is slow and requires expertise across domains.
Composable modelling, where validated components combine into joint models that properly propagate uncertainty, addresses this but requires an ecosystem of reusable infectious disease model components.
We believe Julia is the best language for this ecosystem due to its type system, multiple dispatch, automatic differentiation support, and existing scientific computing infrastructure (SciML, Turing.jl, Distributions.jl), which provide the foundations composable modelling needs.
In this talk, we present the EpiAware roadmap for creating and sustaining that ecosystem, our current progress, and our questions for the Julia community.

In R, we have built the epinowcast ecosystem (packages, community forum, seminar series) and developed several other widely used packages including EpiNow2 and scoringutils.
We want to create something equivalent in Julia: a domain-focused ecosystem in the mould of SciML or Turing.jl, with the community infrastructure of rOpenSci and the domain specificity of SpeedyWeather.jl.

So far, we have CensoredDistributions.jl, which handles common biases in epidemiological delay distributions, and an R interface prototype (EpiAwareR).
We initially plan to implement packages covering distribution extensions for epidemiological use, delay and generation time estimation, disease dynamics components, and forecast evaluation, alongside a centralised documentation site.

At the package level, we need to answer questions about what makes a good Julia package in our ecosystem: consistent documentation via DocStringExtensions and DocumenterCiterepress, robust testing with Aqua.jl and JET.jl, automatic differentiation backend testing via DifferentiationInterfaceTest, and where we need package extensions (e.g. for Turing.jl integration).

At the ecosystem level, we need to understand how to manage releases so that package versions work together, how to run reverse dependency checks before publishing, how to set up shared CI and centralised documentation across many packages, and how to help users understand which automatic differentiation backends are compatible when they combine multiple packages.

Round-table open discussion of everything about Dagger.jl. Success or failure stories, gripes and joys, ideas for new features, discussion of existing bugs or missing documentation, and more!

An hour for users of Makie.jl to gather, show off cool plots, and talk about the state of the Makie ecosystem!

juTarget is a browser based Linux application for M. tuberculosis tNGS data analysis that applies a hybrid ML method for predicting drug resistance. Industry standard toolkit has been used to identify the variants compared against the WHO catalogue. Furthermore, the resistance profile for novel variants is predicted by Random Forest using a feature set of 30 biophysical properties of amino acids. Molecular Drug Susceptibility Report is generated which can be used as a clinical decision-making tool.

Delay distributions describe the time between epidemiological events, such as infection to symptom onset or symptom onset to hospitalisation.
Estimating these distributions from outbreak data is difficult because both the primary event (e.g. infection) and the secondary event (e.g. symptom onset) are usually only known to have occurred within a time window, such as a day.
Real-time outbreak data is also often right-truncated as longer delays have not yet been observed.
Ignoring double interval censoring and truncation biases parameter estimates which are then used for forecasting and transmission modelling.

Adjusting distributions for primary event censoring addresses this by integrating the delay CDF over the primary event window, weighted by the density of when, within the window, the event occurred.
This can then be combined with truncation and secondary interval-censoring adjustments to produce a double-interval-censored and right-truncation-adjusted distribution.

In this talk, we present CensoredDistributions.jl, which implements these adjustments as primary_censored, interval_censored, and double_interval_censored, composable Distributions.jl wrappers.
Multiple dispatch selects closed-form CDFs for delay and primary event distribution pairs where these are available, and falls back to numerical integration otherwise.
We demo the package standalone and with Turing.jl for parameter estimation.

We then compare to primarycensored, our equivalent R package, which also ships a duplicate set of Stan functions so users can fit models in either language.
Maintaining two parallel implementations required reimplementing distribution functions in Stan, building tooling to vendor Stan code into downstream projects, and replacing types with integer distribution identifiers.
Stan's integral solver was also unstable for this problem, so we had to recast it as an ODE.
Julia's multiple dispatch and ecosystem composability eliminates all of this.

We then summarise our plans to build a composed Julia version of our epidist R package, using CensoredDistributions.jl as a foundation with Turing.jl submodels for partially pooled and flexible delay estimation.

Tracking active security advisories (like CVEs) is a critical requirement for many orgs to use and deploy code... but it can't work without the advisories themselves! The new SecurityAdvisories.jl database enables exactly that for Julia packages and their upstream artifacts (like JLLs). Building such a system in a manner that is both sustainable and manageable for thousands of packages is not trivial; I'll be discussing key factors in how it works and how package maintainers and users alike can make use of it.

MEDYAN.jl is a framework for modeling the cytoskeletal filaments and associated proteins that shape and move cells. New declarative rules for dynamic mechanical and chemical bonds, accelerated by new spatial data structures, enable simulations as large as a whole T-cell or as detailed as the individual reactions in a motor protein step. These improvements help bridge the gap between single molecules and cell behavior on timescales of minutes and length scales of micrometers.

We introduce SignatureTensors.jl, a new package for computing signature tensors of paths and membranes. By leveraging the symbolic computation framework provided by OSCAR, the package implements flexible algebraic structures for truncated
tensor signatures, and provides efficient constructors for path signatures. Furthermore, it features implementations of Lie group barycenters and optimized algorithms for learning from signature tensors. We illustrate the package’s versatility with practical applications in geometric statistics, feature extraction,
spline interpolation, and computational algebraic geometry.

Coulomb Explosion Imaging is a booming method to image small molecules. Its principle is relatively straightforward: remove as many electrons as possible as fast as possible from a molecule to induce its explosion into atomic fragments.

Simulating this process is crucial to interpret the experimental data. In this talk I will briefly describe the concept of an x-ray induced Coulomb explosion, introduce a semi-classical model to simulate it and present how I implemented it.

In this talk we will introduce ParallelTestRunner.jl, a package for running in parallel the tests of Julia packages, using a very simple infrastructure, well integrated with Julia's Test's standard library. We will showcase ParallelTestRunner.jl's features, which include filtering of test files, and provide practical dos and don'ts when using this package.

A precise material deposition is nowadays a key component of any microchip production. A prominent deposition technique offering the required level of control is area-selective atomic layer deposition. To improve this technique the chemical reactions of the adsorbates at the substrate surface are modeled. Here, the presented random sequential adsorption approach targets to model the adsorption and packing of the first adsorbate layer. Implementation of the key assumptions as well as first results are part of this contribution.

Periodic structures create band gaps that restrict electromagnetic and elastic wave propagation. These gaps enable control of light and sound at the wavelength scale. PhoXonic.jl is the first pure Julia tool computing both photonic and phononic dispersion relations through a unified interface using plane wave expansion. It supports 1D, 2D, and 3D with dense and sparse solvers, and includes topological invariant analysis. Results reproduce published literature.

Round table discussion on using Julia for computational biology: Use cases, limitations and concerns we should address, and where to focus our collective efforts.

Julia was created by greedy programmers who wanted it all. What if we are equally greedy about tooling? This session invites discussion on missing capabilities in Julia’s development tools. What tools or workflows still fall short? Where should future efforts be made to improve productivity and insight?

This talk discusses our efforts to implement artificial intelligence (AI) workloads on a Ray commodity cluster using the Julia programming language. Similar to Apache Spark, Ray is a cluster computing environment for data analytics and AI workloads, mainly in Python. First, we present the configurations and setup steps for a Ray cluster. Next, we discuss the implementation of three distributed clustering algorithms in Ray: partition-based (a variant of distributed KMeans), hierarchical (the PACk algorithm), and graph (filtered graphs with a distributed hierarchical bubble tree). Specifically, we emphasise the integration of Julia and Python within Ray. Finally, we contrast the Ray environment to Apache Spark and highlight the lessons learned (limitations and advantages) throughout this experiment.

BeamletOptics.jl (BMO) is a Gaussian beamlet tracing package built on top of a geometrical ray tracing solver. It can be used to prototype laboratory optical setups featuring laser sources. BMO features a signed distance function (SDF) based geometry representation which allows for the accurate modeling of surface normals. It offers a variety of optical models for common components, like mirrors, lenses, beamsplitters and detectors. In addition, the API allows for the easy implementation of custom optical elements. This talk will focus on the current state of the package, feature several showcases and outline future development goals.

We implemented a Rust-based virtual machine that accepts and executes a subset of Julia syntax.
This enables Julia code to run in environments where the official runtime is difficult to deploy. By compiling the VM to WebAssembly, Julia can run web apps for educational purposes, and static linking with Swift or Flutter allows mobile applications. This short talk demonstrates these capabilities through live demos.

The phase field method simulates microstructure evolution and phase transitions. PhaseFields.jl is the first pure Julia package providing major phase field models with built-in FDM and FEM (via Gridap.jl) and adaptive time stepping (DifferentialEquations.jl). It couples with OpenCALPHAD.jl for chemical potentials via automatic differentiation from CALPHAD databases. We demonstrate spinodal decomposition, CALPHAD-driven solidification, and Stefan problem validation.

Pluto is a fun-to-use teaching tool. But in order to allow for this seamless experience, it needs to be so much more! It's a reactive execution engine, that works over a robust remote websocket, analyses code, communicates logs, status and rich MIME results! Sounds familiar? This is more than what a notebook does. So why should we limit ourselves in the HTML world when, for example AI Agents can't really -natively- see? In this talk we present the VSCode Extension we made for Pluto, where we wrap Pluto's backend functionalities with a native VSCode Notebook UI.

Julia supports defining new integer types. However, they are currently limited to byte size. Until this restriction is lifted, we can emulate arbitrary bit-sized integers with larger byte-sized ones which should behave identical to future native bit-sized integers. This is what EmulatedBitIntegers.jl does as a generalization of BitIntegers.jl to non-byte-sized integers.

This emulation produces unused bits. Often, structs can be used to combine such types with other emulated integers, making use of the unused bits of one emulated integer to store the content of another emulated integer. This is done with PackedStructs.jl which allows annotating structs to have their fields packed on bit-level to not waste a single bit, because: Every Bit Counts!

Pseudospectra generalize eigenvalue analysis by characterizing how the resolvent norm of (zB - A)^{-1} varies over the complex plane, revealing transient behavior and stability properties that eigenvalues alone miss.
Growing demand from non-Hermitian physics, power systems, and data-driven robust control necessitates large-scale pseudospectral computations that existing CPU-based tools cannot efficiently handle for large dense matrices.

In this talk, we present KAPseudospectra.jl, the first GPU-accelerated pseudospectra package, built on KernelAbstractions.jl for vendor-neutral execution across supported backends.
The package implements a batched Inverse Hermitian Lanczos (IHL) iteration that approximates the smallest singular value at each grid point in only a few steps, requiring O(N^2) operations at each grid point after a single O(N^3) CPU-only Schur decomposition.
Central to the IHL iteration is KATRSM.jl, a submodule providing batched triangular solvers that keep the pencil (zB - A) factored on-device, largely eliminating host-device data movement.
Multi-device parallelism is achieved by partitioning the complex grid across available GPUs with automatic memory-aware batching.

We demonstrate the package on matrices up to dimension 2^14, and discuss the design decisions that enable this codebase to target multiple compute backends through Julia's package extension system and KernelAbstractions.jl.

The Julia standard testing experience can feel quite frustrating.
No interface to run a specific test, difference of project environment, keeping the right context etc...
TestPicker provides a simple REPL mode to run any specific testfile or testset with the same conditions as Pkg.test() without introducing a new testing framework.
It provides on top some nice bonuses like inspection of the results or quick reruns of the same tests.

Pfaffian point processes (PfPPs) most famously arise in the eigenvalue distributions of random orthogonal or symplectic matrices, but also appear in the description of other stochastic processes, such as annihilating and coalescing random walks, random involutions, or symmetric corner growth. We introduce novel sampling algorithms for discrete and continuous PfPPs, as well as a method for constructing skew-symmetric kernels based on skew-orthogonal polynomials derived from arbitrary weights.

Dynamic magnetic field generation is essential for numerous applications but grows power-intensive with system scale. Non-linear current-to-field relationships in soft iron core designs complicate the inverse current problem. This work formulates power-efficient control as a nonlinear program with algebraic constraints on field and gradient strength, solved using JuMP.jl and IPOPT.jl. Spherical harmonic expansions provide the polynomial field representation for efficient optimization on consumer hardware.

Have you ever tried sharing Julia code that computes the Lorenz attractor using DifferentialEquations and visualises it in Makie? I haven't—because the TTFX is unbearable. Users often wait 5+ minutes for compilation during project instantiation, creating an unacceptable first-time experience. What if we could ship precompiled dependencies just like Julia's standard libraries? This is what Jumbo Julia does.

In this talk, I'll explain how Julia distributions work and what's included in Jumbo Julia, including the tradeoffs imposed by package compatibility constraints that can force older versions. I'll demonstrate common workflows and project instantiations to illustrate both capabilities and limitations. Then I'll show you how to create custom distributions for your own package sets. I'll conclude by speculating on how Julia distributions could solve the PkgImage distribution problem in the short term within Pkg itself.

Neuroblox.jl is designed for computational neuroscience, pharmaceutical, and psychiatric applications. Our tools range from control circuit system identification to brain circuit simulations bridging scales from spiking neurons to fMRI-derived circuits, parameter-fitting models to neuroimaging data, interactions between the brain and other physiological systems, experimental optimization, and scientific machine learning.

In this talk we will give an update on the new features we added in the last year, including a new DSL for interacting with Neuroblox, a rich library of pharmacologically relevant receptors, and new GUI features. We'll also discuss our progress on running Neuroblox on various accelerators, and algorithmic improvements we've made to our solving infrastructure.

Information about the sensitivity (the derivative) of a function is of great use in, among many other things, non-linear optimization and root-finding algorithms.
In particular, second-order derivative information (curvature) can be used to accelerate such solvers, for example, the Newton method for optimization and Halley's method for root finding.
Automatic Differentiation (AD), where these sensitivities are effectively available "for free" (in terms of developer time investment), is therefore attractive since it can significantly reduce the time of an implementation. In addition, the performance cost of the AD may either be close to a hand-optimized implementation or not be significant compared to other parts of the full problem, making AD attractive even from a performance standpoint.

In Julia, there are many packages for AD, each with different trade-offs. They might use forward mode AD or reverse mode AD, they might be implemented using operator overloading or by using code inspection, or they might focus on a certain application like machine learning, etc.
HyperHessians.jl is a Julia package for forward mode AD that specializes in taking second-order derivatives (Hessians). It does this by using HyperDual numbers, which is an extension of Dual numbers. By adopting hyperdual numbers, we can show performance gains over traditional nested dual numbers for second-order derivatives, which is employed by, e.g., ForwardDiff.jl. In addition, HyperHessians.jl supports computing Hessian-vector products (Hvp) and quadratic forms (v'Hvp) at a much lower cost than computing the full Hessian, which is not available with straightforward usage of ForwardDiff.

In this presentation, I will go through some of the theory behind hyperdual numbers, how this theory is implemented in the HyperHessians.jl package, some of the implementation considerations, and present some benchmarks (both micro and real-world benchmarks) that show HyperHessians.jl has value as yet another AD package in the Julia AD ecosystem.

Recent outbreaks of Ebola, COVID-19 and mpox, alongside routine surveillance of endemic pathogens, have demonstrated the value of modelling for synthesising data to inform decision making. For modelling evidence to effectively inform policy it must be timely, rigorous, and collaborative, yet current approaches struggle to be all three. Methods broadly fall into approaches that chain separate models together, offering flexibility but losing information and introducing bias, or approaches that rigorously analyse all data together but cannot be separated into reusable parts. Composable models, where components can be reused across contexts, can be both rigorous and flexible, enabling rapid collaborative model development. We outline design considerations for a composable infectious disease modelling framework and present a proof of concept domain-specific language built on the Turing.jl probabilistic programming language in Julia with an R interface. We demonstrate our approach conceptually using models from published epidemiological analyses, and in practice through a worked autoregressive example. We replicate three published analyses, composing elements of our autoregressive example with shared and novel components: a COVID-19 analysis for South Korea using a renewal process, adding components for reporting delays and day-of-week effects to replicate EpiNow2 for real-time nowcasting, and an ordinary differential equation analysis of influenza outbreak data. We then discuss strengths, limitations, and alternative approaches. We find that our proof of concept can address the tension between rigour and flexibility, though work remains to realise this potential. Our approach enables interdisciplinary collaboration by lowering technical barriers for domain experts to contribute specialised components, supporting both routine surveillance and outbreak response. For multi-model efforts, common components enable attribution of differences to assumptions rather than implementation. Our approach is also well suited for large language model assisted model construction. This study demonstrates that a composable modelling approach has the potential to incorporate diverse modelling approaches and domain knowledge across different infectious disease contexts.

Bayesian spatial modeling is critical across science, yet most practitioners are locked into R due to R-INLA.
We present a Julia ecosystem to change this: GaussianMarkovRandomFields.jl provides fast sparse precision-based inference via SPDE discretizations & more, while IntegratedNestedLaplace.jl brings the full INLA methodology to Julia with a familiar formula interface.
We demonstrate the ecosystem on spatial disease mapping, showing competitive results with R-INLA and native Julia advantages.

Julia Gender Inclusive is an initiative dedicated to strengthening gender diversity and inclusion within the Julia community. We are a group of people whose gender is underrepresented in the community and aim to provide a supportive space for all gender minorities in the Julia community. Over the last year, we have worked toward increasing participation in our community by creating and organizing more virtual events, such as regular coffee meetings and hackathons. In this talk, we will share our recent outcomes, lessons learned, and concrete ways the broader Julia community can support and engage with our efforts.

Zed support for Julia is growing!

We'll talk about working and missing features and how Zed today against other Julia supporting editors.

It is time again to take a look at what new exciting things have happened with Julia; the language, the package ecosystem and the community. Join us as we explore these advancements and celebrate the progress of Julia in in the past year.

Thank you all for joining us in Mainz! Safe travels, and see you all next year!