JuliaCon Local Paris 2025

-

Randomization is a powerful dimensionality reduction technique that allows to solve large scale problems while leveraging optimized kernels and enabling the usage of mixed precision. In this talk we will review recent progress in using randomization for solving linear systems of equations or eigenvalue problems. We first discuss sketching techniques that allow to embed large-dimensional subspaces while preserving geometrical properties and their parallel implementations. We then present randomized versions of processes for orthogonalizing a set of vectors and their usage in the Arnoldi iteration. We discuss associated Krylov subspace methods for solving large-scale linear systems of equations and eigenvalue problems. The new methods retain the numerical stability of classic Krylov methods while reducing communication and being more efficient on modern massively parallel computers. We finally discuss their implementation in a Julia library.

What do growth from a corner, random domino tilings, nonintersecting paths and Young tableaux generated from random words have in common? That they can all be simulated in Julia of course! This talk will present various Julia packages for the statistical analysis of determinantal point processes just like these with a focus on interactive exploration through tools such as Pluto.jl and WGLMakie.jl.

In this session, the Pluto developers will teach you how to use Pluto notebooks for computational storytelling to write compelling, interactive articles and dashboards. This tutorial will help you write a lecture for students that's actually more interesting than the latest tiktok trend!

In Float64, 0.1 + 0.2 – 0.3 is not zero due to round-off errors. Try it. Stochastic rounding provides a trick: floating point rounding is done probabilistically: sometimes up, sometimes down. This allows for numerical simulations on hardware made for machine learning, where Float16 precision is common. We can perform meaningful simulations even with limited bits.
And yes, all of this can be done in Julia.

Climate change challenges demand assessing the resilience of key sectors, such as energy and agriculture, to future weather conditions.
Stochastic Weather Generators (SWGs) are essential tools for this purpose, enabling efficient sampling of climate statistics—especially extreme events.

Combined with impact models like crop models, SWGs can be used to stress-test and measure system sensitivity to climate variability, particularly under climate change. For example, estimating the frequency of long dry spells is crucial.

The StochasticWeatherGenerators.jl package implements several SWG models, including those based on Hidden Markov Models and GeoStatistics functions.
Its goal is to provide a range of models and tools to facilitate comparison and experimentation.

Thanks to Julia’s powerful ecosystem and capabilities, defining, fitting, and using stochastic weather generators has never been easier!

Sampling is at the base of many statistical methods and procedures. Apart from the traditional sampling from finite populations available in StatsBase.jl, there are many more methods and techniques which could be of interest in specific simulation scenarios where performance and memory consumption are critical. In such cases, packages implementing sampling methods for streaming data could be particularly advantageous for scalable and efficient simulations.

Our package implements the parallel-tempering Monte Carlo method to study the thermodynamics of physical systems. Several copies of the system at different temperatures, randomly initialized, are evolved in parallel and allowed to exchange information of their current state. We make extensive use of Julia’s dynamic type system and multiple dispatch to unify implementations for different ensembles, interaction potentials and boundary conditions; multi-threading is used for parallelization.

ModelingToolkit.jl provides many benefits as a symbolic component-based modelling language, including efficient code generation and structural simplifications. However, it is limited in its extensibility outside of the SciML ecosystem. Being able to integrate and connect ModelingToolkit systems with other modelling tools in Julia like Agents.jl and with external libraries would open up a range of hybrid modelling options to the Julia community.

TulipaClustering.jl introduces a greedy hull clustering method designed to better preserve constraint-binding extremes in optimization problems, especially within energy systems modeling. This approach yields more accurate reduced models for improved downstream optimization performance.

ClimFlows is an ongoing effort to develop an ecosystem of composable and extensible packages from which one can compose a variety of climate-relevant numerical models, especially for oceanic and atmospheric circulation, from toy models to realistic solvers.
While implementation is important, interfaces (APIs) are essential for the composability and extensibility of such an ecosystem. The talk will exemplify how building blocks of the ecosystem (spectral harmonics transforms, time integration, thermodynamics...) can be composed into two global atmospheric solvers, focus on a sample of packages and their interfaces, and discuss future work and interaction with the Julia community.

