JuliaCon 2025

DifferentialEquations.jl is the main package in Julia for solving differential equations. It has all sorts of things, from solving ordinary differential equations to stochastic differential equations, differential-algebraic equations, and more. You can switch to preconditioned GMRES linear solvers, exponential integrators, integrate with automatic differentiation, tweak the nonlinear solvers, and add customized stepping/logging routines. Most people only ever scratch the surface: let's dive in.

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 key topics such as resource configuration, distributed computing, CPU and GPU code optimization, and scalable workflows.

Computational neuroscience aims to simulate the brain in silico, from single synapses to brain-wide networks. In this workshop, you will learn the basics of computational neuroscience via hands-on model building in Neuroblox and Julia. You will simulate models from the literature, from single neurons to large circuits with synaptic plasticity, and fit them to neural data.

Modeling quantum dynamics on classical computers is a fruitful approach to the study of quantum phenomena and their technological applications. It also leads to a rich universe of computational techniques with subtle tradeoffs between simulation fidelity and computational complexity. This workshop will cover many of the basic techniques of importance to the design of quantum hardware in networking, sensing, computation, and error correction.

Building surrogates of fluid dynamics models is a common way to accelerate the analyses. In this workshop we will go hands-on with ML tooling to improve the ability to analyze a weather model. A live challenge to find the parameters that maximize rainfall in a given model will drive the discussion. Participants will interact with the model and submit solutions to a leaderboard to crown a winner. No prior ML or weather modeling experience required!

Healthcare systems face numerous challenges in operating efficiently and serving the needs of our patients and communities, including problems with healthcare access, quality, and safety. In this talk, Dr. Singh will address why these operational challenges have been difficult to solve with technology before, and how we should rethink our approaches to these problems using computational methods like generative AI and simulation.

What if Julia types were more than struct, Tuple, Union{} and where T?

In this talk, I'll dare to dream of an extension of Julia with powerful type features like intersection types (TypeScript), sum types (Rust), interface types (many languages), etc.

What are the implications for a user, and for the compiler? Building on the intuition of types-as-sets, we'll build a simple subtyping algorithm, explore the consequences for inference, and show how this all connects to real Julia code.

In three recent textbooks on optimization, decision-making, and safety validation, we use Julia instead of pseudocode to present fully executable and concise algorithm descriptions. This talk explores why we chose Julia and how we auto-generate entire textbooks using Julia and LaTeX. We will also discuss how Julia and Pluto support interactive learning and automate grading in Stanford graduate courses—along with exploring Julia's potential future roles in academia.

Contributing to the Julia can feel daunting at first, but it shouldn't be. In open source you don't need to be an expert in something to start making a difference. There are many ways to support the community; from enhancing docs to designing good UI. While some may feel their non-technical contributions aren't as valuable, but these efforts are crucial to Julia’s growth and in building a welcoming community where everyone, regardless of technical background, can make a meaningful impact.

We present OptimalUncertaintyQuantification.jl: A SciML package for end-to-end distributionally robust uncertainty quantification of static and dynamic systems models. The tool performs a worst-case analysis so as to make certification/decertification decisions on engineering models defined in ModelingToolkit.jl as demonstrated on a variety of aerospace and structural engineering applications.

Julia can run fast on a desktop, but can it run fast --- and more importantly, reliably --- on an embedded platform such as a small application-class processor or even a microcontroller? Yes! We use Julia, integrated with PX4, to perform translational and attitude control of a quadcopter in a 1kHz closed loop. We show the compilation and deployment pipeline for running Julia on a CM4 companion computer, connected to PX4 via ROS.

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.

AlgebraOfGraphics (AoG) is a declarative plotting library based on an algebra of composable layers. It allows users to flexibly combine data, mappings, and visuals, utilizing Makie.jl's extensive capabilities. Its initial design, a thin layer over Makie, had limitations in versatility and user experience. Last year, PumasAI fully refactored AoG's scale system, resulting in a more powerful and robust AoG. This talk will highlight key architectural improvements and showcase the best new features.

An update on the current state of TidierPlots, an implementation of ggplot2 in julia.

ModelingToolkit.jl is one of the primary tools for symbolic-numeric computing in Julia. It allows symbolically specifying a wide variety of problems and performing symbolic simplifications to aid in simulation. This talk will cover the developments in the library and related ecosystem in the past year and discuss the plans moving forward.

Modern global geospatial workflows are ill-served by our current conception of planar geometry. In GeometryOps.jl, we have added support for operations natively on the sphere (the space S²), akin to Google's s2 library. This allows us to treat lines as great-circle arcs without subsampling, and calculations like area and intersection are natively non-approximate. This enables fast and substantially more accurate global operations, especially on areas of particular interest like the poles.

As your code advances in complexity, your hardware needs will advance as well. ACCESS Allocations is an NSF-funded program to grant researchers at U.S.-based institutions time on a variety of high performance computers across the country for free. In this talk, members of the Pittsburgh Supercomputing Center and ACCESS Allocations teams will discuss how to get an allocation through ACCESS, as well as introduce PSC’s Bridges-2 supercomputer for use with Julia.

Our world today is defined by big data; the output of a single satellite orbit is larger than your laptop's hard drive. The canonical way to analyze "big earth observation datasets" has always been to throw it on a cluster and let it run overnight. But what if it didn't have to be?

With RangeExtractor.jl, you can run queries over huge gridded datasets on a laptop, without storing the data locally. Loading and processing is batched by chunks, either defaults from the dataset, or from the user

Dagger.jl makes your code go fast, now in innovative new ways! Come here about what's new in Dagger since JuliaCon 2024, how Dagger has continued to develop over the past year, and what you have to look forward to by JuliaCon 2026!

To optimize code, we must have good tools for measuring performance. Chairmarks.jl measures performance substantially faster than BenchmarkTools.jl while gathering more data at a similar accuracy. By avoiding eval and repeated gc calls and an efficient tuning algorithm, Charimarks achieves efficiecies of up to 99%, making setup and tuning time negligible. This allows for a more straightforward API and a much snappier user experience (from 5 seconds to 100ms).

Mathematical optimization is ubiquitous in scientific and engineering domains. We will explore how ConicSolve.jl, a Julia package is utilized to solve a variety of problem classes, including Linear (LP), Quadratic (QP), Second Order Cone (SOCP), and Semidefinite Programming (SDP). We'll cover examples in robotics, imaging and comms to discuss the techniques in modelling optimization problems and the design decisions made to make ConicSolve.jl a performant, versatile and extensible framework.

The Julia SciML solvers in DifferentialEquations.jl are already pretty optimized for stiff ODEs and DAEs, so where does the next order of magnitude in performance come from? In this talk we will describe how symbolic-numeric compiler tricks are being integrated in to the solver architecture in order to achieve performance that is beyond anything possible with purely numerical systems.

Traditional methods struggle to simulate pollutant transport in large oceanic domains. We propose a PINN framework integrating the advection-diffusion equation to predict pollution hotspots. Synthetic datasets with real-world variability and adaptive training strategies address coastal accumulation challenges. This approach supports scalable simulations, enabling future extensions like 3D modeling and real-time forecasting for environmental decision-making.

StaticLint.jl is a popular linter for Julia. Despite its wide acceptance, StaticLint suffers from many shortcomings related to extensibility and poor interoperability.
ReLint is an MIT open-source Lint checker used at RelationalAI. ReLint is fast, extensible, offers tools to match abstract syntax trees, and can be used by a GitHub workflow or a pre-commit hook. ReLint has been successfully employed to enforce programming conventions on a large code base (over 300K LOC).

