0.23 juliacon-2025 2025-07-21 2025-07-26 6 00:05 https://pretalx.com America/New_York Lawrence Room 120 - REPL Main Stage Workshop 2025-07-22T09:00:00-04:00 09:00 03:00 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. juliacon-2025-61405-a-deep-dive-into-differentialequations-jl General Chris RackauckasOscar Smith en DifferentialEquations.jl is many things, and lots of people only use a small portion of it. The purpose of this workshop is to be accessible introduction to many aspects of the packages that the developers feel are underutilized and under-understood. We will start the workshop with a basic introduction to using the ODE solver so that everyone is comfortable, but then we will quickly start diving into detailed topics including: * Scalability tips for ODEs: choosing the right solver, customizing linear solvers, integrating preconditioners, specializing the factorization routines, solving in mixed precision, and more. * Understanding adaptive time stepping, controller choices, handling domain constraints, and details on advanced options. * A deep dive into callbacks: performance of continuous callbacks vs vector continuous callbacks, early stopping of integration, the DiffEqCallbacks.jl premade library. * Writing custom logging systems and taking direct control of the time stepping for embedded deployments. * In-depth debugging of equations using the integrator interface, exposed solver error estimates, and integrations with Revise. The workshop is made to go into details but should accessible to newcomers to the library who care about the details. false YouTube Link https://pretalx.com/juliacon-2025/talk/AREXQA/ https://pretalx.com/juliacon-2025/talk/AREXQA/feedback/ Lawrence Room 120 - REPL Main Stage Workshop 2025-07-22T13:00:00-04:00 13:00 03:00 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! juliacon-2025-62238-sciml-in-fluid-dynamics-cfd-surrogates-of-weather-models General Chris RackauckasAnas Abdelrehim en This workshop is more designed as an interactive challenge. We will use the Julia-based SpeedyWeather.jl / RainMaker.jl as a model and participates will participate in a challenge to find parameter solutions that cause the most rain in a specific location. Premade scripts that show how to run the weather model will be provided. The goal will be to find parameters of the model which maximize the rainfall. Solutions which start by building an ML surrogate model will be shown to the participants as a starting point. A live interactive leaderboard automatically updated through CI (Documenter.jl builds) will be used in order track the progress of different participants. Suggested techniques, using tools like LIBSVM.jl, XGBoost.jl, etc. will be discussed and participants will try various ML and SciML tools to achieve the goals. At the end, the participants will share their solutions and a "winner" to the challenge will be crowned. The goal of course is not to win, but the friends you make along the way. By the end, participants will have had fun while learning new ML tools within Julia, gained experience mixing climate/weather modeling tools with ML, and have discussions about what new tooling could further enhance the workflows. false YouTube Link https://pretalx.com/juliacon-2025/talk/MWHF8J/ https://pretalx.com/juliacon-2025/talk/MWHF8J/feedback/ Lawrence Room 121 - Struct Room Workshop 2025-07-22T09:00:00-04:00 09:00 03:00 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. juliacon-2025-64936-hands-on-with-julia-for-hpc-on-gpus-and-cpus General /media/juliacon-2025/submissions/ECMKLP/Julia_for_HPC_-_JuliaC_KFee52c.png Samuel OmlinJohannes BlaschkeRaye Kimmerer en Why wait hours for computations when they could take seconds? Why struggle with rewriting high-level prototypes in lower-level languages just to achieve performance? Traditionally, writing fast code for HPC systems requires mastering hardware-specific languages, leading to complex, expensive, and difficult-to-maintain software. Julia removes this barrier by providing a seamless, high-performance environment and package ecosystem where domain experts can easily integrate and reuse optimized code, making HPC more approachable and efficient. Participants will gain hands-on experience running Julia code on a GPU-powered supercomputer. This workshop will introduce practical techniques for developing and optimizing Julia applications on modern HPC systems. We will cover: 1. Resource management and configuration 2. Single-node parallelization with multithreading 3. GPU programming using [KernelAbstractions.jl](https://github.com/JuliaGPU/KernelAbstractions.jl), [ParallelStencil.jl](https://github.com/omlins/ParallelStencil.jl), and [JACC.jl](https://github.com/JuliaORNL/JACC.jl) 4. Multi-node parallelization using [MPI.jl](https://github.com/JuliaParallel/MPI.jl), [ImplicitGlobalGrid.jl](https://github.com/eth-cscs/ImplicitGlobalGrid.jl), [Distributed.jl](https://github.com/JuliaLang/Distributed.jl), and [Dagger.jl](https://github.com/JuliaParallel/Dagger.jl) 5. Real-time visualization of multi-process simulations ### Hands-On Learning Experience The workshop is designed for both HPC users and newcomers curious about accelerating computations. It consists of two parts, featuring a session about the fundamentals in the morning and application in the afternoon: 1. **Fundamentals**: Learn core Julia tools for parallel computing through simple, illustrative examples. 2. **Application**: Develop a parallelized version of a serial code and run it on two GPU-accelerated supercomputers: **NERSC’s Perlmutter** and **PSC’s Bridges-2**. ### Who Should Attend? This workshop is for researchers, engineers, and developers looking to accelerate scientific computing, machine learning, and other computational tasks. Whether you're already using HPC systems or just getting started, this session will equip you with the knowledge and tools to write high-performance and scalable Julia applications. ### Prerequisites Participants should have a basic understanding of Julia (functions, modules, control flow, and arrays) and familiarity with standard development tools like Git, SSH, and the Bash command line. No prior experience with multi-threading, distributed computing, or GPU programming is required. We look forward to an engaging, inclusive, and knowledge-rich event—see you there! _This workshop requires RSVPs for the allocation of credits to HPC system resources._ You can RSVP here: https://forms.gle/sC9K9xHgVTMDwjan6. You MUST register by JULY 1 in order to participate. false YouTube Link https://pretalx.com/juliacon-2025/talk/ECMKLP/ https://pretalx.com/juliacon-2025/talk/ECMKLP/feedback/ Lawrence Room 121 - Struct Room Workshop 2025-07-22T13:00:00-04:00 13:00 03:00 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. juliacon-2025-73515-hands-on-with-julia-for-hpc-on-gpus-and-cpus General Samuel OmlinJohannes BlaschkePhilip FacklerT.J. Olesky en Why wait hours for computations when they could take seconds? Why struggle with rewriting high-level prototypes in lower-level languages just to achieve performance? Traditionally, writing fast code for HPC systems requires mastering hardware-specific languages, leading to complex, expensive, and difficult-to-maintain software. Julia removes this barrier by providing a seamless, high-performance environment and package ecosystem where domain experts can easily integrate and reuse optimized code, making HPC more approachable and efficient. Participants will gain hands-on experience running Julia code on a GPU-powered supercomputer. This workshop will introduce practical techniques for developing and optimizing Julia applications on modern HPC systems. We will cover: 1. Resource management and configuration 2. Single-node parallelization with multithreading 3. GPU programming using [KernelAbstractions.jl](https://github.com/JuliaGPU/KernelAbstractions.jl), [ParallelStencil.jl](https://github.com/omlins/ParallelStencil.jl), and [JACC.jl](https://github.com/JuliaORNL/JACC.jl) 4. Multi-node parallelization using [MPI.jl](https://github.com/JuliaParallel/MPI.jl), [ImplicitGlobalGrid.jl](https://github.com/eth-cscs/ImplicitGlobalGrid.jl), [Distributed.jl](https://github.com/JuliaLang/Distributed.jl), and [Dagger.jl](https://github.com/JuliaParallel/Dagger.jl) 5. Real-time visualization of multi-process simulations ### Hands-On Learning Experience The workshop is designed for both HPC users and newcomers curious about accelerating computations. It consists of two parts, featuring a session about the fundamentals in the morning and application in the afternoon: 1. **Fundamentals**: Learn core Julia tools for parallel computing through simple, illustrative examples. 2. **Application**: Develop a parallelized version of a serial code and run it on two GPU-accelerated supercomputers: **NERSC’s Perlmutter** and **PSC’s Bridges-2**. ### Who Should Attend? This workshop is for researchers, engineers, and developers looking to accelerate scientific computing, machine learning, and other computational tasks. Whether you're already using HPC systems or just getting started, this session will equip you with the knowledge and tools to write high-performance and scalable Julia applications. ### Prerequisites Participants should have a basic understanding of Julia (functions, modules, control flow, and arrays) and familiarity with standard development tools like Git, SSH, and the Bash command line. No prior experience with multi-threading, distributed computing, or GPU programming is required. We look forward to an engaging, inclusive, and knowledge-rich event—see you there! _This workshop requires RSVPs for the allocation of credits to HPC system resources._ You can RSVP here: https://forms.gle/sC9K9xHgVTMDwjan6. You MUST register by JULY 1 in order to participate. false https://pretalx.com/juliacon-2025/talk/SP39VF/ https://pretalx.com/juliacon-2025/talk/SP39VF/feedback/ Lawrence Room 121 - Struct Room Social hour 2025-07-22T18:00:00-04:00 18:00 01:00 Julia Gender Inclusive will be hosting an informal dinner at Roots Natural Kitchen (just a few blocks from JuliaCon) on Tuesday, July 22nd at 6pm. We invite anyone who sees their gender as under-represented within this community, including women, non-binary people, trans people of all genders, and people exploring or questioning their gender. juliacon-2025-78195-julia-gender-inclusive-dinner-roots-natural-kitchen General en Julia Gender Inclusive will be hosting an informal dinner at Roots Natural Kitchen (just a few blocks from JuliaCon) on Tuesday, July 22nd at 6pm. We invite anyone who sees their gender as under-represented within this community, including women, non-binary people, trans people of all genders, and people exploring or questioning their gender. false https://pretalx.com/juliacon-2025/talk/YVYLEG/ https://pretalx.com/juliacon-2025/talk/YVYLEG/feedback/ Lawrence Room 104 - Function Room Workshop 2025-07-22T09:00:00-04:00 09:00 03:00 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. juliacon-2025-64982-introduction-to-computational-neuroscience-with-neuroblox-jl General /media/juliacon-2025/submissions/RXB9KF/NB_Logo_Full_Transpare_E20YBK9.png Helmut Strey en Computational neuroscience aims to simulate the brain in silico, from single synapses to brain-wide networks. The field has matured in tandem with experimental neuroscience, where computational modeling has become an indispensable tool for understanding neuroscience data and motivating future experiments. However, building such models can involve a painstaking process of translating concepts from the literature into working code and then optimizing it to run in a reasonable timeframe. Neuroblox is a new software platform for computational neuroscience that aims to break down these barriers. It is based on the Julia programming language and built with simplicity, modularity, and performance. It consists of a library of modular computational building blocks (“Blox”) that can be easily assembled to simulate brain dynamics in code or via an easy-to-use graphical interface. Our tools bridge scales from spiking neurons to brain waves and fMRI and have applications to neurology and psychiatry. Moreover, the behavior of multiple model variants can be compared to discriminate between competing hypotheses. 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. By the end of the course, you will be able to model your own data and build your own custom “blox” that may be incorporated into the Neuroblox library. The structure of the workshop is as follows: Each session consists of a short (~15 min) lecture + hands-on activities Session 1: Introduction to Neuroblox, Differential equations and plotting in Julia, Design new Blox components and connection rules Session 2: Single neurons & neural masses with external sources, Multiple neurons & neural masses in circuits Session 3: Running a decision-making task with a circuit model, Synaptic plasticity, and learning false YouTube Link https://pretalx.com/juliacon-2025/talk/RXB9KF/ https://pretalx.com/juliacon-2025/talk/RXB9KF/feedback/ Lawrence Room 104 - Function Room Workshop 2025-07-22T13:00:00-04:00 13:00 03:00 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. juliacon-2025-65028-quantum-systems-modeling-workshop General Stefan KrastanovKatharine Hyatt en The workshop will be split in three parts, covering the linear algebra necessary for the general (but exponentially expensive) wavefunction formalism; the master equations governing the evolution of open quantum systems; and lastly, less-general algorithms that can not describe arbitrary quantum systems, but are efficient to execute on classical computers and of great importance in the study of error correction (e.g. the stabilizer formalism). The workshop will cover both theoretical basics and practical numerical techniques related to state vector and density matrix handling, a variety of master equations and quantum trajectories approaches to open quantum systems, and the stabilizer formalism and the Gaussian quantum optics formalism for efficient handling of non-general quantum systems. Symbolic computer algebra tools permitting efficient transition between the aforementioned state representations will be discussed. The workshop will focus on existing tools in the Julia ecosystem, but it will also present how such tools can be build from scratch and what alternatives exist in other software ecosystem. false YouTube Link https://pretalx.com/juliacon-2025/talk/ANQWM9/ https://pretalx.com/juliacon-2025/talk/ANQWM9/feedback/ Lawrence Room 107 - Method Room Workshop 2025-07-22T09:00:00-04:00 09:00 03:00 Kick-start JuliaCon 2025 with this half-day workshop to pick up the language. Discover what makes Julia special and start writing your own code right away. No prior Julia experience is necessary; this workshop is geared towards anyone with basic programming knowledge from another language. juliacon-2025-73591-introduction-to-julia General Matt BaumanLetícia MadureiraEthan Meitz en The goal of this workshop is to provide you with a broad overview of the language and establish a foundation for the rest of the week. We will cover Julia's syntax and data structures as well as its marquee features, including multiple dispatch, its type system, and a few common packages. false YouTube Link https://pretalx.com/juliacon-2025/talk/RDB8J8/ https://pretalx.com/juliacon-2025/talk/RDB8J8/feedback/ Lawrence Room 120 - REPL Main Stage Ceremony 2025-07-23T09:00:00-04:00 09:00 00:10 Opening the main days of talks at JuliaCon Global 2025 at Pittsburgh with the organizing committee. juliacon-2025-75183-opening-ceremony General Ranjan AnantharamanRaye Kimmerer en Opening the main days of talks at JuliaCon Global 2025 at Pittsburgh (Pitt/CMU) with the organizing committee. false https://pretalx.com/juliacon-2025/talk/GKEFB9/ https://pretalx.com/juliacon-2025/talk/GKEFB9/feedback/ Lawrence Room 120 - REPL Main Stage Keynote 2025-07-23T09:10:00-04:00 09:10 00:45 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. juliacon-2025-66722-challenges-and-opportunities-of-digital-twins General Prith Banerjee en Digital twins have been used in various industries such as automotive, aerospace, energy, industrials, high-tech, and healthcare to model complex physical systems and predict its behavior accurately under various scenarios. Digital twins have a physical asset, a virtual model, and a two-way information flow between the physical and virtual worlds using an IOT platform.  In this talk I will discuss various challenges and opportunities in building digital twins. One approach to build digital twins is to use data-based analytics and AI/machine learning but this requires lots of training data and the accuracy is limited to the observed data. A second approach to build digital twins is to use physics-based simulation which are very accurate, but they require long computation times to deploy. These simulation runtimes can be accelerated with the use of reduced-order models. I will present the concept of a hybrid digital twin on the Industrial Metaverse that combine 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. I will illustrate how a platform such as JuliaHub can be used to build hybrid digital twins. I will show how this concept can be applied to building digital twins of semiconductor manufacturing fabs to drive higher yields, faster throughput, lower cost, and higher operating equipment efficiency. false YouTube Link https://pretalx.com/juliacon-2025/talk/K9QZKN/ https://pretalx.com/juliacon-2025/talk/K9QZKN/feedback/ Lawrence Room 120 - REPL Main Stage Diamond sponsor talk 2025-07-23T09:55:00-04:00 09:55 00:20 Dyad is a modern modeling and simulation tool that combines both the declarative modeling world with the imperative Julia world, resulting in a unified environment for modeling, scientific machine learning, control system synthesis and code generation for embedded devices. In this talk, JuliaHub will present Dyad Builder, a graphical schematic editor to build models and run SciML analyses, as well as Dyad Studio, a development environment to compile Julia code to several hardware targets. juliacon-2025-73509-juliahub-sponsor-talk General Viral B. Shah en Dyad is a modern modeling and simulation tool that combines both the declarative modeling world with the imperative Julia world, resulting in a unified environment for modeling, scientific machine learning, control system synthesis and code generation for embedded devices. In this talk, JuliaHub will present Dyad Builder, a graphical schematic editor to build models and run SciML analyses, as well as Dyad Studio, a development environment to compile Julia code to several hardware targets. Dyad is already being used by several leading customers across the energy and aerospace verticals. Dyad Studio is available for download today on JuliaHub.com and Dyad-Builder will be released in August 2025. false https://pretalx.com/juliacon-2025/talk/J7WJSW/ https://pretalx.com/juliacon-2025/talk/J7WJSW/feedback/ Lawrence Room 120 - REPL Main Stage Talk 2025-07-23T10:30:00-04:00 10:30 00:30 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). juliacon-2025-62624-relint-an-extensible-lint-checker Developer tools Alexandre Bergel en Despite its wide acceptance, StaticLint.jl has some shortcomings that got in the way of our use: - Adding new rules is cumbersome, - StaticLint cannot be easily run by a GitHub action at each commit or used to gate a commit if changes violate some lint rules. This talk presents and demonstrates ReLint, an open-source Lint checker used at RelationalAI, released under the MIT License. ReLint is fast, extensible, offers tools to match abstract syntax trees, and can be used by a GitHub workflow or a pre-commit hook. **Example 1**: Consider the scenario: we would like to forbid the use of `@async` in a codebase to favor `@spawn`. We can define an empty struct as follows: ```Julia struct AsyncRule <: LintRule end ``` And the function `check` can then be overloaded: ```Julia check(::AsyncRule, x::EXPR) = generic_check(x, "@async hole_variable", "Use `@spawn` instead of `@async`.") ``` The pattern to be matched is provided as a Julia string code `"@async hole_variable"`. The pseudo-variable `hole_variable` matches any expression. Each instance of this pattern in a source code produces the error `"Use @spawn instead of @async."` accompanied by the exact location in the source code. ReLint can be run on a file or a folder using `ReLint.run_lint("path/to/folder_or_julia_file/")`. A Julia code containing the instruction `@async foo() + bar()` will be reported by ReLint. Such a report can be automatically posted as a comment in a Pull Request or used to prevent the code from being committed. **Example 2**: A less trivial rule is forbidding the use of `Threads.nthreads()` in a const variable. This is important if an application is built on a particular machine but runs on a different machine with a different spec. ```Julia function check(::InitializingWithFunctionRule, x::EXPR, markers::Dict{Symbol,Symbol}) # Threads.nthreads() must not be used in a const field, but it is allowed elsewhere haskey(markers, :const) || return generic_check(x, "Threads.nthreads()", "`Threads.nthreads()` should not be used in a constant variable.") end ``` A line of code such as `const MAX_QUEUE = max(2*Threads.nthreads(), 16)` will be reported by RAILint. **Example 3**: As a last example, consider the case of branches that cannot be reached: ```Julia if foo() bar() elseif foo() zork() end ``` Obviously, the `zork()` function will never be executed because the two sequential `if` have the same condition. This error may not be obvious in the presence of dozens of lines of code in each branch. An instance of this pattern can be easily caught with: ```Julia function check(t::UnreachableBranchRule, x::EXPR) generic_check( t, x, "if hole_variableA \ hole_variable \ elseif hole_variableA \ hole_variable \ end", "Unreachable branch.") end ``` Multiple uses of the pseudo-variable `hole_variableA` impose the matched code to be identical, AST-wise. **This presentation**: The main features of ReLint, accompanied by several scenarios, will be demonstrated. We will also cover extensibility, embedding ReLint in a GitHub action (useful to have a Lint report for every commit), and pre-commit (useful to gate a commit if it contains some rule violations). ReLint has been used in an industrial environment to enforce programming conventions and security rules for over 1 year in a large, critical application. false https://pretalx.com/juliacon-2025/talk/RCUTNF/ https://pretalx.com/juliacon-2025/talk/RCUTNF/feedback/ Lawrence Room 120 - REPL Main Stage Talk 2025-07-23T11:00:00-04:00 11:00 00:30 A deep dive into the history of the current Julia language server, the technology it is based on and the design decisions at its foundation. We will go over the pros and cons of the current design, its limitations, challenges we faced during development, and what plans there are for the future. juliacon-2025-64939-past-present-and-future-of-the-julia-language-server Developer tools Sebastian Pfitzner en A deep dive into the history of the current Julia language server, the technology it is based on and the design decisions at its foundation. We will go over the pros and cons of the current design, its limitations, challenges we faced during development, and what plans there are for the future. false https://pretalx.com/juliacon-2025/talk/FNHLJL/ https://pretalx.com/juliacon-2025/talk/FNHLJL/feedback/ Lawrence Room 120 - REPL Main Stage Lightning talk 2025-07-23T11:30:00-04:00 11:30 00:30 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. juliacon-2025-64937-a-new-language-server-for-julia Developer tools Shuhei KadowakiEm Chu en 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 will demonstrate how JETLS enhances coding efficiency for both novice and expert Julia developers, while also discussing the architecture of JETLS, including its use of the `AbstractInterpreter` framework and Revise-based incremental caching system, and exploring the challenges faced in creating a responsive and feature-rich language server. false https://pretalx.com/juliacon-2025/talk/M7SGLS/ https://pretalx.com/juliacon-2025/talk/M7SGLS/feedback/ Lawrence Room 120 - REPL Main Stage Talk 2025-07-23T13:30:00-04:00 13:30 00:30 This presentation discusses interpreting Julia code and particularly the strategy used by JuliaInterpreter.jl together with its benefits and drawbacks. juliacon-2025-65012-interpreting-julia-code Developer tools Kristoffer Carlsson en Julia currently features two distinct interpreters: the built-in interpreter (implemented in src/interpreter.c) and JuliaInterpreter.jl, a package that underpins important tooling in the ecosystem, including Debugger.jl, the VSCode debugger, JET.jl, and Revise.jl. This presentation focuses on the strategy used by JuliaInterpreter.jl to interpret code, the benefits and drawbacks of it, and how JuliaInterpreter enables different tools to work on top of it. Some other things that will be discussed are: - Why are the Julia debuggers quite slow? - What makes Julia code hard to interpret - What should the future of JuliaInterpreter be? false https://pretalx.com/juliacon-2025/talk/9ADY9F/ https://pretalx.com/juliacon-2025/talk/9ADY9F/feedback/ Lawrence Room 120 - REPL Main Stage Keynote 2025-07-23T14:05:00-04:00 14:05 00:45 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. juliacon-2025-66702-an-ai-agenda-to-modernize-healthcare-operations General Karandeep Singh en TBA - stay tuned for more details about this keynote, including speaker information, title, and abstract!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. The talk will lay out an agenda for computational scientists interested in improving healthcare and highlight areas where contributions are needed to modernize healthcare delivery and improve healthcare access and quality. Along the way, Dr. Singh will share some of the data science tools developed and spun out of his lab, including Tidier.jl for Julia, and clinspacy, gpmodels, and runway for R. false https://pretalx.com/juliacon-2025/talk/MQDLNU/ https://pretalx.com/juliacon-2025/talk/MQDLNU/feedback/ Lawrence Room 120 - REPL Main Stage Talk 2025-07-23T15:00:00-04:00 15:00 00:30 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. juliacon-2025-64960-julia-s-secret-superpower Developer tools Joshua Ballanco en So often the act of programming is one of writing something that *should* work, then holding your breath as you run code to find out if it actually did and, when it doesn't, shifting back into a mode of writing, re-writing, and debugging uninformed by the actual running code. While debuggers can help with understanding what code is doing while it is running, the inability to durably change code during debugging means that there is still a process of translating what you learn from a debugger back into the code you are writing. Similarly, while working in a notebook environment allows you to write and run smaller pieces of code at a time, shortening the feedback loop, the separation between writing and running code remains (and notebooks are not particularly amenable to writing large, deployable codebases). REPL-driven development, on the other hand, is more like working with clay: you can see the form of the program come into being as you are actively molding and working with it. In this talk, I will take what I've learned from working with languages like Clojure, that have a much more RELP-based culture, and how I've been able to apply that to working with Julia. I will discuss the aspects of Julia that make it, much more so than Python or Ruby, amenable to REPL-driven development. I will also introduce the combination of editor configuration (focused on Emacs, of course, but applicable to other editors as well), custom helper methods and macros, and tools from the community that I have personally employed to work in a fully REPL-centric way. Finally, I will discuss how Julia's already very capable REPL opens the door to Julia becoming the ultimate REPL language, more so even than Scheme, Lisp, or Clojure. false https://pretalx.com/juliacon-2025/talk/ZZ8GMC/ https://pretalx.com/juliacon-2025/talk/ZZ8GMC/feedback/ Lawrence Room 120 - REPL Main Stage Lightning talk 2025-07-23T15:30:00-04:00 15:30 00:10 In this presentation I will discuss the pros and cons of automatic code formatting. In particular I will present the new code formatter [Runic.jl](https://github.com/fredrikekre/Runic.jl) and discuss and motivate the various stylistic choices that Runic enforces. juliacon-2025-65060-code-formatting-with-runic-jl Developer tools Fredrik Ekre en Automatic code formatting come with many benefits: consistency across the code base, improved readability, easier code review and reduced cognitive overhead when programming. In this presentation I will present the code formatter [Runic.jl](https://github.com/fredrikekre/Runic.jl). The main feature of Runic is that it has no configuration. Instead of letting users customize the formatting Runic have a fixed formatting style. Most of the stylistic choices Runic makes are non-controversional, and most Julia programmers would agree with them. However, some choices are more opinionated but follows naturally from a common ruleset. In this presentation I will discuss and motivate Runic's style and discuss how Runic can be used effectively for Julia code repositories. false https://pretalx.com/juliacon-2025/talk/L9HTHF/ https://pretalx.com/juliacon-2025/talk/L9HTHF/feedback/ Lawrence Room 120 - REPL Main Stage Lightning talk 2025-07-23T15:40:00-04:00 15:40 00:10 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. juliacon-2025-63795-dockerfiles-for-julia-effective-caching-depot-management Developer tools Krystian Guliński en Containerization is considered a basic skill in a developer toolbox, so packaging up Julia code into images will definitely fall into a Julia developer's task list sooner than later. Writing a naive Dockerfile for Julia is simple, but writing a great one is not a trivial task. I've written several Dockerfiles for various Julia projects and I will try to share all the tricks on how to make your Dockerfile better for both development and production use cases. Please note this talk assumes at least a basic to intermediate understanding of Docker and building images. Introductory concepts will not be covered as part of the talk. Link to repository containing examples https://github.com/krynju/docker_julia_juliacon2025 false https://pretalx.com/juliacon-2025/talk/LBSE8T/ https://pretalx.com/juliacon-2025/talk/LBSE8T/feedback/ Lawrence Room 120 - REPL Main Stage Lightning talk 2025-07-23T15:50:00-04:00 15:50 00:10 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. juliacon-2025-64974-state-of-continuous-integration-in-the-sciml-ecosystem Developer tools Anant Thazhemadam en The SciML ecosystem is one of the largest and most prominent ecosystems in the Julia community, and continues to steadily grow, with a large userbase. This demands sufficiently well tested code with acceptable code quality, making CI processes absolutely essential, across the board. In this lightning talk, we'll discuss the historical reasons and provenance that necessitated a shift to a more centrally defined and efficient CI system, the decisions made and tradeoffs involved, and how well it has served us so far. We'll also go through what all this looks like in practice, how this migration was executed and propagated across all SciML repositories, and how new SciML repositories can adopt these workflows. This lightning talk aims to provide audience members with a better understanding on what goes on behind the scenes with CI processes in SciML (and how they can still apply it, even if their project isn't in SciML organization yet), what more is to come, and provide a platform for providing suggestions and feedback, surrounding CI processes in SciML. false https://pretalx.com/juliacon-2025/talk/SHCKEL/ https://pretalx.com/juliacon-2025/talk/SHCKEL/feedback/ Lawrence Room 120 - REPL Main Stage Talk 2025-07-23T16:00:00-04:00 16:00 00:30 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. juliacon-2025-65024-state-of-trim Developer tools Jeff BezansonGabriel BaraldiCody Tapscott en This talk will discuss the development of `--trim` support since last year's "New Ways to Compile Julia". We'll highlight the semantic challenges that make this problem difficult, and we'll show how this differs from a workflow like GPUCompiler / MCUCompiler. The tooling ecosystem for `--trim` is still in its infancy, so we'll also talk about what tools we think would help users write programs directly targeting statically-compiled executables. false https://pretalx.com/juliacon-2025/talk/YVU9E3/ https://pretalx.com/juliacon-2025/talk/YVU9E3/feedback/ Lawrence Room 120 - REPL Main Stage Lightning talk 2025-07-23T16:30:00-04:00 16:30 00:10 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 module or callable value. 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. juliacon-2025-64532-speculator-jl-reduce-latency-in-a-single-line-of-code Developer tools /media/juliacon-2025/submissions/WVUZPK/logo_sWz1yab.svg Jakob Krell (they/them) en A substantial amount of effort has been directed towards reducing compilation latency. This effort has been successful such that most commonly used packages have little latancy, or at least substantially reduced latency compared to earlier versions of Julia. Package precompilation is able to reduce latency by moving the compilation of a method from occurring during each session to occurring once during package installation. There are several tools to assist performing package precompilation, each with their own advantages and disadvantages. [Speculator.jl](https://github.com/jakobjpeters/Speculator.jl) is a new package to reduce latency, which may be used as a supplement or alternative to pre-existing tools. Given a callable value, `speculate` will use reflection to search its compilable method signatures. Given a module, `speculate` will recursively search each of the values contained within. These method signatures may be logged, compiled, and saved to a file as precompilation directives. Additional configuration enables skipping specified values, running in a background task, and handling abstractly typed method signatures. A substantial amount of time spent in an interactive session is "idle". This idle time may instead be put to use by the novel feature implemented in `install_speculator`, which installs a hook into the REPL. Then, each input automatically runs `speculate` in a background task. This is appropriate to be placed in a `startup.jl` file and may reduce latency in interactive sessions. This talk briefly describes some pre-existing tools to reduce latency. Then, it introduces Speculator.jl as a supplement or alternative to them, instructs upon its usage for package precompilation and interactive sessions, and explains notable implementation details. Finally, it discusses the advantages and disadvantages of Speculator.jl relative to other latency reduction tools. false https://pretalx.com/juliacon-2025/talk/WVUZPK/ https://pretalx.com/juliacon-2025/talk/WVUZPK/feedback/ Lawrence Room 120 - REPL Main Stage Lightning talk 2025-07-23T16:40:00-04:00 16:40 00:10 The Julia Programming Language solves the so-called "two-language problem." 2 - 1 = 1, which is fantastic. Here `DocstringTranslation.jl` 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. juliacon-2025-64861-let-s-read-the-julia-documentation-in-your-preferred-language Developer tools /media/juliacon-2025/submissions/CMUACM/demo_nzMN4WI.jpeg terasakisatoshi en The Julia Programming Language solves the so-called "two-language problem." 2 - 1 = 1, which is fantastic news for scientific researchers. It allows us to write code with high-level operations without losing execution performance. In reality, to understand how to use Julia, we also need to install another language, so-called `English` in our brain to read documentation, write docstrings, listen to talks on YouTube, and ask something in Slack, Discord, or Discourse. If you're a native English speaker, it's okay. However, this will not happen to those in non-English-speaking countries, such as Japan. This is yet another two-language problem. By the way, AI (Artificial Intelligence) and LLM (Large Language Model) have made it possible to translate texts easily. Could this be applied to the Julia ecosystem? One of these ideas is `DocstringTranslation.jl`. This tool translates Julia's docstrings into other natural languages to help users understand the manual. It hacks the existing method `Docs.parsedoc(d::DocStr)` to insert a translation engine. As an application, we can translate `Documenter.jl`-based documentation such as the official Julia documentation. false https://pretalx.com/juliacon-2025/talk/CMUACM/ https://pretalx.com/juliacon-2025/talk/CMUACM/feedback/ Lawrence Room 120 - REPL Main Stage Lightning talk 2025-07-23T16:50:00-04:00 16:50 00:10 What's the cost of invalidation freedom? This talk will dive into the invalidation problem from its fundamentals, viewing these as a failed speculative optimization in the compiler. Why do we perform this speculation, despite its costs? What can be done to make it succeed? juliacon-2025-78083-can-we-achieve-invalidation-freedom-for-julia General Cody Tapscott en A foreign concept in most other languages, the word "invalidation" is enough to make many Julia veterans shudder. Despite complex tooling like SnoopCompile.jl and hundreds of latency-oriented PR's, this perennial bugbear continues to show up and make fast code mysteriously slow, waste processor cycles on repeated JIT, and demand extensive developer time to investigate. This talk will dive into the invalidation problem from its fundamentals: What is the language / compiler doing to create them in the first place? What kind of code creates them? What does the compiler need to know to avoid them? Along the way, we'll see how invalidations are really a speculative optimization "gone wrong" and challenge the common wisdom that invalidation issues are due to type-piracy and poorly-inferred code. Finally with that perspective in hand, we'll discuss what can be done to make this speculation succeed. What would it cost to solve the invalidation issue once and for all? false slides pdf https://pretalx.com/juliacon-2025/talk/DCDEQV/ https://pretalx.com/juliacon-2025/talk/DCDEQV/feedback/ Lawrence Room 121 - Struct Room Talk 2025-07-23T10:30:00-04:00 10:30 00:30 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. juliacon-2025-62689-cliffordnumbers-jl-implementing-numeric-primitives-for-geometry General Brandon Flores en Historically, linear algebra has served as one of the mathematical foundations of computational geometry. The straightforward mapping of points to vectors and linear transformations to matrices can be extended to model a wide variety of geometric objects in arbitrary numbers of dimensions. However, an alternative approach, geometric algebra, has gained traction in the past decade. Geometric algebras can model objects in 3D space, such as points, lines, planes, circles, and spheres, but can also model more complex settings, such as the Minkowski space of special relativity. Geometric algebra associates geometric objects and transformations with elements of a Clifford algebra. The elements of Clifford algebras, multivectors, can be added and scaled like vectors, but the algebra also admits new products: the *wedge product*, which generalizes the cross product to produce higher-dimensional geometric objects, and the *geometric product* or *Clifford product*, that composes isometries or applies them to geometric objects. While geometric algebra cannot completely replace linear algebra - geometric algebras bake in assumptions about metrics and orthogonality - it provides a more concise language for the expression of a wide variety of concepts and provides guarantees relevant to geometric operations that are not always available in approaches based on linear algebra. In essence, geometric algebra serves as a mathematical expression of the rule of least power for computational geometry. CliffordNumbers.jl provides dense and sparse representations of the elements of Clifford algebras, as well as high-performance implementations of all key operations used in geometric algebra. This is facilitated by leveraging a significant fraction of the tools Julia provides: multiple dispatch, promotion, parametric types, generated functions, and type domain computation. Most commonly, matrix representations of Clifford algebras are used when working with their elements: for instance, the Pauli sigma matrices and Dirac gamma matrices. By contrast, CliffordNumbers.jl uses a matrix-free additive representation and encodes the algebra structure in the provided operations, allowing for more compact storage of algebra elements, and making the construction of algebra elements more transparent to the user. Much of Julia's geometry ecosystem leverages the LinearAlgebra standard library, `AbstractVector` and `AbstractMatrix`, particularly their static implementations `SVector` and `SMatrix` in StaticArrays.jl for performance reasons. CliffordNumbers.jl makes the radical design decision to subtype `Number`, as Clifford algebras are hypercomplex number systems, foregoing a hard dependency on the LinearAlgebra standard library. This is not without precedent: the complex numbers and quaternions are Clifford algebras used to represent rotations in 2D and 3D, and these are also `Number` subtypes in the Julia ecosystem! The existence of a package like CliffordNumbers.jl highlights the importance of providing generic implementations of geometric objects and constructs that don't require an `AbstractArray` representation. Developing CliffordNumbers.jl has been facilitated by the design and documentation of Julia, but it has also highlighted gaps worthy of the attention of all developers working on Julia. These gaps do not prevent the implementation of CliffordNumbers.jl, but improvements to the areas highlighted will simplify some of the most complex code in the package. Some of these problems are actively being worked on, such as improved constant propagation, which will reduce the need for generated functions that are used to maximize the performance of operations such as geometric products. Others may not be implemented due to complexity issues, such as allowing some types of computations in type parameters, but this package provides a case for allowing a limited subset of arithmetic in the type domain. However, the most notable omission is an interface for `Number` subtypes. `AbstractCliffordNumber` diverges from the behavior of other `Number` subtypes, and it is unclear whether this breaks the assumptions made by Julia or its widely used packages. Two key behaviors that need to be clarified are the construction and conversion of `Number` types should necessarily be identical, and the expected behavior when indexing a `Number`. A thorough specification of the `Number` interface benefits both developers working on numerical packages and anyone who works with numbers in programming - in other words, everyone! CliffordNumbers.jl provides a fresh, alternative perspective to implementing geometry in Julia, akin to the fresh perspective to computing Julia itself has produced. Besides its direct utility for solving geometric problems, it also presents a point of reference for the technical future of Julia itself. false https://pretalx.com/juliacon-2025/talk/8K7QQJ/ https://pretalx.com/juliacon-2025/talk/8K7QQJ/feedback/ Lawrence Room 121 - Struct Room Talk 2025-07-23T11:00:00-04:00 11:00 00:30 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. juliacon-2025-64895-julia-in-academia-textbooks-stanford-courses-and-the-future General /media/juliacon-2025/submissions/YT7AVS/algforval-juliacon_vdYCMhK.png Robert Moss en Julia is no stranger to academia—seeing as it grew out of MIT and was initially adopted by the scientific community. In this talk, we discuss how we have been using Julia for both writing textbooks and for teaching graduate-level courses in computer science and aeronautics/astronautics engineering at Stanford University. Based on our experience as educators, we will discuss the good and not-so-good cases for Julia, and the potential future roles for Julia in academia. In the first part of the talk, we will discuss why we chose Julia as the algorithm description language in three MIT Press textbooks: [_Algorithms for Optimization_](https://algorithmsbook.com/optimization/) (2019), [_Algorithms for Decision Making_](https://algorithmsbook.com/decisionmaking/) (2022), and [_Algorithms for Validation_](https://algorithmsbook.com/validation/) (2025). Not only do we present the algorithms in Julia, but we generate the figures and examples using Julia's `pythontex` integration. This allows us to present concise algorithms to the reader and display figures and examples _using the exact algorithms within the text_. The textbooks use a custom Tufte-style LaTeX template that we've open sourced ([sisl/tufte_algorithms_book](https://github.com/sisl/tufte_algorithms_book)). We will also highlight the features of Julia that enable concise algorithms in print, including multiple dispatch, auto-differentiation, and full Unicode support. Along with Julia-specific features, we will showcase packages in the ecosystem that seamlessly integrate into the algorithms, including `LazySets`, `IntervalArithmetic`, `JuMP`, and `Distributions`. The second part of the talk will focus on how we use Julia in both our lectures and assignments at Stanford. A new course we are teaching at Stanford titled [_Validation of Safety-Critical Systems_](https://aa228v.stanford.edu) follows our validation textbook and heavily uses Julia and `Pluto.jl` in lecture materials and course assignments. Through light-weight interactive Pluto notebooks, we demonstrate complicated topics to students during lecture which also allows them to explore the topics on their own time after class. Notably, we also use Pluto for four programming assignments. We will discuss why we ultimately chose to require Julia and use Pluto, and the framework we implemented to obfuscate hidden code from the students, to test their work locally, and integrate into Gradescope for auto-grading and friendly leaderboard competitions. Finally, we will talk about the future of Julia in academia—from teaching, to assignments, to textbooks, and research papers. We will showcase recent development of a prototype package we use for lecture material, `PlutoPapers.jl`, and the potential for interactive research papers written entirely in Julia, Markdown, and LaTeX ([mossr/PlutoPapers.jl](https://github.com/mossr/PlutoPapers.jl)). false https://pretalx.com/juliacon-2025/talk/YT7AVS/ https://pretalx.com/juliacon-2025/talk/YT7AVS/feedback/ Lawrence Room 121 - Struct Room Lightning talk 2025-07-23T11:30:00-04:00 11:30 00:10 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. juliacon-2025-63999-what-s-new-with-jetreconstruction-jl General Graeme A Stewart en Jet physics is one of the key areas where we can advance our knowledge of the interactions of fundamental particles. In collider physics, e.g., at CERN's Large Hadron Collider, two beams of counter-rotating energetic particles strike head on. This results in the production of new, highly energetic, heavy particles, which are unstable. These decay rapidly into other particles, forming a cascade of many final state stable particles. These particles are detected in high energy physics experiments, particularly in calorimeters, designed to stop and measure the energy of incident particles. The task of grouping these energy deposits is one of the key tasks in high-energy physics event reconstruction. Jets are formed from clustering energy deposits, based on different momentum and geometric criteria. JetReconstruction.jl is a native Julia package that was released in 2024 that implements many established sequential jet reconstruction algorithms. It already outperforms the "standard" C++ package, FastJet, which is widely used. In the last year JetReconstruction.jl has been enhanced with a number of important features. Integration with other Julia packages has been improved (e.g., EDM4hep.jl). Jet grooming can be performed and substructure, as well as the original jet constituents, can be retrieved, which allows many important physics studies to be performed. Algorithms optimised for events at electron-positron colliders (such as CERN's Future Circular Collider proposal, FCC) have been implemented, unlocking the possibility of full FCC analysis support in Julia. Additionally, to support the most time-critical scenarios of jet reconstruction while taking data (in so-called trigger farms), static compilation and C bindings have been added for the package. false JetReconstruction.jl Package Repository slides https://pretalx.com/juliacon-2025/talk/CU8E8K/ https://pretalx.com/juliacon-2025/talk/CU8E8K/feedback/ Lawrence Room 121 - Struct Room Lightning talk 2025-07-23T11:40:00-04:00 11:40 00:10 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. juliacon-2025-63083-getting-started-with-supercomputing General Jillian LehoskyT.J. Olesky en Pittsburgh Supercomputing Center staff will discuss how to get started with using the ACCESS Allocations program for high-performance computing access and discuss Bridges-2’s use with Julia. false https://pretalx.com/juliacon-2025/talk/E83EJZ/ https://pretalx.com/juliacon-2025/talk/E83EJZ/feedback/ Lawrence Room 121 - Struct Room Lightning talk 2025-07-23T11:50:00-04:00 11:50 00:10 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. juliacon-2025-65035-enhancing-spectral-dynamic-causal-modeling-with-julia Julia for Neuroscience Helmut Strey en Dynamic Causal Modeling (DCM) is a framework for inferring neural connectivity from neuroimaging data based on variational Bayes estimation techniques. Among the most widely used techniques is spectral DCM, which provides a fast parameter estimation technique in the spectral domain, allowing to fit biophysically detailed models.Here we present a novel implementation in the Julia programming language of spectral DCM, leveraging its high-performance computational capabilities. We validate and benchmark our implementation using simulated and empirical fMRI data and compare our implementation against the DCM implementation of Statistical Parametric Mapping (SPM), which is MATLAB based and the most commonly used DCM software. In particular we employed automatic differentiation to gain up to tenfold speed enhancements over the SPM implementation while maintaining parameter estimation accuracy. Since computational cost is considered a practical limitation of the application of DCM, this improvement makes the application of this method amenable to the inference of connectivities among more measured brain regions. We further employ Julia's ModelingToolkit for modular model assembly which allows a much more flexible modeling environment as the one provided by SPM whose extension to non pre-implemented models is laborious and error prone. By enabling flexible model specification and extending spectral DCM's applicability through substantial speed improvements, this work provides an open-source platform for advancing neural connectivity research and parameter fitting in neuroscience. Paper: David Hofmann, Anthony G. Chesebro, Chris Rackauckas, Lilianne R. Mujica-Parodi, Karl J. Friston, Alan Edelman, and Helmut H. Strey. “Leveraging Julia’s Automated Differentiation and Symbolic Computation to Increase Spectral DCM Flexibility and Speed.” bioRxiv: The Preprint Server for Biology, 2023. https://doi.org/10.1101/2023.10.27.564407. false https://pretalx.com/juliacon-2025/talk/DJX9LT/ https://pretalx.com/juliacon-2025/talk/DJX9LT/feedback/ Lawrence Room 121 - Struct Room Talk 2025-07-23T13:30:00-04:00 13:30 00:30 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. juliacon-2025-64983-neuroblox-jl Julia for Neuroscience /media/juliacon-2025/submissions/BC7V3E/NB_Logo_Full_Transpare_0Hrx2sd.png Lilianne R. Mujica-Parodi en Neuroblox.jl is based on a library of modular computational building blocks (“blox”) in the form of systems of symbolic dynamic differential equations that can be combined to describe large-scale brain dynamics. Once a model is built, it can be simulated efficiently and fit electrophysiological and neuroimaging data. Moreover, the circuit behavior of multiple model variants can be investigated to aid in distinguishing between competing hypotheses. We employ ModelingToolkit.jl to describe the dynamical behavior of blox as symbolic (stochastic/delay) differential equations. Our libraries of modular blox consist of individual neurons (Hodgkin-Huxley, IF, QIF, LIF, etc.), neural mass models (Jansen-Rit, Wilson-Cowan, Lauter-Breakspear, Next Generation, microcanonical circuits etc.) and biomimetically-constrained control circuit elements. A GUI designed to be intuitive to neuroscientists allows researchers to build models that automatically generate high-performance systems of numerical ordinary/stochastic differential equations from which one can run simulations with parameters fit to experimental data. Our benchmarks show that the increase in speed for simulation often exceeds a factor of 100 as compared to neural mass model implementation by the Virtual Brain (python and similar packages in MATLAB. For parameter fitting of brain circuit dynamical models, we use Optimization.jl for least-square fitting, andTuring.jl to perform probabilistic modeling, including Hamilton-Monte-Carlo sampling and Automated Differentiation Variational Inference. New features of Neuroblox.jl include 1) deep-brain stimulation, 2) implementation of various neurotransmitter receptor dynamics to model brain-drug interactions, and a new GUI with a flatbrain interface. false https://pretalx.com/juliacon-2025/talk/BC7V3E/ https://pretalx.com/juliacon-2025/talk/BC7V3E/feedback/ Lawrence Room 121 - Struct Room Talk 2025-07-23T15:00:00-04:00 15:00 00:30 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. juliacon-2025-64993-pem-ude-for-neural-mass-models Julia for Neuroscience Helmut Strey en Scientific machine learning (SciML) approaches are useful in learning physical equations for dynamical systems, particularly when the derivation of such equations manually would be difficult or impossible using traditional techniques [1, 2]. Chaotic systems, however, are difficult to fit with universal differential equations (UDEs) in many scenarios, both due to numerical issues (e.g., simulating chaotic trajectories with sufficient accuracy) and experimental issues (e.g., collecting high SNR data to allow for accurate modeling of the systems) [1, 3]. Biological systems, in particular, suffer from both of these issues: incomplete theory and very noisy observations lead to intractable problems in fitting UDEs to real data [3]. To overcome these issues, we propose an extension of UDE fitting using the prediction-error method (PEM) technique [4] from classical optimization to assist in training UDEs, and demonstrate its utility in classical chaotic systems and applications to electrical circuits and spiking neural networks. As an initial validation, we explore this combined PEM-UDE approach in the context of classical chaotic systems. We demonstrate that for the Rössler system [5] the PEM approach smooths the harsh landscape of learnable parameters that makes fitting a UDE in the standard way impossible, while also providing a means of tuning the degree to which the landscape is smoothed. We show that the approach makes the system learnable by a UDE and does not overly rely on the exact knowledge of the unobserved parameters (i.e., the approach is robust to noisy estimates of parameters in the simulated states as well). We also demonstrate that the learned system is an accurate simulation of the actual dynamics and can be generalized by using symbolic regression to learn the missing state directly from the fit UDE. We then extend this analysis to the system that describes Chua’s circuit [6], showing that even when a state (one node of the circuit) is entirely unobserved and cannot be used in training the system the PEM-UDE approach can still learn an appropriately close form of the dynamics. Having validated the approach in these well-described chaotic systems, we use it in spiking neural networks where the analytical forms are less defined. Next-generation neural mass models (NGNMMs) provide an analytical approach built on the Ott-Antonsen (OA) ansatz [7] to derive mean-field representations of neuron populations that preserve the microscale parameters of individual neurons [8, 9]. This derivation, however, relies on the assumption that neurons are a fully connected network, which is not the case in many areas of the brain (especially cortex). We show that we can train a UDE to learn the terms of a mean-field representation that violates the original OA ansatz assumptions to simulate a wider range of spiking neuron population activities. Together, these approaches validate the use of PEM in training UDEs for chaotic systems that they could not initially learn and illustrate their utility in computational and experimental neuroscience applications, setting it up for future applications in other dynamical systems. References [1] M. Raissi, P. Perdikaris, and G. E. Karniadakis, “Physics-informed neural networks: A deep learning framework for solving forward and inverse problems involving nonlinear partial differential equations,” Journal of Computational Physics, vol. 378, pp. 686–707, Feb. 2019. [2] C. Rackauckas et al., “Universal Differential Equations for Scientific Machine Learning,” Nov. 02, 2021, arXiv: arXiv:2001.04385. [3] W. Ji, W. Qiu, Z. Shi, S. Pan, and S. Deng, “Stiff-PINN: Physics-Informed Neural Network for Stiff Chemical Kinetics,” The Journal of Physical Chemistry A, vol. 125, no. 36, pp. 8098–8106, Sep. 2021. [4] R. Larsson, Z. Sjanic, M. Enqvist, and L. Ljung, “Direct prediction-error identification of unstable nonlinear systems applied to flight test data,” IFAC Proceedings Volumes, vol. 42, no. 10, pp. 144–149, Jan. 2009. [5] O. E. Rössler, “An equation for continuous chaos,” Physics Letters A, vol. 57, no. 5, pp. 397–398, Jul. 1976. [6] I. Gomes, W. Korneta, S. G. Stavrinides, R. Picos, and L. O. Chua, “Experimental observation of chaotic hysteresis in Chua’s circuit driven by slow voltage forcing,” Chaos, Solitons & Fractals, vol. 166, p. 112927, Jan. 2023.. [7] E. Ott and T. M. Antonsen, “Low dimensional behavior of large systems of globally coupled oscillators,” Chaos, vol. 18, no. 3, p. 037113, Sep. 2008.. [8] E. Montbrio, D. Pazo, and A. Roxin, “Macroscopic Description for Networks of Spiking Neurons,” Phys. Rev. X, vol. 5, no. 2, p. 021028, Jun. 2015. [9] L. Chen and S. A. Campbell, “Exact mean-field models for spiking neural networks with adaptation,” Mar. 15, 2022, arXiv: arXiv:2203.08341. false https://pretalx.com/juliacon-2025/talk/CRDFSR/ https://pretalx.com/juliacon-2025/talk/CRDFSR/feedback/ Lawrence Room 121 - Struct Room Talk 2025-07-23T15:30:00-04:00 15:30 00:30 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 juliacon-2025-64368-graphdynamics-jl-efficient-scalable-neuronal-dynamics Julia for Neuroscience Mason Protter en 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 false https://pretalx.com/juliacon-2025/talk/3KNGDU/ https://pretalx.com/juliacon-2025/talk/3KNGDU/feedback/ Lawrence Room 121 - Struct Room Talk 2025-07-23T16:00:00-04:00 16:00 00:30 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. juliacon-2025-65023-a-large-scale-quantitative-eeg-analysis-of-chronic-insomnia Julia for Neuroscience David Little en Chronic insomnia is a common disorder (affecting ~10% of the population) which is diagnosed based on self-reported symptoms, but is often difficult to objectively characterize (with a high mismatch between objective measurements and symptom burden). When examined across a massive scale (thousands of individuals), quantitative EEG features can provide deep insight into insomnia severity and diagnosis. Our post-hoc analysis across three EEG dataset found that individuals with insomnia had: 1.) a higher likelihood of waking from all sleep stages, 2.) increased wake-like brain activity according to both WESI—an aggregate data-driven measure of arousal—as well as elevated alpha and theta power during periods of wake and 3.) altered sleep spindle characteristics. We then examined one of these datasets—originating from a phase III clinical trial—to see if these same features were reversed following treatment with a dual orexin receptor antagonist (DORA). This class of drugs aims to target the orexin/hypocretin system, thought to play a key role in maintaining wakefulness and promoting arousal. We found that treatment with the DORA partially reversed insomnia-linked differences in EEG by: reducing wake-to-wake transitions and increasing transitions into sleep stages (N1, N2, and REM), reducing measures of wake-like brain activity according to both WESI during wake, reduced beta and alpha power during wake and N1, and increased delta power during wake. Therefore 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. In this talk I’ll describe these findings, the technical successes and technical challenges of performing the analyses as well as some of the strategies we have adopted at Beacon to manage massive heterogeneous datasets. Julia has proven itself to be a robust platform for managing data ingest, feature extraction and model fitting at scale. Sources of success include Julia’s ergonomics, the robust open source libraries available and the ease of integrating with existing tooling built in other languages. Sources of challenge with Julia largely stem from the immaturity of some corners of the ecosystem. Overall Julia has demonstrated its ability to perform scalable analytics to improve neurophysiological data processing. false https://pretalx.com/juliacon-2025/talk/KMBUGE/ https://pretalx.com/juliacon-2025/talk/KMBUGE/feedback/ Lawrence Room 121 - Struct Room Lightning talk 2025-07-23T16:30:00-04:00 16:30 00:10 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. juliacon-2025-64137-neuralodes-modeling-synaptic-tagging-capture-dynamics Julia for Neuroscience Shiv Davay en This work uses a novel computational approach, Neural Ordinary Differential Equations (NeuralODEs) with prospective configuration, to investigate the molecular mechanisms behind memory formation. For this purpose, this work concentrates on the modeling of the Synaptic Tagging and Capture hypothesis, one of the keystones that helps to understand how synaptic consolidation occurs during memory formation. The STC hypothesis represents a fundamental mechanism in synaptic plasticity whereby synapses tag themselves by means of molecular tags, enabling LTP and subsequent memory consolidation. Indeed, traditional computational models of such biological processes have relied on backpropagation-based optimization algorithms. However, backpropagation's bidirectional gradient access methodology is in conflict with the known unidirectional nature of biological neural processes, which raises questions regarding its biological plausibility. To overcome this limitation, prospective configuration utilizes a unidirectional optimization algorithm that more closely resembles biological neural processes. The combination of prospective configuration with NeuralODEs represents a new approach in computational neuroscience, as few studies have applied either technique to biological processes, particularly within the neuroscience domain. The experimental framework is implemented in Julia because of its great scientific computing features and its efficiency in solving differential equations. NeuralODEs' implementation in the simulation of the STC hypothesis was particularly effective, resulting in a very low loss value of 0.005. A small loss would indicate that both temporal dynamics and molecular interactions could be well reflected by the model. Systematic hyperparameter optimization identified a number of critical factors strongly influencing model performance. Network architecture was one of the crucial components, where certain configurations showed better performance in modeling the complex interactions involved in synaptic tagging. The selection of activation functions also turned out to be instrumental in improving the accuracy of the model with reduced loss values. These optimizations were necessary to arrive at a model that effectively captured the nuanced dynamics of synaptic plasticity and memory formation. The findings contribute to a major breakthrough in both computational neuroscience and molecular biology. This research develops insights into the ways synaptic plasticity contributes to memory formation and strengthening of neural pathways by being able to successfully model the STC hypothesis through biologically plausible computational methods. The accuracy in the modeling of molecular interactions using this model makes it a good candidate for research in neurodegenerative conditions and memory-related disorders. Success in this area will make NeuralODEs a very powerful tool for modeling such multifaceted biological processes. Their strength in representing continuous-time dynamics and molecular interaction with high precision will open up new avenues for research both in computational biology and in neuroscience. This approach bridges the gap between computational models and biological reality, allowing for a more faithful representation of neural processes than traditional artificial neural networks. Besides, the methodology followed in the study provides a way in which future research into computational neuroscience could be conducted, especially in devising more biologically accurate models of neural processes. This is a promising direction for constructing computational models that reflect the underlying biology more closely, while keeping the computational efficiency: prospective configuration combined with NeuralODEs. These studies have implications beyond the realm of theoretical understanding, pointing toward a possible development of therapeutic strategies in neurodegenerative diseases and disorders of memory. This work contributes to a more accurate computational model of synaptic plasticity and memory formation necessary for the foundation toward developing targeted interventions in conditions affecting memory and neural function. false https://pretalx.com/juliacon-2025/talk/NUV9GK/ https://pretalx.com/juliacon-2025/talk/NUV9GK/feedback/ Lawrence Room 121 - Struct Room Lightning talk 2025-07-23T16:40:00-04:00 16:40 00:10 We showcase [Neuroblox.jl](https://github.com/Neuroblox/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). juliacon-2025-65016-dbs-modeling-with-neuroblox-jl Julia for Neuroscience Germán Abrevaya en Deep Brain Stimulation (DBS) is a neurosurgical procedure involving the implantation of a "brain pacemaker" that delivers electrical impulses to specific brain regions. This therapeutic approach has become particularly important in treating Parkinson's disease (PD), which affects around 1% of people over 60. In PD patients, DBS electrodes target key structures within the basal ganglia - primarily the subthalamic nucleus (STN) or Globus pallidus internus (GPi) - to help restore normal motor function[1,2]. Despite its clinical success, DBS therapy faces several challenges. The stimulation protocols used are largely _ad hoc_, developed decades ago to accommodate hardware limitations rather than being based on underlying neurobiological mechanisms. While effective at treating motor symptoms, patients can experience adverse effects due to factors like electrode placement and suboptimal programming parameters[3,4]. Computational modeling offers a powerful approach to better understand these challenges and optimize treatment parameters. We explore [Neuroblox.jl](https://github.com/Neuroblox/Neuroblox.jl)'s capabilities as a computational platform for DBS modeling. Our implementation incorporates detailed biophysical models of the basal ganglia circuit, with particular focus on STN-GPe network dynamics based on recently proposed models[4]. Additionally, we have developed a flexible DBS stimulation module that allows testing various stimulation protocols, enabling investigation of phenomena like Evoked Resonant Neural Activity (ERNA)[5,6]. This lightning talk will showcase how [Neuroblox.jl](https://github.com/Neuroblox/Neuroblox.jl), leveraging both its computational efficiency and intuitive approach to complex model construction, can serve as a valuable tool for investigating neural stimulation mechanisms and advancing our understanding of neuromodulation therapies. ----- ##### References: [1] McGregor MM, Nelson AB. Circuit Mechanisms of Parkinson's Disease. Neuron. 2019;101(6):1042-56. [2] Herrington TM, Cheng JJ, Eskandar EN. Mechanisms of deep brain stimulation. J. Neurophysiol. 2016;115(1):19-38. [3] Buhmann C, et al. Adverse events in deep brain stimulation: A retrospective long-term analysis of neurological, psychiatric and other occurrences. PLoS One. 2017;12(7):e0178984. [4] Adam EM, et al. Deep brain stimulation in the subthalamic nucleus for Parkinson's disease can restore dynamics of striatal networks. Proc Natl Acad Sci U S A. 2022;119(19):e2120808119. [5] Sinclair NC, et al. Deep brain stimulation for Parkinson's disease modulates high-frequency evoked and spontaneous neural activity. Neurobiol Dis. 2019;130:104522. [6] Thevathasan W, et al. Tailoring Subthalamic Nucleus Deep Brain Stimulation for Parkinson's Disease Using Evoked Resonant Neural Activity. Front Hum Neurosci. 2020;14:71. false https://pretalx.com/juliacon-2025/talk/S3ET3L/ https://pretalx.com/juliacon-2025/talk/S3ET3L/feedback/ Lawrence Room 121 - Struct Room Lightning talk 2025-07-23T16:50:00-04:00 16:50 00:10 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. juliacon-2025-69407-statespacedynamics-jl-probabilistic-state-space-modeling Julia for Neuroscience Ryan SenneZachary Loschinskey en Advancements in systems neuroscience have enabled the collection of massive, multivariate time series datasets, where simultaneous recordings from hundreds to thousands of neurons are increasingly common. Interpreting these high-dimensional recordings presents a significant challenge. Recent modeling approaches suggest that neural activity can be effectively characterized by sets of low dimensional latent variables. Accordingly, there is a growing need for models that combine dimensionality reduction with temporal dynamics, for which state-space models (SSMs) provide a natural framework. While advanced SSM implementations exist in Python, such as the SSM package from the Linderman lab, the Julia programming language lacks an equivalent library that meets the needs of modern neuroscientists. Existing Julia offerings, such as StateSpaceModels.jl, are limited to Gaussian observation models. This fundamental limitation precludes the analysis of the non-Gaussian observations that are so common in neuroscience, where spike counts often follow Poisson or other discrete distributions. To address these limitations, we have developed StateSpaceDynamics.jl, which employs a direct maximization of the complete-data log-likelihood for LDS models (Paninski et al., 2010). By leveraging the block-tridiagonal structure of the Hessian matrix, this method allows for the exact computation of the Kalman smoother in O(T) time. Furthermore, this method facilitates the generalization of the smoother to accommodate other observation noise models, such as Poisson and Bernoulli. Additionally, StateSpaceDynamics.jl implements a variational expectation maximization method (Ghahramani and Hinton, 2000) that enables the learning of hierarchical SSMs, such as switching linear dynamical systems (sLDS). These models gained traction in the study of neural dynamics, especially as they relate to movement preparation and execution. Lastly, StateSpaceDynamics.jl provides implementations of discrete state space models, such as Hidden Markov Models (HMMs), and the ability to fit these models using the expectation maximization algorithm. While these are not the primary development target of the package and are implemented in HiddenMarkovModels.jl (Dalle, 2024), they are necessary for the development of hierarchical models. By providing these features, StateSpaceDynamics.jl fills a critical gap in the Julia ecosystem, offering modern computational neuroscientists the tools necessary to model complex neural data with state-space models that incorporate both dimensionality reduction and temporal dynamics. false https://pretalx.com/juliacon-2025/talk/DJTA7U/ https://pretalx.com/juliacon-2025/talk/DJTA7U/feedback/ Lawrence Room 104 - Function Room Lightning talk 2025-07-23T10:30:00-04:00 10:30 00:10 Dyad 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 Dyad. 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. juliacon-2025-63786-building-modeling-libraries-with-dyad General Venkatesh Prasad en Using Dyad, declarative descriptions of the guiding mathematical behavior and graphical appearance can be specified for models. Using Dyad Studio (a VSCode extension) or CLI tooling, this description is compiled to ModelingToolkit models to leverage the rich SciML ecosystem for building, solving, and analyzing the ODESystem. With this acausal framework, we have built standard libraries in Electrical, Translational, Rotational, Hydraulic, and Thermal domains. And we expect to include even more domains. We follow industry standards to remain consistent with other modeling applications. These libraries come with a suite of unit tests, examples and documentation (which is partly auto-generated). To keep it lightweight, these libraries are packaged as separate Julia packages; using the package manager and some of its latest features, we maintain compatibility with these libraries. Custom libraries can be created with Dyad Studio's streamlined process. One can import the appropriate domains and build composite models with standard components as building blocks. false https://pretalx.com/juliacon-2025/talk/LWUJPV/ https://pretalx.com/juliacon-2025/talk/LWUJPV/feedback/ Lawrence Room 104 - Function Room Lightning talk 2025-07-23T10:40:00-04:00 10:40 00:10 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. juliacon-2025-64599-geometry-on-the-sphere-with-geometryops-jl Climate science & solutions: Collaboration & coupling in Julia Anshul Singhvi en The Earth is approximately ellipsoidal, but we can approximate it as a perfect sphere with only ~0.5% maximum error - making it suitable for most uses. Geometric operations on the sphere (like polygon intersection, area, or arclength) have an inherent accuracy that cannot be matched by projecting to any planar space. This is because spherical calculations are globally accurate. Google's s2 library and Charles Karney's GeographicLib (now part of the Proj library) were pioneers in this space. We take inspiration from these libraries, while continuing to optimize further. This work was inspired and required by three main use cases: 1. Planar representations struggle with geometry that encircles the poles or crosses the antimeridian (-180 degree line). Systems of geometry that span the globe, like global grid systems, or geometries that encircle the poles, as may happen in ocean simulations, are difficult to represent on a plane. Spherical geometry processing is then a natural fit. 2. Naive calculations of geometric properties in latitude-longitude space, like area or arclength, are inherently inaccurate. Only spherical or geodesic computations provide correct results. While R's `sf` ecosystem solves this by wrapping Google's s2 library, and calling out to that whenever a longitude-latitude geometry is seen, implementing that approach in Julia is very challenging. Spherical computations address these problems effectively. 3. Climate models and parametrizations often use different grid representations. Accurate mapping between these grids is virtually impossible in planar space due to the distortions created when projecting a plane onto a sphere. Working directly on the sphere makes it much easier to compute intersection areas between grid polygons, especially since they are simple polygons with 10 or fewer vertices. This capability will enable coupling between Oceananigans.jl and SpeedyWeather.jl for complete climate simulation! false https://pretalx.com/juliacon-2025/talk/PUL7JN/ https://pretalx.com/juliacon-2025/talk/PUL7JN/feedback/ Lawrence Room 104 - Function Room Lightning talk 2025-07-23T10:50:00-04:00 10:50 00:10 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 juliacon-2025-65041-answering-local-questions-on-big-datasets-with-rangeextractor-jl Climate science & solutions: Collaboration & coupling in Julia Anshul Singhvi en 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? RangeExtractor.jl is a Julia package that is meant to accelerate localized computations over global, large (~1TB to ~1PB), chunked datasets. It does this through multithreading, asynchronous data downloads, and intelligent query-splitting over chunk boundaries. In this talk, I'll touch over the case for RangeExtractor, how it's designed, and what performance bottlenecks remain to be improved upon. I'll also talk about the two principal usecases that motivated RangeExtractor: (a) extracting the lowest elevation of each glacier for all ~200,000 glaciers in the world, over a 30-meter resolution elevation grid, and (b) computing elevation statistics over the whole of Greenland. Both of these questions will be answered on my 14-inch Macbook, without pre-downloading any big data. false https://pretalx.com/juliacon-2025/talk/87W8CN/ https://pretalx.com/juliacon-2025/talk/87W8CN/feedback/ Lawrence Room 104 - Function Room Talk 2025-07-23T11:00:00-04:00 11:00 00:30 We present a Physics-Informed Neural Network (PINN) to model pollutant dispersion via the 2D advection-diffusion equation. Our approach focuses on a systematic hyperparameter and architecture investigation, training the network on noisy, synthetic FDM data. The resulting optimal model achieves high accuracy and serves as an efficient surrogate for near-instantaneous forecasting, providing a robust baseline for more complex environmental models. juliacon-2025-63823-physics-informed-neural-network-for-ocean-pollutant-dispersal Climate science & solutions: Collaboration & coupling in Julia Karishma Battina en Ocean pollutant transport is a critical issue affecting marine ecosystems worldwide. While traditional numerical solvers for the advection-diffusion equation face computational limits, Physics-Informed Neural Networks (PINNs) offer a powerful alternative. This talk presents a PINN-based framework developed entirely in Julia to model oceanic pollutant transport, with a specific focus on the methodology behind building and optimizing these complex models. Our approach leverages Julia’s SciML ecosystem to create a robust and physically consistent model. The core of the framework is a fully connected neural network, built using `Lux.jl`, that approximates the solution to the 2D advection-diffusion equation. A key contribution of our work is the development of a hybrid, weighted loss function to enforce physical constraints and accurately fit the data. This loss function, constructed with `NeuralPDE.jl`, explicitly adds a heavily-weighted term to ensure the model precisely learns sharp initial conditions, a common challenge for PINNs. The network is trained on synthetic data generated from a Finite Difference Method (FDM) solver, with Gaussian noise added to simulate real-world measurement uncertainty. The main focus of this talk is a systematic investigation into the role of neural network architecture and hyperparameters on solution accuracy and computational cost. We will detail our extensive experiments, which varied: **Network Architecture:** Comparing networks with 9 hidden layers and 64, 128, or 256 neurons per layer. **Optimizers:** Evaluating the performance of ADAM, ADAMW, and the quasi-Newton method L-BFGS. **Learning Rates:** Testing a range of rates to find the optimal value for convergence. We will present a comprehensive performance benchmark that identifies an optimal configuration—a 9-layer, 128-neuron network trained with the ADAM optimizer—capable of achieving a relative error of approximately 8.25% against the high-resolution FDM solution. This highlights a "sweet spot" for model capacity, as a larger 256-neuron network yielded worse accuracy and was far more expensive to train. Finally, we will discuss the computational trade-offs, using benchmarks from `BenchmarkTools.jl`. While training our optimal PINN takes significant time, the resulting surrogate model is highly efficient, capable of a full-field inference in just ~0.024 seconds. This work establishes a robust methodology for tuning PINNs and provides a clear blueprint for future extensions that will incorporate real-world, non-constant oceanographic data to tackle practical environmental challenges. arXiv paper: https://arxiv.org/abs/2507.08834 false https://pretalx.com/juliacon-2025/talk/VXDAVF/ https://pretalx.com/juliacon-2025/talk/VXDAVF/feedback/ Lawrence Room 104 - Function Room Talk 2025-07-23T11:30:00-04:00 11:30 00:30 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. juliacon-2025-64007-adaptive-tumor-growth-forecasting-via-neural-universal-odes The JuliaHealth Mini-Symposium Kavya Subramanain en Accurately predicting tumor growth is crucial for understanding cancer development and creating effective treatment strategies. Traditional mathematical models that are based on Ordinary Differential Equations (ODEs), such as the Gompertz and Bertalanffy equations, have been widely used to describe tumor growth. While they provide a theoretical foundation, they often fail to account for variations in real-world data. In experimental settings, tumor growth is influenced by a range of factors, including its microenvironment, the presence/ absence of chemotherapy, genetics, immune system response, etc. As a result, ODE models struggle to capture the full complexity of tumor progression. In order to overcome these limitations, we are using a Scientific Machine Learning (SciML) approach. We leverage Neural Ordinary Differential Equations (Neural ODEs) and Universal Differential Equations (UDEs) to improve traditional models by learning directly from experimental tumor volume data. Our implementation uses several Julia packages built for SciML applications, such as DifferentialEquations.jl for numerically solving ODEs, DiffEqFlux.jl to integrate neural networks into these models, and Lux.jl to construct neural network architectures. Additionally, we use Optimization.jl and OptimizationOptimisers.jl to fine-tune parameters using gradient-based methods like Adam and BFGS. Unlike traditional ODE models that rely on fixed parameters, our UDE model replaces the key growth parameters in the equations with neural networks. This enables our UDE model to adapt better to the experimental data compared to the traditional models. This not only improves the accuracy of our predictions, but we can also effectively forecast future tumor growth with greater precision. Moreover, our approach allows for better personalization of medical treatment, as tumor growth predictions can be tailored to an individual’s clinical history. By combining SciML techniques with traditional tumor modeling equations, our research provides a data-driven approach for optimizing treatment planning and improving clinical decision-making in oncology. This could also pave the way for more advancements in precision medicine, particularly in oncology. false https://pretalx.com/juliacon-2025/talk/WNGHYS/ https://pretalx.com/juliacon-2025/talk/WNGHYS/feedback/ Lawrence Room 104 - Function Room Lunch Break 2025-07-23T12:00:00-04:00 12:00 01:30 Join us for a hands-on workshop with Dyad Studio. Dyad is a fundamentally new modeling paradigm that brings together the declarative modeling world and imperative Julia world. You'll learn how to assemble models declaratively using the Dyad syntax, how to analyze the model through Dyad Analysis and integrate any Julia package with Dyad through DyadInterface.jl. Lunch will be provided. Capacity is limited, so please [RSVP in advance]( https://share.hsforms.com/1VsptHAHTQkGv5A8X9Pae9gcwyu9) juliacon-2025-75857-hands-on-with-dyad-studio-rsvp-required General Chris RackauckasMichael Tiller en Join Dr. Michael Tiller and Dr. Chris Rackauckas for a hands-on workshop with Dyad Studio. Dyad is a fundamentally new modeling paradigm that brings together the declarative modeling world and imperative Julia world. After setting up a Dyad project, attendees will be shown how to assemble models declaratively using the Dyad syntax, and how to analyze the model through the Dyad Analysis. Finally, the workshop will show how to integrate any Julia package with Dyad through DyadInterface.jl. There will be time for a Q&A, and we will end with a brief demo of Dyad Builder GUI interface. Due to limited capacity, please [register your interest in attending in advance]( https://share.hsforms.com/1VsptHAHTQkGv5A8X9Pae9gcwyu9) Lunch will be provided for registered attendees. false https://pretalx.com/juliacon-2025/talk/TBYEKY/ https://pretalx.com/juliacon-2025/talk/TBYEKY/feedback/ Lawrence Room 104 - Function Room Talk 2025-07-23T13:30:00-04:00 13:30 00:30 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. juliacon-2025-63635-cox-model-go-brrr-a-journey-to-performance The JuliaHealth Mini-Symposium Oskar Laverny en **The Cox model** is a standard and 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 benefits from many very good implementations (in Fortran, C or C++) interfaced from almost every language (in particular R and Python). It requires a numerical estimation of its coefficients through gradient descent, but the solving routines are well established nowadays. We start by a very naive implementation using an **off-the-shelf** numerical solver, leveraging **automatic differentiation**. While very convenient, this solution was slow, and we decided to **implement by hand the derivatives and hessian** of the loss function to make it faster. Then, moving to **our own solving loop** instead of the off-the-shelf solver allowed us to reduce overhead. Finally, through **profiling and reducing allocations**, we were able to squeeze out the maximal performance without changing the algorithm itself. The final but crucial improvement comes from **mathematical analysis** of the loss function and led us to depart from standard Newton-Raphson minimization. We discuss how Julia's ecosystem tools helped us at each step, in particular for **type stability** and **allocations reductions**, but also to build fair comparison with the competition directly on GitHub actions. The result is an implementation of the Cox algorithm, a pillar of numerical survival analysis used in many other fields such as public health or medicine, that is **faster than the historical R/C equivalent** for large enough inputs. We hope this implementation will be released soon, with a correct and comprehensive API, in SurvivalModels.jl. false https://pretalx.com/juliacon-2025/talk/ENGU7U/ https://pretalx.com/juliacon-2025/talk/ENGU7U/feedback/ Lawrence Room 104 - Function Room Talk 2025-07-23T15:00:00-04:00 15:00 00:30 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. juliacon-2025-64989-what-s-new-with-komamri-jl The JuliaHealth Mini-Symposium Carlos Castillo Passi en 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. KomaMRI.jl is part of the JuliaHealth GitHub organization and is currently its most starred package, reflecting its strong reception within both the Julia and MRI communities. It was featured as a 30-minute oral presentation at JuliaCon 2023, and its associated paper was among the top 10 percent most viewed articles in Magnetic Resonance in Medicine. In this talk, I will present recent technical developments that make the tool more versatile and broadly applicable. These include optimized GPU kernels for faster simulations, vendor-agnostic GPU acceleration (now supporting Metal.jl, oneAPI.jl, and AMDGPU.jl), support for distributed computing, and the ability to model complex motion in the simulated object, which is particularly important for cardiac imaging. I will also share preliminary results on integrating KomaMRI.jl with AD frameworks to optimize pulse sequence design and tackle other inverse problems, such as image reconstruction. Repository: https://github.com/JuliaHealth/KomaMRI.jl Slides: https://github.com/cncastillo/KomaMRI_JuliaCon2025 false https://pretalx.com/juliacon-2025/talk/FMF3V9/ https://pretalx.com/juliacon-2025/talk/FMF3V9/feedback/ Lawrence Room 104 - Function Room Talk 2025-07-23T15:30:00-04:00 15:30 00:30 Since 2020, the JuliaHealth community has been growing. Now, we highlight the development of the JuliaHealth ecosystem with our first ever mini-symposium! This talk will cover community growth, sub-ecosystems, ongoing projects and collaborations, and future. juliacon-2025-64912-state-of-juliahealth The JuliaHealth Mini-Symposium /media/juliacon-2025/submissions/UADRZR/juliahealth_logo.png_wetoVja.png Jacob Zelko en Since 2020, the JuliaHealth community has been growing. Now, we highlight the development of the JuliaHealth ecosystem with our first ever mini-symposium! In particular, we will discuss the following: - General History - Ecosystem Overview - Community Goals - Leadership Structure - Ongoing Projects & Collaborations - Research Highlights - Future Goals - JuliaCon Activities Time will be reserved at the end of this talk for Q&A. false https://pretalx.com/juliacon-2025/talk/UADRZR/ https://pretalx.com/juliacon-2025/talk/UADRZR/feedback/ Lawrence Room 104 - Function Room Lightning talk 2025-07-23T16:00:00-04:00 16:00 00:10 We present a physics-informed neural ODE approach for modeling tumor-immune dynamics using Julia. Dual neural networks learn immune suppression and corrections within Gompertz growth framework. Model achieves R² > 0.95 (approx. 99.7%) accuracy and captures 30.25% volume reduction effects. Implementation uses DifferentialEquations.jl, Flux.jl, and SciMLSensitivity.jl, training in <1hr on Atsou tumor datasets. juliacon-2025-65004-physics-informed-neural-odes-for-tumor-immune-dynamics-modeling The JuliaHealth Mini-Symposium Anish SarkarAnindya Sarkar en Tumor-immune dynamics modeling requires integrating biological principles with data-driven learning. This work presents a physics-informed neural ordinary differential equation (PNODE) approach implemented in Julia for accurate tumor-immune interaction modeling. Methodology Our approach combines established Gompertz growth dynamics with neural-learned immune effects using Kevin Atsou's tumor growth datasets. The dual neural network architecture separates immune-mediated suppression from general model corrections. The immune response network processes normalized tumor volume and immune cell fractions to predict immune suppression effects, while the correction network uses volume and time inputs to capture unmodeled residuals. The physics-informed loss function incorporates five components: volume prediction accuracy, derivative matching for physics consistency, growth smoothness penalties, biological constraints ensuring volume positivity, and L2 regularization. This multi-objective approach ensures learned dynamics respect fundamental biological laws while maintaining predictive accuracy. Julia Implementation The implementation leverages six core Julia packages demonstrating the ecosystem's scientific computing capabilities: • DifferentialEquations.jl: Robust ODE solving with automatic differentiation support • Flux.jl: Flexible neural network framework with seamless ecosystem integration • SciMLSensitivity.jl: Efficient gradient computation through differential equation solutions • Optimization.jl: Unified optimization interface for training coordination • OptimizationOptimJL.jl: Advanced LBFGS optimization algorithms • Zygote.jl: Automatic differentiation enabling end-to-end gradient computation Training employs a two-phase strategy combining AdamW (1000 iterations) for global exploration and LBFGS (1000 iterations) for local refinement, achieving convergence in under one hour. Results The model demonstrates strong performance across multiple evaluation metrics: • Prediction accuracy exceeding R² = 0.95 across tumor scenarios C2-C4 and cases T1-T5 • Captured 30.25% tumor volume reduction through immune effect modeling • Strong negative correlation (r = -0.82, p < 0.001) between immune response strength and tumor growth rates • Real-time prediction capabilities suitable for interactive analysis The 3D immune response surface learned by the neural networks reveals complex non-linear relationships between tumor burden and immune activation, providing insights into tumor-immune interaction mechanisms. Technical Contributions The work demonstrates several technical innovations: • Integration of physics-informed constraints with neural ODE modeling • Dual network architecture separating biological mechanisms • Multi-objective loss function balancing accuracy and biological realism • Efficient Julia implementation showcasing ecosystem interoperability The approach successfully models tumor volume trajectories under varying immune conditions, capturing both the underlying Gompertz growth dynamics and immune-mediated modifications. The physics-informed framework ensures biological plausibility while the neural components provide flexibility to capture complex, non-linear relationships. Dataset and Validation Model training and validation used Kevin Atsou's comprehensive tumor-immune interaction datasets, including time-series tumor volume measurements, corresponding immune cell levels, and multiple immune parameter scenarios. The dataset encompasses tumor scenarios T1-T5 under immune conditions C2-C4, enabling robust evaluation across diverse biological conditions. Julia Ecosystem Impact This work contributes to the Julia scientific computing ecosystem by demonstrating effective integration of differential equations, neural networks, and optimization for biological modeling. The approach showcases Julia's unique advantages for scientific machine learning applications, achieving both high performance and code clarity essential for complex biological system modeling. The methodology provides a foundation for physics-informed modeling of other biological systems where mechanistic understanding must be combined with data-driven learning. The modular design enables adaptation to different biological processes and disease systems. false GIthub repository of the dataset. Source code (partial) Presentation ppt Presentation pdf https://pretalx.com/juliacon-2025/talk/LLNHUU/ https://pretalx.com/juliacon-2025/talk/LLNHUU/feedback/ Lawrence Room 104 - Function Room Lightning talk 2025-07-23T16:10:00-04:00 16:10 00:10 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. juliacon-2025-65058-mapping-patient-treatment-pathways-in-population-health The JuliaHealth Mini-Symposium Jacob ZelkoJay Landge en # Description ## Contributions to the community. OMOPCDMPathways.jl is a new package in the JuliaHealth ecosystem that standardizes the analysis of patient care progression using OMOP CDM–formatted data. The OMOP Common Data Model, established by OHDSI, enables consistent analysis of real-world health data (e.g., medical claims, electronic health records). OHDSI is a collaborative dedicated to observational health research. This package supports studies in health economics, pharmacovigilance, and patient monitoring by tracking treatment trajectories over time, thereby revealing gaps or abrupt changes in care plans that may signal emerging safety concerns. It is already utilized by researchers at institutions and health systems across the globe. ## Topic diversity. Patient pathways trace a patient's journey from initial contact through subsequent provider interactions. Our package builds on functionality from other JuliaHealth projects (e.g., OMOPCDMCohortCreator.jl) to construct detailed treatment histories that can be visualized via interactive sunburst plots. These visualizations can represent the hierarchical structure of patient treatment pathways, which is particularly useful in observational health research, where the sequence and timing of events—such as overlapping treatments—are key to understanding patient outcomes. ## Applicability to the Julia community This package is highly valuable for Julia users, particularly researchers in health informatics research. Using Julia's performance and the OMOP CDM standard, it uses Julia's performance to construct patient pathways. These pathways can then be used as rich feature sets for machine learning models to predict outcomes such as readmission, adherence to treatment, or adverse drug reactions, advancing personalized medicine. This integration is particularly powerful in personalised medicine, where understanding individual treatment trajectories is key to tailoring future care. ## Significance to the community This package is highly significant to the Julia community because it demonstrates how open source tools can be used to build and analyze patient treatment pathways from scratch. In our talk, we will walk through a hands-on example using synthetic patient data, showing attendees exactly how to transform raw clinical data (present in OMOPCDM format) into meaningful patient pathways. This will not only highlight the power of this software but also it's seamless integration using OMOPCDMCohortCreator.jl. ## Clarity Attendees will learn step by step how to select treatments of interest, filter and combine treatment eras, and build detailed patient treatment histories. They will also see how to visualize these pathways using sunburst plots and how to extract features for machine learning predictions, thereby gaining practical skills that can be directly applied to real-world clinical data analysis. false https://pretalx.com/juliacon-2025/talk/9D8AX3/ https://pretalx.com/juliacon-2025/talk/9D8AX3/feedback/ Lawrence Room 104 - Function Room Lightning talk 2025-07-23T16:20:00-04:00 16:20 00:10 In this talk, we present insights from an ongoing research collaboration exploring 35 million US patients diagnosed with various forms of cancer. We show how we have been using the JuliaHealth ecosystem in performing the research here. juliacon-2025-64911-heart-attack-prediction-in-cancer-patient-populations The JuliaHealth Mini-Symposium Jacob Zelko en In this talk, we present insights from an ongoing research collaboration exploring 35 million US patients diagnosed with various forms of cancer. In total, we have examined 43 different patient cohorts using tools such as OHDSICohortExpressions.jl, OMOPCDMCohortCreator.jl, HealthBase.jl, FunSQL.jl, and additional tools to explore the central question of, "If a patient has an initial heart attack and later develops cancer, can we predict how likely it is for this patient to have a second heart attack?" false https://pretalx.com/juliacon-2025/talk/QKK3XA/ https://pretalx.com/juliacon-2025/talk/QKK3XA/feedback/ Lawrence Room 104 - Function Room Lightning talk 2025-07-23T16:30:00-04:00 16:30 00:10 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. juliacon-2025-65051-a-rag-llm-workflow-for-observational-health-research The JuliaHealth Mini-Symposium Jacob ZelkoParam Thakkar en # Description This work presents an innovative approach to developing a Retrieval-Augmented Generation (RAG)-informed Large Language Model (LLM) tailored to a domain-specific query language within observational health settings. By leveraging the Julia ecosystem — particularly the growing JuliaHealth community and its specialized tools - this project aims to aid observational health researchers' investigation into complex patient datasets stored in the OMOP Common Data Model (OMOP CDM). ## Background and Context Observational health research relies on retrospective data, including patient medical records and claims, to inform studies in pharmacovigilance, public health surveillance, and health economics. The OMOP CDM standardizes these data, enabling scalable and reproducible research across diverse clinical datasets. Within this framework, the JuliaHealth community has been exploring tools that simplify complex data queries and analyses. Tools such as FunSQL.jl offer a domain-specific language (DSL) that abstracts SQL’s intricacies, translating high-level query expressions into executable SQL commands. This DSL not only facilitates query composition and reasoning but also promotes reuse and modularity across various observational health research applications. Additionally, it enables the development of queries that work across different SQL syntax versions, enhancing interoperability across database systems. \subsection{RAG-Informed LLM and Agentic Workflows} At the core of this project is the development of an RAG-informed LLM that integrates seamlessly with the FunSQL.jl DSL. The proposed system leverages a comprehensive knowledge corpus drawn from key resources — such as FunSQL.jl, OMOPCDMCohortCreator.jl, the OMOP CDM standard, and additional materials from the broader Julia and generative AI communities. This corpus serves as the backbone for the LLM’s contextual understanding, enabling it to generate, refine, and validate complex queries automatically. An agentic workflow is a dynamic, iterative process where an AI system actively engages with data, tools, and human feedback to refine its outputs over time. Instead of passively generating responses, the system continuously evaluates, modifies, and optimizes its results based on execution feedback, constraints, and expert input. This approach enhances adaptability, ensuring that AI-generated outputs are accurate and contextually relevant. Within our approach, we incorporate a number of tools from within the JuliaGenAI community. We use various agentic tools, such as PromptingTools.jl and RAGTools.jl, which facilitate dynamic and interactive workflows. These tools allow the LLM not only to generate queries but also to iteratively refine them based on feedback and real-world constraints encountered during execution and given researcher feedback. This **agentic workflow** ensures an adaptive query development process, where the LLM autonomously generates initial queries, evaluates their execution results, and integrates researcher feedback to enhance accuracy and relevance. By continuously iterating and refining queries, this approach bridges the gap between automated query generation and human expert validation, ensuring that the queries produced are both semantically correct and meaningful in a research context. ## Objectives and Methodology The primary goals of this project are multifaceted: ### Evaluation of State-of-the-Art LLMs This project assesses various local LLMs based on inference times, accuracy, and adherence to best practices within the Julia ecosystem. This evaluation is crucial to determine the most suitable models for integration into the RAG pipeline. ### Knowledge Corpus Development A robust corpus assembled using documentation and source code from FunSQL.jl, OMOPCDMCohortCreator.jl, and the OMOP CDM. This corpus can be augmented with insights from related packages and tools—such as EasyContext.jl for embedders and rerankers—ensuring a comprehensive knowledge base for the LLM. ### Designing a Hybrid RAG Architecture The LLM pipeline incorporates advanced embedding models with optimized dimensions (e.g., 256–1024) and, where applicable, binary embeddings. The integration of vector databases (or alternative optimizations like binary or Matrioska-based approaches) are carefully considered. In hybrid RAG setups, traditional techniques such as BM25 are also evaluated to compliment embedding-based methods. ### Agentic Workflow and Query Development The primary objective of this study is to evaluate the effectiveness of a RAG-informed LLM workflow in answering complex observational health research questions. By integrating FunSQL.jl, OMOP CDM, and JuliaGenAI tools, this workflow aims to automate, refine, and validate query generation for large-scale health data analysis. To assess its real-world applicability, we will apply this approach to a population characterization st false https://pretalx.com/juliacon-2025/talk/J9PJ9T/ https://pretalx.com/juliacon-2025/talk/J9PJ9T/feedback/ Cathedral Room G24 - If Room Talk 2025-07-23T10:30:00-04:00 10:30 00:30 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-2025-64711-julia-in-flight-real-time-control-of-a-quadcopter-with-julia General Benjamin Chung en Julia's performance lends itself well to hard-real-time control applications where good performance is critical to the vehicle's operation. There's only several problems: * Julia's compilation and model and runtime can induce pauses that break the real time guarantee, * Julia's runtime is too large for many embedded systems that implement said controllers, and * Julia needs to be able to integrate with an overarching system architecture or RTOS. We show that all three challenges can be met by using Julia to control a quadcopter in real time. The quadcopter, developed by the Autonomous Control Laboratory at the University of Washington, runs PX4 on a STM32H7 connected to a Raspberry Pi CM4. We control it with 1kHz translational and attitude control loops implemented using Julia on the CM4, connected to PX4 on the STM32 via ROS2 and the Micro-XRCE DDS bridge. We measured the latency and jitter of the Julia controller in flight on both platforms and demonstrate the physical performance of the flight controller in agile flight. false https://pretalx.com/juliacon-2025/talk/MTWLYD/ https://pretalx.com/juliacon-2025/talk/MTWLYD/feedback/ Cathedral Room G24 - If Room Talk 2025-07-23T11:00:00-04:00 11:00 00:30 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, Chairmarks achieves efficiencies 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). juliacon-2025-64953-chairmarks-jl-a-new-high-efficiency-benchmarking-package Julia for High-Performance Computing Lilith Hafner en Chairmarks.jl prioritizes the experience of users writing and running benchmarks interactively and also provides a highly extensible interface for working with CI and batch jobs. This talk will: - Explain and showcase Chairmarks' novel implicit pipeline syntax which allows interactive users to specify initialization, setup, primary function, and teardown or any subset of those without any boilerplate syntax; - Demonstrate the accuracy, scalability, and ease of use; - Delineate the execution model; - Describe the auto-tuning algorithm; and - Exhibit the use of Chairmarks.jl with AirspeedVelocity.jl to automatically report performance changes in CI. false https://pretalx.com/juliacon-2025/talk/XNURXX/ https://pretalx.com/juliacon-2025/talk/XNURXX/feedback/ Cathedral Room G24 - If Room Talk 2025-07-23T11:30:00-04:00 11:30 00:30 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. juliacon-2025-64785-cunumeric-jl-automating-distributed-numerical-computing Julia for High-Performance Computing Ethan MeitzDavid Krasowska en In high-performance computing, reducing complexity for domain scientists is crucial. Performance portability enables a code base to be executed on heterogeneous architectures with zero code changes. In addition, for many scientific applications the ability to scale from one to many processors is necessary. cuNumeric.jl tackles these challenges by exposing a high-level array interface which automatically maps code onto available hardware by leveraging distributed kernels implemented in prior work - cuPyNumeric. cuPyNumeric uses nv-legate and Legion which provide abstractions to represent coherence and program structure in order to build a dependency graph before mapping to underlying hardware resources. The centerpiece of cuNumeric.jl is the NDArray type. NDArrays are flexible, supporting arbitrary dimensions and integral data types while behaving like Julia Arrays. However, a key advantage is that data can be split across available hardware resources on a distributed system. High level operations acting on NDArrays are not executed immediately. Instead, cuNumeric.jl’s underlying C++ API translates these operations into asynchronous tasks, which are then scheduled and managed by the Legion programming system. This enables efficient load balancing across resources. The current cuNumeric.jl API implements common linear algebra operations like matrix multiplication and einsum and many unary and binary operations. Additionally it supports stencil based operations which are crucial for solving partial differential equations (PDEs) numerically. In this talk we will describe the core technologies which enable cuNumeric.jl, provide an overview of the API and demonstrate the scaling of a stencil based PDE solver, Monte Carlo integration and common kernels like SGEMM. false https://pretalx.com/juliacon-2025/talk/WHRPXZ/ https://pretalx.com/juliacon-2025/talk/WHRPXZ/feedback/ Cathedral Room G24 - If Room Talk 2025-07-23T13:30:00-04:00 13:30 00:30 [PerfTest.jl](https://github.com/JuliaPerf/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. juliacon-2025-64894-architecture-agnostic-performance-regression-unit-tests Julia for High-Performance Computing Samuel OmlinDaniel Sergio Vega Rodriguez en Unit testing is a fundamental practice in software development, ensuring the correctness of individual code components. While traditional unit tests primarily focus on functional correctness, performance testing is often deferred to higher levels of application testing, making the identification of performance regressions more challenging. Such regressions can significantly impact computational efficiency and are particularly difficult to diagnose due to variations in hardware performance and fluctuations even within the same machine over time. This highlights the need for performance testing at the unit level to enable early detection and precise isolation of performance degradation. To address this gap, this work proposes the design and implementation of an automated performance regression unit testing framework, with a proof-of-concept developed specifically for Julia—a language increasingly favored in high-performance computing for its balance of usability and computational power. Our framework prioritizes ease of adoption and flexibility, accommodating diverse use cases while bridging the divide between functional and performance testing. By integrating modern software development practices into performance regression testing, this research aims to enhance the robustness and efficiency of testing methodologies of high-performance computing applications. false https://pretalx.com/juliacon-2025/talk/7ZLC88/ https://pretalx.com/juliacon-2025/talk/7ZLC88/feedback/ Cathedral Room G24 - If Room Talk 2025-07-23T15:00:00-04:00 15:00 00:30 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! juliacon-2025-64791-dagger-2025-cool-new-things Julia for High-Performance Computing Julian P SamarooFelipe Tomé en Dagger.jl is a Julia-native task runtime, scheduler, and unified parallelism interface for all kinds of applications. Dagger boasts a wide range of interfaces tailored to parallelizing various kinds of problems, whether you're working with arrays, tables, graphs, or your own custom data structures. Dagger also provides a variety of ways to express operations, such as plain one-off tasks, streaming (continuous) tasks, tasks with implicit data dependencies, and much more. Finally, Dagger supports not just CPUs, but also automatically can utilize GPUs from all 4 major vendors (NVIDIA, AMD, Apple, and Intel) near seamlessly, whether on one node or one hundred nodes. The purpose of this talk is to let you know what's new, and what's to come. We'll cover everything that's changed or been added since JuliaCon 2024, and how that can be a big benefit to you and your use case. We'll also take a look at what kind of work is slated for the road to JuliaCon 2026, and what possibilities this improvements will unlock. Be sure to also attend the Dagger Birds of a Feather (BoF) to voice your interest and concerns, and speak directly with the Dagger maintainers and other Dagger users like yourself! false https://pretalx.com/juliacon-2025/talk/Z3Q8SP/ https://pretalx.com/juliacon-2025/talk/Z3Q8SP/feedback/ Cathedral Room G24 - If Room Lightning talk 2025-07-23T15:30:00-04:00 15:30 00:10 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. juliacon-2025-65068-automated-algorithm-selection-discovery-via-llms Julia for High-Performance Computing Emmanuel LujanRabab AlomairyRushil Shah en **Background**. Matrix factorizations are fundamental in mathematics and computer science, enabling efficient solutions to various computational problems. In particular, LU decomposition—essentially the matrix form of Gaussian elimination—enables the efficient solution of linear systems and the computation of determinants (via forward/backward substitution and diagonal products). Moreover, specialized LU algorithms—such as banded LU and KLU—exploit the matrix pattern to reduce both computational and memory costs compared to general‐purpose methods. Popular linear algebra libraries in Julia, Python, and MATLAB incorporate heuristics to automatically select optimal algorithms based on matrix characteristics, particularly for solving linear systems. Despite their success, the continuous development of new algorithms tailored to specific matrix patterns [1] requires improved selection strategies. Given the cost and impracticality of manual criteria determination, automated heuristic generation is crucial. To address these needs, the SmartSolve project, funded by DARPA-DIAL [2], is developing a toolbox that utilizes existing matrix pattern databases [3] to systematically benchmark the performance and accuracy of diverse algorithms across various computational architectures. This approach leverages aforementioned benchmark data and automated classification techniques to generate heuristics that adaptively select optimal solutions for diverse inputs. Large language models (LLMs), with their extensive trainable parameters, offer a powerful approach for identifying trends and patterns in data. Initiatives such as ChatHPC have demonstrated their potential by generating optimized code, leading to substantial computational speedups [4, 5]. As these models continue to advance at an exponential rate, they hold significant promise for the SmartSolve project for automatic heuristics generation. **Contribution**. We present our work on a key component of SmartSolve.jl—the automated discovery of optimal algorithms and data structures. Furthermore, we analyze opportunities and limitations of LLMs in algorithmic selection and in heuristic generation. The discovery process follows a structured approach. First, a diverse set of matrix patterns and data structures—such as dense, sparse, and banded—is provided as input. For each pattern and data type, performance metrics, including casting time, computation time, and accuracy, are systematically measured to construct a comprehensive database. Algorithms are selected based on timing and accuracy, resulting in an optimized smart database. To achieve this, an automated Pareto analysis is performed to identify the most efficient and accurate algorithms while illustrating performance variations across different patterns [6]. For certain matrix patterns, selecting the optimal combination of algorithms and data structures can achieve over a 50X speedup, surpassing the default selections in major linear algebra libraries. To further enhance algorithm selection, we explore the integration of LLMs within SmartSolve.jl. Preliminary experiments with Llama 3 demonstrate its ability to classify and recommend optimal algorithms and data structures. In the course of the present investigation we will scale these experiments to large matrices and benchmark Llama 3 against the package’s existing tree-based machine learning models. Our evaluation will determine whether LLM-driven classification can deliver greater speedups and accelerate heuristic generation for dynamic algorithm selection. **Research Impact**. This project could mark an important step forward in integrating artificial intelligence models with heuristic-driven strategies to optimize computational linear algebra performance. It is among the first to leverage LLM technology for intelligent algorithm selection in LU and QR decompositions, moving beyond traditional static approaches. SmartSolve.jl aims to deliver automated heuristics that can be seamlessly integrated into widely used computational libraries. Furthermore, if the LLM-based approach proves effective, it could substantially accelerate heuristic generation, facilitating the rapid adoption of cutting-edge algorithms in scientific software. **Relevance to the Julia Community**. The Julia linear‐algebra ecosystem—anchored by widely adopted packages like LinearSolve.jl and the standard LinearAlgebra.jl—offers a rich suite of factorization methods to a broad community of users. Enhancements in SmartSolve.jl could further optimize these packages, delivering significant performance benefits to thousands of users. **References**. [1] Li (2005). DOI: 10.1145/1089014.1089017. [2] MIT's SmartSolve, DARPA-DIAL. https://github.com/JuliaLabs/SmartSolve. [3] Zhang and Higham (2016). DOI: 10.7717/peerj-cs.58. [4] Latif and Zhai (2024). DOI: 10.1016/j.caeai.2024.100210. [5] Yin et al. (2024). DOI: 10.1007/s11. [6] Hoefler and Belli (2015). DOI: 10.1145/2807591.2807644. false https://pretalx.com/juliacon-2025/talk/DH7MKC/ https://pretalx.com/juliacon-2025/talk/DH7MKC/feedback/ Cathedral Room G24 - If Room Lightning talk 2025-07-23T15:40:00-04:00 15:40 00:10 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. juliacon-2025-62829-gpu-accelerated-simulations-on-manifolds-for-physics Julia for High-Performance Computing Eduardo Franco Ortega en As a research group interested in performing physics simulations, we encountered two major challenges: understanding the complexity of the physical systems involved and dealing with the limitations of computational resources. Simulating intricate systems often required significant time and effort to grasp the underlying physics, while the simulations themselves were slow and computationally demanding. This led us to explore GPU acceleration as a solution. However, diving into GPU computing revealed the additional complexity of managing parallelism and optimizing performance for what we were trying to achieve. From this point, the research began—focusing on improving simulation performance, expanding the range of physical systems modeled, and enabling more efficient and accessible tools. Our aim is to develop a comprehensive framework for physics simulations, but currently, we have only achieved generalizations for certain systems, with the goal of advancing further in the future. The framework is designed to model complex physical phenomena on manifolds with a focus on precision, scalability, and usability. Examples of simulations developed include fluid dynamics on manifolds, such as spheres and tori, to explore the behavior of flows influenced by geometry. Transport phenomena in manifold geometries, including diffusion and flow processes, highlight the framework's ability to handle intricate physical systems. Particle interactions in granular systems are modeled to study collisions, clustering, and emergent behaviors under varying forces like gravity and friction. Geodesic motion simulations analyze particle dynamics on non-Euclidean spaces, offering insights into trajectories on curved geometries. Coupled processes in multiphysics environments, such as active matter systems where particles exhibit collective dynamics, and electromagnetic simulations for field interactions, highlight the framework’s ability to address diverse and complex problems. These examples underscore the framework's versatility in handling both theoretical and applied physics challenges. In addition to enhancing computational performance, this project contributes to the growth of the Julia community in GPU computing. By providing accessible tools and showcasing the capabilities of Julia in high-performance parallel computing, it encourages new users to engage with both GPU programming and the Julia ecosystem. The engine lowers technical barriers, fostering the adoption of GPUs while supporting Julia's expansion into diverse areas of computational physics. false https://pretalx.com/juliacon-2025/talk/CPFXED/ https://pretalx.com/juliacon-2025/talk/CPFXED/feedback/ Cathedral Room G24 - If Room Lightning talk 2025-07-23T15:50:00-04:00 15:50 00:10 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. juliacon-2025-64501-distributednext-such-distributed-much-wow Julia for High-Performance Computing James Wrigley en 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 on new features being somewhat slow. In addition there are relatively few people with write access to Distributed who have the time and expertise to review PRs for it. For these reasons we decided to make a soft fork named DistributedNext 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. In this talk we will discuss what we have already changed in DistributedNext, how it has benefited Distributed, and the future plans for DistributedNext. false https://pretalx.com/juliacon-2025/talk/ZYESJ3/ https://pretalx.com/juliacon-2025/talk/ZYESJ3/feedback/ Cathedral Room G24 - If Room Talk 2025-07-23T16:00:00-04:00 16:00 01:00 A panel discussion with several members of the JuliaHPC community about various new projects, community efforts, and packages in the community. juliacon-2025-78133-juliahpc-panel-discussion Julia for High-Performance Computing Mosè GiordanoJohannes BlaschkeRaye Kimmerer en A panel discussion with several members of the JuliaHPC community about various new projects, community efforts, and packages in the community. false https://pretalx.com/juliacon-2025/talk/GVLQSP/ https://pretalx.com/juliacon-2025/talk/GVLQSP/feedback/ Cathedral Room 324 - Else Room Talk 2025-07-23T10:30:00-04:00 10:30 00:30 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. juliacon-2025-63891-efficient-symbolic-computation-via-hash-consing Symbolic-Numeric Computing and Compiler-Enhanced Algorithms Bowen Zhu en Symbolic computation is a cornerstone of tasks like model analysis, transformation, and code generation, which are critical in scientific computing and modeling. However, symbolic manipulation systems often suffer from redundancy, where structurally equivalent expressions are represented as distinct objects in memory. This redundancy leads to increased memory consumption and computational overhead, particularly in large-scale models. In this talk, we present the implementation of hash consing in SymbolicUtils.jl, a core symbolic computation library in Julia. Hash consing ensures that only one unique instance of a structurally equivalent expression exists in memory. This optimization not only reduces memory usage but also improves performance by minimizing redundant computations. Additionally, hash consing provides built-in common subexpression elimination (CSE), simplifying the codebase and further enhancing efficiency. We will discuss the design and implementation of hash consing, focusing on its integration into SymbolicUtils.jl. The use of weak references, implemented via Julia's WeakValueDict, ensures that the hash table does not prevent garbage collection, maintaining efficient memory management. We will also present experimental results demonstrating significant reductions in memory usage and improvements in compile and simulation times. Key topics include: - The motivation for hash consing in symbolic computation and its benefits for memory and performance. - The integration of weak references and WeakValueDict for memory management. - Performance benchmarks comparing memory usage and computational speed with and without hash consing. - The implicit benefits of hash consing, such as built-in CSE and its impact on code generation. This work significantly improves the efficiency of SymbolicUtils.jl and its downstream applications, making it more suitable for complex symbolic manipulations in modeling and simulation. We will also discuss limitations, trade-offs, and future directions, including potential optimizations for specific types of symbolic expressions and parallel symbolic computation. Join us to learn how hash consing can enhance the performance of symbolic computation in Julia and contribute to more efficient modeling and simulation workflows. false https://pretalx.com/juliacon-2025/talk/ZW8Y7E/ https://pretalx.com/juliacon-2025/talk/ZW8Y7E/feedback/ Cathedral Room 324 - Else Room Talk 2025-07-23T11:00:00-04:00 11:00 00:30 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. juliacon-2025-62866-what-s-new-with-modelingtoolkit-jl Symbolic-Numeric Computing and Compiler-Enhanced Algorithms Aayush Sabharwal en ModelingToolkit.jl is a library for symbolic-numeric computation. It allows specifying Optimization problems, ODE/DAE problems, Nonlinear problems, Jump problems and more as symbolic systems. This symbolic specification offers a more accessible user experience and enables ModelingToolkit to transform the system in a way that improves performance, robustness and scalability. Over the past year there have been several developments in the library. New features have been added, such as - More robust initialization of all problem types - Callable parameters - Some new `structural_simplify` passes - Code generation for automatically targeting the new `SCCNonlinearProblem` infrastructure from `NonlinearSystem`s - Code generation targeting HomotopyContinuation.jl - And much more Parts of the codebase have been refactored to improve maintainability and accessibility to new contributors, including more comprehensive internal documentation. There have also been several discussions about user experience, the semantic guarantees provided by public API functions and the future direction of the library and ecosystem at large. This talk aims to highlight these key developments in ModelingToolkit.jl, discuss what we have learnt while building out new features, and provide a plan going forward both for new features and addressing existing issues. false https://pretalx.com/juliacon-2025/talk/UDQVDY/ https://pretalx.com/juliacon-2025/talk/UDQVDY/feedback/ Cathedral Room 324 - Else Room Talk 2025-07-23T11:30:00-04:00 11:30 00:30 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. juliacon-2025-61404-fast-stiff-ode-dae-solvers-via-symbolic-numeric-compiler-tricks Symbolic-Numeric Computing and Compiler-Enhanced Algorithms Chris Rackauckas en A lot of ODE solver systems, from Python's scipy to MATLAB ode15s, are purely numerical algorithms. They run under the assumption that you give the solver an ODE model description in the form of `f` and it calls `f` in special ways to build a numerical approximation to the solution. The assumption for almost all researchers for the last half century of having computers has been that the numerical approximation to ODEs uses a numerical solver. But with Julia, we don't like conventions? In this talk we will discuss what happens when we break that convention and integrate specialized computation and symbolic-numeric techniques into the ODE solver. Specifically, we will showcase how specializations on the implicit handling of stiff ODE/DAE solvers, such as BDF methods and SDIRK methods, can greatly change the robustness and performance of the solvers. We will showcase how splitting the nonlinear system into strongly connected components, using specialized tearing passes, integrating symbolic nonlinear solvers, and utilizing homotopy routines can all be done automatically via the codegen of ModelingToolkit in order to enhance the performance of the numerical solver. The results are good enough that it's almost cheating: orders of magnitude faster than other open source solvers because we're not even playing the same game anymore. The hope is that the audience walks away from this talk with a new understanding of what kinds of algorithms are possible when symbolic techniques are integrated into numerics. false https://pretalx.com/juliacon-2025/talk/PJR3XQ/ https://pretalx.com/juliacon-2025/talk/PJR3XQ/feedback/ Cathedral Room 324 - Else Room Talk 2025-07-23T13:30:00-04:00 13:30 00:30 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. juliacon-2025-63680-applying-taylor-mode-ad-in-nonlinear-equations-odes-and-more Symbolic-Numeric Computing and Compiler-Enhanced Algorithms Songchen Tan en Taylor mode automatic differentiation (AD) presents a powerful tool for advancing numerical methods in scientific computation. This talk introduces novel applications of TaylorDiff.jl, a Julia package for Taylor-mode AD, in solving nonlinear equations and ordinary differential equations (ODEs) with higher efficiency, stability and scalability. TaylorDiff.jl is developed with symbolic-numeric techniques to automatically transform first-order AD rules to higher-order AD rules, which makes higher-order AD efficient and easy to maintain. Nonlinear Solvers Using TaylorDiff.jl, we developed implementations of Householder’s method and, specifically, its cubic-convergence variant, Halley’s method, for solving large-scale nonlinear equations. Traditional solvers like Newton’s method rely solely on first-order derivatives to achieve quadratic convergence, while Halley's method uses second-order directional derivatives to achieve cubic convergence, thereby reduces number of iterations to convergence. By leveraging Taylor-mode AD, we efficiently compute these derivatives, avoiding the computational bottleneck of full Hessian evaluations. These solvers are evaluated on problems ranging from simple univariate functions to complex, large-scale nonlinear systems. Notably, Halley’s method demonstrates performance improvements over Newton’s method in both dense and sparse Jacobian settings. For instance, solving large ill-conditioned systems nonlinear systems arising from PDE discretizations shows that the higher convergence order reduces overall computational time while maintaining accuracy. In addition, we also see a performance improvement in using Halley's method to nonlinear equation solving steps within implicit ODE solvers. Differential Equations Since local solutions of ODEs can be obtained by expanding the equation as Taylor series of time, TaylorDiff.jl could also be applied in developing efficient solvers for ODEs, particularly stiff systems where implicit solvers are needed. We are currently extending the use of TaylorDiff.jl to develop efficient and stable implicit ODE solvers with advanced features like adaptive order, adaptive step and solution extrapolation. false https://pretalx.com/juliacon-2025/talk/EXCPRP/ https://pretalx.com/juliacon-2025/talk/EXCPRP/feedback/ Cathedral Room 324 - Else Room Lightning talk 2025-07-23T15:00:00-04:00 15:00 00:10 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. juliacon-2025-64870-optimal-uncertainty-quantification-of-sciml-models Symbolic-Numeric Computing and Compiler-Enhanced Algorithms Chris RackauckasAdam R. GerlachAvinash SubramanianBenjamin ChungAlexander Von Moll en Uncertainty Quantification (UQ) methods explicitly account for the influence of various sources of uncertainty (e.g., input parameters, model structure, numerical simulation errors) on the predictions made by a model. Traditional techniques, such as Monte Carlo simulation, often rely on a priori assumptions regarding the probability distributions of uncertain parameters. These methods involve drawing a large number of samples from these assumed distributions and propagating them through the model. However, such distributional assumptions can be brittle and unsuitable especially for safety-critical applications for instance in aerospace [1]. The Optimal Uncertainty Quantification (OUQ) framework, pioneered by Owhadi et al. [2] avoids making these unwarranted assumptions but instead introduces partial information about the model in a systematic way. OUQ casts the problem into an optimization problem searching over the space of probability distributions with constraints encoding the known information (such as moments or bounds of the random variables). Furthermore, it leverages certain reduction theorems and transformations to generate a computationally tractable finite optimization problem. Since a primary application of OUQ is to provide worst-case certificates for safety-critical systems, the use of rigorous global optimization algorithms is essential to guarantee provable and tight bounds. This work presents OptimalUncertaintyQuantification.jl: An end-to-end framework for OUQ integrated with Julia’s SciML ecosystem. We demonstrate the following workflow for practically relevant engineering applications: 1. Developing a system model using the ModelingToolkit.jl package. 2. Bounding this system model leveraging tools from reachability analysis such as TaylorModels.jl 3. Construction of the OUQ problem and transformation to a tractable finite dimensional optimization problem 4. Global optimization using both custom and external solvers as appropriate. 5. Certification/Decertification of the model based on optimization results [1]: Stark, P. "Your prior can bite you on the posterior: contrasting Bayesian and frequentist measures of uncertainty." In JPL Science Visitor and Colloquium Program-Earth Science Seminar, Sept. 1, 2020. 2020. [2]: Owhadi, H., Scovel, C., Sullivan, T.J., McKerns, M. and Ortiz, M., 2013. Optimal uncertainty quantification. Siam Review, 55(2), pp.271-345. Distribution Statement A: Approved for Public Release; Distribution is Unlimited. PA# AFRL-2025-0776, 11 Feb 2025 false https://pretalx.com/juliacon-2025/talk/EJSMQD/ https://pretalx.com/juliacon-2025/talk/EJSMQD/feedback/ Cathedral Room 324 - Else Room Lightning talk 2025-07-23T15:20:00-04:00 15:20 00:10 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. juliacon-2025-72633-leveraging-julia-ecosystem-to-solve-a-path-planning-problem Clément Coïc en 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. false https://pretalx.com/juliacon-2025/talk/GSL7D8/ https://pretalx.com/juliacon-2025/talk/GSL7D8/feedback/ Cathedral Room 324 - Else Room Talk 2025-07-23T15:30:00-04:00 15:30 00:30 At JuliaCon 2019, Tucker McClure gave a talk "A New Breed of Vehicle Simulation" to show how Julia-based simulation was being used at Zipline to develop autonomous aircraft that deliver life-saving medical supplies to remote areas. After 1.5 million deliveries and 100 million miles flown across seven countries, we're retiring our Julia simulation and rewriting it in Rust. Join for a discussion on how we could have avoided the issues that ultimately led to our decision to move away from Julia. juliacon-2025-72638-parting-ways-with-our-julia-simulation-after-100-million-miles Jonnie Diegelman en This talk will cover how Zipline used Julia for aircraft development and flight software testing, the positives of using Julia for aircraft simulation and engineering development, the pain points of using Julia in a large organization, and how the value proposition of Julia is shifting with changes in the industry. false https://pretalx.com/juliacon-2025/talk/B7WRLT/ https://pretalx.com/juliacon-2025/talk/B7WRLT/feedback/ Cathedral Room 324 - Else Room Talk 2025-07-23T16:00:00-04:00 16:00 00:30 JADE, a new Julia-based BI engine, powers Planview Advisor. It uses NDTable, a multi-dimensional array, along with Index, Choice, and Scalar objects for efficient data manipulation. A C# code generator, JuliaEngine, transforms high-level models into optimized Julia code, including formula chains, caches, and dynamic precompilation. Integrated with Oxygen, JADE enables real-time updates and interactive data exploration. It's designed for local and JuliaHub deployment, offering scalability. juliacon-2025-72634-jade-a-julia-powered-bi-engine Matthew Muyres / Chase Cowart en JADE, a new Julia-based BI engine, powers Planview Advisor. It uses NDTable, a multi-dimensional array, along with Index, Choice, and Scalar objects for efficient data manipulation. A C# code generator, JuliaEngine, transforms high-level models into optimized Julia code, including formula chains, caches, and dynamic precompilation. Integrated with Oxygen, JADE enables real-time updates and interactive data exploration. It's designed for local and JuliaHub deployment, offering scalability. false https://pretalx.com/juliacon-2025/talk/9RETLJ/ https://pretalx.com/juliacon-2025/talk/9RETLJ/feedback/ Cathedral Room 324 - Else Room Talk 2025-07-23T16:30:00-04:00 16:30 00:30 Industrial digital twin solutions require data from both engineering and operations. This typically means combining engineering simulations and operational sensor data using AI/ML. This landscape is growing with frameworks like TensorFlow and PyTorch enabling rapid prototyping in high-level languages like Python. We present a pipeline for prototyping solutions in the Julia language for production speed and performance in the Ansys TwinAI product. juliacon-2025-72639-a-prototype-to-production-pipeline-with-julia Matthew Adams en Industrial digital twin solutions require data from both engineering and operations. This typically means combining engineering simulations and operational sensor data using AI/ML. This landscape is growing with frameworks like TensorFlow and PyTorch enabling rapid prototyping in high-level languages like Python. We present a pipeline for prototyping solutions in the Julia language for production speed and performance in the Ansys TwinAI product. false https://pretalx.com/juliacon-2025/talk/UBXYKH/ https://pretalx.com/juliacon-2025/talk/UBXYKH/feedback/ Lawrence Room 107 - Method Room Lightning talk 2025-07-23T10:40:00-04:00 10:40 00:10 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. juliacon-2025-63505-the-big-refactor-that-made-algebraofgraphics-scale-better General Julius Krumbiegel en AlgebraOfGraphics (AoG) is a powerful declarative plotting library that enables users to construct complex visualizations by composing data, mappings, and visuals. Built on the Makie.jl ecosystem, AoG has always aimed to provide an expressive and flexible approach to data visualization. However, its initial approach to scales had limitations that restricted its usability and versatility. Over the past year, PumasAI undertook a major refactor of AoG’s internals, resulting in significant improvements in performance, usability, and feature richness. This talk will go over the most important architectural changes behind this refactor and highlight key new capabilities that make AoG more robust and intuitive than ever before. Key improvements include: **Multi-Scale Support**: A major breakthrough in this refactor is the ability to use multiple independent scales for the same aesthetic, allowing separate legends for different plot types. This enables more flexibility with layered visualizations. **Better Support for Various Plot Types**: The refactor fixes long-standing issues with some plot types, such as horizontal bar plots, violin plots, and error bars. Plot types have to declare the aesthetics they use in order to provide accurate axis annotations and legends. **Enhanced Legends**: It's now possible to simply add plots that don't use scales to the legend by supplying a `label`. Users can now fine-tune legend elements, override attributes, and apply automatic alpha forwarding to ensure visual consistency. Legends and color bars can be selectively hidden or customized with greater control. Continuous marker size scales are now displayed in legends with areas chosen for linear human perception. **Overhauled Faceting & Pagination**: Scales are now consistent across paginated facet plots, preventing legend collisions that previously arose when groups were missing from individual pages. The update also enables compatibility with multiple X and Y scales per facet, enhancing flexibility in complex multi-panel plots. **Easier Data Handling**: The update introduces a more intuitive approach to mapping, allowing simple column vectors to be passed directly without requiring an explicit `data` call. It also introduces a `direct` function to map external columns effortlessly and supports scalar values as a shorthand for repeated categorical labels. **Improved Sorting & Missing Support**: Sorting behavior for categorical and string-based data has been refined, including natural sorting of string categories and better handling of numerical vectors with missing values. By addressing longstanding pain points and introducing powerful new features, this refactor makes AoG more flexible and user-friendly than ever before. Whether you are creating exploratory plots or publication-quality visualizations, this talk will showcase how these changes improve your AoG experience. false https://pretalx.com/juliacon-2025/talk/CWPZFG/ https://pretalx.com/juliacon-2025/talk/CWPZFG/feedback/ Lawrence Room 107 - Method Room Lightning talk 2025-07-23T10:50:00-04:00 10:50 00:10 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. juliacon-2025-65046-lightweight-composable-plotting-makieextra-s-fplot General Alexander (Sasha) Plavin en Most plotting libraries, such as Makie, typically handle plot properties (like coordinates, color, size) as separate arrays. This simplicity works well for basic plots, epitomized by `scatter(x, y)`. However, for more complex applications, this can be limiting. Frequently, you'll have a dataset — a collection of some elements — and conceptualize plotting in terms of these elements: "for each `r ∈ data`, plot `abs(r.value)` on the x-axis, `angle(r.value)` on the y-axis, and use `r.age` for color." Makie partially supports this with spatial coordinates using a Vector of Points, but still requires other attributes like color to be passed separately. Moreover, even with just coordinates, providing more information about the dataset than raw points can facilitate richer interactivity and automatic plot labeling. The `FPlot` object encapsulates the complete plot definition, including the dataset and functions that map features to plot attributes. This design streamlines exploratory plots, simplifies and enriches interactivity, and encourages further composability in recipes. I'll demonstrate these advantages and discuss existing limitations and potential future improvements, inviting feedback for further development. false https://pretalx.com/juliacon-2025/talk/CN3ZK8/ https://pretalx.com/juliacon-2025/talk/CN3ZK8/feedback/ Lawrence Room 107 - Method Room Talk 2025-07-23T11:00:00-04:00 11:00 00:30 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. juliacon-2025-65039-you-don-t-need-to-know-julia-to-contribute General Hetarth Shah en One of the most common barriers for new contributors is the belief that they need to be experts or know about the core language or technology behind a project. However, this is a misconception that limits the impact that many potential contributors can have. Despite having an amazing community, Julia also faces the same as many contributors might think that they need to be knowledgable in various domains to start contributing. This talk will emphasize that contributing to open source, doesn't necessarily require deep knowledge of the domain or language itself and why every kind of involvement, no matter how small, is valuable in making a community thrive. Some of the points we will explore: - **Opportunities Beyond Coding**: Coding isn't the only way to contribute! Things such as improving documentation, translating content, creating tutorials, organizing events, and engaging with the community can also be invaluable to the project’s growth. - **Real-Life Examples**: Some examples of people who began contributing without knowing Julia, and how they found their place within the community. From helping with issues to writing blog posts, they have been able to build connections and gain valuable experience. - **Learning from Other Communities**: There are many eco-systems other than Julia. As a maintainer you can also take inspirations from those, on how they manage new contributions, issues, outreach, and much more. We will explore some of the things you can add to your project to make it more beginner friendly and help new contributors have a starting place. **Takeaways:** - A roadmap for getting started as a non-technical contributor in the Julia or any other ecosystem. - Actionable advice on how you can start contributing today, regardless of your programming experience. - An overview of the many ways you can engage with the community, from social media and blogs to documentation and educational resources. - Some helpful tips on how as a maintainer you can make your project more beginner friendly. The idea behind this talk is to broaden the understanding of what it means to be part of an open-source community and to empower a wider audience to engage in projects, regardless of their level of technical expertise. false Github Link Presentation in PDF format https://pretalx.com/juliacon-2025/talk/7NGEKM/ https://pretalx.com/juliacon-2025/talk/7NGEKM/feedback/ Lawrence Room 107 - Method Room Talk 2025-07-23T11:30:00-04:00 11:30 00:30 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. juliacon-2025-62847-quantumsymbolics-a-quantum-focused-symbolic-interface Quantum Minisymposium Andrew Kille en The quantum software ecosystem is a vast landscape of libraries implementing classical simulation algorithms based in various formalisms of quantum information. Choosing the appropriate formalism when designing quantum algorithms and hardware is highly problem-dependent, therefore an efficient workflow between different simulation backends is valuable. Furthermore, avoiding the peculiarities of individual quantum software libraries prioritizes the key aspects of developing quantum technologies. Our approach to these challenges is QuantumSymbolics.jl, a computer algebra package that serves as a symbolic interface to numerical quantum simulation libraries. In this talk, we present features of QuantumSymbolics.jl such as symbolic manipulation capabilities and numerical translations to state-vector simulations, Gaussian quantum information, and Clifford stabilizer circuits. false https://pretalx.com/juliacon-2025/talk/P3GCLS/ https://pretalx.com/juliacon-2025/talk/P3GCLS/feedback/ Lawrence Room 107 - Method Room Talk 2025-07-23T13:30:00-04:00 13:30 00:30 In this talk, we will discuss recent improvements and use-cases of the [Piccolo.jl](https://kestrelquantum.github.io/Piccolo.jl/docs/) 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. juliacon-2025-65036-piccolo-jl-toward-version-1-0 Quantum Minisymposium /media/juliacon-2025/submissions/J89BA7/piccolo_logo_2_4ZmqmTt.svg Aaron Trowbridge en Piccolo.jl sets up and solves quantum optimal control problems as nonlinear programs. It is based on the idea of [quantum direct collocation](https://arxiv.org/abs/2305.03261). Piccolo.jl provides composable problem templates for easy implementation of common control tasks, which we will review. This bulk of this talk will focus on the design choices that have been made in the pursuit of a version 1.0 of Piccolo.jl. We will explain the choice to break Piccolo.jl into a number of subpackages, and discuss the management of this ecosystem. We will describe the development of a Python interface, which was necessary to ease adoption by experimental groups. Furthermore, we will explain our interaction with different backend solvers, discussing [Ipopt.jl](https://github.com/jump-dev/Ipopt.jl), [MathOptInterface.jl](https://github.com/jump-dev/MathOptInterface.jl), [MadNLP.jl](https://github.com/MadNLP/MadNLP.jl), and [NLPModels.jl](https://github.com/JuliaSmoothOptimizers/NLPModels.jl). Finally, we will highlight a few new applications of quantum control enabled by Piccolo.jl, and showcase the default visualizations in Piccolo.jl's toolbox. false https://pretalx.com/juliacon-2025/talk/J89BA7/ https://pretalx.com/juliacon-2025/talk/J89BA7/feedback/ Lawrence Room 107 - Method Room Talk 2025-07-23T15:00:00-04:00 15:00 00:30 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. juliacon-2025-62399-quantumtoolbox-jl-efficient-simulation-of-open-quantum-systems Quantum Minisymposium Alberto Mercurio en QuantumToolbox.jl was developed with the goal of bringing the functionality of the widely used QuTiP library in Python to the more efficient and high-performance Julia language. Leveraging Julia’s optimized linear algebra capabilities, QuantumToolbox.jl enables efficient simulation of open quantum system dynamics, computation of emission spectra, and handling of highly entangled composite systems, along with many other advanced features. Almost every simulation can be seamlessly accelerated on GPUs or parallelized across large computing clusters. Thanks to Julia’s multiple dispatch and seamless integration with packages like CUDA.jl and Distributed.jl, users can run simulations on diverse architectures without altering the code syntax, significantly reducing the complexity of adapting code for different computing environments. Although automatic differentiation in QuantumToolbox.jl is still in its early stages, many core functions are already differentiable. With the rapid progress of Julia packages such as Zygote.jl, Enzyme.jl, and SciMLSensitivity.jl, full support for automatic differentiation is within reach. This capability is particularly valuable for quantum optimal control, where differentiating the dynamics of open quantum systems can guide the design of optimal control protocols. By bridging ease of use with high computational efficiency, QuantumToolbox.jl empowers researchers to tackle complex quantum simulations with greater speed and flexibility. false https://pretalx.com/juliacon-2025/talk/YPFSUD/ https://pretalx.com/juliacon-2025/talk/YPFSUD/feedback/ Lawrence Room 107 - Method Room Talk 2025-07-23T15:30:00-04:00 15:30 00:30 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. juliacon-2025-64906-schematic-driven-design-of-a-quantum-processor-w-devicelayout-jl Quantum Minisymposium /media/juliacon-2025/submissions/7EYFPN/qpu17_falsecolor_7b11f36.png Greg Peairs en DeviceLayout.jl is a package developed at the AWS Center for Quantum Computing (CQC) for computer-aided design (CAD) of quantum integrated circuits. At the CQC, we use DeviceLayout.jl to design superconducting quantum devices on our path to building a fault-tolerant quantum computer—devices we’ve used for experiments like [Demonstrating a Long-Coherence Dual-Rail Erasure Qubit Using Tunable Transmons](https://journals.aps.org/prx/abstract/10.1103/PhysRevX.14.011051) and [Hardware-efficient error correction using concatenated bosonic qubits](https://www.nature.com/articles/s41586-025-08642-7). We developed it to allow designers to produce and iterate on device layouts quickly and easily. We’ve paid particular attention to scalability in support of both larger quantum processors and a larger, collaborative team. As examples, we’ll highlight how we can use a schematic-driven workflow for layout of a 17-qubit processor in a modular, reproducible project; we’ll then show how it works together with [Palace](https://awslabs.github.io/palace/stable/), an open-source tool for electromagnetic finite-element analysis also developed at the CQC. We have released DeviceLayout.jl on GitHub as an open-source project, where it joins Palace as part of an open-source toolchain for electronic design automation (EDA) of quantum integrated circuits and other electromagnetic devices. The package supports the generation of 2D layouts and 3D models of complex devices using a low-level geometry interface together with a high-level schematic-driven workflow. At the geometry level, the user writes code to draw 2D geometric entities like polygons and paths, optionally using units with Unitful.jl; position and orient these entities with coordinate transformations; organize them into a hierarchy of local coordinate systems and references; apply operations like rounding, offsetting, or geometric Booleans; and assign each entity metadata that can be used in different ways by different backends. In the schematic-driven workflow, the user specifies a schematic in terms of components and the connectivity between them, followed by automatic placement and routing. The results can be rendered with various backends, including for output in the GDSII format; used to construct and mesh a 3D model; and interfaced with other tools like the open-source electromagnetics solver Palace. Finally, we leverage the Julia package manager for process design kit (PDK) management, allowing users to maintain a library of versioned process technologies and components for portable, reproducible layout scripts. false https://pretalx.com/juliacon-2025/talk/7EYFPN/ https://pretalx.com/juliacon-2025/talk/7EYFPN/feedback/ Lawrence Room 107 - Method Room Talk 2025-07-23T16:00:00-04:00 16:00 00:30 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. juliacon-2025-62846-gabs-a-gaussian-quantum-information-simulator Quantum Minisymposium Andrew Kille en Simulating large-scale quantum systems requires extensive computational resources. However, there exist important classes of quantum states and operations that exhibit low computational complexity. In particular, quantum harmonic oscillators in the phase space representation can be efficiently characterized by low-order statistical moments, provided their characteristic function is Gaussian. This collection of processes, known as Gaussian quantum information, do not yield quantum advantage, yet are fundamental building blocks for designing quantum hardware and protocols. This talk explores Gabs.jl, a library for general tooling with Gaussian quantum information. We present features including symbolic representations, translations to the state-vector formalism, symplectic analysis methods, and simulating slightly non-Gaussian quantum states. false https://pretalx.com/juliacon-2025/talk/PGCLX8/ https://pretalx.com/juliacon-2025/talk/PGCLX8/feedback/ Lawrence Room 107 - Method Room Talk 2025-07-23T16:30:00-04:00 16:30 00:30 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. juliacon-2025-63886-waveguideqed-jl-modeling-propagating-photons-in-julia Quantum Minisymposium /media/juliacon-2025/submissions/HA9S3K/wqedsketch_NMKmENZ.png Matias Bundgaard-Nielsen en WaveguideQED.jl leverages Julia’s multiple dispatch and lazy evaluation of operator products to efficiently handle time-dependent quantum mechanical operators, significantly improving computational performance. Unlike traditional methods that rely on sparse matrices, this framework employs matrix-free operator applications through non-allocating kernel functions, exploiting the structured nature of time-dependent waveguide operators. This enables high-performance simulation of up to two propagating photons, facilitating studies of non-Markovian feedback and multiphoton entanglement. By seamlessly integrating with QuantumOptics.jl, the package provides a flexible interface for researchers familiar with other quantum optics toolkits, such as QuTiP in Python, Quantum Toolbox in Matlab, and QuantumToolbox.jl also in Julia. This flexible interface and generality allow users to construct arbitrary local quantum systems, making it possible to study complex interactions. In the talk, the framework’s capabilities will be demonstrated through examples, including photon scattering calculations, quantum feedback simulations, and multi-photon dynamics in waveguides. The use of lazy operator application to efficiently implement time-dependent waveguide operators, significantly reducing memory overhead and computational complexity, will also be introduced in the talk and highlighted through benchmarks.   WaveguideQED.jl provides an efficient and flexible framework for studying quantum systems coupled to waveguides. Its combination of performance, conceptual simplicity, and modular design enables simulations of a broad range of quantum optical phenomena. Future work will focus on exploring losses in systems through Monte Carlo trajectories and potentially increasing the maximum number of propagating photons. false GitHub repository of WaveguideQED.jl WaveguideQED.jl paper https://pretalx.com/juliacon-2025/talk/HA9S3K/ https://pretalx.com/juliacon-2025/talk/HA9S3K/feedback/ Lawrence Room 120 - REPL Main Stage Keynote 2025-07-24T09:00:00-04:00 09:00 00:45 We’ll share updates on standalone executables, binding replacement, Pkg features, threading stabilization, and RISK-V support. We’ll also discuss the impact of AI on Julia development and open source relations and how Julia language development is organized and directed. Finally, we’ll discuss future work already in the works and speculate on future work that may soon commence, followed by a Q&A panel. juliacon-2025-66706-state-of-julia General Lilith HafnerKeno Fischer en The core Julia developers give an overview of the latest changes to the Julia language and upcoming features in subsequent releases. false https://pretalx.com/juliacon-2025/talk/3TKCZZ/ https://pretalx.com/juliacon-2025/talk/3TKCZZ/feedback/ Lawrence Room 120 - REPL Main Stage Gold sponsor talk 2025-07-24T09:45:00-04:00 09:45 00:10 At the AWS Center for Quantum Computing (CQC), we are working towards fault-tolerant quantum computers capable of solving problems of commercial and scientific importance that are beyond the reach of today’s conventional computers. The CQC recently announced a new quantum chip, Ocelot, designed for quantum error correction with overhead reduced by up to 90%. In this talk, we will introduce the CQC, our approach to quantum computing, and technologies (including Julia) we used to design Ocelot. juliacon-2025-75755-developing-quantum-hardware-at-aws-sponsor-talk General Greg Peairs en At the AWS Center for Quantum Computing (CQC), we are working towards fault-tolerant quantum computers capable of solving problems of commercial and scientific importance that are beyond the reach of today’s conventional computers. The CQC recently announced a new quantum chip, Ocelot, designed for quantum error correction with overhead reduced by up to 90%. In this talk, we will introduce the CQC, our approach to quantum computing, and technologies (including Julia) we used to design Ocelot. false https://pretalx.com/juliacon-2025/talk/C73W73/ https://pretalx.com/juliacon-2025/talk/C73W73/feedback/ Lawrence Room 120 - REPL Main Stage Talk 2025-07-24T10:00:00-04:00 10:00 00:30 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. juliacon-2025-63299-constants-are-no-longer-constant-what-s-up-with-that General Keno Fischer en This is a user-facing talk to put together in one place the entire story of the 1.12 era world-age and binding semantics changes (of which there are multiple related, but independent ones). The hope is to demystify the world-age mechanism for the average Julia user, and serve as useful reference as users upgrade to 1.12 and may start seeing additional world age errors not present on prior Julia versions. false https://pretalx.com/juliacon-2025/talk/TJXV9L/ https://pretalx.com/juliacon-2025/talk/TJXV9L/feedback/ Lawrence Room 120 - REPL Main Stage Lightning talk 2025-07-24T10:30:00-04:00 10:30 00:10 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 in Base Julia 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. juliacon-2025-64897-understanding-your-struct-toolbox General Sam Buercklin en Writing Julia is often a back-and-forth between designing structs to represent a problem and then implementing methods for these structs to solve the problem. At a glance, structs appear to be a fancy container with named fields: a special `NamedTuple` that is easy to dispatch on. This talk takes a deeper view of structs as the language we use to describe problems, a utility for understanding our code, and a tool for implementing complex features beyond this view of structs as convenient `NamedTuple`s. Specifically, we highlight common useful interfaces to implement for structs that enable higher order behavior. These interfaces include understanding struct equality, or identifying what goes into implementing an iterable object. We demonstrate best practices for improved type introspection via custom struct printing. Finally, we emphasize the difference between mutable and immutable structs. The syntax of mutable structs suggests only a difference in the mutability of constituent fields. However, we demonstrate features which are only available to mutable structs, even when all fields are marked as immutable. false https://pretalx.com/juliacon-2025/talk/CF3MSS/ https://pretalx.com/juliacon-2025/talk/CF3MSS/feedback/ Lawrence Room 120 - REPL Main Stage Lightning talk 2025-07-24T10:40:00-04:00 10:40 00:10 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. juliacon-2025-63741-mapping-the-julia-subsystem-in-open-science-use-impact-growth General /media/juliacon-2025/submissions/3EVLR9/photo_2024-08-05_14-42_CL9XHB7.jpg Jonathan Starr en In this talk, we introduce The Map of Open Source Science (MOSS), a large-scale data integration effort aimed at providing a holistic view of the Julia community’s impact on research and open-source development. While the Julia ecosystem has grown impressively in recent years it remains challenging to identify use, impact, and relationships throughout the ecosystem. Our goal with MOSS is to unify disparate data streams, enabling a comprehensive understanding of the ecosystem’s evolution, areas of collaboration, academic influence, and ultimately, importance within research, the economy, and society. Explore our early mappings at https://opensource.science/moss 1. Motivation and Goals Julia's expanding footprint in scientific computing, data science, and machine learning demands an up-to-date, data-driven picture of how code repositories, researchers, and research institutions converge. MOSS addresses this need by capturing not only static metadata (e.g., repository descriptions or paper titles) but also the dynamic relationships—who contributed to which package, which institutions are tied to key Julia projects, and how academic citations reference these repositories. By mapping these relationships in a knowledge graph, MOSS provides insights into the flow of knowledge and collaboration across the Julia ecosystem. 2. System Architecture and Data Flows MOSS builds its knowledge graph from multiple sources: - GitHub: Repositories, contributors, pull requests, issues, and CITATION.cff files that contain DOIs to relevant academic publications. - Scholarly APIs (OpenAlex, CrossRef, Semantic Scholar): Paper metadata, references, citations, and institutional affiliations. A data transformation layer standardizes fields, merges conflicting information, and resolves aliases. The resulting property graph uses well-defined node types such as Repository, Paper, Person, Institution, and Topic, each linked by relationships. 3. Demonstration: Mapping Julia Packages to Research We will showcase how MOSS reveals new insights into the Julia world: - Automatically linking Julia repositories with the papers they implement or reference. - Identifying which contributors are affiliated with which institutions, and how their code impacts various domains (e.g., computational physics, numerical optimization). - Quantifying how often key Julia packages are cited in academic works, and in which fields they hold the most influence. - Enabling modular, open impact algorithms. 4. Implications for the Julia Community By visualizing the interplay between code contributions, scholarly publications, and institutional relationships, MOSS serves both new and experienced community members. Developers can discover underexplored collaborations, researchers can trace code dependencies in scientific papers, and institutions can better understand where their affiliated teams and labs fit within the broader Julia ecosystem. 5. Future Directions MOSS is designed to be modular and extensible. Future work could include: - Integration with additional scholarly sources (e.g., ORCID for contributor disambiguation). Automatic detection of “hot topics,” measuring the growth of specific Julia subdomains like machine learning or HPC clusters. - Expanded entity types, such as grants or patents, to reflect the comprehensive lifecycle of research. Through MOSS, we aim to encourage data-driven community building, highlight impactful software and research, and support the transparent, reproducible ethos that underpins both open source development and open science. By attending this talk, you’ll learn how knowledge graph techniques can uncover hidden relationships in the Julia world, fostering a richer, more collaborative ecosystem for all. false https://pretalx.com/juliacon-2025/talk/3EVLR9/ https://pretalx.com/juliacon-2025/talk/3EVLR9/feedback/ Lawrence Room 120 - REPL Main Stage Lightning talk 2025-07-24T10:50:00-04:00 10:50 00:10 We aim to manipulate a payload along a specific trajectory using two quadrotors in simulation. The system features quadrotors connected via cables to a payload modeled with Multibody.jl. Polynomial trajectory synthesis is performed with DyadControlSystems.jl, and custom geometric controllers on each quadrotor collaboratively guide the payload using AerialVehicles.jl. This approach ensures precise trajectory tracking and effective cooperative aerial payload manipulation. juliacon-2025-64862-cooperative-payload-manipulation-using-aerialvehicles-jl Engineering with Julia Rajeev Voleti en This demonstration builds upon the foundational concept of cooperative rendezvous from last year's JuliaCon talk by developing a cooperative dual-quadrotor system designed to manipulate a payload along a predefined trajectory. The objective is to achieve controlled and stable aerial payload transportation, which has significant applications in areas such as logistics, construction, and emergency response. ** System Modeling The system is modeled using ModelingToolkit.jl powered by Multibody.jl with the quadrotors, cable and payload as components rigidly linked together. ** Control Control law for each quadrotor is determined using a custom geometric controller in AerialVehicles.jl. The state of the payload's center of mass is assumed to be globally known and state estimation is currently not considered for the posed problem ** Trajectory synthesis Similar to the polynomial trajectories in time generated to display acrobatic maneuvers in the documentation for AerialVehicles.jl, the trajectory generation for the payload is accomplished through DyadControlSystems.jl. ** Objective The objective of the presentation is to showcase the interplay of various tools in the Julia and JuliaSim ecosystem to accomplish cooperative payload manipulation tasks in simulation. The developed system has broad applications in various fields: - Logistics: Efficiently transporting goods in environments that are difficult to access by traditional means. Construction: Assisting in the placement of building materials in large-scale or hazardous construction sites. - Emergency Response: Rapidly delivering supplies or equipment to disaster-stricken areas where infrastructure is compromised. - Research and Development: Serving as a platform for further studies in aerial robotics and cooperative control systems by exploring emergent behavior, decentralized, optimal and autonomous control. false https://pretalx.com/juliacon-2025/talk/ZDZBGW/ https://pretalx.com/juliacon-2025/talk/ZDZBGW/feedback/ Lawrence Room 120 - REPL Main Stage Talk 2025-07-24T11:00:00-04:00 11:00 00:30 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. juliacon-2025-65059-poweranalytics-jl-user-centric-power-systems-analysis-in-julia Engineering with Julia /media/juliacon-2025/submissions/TPTJDC/Sienna-icon-circle-gra_ssgvZxO.png Gabriel Konar-Steenberg en Sienna is a state-of-the-art, open-source platform for multi-timescale electrical power systems modeling developed at the National Renewable Energy Laboratory (NREL). It consists of a suite of Julia packages, including InfrastructureSystems.jl and PowerSystems.jl, which together define data structures to flexibly represent a power system, its components, and associated parameters and time series data; and PowerSimulations.jl, which interfaces with JuMP to facilitate the creation of operational optimization problems and manage simulation workflows. While PowerSystems.jl manages inputs and PowerSimulations.jl handles simulation, PowerAnalytics.jl operates at the end of the workflow, serving as an output analysis tool accessible to the typical energy analyst, who can write simple scripts in Julia but is not an expert programmer. PowerAnalytics version 1 (source at https://github.com/NREL-Sienna/PowerAnalytics.jl, docs including tutorial at https://nrel-sienna.github.io/PowerAnalytics.jl/stable/) is a completely novel approach to operational simulation results post-processing that takes full advantage of Julia features to present the simplest interface possible to the Sienna user without sacrificing performance. The design begins with the ComponentSelector, a set of types that represent lazy, grouped collections of components. With a core interface similar to existing PowerSystems.jl API, they let the user reapply their existing Sienna knowledge; with grouping semantics similar to SQL’s GROUP BY, they enable sophisticated analytics queries; and through the magic of multiple dispatch, new ComponentSelector types can be added completely invisibly to the user. The other main concept is the Metric, a (typically time series) quantity calculated on the groups of a ComponentSelector given a particular set of simulation results. Metrics encapsulate arbitrary code to enable sophisticated analytics while harnessing Julia’s inherent speed to make this performant even on simulations of an entire power grid; support intelligent default aggregation behavior; and through a functor pattern appear to the casual user just like functions. PowerAnalytics.jl provides a library of pre-built Metrics; users can also take advantage of multiple dispatch to define new Metrics either from scratch or by composition from other Metrics via a functional programming interface. The output of a Metric is a DataFrames.jl DataFrame, chosen to minimize the number of new types the user must wrangle, while details about the computation are embedded in the DataFrame’s metadata to support further processing and plotting. The design of PowerAnalytics 1 was centered on the Sienna user’s needs at every step of the process, resulting in a package that allows one to leverage the full expressivity of the Sienna data model to accomplish a broad array of analytics tasks, while working completely within the ComponentSelector-Metric framework that simplifies code and eliminates places for bugs to hide. Taking a real-world analytics script written manually by an NREL power systems researcher and rewriting it using PowerAnalytics 1, the number of lines of code was reduced by two thirds and several subtle bugs were eliminated. Already, PowerAnalytics 1 has been used to support power system studies within NREL, and with its recent official release, we expect to see fast adoption outside the lab by users in state institutions and internationally to improve results communication and stakeholder engagement. In this talk, I will cover how PowerAnalytics fits into the general Sienna platform; describe the user-centered design, software engineering, and Julia language techniques employed to create a powerful yet approachable domain specific analytics package in the Sienna style; discuss how the package is being used, and conclude with some lessons that might be applied to the design of other Julia packages. false https://pretalx.com/juliacon-2025/talk/TPTJDC/ https://pretalx.com/juliacon-2025/talk/TPTJDC/feedback/ Lawrence Room 120 - REPL Main Stage Talk 2025-07-24T11:30:00-04:00 11:30 00:30 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! juliacon-2025-64913-algorithms-for-validation-of-dynamical-systems Engineering with Julia /media/juliacon-2025/submissions/N7WXUR/IMG_20250213_184240_96_ropU5zE.jpg Romeo Valentin en As autonomous systems increasingly navigate our airways, roads, and critical infrastructure, the ability to rigorously validate their safety becomes crucial. In this talk we will therefore be exploring safety validation, or "stress testing", of such dynamical systems, using a some of the algorithms presented in the new book *"Algorithms for Validation"* by M. Kochenderfer et. al. ([available for free as pdf!](https://algorithmsbook.com/validation/)) As a case study, we will consider a system of two aircraft on a collision course, and a controller trying to avoid the collision. A series of unfortunate observation errors may mislead the controller into making bad decisions, ultimately leading to a collision. Finding such "rare failure events", and estimating their probability, is therefore integral for validating the integrity of the system and controller. Through a series of interactive `Pluto.jl` notebooks we showcase how Julia can be used to (i) specify system safety properties, (ii) efficiently find rare failures by optimizing over system rollouts, (iii) estimating failure probabilities through Markov Chain Monte Carlo, and (iv) computing the reachable set through set propagation techniques (under bounded noise). On the way, we make use of packages including `SignalTemporalLogic.jl`, `NonlinearSolve.jl`, `Turing.jl`, and `LazySets.jl`. Even though the presented algorithms and used packages are implemented in Julia, we note that the environment and controller may be any black-box, and we showcase specifically how Julia may be used in conjunction with a Python based Neural Network controller, and a black-box simulation environment. Although we highlight an example from aviation, similar problems arise in a wide range of applications such as autonomous driving and flight, financial decision making, chemical process control, logistics and transportation, energy grid balancing, and many others. With this talk we therefore aim to inform practitioners about algorithmic developments for safety validation and the applicability through fast, flexible, and concise implementations in Julia. No prior experience with verification is required, although a familiarity with dynamical systems or Markov decision processes may be beneficial.) false https://pretalx.com/juliacon-2025/talk/N7WXUR/ https://pretalx.com/juliacon-2025/talk/N7WXUR/feedback/ Lawrence Room 120 - REPL Main Stage Talk 2025-07-24T13:30:00-04:00 13:30 00:30 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. juliacon-2025-63793-juliac-for-model-based-engineering Engineering with Julia Fredrik Bagge CarlsonRajeev Voleti en Model-based engineering (MBE) has emerged as a cornerstone of modern engineering, enabling the efficient design, analysis, and deployment of complex systems. By representing systems as mathematical or graphical models, engineers can simulate, test, and validate designs prior to physical implementation, reducing development time and cost. Central to the MBE workflow is the use of high-level modeling languages to describe systems, followed by the automatic generation of low-level C-code for deployment on embedded hardware or other real-time systems. Although this workflow has proven highly effective, it presents several issues. Code-generation capabilities often come with a significant price tag, presenting a financial incentive to find competitive alternatives. Furthermore, high-level modeling languages with code-generation capabilities often impose restrictions on expressiveness to ensure compatibility with C-code generation, such as limitations on which functions may be called, use of variable-sized arrays, and use of flexible data structures, operator overloading, and arrays of objects. Additionally, integrating preexisting libraries or leveraging cutting-edge algorithms and hardware accelerators in these environments can be cumbersome, as it requires significant manual effort to make them code-generation compatible or the hardware support is missing etc. These limitations can hinder the pace of development and stifle innovation, particularly in domains that require flexibility or powerful computing. Historically, Julia lacked support for compiling small, standalone binaries or shared libraries, a feature critical for deploying code to resource-constrained environments such as embedded systems. Recent advancements in Julia’s compiler technology have stared addressing this gap, enabling an alternative approach to MBSE workflows. In this talk, we demonstrate how these developments, combined with the ModelingToolkit equation-based (acausal) modeling framework, enable the compilation and deployment of Julia programs directly to the target system without relying on C-code generation. By leveraging Julia's native code generation pipeline, we eliminate the restrictions typically imposed by traditional workflows, offering greater flexibility and enabling the use of Julia's rich ecosystem of already existing libraries. To illustrate this capability, we design a simple equation-based model and a nonlinear state estimator, compile the resulting program, and deploy it on a Raspberry Pi for real-time state estimation. We also convert a Julia package implementing PID controllers into a C-callable shared library. false https://pretalx.com/juliacon-2025/talk/WKERWE/ https://pretalx.com/juliacon-2025/talk/WKERWE/feedback/ Lawrence Room 120 - REPL Main Stage Talk 2025-07-24T14:00:00-04:00 14:00 00:30 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?" juliacon-2025-63936-handcalcs-jl-calculations-you-can-read-and-reuse Engineering with Julia Cole Miller en This talk will discuss [Handcalcs.jl](https://github.com/co1emi11er2/Handcalcs.jl) which is a calculation tool that is meant to be used in a notebook-style environment. It is inspired by handcalcs.py and brings features that are only possible in Julia. With Handcalcs.jl users will be able to turn their code into LaTeX rendered math that can then be turned into professional quality calc packages. This allows for better checking of calcs compared to Excel due to the improved readability. Mathcad will give you similar readability, but with Handcalcs.jl, users have the power of a complete programming language as well as all the useful packages and features that come along with that. There is one more key feature though that none of these other calc packages have. Handcalcs.jl is able to render your Julia functions into LaTeX rendered math. All of the work of the function is shown automatically. This is recursive, so functions that call other functions can be rendered as well. This talk will go through the features of Handcalcs.jl and show how to then use the tool to create complete calc packages using tools like quarto and weave (typst hopefully coming soon). It will also discuss future roadmap for the tool. false https://pretalx.com/juliacon-2025/talk/H79KPZ/ https://pretalx.com/juliacon-2025/talk/H79KPZ/feedback/ Lawrence Room 120 - REPL Main Stage Lightning talk 2025-07-24T14:30:00-04:00 14:30 00:10 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. juliacon-2025-63549-nonlinear-control-and-reachability-for-reusable-launch-vehicles Engineering with Julia Benjamin Chung en Controlling aerodynamically actuated reusable launch vehicles is complicated by their highly nonlinear, underactuated dynamics that require trajectory optimization and model predictive approaches to control well. Previous approaches were either slow and dynamically accurate or fast but missed large and important parts of the dynamics. We describe the implementation of a model of an axisymmetric aerodynamically-controlled resuable launch vehicle in ModelingToolkit and Julia, including both body and control aerodynamic forces and moments. We use this model to perform both efficient trajectory optimization by reduction to successive convex optimization using JuMP and Clarabel for the resulting 5 degree of freedom system and describe an approach for using that trajectory optimization to perform nonlinear approximate reachability analysis. false https://pretalx.com/juliacon-2025/talk/3ZHWUS/ https://pretalx.com/juliacon-2025/talk/3ZHWUS/feedback/ Lawrence Room 120 - REPL Main Stage Lightning talk 2025-07-24T14:40:00-04:00 14:40 00:10 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. juliacon-2025-63720-juldpm-lattice-discrete-particle-model-for-fracture-simulations Engineering with Julia /media/juliacon-2025/submissions/9WBCGW/JuLDPM_vajeHGl.png Alessandro Fascetti en Lattice models simulate the behavior of solid media by means of a dense network of 1D elements, connected on a structured or unstructured set of nodes. These approaches originate from the work of Navier and Cauchy on the central force approach as the framework for the theory of elasticity (1827). In the early 1940s, Hrennikoff proposed the so-called framework method, in which the mechanical behavior of continuous media is discretized by means of a network of 1D bars. This work constitutes the basis for the variety of lattice modeling approaches derived decades later. Among these, the Lattice Discrete Particle Model (LDPM) emerged as one of the most accurate methodologies to solve elasticity and fracture problems for engineering mechanics applications, such as cementitious composites and granular assemblies. The main feature of LDPM that sets it apart from other available lattice modeling techniques is that the mesoscale features of the materials are directly represented by randomly placing poly-sized spheres in the computational domain. The spheres, which idealize inclusions such as aggregate particles in concrete, are sized according to the physical length scales governing the fracture processes (e.g, the granulometric curve in a concrete mix). The lattice elements are constructed by means of a Delaunay tessellation constructed on the sphere centroids, while their inertial properties are derived from a dual tessellation that was specifically designed to represent potential crack paths in the domain based on the internal structure of the material. This talk will be delivered as a cohesive sequence of three lightning talks, and will feature three speakers, discussing three significant advancements in LDPM recently developed by our research team : (1) a stochastic LDPM approach for simulation of fracture in porous cementitious composites, (2) an extension of the classical lattice model to encompass dual tessellations for the simulation of erosion in flood protection system infrastructure, (3) recent development and implementation of a novel reduced-order modeling technique for LDPM based on a Proper Orthogonal Decomposition. Emphasis will be given to the description of several numerical techniques implemented in JuLDPM, such as automatic differentiation and graph coloring techniques, multithreading (via Threads.jl), as well as ongoing research for deployment of the package on HPC clusters. false https://pretalx.com/juliacon-2025/talk/9WBCGW/ https://pretalx.com/juliacon-2025/talk/9WBCGW/feedback/ Lawrence Room 120 - REPL Main Stage Lightning talk 2025-07-24T14:50:00-04:00 14:50 00:10 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. juliacon-2025-65050-fast-flexible-processing-of-lidar-data-with-pointclouds-jl Engineering with Julia Manuel F. SchmidMarco Giometto en To analyze and model the physical world with computational tools, we need a digital representation – sometimes known as “digital twin” – of the environment. Obtaining detailed information such as the location and shape of buildings and vegetation can however be a major challenge. Airborne lidar data is collected with aircraft-mounted laser scanners that measure the location of millions of points on the land surface. A growing number of countries are creating such scans of their whole territory and make the data freely available online. There is a good chance that you can download high-resolution point-cloud data (often tens of points per m²) for the location of your home, your scientific study, or your engineering project. However, that data is in the form of an unstructured “point cloud” consisting of 3D coordinates and some additional metadata. To extract useful information generally requires a series of processing steps such as coordinate transforms, filtering, classification, and rasterization. This processing might require interactive experimentation with project-specific code that runs fast enough to handle millions of points – a task that Julia is uniquely suited for. With PointClouds.jl we present a new package for working with point-cloud data. It can query available datasets to find and download available data for your location of interest and read the data in the specialized LAS format and its compressed LAZ variant. It also implements common processing steps with support for multithreading and lazy processing of data that does not fit into memory, allowing you to build a processing pipeline tailored to your specific needs. In our research work, we use PointClouds.jl to model wind flow in urban environments. The point-cloud data allows us to include detailed representations of the local terrain, buildings, and vegetation in our computational flow models to generate more accurate predictions for applications in air quality, urban climate, wind engineering, and unmanned aerial vehicles. false https://pretalx.com/juliacon-2025/talk/CWN3MC/ https://pretalx.com/juliacon-2025/talk/CWN3MC/feedback/ Lawrence Room 120 - REPL Main Stage Talk 2025-07-24T15:00:00-04:00 15:00 00:30 This talk demonstrates how the difficult problem of modeling fluid systems is tackled in Dyad. 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. juliacon-2025-63767-modeling-of-fluid-systems-in-dyad Engineering with Julia Michael TillerAvinash SubramanianVenkatesh Prasad en There are a wide variety of modeling and simulation tools on the market. One thing that distinguishes one tool from another is how they approach some of the particularly challenge modeling domains. One such challenging modeling domain is modeling of fluid systems. Fluid systems present a number of challenges for modeling. First, they can often be quite numerically stiff. Furthermore, fluids can be highly non-linear in their behavior, **especially** in the context of phase changes or chemical reactions. Third, computing fluid properties for fluids is an entire topic on its own and is especially complicated by mixtures of different fluids (especially in different phases). Finally, any given component in a fluid model has to concern itself not only with how the component itself (_e.g.,_ valves, tanks, compressors) behaves but with the orthogonal concern of how the fluid contained in it also behaves. In this talk, we'll cover how we model fluid systems in Dyad. This includes using multiple dispatch in Julia to build up component models from an abstract representation of the fluid and its properties. We'll also discuss how we specify which fluids to use in each distinct circuit within our models and the kinds of user friendly diagnostics we provide in cases where uses make errors in this process. Lastly, we'll discuss how we handle the concept of "thermodynamic state" across different types of fluids and property models. false https://pretalx.com/juliacon-2025/talk/3QKB33/ https://pretalx.com/juliacon-2025/talk/3QKB33/feedback/ Lawrence Room 120 - REPL Main Stage Talk 2025-07-24T15:30:00-04:00 15:30 00:30 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. juliacon-2025-62646-tuning-attitude-control-gains-of-a-satellite-using-julia Engineering with Julia /media/juliacon-2025/submissions/SAYCCZ/Amazonia-1B_control_ga_uQSTGjs.png Ronan Arraes Jardim Chagas en The Brazilian National Institute for Space Research (INPE) is currently developing a new satellite named Amazonia-1B. The spacecraft bus is nearly identical to the previous mission, Amazonia-1, which was successfully launched in February 2021. However, the payload for Amazonia-1B is significantly different from that of its predecessor. The attitude control subsystem (ACS) of a satellite is responsible for pointing the satellite towards the desired location to acquire the mission data. This subsystem is tasked with maintaining the pointing accuracy sufficiently high to ensure that the acquired data quality meets the mission requirements. In the case of Amazonia-1B, the payload is a camera with a resolution of 20 m. Therefore, the ACS must be capable of maintaining the attitude within 0.0005° during the camera integration time to prevent image blurring. Among the numerous factors that must be accurately calibrated to maintain the necessary stable attitude, one of the most crucial is the precise adjustment of the control gains and parameters. The Amazonia-1 and Amazonia-1B missions employ a proportional-derivative (PD) controller, along with a set of filters, to mitigate disturbances. However, due to the distinct inertia characteristics of the two missions, it is not feasible to utilize the previously designed values. In the preceding mission, MATLAB was employed to design control gains utilizing consolidated tools. However, our approach proved to be excessively time-consuming for this scenario. The tools and theoretical framework assume a linear system composed of a series of transfer functions. Nevertheless, the actual satellite incorporates numerous impactful non-linearities that substantially alter the system time response. For instance, during the design phase, the available tools did not account for actuator limitations, and the selected reaction wheel only provides 75 mNm of torque. Consequently, the set of gains designed resulted in significantly different time responses when tested in the actual hardware with a highly detailed simulation. To address this scenario, we necessitated selecting a substantial number of candidates for the gains (more than 20) and selecting the best ones based on real-time simulation, which was extremely time consuming. For our current mission, we have adopted a more advanced approach. Utilizing Julia’s ecosystem, we constructed a control gain tuning tool employing SatelliteToolbox.jl, ReferenceFrameRotations.jl, ControlSystems.jl, ModellingToolkit.jl, and GLMakie.jl. This tool encompasses both conventional figures of merit for assessing control stability and robustness (gain and phase margins) and a time response derived from a highly precise model. The latter was obtained by simplifying our validated simulator and restricting the dynamics to a single axis. This tool allowed an effortless selection of a set of control gains that meet the specified margins while simultaneously achieving an exceptionally good time response. In this scenario, Julia’s performance proved highly advantageous, as it enables the instantaneous update of the time simulation upon the selection of a new gain set. This tool enables us to obtain the control gains and filter parameters for the four satellite control modes significantly faster than the previous approach. The initial set of parameters obtained yields an excellent output in the real-time simulation, substantially reducing the time required to complete this task. This presentation will provide a comprehensive description of the development process. We will demonstrate the tool and elucidate our methodology for designing satellite control gains. Additionally, we will demonstrate how we integrated the ecosystem packages to create this application. This information is highly valuable for various engineering endeavors beyond the space domain, as it can be readily adapted for tuning control gains in other types of scenarios. false https://pretalx.com/juliacon-2025/talk/SAYCCZ/ https://pretalx.com/juliacon-2025/talk/SAYCCZ/feedback/ Lawrence Room 120 - REPL Main Stage Keynote 2025-07-24T16:10:00-04:00 16:10 00:50 Solving a linear system is one of the oldest problems in mathematics. Prof John Urschel, at MIT Mathematics, will present the history of the elimination algorithm, one of the most fundamental techniques to solve linear systems. juliacon-2025-78091-80-years-of-computing-with-the-elimination-algorithm General Dr. John Urschel en The solution of a linear system, i.e., given a matrix A and vector b, finding a vector x satisfying Ax = b, is one of the oldest problems in mathematics. Gaussian elimination is one of the most fundamental and well-known techniques for solving linear systems, by factoring a matrix into the product of a lower and upper triangular matrix. Surprisingly, a number of questions regarding the numerical stability of this algorithm remains. In this talk, we will study the history of this subject, a story that spans eighty years, and discuss some recent progress. We'll also highlight the role of Julia in this progress. false https://pretalx.com/juliacon-2025/talk/7HP8SX/ https://pretalx.com/juliacon-2025/talk/7HP8SX/feedback/ Lawrence Room 121 - Struct Room Talk 2025-07-24T10:00:00-04:00 10:00 00:30 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. juliacon-2025-62744-introducing-quarto-s-native-julia-engine-easier-faster-better General Julius Krumbiegel en We’re excited to share the story behind the new native Julia engine for the technical publishing system Quarto, developed by PumasAI in collaboration with the Quarto project. Released right after last year's JuliaCon, this engine, based on the QuartoNotebookRunner.jl package, makes it easier than ever to author, render, and publish computational documents with Julia. Previously, Julia’s integration with Quarto relied on the IJulia package, requiring Python, Jupyter, and a carefully configured Julia environment. This setup often caused frustration due to its complexity and dependency management. The new native Julia engine eliminates these issues. With just Julia and Quarto installed, users can now start creating and rendering documents without additional setup. On first use, Quarto manages the installation of the required Julia packages automatically, providing a frictionless experience. This engine also opens up exciting new possibilities for Julia users. The new expandable cell mechanism, a unique feature of our engine, lets users programmatically generate sections of their document which previously required hardcoding markdown code, unlocking more modular and easily reproducible workflows. Native support for R code cells, powered by RCall, allows effortless integration of Julia and R in a single document. (A proof of concept for a similar mechanism for Python using PythonCall also exists.) In this talk, I will explain the design and architecture of QuartoNotebookRunner.jl, discuss how it interfaces with quarto-cli, and show how it can be extended with custom Julia packages. I’ll also highlight opportunities for further feature development now that Julia has its own native engine, bringing it closer to parity with R’s rich feature set in Quarto. Whether you’re a scientist, data analyst, or developer, this session will provide a comprehensive overview of how the native Julia engine simplifies workflows and expands the possibilities for document creation with Julia and Quarto. false https://pretalx.com/juliacon-2025/talk/PECPHK/ https://pretalx.com/juliacon-2025/talk/PECPHK/feedback/ Lawrence Room 121 - Struct Room Talk 2025-07-24T10:30:00-04:00 10:30 00:30 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. juliacon-2025-62272-juliaqcd-portable-lattice-qcd-package-in-julia-language General /media/juliacon-2025/submissions/J7F3M7/logo_juliaqcd_Rb5QxGR.png Akio Tomiya en JuliaQCD is a new code suite for lattice gauge theory, designed to tackle the computationally demanding problems of four-dimensional QCD and other non-Abelian gauge theories. Lattice QCD is a challenging high-performance computing (HPC) problem, requiring efficient algorithms and scalable implementations to handle large-scale simulations. JuliaQCD leverages LLVM for high-performance execution, integrates MPI for parallel computations, and utilizes Julia’s multiple dispatch for intuitive and flexible development. In addition, the latest release includes GPU acceleration through Julia’s GPU ecosystem, enabling even higher performance on modern heterogeneous HPC systems. The code suite features Hybrid Monte Carlo (HMC), support for various color and flavor extensions, lattice fermions, advanced smearing techniques, and full QCD simulations. With its focus on scalability—from laptops to supercomputers—JuliaQCD provides researchers with a powerful tool for rapid prototyping and deployment of state-of-the-art lattice gauge theory algorithms. false https://pretalx.com/juliacon-2025/talk/J7F3M7/ https://pretalx.com/juliacon-2025/talk/J7F3M7/feedback/ Lawrence Room 121 - Struct Room Talk 2025-07-24T11:00:00-04:00 11:00 00:30 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. juliacon-2025-64528-typstry-jl-the-julia-to-typst-interface General /media/juliacon-2025/submissions/FXAPL7/logo_MZS1RDL.svg Jakob Krell (they/them) en Typst is a powerful and easy-to-learn typesetting system. Since its release of version 0.1.0 in April of 2023, it has earned over 44,000 stars on GitHub and is, anecdotaly, well on its way to becoming as powerful as LaTeX. Typst supports exporting to PDF, PNG, and SVG, with HTML being a focus of active development. It provides incremental compilation to improve performance, a simple markup and intuitive mathematical syntax, an integrated scripting language, and friendly error messages. [Typstry.jl](https://github.com/jakobjpeters/Typstry.jl) is the interface to write, generate, and render Typst from Julia. It provides a custom string and corresponding macro to facilitate writing Typst code. Further, it implements configurable formatting of Julia values, which may be extended for custom types. This Typst string is integrated with the formatting capabilities such that Julia values may be formatted directly by the string constructor and through interpolation within the string macro. The Typst command-line interface can also be ran through the use of a custom command and corresponding macro. These features are composed to enable rendering Julia values with a single function call. Several packages are interoperable with Typstry.jl, improving the ability to render Julia values within notebooks, Makie.jl plots, and even Typst source code. The current use of Typst within the Julia ecosystem is relatively small, but has a promising and exciting future. Future work includes improving Typst support in packages and implementing formatting for additional types, including partial Julia-to-Typst transpilation. false https://pretalx.com/juliacon-2025/talk/FXAPL7/ https://pretalx.com/juliacon-2025/talk/FXAPL7/feedback/ Lawrence Room 121 - Struct Room Talk 2025-07-24T11:30:00-04:00 11:30 00:30 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. juliacon-2025-64600-how-to-hack-into-documenter-jl General /media/juliacon-2025/submissions/7QWVNC/logo_G2T2dTA.svg Anshul Singhvi en Packages like DocumenterCitations, DocumenterMermaid, and others do excellent work. But how do they actually work, and how can you do something similar for your own work? Documenter has some nice abstractions that allow the user to hook in to any stage of the pipeline, and this talk will show you how to do it! Starting from the structure of the document, pages, and the Markdown syntax tree representation, we'll hook in to Documenter build stages, mess with the contents of the document, and see how to render our custom blocks in each backend! false https://pretalx.com/juliacon-2025/talk/7QWVNC/ https://pretalx.com/juliacon-2025/talk/7QWVNC/feedback/ Lawrence Room 121 - Struct Room Talk 2025-07-24T13:30:00-04:00 13:30 00:30 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. juliacon-2025-64954-aliastables-jl-state-of-the-art-o-1-discrete-random-sampling General Lilith Hafner en This talk will lay out the accuracy and performance guarantees the algorithms provide, showcase performance across problem size, and delve into the details of the algorithm itself. Specifically it will focus on: - The novel optimizations this package contributes which allow it to more efficiently utilize random bits; - How AliasTable sampling is integrated with Julia's Xoshiro rng to provide efficient bulk generation; - Correctness proofs and empirical verification of perfect sampling accuracy While less than a year old, AliasTables.jl is mature and widely deployed with tens of thousands of monthly downloads and over 1000 indirect dependents. false https://pretalx.com/juliacon-2025/talk/WJKTVK/ https://pretalx.com/juliacon-2025/talk/WJKTVK/feedback/ Lawrence Room 121 - Struct Room Talk 2025-07-24T14:00:00-04:00 14:00 00:30 _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._ juliacon-2025-63963-ortools-jl-access-google-s-solvers-through-jump General /media/juliacon-2025/submissions/XQKQSW/ortools_logo_7p3If3f.png Ochibobo Warren en ORTools.jl is a package that exposes Google’s optimisation solvers to the Julia ecosystem. It achieves this goal through MathOptInterface, for JuMP and Optimization.jl compatibility, and doing necessary data structure conversions, currently primarily through Protocol Buffer, to target Google’s MathOpt library. It will expose Google’s Glop, CP-SAT, and PLDP open-source solvers to the Julia community, giving access, for the very first time, to Google’s solvers through JuMP as they would other solvers. In particular, [CP-SAT has won gold medals at the MiniZinc challenge for more than a decade](https://www.minizinc.org/challenge/) and [PDLP has sparked new interest in first-order methods for linear programming at extremely large scale](https://arxiv.org/abs/2501.07018). Writing this package was a technical challenge, as the Google solvers are only accessible through a C++ interface, a language that is notoriously hard for interop. The first version of ORTools.jl uses a Protocol Buffer interface and a very small C API to call the solvers. It relies on a JLL package to build OR-Tools, ensuring a smooth experience for end users false https://pretalx.com/juliacon-2025/talk/XQKQSW/ https://pretalx.com/juliacon-2025/talk/XQKQSW/feedback/ Lawrence Room 121 - Struct Room Talk 2025-07-24T14:30:00-04:00 14:30 00:30 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 juliacon-2025-65008-julia-in-c-world-fast-safe-and-seamless General Yury Nuzhdin en If I sparked your interest with "Adventures embedding Julia on a $$$ chip-making machine 🤑" talk then you may have a question "But how did they made Julia code to interact with C in a nice way?". For ASML lithography machines it is important not only to deliver high-end computational algorithms but also fit them into tight timing constraints. Which means that we can't afford to copy data inside of Julia managed memory and have to work with C structures directly. That is a big challenge, as Julia doesn't know about lifetime rules of other languages and in general able to work with foreign memory only via `unsafe_` calls which require careful usage. I this talk I will show how to build a system of types which will represent C memory in native Julia way, so C structures will appear as Julia structures, C arrays and vectors will appear and behave like native Julia ones and even how to build wrappers for tensors and sparse matrices. I will also show and explain the mechanism which ensures strong memory safety for such operations, preventing any memory leaks or violations and minimizing overhead of safety checks. false https://pretalx.com/juliacon-2025/talk/CHYGGX/ https://pretalx.com/juliacon-2025/talk/CHYGGX/feedback/ Lawrence Room 121 - Struct Room Talk 2025-07-24T15:00:00-04:00 15:00 00:30 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. juliacon-2025-63854-julia-and-matlab-can-coexist-let-us-show-you-how General Steven Whitaker en [GLCS.io](https://GLCS.io) has been writing Julia code since 2015 and has re-designed, improved, and developed Julia models across finance, science, and engineering domains over the last 4 years. We’ve fallen in love with the power and performance of Julia and believe there is tremendous untapped potential. For decades, MATLAB has been a gold standard for data exploration, analysis, modeling and simulation across scientific and engineering domains. There are likely hundreds of thousands of MATLAB licenses in use, and millions of users supporting an unimaginable number of models and codebases. Even for a single company, converting all existing MATLAB models to Julia would seem to be an immovable mountain, considering developer's time, expenses, and required expertise. What hope do we have for increased Julia adoption in the face of this obstacle? Can we create a business case that is compelling for our development team? Our management team? Or project sponsors? What is the way forward? GLCS has developed a standard process to enable developers to seamlessly integrate Julia into existing MATLAB codebases. On some projects, we’ve seen up to 100x performance increase while improving code quality and feature-set. This talk will describe the process of integrating Julia into your MATLAB code. We will use a real-world model to illustrate design patterns for integration and maximum performance improvement. We will review before and after benchmarks to articulate the business case. If you partner with GLCS for your Julia integration project, we’ll help you at every step, making sure to clearly understand your goals to meet or exceed your expectations. We aim to encourage industry and research professionals to use Julia for their existing projects. Please share this talk with non-Julians you know; we hope to grow Julia adoption in MATLAB communities. Talk Recording: https://www.youtube.com/watch?v=vvnfyVMwu_Y false Talk slides https://pretalx.com/juliacon-2025/talk/9WCTQR/ https://pretalx.com/juliacon-2025/talk/9WCTQR/feedback/ Lawrence Room 121 - Struct Room Talk 2025-07-24T15:30:00-04:00 15:30 00:30 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. juliacon-2025-63808-metaheuristicsalgorithms-jl General Abdelazim Hussien en MetaheuristicsAlgorithms.jl, a new Julia package designed to bring recent powerful metaheuristic optimization algorithms to the Julia ecosystem. These algorithms, originally developed in MATLAB or Python, have now been ported to Julia. By leveraging Julia’s strengths, this package offers significantly faster execution speeds compared to traditional languages, making it ideal for solving complex optimization problems in various fields such as engineering, artificial intelligence, and beyond. With a growing set of optimization algorithms and future enhancements, this package will help you tackle a wide range of optimization challenges efficiently. MetaheuristicsAlgorithms.jl initially includes more than 100 different metaheuristic optimization algorithms. These algorithms have been carefully implemented and are ready to help solve your optimization problems. Looking ahead, the package will be expanded to include more algorithms and improvements, ensuring it stays up-to-date with the latest advancements in optimization methods. Additionally, we plan to integrate benchmark functions from renowned CEC (Congress on Evolutionary Computation) competitions, including those from CEC 2005, 2014, 2017, 2020, and 2022, giving users a broader toolkit for testing and comparing algorithms in standard scenarios. MetaheuristicsAlgorithms.jl is just the beginning of a larger vision. In the future, we will continue to expand this package to include more metaheuristic algorithms, additional benchmark functions from the CEC competitions, and improved features to make it even more useful for optimization research and applications. The package is designed to be flexible, fast, and easy to use, allowing the Julia community to engage with cutting-edge optimization techniques and contribute to its growth. false https://pretalx.com/juliacon-2025/talk/83CVQ3/ https://pretalx.com/juliacon-2025/talk/83CVQ3/feedback/ Lawrence Room 121 - Struct Room Poster Session 2025-07-24T18:00:00-04:00 18:00 02:00 Come see all the great posters at this year's JuliaCon, chat with presenters and other attendees, and unwind after a day of talks! juliacon-2025-66723-poster-session-alumni-hall-connolly-ballroom General en Come see all the great posters at this year's JuliaCon, chat with presenters and other attendees, and unwind after a day of talks! - MultiTensorKit: the multifusion expansion of TensorKit - Efficient fractional differential equation solving in Julia - LyoPronto.jl: Toolkit for Lyophilization Simulation - Learning Microbial Growth Dynamics: A Neural ODE Framework - CloudCovErr.jl: Infilling in Filamentary Backgrounds for Astro - Using Bayesian Optimization to find Minimal Growth Media - Component based modeling for relativistic electrons - JULIA-ECG: A Novel Arrhythmia Detection Edge Computing System - Circuit Model Discovery Algorithm for Supercapacitors - New features and algorithms in Manopt.jl - StateSpaceDynamics.jl: Probabilistic State-Space Modeling - Collision Simulations on Curved Geometries with Julia - Fortuna.jl: Structural and System Reliability Analysis in Julia - Hephaestus.jl: Auto-Differentiable Structural Analysis in Julia - Antique.jl: Analytical Solutions of Quantum Mechanical Equations - Breaking Barriers in Programming: Julia for Vision-Impaired - ShellFEA.jl - Working with radio interferometry data: VLBIData and companions - DataPipes.jl: no-boilerplate pipes for generic data manipulation - Scalable Distributed FFT using Dynamic Task Scheduling Dagger.jl - Dagger.jl: Dynamic Task Scheduling for Heterogeneous and Mixed-P - FHist.jl - A Python Interface for Julia (with Piccolo.jl) false https://pretalx.com/juliacon-2025/talk/AWAHNU/ https://pretalx.com/juliacon-2025/talk/AWAHNU/feedback/ Lawrence Room 104 - Function Room Talk 2025-07-24T10:00:00-04:00 10:00 00:30 The IEEE has a working group drafting a standard for Floating-point Arithmetic Formats in Machine Learning. This talk presents an overview of their collective implementation and covers design advantages found with using Julia. juliacon-2025-62246-representing-small-floats-for-machine-learning General Jeffrey Sarnoff en The IEEE has a working group to draft a standard for Floating-point arithmetic formats in Machine Learning ( https://standards.ieee.org/ieee/3109/11165/ ). The speaker is Editor-in-Chief. This talk explains a canonical approach to the multi-format implementation and covers advantages found in using Julia for this. false https://pretalx.com/juliacon-2025/talk/TQ933M/ https://pretalx.com/juliacon-2025/talk/TQ933M/feedback/ Lawrence Room 104 - Function Room Talk 2025-07-24T10:30:00-04:00 10:30 00:30 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. juliacon-2025-65043-accessors-jl-beyond-set-or-a-tour-of-the-opticland General Alexander (Sasha) Plavin en The Accessors package implements the concept of "optics" in Julia. In the most basic form, it addresses this common problem: - I have a function (optic) `f(x)` and an object `x`. - I want to get `x_new` similar to `x` but with `f(x_new) = 123` That's just `set(x, f, 123)` in Accessors. Thanks to both Julia powers and the clever Accessors.jl design, a very broad range of functions is supported directly. The package includes the `@o` macro for composing functions with familiar syntax, like `@o year(first(_).dob)`, creating a `ComposedFunction` usable in `set()`. If you have experienced optics libraries in other languages, you will appreciate how seamlessly Accessors fits them into Julia. There is very little magic: optics are plain functions and can be called directly. They just have to be transparent and built from existing blocks: for example, a `ComposedFunction` instead of a black-box anonymous function. This talk will cover the user-facing interface and internal design that enable composable and performant (typically, zero-cost) `set()` operations. I'll discuss both stable and experimental developments within the Julia optics ecosystem. Finally, I'll showcase various use cases where Accessors' optics shine and lead to clean and general code, including applications in autodiff, function optimization, tabular operations, plotting, and UI generation. false https://pretalx.com/juliacon-2025/talk/Z7JRAL/ https://pretalx.com/juliacon-2025/talk/Z7JRAL/feedback/ Lawrence Room 104 - Function Room Talk 2025-07-24T11:00:00-04:00 11:00 00:40 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. juliacon-2025-70608-the-past-present-and-future-of-sparse-computations Sparse & Graph Computing in Julia Aydın Buluç en 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. I am also going to present a review of the trends in sparse computations, powered by the changing application requirements, data size increases, and architectural forces. false https://pretalx.com/juliacon-2025/talk/ZBD3PT/ https://pretalx.com/juliacon-2025/talk/ZBD3PT/feedback/ Lawrence Room 104 - Function Room Lunch Break 2025-07-24T12:00:00-04:00 12:00 01:30 Enjoy a meet and greet with Temple Capital, Diamond Sponsor of JuliaCon 2025. Temple Capital is currently hiring! juliacon-2025-78193-meet-and-greet-with-temple-capital General en Enjoy a meet and greet with Temple Capital, Diamond Sponsor of JuliaCon 2025. Temple Capital is currently hiring! false https://pretalx.com/juliacon-2025/talk/T9VQTD/ https://pretalx.com/juliacon-2025/talk/T9VQTD/feedback/ Lawrence Room 104 - Function Room Talk 2025-07-24T13:30:00-04:00 13:30 00:30 Julia's dynamism, extensive specialization, and metaprogramming make it uniquely suited to express sparse and graph algorithms. In this talk, we will cover a few graph algorithms implemented in Julia, showcasing the suitability of Julia for graph algorithms. We will particularly focus on a fun dataset of the package dependency graph in the Julia ecosystem. We will use graph algorithms implemented in Julia... to better understand the Julia ecosystem. juliacon-2025-70609-the-graph-of-julia Sparse & Graph Computing in Julia Huda en Julia's dynamism, extensive specialization, and metaprogramming make it uniquely suited to express sparse and graph algorithms. In this talk, we will cover a few graph algorithms implemented in Julia, showcasing the suitability of Julia for graph algorithms. We will particularly focus on a fun dataset of the package dependency graph in the Julia ecosystem. We will use graph algorithms implemented in Julia... to better understand the Julia ecosystem. false https://pretalx.com/juliacon-2025/talk/WMZ3FC/ https://pretalx.com/juliacon-2025/talk/WMZ3FC/feedback/ Lawrence Room 104 - Function Room Talk 2025-07-24T14:00:00-04:00 14:00 00:30 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. juliacon-2025-70610-going-beyond-graphs-simplicial-hyper-and-relational-structure Sparse & Graph Computing in Julia James Fairbanks en 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. We will also discuss techniques for exploiting structure in these relational models with CliqueTrees.jl and StructuredDecompositions.jl. These packages support the development of dynamic programming algorithms for structured data by generalizing the *tree decompositions* widely used in theoretical computer science and graph theory. false https://pretalx.com/juliacon-2025/talk/RB9NXR/ https://pretalx.com/juliacon-2025/talk/RB9NXR/feedback/ Lawrence Room 104 - Function Room Talk 2025-07-24T14:30:00-04:00 14:30 00:30 Finch is a Julia-to-Julia compiler which adapts array programs to the sparsity and structure of data automatically. Finch understands array structure through a language of basic loop building blocks called Looplets. This enables new loop optimizations across multiple domains, unifying techniques such as sparse tensors, geometric programming, databases, and lossless compression. juliacon-2025-64710-finch-jl-flexible-and-efficient-sparse-tensor-programming Sparse & Graph Computing in Julia /media/juliacon-2025/submissions/QEXFHD/logo_PL8EoSM.png Willow Marie Ahrens en Multidimensional tensor programming, popularized by frameworks like Numpy or Tensorflow, have revolutionized how we express computation. Sparse tensors represent tensors which are mostly zero, such as graphs, meshes, or pruned neural networks. Unlike dense tensors, support for sparse tensors is fragmented and incomplete. Sparse performance depends on a complex set of factors, including datastructures, fused operations, and the sparsity patterns of the inputs at runtime. Existing frameworks struggle to support and navigate the wide variety of possible implementations. In this talk, we introduce Finch, a state-of-the-art sparse tensor framework for flexible and efficient sparse tensor programming. Finch leverages compiler technology to automatically generate customized, fused sparse kernels for each specific use case. This allows users to write readable, high-level sparse array programs without worrying about the performance of the generated code. Finch can automatically generate efficient implementations even for unique problems that lack existing library solutions. This talk will describe how to use Finch, detailing some of it's main features: - Finch supports most major sparse formats (CSR, CSC, DCSR, DCSC, CSF, COO, Hash, Bytemap). Finch also allows users to define their own sparse formats with a parameterized format language. - Finch supports many high-level array operations out of the box, such as `+`, `*`, `maximum`, `sum`, `map`, `broadcast`, and `reduce`. - Finch supports an @einsum syntax for more complex custom operations - Finch allows users to easily fuse multiple operations into a single kernel with a simple interface. Since zeros allow us to prune computations in other expressions, fusion is a critical optimization for sparse computing. - Different optimizers can be used to fuse programs, such as the state-of-the-art Galley optimizer, which adapts to the sparsity patterns of the inputs at runtime. This talk will also give a brief overview of how Finch works. Under the hood, Finch uses a language of basic loop building blocks called Looplets to hierarchically decompose structured sparsity and generate efficient code. Links: [Finch.jl](https://github.com/finch-tensor/Finch.jl) [finch-tensor-python](https://github.com/finch-tensor/finch-tensor-python) [Looplets Paper](https://dl.acm.org/doi/10.1145/3579990.3580020) [Finch Paper](https://arxiv.org/abs/2404.16730) false https://pretalx.com/juliacon-2025/talk/QEXFHD/ https://pretalx.com/juliacon-2025/talk/QEXFHD/feedback/ Lawrence Room 104 - Function Room Lightning talk 2025-07-24T15:00:00-04:00 15:00 00:15 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. juliacon-2025-70613-graphblas-and-sparse-computation-on-gpus-limits-and-progress Sparse & Graph Computing in Julia Antoine Buttier en GraphBLAS is an API specification that aims to "define standard building blocks for graph algorithms in the language of linear algebra"(https://graphblas.org). A full implementation of the GraphBLAS API allows users to write a wide range of graph algorithms (from Breadth-First-Search to the Coloring problem) using the relationship between graph manipulation and linear algebra operations on the graph's adjacency matrix. In this lightning talk, we will go over the main challenges encountered when building a sparse linear algebra framework on GPU, in particular when trying to implement the GraphBLAS API. **High memory to computation ratio** Sparse linear algebra functions are typically "memory-bound". In other words, there is a lot of data to read from memory, and very little computation to be done with each piece of data. These kind of function can be hard to efficiently adapt on GPUs as they can be "bottlenecked" by the GPUs memory bandwidth, and not fully use the GPU's large computing capacity. **Load balancing** Basic methods to parallelize sparse linear algebra operations will divide the workload on the matrix by "splitting" the matrix by rows or by columns. Consequently, if the distribution of non-zero elements in the matrix is not uniform across rows or columns, the workload of some threads will be higher than others, which can harm performances. This is a real problem for GPUs, as a lot of real-word applications have a high heterogeneity in non-zero distribution. **Modularity** The GraphBLAS API can be hard to bring to GPUs as it requires allowing the users to supply any custom operator to perform matrix-vector multiplication. While implementing custom kernels for every combination of supported operators could work, this can quickly spin out of control. Large codebases like this are hard to develop and maintain in addition to being more error-prone. Up to now, we focused on the Modularity problem. To tackle it, we leverage some of the work previously done but the JuliaGPU community, in particular KernelAbstractions.jl. This allows us to write modular kernels parametrized on the user-supplied operators. These "high-level" kernels are then re-compiled Just-In-Time when called with new operators to generate efficient and specific low-level kernels. false https://pretalx.com/juliacon-2025/talk/YHEHZV/ https://pretalx.com/juliacon-2025/talk/YHEHZV/feedback/ Lawrence Room 104 - Function Room Lightning talk 2025-07-24T15:15:00-04:00 15:15 00:15 Sparse matrices and tensors are ubiquitous throughout multiple subfields of computing. The widespread usage of sparse data has inspired a multitude of in-memory and on-disk storage formats, but the only widely adopted storage specifications are the Matrix Market and FROSTT file formats, which are both ASCII text-based. juliacon-2025-70616-binsparse-a-specification-for-cross-platform-storage-of-sparse Sparse & Graph Computing in Julia Willow Marie Ahrens en Sparse matrices and tensors are ubiquitous throughout multiple subfields of computing. The widespread usage of sparse data has inspired a multitude of in-memory and on-disk storage formats, but the only widely adopted storage specifications are the Matrix Market and FROSTT file formats, which are both ASCII text-based. Due to the inefficiency of text storage, these files typically have larger file sizes and longer parsing times than binary storage formats, which directly store an in-memory representation to disk. This can be a major bottleneck; since sparse computation is often bandwidth-bound, the cost of loading or storing a matrix to disk often exceeds the cost of performing a sparse computation. While it is common practice for practitioners to develop their own, custom, non-portable binary formats for high-performance sparse matrix storage, there is currently no cross-platform binary sparse matrix storage format. In this paper, we present Binsparse, a cross-platform binary sparse matrix and tensor format specification. Binsparse is a modular, embeddable format, consisting of a JSON descriptor, which describes the matrix or tensor dimensions, type, and format, and a series of binary arrays, which can be stored in all modern binary containers, such as HDF5, Zarr, or NPZ. We provide several reference implementations of Binsparse spanning 5 languages, 5 frameworks, and 4 binary containers. We evaluate our Binsparse format on every matrix in the SuiteSparse Matrix Collection and a selection of tensors from the FROSTT collection. The Binsparse HDF5 CSR format shows file size reductions of 2.4x on average without compression and 7.5x with compression. We evaluate our parser's read/write performance against a state-of-the-art Matrix Market parser, demonstrating warm cache mean read speedups of 26.5x without compression and 2.6x with compression, and write speedups of 31x without compression and 1.4x with compression. false https://pretalx.com/juliacon-2025/talk/C8HB7P/ https://pretalx.com/juliacon-2025/talk/C8HB7P/feedback/ Lawrence Room 104 - Function Room Talk 2025-07-24T15:30:00-04:00 15:30 00:30 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++. juliacon-2025-70617-sparse-blas-developing-a-c-interface Sparse & Graph Computing in Julia Ben Brock en Sparse linear algebra libraries are an important tool for sparse application developers and practitioners. Currently, most applications are implemented directly using vendor-specific libraries such as cuSPARSE and MKL. While vendor libraries provide high performance, they require users to write separate implementations to run on different platforms. In this talk, I will discuss recent efforts in developing a Sparse BLAS interface in C++ as well as our efforts to develop a reference implementation. I will discuss both design decisions that allow vendor-optimized backends to apply optimizations as well as efforts developing a high-level C++ reference implementation using the ranges library, to build patterns for structured iteration. false https://pretalx.com/juliacon-2025/talk/AZVLYD/ https://pretalx.com/juliacon-2025/talk/AZVLYD/feedback/ Lawrence Room 104 - Function Room Poster 2025-07-24T18:00:00-04:00 18:00 00:30 We present a Julia-based machine learning pipeline for sleep stage classification using the DREAMT wearable-PSG paired dataset. Our models, leveraging features from the Empatica E4 wristband, achieve AUC up to 0.92 in Wake/NREM/REM stage classification, with Random Forests matching Python benchmarks. Results establish Julia as a viable platform for biosignal processing and sleep research. juliacon-2025-63946-sleep-stage-classification-in-julia General Shaurya Bisht en Sleep is essential for physical and cognitive well-being, yet disorders like insomnia and sleep apnea frequently go undiagnosed. The current clinical standard for detecting sleep stages, polysomnography (PSG), is accurate but resource-intensive, requiring complex sensor setups and manual annotations. Recent advances in wearable technology and machine learning provide a promising alternative by enabling more scalable and passive sleep monitoring. However, most work in this area is conducted in Python, with limited exploration of Julia, a high-performance language suited for scientific computing. This study presents a full machine learning pipeline for classifying sleep into three broad stages, Wake, NREM, and REM, using wearable-derived data, entirely implemented in Julia. We use the DREAMT dataset, which includes synchronized PSG and wristband signals (BVP, EDA, skin temperature, accelerometry) from 100 subjects. Standard signal preprocessing and feature extraction techniques were applied, and class imbalance was addressed using SMOTE, implemented in Julia. We trained three models: Logistic Regression, LASSO Regression, and Random Forests, using leave-one-subject-out cross-validation to evaluate generalizability. The Random Forest model achieved the best overall performance, reaching an AUC of 0.92 and F1-scores of 0.88 (Wake), 0.87 (NREM), and 0.83 (REM), comparable to existing Python-based pipelines. LASSO provided useful feature interpretability, highlighting the importance of heart rate variability, movement, and circadian trends. REM was the most difficult stage to distinguish, likely due to its autonomic overlap with wake periods. Julia’s performance proved comparable or superior in runtime efficiency for key steps such as cross-validation and numerical processing. To our knowledge, this is the first end-to-end wearable-based sleep classification study conducted in Julia. Beyond benchmarking Julia’s feasibility in biosignal analysis, our work offers a reusable template for health researchers and developers seeking alternatives to Python. Future work includes deep learning implementation via Flux.jl and tailoring models for personalized sleep tracking. false https://pretalx.com/juliacon-2025/talk/X3YJAS/ https://pretalx.com/juliacon-2025/talk/X3YJAS/feedback/ Cathedral Room G24 - If Room Talk 2025-07-24T10:00:00-04:00 10:00 00:30 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. juliacon-2025-65037-synchronous-systems-in-modelingtoolkit General Benjamin Chung en ModelingToolkit makes the development of continuous-time models easy. However, many practical applications require adding discrete behavior to the continuous-time model such as friction (stuck vs. un-stuck) or clutches (open, closing, or closed). Similarly, digital control systems are intrinsically periodic and discrete. Capturing this discrete behavior in ModelingToolkit is primarily done with imperative affects and manually-written functions, which offers little compositionality and makes reuse of components across projects hard. We describe the integration of synchronous systems into ModelingToolkit, building of off of systems such as Lustre and Lucid Synchrone, allowing discrete behaviour to be described as algebraic clocked discrete-time components. Synchronous components can be composed using connectors or invocations - much like the existing continuous-time components - and are compiled to efficient imperative code. Synchronous programming allows the easy development of compositional discrete-time systems as both standalone systems or into continuous-time models in ModelingToolkit. false https://pretalx.com/juliacon-2025/talk/BVKRQS/ https://pretalx.com/juliacon-2025/talk/BVKRQS/feedback/ Cathedral Room G24 - If Room Talk 2025-07-24T10:30:00-04:00 10:30 00:30 `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. juliacon-2025-63903-functionfusion-jl-the-algorithm-composition-framework General Yury Nuzhdin en Julia shine as a common programming language connecting research teams with engineering teams deploying algorithms in production environment. But besides single programming language, we also need a single domain language which will connect teams with very distant concerns and goals to create single product. `FunctionFusion.jl` allows engineers to focus on describing the algorithms they making by decomposing them in smaller parts and assembling large algorithms from those parts. From architecture point of view this encourages concise functions with narrow responsibilities and without side effects, making them testable and reusable. The other big challenge is to cover the gap between production and development environment - if you can't read real sensor on the developers laptop you need some way to provide the results, but how to make sure that on the real machine you will run same code that you were studying? `FunctionFusion.jl` allows to replace computational blocks in the algorithm, so you don't have to prove that the whole algorithm is working same way in production and development environment. Last but not least is the performance. `FunctionFusion` generates static algorithms which are optimized for the Julia. It enables Julia inference system to optimize code as if it would be hand written, literally producing the same assembly code as it would be for the hand written functions. false https://pretalx.com/juliacon-2025/talk/GMDWKH/ https://pretalx.com/juliacon-2025/talk/GMDWKH/feedback/ Cathedral Room G24 - If Room Lightning talk 2025-07-24T11:10:00-04:00 11:10 00:10 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. juliacon-2025-63551-interfacing-julia-with-kerbal-space-program-using-krpc-jl General Benjamin Chung en Kerbal Space Program (KSP) is a fun way to design and fly rockets, but is very human-input-focused. Several mods, including KOS and KRPC, allow users to write external software that interfaces with the world of and rockets in KSP. I implemented an interface library from Julia for KRPC called KRPC.jl, allowing Julia to control the game in both physically accurate (by adjusting controls) and cheaty (by directly manipulating game state) ways with a friendly Julia Interface. I'll talk about the library, its implementation, and illustrate its use with an aerodynamic characterization script and a closed loop controller/trajectory optimizer that's able to land a reusable launch vehicle in the game. false https://pretalx.com/juliacon-2025/talk/3YTQY7/ https://pretalx.com/juliacon-2025/talk/3YTQY7/feedback/ Cathedral Room G24 - If Room Lightning talk 2025-07-24T11:20:00-04:00 11:20 00:10 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! juliacon-2025-63327-adaptive-radau-methods-to-solve-ordinary-differential-equations Continued Advancements in Solving Differential Equations Shreyas Ekanathan en Radau methods are known to be state-of-the-art for the high-accuracy solution of highly stiff ordinary differential equations (ODEs). However, the traditional implementation was specialized to a specific ranges of precision and only derived in floating point, thus limiting the algorithm's ability to be truly general purpose for highly accurate scenarios. To alleviate these constraints, we implemented a fully adaptive Radau method that can derive the coefficients for the Radau method on the fly to any precision. Additionally, the Julia-based implementation includes many modernizations to improve performance, including improved linear algebra integrations and parallelization. In a head-to-head benchmark against the classic Fortran implementation, we demonstrate our implementation is approximately 2x faster across a range of stiff ODEs. We further benchmark our algorithm against several well-reputed numerical integrators for stiff ODEs and find state-of-the-art performance on several test problems, with a 1.5x speed-up over common numerical integrators for stiff ODEs when high precision is required. In this talk, we describe the overall scheme of numerical integrators before diving into some of the intricacies of Radau methods, including the beauty of utilizing of the complex plane to accelerate computations and the adaptive time-stepping and order-selection scheme. Prior experience with numerical integration or differential equation is not required! We will start from basic ideas about differential equations and work our way up. false https://pretalx.com/juliacon-2025/talk/RWCAJX/ https://pretalx.com/juliacon-2025/talk/RWCAJX/feedback/ Cathedral Room G24 - If Room Talk 2025-07-24T11:30:00-04:00 11:30 00:30 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. juliacon-2025-63203-efficient-boundary-value-problems-solving-in-sciml Continued Advancements in Solving Differential Equations Chris RackauckasQingyu Qu en Boundary value problems (BVPs) represent a critical and expansive class of differential equations that arise in various scientific fields, such as physics, economics, and many more. These problems typically involve finding a solution to a differential equation subject to certain specified values in some points among interval, known as boundary conditions. The efficiency and precision in solving these problems are important due to their widespread applications, ranging from modeling physical phenomena to optimizing engineering systems. BoundaryValueDiffEq.jl is part of the DifferentialEquations.jl ecosystem, known for its comprehensive suite of tools for solving differential equations. This package has been enriched with several state-of-the-art features, making it a powerful and robust solver for a variety of BVPs. BoundaryValueDiffEq.jl offers a bunch of fast solvers including fully-implicit solvers, Nystrom solvers, etc, and integrates several advanced features such as error control adaptivity, tailored sparse AD, etc. In this talk, we will explore the latest advancements in BoundaryValueDiffEq.jl, which have significantly enhanced the capabilities for solving boundary value problems. In summary, the ongoing development in BoundaryValueDiffEq.jl has transformed it into a versatile and robust tool for solving a wide array of boundary value problems with enhanced efficiency and precision. This talk will delve into the technical details of these new features, demonstrate their application through practical examples, and highlight the future directions of research and development in this vital area of scientific computing. false https://pretalx.com/juliacon-2025/talk/MYSEST/ https://pretalx.com/juliacon-2025/talk/MYSEST/feedback/ Cathedral Room G24 - If Room Talk 2025-07-24T13:20:00-04:00 13:20 00:30 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. juliacon-2025-64944-building-an-astronomy-code-for-vlbi-in-julia Julia in Astronomy & Astrophysics Research 2025 Paul Tiede en As Julia's use case in astronomy is increasing, it is essential to review successes and areas of improvement in the language. Specifically, I will discuss my experience in writing a rather large code, `Comrade` as well as the larger `EHTJulia` ecosystem that is poised to become the software stack for the Event Horizon Telescope (EHT) and future projects like the Black Hole Explorer (BHEX). The talk will discuss where Julia has enabled breakthrough science, including the first analysis of Sgr A*, images of M87* in 2018, and ongoing EHT analyses. I'll also discuss my experience convincing a larger astronomy organization to use Julia and teaching early career scientists how to use and contribute to this software. false https://pretalx.com/juliacon-2025/talk/NSZLHS/ https://pretalx.com/juliacon-2025/talk/NSZLHS/feedback/ Cathedral Room G24 - If Room Lightning talk 2025-07-24T13:50:00-04:00 13:50 00:10 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. juliacon-2025-66713-astrometry-jl-a-fundamental-julia-package-for-astronomy Julia in Astronomy & Astrophysics Research 2025 Paul Barrett en 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. For example, it enables users to perform barycentric corrections for the time, position and velocity of celestial objects. It reduces the number of functions in the International Astronomical Union's (IAU) Standards of Fundamental Astronomy (SOFA) library from 533 to no more than a few dozen. It also contains a sub-package that implements the complete set of SOFA functions in Julia. It is therefore a drop-in replacement for the Julia wrapped FORTRAN and C SOFA libraries. false https://pretalx.com/juliacon-2025/talk/SGJEKU/ https://pretalx.com/juliacon-2025/talk/SGJEKU/feedback/ Cathedral Room G24 - If Room Lightning talk 2025-07-24T14:00:00-04:00 14:00 00:10 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 Comrade.jl which performs MFS in a Bayesian framework. juliacon-2025-64997-bayesian-multifrequency-imaging-for-radio-astronomy Julia in Astronomy & Astrophysics Research 2025 Erandi Chavez en In this talk, I’ll present my contributions to the radio astronomy imaging package Comrade.jl which enables Multifrequency Synthesis in a Bayesian framework. Alongside presenting some scientific results using this technique, I’ll discuss my own experiences learning Julia as an astronomy graduate student. false https://pretalx.com/juliacon-2025/talk/BNCPT8/ https://pretalx.com/juliacon-2025/talk/BNCPT8/feedback/ Cathedral Room G24 - If Room Lightning talk 2025-07-24T14:10:00-04:00 14:10 00:10 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. juliacon-2025-65074-regularized-maximum-likelihood-methods-for-black-hole-imaging Julia in Astronomy & Astrophysics Research 2025 Andy Nilipour en This talk presents an implementation of regularized maximum likelihood (RML) imaging methods for radio interferometry, with the primary aim of imaging black holes with the Event Horizon Telescope (EHT) and its proposed successors, including the next-generation EHT and the Black Hole Explorer. While RML methods have been successfully utilized before, our package, VLBISkyRegularizers.jl, offers several advantages made possible by the Julia language. VLBISkyRegularizers.jl is an extension of Comrade.jl, a Bayesian imaging software that already speeds up black hole imaging by multiple orders of magnitude using key Julia features and Enzyme automatic differentiation. We add RML capabilities to this growing software library. In addition to popular spatial regularizers and novel polarization regularizers which are built into the package, users are able to define their own regularizers, with gradients automatically calculated via Enzyme. Bayesian methods made easy by Julia also allow for more exhaustive searches of the cost function compared to gradient descent methods. Within the larger EHT Julia Organization, simultaneous projects to perform multi-frequency imaging and dynamical imaging are paving the way for movies of black holes in multiple frequencies. Utilizing the composability of Julia, we will be able to perform spatio-temporal-spectral imaging in Bayesian and RML frameworks. While primarily developed for imaging black holes, these packages are widely applicable to radio interferometry on larger arrays as well. false https://pretalx.com/juliacon-2025/talk/AYBT3G/ https://pretalx.com/juliacon-2025/talk/AYBT3G/feedback/ Cathedral Room G24 - If Room Talk 2025-07-24T14:20:00-04:00 14:20 00:30 The images of the shadows of M87 and SgrA* have produced an increased interest in the study of electromagnetic signatures around black holes. These images probe the near horizon region of black holes with unprecedented fidelity. I will present an gpu compatible raytracing code that can be used to model the emission from accretion flows around Kerr black holes. juliacon-2025-64131-krang-jl-physics-inference-from-images-of-black-holes Julia in Astronomy & Astrophysics Research 2025 /media/juliacon-2025/submissions/GCSQQC/Krang_6L6Ntw6.png Dominic Chang en Krang is a Julia package that implements efficient algorithms for raytracing emission geometries in the Kerr black hole space time. It is GPU compatible and is specialized for studies of sub-image contributions from gravitationally lensed sources. Such algorithms are of interest for modeling the sources seen by Very Long Baseline Interferometry (VLBI) observations of Low Luminosity Active Galactic Nuclei (LLAGN) such as those imaged by the Event Horizon Telescope Collaboration (EHTC). false https://pretalx.com/juliacon-2025/talk/GCSQQC/ https://pretalx.com/juliacon-2025/talk/GCSQQC/feedback/ Cathedral Room G24 - If Room Lightning talk 2025-07-24T14:50:00-04:00 14:50 00:10 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. juliacon-2025-63872-building-an-end-to-end-spectral-reduction-pipeline-for-apogee Julia in Astronomy & Astrophysics Research 2025 Andrew Saydjari en As we move deeper into the “big data astronomy” era, the need for fast, stable, homogenous data reduction pipelines is more pressing and the performance, extensibility, and readability of Julia makes it a good candidate for astronomical pipelines. This talk will focus on recent efforts within the Sloan Digital Sky Survey that have led to a new pure Julia pipeline. First, I will outline implementations of both old and new methods for conventional analyses of near-infrared detectors: including non-destructive readout (SUTR), 1/f noise correction, pixel response calibrations (flats/darks), trace extraction, and wavelength calibration. Then, I will emphasize how the speed and simplicity of LinearAlgebra in Julia facilitates Bayesian component separation on large data volumes of spectra, which allows us to avoid conventional sky “subtraction,” instead jointly modeling all of the components contributing to the spectra. false https://pretalx.com/juliacon-2025/talk/HYYXTA/ https://pretalx.com/juliacon-2025/talk/HYYXTA/feedback/ Cathedral Room G24 - If Room Lightning talk 2025-07-24T15:00:00-04:00 15:00 00:10 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. juliacon-2025-65045-juggling-astro-catalogs-in-julia-convenience-meets-performance Julia in Astronomy & Astrophysics Research 2025 Alexander (Sasha) Plavin en Astronomy and astrophysics frequently involve using surveys, catalogs, or archival data from various sources. Observational data spans different wavelengths, times, and observatories - a wide range of sizes and access modes, local or online. In this talk, I will showcase the relevant building blocks available in Julia, and demonstrate how they work together. The power of Julia facilitates key packages at every step working together: from coordinates and their uncertainties (SkyCoords.jl, Uncertain.jl), to querying and matching catalogs (VirtualObservatory.jl, FlexiJoins.jl), to combining them with images (SkyImages.jl), plotting (Makie.jl) and analyzing the results. Heavy use of multiple dispatch enables a uniform syntax to operate on in-memory datasets, local files, and remote Virtual Observatory services. In addition to highlighting existing packages and their interoperability, I'll touch on niches that could use more integrations for common tasks. false https://pretalx.com/juliacon-2025/talk/TUXFSL/ https://pretalx.com/juliacon-2025/talk/TUXFSL/feedback/ Cathedral Room G24 - If Room Talk 2025-07-24T15:20:00-04:00 15:20 00:40 We host an extended panel discussion of challenges and lessons learned from incorporating Julia into Astronomy & Astrophysics research projects. juliacon-2025-64978-panel-discussion-on-julia-in-astronomy-astrophysics-research Julia in Astronomy & Astrophysics Research 2025 Eric B. Ford en This session provides for an extended question and answer session from the symposium's speakers. Depending on the specific talks selected, we could invite some additional panelists to provide complementary areas of expertise. false https://pretalx.com/juliacon-2025/talk/EWRB37/ https://pretalx.com/juliacon-2025/talk/EWRB37/feedback/ Cathedral Room 324 - Else Room Lightning talk 2025-07-24T10:00:00-04:00 10:00 00:10 An update on the current state of TidierPlots, an implementation of ggplot2 in julia. juliacon-2025-62696-what-s-new-in-tidierplots-jl General Randall Boyes en This session will review the current state of development and current capabilities of TidierPlots. TidierPlots is a faithful re-implementation of R's ggplot2, and is part of the Tidier set of julia packages that aim to implement R's tidyverse suite of packages for data analysis. false presentation slides https://pretalx.com/juliacon-2025/talk/QVFETB/ https://pretalx.com/juliacon-2025/talk/QVFETB/feedback/ Cathedral Room 324 - Else Room Talk 2025-07-24T10:20:00-04:00 10:20 00:30 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. juliacon-2025-63565-interfaces-for-streaming-and-chunked-compression The State and Future of Julia I/O Nathan Zimmerberg en I will also briefly describe how to use the high-level functions, discuss how to add support for a new format, and how these interfaces could work with the new IO interface. false https://pretalx.com/juliacon-2025/talk/ZBYAZE/ https://pretalx.com/juliacon-2025/talk/ZBYAZE/feedback/ Cathedral Room 324 - Else Room Talk 2025-07-24T10:50:00-04:00 10:50 00:30 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! juliacon-2025-64792-cancellation-aka-the-big-red-button The State and Future of Julia I/O Julian P Samaroo en Runaway code is familiar to all - maybe due to programmer error, user error, or just a little cosmic bit flip - the result is that the user can't do what they want to do, and so they need to wrestle back control of their system. Everyone knows about the wonders of Ctrl-C and how it can save a session from an infinite descent into madness, but not everyone realizes the lasting damage that Ctrl-C can cause. Memory corruption, segfaults, unexpected behavior - these are just some of the terrible things that can happen to a Julia session which has been sent a Ctrl-C interrupt. But there is a better way! In this session, we'll discuss what Ctrl-C does in simple terms, and why that is really not always what we really want it to do. We'll then learn about cancellation, how it's used to make code robust to failures and runaway code, and how it can be used to build more bulletproof libraries and applications. We'll also cover the downsides of cancellation, and how some of these downsides can be mitigated with good interface design. false https://pretalx.com/juliacon-2025/talk/FK3EZL/ https://pretalx.com/juliacon-2025/talk/FK3EZL/feedback/ Cathedral Room 324 - Else Room Lightning talk 2025-07-24T11:20:00-04:00 11:20 00:10 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. juliacon-2025-71227-static-compilation-and-i-o-vignettes-using-trim-with-hdf5 The State and Future of Julia I/O Gabriel Baraldi en 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. In particular, vignettes on this has impacted HDF5 and JSON based I/O will be presented. false https://pretalx.com/juliacon-2025/talk/R87WRJ/ https://pretalx.com/juliacon-2025/talk/R87WRJ/feedback/ Cathedral Room 324 - Else Room Talk 2025-07-24T11:30:00-04:00 11:30 00:30 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. juliacon-2025-71220-julia-i-o-internals The State and Future of Julia I/O Jameson Nash en 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. false https://pretalx.com/juliacon-2025/talk/NVTUJA/ https://pretalx.com/juliacon-2025/talk/NVTUJA/feedback/ Cathedral Room 324 - Else Room Lightning talk 2025-07-24T13:30:00-04:00 13:30 00:10 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. juliacon-2025-65007-parameterestimation-jl-algebraic-parameter-estimation-in-odes General Oren Bassik en A typical approach to estimating parameters from experiments uses nonlinear optimization to search for parameters which minimize error against observed data. This inherits various difficulties from nonlinear optimization: the need for good initial guesses, getting stuck in local minima, and only finding a single solution. An algorithm in Bassik et al. [1] reduces the task of parameter estimation to solving an algebraic system by using baryrational interpolation to estimate derivatives. This method shows excellent performance on noise-free or synthetic data, but due to the reliance on interpolation degrades severely with even minimal measurement noise. To overcome this limitation, we replaced the baryrational interpolation with Gaussian Process Regression (GPR) and automatically learn the noise hyperparameter from the data. Tentative benchmarks show that this simple replacement significantly improves robustness to measurement noise in observed data. We have implemented new algorithms in Julia package ParameterEstimation.jl. We are currently developing a set of examples and benchmarks to demonstrate its applicability to realistic data with noise. During the presentation, we will demonstrate the use of the new algorithm using a simple example. If time permits, we plan to include a short demo to demonstrate the new capabilities of the packages. Parameter estimation is an important step of model design, so we expect that the talk would be of interest to practitioners in modeling and control. The github pages of the relevant packages: https://github.com/iliailmer/ParameterEstimation.jl https://github.com/orebas/ODEParameterEstimation (testing version) This work is a joint result by Oren Bassik, Alexander Demin, and Alexey Ovchinnikov. [1] Ovchinnikov A., Bassik O., Berman Y., Go S., Hong H., Ilmer I., Rackauckas C., Soto P., and Yap C. (2023). Robust Parameter Estimation for Rational Ordinary Differential Equations, preprint is available at https://arxiv.org/abs/2303.02159. false https://pretalx.com/juliacon-2025/talk/M38E9F/ https://pretalx.com/juliacon-2025/talk/M38E9F/feedback/ Cathedral Room 324 - Else Room Lightning talk 2025-07-24T13:40:00-04:00 13:40 00:10 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!) juliacon-2025-65042-tyler-jl-map-tiles-in-julia General Anshul Singhvi en 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. Tyler works primarily by loading pyramids of map tiles which come at different zoom levels. This is through the XYZ or Slippy standard. However, new developments mean that users can also use their own datasets, either via interpolators or directly via providing a pre-computed Gaussian pyramid from PyramidScheme.jl. In the talk, I'll break down the new features of Tyler - plotting in 3D cartesian space, plotting on the sphere and on the GeoAxis, and the new tile interface. I'll also show how you can hook into that interface for your own datasets or online providers, and how this interfaces with PyramidScheme.jl to seamlessly display huge user datasets. false https://pretalx.com/juliacon-2025/talk/TC3QHW/ https://pretalx.com/juliacon-2025/talk/TC3QHW/feedback/ Cathedral Room 324 - Else Room Lightning talk 2025-07-24T13:50:00-04:00 13:50 00:10 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. juliacon-2025-63894-dictarrays-jl-performant-type-unstable-collections General Alexander (Sasha) Plavin en Julia code often leverages `map` or `filter` for processing collections, performing well with containers that have concrete element types. Common tabular data structures include Vectors-of-NamedTuples for row-based storage and StructArrays for columnar storage. Yet, with a large number of columns, concretely typed collections become unwieldy for the compiler. DictArrays is an attempt to provide the same performant collection API Julia users know and love for type-unstable collections. Think of it like StructArrays, but with Dictionaries instead of NamedTuples. In this talk, I'll explore the design and the implementation strategy that ensure compilation speeds akin to Dictionaries or DataFrames while maintaining fast runtime performance for elementwise operations, like in Vectors or StructArrays. I'll also address fundamental challenges, current limitations, and potential future enhancements, inviting community feedback for further refinement. false https://pretalx.com/juliacon-2025/talk/BKGQFG/ https://pretalx.com/juliacon-2025/talk/BKGQFG/feedback/ Cathedral Room 324 - Else Room Talk 2025-07-24T14:00:00-04:00 14:00 00:30 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. juliacon-2025-63781-using-julia-for-advent-of-code Recreational Julia Mark Kittisopikul, Ph.D. en Using Julia to complete twenty-five days of Advent of Code programming puzzles is a fantastic experience given the nature of the Julia language and the Julia community. The Julia Programming Language provides an interactive read-evaluate-print-loop (REPL) interface while also being fast to execute using just-in-time (JIT) compilation based on LLVM. This allows Advent of Code participants to quickly experiment, interactively see partial results, and rapidly execute brute force solutions when needed. The language is backed by a vibrant community interested in both succinct and efficient solutions to these puzzles. Julia's wide array of features offers many benefits when solving Advent of Code puzzles. For example, operator overloading allows for the easy expression of unusual binary operators. Julia's metaprogramming capabilities allow for the representation of puzzles as domain-specific languages. The Julia standard library offers built-in linear algebra and mathematical capabilities when needed. Meanwhile, some of Julia's conventions add complexity to the puzzles. Julia is column-major and its standard Array type is one-based leading to potential transposition and off-by-one errors. Additionally, the standard library lacks facilities for certain kinds of common collections and functional tools. However, these difficulties can be overcome by judicious use of abstract arrays and the wide variety of available packages from the community. The Julia community is also highly competitive and eager to demonstrate both concise solutions and fast solutions. Many participants will discuss how to optimize solutions via community Zulip and Slack channels. The resulting solutions are often among the most succinct while the performance is competitive with the fastest programming languages. In the rare circumstance where this is not the case, the Julia community will often strive to understand why and seek improvements to the languages. I will share my experience of using Julia to solve all twenty-five days of Advent of Code puzzles over three of the last five years. I will highlight where Julia has shined, where Julia has stumbled, and how Julia has evolved over many years to improve the experience. Along the way, I will also highlight how Julia's technical features interact with competitve and recreational coding. For example, I will touch upon how the module namespace system can help the Advent of Code user stay organized while allowing reuse of code while needed. false https://pretalx.com/juliacon-2025/talk/DPBRHC/ https://pretalx.com/juliacon-2025/talk/DPBRHC/feedback/ Cathedral Room 324 - Else Room Talk 2025-07-24T14:30:00-04:00 14:30 00:30 [Nginx](https://nginx.org/) is a popular, high performance web server and reverse proxy. The [OpenResty](https://openresty.org/) 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. juliacon-2025-65080-julia-in-nginx Recreational Julia Nishanth H. Kottary en The OpenResty project, which combines the nginx web server with LuaJIT, is a very popular web platform for building web based applications like web gateways, proxies, web application firewalls (WAF) etc. The dynamic nature of the Lua programming language is what makes the system expressive and powerful. Since Julia is also capable of being embedded and JIT compiled, we came up with the idea of writing a Julia extension module for nginx. This enables us to use Julia and its vast library of packages inside nginx, replacing logic which would otherwise be written in Lua. In this talk we will go over the implementation of the nginx Julia C module and what I've learned while working on this. We will also take a look at some examples of using the julia plugin to do basic operations on HTTP requests and responses. false https://pretalx.com/juliacon-2025/talk/R3NKXZ/ https://pretalx.com/juliacon-2025/talk/R3NKXZ/feedback/ Cathedral Room 324 - Else Room Talk 2025-07-24T15:00:00-04:00 15:00 00:30 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. juliacon-2025-65056-explainable-teachable-code-golfed-pi-programs-in-julia Recreational Julia Gabriel Konar-Steenberg en The project — explainable, teachable, code golfed pi programs in many languages, but perhaps most successfully Julia — can be found here: https://www.gabrielks.com/projects/pi-golf . false https://pretalx.com/juliacon-2025/talk/RFCK73/ https://pretalx.com/juliacon-2025/talk/RFCK73/feedback/ Cathedral Room 324 - Else Room Lightning talk 2025-07-24T15:30:00-04:00 15:30 00:10 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. juliacon-2025-64956-space-invaders-a-new-repl-mode Recreational Julia Lilith Hafner en SpaceInvaders.jl provides a multi-level game of space invaders complete with a splash screen, game over screen, and even a you win screen, if you can find it :) And adding this as a repl mode with space as the trigger is a surprisingly non-disruptive way to make it available. This talk will include a demo, encourage folks to try the game, and showcase how easy it is to make a custom REPL mode. false https://pretalx.com/juliacon-2025/talk/BVWXJC/ https://pretalx.com/juliacon-2025/talk/BVWXJC/feedback/ Cathedral Room 324 - Else Room Lightning talk 2025-07-24T15:40:00-04:00 15:40 00:10 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. juliacon-2025-63745-nodariety-graphs-theories-and-graph-theory Recreational Julia Rachel C. Kurchin en I will tell the origin story and demonstrate some functionality of this silly little package that I made: https://github.com/rkurchin/Nodariety.jl NB: I do not guarantee that this is not broken as of submission; I promise I will fix any broken dependencies by JuliaCon ;) false https://pretalx.com/juliacon-2025/talk/QVQP9A/ https://pretalx.com/juliacon-2025/talk/QVQP9A/feedback/ Lawrence Room 107 - Method Room Talk 2025-07-24T10:00:00-04:00 10:00 00:30 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. juliacon-2025-61870-manifolds-in-numerical-computations-with-juliamanifolds General /media/juliacon-2025/submissions/F98U7E/logo_text_light_gLQ4zrK.png Mateusz Baran en The following aspects of manifolds in numerical computing will be discussed in the talk: * New developments in [JuliaManifolds](https://github.com/JuliaManifolds) for robotics, including a work-in-progress library for geometric Kalman filters, focusing on affine connections. * Viability of [Manopt.jl](https://github.com/JuliaManifolds/Manopt.jl) as a general-purpose optimization framework. Highlights include comprehensive solver availability, ability to work with arbitrarily structured decision variables and performance. * Ongoing development of statistical tools on manifolds: both methods that work with manifold-valued data as well as methods that exploit manifold structure implicit in the problem, with examples such as robust principal component analysis. Rapid prototyping of advanced optimization-based models. * Perspectives of new developments: stratification as a tool for mixing continuous and discrete data, manifolds with corners for more expressive constraints. The talk only assumes basic knowledge of linear algebra, multivariate calculus and ordinary differential equations. false https://pretalx.com/juliacon-2025/talk/F98U7E/ https://pretalx.com/juliacon-2025/talk/F98U7E/feedback/ Lawrence Room 107 - Method Room Talk 2025-07-24T10:30:00-04:00 10:30 00:30 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](https://juliamanifolds.github.io/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. juliacon-2025-62297-groups-and-smooth-geometry-using-liegroups-jl General /media/juliacon-2025/submissions/JWTZWL/logo_text_readme_LQln1Dp.png Ronny Bergmann en [Lie groups](https://en.wikipedia.org/wiki/Lie_group) are a tool to work with groups, namely they are a [manifold](https://en.wikipedia.org/wiki/Differentiable_manifold) equipped with a smooth group operation. In practice these appear when dealing with rotations on a Euclidean space, the set of translations and rotations, or so-called symplectic matrices in Hamiltonian systems. A main challenge is that these spaces are nonlinear. For example, adding two rotation matrices does usually not yield a rotation matrix. It also requires some additional tools to for example talk about what a “direction” is, for example in optimisation, when looking for a descent direction in order to find a minimizer of a function defined on a Lie group. In this talk we introduce the package [LieGroups.jl](https://juliamanifolds.github.io/LieGroups.jl/) to perform numerical operations on and with Lie groups, for example in state estimation in robotics. We first give a gentle introduction into Lie groups and Lie algebras, we discuss the main features of the package, which are * an interface to define Lie groups based on manifolds defined in [Manifolds.jl](https://juliamanifolds.github.io/Manifolds.jl/stable/) * an interface for Lie algebras, especially employing its vector space structure * the main tools to define and work with Lie groups * a library of Lie groups and an overview of features available The slides are available at [ronnybergmann.net/talks/2025-LieGroups-JuliaCon.pdf](https://ronnybergmann.net/talks/2025-LieGroups-JuliaCon.pdf) false https://pretalx.com/juliacon-2025/talk/JWTZWL/ https://pretalx.com/juliacon-2025/talk/JWTZWL/feedback/ Lawrence Room 107 - Method Room Talk 2025-07-24T11:00:00-04:00 11:00 00:30 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. juliacon-2025-64840-rational-function-approximation-in-julia General /media/juliacon-2025/submissions/NMBHGN/slit_source_p1jvUqF.png Toby Driscoll en Approximation of functions is an enabling technology for scientific computing. The Julia ecosystem has excellent options for approximation in packages such as Interpolations for piecewise polynomials and ApproxFun for global polynomials. Approximation by rational functions is perhaps the most fruitful known nonlinear approximation method, with theoretical and constructive interest stretching back centuries. Unlike polynomial approximation, rational approximation is not constrained in principle by an accuracy–stability tradeoff. It is also well established that the poles of rational interpolants can give root-exponential convergence even to functions with branch cuts. Recent developments of the AAA and greedy Thiele algorithms have sparked renewed interest in computational rational approximation. The RationalFunctionApproximation package supplies the fastest known versions of these methods and the only arbitrary-precision implementations. Combined with the ComplexRegions package, we can produce compact and accurate representations of a huge variety of functions over intervals or other domains in the complex plane. false https://pretalx.com/juliacon-2025/talk/NMBHGN/ https://pretalx.com/juliacon-2025/talk/NMBHGN/feedback/ Lawrence Room 107 - Method Room Talk 2025-07-24T11:30:00-04:00 11:30 00:30 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. juliacon-2025-63775-non-abelian-symmetries-in-the-itensor-software-library Quantum Minisymposium Olivier Gauthé en Tensor network methods are a set of numerical algorithms designed to study strongly correlated systems in condensed matter and high energy physics. They aim to construct efficient low-rank approximations of high dimensional objects such as quantum wavefunctions and produce state of the art results in many-body physics. ITensors.jl is a Julia library dedicated to tensor network computations. It is designed to provide easy access to powerful tensor network algorithms with a high level interface accessible to non experts. As many physical systems of interest exhibit symmetries, such as translation invariance or SU(2) spin symmetry, it is natural to make use of these symmetries inside tensor networks algorithm. Indeed, they can be encoded directly at the level of the tensor in order to enforce constraints on the ansatz as well as to dramatically improve performances. Implementing abelian symmetries is relatively straightforward and already available in ITensor or other tensor libraries, however a generic implementation of non-abelian symmetries is much more challenging. It requires to define a complex internal structure for each tensor as well as the tools needed to modify this internal structure. Using the framework of representation theory, every leg in the tensor network is associated with a representation of a given symmetry group G. A symmetric tensor is defined as a tensor invariant under the action of a G on each of its legs. Such a constraint on a tensor allows for a decomposition between a multiplicity part and a structural part. The latter is entirely determined by the group and allows one to store and manipulate the multiplicity part only without any loss of information, leading to significant performance gains. In this talk, we detail the algorithms used to encode non-abelian symmetries in tensor networks and discuss their implementation in the ITensors.jl software library. false https://pretalx.com/juliacon-2025/talk/UQCRZD/ https://pretalx.com/juliacon-2025/talk/UQCRZD/feedback/ Lawrence Room 107 - Method Room Talk 2025-07-24T13:30:00-04:00 13:30 00:30 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. juliacon-2025-64872-tagging-querying-and-synchronization-in-quantumsavory-jl Quantum Minisymposium Hana Kimlee en QuantumSavory.jl is an ongoing project by the NSF Center for Quantum Networks, developed to bridge the gap between the field’s growing hype and the lack of robust full-stack tools with well-defined abstractions. A key focus of our design is the “classical control” metadata framework, which enables efficient tracking of network status and classical control messages, facilitates metadata queries, and supports asynchronous waiting for trigger events in quantum networks. This mechanism is crucial for managing time-dependent processes and communications in classical control channels. To achieve this, we leverage the ConcurrentSim and ResumableFunctions packages, enabling efficient coroutine-based discrete-event simulation and seamless synchronization between protocols running in parallel. In this talk, we detail our metadata tracking approach and demonstrate its use in applications such as purification protocols, measurement-based quantum computing, and quantum sensing. false https://pretalx.com/juliacon-2025/talk/X9BNKD/ https://pretalx.com/juliacon-2025/talk/X9BNKD/feedback/ Lawrence Room 107 - Method Room Talk 2025-07-24T14:00:00-04:00 14:00 00:30 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. juliacon-2025-63259-quantum-many-body-simulations-with-paulistrings-jl Quantum Minisymposium /media/juliacon-2025/submissions/ACSJEM/logo_vqyvwLt.svg Nicolas Loizeau en PauliStrings.jl provides a competitive platform for studying quantum many-body dynamics by representing operators as sets of Pauli strings encoded in binary. We show how this encoding can be advantageous for numerical simulation of quantum dynamics. The advantage arises from two key features: (i) The Pauli string algebra is encoded in low-level logic operations on integers, making it very efficient to numerically store and multiply strings together. (ii) Operators can be systematically truncated to some precision by discarding strings with negligibly small weight. This allows one to keep the number of strings manageable at the cost of some incurred error. We will present examples of this for Heisenberg time evolution and Krylov subspace expansion through the recursion method. One of the important strengths of Pauli strings is that they provide a natural framework to take advantage of noise to make simulations tractable. In addition, though tensor network methods quickly break down with increasing long-range entanglement, some systems with this type of entanglement can still be decomposed into a small number of strings, making Pauli strings more efficient for these kinds of systems. Furthermore, Pauli string methods are not as limited in spatial dimension and geometry, and arbitrary geometries are easy to implement. Currently, the main limitations are the inefficiency of representing non-trivial pure states (or other low-rank operators), as well as the need to introduce dissipation to probe long-time dynamics. PauliStrings.jl is easily installable through the Julia language package manager, and thorough code examples can be found in the documentation. false https://pretalx.com/juliacon-2025/talk/ACSJEM/ https://pretalx.com/juliacon-2025/talk/ACSJEM/feedback/ Lawrence Room 107 - Method Room Talk 2025-07-24T14:30:00-04:00 14:30 00:30 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. juliacon-2025-64836-quasar-jl-a-pure-julia-parser-for-openqasm-3 Quantum Minisymposium Katharine Hyatt en Quasar.jl is a new, purely Julia package for parsing OpenQASM 3 and outputting circuit instructions which can be executed on real quantum hardware or simulators. In this talk, I will explain the motivation for developing the package, which addresses a long-standing community need, discuss design choices made when writing it, show some usage examples for both simple and more complex quantum programs, and discuss ongoing pain points in the package itself. false Slides https://pretalx.com/juliacon-2025/talk/PJWRU8/ https://pretalx.com/juliacon-2025/talk/PJWRU8/feedback/ Lawrence Room 107 - Method Room Talk 2025-07-24T15:00:00-04:00 15:00 00:30 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. juliacon-2025-63603-optimization-of-quantum-repeater-networks-using-stochastic-ad Quantum Minisymposium /media/juliacon-2025/submissions/3MX9ZR/solution_four_repeater_Uk2NID0.png Guus Avis en Future quantum networks are envisioned to create entanglement between end nodes using intermediate nodes called quantum repeaters. However, before useful real-world quantum repeaters can be constructed, major breakthroughs are required both in the engineering of quantum devices and in understanding how to configure those devices. Over the last few years, Monte Carlo simulations have rapidly become one of the most important tools used to study quantum networks. They can be used to determine, given a specific hardware quality and device configuration, how good a network would be. However, they struggle to provide meaningful information about how hardware should be improved and how devices should be configured to build the best quantum networks as soon as possible. In this talk, which is based on our paper titled “Optimization of Quantum-Repeater Networks using Stochastic Automatic Differentiation”, we discuss how to overcome this problem using a recent technique from machine learning called stochastic automatic differentiation (stochastic AD). Stochastic AD provides a framework for automatic differentiation that is compatible with discrete random programs, allowing the extraction of derivative estimates that are both accurate and precise, something that is notoriously difficult in the presence of discrete randomness. As quantum networks are rife with discrete randomness, their simulations are discrete random programs. Therefore, Stochastic AD can be used to extract derivative information that directly reveals the most crucial hardware parameters and can be used to optimize networks using gradient-based optimization techniques. We have created an open-source Julia package (QuantumNetworkRecipes.jl) that implements Monte Carlo simulations of quantum repeaters in a way that is compatible with StochasticAD.jl, the first and currently only implementation of stochastic AD. We use this package to provide concrete examples of how useful a repeater simulation supercharged with stochastic AD can be, such as by efficiently tuning rate-fidelity trade-offs in a repeater chain through gradient descent and determining the most crucial parameters in a quantum network. As our most significant example we address the optimal placement of quantum repeaters in a 2D plane. We have developed an open-source Julia package (RepeaterPlacement.jl) to find optimal repeater locations using gradients obtained from QuantumNetworkRecipes.jl and StochasticAD.jl. This has allowed us to reveal an interesting case of spontaneous symmetry breaking and discover that, in the studied case, the required number of repeaters only scales with the square root of the total area of the network. We believe these examples demonstrate that integration of stochastic AD in quantum-network simulators could accelerate the research and development of functional quantum networks. false Paper that this talk is based on (arXiv). https://pretalx.com/juliacon-2025/talk/3MX9ZR/ https://pretalx.com/juliacon-2025/talk/3MX9ZR/feedback/ Lawrence Room 107 - Method Room Lightning talk 2025-07-24T15:30:00-04:00 15:30 00:10 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. juliacon-2025-64136-gausslets-molecular-hamiltonians-and-tensor-network-methods Quantum Minisymposium Casey Dowdle en Discretization of molecular Hamiltonians using a basis set is an important first step for numerically solving electronic structure problems in quantum chemistry. First proposed by Steven White, gausslets are constructed from wavelet transformations on gaussian functions. Compared to atomic basis sets, gausslets are highly localized. Due to their locality, they increase the sparsity of molecular Hamiltonians, which improves the computational scalability of tensor network methods in quantum chemistry. Specifically, they diagonalize the two-body interactions in the Hamiltonian, reducing the number of non-zero terms from O(N^4) to O(N^2). However, many more basis functions may be required to reach an accuracy comparable to atomic basis sets. We will show how Quiqbox.jl can both construct gausslets and augment them with atomic basis sets to reduce the overall basis set size while maintaining accuracy and two-body diagonalization. Since gausslets are constructed from gaussian functions, the analytical integral engine in Quiqbox.jl can still be utilized. By using Quiqbox.jl and iTensor.jl, we hope to demonstrate a pathway to exploring novel molecular Hamiltonian discretization methods in conjunction with tensor network methods for electronic structure problems. false https://pretalx.com/juliacon-2025/talk/NFYTSE/ https://pretalx.com/juliacon-2025/talk/NFYTSE/feedback/ Lawrence Room 107 - Method Room Lightning talk 2025-07-24T15:40:00-04:00 15:40 00:10 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. juliacon-2025-65087-qubo-jl Quantum Minisymposium /media/juliacon-2025/submissions/BY7RM7/qubo-logo_52Kfk2x.png Pedro Maciel Xavier en Quantum algorithms and devices are being developed by multiple participants in a diverse scientific environment. As potential applications of its products are considered, access to these resources is usually granted through each vendor's specific interface. This poses a barrier for incoming practitioners to experiment with new methods and compare platforms within a common practical scenario. With this in mind, QUBO.jl was developed to bridge the gap between emerging optimization methods and important industrial applications. On one side, JuMP (Julia Mathematical Programming) is extended to provide a common interface for multiple types of quantum and other physics-inspired solution methods in the same way that regular solvers are made available. This exempts interested experts from adapting to the specificities of each platform, especially if one considers that many already use JuMP daily. On the other hand, an extensive set of tools for automatically reformulating mathematical models into Quadratic Unconstrained Binary Optimization (QUBO) makes it possible for users to directly send more complex models they already use and are familiar with to quantum devices. In this talk, we would like to highlight the impact that such a tool has on the journey of the Operations Research community in adopting and prototyping quantum optimization applications. false https://pretalx.com/juliacon-2025/talk/BY7RM7/ https://pretalx.com/juliacon-2025/talk/BY7RM7/feedback/ Cathedral Room 332 - Let Room (Thursday only) Talk 2025-07-24T10:00:00-04:00 10:00 00:30 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. juliacon-2025-64990-lead-follow-or-get-out-of-the-way-julia-and-threaded-python General Katharine Hyatt en Although Julia aims to address the "two language problem" - using a high performance language like C, C++, or FORTRAN "under the hood" but writing interfaces in Python - user and institutional reluctance to embrace Julia means there's demand for Python wrappers around Julia packages. Python's threading model makes interoperability with Julia threads complex, and can hamstring performance of threaded Julia code. In this talk I will explain how and why these problems arise, some possible workarounds coming in Python, and how developers today can work around these pitfalls when creating Python wrappers for their high performance Julia code. Another goal of the talk is to stimulate discussion of what can be done in code our community controls (e.g. PythonCall.jl and juliacall) to make this easier for developers and wrapper writers. false Slides https://pretalx.com/juliacon-2025/talk/HU7YUZ/ https://pretalx.com/juliacon-2025/talk/HU7YUZ/feedback/ Cathedral Room 332 - Let Room (Thursday only) Lightning talk 2025-07-24T10:30:00-04:00 10:30 00:10 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. juliacon-2025-64976-mixedmodelssmallsample-jl-inference-adjustments General Arno Strouwen en Mixed effect regression models are statistical models that not only contain fixed effects but also random effects. Fixed effects are non-random quantities, while random effects are random variables. Both of these effects must be estimated from data. A popular method for estimating mixed models is restricted maximum likelihood (REML). Julia already has a state-of-the-art package, MixedModels.jl, for estimating these effects using REML. Inference for the effects is, however, based on large sample approximations or on bootstrapping. When working with a small sample, the asymptotic approximation might not hold, and the resampling in the bootstrapping procedure might make the model inestimable. Alternative small sample inference approaches have been suggested by Kenward and Roger [1] and by Fai and Cornelius [2]. In these methods, the asymptotic results for confidence intervals and hypothesis tests are adjusted to account for finite sample sizes. MixedModelsSmallSample.jl implements these small sample adjustments for models estimated by MixedModels.jl. These adjustment methods have already been incorporated in many statistical software programs, such as SAS, JMP and lmerTest [3-5]. These packages, however, differ in some statistical details. For example, SAS and JMP use the observed Fisher information matrix for variance components, while lmerTest uses the expected Fisher information matrix. MixedModelsSmallSample.jl provides user options to configure these technical details, such that results from SAS, JMP and lmerTest can be exactly reproduced and easily compared. The documentation of MixedModelsSmallSample.jl can be found on: https://arnostrouwen.github.io/MixedModelsSmallSample.jl/dev/ References: [1]: Kenward, Michael G., and James H. Roger. "Small sample inference for fixed effects from restricted maximum likelihood." Biometrics (1997): 983-997. [2]: Hrong-Tai Fai, Alex, and Paul L. Cornelius. "Approximate F-tests of multiple degree of freedom hypotheses in generalized least squares analyses of unbalanced split-plot experiments." Journal of statistical computation and simulation 54.4 (1996): 363-378. [3]: SAS Institute Inc. 2015. SAS/STAT® 14.1 User’s Guide: The MIXED Procedure. Cary, NC: SAS Institute Inc [4]: JMP Statistical Discovery LLC 2024. JMP ® 18 Fitting Linear Models. Cary, NC: JMP Statistical Discovery LLC [5]: Kuznetsova, Alexandra, Per B. Brockhoff, and Rune HB Christensen. "lmerTest package: tests in linear mixed effects models." Journal of statistical software 82 (2017): 1-26. false https://pretalx.com/juliacon-2025/talk/3WUUQT/ https://pretalx.com/juliacon-2025/talk/3WUUQT/feedback/ Cathedral Room 332 - Let Room (Thursday only) Lightning talk 2025-07-24T10:40:00-04:00 10:40 00:10 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 `TaskGroup`s: why we need them and what you can do with them. juliacon-2025-64255-taskgroups-reusable-worker-pools Multithreading in Julia Kiran Pamnany en At Relational AI, we have built a high-level multi-threading abstraction for our use: `TaskGroup`s. We will open source the code prior to JuliaCon and describe the abstraction in this talk. false https://pretalx.com/juliacon-2025/talk/KNS7RW/ https://pretalx.com/juliacon-2025/talk/KNS7RW/feedback/ Cathedral Room 332 - Let Room (Thursday only) Lightning talk 2025-07-24T10:50:00-04:00 10:50 00:10 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. juliacon-2025-65002-things-that-annoyed-me-about-multithreading-in-2024 Multithreading in Julia Katharine Hyatt en Julia's multithreading capabilities are one of its strongest features. However, there are still some pitfalls. Having written a library which needed efficient multithreading on a wide variety of hardware, I ran headfirst into several of these, including: - Scheduler churn with many small, short-lived Tasks - Frustration in partitioning work among threads - Nested dynamic threading works very well, until it doesn't I'll give some short examples of these problems in this presentation, as well as showing how I used tools like Intel's VTune to identify and try to work around them. Finally, I'll offer some feature suggestions to the minisymposium attendees with the view of spurring further development of Julia's very strong multithreading tools. false Slides https://pretalx.com/juliacon-2025/talk/RCUYNA/ https://pretalx.com/juliacon-2025/talk/RCUYNA/feedback/ Cathedral Room 332 - Let Room (Thursday only) Talk 2025-07-24T11:00:00-04:00 11:00 00:30 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` juliacon-2025-65031-ohmythreads-jl-user-friendly-flexible-multithreading-in-julia Multithreading in Julia Mason Protter en 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` false https://pretalx.com/juliacon-2025/talk/X9RRM9/ https://pretalx.com/juliacon-2025/talk/X9RRM9/feedback/ Cathedral Room 332 - Let Room (Thursday only) Talk 2025-07-24T11:30:00-04:00 11:30 00:30 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. juliacon-2025-64259-task-scheduling-and-fairness Multithreading in Julia Kiran Pamnany en In RAI's Julia build, we carry, among other patches, a one line patch that has a dramatic effect on scheduling fairness. In this talk, we will describe both the positives and the negatives of this patch. We will also discuss the fairness implications of a work-stealing scheduler, glance at where other languages have gone, and speculate on alternatives. false https://pretalx.com/juliacon-2025/talk/FQ7HUZ/ https://pretalx.com/juliacon-2025/talk/FQ7HUZ/feedback/ Cathedral Room 332 - Let Room (Thursday only) Talk 2025-07-24T13:30:00-04:00 13:30 00:30 Task based parallelism brings many advantages to Julia, the main one being that Tasks are lighter abstractions than OS threads. That is possible because we do the scheduling in user space, avoiding expensive context switches. None of this matters if the scheduler itself has poor performance. This year many improvements were made around an in it, so let's take a deep dive into what makes our scheduler work, how to write code that cooperates with it and how we've made it better. juliacon-2025-73740-improving-julia-s-scheduler-one-task-at-a-time Multithreading in Julia Gabriel Baraldi en Task based parallelism brings many advantages to Julia, the main one being that Tasks are lighter abstractions than OS threads. That is possible because we do the scheduling in user space, avoiding expensive context switches. None of this matters if the scheduler itself has poor performance. This year many improvements were made around an in it, so let's take a deep dive into what makes our scheduler work, how to write code that cooperates with it and how we've made it better. false https://pretalx.com/juliacon-2025/talk/RPZWTC/ https://pretalx.com/juliacon-2025/talk/RPZWTC/feedback/ Cathedral Room 332 - Let Room (Thursday only) Lightning talk 2025-07-24T14:00:00-04:00 14:00 00:10 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. juliacon-2025-65017-julia-chapel-interoperability General Luca Ferranti en 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. Both languages share a commitment to productivity and performance. Rather than competing, can they work together to extend each other's capabilities? The answer is yes and this talk will show how. The talk will first give a short overview of the Chapel programming language, focusing on its design strengths and similiarities and differences with Julia. The rest of the talk will then focus on interoperability between the two languages, showing how one can call Chapel code from Julia and Julia code from Chapel. false https://pretalx.com/juliacon-2025/talk/XKRPXC/ https://pretalx.com/juliacon-2025/talk/XKRPXC/feedback/ Cathedral Room 332 - Let Room (Thursday only) Lightning talk 2025-07-24T14:10:00-04:00 14:10 00:10 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. juliacon-2025-65047-using-arrays-as-lightweight-tables-base-and-datamanipulation-jl General Alexander (Sasha) Plavin en Base Julia provides foundational tools for data processing, such as map and filter. DataManipulation.jl, along with its companion packages, builds upon these by extending functionality: more general mapping, grouping, reshaping, pivoting, and more. These functions remain composable and support datasets represented as basic Julia collections – most commonly, arrays. Using simple data structures like arrays and tuples for data manipulation has numerous benefits. It leverages generic Julia functions, enhancing code readability and avoiding the focus on container-specific solutions. With the diversity of Julia array types, decisions on storage formats, such as row- or column-based, can be made independently of data pipeline design. Additionally, the collection interface is highly generic, enabling natural extensions beyond flat in-memory tables to nested structures and SQL tables. I'll also address some rough edges in the current landscape, such as missing functionalities or suboptimal performance in specific cases. Many of these issues are not intrinsic to the design and can be improved while maintaining generality and extensibility. false https://pretalx.com/juliacon-2025/talk/838EJA/ https://pretalx.com/juliacon-2025/talk/838EJA/feedback/ Cathedral Room 332 - Let Room (Thursday only) Lightning talk 2025-07-24T14:20:00-04:00 14:20 00:10 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. juliacon-2025-64961-basicautoloads-jl-when-i-type-this-in-the-repl-run-that-for-me General Lilith Hafner en By registering an autoload of, for example, `["@profile", "@testset"] => :(using Test)`, when you type `@test` or `@testset` in the REPL for the first time `Test` will be automatically loaded. This is great for loading dev-tool packages that provide unambiguous names. With a load time plus TTFX of only 12ms and no dependencies, this package is quite suitable for inclusion in startup.jl files. This talk will tell the story of how this package came to be, supplanting several individuals' home-rolled auto-loading scripts, explain and motivate design decisions, and demonstrate how one can quickly integrate this package into a workflow. Attendees will leave with a solid understanding of what BasicAutoloads has to offer; when it is helpful; what the costs of using it are; and, if they so choose, how to start using it in their workflows. false https://pretalx.com/juliacon-2025/talk/RXTVR9/ https://pretalx.com/juliacon-2025/talk/RXTVR9/feedback/ Cathedral Room 332 - Let Room (Thursday only) Birds of Feather (BoF) 2025-07-24T14:30:00-04:00 14:30 01:00 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. juliacon-2025-61414-chapel-julia General Luca FerrantiMichael Ferguson en The purpose of this Birds of a Feather (BoF) is to introduce Chapel to the Julia community. Both languages, while not directly competing, share some similarities in design goals and choices. For example, they both aim to bridge the gap between human productivity and computer efficiency, and they both target the scientific / HPC community. However, the languages have also significant differences in design choices and internals. The BoF will feature a core Chapel developer who can describe compiler, library, and language design challenges that the project has successfully overcome. Can the two communities learn from each other? Join the BoF for the first ever Chapel-Julia crossover. The session will start with a short overview of Chapel and its features, followed by an informal discussion. We will chat about how each language solves design challenges they encountered, what communities can learn from each other, how to spark collaboration and synergies, and whatever you want to talk about. false https://pretalx.com/juliacon-2025/talk/DADLAW/ https://pretalx.com/juliacon-2025/talk/DADLAW/feedback/ Cathedral Room 332 - Let Room (Thursday only) Talk 2025-07-24T15:30:00-04:00 15:30 00:30 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. juliacon-2025-63689-efficient-constrained-optimization-using-conicsolve-jl General Alexander Leong en Mathematical optimization is used in many scientific and engineering domains, from robotics and image processing to communications. In robotics, for example, optimization helps compute collision-free trajectories; in image processing (e.g., MRI or Magnetic Resonance Imaging), it aids in denoising through matrix completion; and in network design, it enables maximizing data throughput subject to capacity constraints (e.g., Max Flow Min Cut). This talk focuses on constrained optimization problems and how Interior-point Methods (IPMs) are applied to efficiently solve them. We will explore how ConicSolve.jl, a Julia package, implements these methods to handle a variety of problem classes, including Linear Programming (LP), Quadratic Programming (QP), Second Order Cone Programming (SOCP), and Semidefinite Programming (SDP). We will discuss key challenges in solving large-scale constrained optimization problems, especially when dealing with thousands of constraints and explain how array manipulation techniques and thoughtful API design decisions in ConicSolve.jl simplify the process for practitioners. Additionally, we'll explore strategies such as exploiting problem structure and sparsity to enhance solver performance. This talk will include practical examples, such as image denoising and max flow min cut, to demonstrate the utility of solvers based on Conic IPMs. By the end of the session, you'll have a deeper understanding of the optimization modeling process and a set of tools to tackle the common challenges faced when solving constrained optimization problems. false Poster session https://pretalx.com/juliacon-2025/talk/KJKF8M/ https://pretalx.com/juliacon-2025/talk/KJKF8M/feedback/ Lawrence Room 120 - REPL Main Stage Keynote 2025-07-25T09:00:00-04:00 09:00 00:45 Dr. Bob Metcalfe is research affiliate and computational engineer at the MIT Julia Lab. He is well known as a co-inventor of Ethernet, and the winner of the 2022 Turing award. Join us as well we explore Dr. Metcalfe's journey using Julia since 2022. juliacon-2025-66703-fireside-chat-with-dr-bob-metcalfe General Dr. Bob Metcalfe en Dr. Bob Metcalfe is research affiliate and computational engineer at the MIT Julia Lab. He is well known as a co-inventor of Ethernet, and the winner of the 2022 Turing award. Join us as well we explore Dr. Metcalfe's journey using Julia since 2022. false https://pretalx.com/juliacon-2025/talk/UYYLRS/ https://pretalx.com/juliacon-2025/talk/UYYLRS/feedback/ Lawrence Room 120 - REPL Main Stage Gold sponsor talk 2025-07-25T09:45:00-04:00 09:45 00:10 Dr. Austin Hansen, a researcher at Temple Capital, will explore his transition from mathematical biology research to finance. Additionally, he explains why Temple has chosen Julia to streamline the research process, leading to more accurate predictions about the price movements of various assets. juliacon-2025-78086-academia-to-finance-how-julia-makes-efficient-research-possible General Austin Hansen en Dr. Austin Hansen, a researcher at Temple Capital, will explore his transition from mathematical biology research to finance. Additionally, he explains why Temple has chosen Julia to streamline the research process, leading to more accurate predictions about the price movements of various assets. false https://pretalx.com/juliacon-2025/talk/FL7TRV/ https://pretalx.com/juliacon-2025/talk/FL7TRV/feedback/ Lawrence Room 120 - REPL Main Stage Talk 2025-07-25T10:00:00-04:00 10:00 00:30 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. juliacon-2025-65052-an-intersection-of-concerns-extended-types-for-julia General Cody Tapscott en Semantic subtyping is a frequently-cited basis for Julia's type system, but much more time has been spent explaining the particularities of Julia's types (e.g. invariance vs. covariance) versus the fundamental semantic subtyping features that Julia supports and those that have been left out. We've built a new subtyping algorithm that gives up some complexity of `where T` and inherits the ability to extend Julia with a variety of interesting features such as intersection / negation types, sum types, and interface types. This talk will explore the details of that algorithm, making frequent references to major languages with similar type system features. false https://pretalx.com/juliacon-2025/talk/ADCQMM/ https://pretalx.com/juliacon-2025/talk/ADCQMM/feedback/ Lawrence Room 120 - REPL Main Stage Talk 2025-07-25T10:30:00-04:00 10:30 00:30 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. juliacon-2025-64143-survey-of-unit-testing-packages General Andrew Dolgert en Critical software benefits from powerful testing tools. Tools for unit testing in Julia show the community's emphasis on scientific computation and the language's unique capabilities for combining numerics with symbolic methods. Looking at JuliaHub, the tools fall into rough bins. * Unit Test Frameworks * Extensions to Test Sets * Mocking, Faking * Property-based testing * Mutation testing * Test code coverage * Regression testing * Floating-point assessment * Performance testing These packages will save you time by helping you find difficult bugs. We can see what's popular and what's overlooked. You can decide how to unit-test your next critical code. false https://pretalx.com/juliacon-2025/talk/NAYEPK/ https://pretalx.com/juliacon-2025/talk/NAYEPK/feedback/ Lawrence Room 120 - REPL Main Stage Talk 2025-07-25T11:00:00-04:00 11:00 00:30 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. juliacon-2025-64529-adventures-embedding-julia-on-a-chip-making-machine General Jorge Alberto Vieyra SalasYury Nuzhdin en ASML is the leading edge company production photo-lithography machines used to produce the most advanced chips in the world. Currently our machines produce around 300 wafer per hour, each wafer contains somewhere between 100 and 10,000 chip dies that are exposed with a scanning technique. This is achieved by exposing groups of dies at a time somewhere between 100 and 300 exposures on a wafer. This roughly means that a wafer is exposed every 12 seconds and an exposure completed in at most 40 ms. In order to produce sub-nanometer precision wafers, we need to run complex correction models for each exposure. Besides that those models run in parallel they are still very constrained in time and have to complete in <30 ms per exposure. To keep up with the pace of technology improvements we need to increase complexity of the algorithms and quickly adapt to the demanding requirements of semi-conductor manufacturers. As a pilot we are using Julia as a language for a few of such algorithms. That poses few challenges: * how to reach the desired performance (fast and consistent)? * how to deploy algorithms compiled ahead of time? * how to connect the algorithms with other algorithms and facilities of the machine? We employ the new ahead of time compiler `juliac` ([presented by Gabriel and Jeff on JuliaCon 2024](https://youtu.be/MKdobiCKSu0?si=YWHo-qRv-Bl3PuC0)) which will be released in Julia 1.12. However, using juliac poses its own challenges. This talk will be a summary of several issues that we encountered and how we solved them or still struggling with. false https://pretalx.com/juliacon-2025/talk/MTT73S/ https://pretalx.com/juliacon-2025/talk/MTT73S/feedback/ Lawrence Room 120 - REPL Main Stage Talk 2025-07-25T11:30:00-04:00 11:30 00:30 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 juliacon-2025-64848-monitor-modify-values-in-realtime-debug-1000-programs-at-once General /media/juliacon-2025/submissions/KPLMCS/Monitor.jl_Illustratio_wjwlVC5.png William R Burdick en Monitor.jl is a simple monitoring, evaluation, and communication system with pluggable transports, including using REDIS streams for pubsub. [https://github.com/Leisure-tools/Monitor.jl](https://github.com/Leisure-tools/Monitor.jl) Imagine many jobs simulating Formula 1 engines where some overheat unexpectedly, which the developer can tell from log messages but without a clear idea of why it happens. So far, the developer has had to stop, change, and restart the jobs and then wait for log messages with more information three times in a row. Each cycle takes around 15 minutes, so the initial run plus 3 restarts has cost almost an hour of work. Then the developer decides to use Monitor.jl with these steps: 1. Modify the job's start script to use a different main program that a. Loads Monitor.jl, b. Connect to a REDIS server for communication, c. Calls original main program within a handler that waits upon crashing instead of terminating, d. There should normally not be a need to change the job’s original main program, only the start script, although certain modifications might be needed to make data accessible for monitoring. 2. Rerun the jobs and start the REDIS server. 3. Connect a notebook to REDIS. 4. Use the notebook to: a. Publish code to all the jobs that defines a function to check for overheating and then changes the monitor (below) to send updates to a stream named “overheating”. b. Publish a monitor to all the jobs that uses the new function. c. Watch the “overheating” stream for incoming monitors on problematic jobs. d. Use monitor UI views in the notebook to explore data in problematic jobs, creating additional monitors as needed. After the developer fixes the problem, they decide to add another monitor block to each job which reaches into the simulation data and produces dynamically updating trend information. They then use the notebook to display a roll-up for all the jobs. Without needing to restart jobs or change code, the developer is able to add real time monitoring to get more insight on the activities of their jobs. More technical information is available in the repository readme. false https://pretalx.com/juliacon-2025/talk/KPLMCS/ https://pretalx.com/juliacon-2025/talk/KPLMCS/feedback/ Lawrence Room 120 - REPL Main Stage Lightning talk 2025-07-25T13:30:00-04:00 13:30 00:10 In this talk we will introduce `FixedSizeArrays.jl`, a new package which implements mutable fixed-size arrays, based on the recent `Memory` type. juliacon-2025-62928-fixedsizearrays-jl-what-array-probably-should-have-been General Mosè GiordanoOscar SmithNeven Sajko en Julia's built-in `Array` type is a convenient multi-dimensional container for continuous data, with the ability to resize it. But do you really need this flexibility all the time? In most linear algebra-related applications you don't need to change the size of existing vectors or matrices, and the resizability comes at the cost of preventing potential compiler optimizations based on the known shape of arrays. `FixedSizeArray`s look very similar to Julia's standard `Array`s, with the difference that their size can't be changed, but unlike `StaticArrays.jl` the shape of the array isn't part of their type. We will explore the opportunities for optimization and improved performance that `FixedSizeArrays.jl` offers, and outline possible future direction, including the possibility of having such an implementation in Julia `Base`. false https://pretalx.com/juliacon-2025/talk/J3J7U8/ https://pretalx.com/juliacon-2025/talk/J3J7U8/feedback/ Lawrence Room 120 - REPL Main Stage Lightning talk 2025-07-25T13:40:00-04:00 13:40 00:10 [TidierDB.jl](https://github.com/TidierOrg/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. juliacon-2025-64645-intro-to-tidierdb-jl-1-syntax-for-12-database-backends General /media/juliacon-2025/submissions/DL9ZS9/tidierdblogo_2RQRPvK.png Daniel Rizk en TidierDB supports 12 different database backends (DuckDB, ClickHouse, Postgres, databricks, Snowflake, Oracle...) and multiple sql dialects. This means that knowing TidierData syntax for Dataframes immediately gives a user to the ability work with data on any of the supported backends without learning sql or new syntax. With DuckDB as the default backend, .parquet, .json, .csv, iceberg, delta, geoparquet, and google sheets data can all be analyzed without ever reading the data into memory, regardless of size. TidierDB supports complex queries, equi and non equi joins, joining queries, grouped window functions, sql views etc. Since TidierDB leverages non standard evaluation, _every_ sql function and any user defined function can be effortlessly blended directly into TidierDB `@mutate` and `@summarize` calls. false https://pretalx.com/juliacon-2025/talk/DL9ZS9/ https://pretalx.com/juliacon-2025/talk/DL9ZS9/feedback/ Lawrence Room 120 - REPL Main Stage Lightning talk 2025-07-25T13:50:00-04:00 13:50 00:10 GPU for histogramming juliacon-2025-65014-making-histograms-on-gpu-how-hard-can-that-be General Jerry LingMichael Steven Farrington en In this talk, we demonstrate a GPU-friendly extension to the FHist.jl. Within the analysis computing ecosystem, moving to GPU has been a steady trend, however, since any event we select almost always goes to a histogram, it would be a huge bottleneck if histogramming requires moving data GPU -> CPU. We briefly discuss the design and implementation of GPU-backed histogram, and then show some benchmarks to inform the audience what kind of performance tradeoff is being made when you use GPU for histogramming. false Slides Typst Slides https://pretalx.com/juliacon-2025/talk/J9MSQU/ https://pretalx.com/juliacon-2025/talk/J9MSQU/feedback/ Lawrence Room 120 - REPL Main Stage Talk 2025-07-25T14:00:00-04:00 14:00 00:30 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. juliacon-2025-65003-fixing-julia-s-task-local-rng-a-bother-a-bug-a-breakthrough General Stefan Karpinski en Julia uses Xoshiro256++ as its default random number generator. With only four 64-bit values of state, this RNG is small enough that each task can have its own instance. This means tasks can generate random values without locking and each task has its own independent, reproducible random number sequence. But what happens when a task spawns a child task? The parent task must seed the child task’s somehow. This talk covers the history of how we used to do this, why it was annoying, how we fixed it, how that fix was discovered to be subtly but significantly broken, and how it was fixed yet again. The final design is derived from the DotMix algorithm designed by Leiserson et al. for the Cilk parallel runtime system. DotMix requires arithmetic modulo a large prime to guarantee that so-called "pedigree coordinates" have multiplicative inverses. We noticed that by structuring the task tree a bit differently, we can ensure that it is a binary tree, which lets us use machine arithmetic instead since a coefficient of one is invertible in any modulus. We also found that the dot product construction at the heart of DotMix could be problematic as it inherently introduces linear relationships between the states of sibling tasks. These linear relationships can be masked by a good non-linear output function, which is what the original DotMix did. I failed to recognize the significance of that non-linear output function and initially omitted it from our implementation, which caused a very observable correlation between the outputs of random values from carefully constructed task families. When trying to fix this, I noticed that we can replace the dot product in DotMix with reduction by *any* doubly bijective binary function without losing DotMix's collision resistance property. Machine addition is bijective in each argument, of course, but we can use a non-trivial and non-linear mixing operation instead, which yields a construction that is both stronger and more efficient than the original DotMix. It's stronger because it's inherently non-linear and the non-trivial bit mixing is chained rather than only applying to the output after relatively trivial additive mixing. It's also more efficient because we no longer need a relatively expensive non-linear output function after mixing, we can use the mixed output directly. Finally, we verify empirically that this construction has the collision resistance properties that we expect by simulating a reduced-state version of it. false https://pretalx.com/juliacon-2025/talk/ZNBEAN/ https://pretalx.com/juliacon-2025/talk/ZNBEAN/feedback/ Lawrence Room 120 - REPL Main Stage Talk 2025-07-25T14:30:00-04:00 14:30 00:30 Since [Tidier.jl](https://github.com/TidierOrg/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! juliacon-2025-64649-state-of-tidier-jl General /media/juliacon-2025/submissions/KGPC7B/tlogo_hEMewwJ.png Daniel Rizk en Tidier is an organization dedicated to crafting a data analysis and visualization ecosystem in Julia inspired by the tidyverse in R. Our flagship package is Tidier.jl, a 100% Julia implementation of the R tidyverse meta-package. Tidier.jl wraps best-in-class Julia data analysis packages like DataFrames.jl and Makie.jl to bring the best of both worlds: convenient syntax and blazing fast speed. Over the course of this brief talk, we hope to demonstrate how Tidier is a great tool for broad variety data analysis/tasks needs and touch on some of the design choices, guiding principles and goals. (+one exciting resource that will hopefully be up) false https://pretalx.com/juliacon-2025/talk/KGPC7B/ https://pretalx.com/juliacon-2025/talk/KGPC7B/feedback/ Lawrence Room 120 - REPL Main Stage Talk 2025-07-25T15:00:00-04:00 15:00 00:30 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. juliacon-2025-65000-pkg-s-new-sat-based-version-resolver General Stefan Karpinski en Resolving package versions is an NP-hard problem. Until recently, Julia used a heuristic solver based on belief propagation. This approach has worked pretty well over the years and we’re all indebted to it’s creator and maintainer, Carlo Baldassi. But it has some limitations. It isn’t guaranteed to find a solution if one exists, nor that solutions found are optimal. Additionally, it encodes assumptions about version numbers—major, minor, and patch—that limit its flexibility, and prevent it from correctly handling versions with build or prerelease tags. Finally, since it bakes in the preference ordering of versions, if we want to do something different, such as preferring the oldest versions, or preferring the current version, we can't straightforwardly do that. The new resolver addresses all of these issues and more. false https://pretalx.com/juliacon-2025/talk/Y7NPFM/ https://pretalx.com/juliacon-2025/talk/Y7NPFM/feedback/ Lawrence Room 120 - REPL Main Stage Talk 2025-07-25T15:30:00-04:00 15:30 00:30 Julia's mark-sweep GC poses some challenges to heap-intensive workloads like RelationalAI's cloud application, eg. fragmentation. The runtime's tight coupling with the GC prevents the adoption of new collectors. We introduced a GC interface to decouple the runtime from the GC, and integrated MMTk as one new alternative collector. MMTk provides cutting-edge GC algorithms, and allows community-driven innovation. We present preliminary results from using MMTk in the open-source GCBenchmarks. juliacon-2025-63918-julia-s-gc-reimagined-flexibility-and-mmtk-integration General Diogo NettoLuis Eduardo de Souza Amorim en Julia’s garbage collector has served the language well for the typical high-performance computing (HPC) applications it was originally designed for. As Julia evolves and expands into more diverse domains—such as cloud computing—the garbage collector faces new challenges. Although the built-in mark-sweep collector is straightforward and performs sufficiently well for throughput-oriented workloads, it struggles with memory-intensive applications with tight latency constraints. Unpredictable stop-the-world pauses disrupt latency-sensitive tasks, while the inability to move objects leads to fragmentation, which, in turn, leads to poor memory utilization for long-running workloads. We encounter both issues with Julia’s built-in collector at [RelationalAI](https://relational.ai). Compounding these issues, years of incremental evolution have embedded GC-specific constraints deep into the runtime. For example, the runtime assumes that heap objects never move, making direct access to objects pervasive. This immovability blocks optimizations like heap compaction, further limiting the collector’s capability and complicating the adoption of more advanced collectors. To overcome these challenges, we have rearchitected Julia’s GC subsystem into a modular interface that decouples the runtime from any specific collector. This refactoring requires untangling years-old assumptions—such as object movability, root management, and generational behaviors—while preserving Julia’s existing flexibility and semantics. The result is a framework that empowers the community to experiment with diverse GC implementations, ensuring Julia can adapt to evolving memory management needs. Central to this effort is our integration of [MMTk](https://www.mmtk.io/), a high-performance, cross-language GC framework. We have added support for multiple collectors from MMTk, including one of its generational collectors (Sticky Immix) with support for opportunistic copying, demonstrating that Julia’s refactored interface can support collectors far beyond the capability of the built-in mark-sweep. Early results show improvements in allocation and collection throughput, as well as reductions in memory fragmentation, both on open-source micro-benchmarks and on large-scale customer benchmarks, where we have begun experimentally testing MMTk at RelationalAI. More interestingly, MMTk is a suite of diverse garbage collection algorithms that supports multiple language implementations. Its active development ecosystem opens doors to cutting-edge algorithms like [LXR low-latency GC](https://dl.acm.org/doi/10.1145/3519939.3523440) and other innovations. By integrating MMTk, Julia not only future-proofs its memory management but also joins a cross-language effort to advance GC innovation—where improvements in one language benefit all. false https://pretalx.com/juliacon-2025/talk/7RHKPZ/ https://pretalx.com/juliacon-2025/talk/7RHKPZ/feedback/ Lawrence Room 120 - REPL Main Stage Ceremony 2025-07-25T16:10:00-04:00 16:10 00:30 Join the organizers at Lawrence Hall Room 120 as they close out the formal conference program, announce the 2025 Julia Community prizes, and share plans for the Saturday hackathon. juliacon-2025-78101-closing-ceremony General Ranjan AnantharamanRaye Kimmerer en Join the organizers at Lawrence Hall Room 120 as they close out the formal conference program, announce the 2025 Julia Community prizes, and share plans for the Saturday hackathon. false https://pretalx.com/juliacon-2025/talk/8BVRNB/ https://pretalx.com/juliacon-2025/talk/8BVRNB/feedback/ Lawrence Room 121 - Struct Room Talk 2025-07-25T10:00:00-04:00 10:00 00:30 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. juliacon-2025-64891-computational-quantum-chemistry-with-sparse-matrix-algorithms Computational Chemistry and Materials Science Minisymposium Letícia Madureira en Quantum chemistry heavily relies on matrix computations to model molecular interactions and quantum states. Traditionally, these computations have been constrained by the limitations of dense matrix algorithms, leading to high computational costs and substantial memory requirements. The adaptation of sparse matrix techniques in Julia presents a transformative solution, offering a more efficient and scalable approach to handle the vast and sparse matrices typical in quantum chemistry. This advancement in Julia is not merely a technical enhancement; it represents a paradigm shift in computational quantum chemistry. Sparse matrix algorithms drastically reduce computational overhead, making it feasible to simulate larger systems and more complex interactions than ever before. This has profound implications for the accuracy and scope of quantum chemical calculations, enabling more precise modeling of molecular behavior and electronic structures. The talk will delve into the theoretical foundations of these algorithms and their practical applications in quantum chemistry, demonstrating Julia's sparse matrix capabilities are being used to tackle some of the most challenging problems in the discipline, such as the simulation of large molecular systems and the exploration of new materials. The presentation will focus on practical examples shown in the package OohataHuzingaga.jl (The repo: https://github.com/HartreeFoca/OohataHuzinaga.jl), which is part of the HartreeFoca community focused on the development of open source code for advanced electronic structure methods. false https://pretalx.com/juliacon-2025/talk/J9LVM8/ https://pretalx.com/juliacon-2025/talk/J9LVM8/feedback/ Lawrence Room 121 - Struct Room Talk 2025-07-25T10:30:00-04:00 10:30 00:30 We are launching [JuliaFewBody](https://github.com/JuliaFewBody) and developing FewBody.jl, general-purpose flexible solvers for quantum mechanical few-body problems. Our presented package, [TwoBody.jl](https://github.com/ohno/TwoBody.jl) is a prototype for FewBody.jl. We will introduce practical examples of how TwoBody.jl can be used beyond the prototype. Try it out on [Google Colab](https://colab.research.google.com/drive/1c87aEFRGXxq0FFIdmskbtMX8yTjQXpjV?usp=sharing). juliacon-2025-63873-quantum-mechanical-two-body-problems-in-julia Computational Chemistry and Materials Science Minisymposium /media/juliacon-2025/submissions/ZZW8AC/TwoBody.jl_1obXVAX.png Akio TomiyaShuhei OhnoLucas HappAhmad Jafar Arifi en We present [TwoBody.jl](https://github.com/ohno/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. One of our targets, the quark model describes the spectra and structures of mesons. These potentials have several terms. For example, the Cornell potential has three terms: a constant term, a linear term, and a Coulomb term. Furthermore, a hyperfine interaction term is added in our case: [A. J. Arifi, L. Happ, S. Ohno, M. Oka, Phys. Rev. D 110, 014020 (2024)](https://doi.org/10.1103/PhysRevD.110.014020). Therefore, the Hamiltonian should be flexibly customized for exploring models. The Hamiltonian is defined as a struct and processed with multiple dispatch in Julia. The Schrödinger equation is solved by the Rayleigh-Ritz method with Gaussian basis functions. In the alternative calculations, the neural network was employed as trial wave functions in the variational method. Implementations of these methods will be published as [TwoBody.jl](https://github.com/ohno/TwoBody.jl). This package provides a comprehensive solution to quantum mechanical two-body problems including quark models of mesons. It can be applied not only to hadron physics but also to quantum chemistry and other fields. Each method is tested by comparing its numerical solutions with analytical solutions of the hydrogen atom provided by [Antique.jl](https://github.com/ohno/Antique.jl). This package is useful for developing and testing numerical methods for quantum mechanical systems. It is also useful for educational purposes, and we hope that textbooks for quantum mechanics will be written using Antique.jl. We acknowledge all supporters, sponsors, and contributors. This travel was partially supported by the funding and free accommodation from American Physical Society DCOMP Travel Award for JuliaCon 2025. S. O. was supported by the RIKEN Junior Research Associate Program. A. J. A. and L. H. were supported by the RIKEN Special Postdoctoral Researcher Program. A. T. was partially supported by JSPS KAKENHI Grant Numbers 20K14479, 22K03539, 22H05112, and 22H05111, and MEXT as "Program for Promoting Researches on the Supercomputer Fugaku" (Grant Number JPMXP1020230411, JPMXP1020230409). false https://pretalx.com/juliacon-2025/talk/ZZW8AC/ https://pretalx.com/juliacon-2025/talk/ZZW8AC/feedback/ Lawrence Room 121 - Struct Room Talk 2025-07-25T11:00:00-04:00 11:00 00:30 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. juliacon-2025-63667-carlo-jl-high-performance-monte-carlo-simulations-in-julia Computational Chemistry and Materials Science Minisymposium /media/juliacon-2025/submissions/AMMTMW/header_HKxUOKC.svg Lukas Weber en In this talk, I will first give an overview of the features of Carlo.jl and then show its usage from two perspectives: In the first perspective of an implementer of Monte Carlo codes, we will see how to build a Monte Carlo code from scratch using Carlo.jl by implementing a few callbacks for updates and measurements. In the second perspective of the practitioner, we will show how to run an existing implementation and calculate properties of a quantum magnet using the state-of-the-art code StochasticSeriesExpansion.jl, which is built on Carlo.jl. false https://pretalx.com/juliacon-2025/talk/AMMTMW/ https://pretalx.com/juliacon-2025/talk/AMMTMW/feedback/ Lawrence Room 121 - Struct Room Talk 2025-07-25T11:30:00-04:00 11:30 00:30 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. juliacon-2025-64917-elasticnetworks-jl-package-for-metamaterial-research-design Computational Chemistry and Materials Science Minisymposium Haina Wang en Elastic networks are stiff yet lightweight with low volume fractions. Thus, they appear in many biological and engineering contexts, e.g. as mechanical scaffolds in the cytoskeleton. The usual way to compute their stiffness tensor is through finite differences, i.e., give the material a small deformation, minimize the energy, and find the difference in energy before and after the deformation. This is inexact and can introduce large errors if the deformation is not chosen small enough, but on the other hand, this deformation cannot be chosen too small compared to the precision threshold during the energy minimization. Automatic differentiation is an excellent solution to this problem. We have built a package based on exactly this idea. One can now obtain *exact* stiffness tensor and elastic moduli. Our package builds Network objects that incorporate julia Graphs and coordinates of the nodes, as well es the rest lengths of edges. false https://pretalx.com/juliacon-2025/talk/AABQQN/ https://pretalx.com/juliacon-2025/talk/AABQQN/feedback/ Lawrence Room 121 - Struct Room Talk 2025-07-25T13:30:00-04:00 13:30 00:30 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. juliacon-2025-64484-simulating-strongly-correlated-material-models Computational Chemistry and Materials Science Minisymposium Benjamin Cohen-Stead en The SmoQySuite organization is committed to developing and maintaining Julia packages to solve low-energy effective Hamiltonian models for strongly-correlated quantum materials, with particular focus given to quantum Monte Carlo (QMC) related tools. In this talk, we will review the current Julia packages maintained by the SmoQySuite organization and discuss the planned development roadmap. Adopting a modular design philosophy, the SmoQySuite organization maintains high-level, low- level, and utility packages that serve various research needs. High-level packages implement a specific algorithm for a certain parameterized class of systems. For example, this talk will review the functionality of the SmoQyDQMC.jl package, which exports a user-friendly implementation of the determinant QMC (DQMC) method for simulating Hubbard and flexibly parameterized electron-phonon Hamiltonians. We will also discuss the SmoQyDEAC.jl package, an implementation of the Differential Evolution Analytic Continuation algorithm for obtaining spectral densities based on results generated by QMC simulations. While high-level packages like the ones mentioned above are useful, researchers frequently encounter specific research questions requiring specialized functionality that fall outside the scope of existing packages. The low-level and utility packages maintained by this SmoQySuite organization are intended to address this issue by exporting functionality to expedite the implementation of other numerical techniques. For instance, the SmoQyDQMC.jl package is built on top of the low-level package JDQMCFrameworks.jl, which exports functionality empowering researchers to implement their own DQMC codes while avoiding many common pitfalls that typically hinder such efforts. Lastly, a development roadmap for the SmoQySuite organization will be discussed. In particular, development efforts are underway for two new high-level packages focused on modeling strongly- correlated systems near the thermodynamic limit. Specifically, SmoQyElPhQMC.jl will export a QMC algorithm for simulating electron-phonon Hamiltonians with a computational cost that scales linearly with systems size, while SmoQyDCA.jl will implement the dynamical cluster approximation using SmoQyDQMC.jl as the cluster solver. The development of the SmoQyDQMC.jl and SmoQyDEAC.jl packages was supported by the U.S. Department of Energy, Office of Science, Office of Basic Energy Sciences, under Award Number DE-SC0022311. The current development of the SmoQyElPhQMC.jl and SmoQyDCA.jl package is supported by the National Science Foundation under Grant No. OAC-2410280. Lastly, I would like to thank the Simons Foundations for supporting my open-source software development efforts with the Scientific Software Research Faculty award. false https://pretalx.com/juliacon-2025/talk/NDZ3MF/ https://pretalx.com/juliacon-2025/talk/NDZ3MF/feedback/ Lawrence Room 121 - Struct Room Talk 2025-07-25T14:00:00-04:00 14:00 00:30 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. juliacon-2025-64959-simulation-of-light-driven-hot-carrier-dynamics-transport Computational Chemistry and Materials Science Minisymposium Henry Snowden en Light-matter interactions are fundamental to a wide range of natural and technological processes, from photosynthesis and vision to photovoltaics and photocatalysis. Understanding how light drives matter out of thermodynamic equilibrium and leads to electronic and phononic transport phenomena is crucial for developing efficient optical sensors, nanolithography, and quantum technologies. These interactions govern key phenomena such as plasmonic excitations, energy transfer, and non-radiative relaxation, all of which play a critical role in spectroscopy, materials science, and nanophotonics. LightMatter.jl provides a framework for the simulation of the time-dependent evolution of the electronic energy distribution due to laser excitation in metals. The aim of the package is to enable users to design simulations that capture the physics of interest to their required level of theory. LightMatter.jl uses metaprogramming within Julia to construct a custom coupled set of ordinary differential equations which can then be propagated using DiffEq.jl. The metaprogramming also enables users to develop their own methodologies by exchanging components of the expression that describe different physical phenomena for custom functions or approximations. Currently the package contains capabilities to perform energy-resolved Boltzmann equations (B. Y. Mueller & B. Rethfeld, Phys. Rev. B 2013) , the Two-Temperature Model (S. I. Anisimov et al., Sov. Phys. JETP 1974), the Athermal Electron Model, and time-dependent Schrödinger equation (TDSE) for a given Hamiltonian in the dipole approximation. The package is designed in such a way that components of the theories such as lifetimes, parameters and matrix elements can easily be implemented and tested while accessing all the other features. false https://pretalx.com/juliacon-2025/talk/LHZNS8/ https://pretalx.com/juliacon-2025/talk/LHZNS8/feedback/ Lawrence Room 121 - Struct Room Talk 2025-07-25T14:30:00-04:00 14:30 00:30 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. juliacon-2025-64135-quiqbox-jl-0-6-basis-design-for-electronic-structure-and-beyond Computational Chemistry and Materials Science Minisymposium Weishi Wang en Quiqbox started as an open-source basis set generation and optimization software library for electronic structure at the intersection between quantum computing and quantum chemistry. It was designed to flexibly construct custom single-particle wave functions based on linear combinations of parameterized Gaussian-type orbitals. These parameterized basis functions are used to discretize the molecular Hamiltonians for numerical computation in electronic structure. With Quiqbox, one can study the relation between molecular Hamiltonian discretizations and classical methods or quantum algorithms in electronic structure. Our presentation's primary goal is to demonstrate new features and performance improvements of Quiqbox over the past two years, which will help further such research endeavors and related studies. Due to the upgrades to the parameterization and construction system, Quiqbox has also become a flexible toolbox for designing computational models that may benefit a broader range of researchers. For instance, after version 0.6, Quiqbox can be used to prototype machine learning models based on artificial neural network architectures (e.g., Multilayer perceptron). We hope this talk can illuminate potential use cases of Quiqbox for both electronic structure and scientific modeling within the Julia community. false https://pretalx.com/juliacon-2025/talk/RR3SMD/ https://pretalx.com/juliacon-2025/talk/RR3SMD/feedback/ Lawrence Room 121 - Struct Room Lightning talk 2025-07-25T15:00:00-04:00 15:00 00:10 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. juliacon-2025-62693-freebird-jl-an-extensible-toolbox-for-surface-phase-equilibria Computational Chemistry and Materials Science Minisymposium Ray YangJunchi Chen en We present FreeBird.jl, an extensible platform for computationally studying phase equilibria across a diverse range of interfacial systems, with easy extension to other phenomena, such as point defects and grain boundaries in crystals. FreeBird.jl employs the concept of walkers—sets of configurations that evolve systematically within chosen algorithms to sample a desired statistical distribution by design. We implemented (1) an atomistic walker system, heavily utilizing AtomsBase.jl developed by the JuliaMolSim community, with their energies computed using classical interatomic potentials, and (2) a lattice walker system, which supports flexibly defined lattice Hamiltonians. Furthermore, we implemented various sampling schemes, such as nested sampling, Wang-Landau sampling, and Metropolis Monte Carlo, which are broadly applicable, as well as exact enumeration, enabling the user to conveniently select the most appropriate and efficient numerical algorithms for solving interfacial problems under a unified framework. FreeBird.jl also provides a built-in analysis toolkit for processing sampling outputs and performing statistical thermodynamic analyses. A FreeBirdIO module for quick conversions between atomic structures and walker systems is developed as well. Overall, we aim to provide a comprehensive library of sampling methods for exploring the thermodynamics of interfacial systems, broadly defined, and uncovering their properties under various, typically non-standard, conditions through statistics. false https://pretalx.com/juliacon-2025/talk/YCYTWQ/ https://pretalx.com/juliacon-2025/talk/YCYTWQ/feedback/ Lawrence Room 121 - Struct Room Lightning talk 2025-07-25T15:10:00-04:00 15:10 00:10 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. juliacon-2025-65029-liquid-crystal-modeling-thermodynamics-numerical-methods Computational Chemistry and Materials Science Minisymposium Pablo ZubietaJonathan Salmerón-HernándezSuraj Sudhakar en Experimental data on liquid crystals (LCs) have revealed complex patterns that remain unexplained, including active nematics triggered by molecular motors and solitons generated by external electric fields. These studies raise questions about the effective parameters that transform such chaotic dynamics into coherent motion, with the goal of uncovering new applications and technologies. To address this challenging problem, we employ the GENERIC framework to construct a thermodynamically consistent model. Within this framework, the time-evolution equations for out-of-equilibrium systems are naturally described by the sum of energy and entropy contributions. Using this approach, we systematically formulate a set of equations that describe the behavior of concentration-dependent (lyotropic) LCs. We solve these equations using a hybrid lattice Boltzmann code written in Julia, which combines: 1) finite differences (inspired by DiffEqOperators.jl) and 2) the Lattice Boltzmann method (from Trixi.jl); the time evolution is integrated using DifferentialEquations.jl. We show that, in 2D, two passive isotropic droplets within a nematic environment can form stable defect cores with topological charges of +1/2 and -1/2, as observed in chromonic LC data. In 3D, the simulations predict different behaviors, such as the Fréedericksz' transition, due to the electric energies involved. Additionally, we investigate the effect of our solutions under different types of flow, arisen by these additional energy sources. Our findings demonstrate that the experimental results can be quantitatively predicted by the proposed GENERIC equations and our numerical approach. false https://pretalx.com/juliacon-2025/talk/CGGQBT/ https://pretalx.com/juliacon-2025/talk/CGGQBT/feedback/ Lawrence Room 121 - Struct Room Lightning talk 2025-07-25T15:20:00-04:00 15:20 00:10 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. juliacon-2025-63924-accelerating-fermi-operator-expansion-ml-inspired-methods Computational Chemistry and Materials Science Minisymposium Qi Zhang en Calculating electronic properties of materials using the density matrix formalism enables linear scaling with system size, compared to the cubic scaling of direct diagonalization. To obtain density matrices, one typically applies the Fermi–Dirac operator to the Hamiltonian of a given system. The second-order spectral projection (SP2) scheme has proven effective across a broad range of temperatures. We generalize this SP2 method, drawing inspiration from machine learning models, to recursively expand the Fermi–Dirac operator. This approach accurately captures properties such as fractional occupation numbers and electronic entropy while significantly reducing computational cost by replacing highly nonlinear matrix functions with iterative matrix multiplications. Performance further improves by running these calculations on GPUs. In this presentation, we show how Julia enables rapid prototyping of this algorithm and the subsequent design of a user-friendly API. We share strategies for optimizing performance (e.g., removing type instabilities, reducing allocations, and avoiding code duplication) with the help of robust benchmarking tools from the Julia community. We have been pleasantly surprised to see that writing GPU-compatible Julia code adds minimal overhead compared to calling CUDA C++ directly, while substantially improving readability—particularly when leveraging tensor cores. We also take advantage of automatic differentiation packages to generalize our approach to differentiating physically meaningful functions. Test cases for this model use a rich ecosystem of random distribution generation code, showcasing the flexibility and power of Julia for computational chemistry applications. false https://pretalx.com/juliacon-2025/talk/88WEPL/ https://pretalx.com/juliacon-2025/talk/88WEPL/feedback/ Lawrence Room 121 - Struct Room Talk 2025-07-25T15:30:00-04:00 15:30 00:30 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. juliacon-2025-64957-nqcdynamics-jl-nonadiabatic-quantum-classical-dynamics-in-julia Computational Chemistry and Materials Science Minisymposium /media/juliacon-2025/submissions/BY3B8P/logo_rN3sp1Y.svg Henry SnowdenAlexander Spears en Accurate and efficient methods to simulate nonadiabatic and quantum nuclear effects in high-dimensional and dissipative systems are crucial for the prediction of chemical dynamics in the condensed phase. Non-adiabatic effects arise from the transfer of energy between electrons and vibrational motion and are an essential process in the study of photocatalysis, inelastic scattering and chemical reactions. A full quantum dynamical treatment based on first principles is unfeasible for anything but the simplest model systems. To facilitate effective development, code sharing, and uptake of newly developed approximate and efficient mixed quantum-classical dynamics methods, it is important that software implementations can be easily accessed and built upon. Using the Julia programming language, we have developed the NQCDynamics.jl package and Non-adiabatic Quantum-Classical Dynamics (NQCD) code suite, which provides a framework for established and emerging methods for performing semiclassical and mixed quantum–classical dynamics in the condensed phase (J. Gardner et al., J. Chem. Phys. 2022). At its core, NQCDynamics.jl offers efficient implementations of numerous dynamics methods and offers the community an open space for proof-of-principle implementations of newly published methods. The code wraps around the powerful DifferentialEquations.jl framework, therefore providing users with fine-grained control over simulation accuracy, stability, and performance. As part of the NQCD suite, NQCModels.jl offers common model Hamiltonians and integrates with the Atomic Simulation Environment (ASE) for performing ab initio electronic structure calculations. The suite also features interfaces to cutting-edge machine learning potentials such as MACE, SchNet, and other neural networks, enabling rapid on-the-fly interatomic potential electronic structure property predictions (W. G. Stark et al. J. Phys. Chem. C 2023). Together, these components create a flexible, high-performance ecosystem for studying complex surface chemistry dynamics with both accuracy and efficiency, which we will showcase as part of this talk (G. Meng et al., Phys. Rev. Lett. 2024, J. Gardner et al., J. Chem. Phys. 2023). false https://pretalx.com/juliacon-2025/talk/BY3B8P/ https://pretalx.com/juliacon-2025/talk/BY3B8P/feedback/ Lawrence Room 104 - Function Room Talk 2025-07-25T10:00:00-04:00 10:00 00:30 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. juliacon-2025-62457-juliacon-proceedings-behind-the-scenes General Ludovic RässLuca Ferranti en JuliaCon often features researchers showcasing new tools or results useful to scientific communities. Recognizing the importance of publications for academic recognition, JuliaCon launched its own peer-reviewed journal, JuliaCon Proceedings, in 2019. JuliaCon proceedings is inspired by the Journal of Open-Source Software (JOSS), it is fully free and has a fully transparent open peer-review process. The whole review process happens on GitHub as an issue, where reviewers can leave comments and authors reply. The journal allows to submit both extended abstracts and full papers and everyone who presented at JuliaCon can submit their talk for publication. The talk will outline the journal's structure, the submission and review process, its underlying technical infrastructure, and ways for community members to get involved. false https://pretalx.com/juliacon-2025/talk/BKL99E/ https://pretalx.com/juliacon-2025/talk/BKL99E/feedback/ Lawrence Room 104 - Function Room Talk 2025-07-25T10:30:00-04:00 10:30 00:30 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. juliacon-2025-65005-why-are-float-ranges-so-hard-and-can-we-do-better General Stefan Karpinski en In the float range 0.1:0.2:0.7, how does one guess that 0.1 was actually intended to be 1/10? Julia currently computes the simplest fraction for each float and then checks if the resulting interpretation is valid—i.e. does the step divide the width exactly? If that doesn’t work, it gives up, which can lead to rather bad behavior, including ranges that are too short and interior points that are wrong. There are cases where a simple interpretation of a range exists, but rationalizing the float values independently doesn’t find it—the start, step and stop need to considered together in order to find the "right" interpretation. This problem is unexpectedly hard to solve in a principled and general way. This talk first defines what it means for a triple of rationals to be a valid interpretation of a floating-point range. We then consider how to pick a single interpretation among the infinite possibilities as the best one. This problem is partly definitional and partly algorithmic: we want a definition that makes sense and produces intuitive results, but we also need it to be efficiently computable—every time we construct a float range object. The mathematics required to find an optimal interpretation of a range turn out to be unexpectedly deep, touching on integer linear programming, numerical semigroup theory, and the Stern-Brocot tree of fractions. false https://pretalx.com/juliacon-2025/talk/S9HMM9/ https://pretalx.com/juliacon-2025/talk/S9HMM9/feedback/ Lawrence Room 104 - Function Room Talk 2025-07-25T11:00:00-04:00 11:00 00:30 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. juliacon-2025-65034-multipleinterfaces-jl-multiple-inheritance-multiple-dispatch General Cameron Bieganek en We present MultipleInterfaces.jl, 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. An interface can inherit from one or more interfaces. The support for multiple inheritance of interfaces allows the expression of complex hierarchies of interfaces. Optional interface methods are no longer needed because optionality is expressed through the DAG of interfaces. In addition to multiple inheritance, MultipleInterfaces.jl provides an enhanced version of multiple dispatch methods. These methods can dispatch on traditional Julia types for some arguments and interfaces for other arguments. They even allow dispatching on the intersection of interfaces, like `Iterator & Table`. And all this comes with no runtime penalty. We begin by providing an example of a hierarchy of graph types that motivates the need for multiple inheritance. Next, we show how to define interfaces, how to declare implementors of interfaces, and how to define methods that provide multiple dispatch on interfaces. Finally, we describe how to resolve the issues with the graph type hierarchy by replacing it with an interface hierarchy. false https://pretalx.com/juliacon-2025/talk/YQATV9/ https://pretalx.com/juliacon-2025/talk/YQATV9/feedback/ Lawrence Room 104 - Function Room Talk 2025-07-25T11:30:00-04:00 11:30 00:30 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. juliacon-2025-62175-fast-and-robust-least-squares-curve-fitting-in-julia Methods and Applications of Scientific Machine Learning (SciML) Chris Rackauckas en Solving nonlinear least squares problems lives in a very interesting part of the ecosystem. Naively, many would think that nonlinear least squares is very similar to nonlinear optimization, since after all it's solving a problem to minimize ||f(u)||_2 where ||.||_2 is the 2-norm (i.e. sum of squares). You can solve such a problem using a standard nonlinear optimization tool, like Optimization.jl or Optim.jl, but it turns out this is sub-optimal because it does not specialize on the special properties involved in the evaluation of the 2-norm. In the Julia ecosystem, we have traditionally had the package LsqFit.jl that fits into this part of this ecosystem with a Levenberg–Marquardt method. However, its implementation, along with many other implementations (such as those from SciPy) are not numerically stable, and thus can have convergence issues for many problems. This problem has been solved by integrating numerically stable and high-performance methods into NonlinearSolve.jl. The reason these methods are part of NonlinearSolve.jl and not an optimization package like Optimization.jl is because nonlinear least squares problems are actually more numerically similar to solving f(u)=0 than it is to doing an optimization. The reason for this is subtle. Newton's method is equivalent to the process of "linearize my function f at u, solve where the zero is to get a new u, and repeat". If you change that process to "linearize my function f at u, solve the least squares problem for the linear f to get a new u, and repeat", then you now have the generalization of Newton's method to nonlinear least squares problems, which is known as Gauss-Newton. The naive way of doing this is to simply change the Jacobian J in Newton to the square form J'J, that's all that's required! The downside of this form is that is the numerically unstable aspect of the aforementioned algorithms because this squares the condition number. Instead, if you replace the LU factorization with a QR factorization, the natural result that a QR factorization gives the solution to a linear least squares problem is precisely the solution. In other words, solving nonlinear least squares problems is the same as solving nonlinear systems of equations except you now allow for non-square Jacobians and you use QR factorizations instead of LU factorizations. Everything from Levenburg-Marquardt and beyond then simply falls out of this formulation, it's all numerically stable, and gives generalizations to line searches and trust regions to help ensure global convergence. While that result is beautiful in its own right, it gives an odd aspect to the Julia ecosystem: the fastest and most robust nonlinear least squares solvers are in a package called NonlinearSolve.jl, which is not a package that mentions nonlinear optimization or nonlinear least squares in its name. So what do we do about discoverability, and how do we share this more widely with the community? The end of this is meant to be a discussion, since we really don't know at this point. Should we make a separate package NonlinearLeastSquares.jl that simply re-exports NonlinearSolve.jl and documents the nonlinear least squares tooling separately? Do we use a name like CurveFit that more matches the SciPy naming, but doing the same thing? Are there other ways to lead people towards this tooling? We don't know, but hopefully this talk will help people throughout the Julia ecosystem better understand how we got into the current situation to better brainstorm how to solve the last steps of the discoverability problem. false https://pretalx.com/juliacon-2025/talk/ZXBGVK/ https://pretalx.com/juliacon-2025/talk/ZXBGVK/feedback/ Lawrence Room 104 - Function Room Lunch Break 2025-07-25T12:00:00-04:00 12:00 01:30 Enjoy a meet and greet with ASML, Silver Sponsor of JuliaCon 2025 and big supporter of the conference in prior years. juliacon-2025-78194-meet-and-greet-with-asml General en Enjoy a meet and greet with ASML, Silver Sponsor of JuliaCon 2025 and big supporter of the conference in prior years. false https://pretalx.com/juliacon-2025/talk/9UJH8M/ https://pretalx.com/juliacon-2025/talk/9UJH8M/feedback/ Lawrence Room 104 - Function Room Talk 2025-07-25T13:30:00-04:00 13:30 00:30 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. juliacon-2025-64152-exploring-acasual-model-augmentation-with-neural-networks Methods and Applications of Scientific Machine Learning (SciML) Fredrik Bagge CarlsonSebastian Micluța-Câmpeanu en In this talk we will discuss about how to augment acasual models in the ModelingToolkit framework and about how does the architecture impact the kind of corrections we can make. The initial paper on UDEs [1], a methodology is described for systems of differential equations, but in the context of acasual models we start with sets of differential algebraic equations (DAEs) for each component and then a simplification algorithm condenses them in a final system of DAEs that will be solved. This two stage nature of the process naturally divides the possible UDE architectures in two: before structural simplification, where we have we deal with individual components and after simplification where we only have the final simplified system without a direct link to the individual components. We will call these component level UDEs and system level UDEs. In the case of component level UDEs, we can describe the neural network correction via components too. The ModelingToolkitNeuralNets.jl package provides a block component that abstracts a Lux.jl neural network. This block componet can be then used as any other component from the ModelingToolkitStandardLibrary. In the case of system level UDEs we only have access to the final system of DAEs generated by structural simplification and thus the corrections cannot be expressed at the symbolic level. As such, it can be harder to decide what equations to change with the neural network. This talk will present some approaches based on sensitivity analysis that can help us decide what equations to target. The presentation will also showcase how JuliaSim can be used to easily build UDEs. The slides are available at https://github.com/SebastianM-C/JuliaCon2025_MTKNN [1] C. Rackauckas et al., “Universal Differential Equations for Scientific Machine Learning,” arXiv:2001.04385 [cs, math, q-bio, stat], Jan. 2020, Accessed: Feb. 09, 2020. [Online]. Available: http://arxiv.org/abs/2001.04385 false https://pretalx.com/juliacon-2025/talk/X8PS8Q/ https://pretalx.com/juliacon-2025/talk/X8PS8Q/feedback/ Lawrence Room 104 - Function Room Talk 2025-07-25T14:00:00-04:00 14:00 00:30 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. juliacon-2025-64099-universaldiffeq-jl-applying-sciml-to-ecology Methods and Applications of Scientific Machine Learning (SciML) Jack H Buckner en Ecological systems can exhibit complex patterns of change over time, including chaotic dynamics and rapid changes in state, which are called regime shifts. These patterns are caused by nonlinear interactions between species within the ecosystem and external factors, including climate change. Models that capture these nonlinear relationships are critical for understanding the causes of the past and predicting future changes within ecosystems. Theoretical ecologists have developed various mathematical models using differential equations that demonstrate how biological mechanisms can give rise to the complex emergent behaviors observed in ecosystems. However, these models make strong assumptions about functional forms and can often cause them to fail when confronted with data. Universal differential equations are a form of scientific machine learning that incorporates artificial neural networks into systems of differential equations. This combination allows UDEs to encode known biological mechanisms and constraints through the structure of the differential equations while learning unknown relationships from the data with neural networks. UniversalDiffEq.jl provides an easy-to-use front end for building UDEs that leverages the Julia SciML ecosystem. The package allows the user to choose between several training routines, including a novel approach that embeds the UDEs within a state-space modeling framework. This state-space approach is designed to increase the stability of training on noisy and highly variable time series data common in ecology. We use simulated and empirical data sets to show that UDEs trained using the state-space approach can successfully learn complex nonlinear species interactions that cause regime shifts in ecological systems. Furthermore, they can outperform common alternatives for forecasting ecological systems with chaotic and osculating dynamics. My talk will cover the design of the UniversalDiffEq.jl package and several example applications to illustrate lessons learned from applying UDEs to problems in ecology. We have found that the skill of UDEs at learning nonlinear relationships from time series depends in large part on the type of dynamics they exhibit. UDEs performed well at both inference and forecasting for time series with oscillating and chaotic dynamics but only performed well on inference tasks when the data exhibited regime shifts. Universal differential equations and scientific machine learning in general, are promising tools for understating ecological change. Tools like UniversalDiffEq.jl that lower the barrier for applied researchers to access these tools can help encourage their adoption and foster new insights into complex ecological systems. false https://pretalx.com/juliacon-2025/talk/CPGF7V/ https://pretalx.com/juliacon-2025/talk/CPGF7V/feedback/ Lawrence Room 104 - Function Room Talk 2025-07-25T14:30:00-04:00 14:30 00:30 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. juliacon-2025-64890-optimizing-gaussian-basis-sets-with-automatic-differentiation Methods and Applications of Scientific Machine Learning (SciML) Letícia Madureira en In quantum chemistry, Gaussian basis sets are essential for approximating molecular wavefunctions, where a complete basis set represents an infinite set of functions approaching the exact solution of the Schrödinger equation. Achieving completeness in these basis sets is crucial for high-precision molecular modeling and simulations. However, this completeness is often limited by practical computational constraints, making optimization a key step in enhancing the accuracy of quantum chemical calculations. The BasisSets.jl package in Julia addresses this challenge by leveraging the language's high-performance computing and advanced AD features. Julia’s efficient handling of AD is particularly advantageous for optimizing basis sets, enabling automatic and precise calculation of derivatives, a vital component in this optimization process. This talk will provide an insightful overview of what constitutes a complete basis set and the significance of its optimization in quantum chemistry. We will demonstrate how BasisSets.jl facilitates this optimization, leading to more accurate and computationally efficient quantum chemical calculations. The ability to optimize Gaussian basis sets to near-completeness has profound implications for molecular dynamics, material science, and drug design, where precise molecular modeling is paramount. Attendees will gain an understanding of the challenges in achieving complete basis sets, the role of Julia and BasisSets.jl in overcoming these challenges, and how this optimization enhances the capabilities of quantum chemistry. The session will feature practical examples, showcasing the application and impact of optimized basis sets in real-world quantum chemical problems, by exploring the BasisSets.jl package, another implementation within the HartreeFoca organization, focused on open source for modern electronic structure methods. false https://pretalx.com/juliacon-2025/talk/BQNDZT/ https://pretalx.com/juliacon-2025/talk/BQNDZT/feedback/ Lawrence Room 104 - Function Room Talk 2025-07-25T15:00:00-04:00 15:00 00:30 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. juliacon-2025-63776-experimental-design-for-missing-physics Methods and Applications of Scientific Machine Learning (SciML) Arno StrouwenSebastian Micluța-Câmpeanu en Model-based approaches are commonly used in the analysis, control and optimization of biosystems. These models rely on knowledge of physical, chemical and biological laws, such as conservation laws, transport phenomena and reaction kinetics, which are usually described by a system of non-linear differential equations. Often our knowledge of the laws acting on the system is incomplete. These gaps in our knowledge are also referred to as missing physics. Experimental data can be used to fill in such missing physics. Universal Differential Equations (UDE) have recently been proposed to learn the missing parts of the structure. These UDE use neural networks to represent terms of the model for which the underlying structure is unknown. Because the opaque nature of neural networks is often not desirable in a scientific computing setting, UDE based techniques are often combined with interpretable machine learning techniques, such as symbolic regression. These techniques post-process the neural network to a human-readable model structure. Because neural networks are data-hungry, it is important that these applications gather highly informative data. However, current model based design of experiment (MbDoE) methodology focuses on parameter precision or discriminating between a finite number of possible model structures. When part of the model structure is entirely unknown, neither of these techniques can be directly applied. In this presentation, we propose an efficient data gathering technique for filling in missing physics with a universal differential equation, made interpretable with symbolic regression. More specifically, a sequential experimental design technique is developed, where an experiment is performed to discriminate between the plausible model structures suggested by symbolic regression. The new data is then used to retrain the UDE, which leads to a new set of plausible model structures by applying symbolic regression again. This methodology is applied to a bioreactor, and is shown to perform better than a randomly controlled experiment, as showcased here: https://docs.sciml.ai/Overview/dev/showcase/optimal_data_gathering_for_missing_physics/ false https://pretalx.com/juliacon-2025/talk/J3HTVE/ https://pretalx.com/juliacon-2025/talk/J3HTVE/feedback/ Lawrence Room 104 - Function Room Talk 2025-07-25T15:30:00-04:00 15:30 00:30 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 juliacon-2025-63874-designing-sciml-components-in-modelingtoolkit-jl Methods and Applications of Scientific Machine Learning (SciML) Ashutosh BharambeDhairya Gandhi en Modeling and Simulation covers a vast array of problem types, and is heavily utilised in modern engineering. ModelingToolkit.jl (MTK) is a framework for defining high performance acausal systems in Julia. Scientific Machine Learning (SciML) leverages MTK's transparent design philosophy and Julia's excellent composition capabilities, to be able to train data driven physics informed models to accelerate otherwise computationally expensive simulations, or fit for missing physics from the first principles model. This talk focusses on how one can actually incorporate a Machine Learning component in an existing ODESystem defined using MTK. We demonstrate training a surrogate of a dynamical system, and then converting it into a usable component which MTK can consume. We will also discuss some methods for setting up the surrogatization problem properly. We will discuss how to prevent MTK from looking into the inference code to maintain speed. We will demonstrate how to properly setup a ML component and show how to replace the first-principle component we created a surrogate for. We will demonstrate the speedups we can observe with this surrogate and finally discuss alternate ways to "export" a ML model as a Functional Mockup Unit (FMU) which can also be used by other simulation platforms. We will also demonstrate the ModelingToolkitNeuralNets.jl package which allows creating neural network blocks which can generate MTK compatible components that can also be directly used. false https://pretalx.com/juliacon-2025/talk/BR8MMM/ https://pretalx.com/juliacon-2025/talk/BR8MMM/feedback/ Cathedral Room G24 - If Room Birds of Feather (BoF) 2025-07-25T10:00:00-04:00 10:00 01:00 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. juliacon-2025-63884-julia-in-hpc General /media/juliacon-2025/submissions/U7B78W/Julia_for_HPC_-_JuliaC_8rnFctu.png Mosè GiordanoJohannes Blaschke en The JuliaHPC working group meets monthly to discuss challenges and issues of using Julia in HPC. Building on the success of this format at previous JuliaCons and the well-received Julia BoF sessions at SuperComputing, we are looking forward to invite the wider Julia community again, and discuss Julia for high performance computing in person! false https://pretalx.com/juliacon-2025/talk/U7B78W/ https://pretalx.com/juliacon-2025/talk/U7B78W/feedback/ Cathedral Room G24 - If Room Birds of Feather (BoF) 2025-07-25T11:00:00-04:00 11:00 01:00 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. juliacon-2025-64146-supporting-gender-diversity-in-the-julia-community General Julia Gender Inclusive en The objective of this BoF is to create space for discussion and community building among people who feel their gender is underrepresented within the Julia community, as well as allies who want to support us. We aim to create a safe and fruitful discussion about diversity, increase awareness of our current initiatives, and brainstorm ways for the wider community to increase their involvement and commitment. false https://pretalx.com/juliacon-2025/talk/XBTJHK/ https://pretalx.com/juliacon-2025/talk/XBTJHK/feedback/ Cathedral Room G24 - If Room Birds of Feather (BoF) 2025-07-25T14:00:00-04:00 14:00 01:00 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. juliacon-2025-62989-sciml-roadmapping General Chris Rackauckas en This BoF will be a discussion of the SciML roadmap. We will start with a brief update from last years State of SciML JuliaCon talk, what has changed and what was successfully added, and open the floor for a discussion on what features the community would like to see, the difficulties and timelines involved, and understand use cases. Hopefully this also invites new contributors into the fold as well! false https://pretalx.com/juliacon-2025/talk/AQP9UM/ https://pretalx.com/juliacon-2025/talk/AQP9UM/feedback/ Cathedral Room G24 - If Room Birds of Feather (BoF) 2025-07-25T15:00:00-04:00 15:00 01:00 An hour for users of Makie.jl to gather, show off cool plots, and talk about the state of the Makie ecosystem! juliacon-2025-65076-makie-jl-bof General Anshul Singhvi en Will be pretty free-form - starting out with a 10-minute recap of what's happened in Makie world since last year, and then going to free-form discussion. I'll also ask around if people would like to show off their own packages or plots. false https://pretalx.com/juliacon-2025/talk/9SSM8W/ https://pretalx.com/juliacon-2025/talk/9SSM8W/feedback/ Cathedral Room 324 - Else Room Lightning talk 2025-07-25T10:00:00-04:00 10:00 00:10 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. juliacon-2025-62162-2025-julia-user-developer-survey General Andrew Claster en 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. false https://pretalx.com/juliacon-2025/talk/8FKBWU/ https://pretalx.com/juliacon-2025/talk/8FKBWU/feedback/ Cathedral Room 324 - Else Room Lightning talk 2025-07-25T10:10:00-04:00 10:10 00:10 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. juliacon-2025-64126-this-is-a-metaline-how-to-get-more-out-of-comments General Jeroen Sieburgh en What can be gained from embedding formalized metadata within comments? Lets consider **four, seemingly unrelated use cases** which together ought to resonate with the vast majority of JuliaCon's attendees: 1. Over time a large number of Julia files can accumulate. Wouldn't it be wonderful to speedily retrieve any, long forgotten poignant example, powerful code snippet, insightful explanatory statement or laboriously tweaked plot related to some task at hand? An instrument solving this problem might prove even more invaluable when collaborating in a group sharing a repository of files. 2. One might want to (inter)link a certain fragment of one file with another fragment, possibly contained in some other file. E.g.: linking an intricate piece of code to an enlightening explanation or a clarifying toy example. 3. Would you like to harness the power of `Documenter`, enjoying simplified control while sticking to pure Julia files rather than having to deal with additional markdown documents? More generally, a Julia file can serve as a source for all kinds of outputs. 4. Being able to control how individual chunks of code / text are being executed, respectively rendered, can be beneficial. E.g.: certain passages of a file might be intended for personal usage only. Marking them as such would allow automated removal before sharing. To illustrate how a set of meta instructions can offer a unified, efficient approach, lets introduce `GoLiterate`. This is an extended adaptation of the well established `Literate` by Fredrik Ekre et al. Thanks :-) The defining concept of `Literate` consists of storing chunks of code and text together in pure Julia files. These serve as source files which can subsequently be converted into a variety of formats such as notebooks, standard markdown or even documenter markdown files. A suitable system for metadata would **allow exerting precise control over these format's wide ranging capabilities from within the Julia source file**. `GoLiterate` is a fork of `Literate` to showcase this. So what does the proposed schema for metadata look like? Any line starting with `#~` is considered to be a `metaline` i.e.: it will be processed as metadata. **Contiguous metalines** constitute a coherent `block of metadata` separating it from others. By **positioning such a block just above a chunk of code or text** [no vertical spacing in between] the former gets attached to the latter – similar to how docstrings get associated with Julia structures following them. For the purpose of `inheritance`, a **hierarchy of blocks of metadata** can be defined by prepending one or more `#` to the first metaline of a given block which works analogously to markdown's syntax for titles. The current implementation of `GoLiterate` accepts `standard metalines` [more below] with its content consisting of key-value pairs where the keys are restricted to one word and the values may include general strings or vectors. Like this a `name` or `title` can be provided and `labels` can be applied. A `UID` is automatically generated and assigned to each block of metadata. This way a targeted search for particular sections of code or text becomes possible as well as interlinking various sections. The execution of some tasks may be so common that they are deserving of a simplified syntax to facilitate their usage. Others may benefit or even necessitate custom tailored metadata to enable full functionality, as is the case for instructions passed to `Documenter`. The current schema resolves this by introducing `specialized metalines`. E.g.: a leading `#~d` instructs the parser to process the subsequent content for the usage with `Documenter`. Appending a `!` to a metaline declaration, `#~!`, causes its content to be **retained but not processed**. All this is readily exemplified: ``` # Start file.jl #~ [Metadata Block 1] #~ ... code/text ##~ [Metadata Block 2] #~! #~ """ addone(x) This is a docstring for addone(). """ function addone(x) x += 1 end ... code/text #~ [Metadata Block 3] #~d jldoctest; output = false addone(2) # output 3 # End file.jl ``` Above three distinct blocks of metadata are presented. The second of which can inherit attributes from the first. While the second block is attached to a chunk and thus gets applied to it, the first block has no direct effect on any code or text chunk. Its attributes are only passed on indirectly through inheritance. Block 3 does not inherit anything from the blocks before since it's not a sub-block / sub-section of them. However, since it contains a *specialized metaline* meant for `Documenter`, the chunk of code following it will be fenced by ```` ```jldoctest; output = false … ``` ```` when targeting `Documenter`. Time permitting, the talk will be expanding on this brief overview. In the near future, AI will automate much of the labeling. Crucially, if this black box is confined within a formalized framework of metadata, it can become train- and tunable. false https://pretalx.com/juliacon-2025/talk/7KG3WJ/ https://pretalx.com/juliacon-2025/talk/7KG3WJ/feedback/ Cathedral Room 324 - Else Room Lightning talk 2025-07-25T10:20:00-04:00 10:20 00:10 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. juliacon-2025-65072-shipping-your-julia-app-in-an-air-gapped-environment General Harsha Byadarahalli Mahesh en Julia apps have specific deployment characteristics that differentiate them from other applications, especially when considering air-gapped systems. This talk is based on over eight years of practical experience developing and maintaining Julia-based products like JuliaPro and Pumas (https://pumas.ai/pumas), we will focus on the following aspects with a particular emphasis on air-gapped environments: 1. Notarization and code-signing your Julia app:- Julia binaries might be code-signed and notarized but your Julia app will be shipping lot more than a Julia binary, so you need to notarize and code-signing your Julia app using a dedicated certificate that's recognized by the operating systems. On MacOS, whenever you try to install an app, Gatekeeper performs an online check with Apple's servers to check the authenticity of the app, this is troublesome in air-gapped environments because the OS cannot connect to Apple servers, we will face similar issues while verifying the authenticity of the binaries on Windows and Linux as well. In this talk, we will share tips and tricks to work-around these issues on all 3 major operating systems (Mac, Windows and Linux) and provide guidelines to make sure your Julia app is usable on all 3 major OS’es without putting the hassle of whitelisting (Or bypassing the operating system security process for) your app on the end-user’s side. 2. Air-Gapped Deployment Challenges: This talk will focus on the specific hurdles of deploying Julia apps in air-gapped environments, including dependency management, updates, and data transfer, and provide practical solutions. 3. User Environment Management: Julia dependencies (artifacts, registries, package source code, environments, etc.) included in your app may be deployed in distributed (roaming profiles) and multi-user environments. We'll discuss how your Julia app should handle these diverse environments, and also provide critical considerations when dealing with potentially isolated user setups within air-gapped networks. 4. License Management can be particularly tricky in air-gapped environments, because you don’t have an option to cross-check the license with your public license servers. We will share ways to integrate a license manager in your Julia app and also provide guidelines on how to handle license activations in an Air-Gapped environment. false Presentation PDF https://pretalx.com/juliacon-2025/talk/C9AGV7/ https://pretalx.com/juliacon-2025/talk/C9AGV7/feedback/ Cathedral Room 324 - Else Room Talk 2025-07-25T10:30:00-04:00 10:30 00:30 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. juliacon-2025-65044-flexijoins-jl-the-ultimate-package-for-dataset-joining General Alexander (Sasha) Plavin en FlexiJoins.jl is crafted to be the most flexible and generic package for dataset/table joining – and not just among Julia libraries. Thanks to Julia's multiple dispatch, it achieves this while remaining user-friendly and efficient. In particular, FlexiJoins provides the following with a uniform interface and performantly – without falling back to nested loop joins: - A wide range of join conditions: from simple equality to intervals, ranges, and arbitrary distance measures, including combinations of these; - Various join options: all matches or the closest match, left or right joins, flat results or grouped by one side; - Compatible with a variety of dataset types: Julia collections such as Vectors or Dictionaries, specialized table types like DataFrames, and experimental support for SQL databases through SQLCollections.jl. In the talk, I'll explore the overall design of FlexiJoinsthat allows for such flexibility. The package uses asymptotically optimal algorithms (hash-/sort-/tree-based), ensuring no join operation falls back to the naive O(n^2) path by default. Looking ahead, incorporating heuristics for specific cases can be useful to stay competitive with heavily optimized specialized join implemenetations. FlexiJoins is applicable in a wide range of scenarios already, and I invite feedback on its interface and potential extension points to support additional use cases. false https://pretalx.com/juliacon-2025/talk/WBXGYT/ https://pretalx.com/juliacon-2025/talk/WBXGYT/feedback/ Cathedral Room 324 - Else Room Talk 2025-07-25T11:00:00-04:00 11:00 00:30 This talk discusses our efforts to enhance the Dyad 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. juliacon-2025-63764-automating-testing-and-documentation-generation-for-dyad General Michael Tiller en In Dyad, users can create a wide variety of component models across many different physical domains. Furthermore, they can assemble these components into fairly complex hierarchical subsystem and system models. An interesting consequence of making it so easy to create modeling content is that you wind up with a large collection of models. As a result, it could be potentially difficult to write and maintain documentation for all these models. In addition to the work required to provide high quality documentation, another aspect of quality is ensuring that the models are sufficiently tested. It isn't simply a question of ensuring that a model is correct when you create it. It is important to ensure that as the models are changed, improvements to those model (new functionality, improved efficiency) don't cause existing models to stop working. So some form of regression testing is required to address this. Furthermore, in cases where the original models were actually incorrect, it is necessary to understand what impact that bug fix has across all existing models. This talk will show how we tackle both of these problems. The Dyad toolchain allows model developers to not only automatically generate documentation for their existing component libraries but it also provides extensive support for regression testing that is not only integrated with Julia's builtin testing capabilities but also connects to the documentation system to provide visual representations of the model reference data against actual simulated results. false https://pretalx.com/juliacon-2025/talk/WYUASV/ https://pretalx.com/juliacon-2025/talk/WYUASV/feedback/ Cathedral Room 324 - Else Room Talk 2025-07-25T11:30:00-04:00 11:30 00:30 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. juliacon-2025-64991-vulkan-jl-cross-platform-graphics-on-the-gpu General Cédric Belmant en [Vulkan.jl](https://github.com/JuliaGPU/Vulkan.jl) is a lightweight wrapper around the [Vulkan](https://www.vulkan.org/) graphics and compute library. It exposes abstractions over the underlying C interface, primarily geared towards developers looking for a more natural way to work with Vulkan with minimal overhead. It builds upon the core API provided by [VulkanCore.jl](https://github.com/JuliaGPU/VulkanCore.jl/), but because Vulkan is originally a C specification, interfacing with it requires some knowledge to be used correctly from Julia. This package acts as an abstraction layer, so that one doesn't need to deal with C interoperability details, while still retaining full functionality and maximum performance. After detailing the motivations to provide such a wrapper, this talk will present the various challenges encountered while interfacing with the Vulkan API, in the hope that it may help other developers deal with complex C interfacing concerns. Many of the patterns encountered in this API are very common; we will show how we abstracted them away using features available in the Julia language, to provide a more convenient API without sacrificing functionality. We will then proceed to show how productive it is in enabling access to the Vulkan API, and demonstrate a few applications to get a feel for the capabilities unlocked by combining Vulkan with an idiomatic Julia interface. false Slides https://pretalx.com/juliacon-2025/talk/JWJNGB/ https://pretalx.com/juliacon-2025/talk/JWJNGB/feedback/ Cathedral Room 324 - Else Room Talk 2025-07-25T13:30:00-04:00 13:30 00:30 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. juliacon-2025-64540-reviving-opencl-jl-for-cpu-glory JuliaGPU minisymposium Tim Besard en This talk will explore the revival of OpenCL.jl, one of Julia's oldest GPU programming packages. We'll detail how we modernized and integrated it with the JuliaGPU stack by implementing the GPUArrays.jl interfaces, developing a SPIR-V compiler based on GPUCompiler.jl, and adding KernelAbstractions.jl support. These changes enable programming modern OpenCL accelerators using native Julia code, similar to CUDA.jl or AMDGPU.jl. Building on this foundation, we enhanced support for the Portable OpenCL (PoCL) library as a backend for OpenCL.jl. PoCL's key feature is CPU execution of OpenCL kernels, leveraging multithreading and SIMD instructions for acceleration. This functionality is now readily available through the pocl_jll package and integrates seamlessly with OpenCL.jl. The culmination of this work is a new CPU backend for KernelAbstractions.jl that combines PoCL's CPU capabilities with GPUCompiler.jl's SPIR-V code generation. This backend addresses the limitations of the current Julia tasks-based implementation, significantly improving both the portability and performance of KernelAbstractions.jl. We'll demonstrate these improvements through practical examples and benchmarks. false https://pretalx.com/juliacon-2025/talk/WX7JLQ/ https://pretalx.com/juliacon-2025/talk/WX7JLQ/feedback/ Cathedral Room 324 - Else Room Talk 2025-07-25T14:00:00-04:00 14:00 00:30 In this talk on [TrajectoryBundles.jl](https://github.com/aarontrowbridge/TrajectoryBundles.jl), we will discuss the implementation of [the Trajectory Bundle Method](https://kestrelquantum.github.io/Piccolo.jl/docs/) in Julia leveraging DiffEqGPU.jl. This approach to trajectory optimization is derivative-free, and instead leverages GPU-based ODE solvers and convex optimization. juliacon-2025-65070-trajectorybundles-jl-parallelizable-derivative-free-traj-opt JuliaGPU minisymposium Aaron Trowbridge en The Trajectory Bundle Method](https://kestrelquantum.github.io/Piccolo.jl/docs/) was developed in [the Robotic Exploration Lab](https://rexlab.ri.cmu.edu/) at Carnegie Mellon University as part of the doctoral dissertation of Kevin Tracy. This derivative-free trajectory optimization method leverages the ability of computers to massively sample trajectories of dynamical systems and transform that data into a quadratic program at each optimization step. This is ongoing research and a paper is currently under review. [TrajectoryBundles.jl](https://github.com/aarontrowbridge/TrajectoryBundles.jl) utilizes the rich ecosystem for solving differential equations, in particular, the package DiffEqGPU.jl to solve ODEs in parallel on GPUs massively. We also leverage Convex.jl and Clarabel.jl to solve a QP at each iteration. Given recent announcements from Nvidia -- e.g. [cuDSS](https://developer.nvidia.com/cudss) -- we are very excited to leverage massively parallel computing in even more facets of this approach. false https://pretalx.com/juliacon-2025/talk/YL8GME/ https://pretalx.com/juliacon-2025/talk/YL8GME/feedback/ Cathedral Room 324 - Else Room Lightning talk 2025-07-25T14:30:00-04:00 14:30 00:10 This session provides a brief introduction to our new package, TrixiCUDA.jl, which offers CUDA acceleration support for solving hyperbolic PDEs on GPU. juliacon-2025-60684-trixicuda-jl-cuda-support-for-solving-hyperbolic-pdes-on-gpu JuliaGPU minisymposium Huiyu Xie en Trixi.jl has provided a numerical simulation framework for solving PDEs on CPU for years, but it lacks GPU support for greater acceleration. TrixiCUDA.jl is designed to address this gap by serving as an acceleration package for Trixi.jl, offering CUDA-based support for solving PDEs on GPU. This new package is implemented based on CUDA.jl from JuliaGPU and Trixi.jl from the Trixi-Framework. Its current acceleration efforts focus on the computationally intensive core of the PDE solver: semidiscretization—a high-level description of spatial discretizations specialized for certain PDEs. GPU kernels are implemented to achieve high-performance semidiscretization on GPU, and minor optimizations are applied to further enhance performance. The package is currently under active development, testing, and optimization. Future steps will focus on the deep optimization of GPU kernels and initiating the migration of the mesh initialization process to GPU. TrixiCUDA.jl on GitHub: https://github.com/trixi-gpu/TrixiCUDA.jl Comprehensive Documentation: https://trixi-gpu.github.io Draft Talk Slides (Latest update on August 5, 2025): https://trixi-gpu.github.io/assets/files/juliacon25.pdf false https://pretalx.com/juliacon-2025/talk/EFYUBD/ https://pretalx.com/juliacon-2025/talk/EFYUBD/feedback/ Cathedral Room 324 - Else Room Lightning talk 2025-07-25T14:40:00-04:00 14:40 00:10 Latest changes, features and performance improvements in AMDGPU.jl which provides AMD GPU programming support in Julia. juliacon-2025-65067-what-s-new-in-amdgpu-jl JuliaGPU minisymposium Julian P Samaroo en This talk covers latest developments in AMD GPU programming using AMDGPU.jl package and its future directions. false https://pretalx.com/juliacon-2025/talk/9QRAXE/ https://pretalx.com/juliacon-2025/talk/9QRAXE/feedback/ Cathedral Room 324 - Else Room Lightning talk 2025-07-25T14:50:00-04:00 14:50 00:10 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. juliacon-2025-64835-what-s-new-and-improved-in-cuda-jl JuliaGPU minisymposium Katharine Hyatt en CUDA.jl is one of the most mature and widely used libraries in the JuliaGPU family. Much of the HPC, SciML, and graphics stack depends on it. In this talk we will communicate many of the improvements the development team has made over the past year and demonstrate why and how they're useful for a variety of audiences. We'll cover both the "core" CUDA stack for integrating with the device, its driver, and its runtime, as well as the improvements to the wrappers for various application libraries such as CUBLAS, CUFFT, and more. false Slides https://pretalx.com/juliacon-2025/talk/VTVVMG/ https://pretalx.com/juliacon-2025/talk/VTVVMG/feedback/ Cathedral Room 324 - Else Room Talk 2025-07-25T15:00:00-04:00 15:00 00:30 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. juliacon-2025-64973-acceleratedkernels-jl-cross-architecture-parallel-algorithms JuliaGPU minisymposium Andrei-Leonard Nicusan en In this talk I present AcceleratedKernels.jl, a library that provides a unified interface for writing parallel algorithms in Julia. The library is built on KernelAbstractions.jl, which allows high-level Julia code to be compiled into efficient kernels for a range of hardware. AcceleratedKernels.jl supports both multithreaded CPUs and GPUs from several vendors (CUDA, ROCm, oneAPI, Metal) using a single codebase. This design removes the need to write separate code for each target, making it easier for developers to write and maintain high-performance applications. Key points in the talk include: - Unified Codebase: I describe how the same Julia user-code can be used to produce high-performance kernels for different hardware. - Performance Benchmarks: I will present benchmark results that compare AcceleratedKernels.jl with traditional implementations. Benchmarks for operations like sorting, mapreduce, and arithmetic computations show that the performance of kernels generated by AcceleratedKernels.jl is comparable to that of code written in C with OpenMP (on CPUs) and vendor libraries like Nvidia Thrust (on GPUs). These tests have been run on different architectures, from desktop CPUs to data-center GPUs, and the results demonstrate competitive speed and scalability. - Developer Experience: I will show how to write custom kernels in Julia with minimal changes to existing code - with the aim of writing a user application / library that transparently works across architectures, without special-cased kernels for GPUs or explicit multithreading. This also allows composable CPU-GPU co-processing across Julia libraries. - Real-World Applications: I will discuss several use cases from scientific computing and industry where the ability to run the same code on different hardware is valuable. Examples include multi-node data sorting and numerical simulations - in particular Lagrangian simulations such as the Discrete Element Method, Molecular Dynamics, or N-Body Simulations - where parallel execution is critical. - Future Work: I will outline planned improvements for AcceleratedKernels.jl, such as adding automated tuning for algorithm parameters, extending the range of available algorithms, and supporting emerging hardware platforms. I also discuss how contributions from the community can help shape the future of the library. AcceleratedKernels.jl was created to simplify parallel programming by reducing the need for hardware-specific code. Instead of writing separate kernels for each target, developers write a single function that runs across all supported devices. The talk will also include a live demonstration. I will write a simple kernel in Julia and show how it runs on both a CPU and a GPU without any modifications. I will discuss some challenges encountered during development, such as algorithm and interface design choices. Finally, I will place AcceleratedKernels.jl within the broader Julia ecosystem and show its composability across separate libraries. In summary, this session provides a detailed overview of AcceleratedKernels.jl, covering its design, performance, and practical applications. Attendees will learn how to write portable parallel code in Julia using a single, unified API and understand the trade-offs involved in cross-architecture programming. This talk is aimed at developers, researchers, and anyone interested in high-performance computing with Julia, and it offers practical insights into writing code that runs efficiently on modern hardware. false https://pretalx.com/juliacon-2025/talk/7RLZAL/ https://pretalx.com/juliacon-2025/talk/7RLZAL/feedback/ Cathedral Room 324 - Else Room Talk 2025-07-25T15:30:00-04:00 15:30 00:30 In this panel we'll sum up where the wider JuliaGPU ecosystem is today and invite feedback from developers and users on where we should focus efforts in the year to come. juliacon-2025-78122-juliagpu-panel-discussion-where-to-go-from-here JuliaGPU minisymposium Tim BesardJulian P SamarooKatharine Hyatt en In this panel we'll sum up where the wider JuliaGPU ecosystem is today and invite feedback from developers and users on where we should focus efforts in the year to come. false https://pretalx.com/juliacon-2025/talk/CWARJQ/ https://pretalx.com/juliacon-2025/talk/CWARJQ/feedback/ Lawrence Room 107 - Method Room Birds of Feather (BoF) 2025-07-25T10:00:00-04:00 10:00 01:00 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! juliacon-2025-63068-dagger-jl-birds-of-a-feather General /media/juliacon-2025/submissions/HMND8A/Final-medium_ZaJzwZI.jpg Julian P SamarooRabab AlomairyFelipe Tomé en Dagger.jl is a rising star in the landscape of High Performance Computing, striving to make parallel computing easy and productive for everyone. Dagger has grown significantly over the last few years, and many more improvements are already planned for 2025. But during this BoF, we want to hear from you, the community, to understand why you do (or don't) use Dagger to solve your problems, and how Dagger can do better. We welcome both positive feedback and negative constructive criticism, and would like to find out what you want to see change in Dagger in 2025, 2026, and beyond! We welcome past and current users of Dagger, and also those just interested in sitting in to learn more about Dagger. false https://pretalx.com/juliacon-2025/talk/HMND8A/ https://pretalx.com/juliacon-2025/talk/HMND8A/feedback/ Lawrence Room 107 - Method Room Talk 2025-07-25T11:00:00-04:00 11:00 00:30 This talk introduces Reactant, a tool for optimizing existing Julia programs through MLIR and XLA. Reactant preserves high level semantics already found in Julia programs (like linear algebra) to enable novel optimizations that cross function boundaries, rewrite programs to effectively execute on any hardware backend (including rewriting CUDA programs to run on thousands of distributed TPUs), and combines with Enzyme to provide high-performance multi-backend differentiation. juliacon-2025-71230-reactant-optimize-julia-functions-with-mlir-xla Machine Learning Minisymposium William Moses en This talk introduces Reactant, a tool for optimizing existing Julia programs through MLIR and XLA. Reactant preserves high level semantics already found in Julia programs (like linear algebra) to enable novel optimizations that cross function boundaries, rewrite programs to effectively execute on any hardware backend (including rewriting CUDA programs to run on thousands of distributed TPUs), and combines with Enzyme to provide high-performance multi-backend differentiation. false https://pretalx.com/juliacon-2025/talk/X7EVKM/ https://pretalx.com/juliacon-2025/talk/X7EVKM/feedback/ Lawrence Room 107 - Method Room Talk 2025-07-25T11:30:00-04:00 11:30 00:30 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. juliacon-2025-63876-accelerating-machine-learning-in-julia-using-lux-reactant Machine Learning Minisymposium Avik Pal en We will cover the following topics: 1. Compiling Lux models using Reactant and EnzymeJAX 2. Model-Parallel and Data-Parallel Training: Implement scalable training strategies in Lux.jl using Reactant.jl and OpenXLA for distributing models and data across multiple devices. 3. Compiler Optimizations with Enzyme and JAX. 4. Debugging Performance with TensorBoard Profiler: Use TensorBoard Profiler to identify and resolve performance bottlenecks in training and inference pipelines. 5. Visualizing Models with Model Explorer: Explore and analyze neural network architectures interactively using Model Explorer for better debugging and understanding. 6. Exporting Models to JAX and TensorFlow: Seamlessly export trained models from Lux.jl to JAX and TensorFlow for deployment in production environments. false https://pretalx.com/juliacon-2025/talk/KBVHS8/ https://pretalx.com/juliacon-2025/talk/KBVHS8/feedback/ Lawrence Room 107 - Method Room Talk 2025-07-25T13:30:00-04:00 13:30 00:30 This talk introduces GraphNeuralNetworks.jl, a Julia-based framework for deep learning on graphs. It supports both dense and sparse graphs, multiple GPU backends, and flexible manipulation of standard, heterogeneous, and temporal structures. The framework provides gather/scatter message-passing primitives for defining custom layers, along with a collection of standard layers for rapid prototyping. Real-world use cases and ongoing developments will also be discussed. juliacon-2025-71225-graphneuralnetworks-jl-deep-learning-on-graphs-with-julia Machine Learning Minisymposium Aurora Rossi en In this talk, I will introduce GraphNeuralNetworks.jl, an open-source framework for deep learning on graphs, developed in the Julia programming language. Designed for flexibility and performance, the library supports multiple GPU backends and works seamlessly with both sparse and dense graph representations. I’ll show how it enables intuitive manipulation of standard, heterogeneous, and temporal graphs, with full support for attributes at the node, edge, and graph levels. The framework allows users to define custom graph convolutional layers using gather/scatter message-passing primitives and includes a suite of popular layers for rapid experimentation. I will also highlight real-world use cases and ongoing developments within the ecosystem. false https://pretalx.com/juliacon-2025/talk/JSZA8C/ https://pretalx.com/juliacon-2025/talk/JSZA8C/feedback/ Lawrence Room 107 - Method Room Talk 2025-07-25T14:00:00-04:00 14:00 00:30 [EvoTrees.jl](https://github.com/Evovest/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. juliacon-2025-71228-evotrees-jl-efficient-boosted-trees-on-cpus-gpus-in-julia Machine Learning Minisymposium Jeremie Desgagne-Bouchard en Key topics covered: 1. Key steps in gradient-boosted trees algorithm: binarization, build histogram, best split search, prediction. 2. EvoTrees approach to reconcile ease of research and achieving performance comparable to its C++ peers 3. Minimal benchmark against `XGBoost`, `LightGBM` and `CatBoost` 4. Beyond gradient-based learning: mean-absolute error and volatility-adjusted losses 5. Future development paths: improved GPU acceleration, auto-diff support for custom and multi-target losses and enhanced support of categorical variables. false https://pretalx.com/juliacon-2025/talk/8L9PRA/ https://pretalx.com/juliacon-2025/talk/8L9PRA/feedback/ Lawrence Room 107 - Method Room Talk 2025-07-25T14:30:00-04:00 14:30 00:30 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. juliacon-2025-62929-secure-and-local-copilots-powered-by-open-source-llms-and-julia Machine Learning Minisymposium Shivay Lamba en In this talk, we’ll see 1. Introduction to Local AI (5 minutes): Overview of cloud-based AI privacy issues and the importance of local AI. 2. Exploring Ollama, Open Source Vector Databases like QrandantDB , LangChain: Detailed insights into each tool, generating embeddings with Ollama for vector searches in vector databases like QrandantDB and demonstrating how LangChain agents can perform tasks such as document summarization and API interactions, all while maintaining data privacy (10 minutes) 3. Live Demo and Applications (15 minutes): A practical demonstration of these tools and discussion of real-world use cases by implementing Ollama Using a simple Julia client scripts to connect to Ollama ( local LLM ) and generates Julia code false https://pretalx.com/juliacon-2025/talk/RCMHGU/ https://pretalx.com/juliacon-2025/talk/RCMHGU/feedback/ Lawrence Room 107 - Method Room Talk 2025-07-25T15:00:00-04:00 15:00 00:30 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. juliacon-2025-64779-enhancing-deterministic-voice-control-with-llm-interaction Machine Learning Minisymposium Samuel Omlin en Large Language Models (LLMs) are rapidly advancing, with increasingly cost-effective training and inference, and the emergence of powerful, compact models such as distilled variants of DeepSeek. These models can now be executed efficiently on commodity hardware, opening new avenues for offline applications. Operating offline offers significant advantages, most notably maintaining data privacy by ensuring all information processing remains local to the user's device. Furthermore, offline execution reduces latency, enabling efficient processing of small, routine tasks within a fraction of a second. One compelling use case is the development of voice assistants that leverage LLMs for intelligence while maintaining strict control over system operations. While LLM-based AI agents can reason, generate text, and even execute predefined actions, granting them unrestricted control over a personal computer poses safety risks due to potential hallucinations and ambiguous user inputs. To address this, we present an approach that integrates deterministic voice control with LLM-enhanced interactions, enabling safe and efficient offline voice assistants. This approach is implemented in the Julia package [JustSayIt.jl](https://github.com/omlins/JustSayIt.jl). This talk focuses on the enhancement of the initially purely deterministic voice control application (see the [paper](https://proceedings.juliacon.org/papers/10.21105/jcon.00121) [1], the [2022 talk](https://www.youtube.com/watch?v=W7oQb7pLc04with) [2], and the [2023 talk](https://www.youtube.com/watch?v=_gpH-mkrdGM) [3]) with LLM technology. [JustSayIt.jl](https://github.com/omlins/JustSayIt.jl) can operate entirely offline, utilizing locally installed LLMs via Ollama, with model management and interaction handled through Python packages such as ollama, accessed via PyCall. LLM interactions are streamlined by incorporating dynamic context such as selected text and clipboard content. This enables, for example, near-instantaneous text summaries or translations via single-word voice commands. More complex tasks are enabled by directly forwarding free speech to the LLM, and the LLM output can be instantly converted to audio output using a text-to-speech engine. As a result, almost human-like interaction with the LLM is possible. For speech recognition, [JustSayIt.jl](https://github.com/omlins/JustSayIt.jl) employs a dual approach: lightweight, low-latency constrained speech recognition using Vosk for deterministic commands and high-accuracy free speech recognition via a faster reimplementation of OpenAI's Whisper for natural language interactions. The system automatically switches between these engines to optimize responsiveness and accuracy, ensuring seamless voice control and LLM interaction without performance bottlenecks. The approach presented here bridges a crucial gap in human-AI interaction by enabling the seamless integration of LLM intelligence into small, everyday tasks where traditional LLM-chat interactions are overly cumbersome and time-consuming. By combining deterministic, low-latency voice control with LLM capabilities and leveraging offline execution of distilled LLM models, this solution ensures privacy, efficiency, and performance. With limitless customizability and programmability, [JustSayIt.jl](https://github.com/omlins/JustSayIt.jl) empowers users to create their ideal, AI-powered voice assistant tailored to their individual needs. References: [1] Omlin, S. (2024). JustSayIt.jl: A Fresh Approach to Open Source Voice Assistant Development. The Proceedings of the JuliaCon Conferences, 6(66), 121, https://doi.org/10.21105/jcon.00121 [2] Omlin, S. (2022). JustSayIt.jl: A Fresh Approach to Open Source Voice Assistant Development. JuliaCon 2022 conference, 2022. https://www.youtube.com/watch?v=W7oQb7pLc04 [3] Omlin, S. (2023). Quick Assembly of Personalized Voice Assistants with JustSayIt. JuliaCon 2023 conference, 2023. https://www.youtube.com/watch?v=_gpH-mkrdGM false https://pretalx.com/juliacon-2025/talk/SURQTD/ https://pretalx.com/juliacon-2025/talk/SURQTD/feedback/ Lawrence Room 120 - REPL Main Stage Hackathon 2025-07-26T09:00:00-04:00 09:00 08:00 Come hang out and work on projects with other Julia community members or find something new to contribute to! We'll be codejamming all day. There are no prizes or competition - we're all collaborating together and having a good time. juliacon-2025-73807-hackathon-cmu-cohon-university-center-rangos-auditorium en Come hang out and work on projects with other Julia community members or find something new to contribute to! We'll be codejamming all day. There are no prizes or competition - we're all collaborating together and having a good time. false https://pretalx.com/juliacon-2025/talk/PAASQZ/ https://pretalx.com/juliacon-2025/talk/PAASQZ/feedback/