A supercapacitor is a complex charge storing device which relies on multiple physical phenomena, namely electrical double layer formation and pseudocapacitance, that are to this day not so well understood. When theory stagnates, so does innovation. Where trial and error give results, it could give faster results if the trial could be guided by knowledge. Part of the process in trying to understand how a supercapacitor works is finding an equivalent circuit model, acting as a sort of a rigorous guide through uncharted territory using charted territory in the form of already known circuit elements which describe, to some extent, the physical phenomena behind a supercapacitor. Therefore, this is what the presented work is concerned with, using Julia to find a circuit model from acquired supercapacitor data.

We present a Julia implementation of extended Kohn-Sham models (LDA/LSDA) for computing ground states of atoms and ions using high-precision finite element methods. Originally developed to investigate the existence of negative ions, the code also serves as a versatile tool for testing new density functionals, studying numerical precision issues.

The use of Fourier series for high-order trigonometric interpolation can be found in a plethora of applications in science and engineering. Here we present a framework for constructing and testing recently-introduced extension operators that can enable such representations for non-periodic functions (while avoiding the ringing effect). This can ultimately facilitate the construction of high-performance FFT-based solvers for PDEs with general boundary conditions.

MedEye3d.jl is a vital Julia package for 3D medical image visualization, playing a crucial role in workflows from registration to segmentation analysis. This talk introduces recent advancements in MedEye3d.jl, stemming from GSoC, that push it towards a "digital twin" for medical imaging. We'll explore the implementation of a novel multi-image display mode, enabling concurrent visualization of registered heterogeneous studies (e.g., CT and PET). A key focus will be the introduction of dynamic supervoxel border rendering and interactive highlighting across these linked views, allowing for intuitive comparison and analysis. We'll also touch upon new features for interactive supervoxel association correction and control point annotations, significantly enhancing the tool's utility for registration, orientation, and detailed visual inspection. These enhancements leverage Julia's performance and ModernGL.jl for a responsive and powerful user experience, further solidifying Julia's position in the medical imaging domain.

The concept of embedding formalized meaning into a Julia file's comments by means of brief, simple, expressive and extendable metadata is firstly motivated at JuliaCon 2025 in Pittsburgh.

In Paris, this talk will greatly expand on the previous one, in depth and breadth by illustrating the various benefits gained from adding parsable meaning to a file's content.

To this end, GoLiterate will be formally introduced. It serves a variety of different packages and facilitates interactions between them.

Sponsor talk by Temple Capital

Sponsor talk by Eutelsat OneWeb

Sponsor talk by JuliaHub

Bcube.jl is a new open-source Julia package developed at ONERA to solve PDEs on unstructured meshes using finite element and discontinuous Galerkin methods. It enables flexible, efficient, and unified multi-physics simulations. This talk presents the package's philosophy, architecture, and capabilities through diverse examples, and shares insights on using Julia in an industrial research context.

Symbolic learning is a branch of machine learning that studies algorithms for building symbolic models, classifiers that can be translated to logical rules. Hence, differently from neural networks and other statistical models, symbolic models are more easily readable and interpretable. Common examples include decision trees and their ensemble counterpart, random forests.

Sole.jl is a Julia package for symbolic learning and rule extraction, aimed at guiding the user throughout the whole process, from the initial data to learning a symbolic model, to the extraction and manipulation of logical rules from such model.

It is also the entry point to the SOLE framework (which stands for SymbOlic LEarning), an open-source project fully developed in Julia, serving as an interface to both its main packages, such as SoleData.jl, SoleModels.jl, SolePostHoc.jl, as well as useful packages developed by the learning community, such as DecisionTree.jl, ModalDecisionTrees.jl, ModalAssociationRules.jl, MLJ.jl, XGBoost.jl, and so on.