Solving problems like nonlinear equations and differential equations can often benefit from higher-order derivative info. Using TaylorDiff.jl, we could efficiently compute higher-order derivatives in Taylor mode, thereby developing solvers with higher accuracy while maintaining a relatively low cost. We demonstrate a scalable nonlinear solver with third-order convergence and cost comparable to Newton's method, as well as ongoing work of high accuracy implicit Taylor solver for ODEs.

Linear algebra, with matrices and vectors, forms the common language of computational geometry. CliffordNumbers.jl forms the basis of an alternative approach to the field, providing representations of elements of Clifford algebras that support high-performance operations compatible with Julia Base Number types. The package leans heavily on Julia's tools for performance, but also highlights points of interest for the future development of Julia.

Kerbal Space Program (KSP) is an entry point for many to aerospace as an easy-to-use, understandable way to build and fly flying machines. The community mod KRPC is then a gateway to automatic control of said vehicles, allowing external software to integrate with KSP to control spacecraft. KRPC.jl is an interface library to KRPC, allowing Julia software to control Kerbal rockets; we describe its architecture, use, and show an application where we use Julia to land an orbital rocket.

Writing parallel programs is hard. Writing distributed parallel programs is even harder. cuNumeric.jl reduces the burden of writing correct parallel code, and allows the developer to focus on the heart of their problem. By leveraging the infrastructure developed for cuPyNumeric (a NumPy replacement), we implement a new front end for the Legion Programming System in Julia. This enables us to run Julia on CPUs and NVIDIA GPUs at a distributed scale with a simple array programming interface.

BasicAutoloads.jl allows you to automatically load packages on use in the REPL. This streamlines workflows without adding the startup cost or precompile and memory bloat of proactively loading packages. The API and semantics are both incredibly simple and, by virtue of supporting arbitrary Julia expressions, surprisingly powerful.

Jets in high energy physics (HEP) are sprays of particles that occur in HEP experiments, such as those at the LHC at CERN. The JetReconstruction.jl package is a native implementation of sequential jet reconstruction, essential for interpreting these events. The package was introduced in 2024 and already outperforms C++ versions. The package now has improved functionality, to extract enhanced information for jets, build a static library, and support e+e- events for future experiments at CERN.

Forecasting tumor growth is critical for optimizing treatment, yet traditional models like Gompertz and Bertalanffy equations struggle with patient-specific variability. We leverage Universal Differential Equations (UDEs) and Neural ODEs, integrating Scientific Machine Learning (SciML) to replace rigid terms with adaptive neural networks. This enables real-time learning from patient data, uncovering hidden dynamics beyond classical models to improve clinical outcomes.

PerfTest.jl is a Julia package conceived from the idea of bridging the gap between unit testing and architecture-agnostic performance testing. It brings a set of features that allow the user to set up performance regression unit tests from functional unit tests with minimal effort. An emphasis is made on letting the user create flexible test suites with classical performance models that can be applied across different machines.

MixedModelsSmallSample.jl makes small sample adjustments to the hypothesis tests and confidence intervals of mixed effect regression models estimated by restricted maximum likelihood using MixedModels.jl.

Neuroblox.jl is designed for computational neuroscience and psychiatry 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 two years.

We supercharge quantum-repeater simulations by presenting Julia packages that incorporate a recent technique from machine learning, stochastic automatic differentiation. To demonstrate its usefulness, we optimize rate-fidelity trade-offs and optimally place repeaters in a 2D plane. We observe spontaneous symmetry breaking and discover that the required number of repeaters scales only with the square root of the network area.

With Julia 1.12, experimental support for statically compiled executables is here, but for many the --trim feature is still a mystery. How does it work? What are its limitations? What might it look like in the future?

To answer those questions, we'll dive deep into specialized inference support, challenging language semantics, and sharp corners in workflows today. Looking to the future, we'll talk about the tooling we might need to make --trim accessible for everyday Julia programmers.

Traditional plotting functions like scatter(x, y, color=c) separate x, y, and c, losing the fact that they describe properties of the same elements. MakieExtra.jl’s FPlot promotes a dataset-centric approach, linking arbitrary element features to plot attributes. This method simplifies and enriches interactivity, enables automatic labeling, and enhances composability, as demonstrated in the talk.

The Cox model is a standard and very well studied parametric model for censored time-to-event data, relying on very strict proportional hazard assumptions. It is one of the core tools of survival analysis and requires numerical estimation of its coefficients. Our first implementation, using an off-the-shelf numerical solver, was correct but very slow compared to competition. We describe here the step-by-step procedure to performance that led us to our current top-of-the-line implementation.

Scientific machine learning has proven effective in deriving equations for complex dynamical systems but faces challenges with chaotic systems, particularly in biological systems with incomplete theories and noisy data. We present a new approach combining universal differential equations with the prediction-error method from optimization to successfully learn neural system dynamics from simulated and real spiking neural networks.

In this talk, we will discuss recent improvements and use-cases of the Piccolo.jl meta-package for quantum optimal control. We will detail where we are at the moment and what will comprise the release of version 1.0.

Digital twins have been used to model complex physical systems to predict their behaviour accurately. In this talk, I will present the concept of a hybrid digital twin on the Industrial Metaverse that combines AI/ML based analytics and physics-based simulation to build digital twins that are very accurate, require less training data, and drive high operational efficiency, illustrating how a platform such as JuliaHub can be used to build hybrid digital twins.

GraphDynamics.jl is an open source tool developed for Neuroblox.jl with the goal of efficiently representing systems composed of many, heterogeneous, interacting subsystems so that their dynamics can be solved with existing SciML differential equation solvers. In this talk I'll discuss how it works, why we need this functionality, and what advantages this has over other approaches

This presentation discusses interpreting Julia code and particularly the strategy used by JuliaInterpreter.jl together with its benefits and drawbacks.

QuantumToolbox.jl is a high-performance Julia package for simulating quantum systems and open quantum dynamics, inspired by the widely used QuTiP library in Python. It offers efficient tools for state manipulation, Hamiltonian modeling, time evolution, and many other features. With GPU acceleration and seamless parallel computing, it enables scalable, high-fidelity quantum simulations with superior performance.

KomaMRI.jl is a tool developed to efficiently simulate the physics of magnetic resonance phenomena by solving the Bloch equations, helping to address technical challenges that can affect medical image quality. These simulations are especially useful for designing pulse sequences, a fundamental component of MRI acquisition. In this talk, I will present recent technical developments that make the tool more versatile and broadly applicable.

The first time you start Julia, you are presented with its humble, yet powerful, REPL. If you explore a bit, you'll quickly discover that Julia's REPL is more than just a place to try a line of code. You can also use it to install packages, look up documentation, and execute shell commands. But much like Clark Kent's glasses, Julia's REPL is hiding a secret superpower! In this talk, we will explore how REPL-driven development with Julia can transform how you write and develop code.

DeviceLayout.jl is a package for computer-aided design (CAD) of quantum integrated circuits, supporting schematic-driven design, 2D geometry rendering, and the construction and meshing of 3D models. We show how it can be used for layout of a superconducting quantum processor, and we highlight its use for design and simulation with Palace, an open-source 3D finite element solver for computational electromagnetics.

invited talk please accept

State-space models (SSMs) are powerful tools for modeling time series data that naturally arise in neuroscience, finance, and engineering. These models assume observations arise from a hidden latent sequence, encompassing methods like Hidden Markov Models (HMMs) and Linear Dynamical Systems (LDS). We introduce StateSpaceDynamics.jl, an open source, modular package designed to be fast, readable, and self contained for the express purpose of fitting a plurality of SSMs, easily in Julia.

Large scale EEG analysis pipelines are a critical tool for understanding complex neurophysiology. Using Beacon Biosignal’s platform for EEG data analysis in Julia we performed one of the largest studies of chronic insomnia to date. It appears that the most prevalent EEG differences between those with and without insomnia arise during periods of wake or near wake-like (N1) activity throughout the night. Overall Julia proved to be a robust platform for EEG ingest, featurization and analysis.

In response to staff shortages in hospitals, healthcare providers aim at increasingly automating their systems. Defining the path of automated systems – avoiding collisions – typically requires a dynamic model of the system and a second layer that optimizes the path under constraints. We have found that the Julia ecosystem – that allows for both physical modeling and programming capabilities – enabled a fast (5x) and robust solving of this path planning problem.

The DARPA-MIT SmartSolve project tackles the challenge of dynamically selecting optimal algorithms and architectures through an automated discovery framework. As part of this effort, we present advances on optimizing algorithm and data structure choices tailored to linear algebra. Contributions include automated benchmarking across diverse matrix patterns, database-driven selection via Pareto analysis, and exploring large language models for automatic heuristic generation.

In my work, I explore a novel simulation where tumor growth is controlled by the immune system using Neural ODEs. I integrate skip connections and physics-informed loss to capture real-world metastatic behavior under various treatments. By calibrating the model with experimental data, I uncover insights into optimizing combination therapies that could ultimately improve patient outcomes.

QuantumSavory.jl offers a robust set of abstractions and APIs that streamline quantum protocol development. Over the past year, we have introduced several new features, particularly tagging, querying, and tag-based synchronization of classical control channels for quantum networks. In this talk, we detail how these functionalities operate and demonstrate their applicability through examples such as measurement-based quantum computing.

A great Dockerfile for Julia should:
1. Contain a depot with a precompiled Manifest.
2. Rebuild fast and efficiently - only changed code should be recompiled.
3. Be as light as possible with no unnecessary files in its layers.

In this talk I will present some clever ways on how to abuse Dockerfile RUN --mount to achieve fully cached rebuilds. I will also share tips on how to manage your depot and solve other common issues a Julia user might experience when writing an advanced Dockerfile.

We will present new developments over the past two years in JACC.jl a performance portability package targeting high-performance computing (HPC) applications. These will include API changes and additions, the oneAPI backend, shared memory utilization, and ongoing efforts to manage kernels on multiple GPUs. We will relate lessons learned as well as challenges, and we might even ask for help.

OMOPCDMPathways.jl is a JuliaHealth package that generates patient treatment pathways from scratch, mapping a patient’s journey from initial contact to future interactions. It provides vital insights for observational studies by revealing treatment patterns and care progression. Users can adjust parameters to create customized pathways for specific disease definitions.

Computational challenges limit our understanding of memory formation at the molecular level. This study applies Neural Ordinary Differential Equations (NeuralODEs) using prospective configuration techniques to model the STC hypothesis, offering a biologically plausible alternative to backpropagation. Using Julia, the system achieved a loss of 0.005 while accurately capturing molecular interactions. The findings demonstrate NeuralODEs' potential for modeling complex biological processes.

In this presentation, we unveil JETLS, a new language server for Julia that enhances developer productivity through advanced static analysis and seamless integration with the Julia runtime. By leveraging cutting-edge tools like JET and JuliaLowering, JETLS provides advanced language features, including type-sensitive diagnostics and macro-aware code completions.

We showcase Neuroblox.jl's capabilities for investigating Deep Brain Stimulation (DBS) effects on basal ganglia dynamics. This framework enables efficient and detailed simulation of neural circuits under various stimulation protocols, providing an intuitive platform for testing DBS parameters and exploring phenomena like Evoked Resonant Neural Activity (ERNA).

invited talk please accept

This talk discusses a hybrid recommender system implemented in Julia for applicant preselection for a job. The recommender system is built using a neural network adopting a hybrid architecture that combines convolutional layers of a graph neural network and a transformer (both encoder and decoder). We discuss the preprocessing of applicant metadata and job adverts to generate a heterogeneous graph. Next, we present the recommender as a model and its training using an HPC.

Dynamic Causal Modeling (DCM) is a key method for inferring neural connectivity among brain regions. We present a novel Julia-based implementation of spectral DCM using Julia's ModelingToolkit and automatic differentiation. We provide a fast, modular platform for biophysically detailed models, validated against the widely used MATLAB based Statistical Parametric Mapping software commonly used to estimate DCMs.

This project democratizes GPU hardware by developing a GPU-accelerated simulation engine for modeling physical systems on manifolds. Built with CUDA and Julia, it introduces innovative methods for high-performance simulations, enabling efficient modeling of complex phenomena. By emphasizing user-friendliness, scalability, and efficiency, the project lowers barriers for researchers to leverage GPU power, promoting the adoption of advanced computational tools through the Julia framework.

With over 100+ repositories under its umbrella and a multitude users of users, ensuring consistent continuous integration practices is of paramount importance and is non-negotiable for the SciML ecosystem. Now, a year since the undertaking to centralize and properly structure these processes was initiated, this lightning talk aims to offer a retrospective to the audience about the state of CI processes in SciML.

Waveguide quantum electrodynamics (WQED) describes how propagating photons interact with localized quantum systems. Their multimode nature leads to entanglement and feedback effects, making analytical solutions impractical beyond simple cases. WaveguideQED.jl is a Julia package that efficiently simulates WQED using a time-bin discretization approach, enabling intuitive modeling of traveling photon states to treat photon scattering, non-Markovian feedback, and multi-photon interactions.

We describe a Retrieval-Augmented Generation (RAG)-informed Large Language Model (LLM) workflow for querying observational health data in the OMOP Common Data Model (OMOP CDM). Leveraging Julia software such as FunSQL.jl and OMOPCDMCohortCreator.jl, we explore how the model can automate and refine complex research queries in health research settings. This work explores RAG architectures, query examples, and reproducibility within health informatics.

Julia's Distributed stdlib has been part of the language from the beginning and
has a solid track record. However, being a standard library comes with higher
standards for changes and that has led to progress being somewhat slow. We
present DistributedNext as a way to:
1. Implement new features at a faster rate than Distributed.
2. Use DistributedNext as a testbed for these features to potentially upstream
to Distributed.

Compilation latency in the package ecosystem has been effectively reduced through improvements to type inference and package precompilation. This talk discusses several tools to reduce latency and introduces Speculator.jl, which searches for compilable method signatures from a callable value or module. In a single line of code, Speculator.jl can be used to precompile a package or automatically compile methods in the background of an interactive session.

The Julia Programming Language solves the so-called "two-language problem." 2 - 1 = 1, which is fantastic. Here DocstringTranslation.jl
package and some derived packages translate Julia's documentation written in a language called English into the user's preferred language, which also reduces the issue of yet another two-language problem.

Julia 1.12 introduced significant changes to the semantics of global bindings and world ages. In particular, constant redefinition is now permitted in all cases (and the cases previously allowed are no longer considered undefined behavior). As an immediate consequence, struct redefinition is now possible, resolving the biggest remaining case in which Revise.jl was unable to hot-reload changed code. This talk will provide an overview of the new semantics, including common pitfalls.

Learn about the new native Julia engine for Quarto, developed by PumasAI and integrated into the publishing system since version 1.5 (July 2024). Unlike earlier Julia support requiring IJulia and Python, this engine simplifies workflows by directly connecting Julia and Quarto. I will discuss the engine’s unique features, such as seamless R code support via RCall and dynamic document generation, while also diving into the architecture of QuartoNotebookRunner.jl and its interface with quarto-cli.

Parameter estimation for ODEs is a fundamental problem in modeling and dynamics. The algebraic approach in Bassik et al. does not suffer from difficulties inherent in nonlinear optimization (the need for good initial guess, getting stuck in local minima, etc), but degrades severely in the presence of measurement noise. We combined the algebraic approach with Gaussian Process Regression to increase robustness to noise. In this talk, we will demo a Julia implementation of this new algorithm.