For instance, given a dataset, one can use Sole.jl to fit a decision tree model, provided by the DecisionTree.jl package, and then extract and eventually manipulate rules from such model through the SolePostHoc.jl package. Furthermore, if working with more non-tabular data like images or time-series, one can leverage the SoleData.jl package to interpret the dataset as a set of logical interpretations of a more-than propositional logic (e.g., interval or rectangle modal logic) and use a learning package compatible with such logic, such as ModalDecisionTrees.jl or ModalAssociationRules.jl.

In this presentation, we will have a look at how Sole.jl works through a hands-on tutorial, emphatizing on its comprehensiveness and user-friendliness. This will also allow us to introduce two newcomers to the SOLE ecosystem: ModalAssociationRules.jl, a package for mining association rules between instances, and SolePostHoc.jl, a package to extract, interpret and simplify sets of rules starting from a symbolic model.

Computational Earth Science relies on modelling to explore complex physical systems that are difficult to observe directly and where data is limited. This is especially crucial in geodynamics and ice sheet dynamics, both of which require large-scale simulations on next-generation HPC systems. These simulations benefit significantly from automated data-driven model constraints, enhancing accuracy and predictive capability.

BetaML.jl is a lightweight, pure-Julia machine learning library with a scikit-learn-like, consistent API, designed for usability over complexity. It supports decision trees, neural networks, clustering algorithms, and essential ML workflows, with heuristics that simplify usage and a one-parameter autotuning system. This talk highlights its new features: missing value imputation, non-linear dimensionality reduction via autoencoders, and variable importance metrics.

Recurrent neural networks (RNNs) are deep learning (DL) models for sequential data, with many variants developed over the last two decades. However, core DL libraries typically offer only a limited number of cell implementations. In this talk, I introduce RecurrentLayers.jl and LuxRecurrentLayers.jl, two libraries that extend Flux and Lux with over 30 additional RNN cells each, enabling broader experimentation and research.

We present Chmy.jl, a Julia package for developing scalable finite-difference solvers, with a focus on portability, ease of use, and minimal overhead. Chmy.jl contains modules for working with structured staggered grids, discrete fields, finite-difference and interpolation operators, boundary conditions, and distributed computing. Users can use Chmy.jl in functions that execute both on CPUs and GPUs supported by the JuliaGPU ecosystem.

Nonuniform FFT (NUFFT) algorithms enable the efficient evaluation of Fourier series from non-equispaced points. They have a wide range of applications, from medical imaging to the simulation of physical systems. The NonuniformFFTs.jl package provides a highly optimised NUFFT implementation, compatible with CPUs and with various GPU platforms. I will discuss its unique features and the strategies that make it one of the fastest available GPU implementations for large-scale problems.

Traditional message passing-based Bayesian inference algorithms are fast but often struggle with real-world models that lack closed-form update rules, such as those with non-conjugate terms or any external code integrated into RxInfer: differential equation solvers, root finding, or even code outside of Julia. The Bayesian inference package RxInfer (from v3) introduces a powerful projection mechanism that overcomes this limitation, enabling modelers to maintain the speed of message passing while handling complex model components.

The core idea is simple: you define your joint distribution in Julia, then annotate challenging factors with ProjectedTo(<family>) constraints. RxInfer then automatically derives the necessary inference approximations and delivers streaming estimates of posterior distributions. This talk will demonstrate this workflow through two compact examples: a hierarchical Gaussian filter for choice data and integrating an ordinary differential equation (ODE) solver for an SIR epidemic model. Attendees will receive runnable notebooks and a clear recipe for applying reactive variational inference to their own non-conjugate or simulator-based models.

Modern computing relies on parallelism, from GPUs accelerating AI workloads to multi-core CPUs in every laptop. But writing code that harnesses this power across different hardware remains challenging. In this talk, we'll explore how KernelAbstractions.jl brings GPU-style programming to Julia, allowing you to write parallel kernels once and run them anywhere.