The IEEE has a working group drafting a standard for Floating-point Arithmetic Formats in Machine Learning. This talk explains one approach to implementing these multi-format microfloat representations. The presentation covers specific implementation approaches adopted and design advantages found with Julia.

Discrete models and control systems go hand in hand with continuous-time controls: many physical systems show state-dependent or discrete behavior such as clutches or friction, while realizable digital control systems are intrinsically discrete time. We describe the integration of synchronous systems - systems that execute in discrete steps on clocks or events - with ModelingToolkit to provide easy and compositional handling of discrete systems in high-level models.

The Chapel programming language, while not competing with Julia in target audience, shares a similar story. Chapel was developed for making high-performance parallel programming easier and more fun to write, without giving up on performance.

This talk, after a short overview of the Chapel programming language, will focus on interoperability between the languages, showing how one can use Chapel code from Julia and Julia code from Chapel.

Functions like map or filter in Julia perform well on containers with concrete element types, such as Vectors-of-NamedTuples or StructArrays, used in typical tabular data. However, dealing with hundreds or thousands of columns can overwhelm the compiler. DictArrays aims to get the best of both worlds by delivering the familiar, efficient collection API to type-unstable collections, optimizing both compilation and runtime performance.

There are many different formats for lossless compression, for example, gzip and zstandard. These formats are often used as part of other higher level file formats and protocols, such as HDF5, Zarr, Parquet, and HTTP. In this talk I will describe work towards consistant Julia interfaces for encoding and decoding lossless compression formats in the TranscodingStreams.jl and ChunkCodecCore.jl packages.

FunctionFusion.jl is a framework which generates large algorithms from small computational blocks.
It allows to develop algorithms like drawing data flow diagrams.

The framework allows to create algorithms running in multiple environments (like production and simulation) and provides necessary tools for visualization and performance optimization.

JuliaQCD is a versatile tool for lattice Quantum Chromodynamics (QCD), a key framework in particle physics for studying the strong force that binds quarks and gluons. Designed for seamless scalability, it runs efficiently on CPU/GPU systems from laptops to supercomputers (e.g. Fugaku). By implementing standard algorithms like Hybrid Monte Carlo (HMC) with a focus on rapid and efficient research, JuliaQCD enables scientists to explore fundamental physics with unprecedented flexibility and speed.

Manifolds are mathematical objects that can be used to describe complicated numerical domains. They are often used in optimization, statistical computations, physics and engineering. Manifolds can describe constraints on data, be used to explore necessity of assumptions in numerical algorithms or design faster algorithms. The talk provides an overview of the capabilities available in JuliaManifolds and beyond, along with a historical perspective and future prospects.

MultipleInterfaces.jl provides a powerful way to define and work with interfaces in Julia. With MultipleInterfaces.jl you can declare an interface that is defined by a list of required methods, and you can declare which types implement that interface. Interfaces support multiple inheritance, interface intersection, and multiple dispatch. And all with no runtime cost. We will present the motivation for MultipleInterfaces.jl, how the package works, and an example application.

We present MOSS (The Map of Open Source Science), a system that consolidates data from GitHub, OpenAlex, CrossRef, and other scholarly sources to build an integrated knowledge graph of open research and software projects. We will demonstrate how MOSS can be configured to zero in on the Julia community, mapping key Julia repositories to associated papers, contributors, institutions, topics, and other objects.

Radau methods are highly efficient ways to solve stiff ordinary differential equations, yet the state-of-the-art remained Fortran scripts from the 1990s for decades. In this talk, I describe several new innovations made to Radau methods in Julia's OrdinaryDiffEq.jl interface that enhance their performance. Prior knowledge of differential equations is not necessary!

What do you do when everything goes to crap? You hit the big red button, of course! Otherwise known as Ctrl-C, we'll discuss what Ctrl-C does, why it does its job poorly, and how cancellation can help your library or application become much better behaved when the world around them lights on fire!

Boundary value problems arise in various scientific domains and play an important role in scientific computing, how to efficiently solve them is vital in numerical simulations. BoundaryValueDiffEq.jl as a crucial part of DifferentialEquations.jl provides powerful BVP solvers and tackles various kinds of BVP problems. In this talk, the presenter will talk about the latest development of BoundaryValueDiffEq.jl and why it makes itself a powerful and robust package.

Lie groups are a tool to work with groups where the group operation is smooth, for example the set of rotation matrices or the collection of all possible translations and rotations on a Euclidean space.

In this talk we introduce the package LieGroups.jl to perform numerical operations on and work with Lie groups in numerical tasks, for example when working with physical quantities such as rotations, translations and velocities.

Tyler.jl is a Makie ecosystem package that enables plotting tiled datasets, like Google Maps and many other basemaps. In the last few years, it's also gained 3D capability, and can plot colored elevation data in 3D and on GeoMakie's projected GeoAxis. Progress is also under way to allow Tyler to plot arbitrary user-provided datasets or pyramid overviews.

In this talk, we'll dissect how Tyler works and how you can use it (and abuse it!)

Typst is an open-source and relatively new typesetting system, designed to improve upon the performance and usability of LaTeX. Typstry.jl was inspired by LaTeXStrings.jl and Latexify.jl, implementing similar features and expanding upon them for Typst. This package implements Typst strings, formatting, and commands. Together, these provide a robust system to write and generate Typst code, run the Typst command-line interface, and render Julia values.

At first blush, Julia structs may seem to just be a named data container we use for dispatch. However, structs do far more than just contain data. This talk explores tools available to make your structs more feature rich, providing a checklist of potential features to benefit your types. These tools range from simple type equality to tricks with mutable structs beyond mutation. In addition to enumerating these tools, we provide code samples which demonstrate proper implementation.

Julia stands out by enabling convenient tabular data manipulation without specialized types: built-in arrays, with their versatility, fit perfectly. This approach seamlessly extends beyond flat tables and to out-of-memory datasets while maintaining simplicity and performance. In this talk, I'll explore the tabular-like functions available in Julia, from foundational map to advanced pivoting and joins, and their design.

Performing I/O in Julia under static compilation requires new considerations. In particular, juliac's --trim feature requires that the types returned from I/O calls be known statically at compile time or at least be enumerated. While this allows for small binaries, it does limit how dynamic statically compiled Julia I/O programs can be. This has required modifications to existing I/O packages as well as a new versions of I/O packages to implement these static features.

This talk presents the implementation of hash consing in SymbolicUtils.jl, a Julia library for symbolic computation. By ensuring unique representation of structurally equivalent expressions, hash consing reduces memory usage and computational overhead. We demonstrate significant performance improvements, including memory savings and faster compile and simulation times, while simplifying code through built-in common subexpression elimination.

Documenter.jl is the primary documentation engine for Julia, and powers backends ranging from native HTML and LaTeX to the spiffy DocumenterVitepress.jl. In this talk, we'll explore the structure of a Documenter.jl "document", and how to modify it and hook into Documenter.jl to your own (evil) ends!

We'll explore how Documenter's abstractions are structured, the build and extension pipelines, as well as how to define and implement a custom Documenter block.

Jameson Nash is a Julia core developer with expert knowledge of the internals of the Julia I/O interface. Jameson will discuss the low-level details of the Julia I/O interface and its underpinnings in libuv. Furthermore, how Julia I/O is changing in light of new features such as interactive threads and static compilation will be explored.

The National Renewable Energy Lab just released version 1 of PowerAnalytics.jl, an analysis module for the outputs of its popular open-source electrical power systems modeling platform Sienna. It features an extensible framework to process results in the Sienna style while keeping the interface as simple as possible for non-Julia experts. I’ll present on how I harnessed user-oriented design and Julia features to create such a package and what we might learn from its design and implementation.