When using parametric dynamical models with partial observations, one important task is to infer the parameter values and the states from the measurement data. One of the obstacles to a successful estimation can be the lack of structural identifiability. This means that an unambiguous estimation is impossible due to the very structure of the model, regardless of the quality and quantity of data. We will present StructuralIdentifiability.jl, a Julia package capable of detecting identifiability issues, exploring their nature, and suggesting model transformation improving identifiability.

Reactant.jl is a package that takes a Julia function operating on arrays, and compiles it into the MLIR representation. It can then run fancy optimizations on top of it, including using EnzymeMLIR for automatic differentiation, and create relevant executables for CPU/GPU/TPU via XLA.

Universal Differential Equations (or UDEs for short) have emerged as a novel way to integrate information
from experimental data into mechanistic models. In this talk I will present ModelingToolkitNeuralNets, a package intended to help with embedding neural networks inside ModelingToolkit models.

Optimal control problems of ordinary differential equations are challenging numerical problems to solve with applications in many fields, including a current strong trend in quantum control. The aim of this talk is to present the ongoing effort made in the framework of control-toolbox.org with the Julia package OptimalControl.jl, within a collaboration involving Inria, CNRS and Argonne. The focus will be on so-called direct methods that discretise the control problem into a large sparse nonlinear mathematical program. The numerical solution then heavily relies on sparse automatic differentiation (AD) and sparse numerical linear algebra for optimisation solvers. This includes remarkable progress in Julia with such packages as Enzyme.jl, ADNLPModels.jl, ExaModels.jl or MadNLP.jl. The last two packages, in particular, allow to take advantage of the natural massive SIMD parallelism of the discretised problem to provide efficient solving on GPU's.

Modelica is one of the most used standards for modeling and simulation of multi-physics systems. It also has some flaws that are yet to be corrected.
Julia SciML ecosystem offers a recent alternative to Modelica.
This talk shows with simple examples the hopes that SciML brings to the system simulation world and the current shortcoming of this solution, in comparison with Modelica.

We present an idiomatic Julia interface to Vulkan, a high-performance cross-platform graphics API for GPUs. As an extremely large and complex specification, Vulkan is hard to interface with by hand while guaranteeing correctness of execution. Fortunately, clear patterns and a structured specification format enable various automations that allowed us to lift the C API to a much more convenient high-level API. We will present this process in detail, and provide example applications.

Optimal control is a ubiquitous problem spanning applications of aerospace engineering to chemical processes. Because of that, there are as many softwares for solving optimal control problems as there are applications and domains. Is it possible to unify all optimal control software under one interface? Well that's what SciML does, and we've now entered this domain. In this talk we will demonstrate how ModelingToolkit can be used as a frontend to optimal control that is able to target many of the backend solver methods used throughout various domains. We will also showcase new solvers, built from adaptive BVP solvers, which greatly outperform the standard NLP formulation.

Writing a loop to add up all the elements in an array is often featured in tutorials and training materials — it's just five lines of code, and can be remarkably generic and performant. Yet there are a surprising number of challenges in determining exactly how such a function should operate while ensuring consistent generic behaviors, numeric accuracy, high performance, and an extensible interface.

This talk will describe these challenges and some of their solutions, looking at both the specific designs of Julia's builtin reduction machinery (and how it may change) as well as general learnings about best practices when designing such highly generic, performance-critical, and extensible interfaces.

Model Discovery is a symbolic-numeric method that modifies the physical equations of a dynamic system in order to fit test or telemetry data. In this talk, we introduce the Model Discovery pipeline in the Julia product Dyad, which builds upon Universal Differential Equations and other SciML methods.

Ket.jl is an open-source Julia package tailored for quantum information science, focusing on nonlocality and entanglement. It offers a suite of tools for constructing and processing quantum states, measurements, and channels, all designed to work seamlessly with JuMP. By supporting arbitrary-precision arithmetic, Ket.jl enables researchers to perform high-precision computations essential for exploring quantum phenomena and solving complex optimization problems. Ket.jl's design facilitates integration into optimization workflows, making it a valuable tool for both theoretical investigations and practical applications in quantum information science.