Approximation of functions is an enabling technology for scientific computing. The Julia ecosystem has excellent options for polynomial-based approximation methods. New algorithms for approximation by ratios of polynomials have sparked increasing interest in computational rational approximation. The RationalFunctionApproximation.jl package supplies the fastest known versions of these methods for approximation of functions over an interval or any connected domain in the complex plane.

Sparsity is a fundamental assumption that allows us to compute efficiently and find parsimonious solutions to science and engineering problems. Sparsity exists in all basic sciences such as physics, biology, and chemistry. I am going to give a sampling of our recent work on sparse computations, with an emphasis on large-scale parallelism. The underlying theme will be the challenges posed by sparsity and the computational techniques we employ to overcome these challenges.

Julia's dynamism, extensive specialization, and metaprogramming make it uniquely suited to express sparse and graph algorithms. This talk will explore the suitability of Julia for graph algorithms, covering several algorithms and their real-world use cases. We will discuss the challenges of implementing graph algorithms in Julia as well and how to overcome them. Practical examples and code snippets will be included to illustrate the concepts discussed.

The Accessors.jl package is known as a way to update values within immutable structs with its @set macro. However, the underlying "optics" concept is far more powerful and versatile. The Accessors design makes these optics impressively seamless and performant in Julia, relying heavily on multiple dispatch for composability. In the talk, I'll cover its design and implementation, showcasing neat usecases from autodiff and function optimization to tabular operations and plotting.

This talk demonstrates practical safety validation techniques from the new book "Algorithms for Validation" using Julia's ecosystem. Through interactive Pluto.jl notebooks and a case study of aircraft collision avoidance, we showcase Julia's capabilities in safety validation, including seamless integration with Python-based controllers and black-box simulation environments. No prior verification experience required!

Julia's usage of astronomy has increased in the last decade. This talk will discuss my experience writing a larger astronomy code, Comrade.jl, and building the EHTJulia organization. I'll detail my experience writing code in Julia, contrasting it to my past experiences with C++ and Python astronomy software. Finally, given that astronomy software is built upon early career scientists, I'll also discuss the experience of teaching students how to use Julia and areas of improvement.

Tensor network methods are a set of numerical algorithms designed to study strongly correlated systems in quantum physics. ITensors.jl is a high performance library providing easy access to them. As many physical models exhibit symmetries such as SU(2), enforcing them directly within the tensors leads to significant performance gains. In this talk, we introduce the core concepts of tensor networks, the basics of ITensor and expose its implementation of non-abelian symmetries.

I will discuss using Julia during Advent of Code to earn 50 stars each in 2020, 2022, and 2024. Advent of Code consists of twenty-five days of programming puzzles during the holiday season. Julia is well suited to solve these puzzles due to its ergonomic syntax, fast execution via just-in-time compilation, interactive read-evaluate-print-loop (REPL), and fantastic visualization capabilities. The triumphs and challenges of using Julia for competitive and recreational programming will be reviewed.

Graph theory and complex networks provide a language for understanding combinatorial structure in mathematical, computational, and engineering problems. However, plain graphs leave out higher order interactions between multiple entities. We will discuss Julia software for representing and manipulating more general relational structures with ACSets.jl a framework that covers simplicial complexes, hypergraphs, and Petri Nets.

By using novel optimizations on top of Walker's alias method for random sampling, AliasTables.jl implements a discrete random sampler that supports arbitrary category weights and provides O(n) construction and O(1) sampling with a constant factor of 20-40 clock cycles for construction and 5-10 clock cycles for sampling.

Gabs.jl is a numerical package for simulating a large class of quantum continuous variables known as Gaussian quantum information. Gaussian processes are efficient to simulate on a classical computer, thus serving as a practical tool for developing applications in quantum teleportation, quantum networking, and quantum computation.

Anime is a Julia-based framework for modelling atmospheric and instrumental effects in Very Long Baseline Interferometry (VLBI). It enables instrument model creation, realistic synthetic data generation, and seamless conversion between popular radio data formats. Supporting both modular and pipeline workflows, Anime is designed to support radio data processing and analysis.

Nginx is a popular, high performance web server and reverse proxy. The OpenResty project combines nginx and LuaJIT enabling programmers to extend nginx with the Lua programming language. Like Lua, Julia also has a C API and JIT compiler. Using the Julia C API, we created a Julia nginx extension that can be used to run Julia code inside nginx. This is a fun experiment in the realm of julia embedded development.

We demonstrate how recent compiler developments allow users of Julia and the equation-based modeling language ModelingToolkit to compile and deploy binaries for real-time model-based estimation and control. Contrary to the approach taken by a majority of modeling-and simulation tools, we do not generate C code, and instead demonstrate how we may use the native Julia code-generation pipeline.

Many radio astronomy facilities are interferometers, and interferometric data require computational algorithms to produce an astronomical image. Multifrequency Synthesis (MFS) is a technique in which interferometric data at multiple frequencies are imaged simultaneously, resulting in higher quality radio images and improved constraints on the source’s spectral structure. Here I present an extension to the Julia package Stoked.jl which performs MFS in a Bayesian framework.

The Event Horizon Telescope (EHT) produced the first image of the black hole shadow in 2019, and advancements in imaging algorithms have only improved performance since then. We present VLBISkyRegularizers.jl, a regularized maximum likelihood (RML) black hole imaging software. Based on the Bayesian imaging package Comrade.jl, we take full advantage of the Julia language to make VLBISkyRegularizers.jl faster and more modular and flexible than comparable RML packages.

Consider this Julia program:
n\y=for t=y:n^y n+=2y^2+2(y=(t*y-n)<<25>>32)^2>0;println(4n/t)end;5\27

At 70 characters, it’s barely longer than this session’s title. Yet it contains a custom PRNG and pairs this with integer overflow to calculate pi by an algorithm explainable to an 8th grader. Though it converges very slowly, it’s no slower than a version written directly in assembly. Here, I’ll discuss how I made this and the surprising number of computer science lessons it can be used to teach.

As engineers, when we are faced with creating calculations, we don’t have many options. Those choices are between Excel, Mathcad, or our own handwritten calculations. However, while this list may be small, it is not a list that is lacking in anyway. Or is it? This talk discusses a new Julia package that brings a unique feature that will have you asking, "Why hasn't this existed all along?"

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.

We present the Julia package PauliStrings.jl for quantum many-body simulations, which performs fast operations on the Pauli group by encoding Pauli strings in binary. All of the Pauli string algebra is encoded into low-level logic operations on integers, and is made efficient by various truncation methods. We illustrate the effectiveness of our package by (i) performing Heisenberg time evolution through direct numerical integration and (ii) by constructing a Liouvillian Krylov space.

In this lightning talk, I’ll share recent work on embedding physical constraints into graph neural networks using Lux and Reactant. I’ll discuss approaches for modeling systems governed by differential equations and structured meshes, and highlight how compiler-level optimizations in these frameworks accelerate training and improve efficiency.

As we move deeper into the “big data astronomy” era, the need for fast, stable, homogenous data reduction pipelines is more pressing. I will present the recent development of a pure Julia pipeline for the APOGEE instrument that takes 3D non-destructive readout images to 1D wavelength calibrated stellar spectra components. I will emphasize implementations of new/old methods of general interest to the JuliaAstro community and the desiderata to facilitate both daily and large HPC reductions.

Julia is already equipped with enough tools to interact with C libraries, but you have to be C developer to operate all those unsafe_ prefixed functions correctly.
But what if your physical degree scientists have to make mathematical models crunching gigabytes of data coming directly from C and you don't have time budget to make a copy?
In this talk I will show how to build wrappers around your C API to provide native Julia look and feel for C types and functions

Aerodynamically-controlled vertical takeoff vertical landing reusable space launch vehicles are of considerable commercial interest. We built a reusable launch vehicle model with aerodynamic and propulsive controls, performed trajectory optimization, and developed an algorithm for approximate nonlinear reachability analysis of the system to identify safe re-ignition points.