Graph Neural Networks (GNNs) are powerful models for learning from graph-structured data, but their performance can depend critically on how message passing is implemented. In this talk, I will present my Google Summer of Code project with the Julia organization, aimed at accelerating GNNs by improving support for sparse computations on GPUs. By leveraging sparse-dense matrix multiplications—rather than the traditional gather-scatter paradigm—for layers such as graph convolutions, we can reduce memory overhead and improve performance. These enhancements are integrated into the GraphNeuralNetworks.jl package, helping bring Julia’s GNN ecosystem closer to state-of-the-art frameworks in other languages.

You and I both think Julia is the best language! Faster than Python, more flexible than R, better syntax than C++. So why are these other languages still dominant in scientific computing, and growing? Why is it a "weird choice" to teach your class in Julia?

This talk explores what Julia could look like if we designed it entirely for future users. Drawing from the Pluto project's work with students and teachers, plus lessons from other language ecosystems, I'll share a vision for making Julia's technical advantage actually accessible to the people who could benefit most from it.

With the ever increasing computational cost of machine learning applications in mind, the need to explore alternative learning paradigms becomes apparent. One such paradigm would be to exploit the massive parallelism of physical systems. We introduce a metamaterial based on coupled nonlinear resonators that learns in-situ, and show how we are able to study it seamlessly across various levels of abstraction, building on Julia and the extensive ecosystem for scientific computing.

In this presentation, we showcase Parameter-Learning in soil carbon modeling, a scientific machine learning paradigm where a process-based model is parameterized through the use of a neural network. This enables us to learn latent soil properties from soil carbon data, leveraging the Julia’s ML and auto-differentiation ecosystems. The resulting hybrid model is more explainable through the latent variables, and more robust as it is constrained to a process-based model.

The Helmholtz equation is essential to modeling wave scattering problems in periodic structures. Green’s functions, which solve linear partial differential equations with Dirac delta function sources δ(x), provide a foundation for recasting these problems into boundary integral equations. While closed-form expressions exist for many settings, the quasi-periodic Green’s function for the Helmholtz equation poses a unique challenge: it is defined as an infinite series that converges slowly as x2 → 0 in 2D (or x3 → 0 in 3D).

In this talk, we introduce QPGreen.jl, which implements an FFT-based algorithm to efficiently evaluate these Green’s functions. It combines spectral truncation and interpolation to overcome the limitations of direct series summation. Leveraging Julia’s composability, we combine QPGreen.jl with Inti.jl—a boundary integral equation solver—and demonstrate applications to wave scattering problems with quasi-periodic incident fields.

We use DuckDB as a backend to generate JuMP variables and constraints using SQL. This enables memory-efficient slicing, reusable indices, and traceable constraints. In TulipaEnergyModel.jl, this reduced preprocessing time and memory usage by up to 50%, improving scalability and clarity.

The principle of Coulomb explosion imaging is simple: use a powerful x-ray pulse to slap a molecule so hard that it (literally) explodes into its constituting atoms. The fragments can then be measured to produce an indirect image of the molecule.

Currently, a key question in the Coulomb explosion community is what we can actually learn from these measurements. What information is preserved about the state of the molecule just before it exploded?

Our simulations show that if the detectors are perfect, we can use this method to image advanced properties of the molecule, namely the high dimensional shape of its ground-state quantum fluctuations. Unfortunately, we can't directly use the experimental data to this end, because it suffers from several key limitations. We circumvent them by fitting a high-dimensional distribution to the data using gradient-based optimization to perform the fit. Then we simply perform our analysis on the fitted model.

Putting everything together, we demonstrate that the experiment indeed succeeds in imaging subtle quantum properties of the studied molecule.

This talk introduces UncertaintyQuantification.jl , a generalised framework for uncertainty quantification. The framework has undergone extensive development since its initial release in August of 2020 and now includes a number of numerical algorithms to quantify and propagate uncertainties. We have previously presented the package at two scientific conferences and now want to share it with the wider Julia community.