A significant pain point for the wider Julia Quantum ecosystem has been the lack of a Julia parser for OpenQASM 3 (OQ3). OQ3 is a widely used domain-specific language for specifying quantum programs. Quasar.jl is a new Julia package built on top of Automa.jl which allows generation of an AST from OQ3 and output of easily translatable instructions which can be run on real quantum devices or simulators. In this talk I will introduce the package and provide several usage examples.

Put WatchJuliaBurn.jl in your startup.jl file and you'll rarely be more than a keystroke away from a game of space invaders! And when I say keystroke, I'm not referring to just any key, certainly not that F13 key tucked away behind your monitor, I'm referring to the space bar.

But don't worry! Like any other REPL mode, a game of space invaders is entered by pressing a key at the start of a line that expressions don't normally begin with so this should not impact your existing workflows.

GPU-accelerated sparse operations are notoriously difficult to implement efficiently. In addition, the GraphBLAS standard requires modularity as users can provide custom operators to use in the matrix multiplication, which usually doesn't mix well with handwritten GPU kernels. Leveraging KernelAbstractions.jl, we took a novel approach by JIT-compiling customized kernels for any user-defined operation while making it compatible cross-platform.

This talk will present the latest developments in JuLDPM.jl, a Julia package for the Lattice Discrete Particle Model (LDPM), in the context of mechanics of porous media. The talk will first present the main features of the LDPM approach, highlighting several computational advantages in the description of discontinuities and localized phenomena. Three applications will be presented, with emphasis on the computational advantages granted by Julia in performing large-scale simulations.

Astronomy problems often involve data from diverse instruments and archives. In Julia, all essential tools are available and work together, offering a uniquely performant and uniform workflow. We'll explore how Julia ecosystem tackles the full range of steps when working with astronomy catalogs, large and small.

Once upon a time, a significant other who shall remain nameless (for now) idly asked what the longest chain of hyphenated names of theories/equations/theorems one could string together might be: e.g. Navier-Stokes, Stokes-Einstein, Einstein-Smoluchowski, ...

What follows is what happened next.

JuliaSim Modeling Language (JSML) is a declarative language for describing the composition of ModelingToolkit models. It encompasses all aspects of the models: their mathematical behavior and graphical appearance and composition.

This talk introduces the standard libraries we are building with JSML. It gives insight into how we manage these libraries and how one can develop custom component libraries to integrate with the rest of the ecosystem.

A growing number of countries are using airborne lidar scanning to collect geospatial point-cloud data at sub-meter-scale resolution for their whole territory and making it freely available. PointClouds.jl allows you to make use of such datasets by locating available data for your coordinates of interest, downloading and reading the data in the specialized LAS format, and extracting useful information from the raw point cloud through a series of processing steps.

ScatteringOptics.jl is a Julia package for simulating anisotropic radio wave scattering in the ionized interstellar medium. It leverages Julia’s speed and composability to outperform Python by up to 100× in model computations. The package incorporates phase screen models and integrates with the Bayesian radio interferometric module Comrade.jl. Julia’s high-performance auto-differentiation enables efficient computation and Bayesian inference of complex scattering models.

Astrometry is the science of positional astronomy. It involves the measurements of the locations, velocities, and distances of celestial objects, such as stars, planets (including Earth), and space probes. The Astrometry package implements basic astrometric algorithms that are fast and simple to use.

Chapel is a programming language designed to make parallel and distributed programming easier, more productive and more enjoyable. Julia, similarly, aims to solve the two-language problem, bridging the gap between scientific exploration and efficient computation. With such similar goals, the communities can learn from each other to share experiences, and thoughts. Join our BoF for a cozy and informal session about Chapel, with a brief overview of the language followed by an informal discussion.

Are you a Julia enthusiast swimming in a sea of legacy MATLAB code and models? Do you wish you could convince your colleagues to make the leap into the Julia ecosystem? You are in the right place! What if you could convince your team they didn’t have to choose between MATLAB and Julia? There is a way to have the best of both worlds without totally re-writing all your legacy models. Join us for a session on how to integrate high-performance Julia code into your MATLAB codebase.

This talk demonstrates how the difficult problem of modeling fluid systems is tackled in JuliaSim. We will cover various numerical and symbolic challenges that we face and then provide a detailed discussion of how we model the properties of different types of fluids across a range of engineering applications including applications like HVAC, power fluids and so on.

QuantumSymbolics.jl is a quantum-focused computer algebra system designed for numerical translations to different formalisms in quantum information. This package provides symbolic manipulation methods and convenient abstractions of various backend quantum simulators.

We host an extended panel discussion of challenges and lessons learned from incorporating Julia into Astronomy & Astrophysics research projects.

Let's talk about implementing an interface for sparse linear algebra! This talk will focus on the ongoing Sparse BLAS effort as well as experiences implementing a high-level Sparse BLAS reference implementation in C++.

We present a demonstration of applying tensor network methods with gausslets as a basis set. The locality of gausslets promotes sparsity in the molecular Hamiltonian, which is important for numerical scaling. We first use Quiqbox.jl to discretize molecular Hamiltonians with gausslets, then use iTensor.jl to approximate the ground-state energies. This pipeline demonstrates the potential of studying the application of novel basis sets for tensor network methods in electronic structure problems.

is a new Julia package designed to bring recent powerful metaheuristic optimization algorithms to the Julia ecosystem. It includes more than 100 different metaheuristic optimization algorithms. These algorithms have been carefully implemented and are ready to help solve your optimization problems. Implementing the CEC benchmark for performance evaluation, future plans include the full CEC suite and expanding to ~300 optimization algorithms.

The Brazilian National Institute for Space Research (INPE) is developing a new satellite, Amazonia-1B, with a different payload than it was used on Amazonia-1. This new configuration requires new control gains and parameters. A new control gain tuning tool, developed using Julia, enabled faster and more efficient gain selection than the previous approach. It utilizes libraries from the Julia ecosystem and a simplified single-axis model, significantly reducing the time for gain optimization.

In this talk, we would like to show how QUBO.jl makes Quantum Optimization accessible to Operations Research practitioners as it integrates a heterogeneous hardware and software landscape under a common interface, providing users with a smooth modeling experience. By leveraging JuMP’s extension capabilities, QUBO.jl makes it simple to access quantum and other novel devices as if they were regular optimization solvers. This makes it the ideal environment to try and explore potential applications.

The Julia User & Developer Survey is an annual survey of 1,000+ Julia users and developers. We provide the Julia community with updated information about the most popular Julia packages, most important opportunities, issues to address, community growth and more.

The Julia HPC community has been growing over the last years with two monthly meetings to coordinate development and to solve problems arising in the use of Julia for high-performance computing.

The Julia in HPC Birds of a Feather is an ideal opportunity to join the community and to discuss your experiences with using Julia in an HPC context.

PythonCall.jl and juliacall have recently added support for using multithreaded Julia code from Python, or calling Python code from Julia threads. However, there are still quite a few gotchas. In this talk I will discuss some pitfalls encountered when developing a Python wrapper for a multithreaded Julia package and demonstrate workarounds and some suggestions for other package developers encountering similar issues.

The primary aim of this talk is to motivate embedding formalized meaning into a Julia file's comments by means of brief, simple, expressive and extendable metadata. An intuitive schema satisfying these conditions will be proposed. The crux of the idea lies in its potential to serve a wider variety of different packages, possibly even facilitating interactions between them.

For the purpose of illustrating some of the benefits of using this schema, a new package will be introduced.

Air-gapped environments are computer systems or networks that are physically isolated from the internet and other external networks. This means, your Julia app in this environment will not have access to any public or private package servers that are outside the network. This talk will focus on how to make your Julia app usable in these environments. We'll also explore common challenges, including regulatory compliances, portability, certifications, and licensing, and how to address them.