In this talk we discuss a significant subset of the features currently available. Adequate illustrative numerical examples from various engineering disciplines are presented throughout, to highlight the capabilities of the implemented algorithms.

Quantum technologies exploit small-scale systems to advance computation, communication, and metrology. In this work we develop theory and algorithms for optimal pulse control using indirect methods based on Pontryagin maximum principle. Simulations and numerical solution are obtained by means of the Julia package OptimalControl.jl to couple direct and indirect methods. We also use Julia to implement efficient algorithms to generate the free Lie algebra in the Hall basis to assess controllability of quantum systems.

Quantum many-body problems famously scale very badly and sometimes it cannot be avoided to work with a Hilbert space of infinite dimension. Rimu.jl can represent a Hamiltonian as a sparse matrix and implements a projector Monte Carlo method that can sample the ground and low-lying eigenstates, even when the matrix size is huge. This talk will introduce the Rimu.jl package and focus on updates since the JuliaCon24 talk. The highlights will include a new link to the quantum chemistry package ElemCo.jl and a bias-free taming of the Monte Carlo sign problem in the Fröhlich polaron model with a formally and practically infinite Hilbert space.

Tractography.jl is a Julia package for reconstructing numerical representations of white matter (WM) fiber pathways in the brain from magnetic resonance imaging (MRI) data. It supports multiple tractography algorithms and includes a visualization backend based on Makie.jl for exploring these complex datasets interactively.

Floating point numbers are beautiful but are limited. If we push them hard enough, computations that use them become inaccurate, and they are only a very thin sample of all real numbers. In contrast, considering intervals on the real line provides strict guarantee and accuracy and allows to draw general conclusions on continuous subsets of the real line. With intervals, a range of rigorous numerical proofs of mathematical facts can be performed.F or example, the existence or absence of solutions to an equation can be established and proven. By defining all required basic arithmetic operations on intervals, they can be used in arbitrary code, extending their benefits to all sort of calculations.

The goal of IntervalArithmetics.jl is to bring this method to the Julia ecosystem, without sacrificing Julia's flexibility. To reach this objective, we must face a difficult challenge: how to guarantee that interval computations stay rigorous while seamlessly being performed in codes that are, in general, unaware of the existence of interval arithmetic?

In this talk, I will present the strategies that we have implemented for the 1.0 version of the package which allows safe and easy use of rigorous interval computations in Julia, and how it can be applied to root-finding problems.

The Unfold family is a set of time-series analysis, visualization, and simulation toolboxes built around the regression ERP (rERP) framework for EEG analysis. That is, the application of multiple regression models to time series data. While all packages have a focus on EEG data, they can typically be easily applied to pupil dilation, skin conductance, or even fMRI data.

In this 10-minute talk, we will explore how UnfoldMakie.jl visualizes electrical activity of the brain recorded from the scalp. It works with electroencephalographic (EEG) data and such techniques as event-related potentials (ERPs) and regression-based ERPs (rERPs). UnfoldMakie integrates ERP and rERP analysis from Unfold.jl with interactive, customizable plotting from Makie.jl. This session will demonstrate how to create interactive and insightful visualizations of scalp electrical activity in Julia.

This talk presents HiGHS, the world's leading open-source solver for large-scale, sparse linear programming and mixed integer programming problems. We will discuss the types of problems handled by HiGHS, its solution methods, and some of the challenges we have faced in transforming them into software. We will also talk about scaling software, platforms, interfaces and maintaining the reliability of a widely used open-source project.

In Julia, JuMP is the go-to modelling package for mathematical optimisation. As of this writing, Google's award-winning solvers have not been accessible through JuMP; which offers Julia's ease of use. ORTools.jl is changing this. Julia users will now have access to Google's Glop, CP-SAT, and PDLP solvers through JuMP as provided by the ORTools.jl package.
This talk offers an introduction to the features of the package and an overview of the difficulties we encountered.