FlexiJoins.jl offers unparalleled flexibility in data joining – both within the Julia ecosystem and beyond. It supports a wide variety of join conditions and options through efficient algorithms, can operate on both in-memory collections and SQL tables. In this talk, I'll demonstrate and explore the uniform user-facing interface, and discuss the underlying design of the package that leverages Julia dispatch capabilities.

Julia's unit testing capability is aided by over 200 testing packages on JuliaHub. Some of these packages offer quiet necessities like protecting the scope of an individual test case. Others offer arcane and powerful techniques like mutation testing. Let's survey testing packages to see what help is only a package-add away.

We present TwoBody.jl, a Julia package for solving quantum mechanical two-body problems in hadron physics, quantum chemistry, and other fields. This package has several methods for solving the Schrödinger equation. Since this package allows users to construct custom Hamiltonians, it is well-suited for general two-body problems. Software testing is performed using Antique.jl. We present the research and the development workflow using these two Julia packages.

Base Julia provides mostly low-level multi-threading and synchronization primitives -- task spawn, locks, conditions, etc. In building our knowledge graph application at RAI, we have found the need for higher level abstractions to build parallelism into our processing pipeline. In this lightning talk, we will describe TaskGroups: why we need them and what you can do with them.

In this lightning talk I will step through some of the annoyances and papercuts I encountered while writing multithreaded Julia code for my scientific applications. I will present a feature wishlist for Julia multithreading capabilities going forward and identify some tools I used to address performance problems I ran into.

ASML is the leading edge company production photo-lithography machines used to produce the most advanced chips in the world. Development of sophisticated machines requires rapid development of fast and advanced algorithms. Julia is a natural match for such developments. However, deployment is still a challenge.
For those machines we are testing deployment of compiled Julia code using juliac. This talk is a summary of our adventures trying make it work.

This talk discusses our efforts to enhance the JuliaSim modeling platform with tools that make it easy for model developers to create high quality component libraries. This talk focuses on two aspects of building a quality component library, documentation and testing. Our approach is to provide tools that provide highly automated workflows to support regression testing and documentation generation and to do so in a way that mirrors best practices in the area of software development.

Julia's capabilities in complex mathematical operations and its efficient use of sparse matrices make it an optimal choice for modeling quantum chemical interactions. The methods of simulating these interactions often involve dense matrix computations, which are computationally expensive and memory-intensive. The use of sparse matrix algorithms in Julia for quantum addresses these challenges by significantly reducing the computational resources required, thus enabling more extensive simulations.

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

OhMyThreads.jl is a package providing interfaces for 'data-parallel' multithreaded operations in Julia, providing solid, modular implementations of common building blocks to speed up development, and reduce errors that occur when users attempt to write their own versions of operations they typically think of as for loops.

We hope that this package can become the standard package that users know to reach for when multithreading, and that it can inform changes and improvements to Base.Threads

Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.

This talk will explore the latest advancements and current state of Lux.jl, a deep-learning framework in Julia. We will also introduce how to use Reactant.jl, a powerful tool that compiles Julia code to MLIR and executes it across various backends using XLA, with Lux. The session will highlight how Reactant.jl and Lux.jl enable training neural networks in Julia at speeds comparable to popular frameworks like JAX and PyTorch.

Carlo.jl is a framework for developing high-performance, distributed Monte Carlo simulations, geared towards the needs of the quantum Monte Carlo community. It takes care of parallel scheduling (including parallel tempering), organized storage of input, checkpoint, and output files, as well as statistical postprocessing, allowing for the quick development of versatile Monte Carlo codes.

Solving systems of polynomial equations is a challenging problem that appears ubiquitously in the sciences and engineering. In this talk, we will present a tutorial for a new software for solving multivariate polynomial systems that provides guarantees on the correctness of solutions. Our methods can be accessed through PACE.jl, a new Julia package that combines symbolic and numerical methods.

Julia tasks are lightweight threads that Julia schedules MxN on OS threads. Tasks are cooperatively scheduled: there is no preemption; switches typically occur when waiting for events. In such a system, fairness is difficult to achieve--tasks can hog CPU time and starve other tasks.

We will describe the consequences of a lack of fairness in a real world system--RAI's knowledge graph system. We show how we were able to improve and discuss the implications for future work on Julia's scheduler.

When you write a float range like 0.1:0.2:0.7 it seems obvious that you want the elements to be 1/10, 3/10, 5/10, 7/10. But the floating-point numbers 0.1, 0.2 and 0.7 are not exactly 1/10, 2/10 and 7/10—they are approximations of the form m/2^p. Guessing what any given float range was intended to mean turns out to be shockingly hard. Julia currently uses a heuristic that mostly works but still has some rather unfortunate failures. This talk explores how to solve this problem once and for all.

AcceleratedKernels.jl is a unified, backend‐agnostic library for high-performance parallel algorithms in Julia. Built on KernelAbstractions.jl, it lets you write “once” and run everywhere—supporting multithreaded CPUs and GPUs (CUDA, ROCm, oneAPI, Metal) from a single codebase. In this talk I explain the design, implementation, and 200-GPU benchmark results of AcceleratedKernels.jl and show how to write portable code that runs on different hardware without modification.

Elastic networks composed of Hookean springs serve as important models for the cytoskeleton, enzymes, and adaptive metamaterials. However, the elastic moduli of such networks are typically computed with finite difference methods, which yield inexact results that may introduce significant errors for mechanically sensitive materials. In ElasticityAD.jl, we have use Julia's automatic differentiation framework to enable calculations of exact stiffness tensor and elastic moduli.

Solving nonlinear least squares problems is very common across many aspects of science, from the implementation of curve fitting in data analysis to complex nonlinear optimizations. In this talk we will talk about the latest advancements in solving nonlinear least squares problems in Julia. This includes a discussion of the newest methods and packages, along with the remaining challenges around discoverability and documentation.

Monitor.jl is a tool that allows you to monitor and modify Julia values you choose in real-time, even across thousands of jobs. Combined with ad hoc UIs / dashboards, this significantly speeds up debugging, especially in complex scenarios like cloud-based simulations.

The talk will discuss and demo

• Monitor.jl’s capabilities
• how it works
• connecting to single or multiple Julia sessions (map/reduce, etc.)
• diagnostic exploratory programming
• monitoring and rollups
• front ends

This talk will dive deep into gen ai topics like integrating vector search and RAG with Julia.

In this talk you'll learn how to build a sophisticated RAG chatbot in Julia, focusing on efficiently retrieving and processing information from the DataFrames.jl documentation to generate accurate and contextually relevant responses while using implementations of popular open source vector databases like Milvus for fast retrieval of closely related data.

Julia Gender Inclusive is an initiative that aims to provide a supportive space for all (gender) minorities in the Julia community. In this BoF session we hope to discuss the status of (gender) diversity in the community and engage supportive allies. In particular, we want to focus on how the Julia community can support our efforts and promote inclusion in the wider technical community. While we focus on gender diversity, we would like to open the discussion up to all facets of diversity.

Universal Differential Equations (or UDEs for short) have emerged as a novel way to integrate information
from experimental data into mechanistic models. One of the most important questions when using UDEs
is what equations to modify in order to add the effects of a neural network. In this talk we will
explore what kind of corrections we can make based on the architecture of the UDE.

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

OpenCL.jl is one of the oldest GPU programming packages in Julia. We recently revived this package, integrating it with the JuliaGPU ecosystem and enabling native compilation of Julia code through SPIR-V. This allows programming modern OpenCL accelerators, including CPUs through the PoCL library. The end result is a high-quality CPU backend for KernelAbstractions.jl that outperforms the existing tasks-based implementation.