Software testing is a complicated endeavor, which even with good code coverage often leaves doubts about the quality of the written code when subsequent usage still uncovers bugs. In this talk, we are going to take a look at some problems of traditional testing, challenges when it comes to testing Julia code in particular and how Property Based Testing with Supposition.jl can help with that.

Static analysis improves software quality by identifying problematic patterns in code. Julia provides static analysis tooling through packages such as JET.jl and StaticLint.jl. This presentation introduces Argus.jl, a JuliaSyntax-based package that proposes a new approach to static analysis in Julia. It draws inspiration from the Racket libraries syntax/parse and resyntax.

CrystalNets.jl is a library dedicated to the topological identification of crystalline materials, a seminal problem in materials science. This requires solving the periodic graph canonization problem, a superset of the well-known graph isomorphism problem, but also several other issues ranging from bond detection in chemical structures to the design of an optimized sparse rational system solver. CrystalNets.jl boasts a unique combination of crystal structures coverage and order-of-magnitude performance improvements compared to other topological analysis tools. We will discuss the design of the library, as well as the development of its web interface which allows an easy access to the performance of the Julia code, even for non-programmers in the scientific community.

In this talk we will introduce FixedSizeArrays.jl, a new package which implements mutable fixed-size arrays, based on the recent Memory type.

We present GraphLab.jl, a Julia package designed to facilitate the study, experimentation, and research of graph partitioning. GraphLab.jl provides a framework for exploring the principles and trade-offs of partitioning algorithms through hands-on tools. It implements a growing set of methods—including coordinate, inertial, and spectral bisection, random spheres, space-filling curves, and nested dissection—with support for recursive partitioning. The package includes routines for generating adjacency matrices, computing partition quality metrics, benchmarking problems, and visualizing partitioned graphs. GraphLab.jl enables integration with external graph partitioning software, thus allowing users to compare additional methods and results in a unified environment. Our work aims to introduce Julia's capabilities to learners and researchers engaging in graph theory and related partitioning problems.

JuliaCon has its own peer-reviewed academic proceedings journal, where authors can publish their work presented at JuliaCon. This talk will give an overview of the JuliaCon proceedings, discussing its structure, its submission and review process, its technical infrastructure and how people in the community can get involved.

PACE.jl is a Julia package designed to address challenging problems in control theory and robotics through certified polynomial system solving. By combining symbolic elimination techniques with multi-precision interval computations, PACE.jl provides robust, certified solutions and an efficient alternative to traditional numerical methods. This talk will demonstrate its usage and performance through classic examples from control theory and robotics, while remaining accessible to anyone interested in certified polynomial system solving.

CarnotCycles.jl provides a base framework to model thermodynamic cycles in Julia. The name is inspired by Nicolas Léonard Sadi Carnot who among many other things theorized the most efficient power cycle called the Carnot’s cycle. This package aims to have the versatility of modeling various thermodynamic cycles, ranging from Vapour compression cycles to Organic Rankine cycle.

We present the new package HAdaptiveIntegration.jl which can compute the integral of functions over simplicies (triangle, tetrahedron, ...) and axis-aligned orthotopes (rectangle, cuboid, ...). The numerical computation of the integral is based on efficient tabulated embedded cubature rules and automatic mesh refinement (h-adaptivity) guided by error estimation given by the embedded cubature.

The performance of membrane filtration system could be improved by optimal control. We present a code in Julia for the optimal control of membrane filtration systems, for a wide range of models proposed in the literature, mainly based on combination of automatic differentiation (ForwardDiff.jl) and numerical integration of ordinary differential equations (OrdinaryDiffEq.jl).

Learn how to perform practical identifiability and predictability analysis in Julia. This talk showcases how LikelihoodProfiler.jl fits into the model calibration workflow, integrates with the SciML ecosystem, and leverages Julia's parallel computing features. A Systems Biology model will be used to illustrate the analysis and demonstrate the overall workflow.

In this talk we will present the ADMM-based quadratic program (QP) solver qpBAMM.jl. This solver is particularly suitable for solving blocked-structured QPs that occur in the context of the direct approach to solving optimal control problems. Besides the method used in the solver, we want to present the usage of our solver, as well as numerical results compared to other augmented Lagrangian based QP solvers available in Julia.

Turing.jl is a probabilistic programming language written entirely in Julia. It makes writing statistical models and performing Bayesian inference on them easy. Turing.jl is used in a wide range of fields from astrophysics to epidemiology, and integrates with the Julia scientific computing ecosystem. It has existed since Julia v0.4, and in this poster we provide an update on its latest new features and current plans for its development.

Did you know you can create an array of non-uniform data types, run it through a differential equation solver and still ensure there is no need for runtime type inference? We will dive into Julia's array interface and explore how it allows us to implement such unusual, yet useful, data structures in a type-stable manner.

UnfoldSim.jl is used to simulate multivariate time series, with a focus on continuous EEG data based on event-related potentials (ERPs). Its modular approach allows users to specify complex experimental designs, parameterized response functions, event order and temporal structure, and different noise specifications. Using abstract types and multiple dispatch, each ingredient can easily be exchanged and customized, allowing users to tailor the simulation to their needs.

In this workshop, we'll focus on mathematical optimization using JuMP. You'll learn to write programs and solve integer linear, nonlinear, conic, and constraint optimization problems. We'll also discuss the recent new features of JuMP. Additionally, we'll detail important performance tips for solving large-scale models with JuMP.

BifurcationKit.jl is a powerful and flexible Julia package for the numerical study of bifurcations in nonlinear systems. This tutorial will guide participants through the practical use of BifurcationKit.jl to analyze dynamical systems, including fixed points, bifurcation diagrams, continuation of solutions, and codimension-1 bifurcations. Through interactive coding examples, participants will learn how to apply the package to both low- and high-dimensional systems and understand the computational tools behind continuation and stability analysis.

Jacobians and Hessians play vital roles in scientific computing and machine learning, from optimization to probabilistic modeling. While these matrices are often considered too computationally expensive to calculate, their inherent sparsity can be leveraged to dramatically accelerate Automatic Differentiation (AD). By building on top of DifferentiationInterface.jl, we are able to bring Automatic Sparse Differentiation to all major Julia AD backends, including ForwardDiff and Enzyme.

Mooncake.jl is an algorithmic differentiation (AD) tool written in Julia. It is characterised by support for a wider range of Julia language features than existing tools, and performance which is typically better than comparable tools written in Julia. It has extensive documentation, simple-to-use tools for correctness testing supported by a precise type system, and is best used via DifferentiationInterface.jl. In this talk I will attempt to both justify and qualify these claims, and will conclude with an opinionated outlook on the future of AD in Julia.

Tulipa is a group of open-source tools for modelling and comparing European-scale energy systems, to support stakeholder decisions in the transition to sustainable energy.

One of the key challenges in energy system optimization modelling is achieving both high spatial-temporal detail and broad geographic or sectoral scope without overwhelming computational resources. Existing models are forced to prioritize either granularity or scale, because they cannot do both.

Tulipa addresses this trade-off through innovative modelling techniques that solve large, complex problems both faster and with higher accuracy – opening the door to analyses that were previously intractable.

This talk presents a research project turned product: a space mission simulator suite with Julia at its core. I'll highlight how the Julia language and ecosystem were essential to this effort, and how they offer a significant advantage over alternatives. I'll share an experience report about using Julia in production. I'll argue that Julia's potential for scientific tooling can be an edge in commercializing research — with proper attention to interoperability, tooling, and streamlined user experience.

This project is a playful collection of interactive Pluto.jl notebooks, made to turn tricky scientific and math ideas into something explorable! The aim? To make learning feel less like a boring lecture and more a “wow, that’s cool!” moment—while sharing clean, high-quality Julia code anyone can use. I also want to take you behind the scenes to show how you can build these notebooks yourself using the same tools for computational storytelling (and have fun doing it!).

-

Hacking together on our favorite Julia projects!

Hacking together on our favorite Julia projects!