The SmoQySuite organization maintains a growing suite of Julia packages for solving low-energy effective models of strongly-correlated quantum materials. Our organization specifically focuses on developing quantum Monte Carlo related tools for solving model Hamiltonian systems. SmoQySuite pursues a modular development philosophy, enabling users to interface with its suite of packages at various levels of complexity. This allows us to provide useful tools to a large community of researchers.

TidierDB.jl is a 100% Julia implementation of the dbplyr and duckplyr R packages, and similar to Python's ibis package.

The main goal of TidierDB.jl is to bring the syntax of Tidier.jl to multiple SQL backends, making it possible to analyze data directly on databases (or locally) without copying the database/file into memory.

We present FHist.jl, a well-used pure Julia package for histogramming among High-energy physics Julia community as well as in some GeoSpatial applications.

The package implements one of the fastest histogram package on CPU that also handles weighted inputs and tracks the uncertainty properly. We demonstrate the feature, performance, as well as visualization integration of FHist.jl in the talk.

Additionally, as data analysis are moving towards GPU, we will show a GPU-friendly implementation.

Each task in Julia has its own PRNG. When a task is forked it needs to seed the child task's RNG. This talk is about the evolution of how we've done this and the novel technique we now use that solves the annoyances and bugs that plagued our previous approaches. We've generalized the DotMix algorithm designed by Leiserson et al. for the Cilk parallel runtime system, simplifying and strengthening it while retaining provable collision resistance.

Comments, questions, or concerns about the future direction of the SciML tools? Come here to discuss what we want to see in the near future.

Here we present, LightMatter.jl, a flexible and efficient framework for simulations of nonequilibrium dynamics triggered by light. By leveraging Julia’s powerful metaprogramming capabilities, it dynamically assembles and propagates user-defined 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.

In this talk on TrajectoryBundles.jl, we will discuss the implementation of the Trajectory Bundle Method in Julia leveraging DiffEqGPU.jl. This approach to trajectory optimization is derivative-free, and instead leverages GPU-based ODE solvers and convex optimization.

UniversalDiffEq.jl provides an easy-to-use front end for building universal differential equations (UDEs). It implements and several training routines, including a novel state-space approach that increases training stability on noisy and highly variable time series data. We applied these methods to long-term environmental data sets to demonstrate their usefulness for inferring biological mechanisms from time series data and forecasting large changes in ecosystem states called regime shifts.

EvoTrees.jl is a Julia implementation of gradient-boosted trees, a state-of-the-art algorithm class for tabular data.

This talk provides an overview of EvoTrees.jl implementation and key features. We present recent advancements, including new loss functions, benchmarks against popular libraries, and planned improvements, such as enhanced GPU support and auto-diff for custom loss functions.

This talk will focus on the BasisSets.jl package, available at https://github.com/HartreeFoca/BasisSets.jl, which leverages Julia's state-of-the-art capabilities in automatic differentiation (AD) to optimize Gaussian basis sets, a fundamental component in molecular modeling.

In this talk, we demonstrate major updates to Quiqbox. First, we introduce enhanced parameterization based on directed acyclic graphs. Second, we showcase improved basis compositions and support for user-defined basis functions. Correspondingly, a hybrid integral engine is implemented to compute the discretized molecular Hamiltonians. Last, we hope to shed light on Quiqbox’s applicability for general scientific modeling beyond electronic structure problems within the Julia community.

Since Tidier.jl hit the registry in 2023, a lot has changed!

Some Highlights:
- TidierData now supports logging to provide feedback on variable changes in chained DataFrame transformations
- TidierPlots is fully featured ggplot2 with Julian flavor
- TidierDB brings TidierData syntax to 12 sql database backends
- TidierFiles harmonizes file reading/writing for over 12 file types from .csv and .xpt to Google Sheets
- Benchmarks!

In this talk we'll summarize and demonstrate some of the improvements made to the CUDA.jl package over the past year; including new features in the compiler, memory management, and device programming stack; as well as updates about the support for various CUDA libraries. Practical examples will be provided to show the benefits of this work for both end users and developers of packages which rely on CUDA.jl.

Knowledge of the physical laws acting on a system is often incomplete. These gaps in our knowledge are referred to as missing physics. Neural network based techniques, post-processed with interpretable machine learning techniques such as symbolic regression, are one way to learn this missing physics. We propose an efficient data gathering technique which aims to make both the fitting and post-processing of the neural network as precise as possible, showcased through a bioreactor case study.

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

The NQCDynamics.jl performs semiclassical and mixed quantum–classical molecular dynamics simulations of chemical reaction dynamics. It hosts modular packages designed to enable developing new methods and production-level simulations. The code hosts common models and provides interfaces to existing atomistic simulation frameworks, such as ASE and machine learning representations. Here we present the code design that benefits from Julia features and recent research use cases.

This talk introduces Julia’s new SAT-based version resolver, which overcomes various issues with the old resolver while being faster, more scalable, more flexible, and guaranteeing optimal solutions. Since it constructs a SAT instance encoding all dependencies and conflicts between versions, it also provides a powerful tool for solving related resolution-like problems. We'll cover how this approach works and explore additional use cases beyond version resolution.

Today, most AI applications send data to LLM cloud providers, raising privacy concerns. This talk introduces a new way to build AI applications that keep everything local on your computer. By running LLMs locally with Ollama powered by a Julia Client Script and managing data with open source vector databases, we avoid transmitting sensitive information to external cloud providers. We will also highlight LangChain's ability to create versatile agents capable of handling tasks autonomously.

Latest changes, features and performance improvements in AMDGPU.jl which provides AMD GPU programming support in Julia.

This session provides a brief introduction to our new package, TrixiCUDA.jl, which offers CUDA acceleration support for solving hyperbolic PDEs on GPUs.

SciML bridges the gap between scientific modeling and Machine Learning (ML). It has revolutionised simulation, if used properly when designing and calibrating complex acausal systems. Julia, with ModelingToolkit.jl (MTK) has some of the most advanced simulation capabilities, but how does one make use of ML methods with it? This talk will focus on how to utilise an existing neural network as a component in MTK and seamlessly integrate it back into the first principles system

The approach presented here bridges a gap in human-AI interaction, enabling LLM intelligence for small tasks where traditional chat is too cumbersome. It combines deterministic voice control with offline execution of distilled LLMs, offering privacy, efficiency, and performance. The LLM output can be converted to audio via text-to-speech, enabling almost human-like interaction. Implemented in JustSayIt.jl, it lets anyone define or program voice-enhanced LLM interaction tailored to their needs.

FreeBird.jl is an extensible platform for computationally studying phase equilibria across a diverse range of interfacial systems, with easy extension to other phenomena. FreeBird.jl employs the concept of walkers—sets of configurations that evolve systematically to sample a desired statistical distribution. We implemented an atomistic and a lattice walker system, and various sampling schemes, such as nested sampling, Wang-Landau sampling, Metropolis Monte Carlo, etc.

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.

We first present the hydrodynamic equations for lyotropic (concentration-dependent) Liquid Crystals, derived via the thermodynamic GENERIC framework. Next, we introduce our .jl package to solve these equations, combining (1) finite differences (inspired by DiffEqOperators.jl) and (2) the Lattice Boltzmann method (found in Trixi.jl). Solving in 2D and 3D, under different flows and with external electric fields, we demonstrate that our methodology allows the prediction of experimental data.

We present a machine-learning-inspired approach to expand the Fermi operator, enabling linear-scaling density-matrix calculations for electronic properties with reduced computational cost. Utilizing Julia’s ecosystem, we achieve rapid prototyping, performance optimizations, and GPU acceleration (including tensor cores). Automatic differentiation packages allow us to handle physically meaningful functions more flexibly.