2.0 -//Pentabarf//Schedule//EN PUBLISH 7JKGJU@@pretalx.com -7JKGJU Performance Engineering with Julia on Modern Supercomputers en en 20260810T100000 20260810T130000 030000 Performance Engineering with Julia on Modern Supercomputers ## Overview and Goals This 3-hour workshop provides essential knowledge and practical skills for performance engineering with Julia on modern high-performance computing (HPC) systems. Participants will understand the hierarchy of an HPC system and CPU architectures from a Julia programmer's perspective, learn systematic workflows for performance analyzing, optimizing, and parallelizing Julia programs, and apply these methods to real-world scientific computing applications. ### Session 1: Demystifying Modern Supercomputers and Processor Architectures This session introduces the hierarchical architecture of modern HPC clusters for Julia programmers. Using the state-of-the-art [Otus system](https://pc2.uni-paderborn.de/systems-and-services/otus) at the [Paderborn Center for Parallel Computing (PC2)](https://pc2.uni-paderborn.de/) participants will explore the structure of an HPC cluster, from interconnected compute nodes and node-level memory hierarchy to the core architecture of modern CPUs, such as AMD 5th-generation Turin processors with AVX-512 vector units. Interactive Julia code examples, executed through the PC2 JupyterHub service running on Otus, will accompany the presentation. This session concludes with an introduction to the Roofline Performance Model, which helps participants reason about computational performance, identify bottlenecks, and recognize optimization opportunities. This session establishes the foundation for performance engineering on modern HPC systems. ### Session 2: Performance Engineering Workflow in Julia This session focuses on practical performance optimization in Julia, illustrating how to fully exploit the computing power of modern CPUs. Following an introduction to performance analysis, participants will learn to profile Julia codes. Key topics include writing type-stable Julia code, optimizing memory layout for cache efficiency, reducing heap allocations, and leveraging SIMD vectorization. Participants will conduct performance measurements using BenchmarkTools.jl and LIKWID.jl to understand the interplay between hardware performance counters and performant Julia programming. All topics will be illustrated through simple Julia examples executed on the Otus system, allowing participants to follow along and gain hands-on experience. ### Session 3: Case Study: Molecular Dynamics Simulation of Liquid Argon (ArgonMD) The final session applies the learned techniques to a realistic scientific application, ArgonMD, a molecular dynamics simulation of liquid argon based on the Lennard-Jones potential under periodic boundary conditions. Through a live demonstration, participants will observe how successive optimization steps yield performance gains. The case study progresses from a single-core baseline to parallelization across multiple compute nodes on Otus, consolidating the complete workflow for performance engineering introduced in earlier sessions. By the end of this workshop, participants will be able to: * Understand the structure of modern HPC systems and CPU architectures in Julia programming. * Apply the Roofline model to analyze and reason about performance of Julia codes. * Use profiling tools to identify computational bottlenecks in Julia programs. * Utilize systematic optimization techniques to write high-performance Julia codes. * Employ multithreading and distributed computing to scale Julia applications on HPC systems. This workshop integrates fundamental concepts, benchmarking, live Julia code examples, and a case study to equip participants with the knowledge and methods to develop performant Julia applications for state-of-the-art supercomputers. Target Audience This workshop is designed for a broad audience of Julia programmers, from those new to HPC environment to experienced computational scientists and HPC software developers seeking to leverage Julia as a high-performance and high-productivity language for their scientific research. No prior experience with HPC is required for Session 1; only basic Julia programming is assumed. Session 2 builds upon this foundation and presents practical workflows for performance engineering in Julia. Session 3 is particularly suited to domain scientists interested in developing optimized and scalable Julia codes that can take full advantage of modern HPC systems. ## Detailed Outline This workshop is planned for 3 hours and combines presentations, live Julia code demos, and hands-on exercises for an interactive learning experience. ### Session 1: Demystifying Modern Supercomputers and Processor Architectures * Speaker: Prof. Dr. Christian Plessl (Chair Professor W3 for High-Performance Computing, Managing Director of PC2, Paderborn University) * Format: Presentation with interactive Jupyter notebooks * Topics: * Modern supercomputers: the Otus system at PC2 * Accessing Otus via PC2 JupyterHub * Hierarchy of HPC cluster system * CPU architectures in Julia programming * Roofline Performance Model ### Session 2: Performance Engineering Workflow in Julia * Speaker: Alex Wiens (HPC Advisor at PC2, Paderborn University) * Format: Presentation with interactive Jupyter notebooks * Topics: * Introduction to code optimization in Julia * Profiling * Benchmarking with BenchmarkTools.jl * Writing type-stable Julia code * Hardware performance counters with LIKWID.jl * Memory optimization and efficient cache utilization * SIMD vectorization ### Session 3: Case Study: Molecular Dynamics Simulation of Liquid Argon (ArgonMD) * Speaker: Dr. Xin Wu (Scientific Advisor Theoretical Physics/Chemistry at PC2, Paderborn University) * Format: Presentation with live demos * Topics: * Applying performance engineering workflows to scientific computing * Progressive optimization of ArgonMD on single CPU-core * Node-level and multi-node parallelization on the Otus system ### Hands-on Exercises Participants only need a web browser to access the PC2 JupyterHub platform, where all exercises run directly on the Otus system. Each exercise is provided as a Jupyter notebook, containing guided explanations, starter code, and space for experimentation. Hints and reference solutions will also be provided to ensure participants progress smoothly throughout the workshop. PUBLIC CONFIRMED Workshop https://pretalx.com/juliacon-2026/talk/7JKGJU/ Muschel — N2 Alex Wiens Xin Wu Christian Plessl Gerrit Pape PUBLISH MRFYNN@@pretalx.com -MRFYNN Hands-on with Julia for HPC on GPUs en en 20260810T143000 20260810T173000 030000 Hands-on with Julia for HPC on GPUs ## Why this workshop 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 1. Good paractices in GPU programming 2. GPU programming using [KernelAbstractions.jl](https://github.com/JuliaGPU/KernelAbstractions.jl) and [ParallelStencil.jl](https://github.com/omlins/ParallelStencil.jl) 3. Multi-GPU parallelization using [MPI.jl](https://github.com/JuliaParallel/MPI.jl) and [ImplicitGlobalGrid.jl](https://github.com/eth-cscs/ImplicitGlobalGrid.jl) 4. Multi-GPU computing using Chmy v0.2, a DSL for finite-difference discretisations and automatic kernel fusion 5. GPU computing with AI technology using [Reactant.jl](https://github.com/EnzymeAD/Reactant.jl) 6. Solving PDEs inn parallel on CPUs using [PETSc.jl](https://github.com/JuliaParallel/PETSc.jl) 7. 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: 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 a GPU-accelerated supercomputer. ## 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 distributed computing, or GPU programming is required. We look forward to an engaging, inclusive, and knowledge-rich event! _This workshop will offer the possibility to access one-time HPC resources on-the-fly._ PUBLIC CONFIRMED Workshop https://pretalx.com/juliacon-2026/talk/MRFYNN/ Muschel — N2 Ludovic Räss Collin Wittenstein Boris Kaus Ivan Utkin PUBLISH 83EN8J@@pretalx.com -83EN8J DyadAgent: Adding intelligence to modeling and simulation en en 20260810T100000 20260810T130000 030000 DyadAgent: Adding intelligence to modeling and simulation Building accurate physical models requires domain expertise, careful equation formulation, and iterative testing. DyadAgent is an AI agent built on Julia and Dyad that assists with this process by combining large language models with the SciML ecosystem. Given a natural language description of a system, DyadAgent writes Dyad model code, compiles and simulates it, and checks the output against physical expectations. When the results are off, it revises the model using that feedback. The agent supports building new models, running transient and steady-state analyses, optimization, and translating legacy code into Dyad. It uses Julia's compiler and simulator as a source of truth rather than treating generated code as correct by assumption. In this workshop, participants will work through hands-on examples. Attendees will explore how the agent handles model construction, simulation, and iterative refinement. Along the way, we will discuss how DyadAgent is set up, where it excels and where it has limitations. The goal is for participants to come away with a practical understanding of how DyadAgent fits into their modeling workflow and hands-on experience with Dyad. PUBLIC CONFIRMED Workshop https://pretalx.com/juliacon-2026/talk/83EN8J/ Muschel — N3 Venkatesh-Prasad Bhat Anas Abdelrehim Ashutosh Bharambe Marius Micluța-Câmpeanu PUBLISH P39YQD@@pretalx.com -P39YQD Dyad + SciML Tutorial: Bringing Julia to Engineers en en 20260810T143000 20260810T173000 030000 Dyad + SciML Tutorial: Bringing Julia to Engineers In this workshop, participants will be able to do hands-on works using our Dyad platform. Our Dyad agent has proven remarkably effective at flattening the learning curve for Dyad, SciML and Julia. This means that participants will be able to jump directly into solving interesting problems with these tools. Dyad provides system modeling capabilities that will allow participants to create system models from nearly every engineering domain (and systems that span domains as well). From there, they can perform a wide variety of analyses on their models (steady-state analysis, transient analysis, linearization, etc.) to answer important engineering questions. Adventurous participants will even be able to create their own custom analyses directly in Julia (with the excellent support of our agent). We will guide participants through the process of building models graphically and with the agent. We will then demonstrate how they can use the Dyad language to add new primitives and components for describing both continuous and discrete behavior. They can then integrate these seamlessly into their system models alongside the extensive collection of components available in our standard libraries. Our agent will be there every step of the way to help users perform research, create visualizations, build Dyad models and write regression tests. We'll provide some exercises for users to work through during the workshop. But users are not only free to explore on their own, but encouraged to do so. Our agent can act as your personal tutor during the workshop. It can answer questions about any part of the Dyad platform and create examples of models and visualizations to help get you started. PUBLIC CONFIRMED Workshop https://pretalx.com/juliacon-2026/talk/P39YQD/ Muschel — N3 Michael Tiller John Batteh PUBLISH 9FCTYW@@pretalx.com -9FCTYW Finding Hidden Performance Costs in Julia en en 20260811T100000 20260811T130000 030000 Finding Hidden Performance Costs in Julia There are many reasons why a Julia application may run slower than expected, ranging from inefficient code patterns to more subtle issues such as dynamic dispatch, unexpected allocations, or inference failures. While Julia offers several tools to analyze performance, correlating runtime behavior with source-level causes can still be challenging. This workshop focuses on a runtime instrumentation approach that provides detailed insight into what your program actually executed and how runtime behavior relates to your source code and can find performance and memory issues that are not directly visible in existing tools. The workshop exists out: - Explain how compiler and runtime instrumentation can be used to understand performance & memory issues. - Walk through concrete workflows to find and fix common & advanced (hidden) issues. - Help participants apply these techniques to their own code or sample code. The workshop will use [CodeGlass](https://codeglassdotio.github.io/Documentation/), our implementation of this instrumentation approach, to provide hands-on experience. While the underlying instrumentation hooks are under active development for upstream integration into Julia, the implementation used in this session will be available to participants during the workshop. Participants should bring a laptop. You are welcome to bring your own Julia code to analyze, and sample code will also be provided. Multiple instructors will be available during the hands-on portion. PUBLIC CONFIRMED Workshop https://pretalx.com/juliacon-2026/talk/9FCTYW/ Muschel — N2 Joost Godschalk Yury Nuzhdin Tyrone Krieger PUBLISH MCXKBF@@pretalx.com -MCXKBF JuliaServices: Packages for running Julia application servers in production en en 20260811T100000 20260811T130000 030000 JuliaServices: Packages for running Julia application servers in production PUBLIC CONFIRMED Workshop https://pretalx.com/juliacon-2026/talk/MCXKBF/ Muschel — N3 Jacob Quinn PUBLISH C7HJJD@@pretalx.com -C7HJJD Opening Ceremony en en 20260812T083000 20260812T084500 001500 Opening Ceremony PUBLIC CONFIRMED Ceremony https://pretalx.com/juliacon-2026/talk/C7HJJD/ Tent — RW1 PUBLISH QWW3TE@@pretalx.com -QWW3TE Haskell: origins, evolution, and future by Simon Peyton Jones en en 20260812T084500 20260812T094500 010000 Haskell: origins, evolution, and future by Simon Peyton Jones PUBLIC CONFIRMED Keynote https://pretalx.com/juliacon-2026/talk/QWW3TE/ Tent — RW1 PUBLISH PBYF33@@pretalx.com -PBYF33 Why is compilation as slow as it is? en en 20260812T100000 20260812T103000 003000 Why is compilation as slow as it is? PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/PBYF33/ Tent — RW1 Gabriel Baraldi PUBLISH 3AZE7E@@pretalx.com -3AZE7E Spying into Julia’s Runtime. en en 20260812T103000 20260812T110000 003000 Spying into Julia’s Runtime. Julia lets you write high-level, generic code while still getting the best performance. To make this possible, the compiler and runtime apply aggressive transformations during compilation and execution. As a result, the code that runs is different from the source code. When this behavior is not fully understood, it can lead to subtle performance issues and unexpected memory use. Julia already provides useful performance tools. However, these tools often show only part of the picture. Understanding how compilation decisions, dispatch, and allocation behavior interact can require switching between tools and manually connecting the dots. It is not always clear where a runtime event came from in the source code or what caused it. This makes it difficult to answer questions like: where was a conversion inserted, why did a call dispatch dynamically, or why does a function that looks allocation-free allocate at runtime? When examining real-world Julia projects, we repeatedly observed hidden costs, especially allocations caused by implicit conversions, even in code that looks type stable. The compiler may insert conversions to preserve correctness, but their runtime impact is not always visible through existing tools. To address this, we introduce a compiler and runtime instrumentation layer that provides a view into what happens during compilation and execution. It records function calls, type conversions, dynamic dispatch, allocations, deallocations, and garbage collection activity across the application. It also links runtime behavior back to call sites and method specializations, including context information such as concrete types involved. We briefly explain the key design decisions behind this approach and how we instrument compilation and execution without changing program behavior. This session focuses mainly on practical examples from real Julia code. We look at: - Implicit conversions that allocate memory - The runtime impact of macros such as `@assert`, `@inline`, and `@noinline` - Dynamic dispatch in performance-critical or seemingly type-stable code - Allocation and garbage collection patterns that are hard to trace back to their source For each case, we show how connecting runtime events with context helps you confirm your performance assumptions and better understand how your Julia code actually runs. Finally, we discuss how this instrumentation work is being prepared for upstreaming into Julia itself. The goal is to make runtime observability part of the language infrastructure, rather than something tied to a single tool. PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/3AZE7E/ Tent — RW1 Tyrone Krieger Yury Nuzhdin Jorge Alberto Vieyra Salas PUBLISH CUVPA3@@pretalx.com -CUVPA3 LLMs, agents and tools for Julia development en en 20260812T111500 20260812T113000 001500 LLMs, agents and tools for Julia development This talk is mainly to give an overview of what exists and what efforts are still ongoing. It will mainly focus on the foundational strategies of how to use AI to develop Julia packages and work with Julia code. I'm_ mainly orienting this talk at folks who may not have used agents much yet, to provide a basic grounding in techniques that they can use going forward. It probably will be a bit boring for folks who are really using AI agents at this point. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/CUVPA3/ Tent — RW1 Anshul Singhvi PUBLISH V9YEJL@@pretalx.com -V9YEJL AppBundler 1.0 - Bundle your Julia application and beyond en en 20260812T113000 20260812T120000 003000 AppBundler 1.0 - Bundle your Julia application and beyond PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/V9YEJL/ Tent — RW1 Janis Erdmanis PUBLISH RQVGL3@@pretalx.com -RQVGL3 The Julia Registrator setup and runtime environment en en 20260812T120000 20260812T121500 001500 The Julia Registrator setup and runtime environment PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/RQVGL3/ Tent — RW1 Nishanth H. Kottary PUBLISH GBYL3S@@pretalx.com -GBYL3S JuliaSubtyping: A logical approach to types en en 20260812T121500 20260812T124500 003000 JuliaSubtyping: A logical approach to types PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/GBYL3S/ Tent — RW1 Cody Tapscott PUBLISH NVEP3P@@pretalx.com -NVEP3P Building and Shipping Omakase Julia Distributions en en 20260812T143000 20260812T150000 003000 Building and Shipping Omakase Julia Distributions Many advancements in the latest Julia versions (v1.11 and v1.12) have focused on making the core of the language leaner for users who want flexibility and smaller binaries. While we are happy to have these features available in the language, we have noticed the average user does not prioritize either of these two for their day-to-day work. More importantly, we have found they have a less optimal experience using the language for common workflows due to these changes. The situation became a significant user experience issue as we were building out the Dyad stack, as it heavily depends on a large part of the ecosystem, including over 400 of the top Julia packages, the full SciML stack, and proprietary algorithms. In our internal testing, users with machines as little as a few years old could easily spend over 30 minutes getting set up before they could start to run analyses for models they created. We found that the lean, approximately 300MB, download for Julia v1.11, or the performance gains from a very custom `JULIA_CPU_TARGET`, did not address our users' needs. Discomfort with these options being the defaults has also surfaced multiple times from the community, in Julia’s Slack and several [Discourse](https://discourse.julialang.org/t/julia-1-11-is-slower-than-1-10/121077) [posts](https://discourse.julialang.org/t/new-julia-versions-higher-pluto-loading-times/135187). There is even a tool to [track slowness](https://juliaecosystembenchmarks.github.io/web-explorer/#tasks=Project-Path)! In this talk, we present the solution used to deliver Dyad Studio (a JuliaHub product) and the tooling you can use to prepare custom distributions to address your and your users' needs. These distributions can be shared as tarballs or even using a custom `juliaup` server. We show this approach significantly reduces time-to-first-plot, including installation, even for complex analyses involving precompilation-heavy workloads, such as Dyad's modeling and analysis workflows. We consider this a viable solution for both enterprise users of Julia and for communities of users with similar needs. PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/NVEP3P/ Tent — RW1 Panagiotis Georgakopoulos Joris Kraak PUBLISH 37PYYA@@pretalx.com -37PYYA Lessons in deploying Julia to productions services en en 20260812T150000 20260812T153000 003000 Lessons in deploying Julia to productions services This talk will discuss strategies, architectures and pitfalls for various options and methods for running and deploying Julia services in production. Issues addressed in this talk will include: * The trivial method, and when that is appropriate * Packaging code * Considerations for HPC clusters * Using Docker * Using system images for packaging * Need for relocability * Cloud deployments PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/37PYYA/ Tent — RW1 Avik Sengupta PUBLISH LYBBPW@@pretalx.com -LYBBPW Bringing Order to the Seas: Defining Type-piracy in Julia en en 20260812T154500 20260812T161500 003000 Bringing Order to the Seas: Defining Type-piracy in Julia PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/LYBBPW/ Tent — RW1 Cody Tapscott PUBLISH GDBGPJ@@pretalx.com -GDBGPJ julia-novices -- About The Carpentries lessons for teaching julia en en 20260812T161500 20260812T163000 001500 julia-novices -- About The Carpentries lessons for teaching julia PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/GDBGPJ/ Tent — RW1 Simon Christ PUBLISH CZDYJF@@pretalx.com -CZDYJF How is Julia both dynamic and fast? en en 20260812T163000 20260812T164500 001500 How is Julia both dynamic and fast? There are many ways a programming language can be dynamic, but not all them are equal. By retreating from fully dynamic behaviour in a few cases, Julia is able to strike a balance that allows its dynamic features to be used pervasively, rather than only where performance allows. This talk compares Julia's multiple dispatch mechanism with Common Lisp's, explaining how the "world age" concept enables Julia's compiler to make dispatch dramatically faster, while keeping eval() useful for interactive development. We also cover why Julia's immutable structs are valuable in more ways than only their unmodifiable nature. Finally, we look at some experimental Julia features that explore the dynamism-vs-speed frontier further, including opaque closures. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/CZDYJF/ Tent — RW1 Sam Schweigel PUBLISH TBHR8T@@pretalx.com -TBHR8T ReLint.jl and Argus.jl are merging into a powerful Julia linter en en 20260812T164500 20260812T170000 001500 ReLint.jl and Argus.jl are merging into a powerful Julia linter ReLint was developed at [RelationalAI](https://www.relational.ai) as an alternative to StaticLint. It already provides a set of \~50 built-in linting rules that can be run right after installing the package. At RelationalAI, it is used on a daily basis on a fairly large codebase (\~700K lines of Julia code). One of the main goals of ReLint was to make it easier to write new rules. This was achieved with a design that allowed defining rules as types with associated `check` methods. For a simple rule, the definition might be as simple as the following: ```julia struct AsyncRule <: ViolationLintRule end function check(t::AsyncRule, x::EXPR) msg = "Use `@spawn` instead of `@async`." generic_check(t, x, "@async hole_variable", msg) generic_check(t, x, "Threads.@async hole_variable", msg) end ``` However, complicated rules would require complex `check` functions that inspect the internals of Julia code. That is, _of the `EXPR` representation of Julia code_, which is not even the _official_ representation. Hence, while this design is a major improvement upon StaticLint, it is still lacking expressivity, and it is not as tightly integrated with the Julia compiler as it could be. Argus proposes a pattern matching framework that represents ASTs using [JuliaSyntax](https://github.com/JuliaLang/JuliaSyntax.jl), the official compiler front-end. It provides a DSL for expressing patterns that resemble the code they are meant to match. These patterns are used to define linting rules in an elegant manner: ```julia VIOLATIONS = RuleGroup("violations") @define_rule_in_group VIOLATIONS "@async" begin description = "Use `@spawn` instead of `@async`." pattern = @pattern ~or( @async({_}...), Threads.@async({_}...) ) end ``` There is no need for the user to write a custom `check` method – Argus's rule matching mechanism handles everything! Argus's powerful pattern abstractions – syntax classes – offer a flexibility that ReLint's string-based patterns cannot match. The following rule, which warns against containers with abstract type parameters, would be impossible to express in ReLint: ```julia @define_rule_in_group PERFORMANCE "containers-with-abstract-type-params" begin description = "Avoid containers with abstract type parameters." pattern = @pattern {container}{{_}..., {t:::abstract_type}, {_}...} end ``` Argus seems to be the better choice for writing linting rules, but it is limited in terms of workflow integration. Here ReLint is a step ahead, embedding linting in GitHub actions and workflows. It allows automatic CI/CD checks for all rules and provides a pre-commit hook for catching severe violations especially early in the development cycle. By integrating Argus, the latest ReLint release addresses the need for better static analysis tooling for Julia. The new linter still has the benefits of CI/CD integration and a pre-defined set of rules, but it greatly improves user experience and expressive power. Developers can now easily extend the default rule set by writing their own rules that look just like the code they want to match. The package is openly available under the MIT license. For more information you can watch the [JuliaCon 2025 presentation on ReLint](https://www.youtube.com/watch?v=H69bGbT0ZNQ) or the [JuliaCon Paris 2025 presentation on Argus](https://www.youtube.com/watch?v=GRRtlfCt0rQ). PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/TBHR8T/ Tent — RW1 Iulia Dumitru Alexandre Bergel PUBLISH WVE37X@@pretalx.com -WVE37X JuliaC.jl and the state of --trim en en 20260812T170000 20260812T173000 003000 JuliaC.jl and the state of --trim PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/WVE37X/ Tent — RW1 Gabriel Baraldi Jeff Bezanson Cody Tapscott PUBLISH XSYZLV@@pretalx.com -XSYZLV Resolving the Edge of the Universe: Imaging Black Holes with Julia en en 20260812T174500 20260812T184500 010000 Resolving the Edge of the Universe: Imaging Black Holes with Julia Black holes were once thought to be unobservable. In 2019, the Event Horizon Telescope (EHT) changed that by producing the first horizon-scale image of M87*. That breakthrough was not only an achievement in astronomy, but also in scientific computing: every step, from building a planet-sized telescope to reconstructing the final image, depended on extensive computation. In this talk, I will show how Julia is helping push black hole imaging into its next era. Its combination of speed, flexibility, and composability has made it a core part of the EHT software stack, powering modern workflows for imaging, modeling, and uncertainty quantification. Julia is also helping define the future of black hole astronomy. The Black Hole Explorer (BHEX), a NASA space mission concept, aims to produce the highest-resolution images of black holes ever made, resolving regions of spacetime where light can orbit the black hole itself. In the final part of the talk, I will highlight how Julia will form the foundation of the BHEX analysis pipeline and demonstrate its potential as the primary software platform for a next-generation scientific instrument. PUBLIC CONFIRMED Keynote https://pretalx.com/juliacon-2026/talk/XSYZLV/ Tent — RW1 Paul Tiede PUBLISH WGRWHS@@pretalx.com -WGRWHS Disrupt Drug Design en en 20260812T100000 20260812T103000 003000 Disrupt Drug Design PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/WGRWHS/ Muschel — N1 pato PUBLISH BXHNXX@@pretalx.com -BXHNXX Julia For Quantitative Systems Pharmacology en en 20260812T103000 20260812T104500 001500 Julia For Quantitative Systems Pharmacology Contents of presentation: - Background: QSP - Model building process and pain points - Simulations and performance improvement with Julia - Two-language problem: Balancing model accessibility and performance PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/BXHNXX/ Muschel — N1 Elisabeth Roesch PUBLISH 7B9YZJ@@pretalx.com -7B9YZJ Staged programming in pharmacometrics en en 20260812T104500 20260812T110000 001500 Staged programming in pharmacometrics PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/7B9YZJ/ Muschel — N1 Andreas Noack PUBLISH NEH3S3@@pretalx.com -NEH3S3 NoLimits.jl: A flexible Julia framework for nonlinear, neural and latent-state mixed-effects modeling en en 20260812T110000 20260812T113000 003000 NoLimits.jl: A flexible Julia framework for nonlinear, neural and latent-state mixed-effects modeling Nonlinear mixed-effects models are central to longitudinal and hierarchical data analysis. While many established platforms provide robust and production-ready workflows, extending open-source tools to incorporate modern machine learning components, flexible random-effect distributions, or complex latent structures often requires substantial methodological effort. This talk introduces NoLimits.jl (NOn LInear MIxed effecTS), an open-source Julia framework for nonlinear modeling with random effects, designed for composability and rapid methodological experimentation. The framework enables users to combine mechanistic models (including DifferentialEquations.jl-based ODE systems), hierarchical random effects with multiple nested levels, hidden Markov structures, and differentiable machine learning components within a unified interface. NoLimits.jl integrates seamlessly with the Julia ecosystem, leveraging Distributions.jl, DifferentialEquations.jl, Lux.jl, Optimization.jl, and Turing.jl for both frequentist and Bayesian inference. The focus of the talk is to present the capabilities of the framework and to outline potential improvements that can benefit from the community. Using real data examples, I will showcase the package capabilities by demonstrating practical modeling workflows, including: 1) Embedding soft decision trees and neural networks as differentiable components alongside mechanistic ODE models, 2) Specifying hidden Markov models within nonlinear mixed-effects structures for individualized latent transition analysis, 3) Extending classical Gaussian random effects using normalizing flows to capture skewed or multimodal heterogeneity. I will conclude the talk with an outline of opportunities for collaboration and contribution, as well as future directions, including extending the framework toward federated learning capabilities. PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/NEH3S3/ Muschel — N1 Manuel Huth PUBLISH VEWE33@@pretalx.com -VEWE33 Feature based prediction of preclinical pharmacokinetic profiles using machine learning and compartmental modeling en en 20260812T113000 20260812T114500 001500 Feature based prediction of preclinical pharmacokinetic profiles using machine learning and compartmental modeling For healthcare and drug discovery, particularly during the earlier stages of target identification and hit finding, recent advancements in data availability, computational power, and methods (machine learning (ML) and artificial intelligence (AI)) have shown great promise to further rationalized the drug development pipeline initiating a transition from a “data generation and triaging” to a ”result prediction and verification” pipeline. We present different feature-based concepts of predicting in vivo PK profiles for chemical and biological identities derived from their chemical structure or amino acid sequences with physics informed neural networks. The first example evaluates the performance of different state of the art (hybrid) methods for predicting PK profiles based on chemical structures and benchmark their performance on a common data set for pre-clinical species. Next, a method for predicting non-rodent PK profiles for using allometric AI approach is introduced. The last concept utilizes protein large language models and sequence derived features to predict in vivo clearance and PK profile in pre-clinical species. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/VEWE33/ Muschel — N1 Felix Jost PUBLISH MGNSFV@@pretalx.com -MGNSFV VPopMIP: A Mixed-Integer Programming Approach to Virtual Population Generation en en 20260812T114500 20260812T120000 001500 VPopMIP: A Mixed-Integer Programming Approach to Virtual Population Generation PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/MGNSFV/ Muschel — N1 Ivan Borisov Evgeny Metelkin PUBLISH SA7F9J@@pretalx.com -SA7F9J Reproducible Bioinformatics Pipelines in Julia: Lessons from AlphaConformers en en 20260812T120000 20260812T123000 003000 Reproducible Bioinformatics Pipelines in Julia: Lessons from AlphaConformers Building modeling and analysis pipelines is a common task when doing molecular modeling and bioinformatics. However, keeping such pipelines reproducible and sharable is not an easy task. Thankfully, Julia's interoperability and reproducibility make it the best glue language for building such pipelines. Julia allows us to have everything expressed in a single high-level programming language with performance that pairs that of low-level ones. But, while it solves the two-language problem, it is unlikely that advanced tools, fruit of years of research and development, will be translated to Julia. Therefore, to be able to build on the shoulders of giants and avoid reinventing the wheel, we need a language that can also run and manage outside tools, and Julia is such a language. Julia's can easily interoperate with well-established languages in bioinformatics, such as Python and R, thanks to packages such as PythonCall, using CondaPkg to keep the Python environment reproducible, and RCall. But the Julia ecosystem also offers prebuilt, cross-platform native binaries for command-line tools through versioned JLL packages. That allows integrating such tools, possibly developed using languages such as C, C++, Fortran, or Rust, among others, into Julia workflows. Currently, many of the classical and more popular bioinformatics packages are available as JLL packages. In this talk, I will present AlphaConformers, a Julia package for the modeling of protein alternative conformations. It takes advantage of Julia’s Pkg environments and already available JLL packages for common bioinformatics tools, such as FoldSeek and USalign. Therefore, we will showcase the power of Julia for the development of bioinformatics pipelines and workflows. PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/SA7F9J/ Muschel — N1 Diego Javier Zea PUBLISH XYQJFH@@pretalx.com -XYQJFH juDock: An Open-Source, ML-Driven Platform for Virtual Screening of Phytocompounds in Drug Discovery en en 20260812T123000 20260812T124500 001500 juDock: An Open-Source, ML-Driven Platform for Virtual Screening of Phytocompounds in Drug Discovery The Structure of the Talk is as follows: **Background and Problem:** (2 mins; Will brief clinical challenges, limitations of the existing tools) There has been a growing interest in screening for phytocompounds. However, High Throughput Virtual Screening (HTVS) requires computational expertise from downloading the ligands to molecular docking including format conversions. Sometimes, it also demands scripting, producing non-reproducible results. Furthermore, various tools should be used sequentially such as RDKit, OpenBabel, AutoDock Vina, Discovery Studio Visualizer etc. **The Julia Solution:** (3 mins; Will talk about the methodologies implemented) We present juDock, a containerized ML-Driven browser based Linux application that solves this fragmentation. We have used Julia to build a streamlined pipeline, as an ultimate orchestrator optimizing specifically for the virtual screening of phytocompounds. While traditional docking provides physics-based binding affinities, our integrated model provides a complementary ML-based probability score, termed as dockscore. This allows researchers to perform high-throughput screening where the software simultaneously validates spatial docking feasibility and chemical inhibitory potential, processing thousands of phytochemicals in seconds. **Key Highlights:** (5 min; Will talk about the application architecture) - **Phytocompound based Training:** We trained the Multi-Output Random Forest Regressor model on a curated phytocompounds dataset docked against 17 beta HSD1 target. The model learned to predict the binding affinity and an overall dockscore based on a combination of binding affinities, molecular interaction profiles (H bonds, Non bond interactions such as hydrophobic interactions etc) and also, physicochemical descriptors of the compounds. - **Seamless Interoperability:** We have used industry-standard libraries such as RDkit, Scikit-learn entirely from within Julia using Conda and PythonCall.jl - **Robust Multi-Processing:** We have applied a RAM-aware parallel processing system using Julia’s Distributed library allowing effective parallel screening of large numbers of natural product libraries without segmentation faults. - **Full-Stack Browser Based Interface:** We have built a responsive GUI dashboard using Genie.jl. The application, while installing, creates directories such as juDock_input and juDock_output in the user’s Home directory. The researchers have to just place the .sdf files in the input directory and the results are available both in the output folder and also, in the browser interface. The interface also provides real-time progress tracking with status bars. - **Open Source project:** The uniqueness of juDock relies on its specificity towards the target protein. The interface allows the user to select the protein target and consequently, the respective model is loaded. Hence, we have created this project as an open-source project allowing researchers to contribute the model trained using our established pipeline. Currently, juDock holds two protein targets, 17 beta HSD1 (trained by us) and Aromatase (Contributed). The complete code is available at https://github.com/drbenedictpaul/judock . **Validation and Conclusion:** (2 mins: Will talk about the case studies for validation) The application was validated against traditional computer aided drug design methods with various types of proteins (Human, bacterial, viral and fungal) and compounds. juDock empowers scientists who are interested in screening various phytocompounds for its therapeutic potential. Combining the power of Machine Learning and the speed of Julia, juDock provides a powerful interface for the High Throughput Virtual Screening of phytocompounds in modern natural product drug discovery. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/XYQJFH/ Muschel — N1 Surya Sekaran PUBLISH NWQCHH@@pretalx.com -NWQCHH Effects of stochasticity on molecular minimization en en 20260812T124500 20260812T130000 001500 Effects of stochasticity on molecular minimization Protein structures are determined experimentally by X‑ray crystallography, electron microscopy, or NMR, or they are predicted with AlphaFold or RoseTTAFold [1,2]. Either way, the resulting protein models often contain missing atoms, distorted bond lengths, or unrealistic side chain orientations generating severe steric clashes and steep energy gradients. Energy minimization is thus essential to achieve physically realistic conformations. While classical minimizers (e.g., conjugate gradient, quasi-Newton) are standard, we demonstrate how machine learning (ML) optimizers can be effectively adapted to this domain. We introduce a novel mini-batching strategy for ML-based minimization (e.g., SGD, ADAM), implemented in BiochemicalAlgorithms.jl, our library for molecular analysis and simulation [3]. The library provides molecular mechanic functionalities to evaluate energy gradients and corresponding forces, which are essential for energy minimization. Our mini-batching strategy partitions the force‑field contributions by atom‑pair groups, allowing the energy and gradient calculations to be performed on small batches corresponding to random selected portions of the molecule. Furthermore, a major contribution of this work is a systematic assessment of different optimization algorithms by leveraging the unified Optimization.jl ecosystem—an interface that connects to more than 25 optimization libraries [4]. Our approach supports the possibility of interchanging solvers including SGD and ADAM or alternative ML solvers for energy minimization of proteins without custom code per algorithm. Using a representative set of proteins from each of the five top‑level SCOP classes, we compared runtime and convergence precision across the solvers. The results highlight which algorithms deliver the best trade‑off between speed and final energy for different structural families. Overall, the talk will demonstrate how the proposed mini‑batching scheme opens a path towards ML‑augmented protein‑structure refinement and how a single, extensible optimization interface can streamline the evaluation of diverse minimization strategies for protein structure relaxation. [1] J. Jumper et al., “Highly accurate protein structure prediction with AlphaFold,” Nature, vol. 596, pp. 583‑589, 2021, doi: 10.1038/s41586‑021‑03819‑2. [2] M. Baek et al., “Accurate prediction of protein structures and interactions using a three‑track neural network,” Science, vol. 373, pp. 871‑876, 2021, doi: 10.1126/science.abj8754. [3] J. Leclaire et al., “Structure‑based bioinformatics with BiochemicalAlgorithms.jl,” in Proceedings of the JuliaCon Conferences, vol. 7, no. 78, p. 188, 2025, doi: 10.21105/jcon.00188. [4] V. K. Dixit and C. Rackauckas, “Optimization.jl: A unified optimization package (version v3.12.1),” Zenodo, Mar. 2024. [Online]. Available: https://doi.org/10.5281/zenodo.7738525. [5] N. K. Fox, S. E. Brenner, and J. M. Chandonia, “SCOPe: Structural classification of proteins—extended, integrating SCOP and ASTRAL data and classification of new structures,” Nucleic Acids Res., vol. 42, no. D1, pp. D304‑D309, 2014, doi: 10.1093/nar/gkt1240. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/NWQCHH/ Muschel — N1 Jenny Leclaire PUBLISH VZUPJA@@pretalx.com -VZUPJA The HeartRateLab.jl: a toolkit for heart beats time series en en 20260812T143000 20260812T150000 003000 The HeartRateLab.jl: a toolkit for heart beats time series As a tool for his Ph.D. in Cognitive Science at the Institute for Human-Computer Interaction, Technical University of Graz, Alberto Barradas has collected many methods and standards that are now integrated and presented in this Julia computing laboratory. Accessible scientific tooling makes live experimentation accessible, and is presented with a general overview on the study of Heart Rate (HR) and Heart Rate Variability (HRV) and its use in sport and cognitive science. Live visualizations and demonstrations are prepared for this presentation, including suggestions for integrating biofeedback into contemplative practices. We hope the community finds this contribution valuable, as we have found it for our work in cognitive and sports science, teaching and learning, and personal practice. PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/VZUPJA/ Muschel — N1 Alberto PUBLISH WGZ9ZA@@pretalx.com -WGZ9ZA Radiomics.jl: a Library for High-Performance Radiomic Features Extraction from Medical Images en en 20260812T150000 20260812T151500 001500 Radiomics.jl: a Library for High-Performance Radiomic Features Extraction from Medical Images **_Introduction_** Radiomics has emerged as a fundamental approach in precision medicine, enabling the extraction of high-throughput quantitative features from medical images for computer-aided diagnosis and personalized treatment planning [1]. In this work, Radiomics.jl [2], a new and open-source Julia library designed to extract radiomic features, is presented. **_Materials and Methods_** Radiomics.jl implements a complete set of radiomic features (106 in total) extraction capabilities, encompassing first-order and 2D/3D shape-based features, as well as sophisticated texture descriptors. These advanced texture features include the Gray-Level Co-occurrence Matrix (GLCM), Gray-Level Dependence Matrix (GLDM), Gray-Level Run-Length Matrix (GLRLM), Gray-Level Size-Zone Matrix (GLSZM), and Neighborhood Gray-Tone Difference Matrix (NGTDM). The tool is designed for convenience and user-friendliness, and it takes advantage of a multi-threading workflow, which allows efficient feature extraction from multiple tissues or organs concurrently. **_Results_** A Computed Tomography (CT) scan of a patient with a lung tumor [3,4] was selected for benchmarking. The CT volume dimensions were 500 x 500 x 319 voxels, with the tumor segmentation comprising 38226 voxels (38.226 cm3). Excluding the initial JIT compilation overhead, which accounted for 12.47 s (single-thread) and 5.60 s (multi-thread), the mean execution time over 14 repetitions was 4.07 s (SD=0.10 s) for single-thread and 3.00 s (SD=0.29 s) for multi-thread. Multi-threading yielded a 25% reduction in computational time (Wilcoxon rank-sum test revealed statistically significant difference between the two distributions). **_Discussion and Conclusions_** Radiomics.jl offers a high-performance, efficient, and user-friendly solution for quantitative medical image analysis entirely within the Julia ecosystem. Designed for fast and user-friendly feature extraction from medical images, its goal is to support and advance the field of personalized medicine. **_References_** [1] https://pmc.ncbi.nlm.nih.gov/articles/PMC4734157/ [2] https://github.com/pzaffino/Radiomics.jl [3] Aerts HJWL, et al. Nat Commun. 2014;5:4006. https://doi.org/10.1038/ncomms5006 [4] Aerts HJWL, et al. NSCLC-Radiomics [Data set]. TCIA, 2014. https://doi.org/10.7937/K9/TCIA.2015.PF0M9REI PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/WGZ9ZA/ Muschel — N1 ALDO GIULIANI PUBLISH F8GRBR@@pretalx.com -F8GRBR Generic GPU-Acceleration for Medical Image Reconstruction en en 20260812T151500 20260812T153000 001500 Generic GPU-Acceleration for Medical Image Reconstruction Medical image reconstruction for tomographic modalities such as magnetic resonance imaging (MRI) and magnetic particle imaging (MPI) involves solving ill-posed inverse problems that are typically addressed through regularized least-squares optimization. As imaging techniques advance, computational demands increase significantly, often requiring GPU acceleration for practical use. Additionally, the operators involved often become too large to store in memory, requiring or benefitting from (composable) matrix-free operator implementations. The MRIReco.jl and MPIReco.jl reconstruction packages feature a shared optimization backend that prioritizes code reuse. LinearOperatorCollection.jl provides matrix-free implementations of common image processing operations (FFT, NFFT, DCT, Wavelet) and enables their composition through custom building blocks and the underlying LinearOperators.jl package. The collection also provides structure-aware optimizations that exploit properties of composed operators for computational efficiency. Modality-specific packages like MRIOperators.jl and operators in MPIReco.jl implement encoding operators for their respective imaging physics. RegularizedLeastSquares.jl serves as the shared optimization backend, providing reusable iterative solvers (CGNR, FISTA, ADMM) that work with any operator implementing matrix-vector products and adjoints. This architecture allows the same solver implementations to work across different imaging modalities. In this talk, I will present our recent technical developments in extending vendor-agnostic GPU acceleration throughout this entire stack. This is achieved through a combination of Julia's features, such as multiple dispatch, parametric types, and package extensions, as well as the Julia GPU ecosystem, particularly GPUArrays.jl, KernelAbstractions.jl, and Adapt.jl. Using parametric types and Adapt.jl means that our operators and solvers remain generic over array types and work with both CPU and GPU arrays, while GPUArrays.jl and KernelAbstractions.jl allow us to write GPU kernels that are compatible with different GPU backends. Lastly, package extensions allow GPU-specific code to be loaded conditionally, i.e. only when users load their preferred GPU backend. This means that the core packages remain lightweight with no GPU dependencies. Users can enable GPU acceleration with minimal code changes by loading a GPU package and providing an array type. Related organizations: https://github.com/JuliaImageRecon https://github.com/MagneticParticleImaging https://github.com/MagneticResonanceImaging Related repositories: https://github.com/JuliaImageRecon/LinearOperatorCollection.jl https://github.com/JuliaImageRecon/RegularizedLeastSquares.jl https://github.com/MagneticResonanceImaging/MRIReco.jl https://github.com/MagneticParticleImaging/MPIReco.jl PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/F8GRBR/ Muschel — N1 Niklas Hackelberg PUBLISH THM7WY@@pretalx.com -THM7WY Application of SphericalHarmonicExpansions.jl: Representation and Handling of Magnetic Fields en en 20260812T154500 20260812T160000 001500 Application of SphericalHarmonicExpansions.jl: Representation and Handling of Magnetic Fields The Julia package [SphericalHarmonicExpansions.jl](https://github.com/IBIResearch/SphericalHarmonicExpansions.jl) provides a flexible and efficient framework for working with spherical harmonics and their expansions. By expanding general solutions to Laplace’s equation inside a sphere into spherical harmonics, the package enables a broad range of applications. It offers easy manipulation of the coefficients, including coordinate transformations such as translation, rotation, and point reflection, as well as fast numerical evaluations of the expansion. The focus of the talk is the application of the package to magnetic fields, which play a crucial role in medical imaging techniques such as magnetic particle imaging (MPI). In MPI, static and dynamic fields excite iron-oxide nanoparticles to achieve spatial encoding. Field-related imperfections can cause artifacts that degrade image quality, making precise knowledge and characterization of these fields essential. Spherical harmonic expansions offer a compact and robust representation of the magnetic fields within a spherical region, which can be obtained by calibration measurements on a spherical surface. While the package itself is application-independent, it serves as the core component to handle magnetic fields using spherical harmonics in Julia. Example code demonstrating its application to magnetic field representation and evaluation is available in the [SphericalHarmonicExpansionOfMagneticFields repository](https://github.com/IBIResearch/SphericalHarmonicExpansionOfMagneticFields). Complementary, in-development packages like [MPISphericalHarmonics.jl](https://github.com/MagneticParticleImaging/MPISphericalHarmonics.jl), which provides interfaces tailored to magnetic field handling in MPI, and [MPIUI.jl](https://github.com/MagneticParticleImaging/MPIUI.jl), with an interactive GUI for visualization, extend this foundation with practical tools for research and application. The focus of this talk will be * Structure and functionality of SphericalHarmonicExpansions.jl * Application to magnetic fields * Usage example in MPI PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/THM7WY/ Muschel — N1 Marija Boberg PUBLISH PZSLRD@@pretalx.com -PZSLRD How I Drew the Julia Logo Using Spins in an MRI Machine en en 20260812T160000 20260812T163000 003000 How I Drew the Julia Logo Using Spins in an MRI Machine Radio frequency (RF) and magnetic field gradient waveforms are the controls an MRI scanner uses to excite spins. By shaping these waveforms, we can go beyond simple slice selection and excite a chosen 2D pattern within a slice. In this talk, I will first build intuition with minimal prerequisites: resonance, the rotating frame, how gradients turn frequency into a spatial label, and how time-varying gradients combined with a shaped RF waveform produce a 2D excitation pattern. I then frame pulse design as an inverse problem. We seek an RF waveform x that minimizes the mismatch between a desired transverse magnetization pattern b and the simulated pattern A(x), where A(x) is computed by integrating the spin dynamics under the applied RF and gradient waveforms. The simulation is implemented in Julia using KomaMRI.jl, accelerated with GPU kernels via KernelAbstractions.jl, and differentiated using reverse-mode AD with Enzyme.jl. The key contribution is speed. With CPU finite-difference gradients (FiniteDiff.jl), optimizing the Julia-logo pulse took about 5 hours. Using GPU execution and Enzyme-based reverse-mode AD, we reduced the same optimization to under 5 seconds. As a concrete demonstration, we designed a 2D pulse that imprints the Julia logo in a water-bottle phantom and validated it by executing the pulse on a real scanner via Pulseq. The measured excitation pattern closely matches the simulation. I will close by explaining why this matters clinically. If pulse design becomes fast enough, subject-specific RF tailoring becomes practical. Instead of one-size-fits-all pulses, we can restrict excitation to specific anatomical regions, improve imaging near metal implants, and optimize fat suppression, while staying within hardware limits such as RF power and gradient strength. PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/PZSLRD/ Muschel — N1 Carlos Castillo Passi PUBLISH TDWGHB@@pretalx.com -TDWGHB Improving JuliaHealth Documentation Accessibility for Community Onboarding en en 20260812T163000 20260812T170000 003000 Improving JuliaHealth Documentation Accessibility for Community Onboarding This project was developed under a NumFOCUS Small Development Grant to strengthen the JuliaHealth ecosystem through three main goals. - **(Goal 1) Attracting New Community Members and Contributors**: By centralizing and making our documentation more broadly accessible, we provided clearer on-ramps for new JuliaHealth community members to get started with JuliaHealth tools and understand how they can contribute. - **(Goal 2) Highlighting JuliaHealth Workflows**: Through the development of explanatory guides and structured examples, including the JuliaHealthZoo initiative, we demonstrated how JuliaHealth and broader Julia tools can be used to meet practical needs within real health informatics workflows. - **(Goal 3) Strengthening Community Robustness:** A reproducible JuliaHealthAudit was conducted across core packages to evaluate documentation, CI pipelines and maintenance signals. Based on its findings, targeted improvements were opened across repositories and package specific documentation and CI standards were established to improve consistency and reliability. Beyond technical changes, this work has made JuliaHealth easier to approach and more sustainable in the long term. By combining ecosystem analysis with improvements and clearer documentation practices, the project reduces barriers for new contributors while strengthening the stability of the existing packages. The lessons learned may serve as a reference for improving documentation and maintenance practices in other Julia organizations as well. Some highlights of this work are: - JuliaHealth Audit: https://github.com/JuliaHealth/JuliaHealthAudit - Documentation improvements: https://github.com/JuliaHealth/OMOPCDMFeasibility.jl , https://juliahealth.org/KomaMRI.jl/previews/PR725/ - JuliaHealthZoo: https://github.com/JuliaHealth/JuliaHealthZoo Acknowlegments: This work was supported by a NumFOCUS Small Development Grant. I am grateful to the JuliaHealth community, and especially to Carlos Castillo Passi and Jacob S Zelko, for their guidance and support throughout the project. For additional details, see the grant proposal issue: https://github.com/numfocus/small-development-grant-proposals/issues/59 PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/TDWGHB/ Muschel — N1 Kosuri Lakshmi Indu PUBLISH FYD7SD@@pretalx.com -FYD7SD State of JuliaHealth en en 20260812T170000 20260812T173000 003000 State of JuliaHealth We will provide an overview of the JuliaHealth ecosystem, including its structure, ongoing efforts, and recent milestones. In particular, the talk will cover: - History and evolution of JuliaHealth, including the growth of the community and its sub-ecosystems - Ecosystem governance, including current leadership, and community goals - Projects, collaborations, and research highlights across the JuliaHealth ecosystem - Current initiatives and support, including the recent NumFOCUS grant and the JuliaHealth bounty program - Future goals and direction for the community PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/FYD7SD/ Muschel — N1 Hetarth Shah Carlos Castillo Passi Jacob Zelko PUBLISH FCV33L@@pretalx.com -FCV33L The Agentic AI Maintenance Bots of the SciML Organization en en 20260812T100000 20260812T103000 003000 The Agentic AI Maintenance Bots of the SciML Organization Right now the system is kept private, but it will be opened sourced before the talk. It needs an audit to ensure no secret keys are leaked. The core system has 48 concurrent agents which trigger individual bots and cycle through different behaviors to cover many standard maintenance problems. Right now the system has the following bot profiles that are orchestrated with specific purposes: * CI Health, Check Tests master branch CI, diagnoses and fixes failures * Random Issue Solver, Investigates open issues (prioritizes bug label) * Dependency Update, Handles dependency update PRs * Min Version Bump, Bumps minimum versions in compat * Docs Improvement, Improves documentation * Static Improvement, Static analysis improvements * Performance Improvement, Performance optimizations * Interface Check, Checks package interfaces * Precompilation, Improvement Improves precompilation * Version Bump, Checks for version releases * Explicit Imports, Adds explicit imports * Deprecation Fix, Fixes deprecation warnings * Benchmark Check, Checks SciMLBenchmarks.jl PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/FCV33L/ Muschel — N2 Chris Rackauckas PUBLISH 8CDNV9@@pretalx.com -8CDNV9 Agentif.jl: AI agent primitives for Julia en en 20260812T103000 20260812T110000 003000 Agentif.jl: AI agent primitives for Julia PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/8CDNV9/ Muschel — N2 Jacob Quinn PUBLISH RGVXMP@@pretalx.com -RGVXMP Gradients aren't always great -- a case study with MixedModels.jl en en 20260812T111500 20260812T113000 001500 Gradients aren't always great -- a case study with MixedModels.jl The developers of MixedModels.jl are often asked why they don't use gradient-based optimization and GPUs, which have fueled many recent advances in statistics and machine learning, to make the package even faster. In this talk, we'll focus on the first aspect: the use of the gradient in the optimization and use MixedModels.jl as a case study to discuss why gradients, even with modern automatic differentiation, may not provide much benefit or even be slower than gradient-free approaches. We'll look at why the evaluation of the gradient itself can be expensive enough that gradient-based optimization suffers from dramatically slower step speed. We'll also discuss how particular objective functions can be "compatible" with particular gradient-free optimizers in a way that results in very rapid convergence, such that gradient-free approaches may not require substantially more iteration steps than gradient-based approaches. We'll explore these properties with examples from our attempts to take advantage of the gradient in MixedModels.jl. We'll see why we haven't (yet) moved to gradient-based approaches and, more generally, that gradient-free approaches still have a role to play, even in a world of convenient, accessible autodiff. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/RGVXMP/ Muschel — N2 Phillip Alday PUBLISH RXG7AD@@pretalx.com -RXG7AD What’s new with Herb.jl: Teaching Programs how to Program with Program Synthesis en en 20260812T113000 20260812T120000 003000 What’s new with Herb.jl: Teaching Programs how to Program with Program Synthesis `Herb.jl` is a toolbox and framework for program synthesis: Automatically generating (not just) programs from specifications. Since our last talk at JuliaCon 2024, `Herb.jl` has grown substantially, combining both reasoning about programs and LLM-guided code generation. First, we introduce new constraint-solving techniques to `Herb.jl` and program synthesis: Constraints allow us to prune large regions of possible programs, e.g., by removing symmetries and useless programs, leading to significantly faster solving times. Second, we introduce provable LLM guidance: In `Herb.jl`, large language models (LLMs) can propose candidates or search heuristics, while `Herb.jl` retains formal guarantees and reasoning capabilities. In this talk, we give a brief overview of our architecture, which unifies these ideas into a single extendable pipeline. We demonstrate how Julia’s metaprogramming and composability enable implementing new and old synthesizer ideas, and show how `Herb.jl` helps to synthesize not just programs. PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/RXG7AD/ Muschel — N2 Tilman Hinnerichs Reuben Gardos Reid PUBLISH A9PDA7@@pretalx.com -A9PDA7 Optuna.jl - Hyperparameter optimization with Optuna in Julia en en 20260812T120000 20260812T121500 001500 Optuna.jl - Hyperparameter optimization with Optuna in Julia Hyperparameter optimization is essential for improving model performance, robustness, and generalization across machine learning, simulation, and data-driven applications. While Python users have long benefited from mature frameworks like Optuna [1], Google Vizier [2], and Weights & Biases [3], Julia's native offerings remain limited: the most established package, `Hyperopt.jl`, is in maintenance mode and no longer accepts new features, and to our knowledge no existing Julia package supports distribution across multiple machines. This talk presents `Optuna.jl`, which can be used to seamlessly integrate the `Optuna` framework into your Julia code via `CondaPkg.jl` and `PythonCall.jl`, and optimize hyperparameters directly in Julia. We support all samplers, pruners and database backends, with native single-threaded, multi-threaded and multi-process execution and took special care to make sure high-performance Julia-Code doesn't get slowed down from Python-Calls. We will also introduce `OptunaDashboard.jl`, a wrapper for the `optuna-dashboard` package for visualizing and managing optimization studies. “Optuna, the Optuna logo and any related marks are trademarks of Preferred Networks, Inc.” [1] Akiba, T., Sano, S., Yanase, T., Ohta, T., & Koyama, M. (2019). Optuna: A Next-generation Hyperparameter Optimization Framework. In Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining. [2] Golovin, D., Solnik, B., Moitra, S., Kochanski, G., Karro, J., Sculley, D. (2017). Google Vizier: A Service for Black-Box Optimization. In Proceedings of the 23rd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, Halifax, NS, Canada, August 13 - 17, 2017 (pp. 1487–1495). ACM. [3] Biewald, L. (2020). Experiment Tracking with Weights and Biases. https://www.wandb.com/ PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/A9PDA7/ Muschel — N2 Julian Trommer Lars Mikelsons PUBLISH CYWCXK@@pretalx.com -CYWCXK BaseModelica.jl: A Julia Interface for BaseModelica en en 20260812T121500 20260812T123000 001500 BaseModelica.jl: A Julia Interface for BaseModelica BaseModelica is a newly proposed standard that defines a subset of the Modelica standard to be used as a "flattened" representation of full Modelica models. Engineers and scientists often have large, carefully validated Modelica models built up over years in tools like Dymola, OpenModelica, or Modelon Impact. However, these models are oftentimes dependent on the exact toolchain that was used to create them. BaseModelica aims to side step portability issues by defining a common intermediate representation of models that can be imported and exported from any Modelica tool. BaseModelica.jl translates BaseModelica models in to ModelingToolkit models, bringing the full capabilities of the SciML and Julia ecosystem to preexisting Modelica models. This talk will explain exactly what the BaseModelica standard is and what its goals are, explore the design and implementation of BaseModelica.jl, and discuss some of the difficulties that come with developing a package around an unfinished and evolving standard. Finally, we'll show off some of the capabilities of the package by parsing some BaseModelica models and using the SciML stack. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/CYWCXK/ Muschel — N2 Jadon Clugston PUBLISH 8ETRSY@@pretalx.com -8ETRSY PointCloudRegistration.jl: Rigid and non-rigid registration of point clouds en en 20260812T123000 20260812T130000 003000 PointCloudRegistration.jl: Rigid and non-rigid registration of point clouds The talk will contain aspects of the design, implementation, and usage of PointCloudRegistration.jl ## Why is this interesting? Be it the molecular structure of a therapeutic protein or the surface of a sculpture in an art gallery, point clouds are a convenient model to describe real world objects. If you have two of them, you might want to combine them into a bigger object, find their differences, or compare them in a more complex way. For any of these operations, you first have to find a common frame of reference by rotating and translating one point cloud (the _source_) to match the other (the _target_). This is called _rigid registration._ To align the two point clouds beyond rigid transformations, you might assign an individual displacement to every point of the source such that the displaced source matches the target. Different methods of such _non-rigid registration_ vary in what kind of displacement they consider admissible and/or plausible. ## About the package The package aims at offering a comprehensive set of tools for all point cloud registration needs, focusing on performance, a convenient interface, and broad applicability. While some implementations already exist in the Julia ecosystem, they mostly cover the simplest case of known point-to-point correspondences and no outliers (Kabsch algorithm). Our package not only has a more time and memory efficient implementation of the Kabsch algorithm but can register point clouds in more adverse settings as well. For non-rigid registration, multiple algorithms are available, letting users of the package choose between different notions of optimal matching and plausible displacement. Finally, PointCloudRegistration.jl comes with a small amount of helper functions that can be useful when dealing with point clouds, such as thinning or conversion from density maps. PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/8ETRSY/ Muschel — N2 Andreas Kröpelin PUBLISH NJBNMC@@pretalx.com -NJBNMC ComputableDAGs.jl en en 20260812T143000 20260812T150000 003000 ComputableDAGs.jl PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/NJBNMC/ Muschel — N2 Anton Reinhard PUBLISH QJYSLE@@pretalx.com -QJYSLE Reseau.jl: Platform-Native Async IO Primitives for Julia en en 20260812T150000 20260812T153000 003000 Reseau.jl: Platform-Native Async IO Primitives for Julia PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/QJYSLE/ Muschel — N2 Jacob Quinn PUBLISH 3W9MAF@@pretalx.com -3W9MAF Making the Cut Norm Practical: A Julia Ecosystem Approach en en 20260812T154500 20260812T160000 001500 Making the Cut Norm Practical: A Julia Ecosystem Approach PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/3W9MAF/ Muschel — N2 Martin Köhler PUBLISH VAB77G@@pretalx.com -VAB77G ConvolutionInterpolations.jl: High-order interpolation, differentiation, integration and smoothing on discrete grids in arbitrary dimensions en en 20260812T160000 20260812T163000 003000 ConvolutionInterpolations.jl: High-order interpolation, differentiation, integration and smoothing on discrete grids in arbitrary dimensions This talk will be a practical demonstration of the features of ConvolutionInterpolations.jl. After a brief introduction of the package and its author, this talk will proceed live in the Julia REPL. Features which will be demonstrated include: - A selection of the available interpolation methods, from simple to high accuracy. - Performance comparison with other interpolation packages. - Non-uniform grids. - High-order smooth derivatives from discrete samples. - Integrals. - Dimension-wise kernel and derivative selections. - Multi-dimensional application (2D). Future plans include: a Python port, writing a paper, PDE applications, more documentation. Attendees will leave with the intuition of how, when and why to use ConvolutionInterpolations.jl. PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/VAB77G/ Muschel — N2 Nikolaj Maack Bielefeld PUBLISH SFWUKP@@pretalx.com -SFWUKP Deep Adaptive Experimental Design for SciML en en 20260812T163000 20260812T170000 003000 Deep Adaptive Experimental Design for SciML Model-based design of experiments (MbDoE) is a fundamental methodology in engineering and the sciences: given a mechanistic model with unknown parameters, choose experimental conditions that yield the most informative data [1]. Adaptive designs use the information in the already gathered experiments to guide the remainder of the experiment. However, conventional adaptive MbDoE requires solving a computationally expensive optimization problem between every measurement, which is infeasible when experiments run in real-time [2]. Deep Adaptive Design (DAD) addresses this by training a neural network policy offline to map experimental histories to optimal designs [3]. Once trained, the policy requires only a forward pass at deployment, enabling real-time adaptive decisions. We apply DAD on a differentiable mechanistic model, i.e., dynamical systems described by ODEs with known structure but uncertain parameters. ## The SciML stack: Lux + Enzyme + Reactant The core contribution of this talk is showing how three pillars of the Julia ecosystem compose to solve a problem that would be difficult in any other framework. Enzyme.jl -- differentiating through ODE solvers. Lux.jl -- defining the policy network. Reactant.jl -- GPU compilation of the full training loop. The key insight is that none of these packages needed special adaptation to work together. Writing the ODE solver, the neural network, and the loss function in plain Julia was sufficient for Enzyme to differentiate through all of it and for Reactant to compile the result to GPU. ## Application and results We primarily demonstrate the approach on a fed-batch bioreactor with Monod growth kinetics. The goal is to estimate the maximum growth rate and substrate affinity constant by adaptively choosing feed rates over a 14-hour experiment based on noisy substrate concentration measurements. The trained policy is compared against a Bayesian D-optimal static design. The adaptive policy achieves a 99.5% win rate over this optimized static baseline. Besides the bioreactor with Monod kinetics, an overview of several other applications is showcased. ## Who should attend This talk is relevant to anyone interested in differentiable programming in Julia, scientific machine learning, Bayesian experimental design, or composing the SciML ecosystem for non-standard workloads. No prior knowledge of experimental design is assumed. ## References [1] Franceschini, G. & Macchietto, S. (2008). Model-based design of experiments for parameter precision: State of the art. Chemical Engineering Science, 63(19), 4846-4872. [2] Ryan, E.G., Drovandi, C.C., McGree, J.M., & Pettitt, A.N. (2016). A review of modern computational algorithms for Bayesian optimal design. International Statistical Review, 84(1), 128-154. [3] Foster, A., Ivanova, D.R., Malik, I., & Rainforth, T. (2021). Deep Adaptive Design: Amortizing Sequential Bayesian Experimental Design. International Conference on Machine Learning, 3384-3395. PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/SFWUKP/ Muschel — N2 Arno Strouwen Sebastian Micluța-Câmpeanu PUBLISH D8SJCG@@pretalx.com -D8SJCG What's new in BestieTemplate.jl en en 20260812T170000 20260812T171500 001500 What's new in BestieTemplate.jl I will present updates to [BestieTemplate.jl](https://github.com/JuliaBesties/BestieTemplate.jl) since [JuliaCon 2024](https://pretalx.com/juliacon2024/talk/9AMPUD/), including: - Strictness levels Tiny, Light, Moderate, Robust; - `new_pkg_quick` for non-interactive package creation; - Better UX for application to existing packages; - New additions such as TestItem-based testing, and dependabot. I will also talk about the process of creating a new question, explaining a bit the inner workings of the package and of copier. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/D8SJCG/ Muschel — N2 Abel Soares Siqueira PUBLISH 8A73NK@@pretalx.com -8A73NK Leveraging Go in Julia: a story of interop en en 20260812T171500 20260812T173000 001500 Leveraging Go in Julia: a story of interop Go is a statically typed, compiled programming language, widely used for web backend development, microservices, and highly concurrent applications. It has a very mature and robust support for networking, HTTP servers, and related technologies, both as part of the standard library and in the broader Go package ecosystem. Julia, on the other hand, often has limited or lacking support in these areas. In this talk, I explore a recent project where we filled a Julia capability gap — the lack of support for gRPC — by leveraging Go. Via the Julia-C interop and Go’s cgo C interoperability, we can link a Julia process to a Go shared library and use ccalls to offload the complicated bits to the robust and battle tested Go implementation of gRPC, while keeping the business logic in Julia. Go’s runtime introspection also allowed us to keep the glue code quite simple and generic, without resorting to any form of code generation. The talk will focus on the challenges and lessons from the Go-Julia interoperability, such as how to manage types, Go’s garbage collector & asynchronous programming capabilities, and potential pitfalls. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/8A73NK/ Muschel — N2 Morten Piibeleht PUBLISH VMYLLT@@pretalx.com -VMYLLT Data Analysis on Global Grid Systems en en 20260812T100000 20260812T101500 001500 Data Analysis on Global Grid Systems Julia now has an up-and-coming ecosystem for global grid systems (commonly called DGGS). The question of getting data to and from such a grid is mostly solved. But once data is on that grid, how do you interpret and analyse it? One of the most interesting applications here, especially for earth scientists, might be analysing data on the grid it's simulated on - thus removing regridding error, and allowing easier debugging at the simulation level. By "data analysis", we mean both "traditional" zonal statistics and similar methods as well as more interesting things like applying stencil operations, movement analysis and more. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/VMYLLT/ Muschel — N3 Anshul Singhvi PUBLISH XFLETV@@pretalx.com -XFLETV MapMaths.jl - Leveraging Julia for Flexible and Fast Coordinate Transformations en en 20260812T101500 20260812T103000 001500 MapMaths.jl - Leveraging Julia for Flexible and Fast Coordinate Transformations The most straightforward way to implement a coordinate conversion library is to define functions like `cartesian_from_latlonalt()` or `webmercator_from_cartesian()`, but this approach requires manually implementing a new pair of conversion functions for every pair of coordinate systems and therefore puts a substantial cost on adding new systems. Furthermore, we frequently want to convert not just between full three-dimensional coordinate systems but also partial coordinate systems like latitude-longitude or WebMercator without altitude, and this forces us to either define even more conversion functions between even more start- and endpoints, or else to sacrifice readability and potentially performance by introducing "phantom coordinates" whose only purpose is to fill in the holes imposed by the API. Finally, every start and end coordinate system comes with a potentially distinct geodetic datum (a mathematical reference model for the true geometry of the earth), and this adds yet another layer of combinatorial complexity. Julia has two fairly decent coordinate conversion packages, namely Geodesy.jl and CoordRefSystems.jl, but both of these packages solve the combinatorial explosion problem largely by force rather than clever software design. In this talk, I will show how MapMaths.jl leverages Julia features like multiple dispatch, Holy traits and generated functions so human programmers can implement just a spanning tree of coordinate conversions and then rely on the Julia compiler to fill in its transitive closure. As we will see, this conversion generator unlocks a new level of API flexibility and completeness, and it does that without sacrificing even an arcsecond of performance. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/XFLETV/ Muschel — N3 Simon Etter PUBLISH NEXMM8@@pretalx.com -NEXMM8 DGGS.jl: Discrete Global Grid System Native Data Cubes en en 20260812T103000 20260812T104500 001500 DGGS.jl: Discrete Global Grid System Native Data Cubes Discrete Global Grid Systems (DGGS) tessellate the earth’s surface into zones of equal area and very similar shape, minimizing spatial distortions in geospatial data processing. DGGS are not only used for geocoding but also offer a highly efficient data structure by eliminating tile overlap compared to traditional grids like UTM used in many satellite missions. The performance of operations on DGGS native data cubes is intrinsically linked to the cell index. Many real-world applications, such as visualization or convolutions, require efficient handling of higher-order neighbor queries based on spatial distances, motivating a multidimensional spatial index as coordinates in the n-dimensional array. In response to these challenges, we introduce DGGS.jl (https://danlooo.github.io/DGGS.jl), a Julia package specifically developed to create and utilize DGGS native data cubes optimized for neighbor queries. Our package employs the DGGRID Q2DI index to store data on a grid based on the Icosahedral Snyder Equal Area projection, enabling compact and efficient data cube arrays. We have implemented methods to seamlessly convert raster data between geographic and Q2DI coordinates, access neighbor disks around a given cell, and visualize these data on a global scale. In addition, we developed an XYZ tile server, allowing us to view DGGS native data cubes in QGIS and in the browser. Finally, we applied DGGS.jl on a subset of the Sentinel-2 archive. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/NEXMM8/ Muschel — N3 Daniel Loos PUBLISH YKG9N9@@pretalx.com -YKG9N9 Exploring Meteorological Satellite Observations with MetopDatasets.jl en en 20260812T104500 20260812T110000 001500 Exploring Meteorological Satellite Observations with MetopDatasets.jl PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/YKG9N9/ Muschel — N3 Simon Kok Lupemba PUBLISH 33JU7Y@@pretalx.com -33JU7Y Fast geospatial lookups across projections using SphericalSpatialTrees.jl en en 20260812T111500 20260812T113000 001500 Fast geospatial lookups across projections using SphericalSpatialTrees.jl PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/33JU7Y/ Muschel — N3 Fabian Gans PUBLISH 8RGCRS@@pretalx.com -8RGCRS Spatial Machine Learning for Digital Soil Mapping en en 20260812T113000 20260812T114500 001500 Spatial Machine Learning for Digital Soil Mapping Digital soil mapping increasingly relies on spatial machine learning techniques that must balance predictive accuracy, spatial fidelity, and computational scalability. Recent research in the Python and R ecosystems highlights the advances in explicit spatial structure, multi‑scale context, and robust uncertainty quantification. However, for experimenting with large‑area, high‑resolution prediction tasks, Python felt inefficient. Building on earlier national‑scale experiments in Estonia and leveraging the increasingly mature MLJ ecosystem, this project explores a fully Julia‑based spatial ML pipeline to improve the modelling of soil organic carbon (SOC). The workflow integrates three components: - Random Forest (RF) models implemented via MLJ / DecisionTree for nonlinear, interaction‑rich prediction; - Stacked ML meta‑learning to combine predictions across multiple model families and spatial resolutions (DGGS-based neighbourhood kernels and parent-relationship to model spatial structure and tele-connections); - Conformal prediction to generate calibrated, spatially explicit uncertainty intervals. A key innovation is the integration of the IGEO7 discrete global grid system (DGGS). DGGS are increasingly used, knowingly and unknowingly (HEALPix, H3, etc). IGEO7 originates from the DGGRID tool (Sahr, K., https://github.com/allixender/DggridRunner.jl, a native CxxWrap binding is still under development). We made it available to Julia as the fundamental spatial scaffold. Several core functionalities, such as Z7-indexing-based neighbourhoods, are now natively implemented in Julia (https://github.com/allixender/Z7.jl), as is the required authalic conversion from the spherical DGGS to the WGS84 ellipsoid. IGEO7’s equal‑area, multi‑resolution hierarchy provides a principled alternative to traditional spatial ML approaches based on k‑nearest neighbours, coordinate distances, or buffer‑based metrics. Environmental covariates (climate, terrain, land cover, and Estsoil profile data) are aggregated at several DGGS resolutions, allowing the models to capture hierarchical spatial dependencies similar to those of multi‑mesh graph structures proposed in current spatial ML research (e.g., Google GraphCast). Variable preparation follows the literature to enhance the role of predictors most relevant to SOC modelling, including various terrain and geomorphological indices (e.g., via Geomorphometry.jl) and remote sensing indices, such as NDVI and more. These predictors form the basis for both model training and the dissimilarity index (DI) used in the area of applicability (AOA) framework, which is an increasingly standard requirement in spatial ML for assessing extrapolation risk. Training samples are drawn within the DGGS structure to ensure spatial representativeness, and spatial cross‑validation is performed using DGGS‑consistent blocking schemes to counter overoptimistic estimates caused by autocorrelation. The resulting models can generate predictions at multiple IGEO7 levels, supporting both fine‑resolution mapping and aggregated, scalable national‑level assessments. Uncertainty assessment combines two complementary approaches: - Conformal prediction, offering distribution‑free uncertainty intervals calibrated to the empirical error structure; - AOA‑based spatial validity masks, identifying regions where model predictions are reliable based on weighted distances in predictor space. In a future research paper, we aim to explore and discuss in more detail the similarities and differences in the uncertainty results between the two methods. Additionally, Quantile Random Forest would be great, but it is not yet available in Julia. By building this workflow almost entirely in Julia, the project benefits from Julia’s performance for large‑scale raster/grid operations, MLJ’s flexible model composition, and the ease of integrating custom spatial data structures such as IGEO7. The talk will present the modelling pipeline, computational aspects, evaluation results, and lessons learned about implementing advanced spatial ML methods in the Julia ecosystem. This work demonstrates how Julia can serve as a powerful platform for modern spatial machine learning, offering performance, composability, and extensibility in comparison to what is typically feasible in Python/R‑based workflows. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/8RGCRS/ Muschel — N3 Alexander Kmoch PUBLISH TRBDEP@@pretalx.com -TRBDEP State of GeoDataFrames.jl en en 20260812T114500 20260812T120000 001500 State of GeoDataFrames.jl Every spatial ecosystem needs packages to read and write vector data. In the JuliaGeo ecosystem, we've done so with GDAL, ArchGDAL and GeoDataFrames packages for a long time, slowly introducing more native file formats (ShapeFile, GeoJSON, GeoArrow). In the past (and current) year, GeoDataFrames.jl has seen an uptick in developments, as the community considers the package (should become) an entrypoint for the whole ecosystem. Recent developments include: - Native Julia driver support when loaded using extensions - Metadata passthrough support, keeping metadata intact when possible - GeometryOps integration, deprecating ArchGDAL operations - GeometryVector (column) to make some handling of spatial data easier Future planned developments include: - Native GeoDataFrame <: AbstractDataFrame type so dispatch becomes easier - Spatial index support (from GeometryOps) on GeometryVector - Lazy reading mode The above two developments (ideally with the new FilePaths design proposals) should enable lazily reading and subsetting of cloud native datasets. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/TRBDEP/ Muschel — N3 Maarten Pronk PUBLISH 9TXRNM@@pretalx.com -9TXRNM GeometryOps.jl: finally on the sphere! en en 20260812T120000 20260812T121500 001500 GeometryOps.jl: finally on the sphere! The conventional idea of geospatial geometry processing is that it happens on a 2-dimensional plane. Given the rise of global grid systems as new storage formats, a focus on the north and south poles as the harbingers of climate change, and increased computational budgets, in many modern usecases it may not be desirable to compute in 2D anymore. We've been talking about this for a while, but GeometryOps now finally has 2-dimensional polygon intersection natively available in Julia, along with some other utility functions like area, perimeter, etc. It also has a connection to Google's s2 library via the [s2geography](https://github.com/paleolimbot/s2geography) library, which is the same wrapper library used in R and Python. GeometryOps should thus be capable of performing most, if not all, necessary operations on the sphere. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/9TXRNM/ Muschel — N3 Anshul Singhvi PUBLISH UVWQCA@@pretalx.com -UVWQCA ATLAS: A global atmospheric chemistry and transport model written in Julia en en 20260812T143000 20260812T144000 001000 ATLAS: A global atmospheric chemistry and transport model written in Julia ATLAS is a global atmospheric chemistry and transport model (commonly known as CTM). In contrast to many other models, it is not based on a Eulerian approach ("grid boxes"), but on a Lagrangian approach ("air parcel trajectories"). It has a focus on stratospheric chemistry (in particular anthropogenic ozone depletion), but also has seen some extensions in the last years. These include, e.g., tropospheric convection on individual trajectories and the chemistry of sulfur dioxide. We give a short overview over the implementation of the model and the algorithms. ATLAS is based on a modular approach, and several of the components, like the air parcel trajectory model or the chemistry "box" model can also be used as stand-alone components. In contrast to a climate model, ATLAS does not have a "dynamical core". Temperatures and winds are obtained from external meteorological data (e.g. ECMWF ERA5). Transport and mixing (diffusion) are simulated. In contrast to an Eulerian model, atmospheric diffusion can be tuned to observations in the real atmosphere. ATLAS has been used in numerous scientific studies and publications in the last 15 years, and we will show some examples of the application of the model. GitLab repository (not public): https://gitlab.awi.de/iwohltmann/atlas-julia Snapshot of the code: https://doi.org/10.5281/zenodo.21103974 PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/UVWQCA/ Muschel — N3 Ingo Wohltmann PUBLISH LFPLJT@@pretalx.com -LFPLJT Helmut: A Modular and Extensible Snow Cover Model en en 20260812T144000 20260812T145000 001000 Helmut: A Modular and Extensible Snow Cover Model Helmut was developed in collaboration between the Snow Studies Centre in Grenoble, France, the developers of Crocus and the WSL Institute for Snow and Avalanche research SLF in Davos, Switzerland, the developers of SNOWPACK. It therefore benefited from the combined knowledge, with the goal of having a unified snow model that can be adjusted as needed. Such adjustments can be as simple as introducing a new type of material layer, for example glacier ice, or a new parameterziation for thermal conductivity, to as complex as a new physics-based process that needs to be solved in a coupled fashion with other processes. As of now, most parametrizations for snow follow the Crocus model, while the integrated soil model closely follows the implementation in SNOWPACK. The goal is to have parametrizations that are like SNOWPACK’s and Crocus’s in the model and as a starting point for community-driven future model developments. In this contribution, we show the general model structure and show examples of how the flexible model structure can be leveraged to explore different physics configurations and add new parametrizations. One of these examples demonstrate how soil layers can be defined as extension of the general layer type, and the inclusion of a new detailed radiative transfer process by implementing the Tartes model for albedo. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/LFPLJT/ Muschel — N3 Patrick Leibersperger de Fleurian Basile PUBLISH VB7AEV@@pretalx.com -VB7AEV Idealized Atmospheric Flow and Gravity-Wave Modeling with PinCFlow.jl en en 20260812T145000 20260812T150000 001000 Idealized Atmospheric Flow and Gravity-Wave Modeling with PinCFlow.jl [PinCFlow.jl](https://github.com/Atmospheric-Dynamics-GUF/PinCFlow.jl) (Pseudo-inCompressible Flow solver), developed for conducting idealized atmospheric simulations, integrates the Boussinesq, pseudo-incompressible, and compressible equations using a finite volume approach and a semi-implicit time-stepping scheme. Due to MPI parallelization in all spatial dimensions, high-resolution, wave-resolving simulations can be conducted efficiently. The use of a terrain-following coordinate system allows for arbitrary surface topography. A unique feature of [PinCFlow.jl](https://github.com/Atmospheric-Dynamics-GUF/PinCFlow.jl) is its numerical realization of multiple-scale WKB theory for the parameterization of gravity-wave impacts on mean-flow dynamics using MS-GWaM (Multi-Scale Gravity-Wave Model). Here, gravity waves are approximated using a ray-tracing technique, where so-called ray volumes propagate through a six-dimensional phase-space. Unlike conventional single-column, steady-state parameterizations, MS-GWaM accounts for wave transience and horizontal propagation. Current research and development focuses on the generation of orographic gravity waves, the interaction between gravity waves and turbulence, and their impact on ice cloud formation and tracer transport. Originally developed in Fortran 90, the solver has been fully translated and optimized as a Julia package. Now officially registered and accompanied by extensive documentation, [PinCFlow.jl](https://github.com/Atmospheric-Dynamics-GUF/PinCFlow.jl) provides a modern, high-performance framework for research in computational fluid dynamics. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/VB7AEV/ Muschel — N3 Irmgard Steiger PUBLISH TGHPQ9@@pretalx.com -TGHPQ9 Online calibration of a Neural Network Parameterization in ShallowWaters.jl en en 20260812T150000 20260812T151000 001000 Online calibration of a Neural Network Parameterization in ShallowWaters.jl PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/TGHPQ9/ Muschel — N3 Sarah Williamson PUBLISH 9RKTV9@@pretalx.com -9RKTV9 Snow modelling for operational and research applications en en 20260812T151000 20260812T152000 001000 Snow modelling for operational and research applications PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/9RKTV9/ Muschel — N3 Jan Magnusson PUBLISH GB8WXW@@pretalx.com -GB8WXW SpeedyWeather.jl: Towards a differentiable and GPU-capable general circulation model en en 20260812T152000 20260812T153000 001000 SpeedyWeather.jl: Towards a differentiable and GPU-capable general circulation model The current generation of usually Fortran-based climate models presents a high entry barrier to climate modelling. Julia on the other hand gives us the tools to write climate models that are performant, but at the same time easy to use for both end users and developers. This extends to differentiable programming and GPU programming as well. In the past year, we spent a considerable effort on making SpeedyWeather.jl differentiable with Enzyme, GPU-capable with KernelAbstractions and Reactant. We also extended our process implementations by adding new parameterizations of radiation, and simple sea ice, land and snow models to run climate simulations with SpeedyWeather.jl. In this talk, we will give an overview on the changes we had to make for this. These changes also enabled us to redesign parts of our model for even better customisability and composability, as demonstrated for example by a new parametrization system. Furthermore, we will give an outlook on using SpeedyWeather.jl differentiability for sensitivity analysis and ongoing work on including machine-learning-based parametrizations and coupling SpeedyWeather.jl to other Earth system component models. **Authors** Maximilian Gelbrecht (1,2), Milan Klöwer (3), and SpeedyWeather.jl contributors* 1. Potsdam Institute for Climate Impact Research, Germany 2. Technical University of Munich, Germany 3. University of Oxford, UK *SpeedyWeather.jl is a community project with valuable contributions from a large group of contributors, we are sorry that we can’t list everyone here by name PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/GB8WXW/ Muschel — N3 Maximilian Gelbrecht Milan Klöwer PUBLISH D8AMAJ@@pretalx.com -D8AMAJ Pagos.jl - play ice-sheet modelling like it’s Lego en en 20260812T155000 20260812T160000 001000 Pagos.jl - play ice-sheet modelling like it’s Lego PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/D8AMAJ/ Muschel — N3 Jan Swierczek-Jereczek PUBLISH UETBSG@@pretalx.com -UETBSG Terrarium.jl: Fully differentiable and GPU-accelerated land modeling at all scales in Julia en en 20260812T160000 20260812T161000 001000 Terrarium.jl: Fully differentiable and GPU-accelerated land modeling at all scales in Julia PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/UETBSG/ Muschel — N3 Brian Groenke Maximilian Gelbrecht PUBLISH V337P8@@pretalx.com -V337P8 TrixiAtmo.jl: Advanced numerical schemes for atmospheric flows en en 20260812T161000 20260812T162000 001000 TrixiAtmo.jl: Advanced numerical schemes for atmospheric flows We have recently released `TrixiAtmo.jl`, a specialized extension of `Trixi.jl` that brings state-of-the-art numerical methods, drastically increased resolution, and high physical fidelity to Earth system models. Current global climate models typically operate at horizontal resolutions of tens of kilometers. Increasing this resolution towards the kilometer scale would enable a substantially improved representation of key physical and chemical processes, which are currently treated by parametrizations and constitute a major source of uncertainty. We address this challenge with two tightly coupled methodological advances: Discontinuous Galerkin (DG) methods and dynamic Adaptive Mesh Refinement (AMR). DG, as a high order method, offers high accuracy while maintaining a low memory footprint, thereby reaching unmatched efficiency. Historically, high-order methods have been susceptible to numerical instabilities and have struggled with unresolved physical processes like turbulence. However, recent advancements, particularly the development of entropy-conserving schemes, have significantly improved this situation. By incorporating a physics-based concept of stability, spurious disturbances in the numerical solution are effectively suppressed. Simultaneously, AMR allows us to concentrate computational effort in regions of interest, such as sharp gradients in prognostic quantities or chemically active zones. Consequently, overall computational and storage costs are drastically reduced, and simulations governed by local and regional processes achieve substantial gains in efficiency. Despite their undisputed potential, both DG and AMR, have seen limited adoption in global atmospheric and chemistry–climate simulations to date. With `TrixiAtmo.jl`, we tailor `Trixi.jl`'s numerical schemes to the requirements of atmospheric dynamical cores. So far, we have implemented the compressible Euler equations, including moist air and rain, on hex-based cubed sphere grids, and the shallow water equations on prism-based icosahedral grids, where the latter closely resembles the `ICON` model setup. We have added well-balanced, and entropy-conserving and dissipating split-form schemes. For idealized atmospheric flows, such as the barotropic and baroclinic instability, we observe stable simulations even on coarse meshes. We now aim to extend `TrixiAtmo.jl` towards more realistic applications to put our methods to a compelling test. Among other tasks, this requires flexible import and remapping methods of reanalysis-based input data and easy to use analysis and visualization work flows for the resulting data. Julia already boasts an exceptionally rich geoscience community and software stack, which we plan to leverage. Several projects such as `CliMA`, `SpeedyWeather.jl`, and `Breeze.jl`, to name but a few, have already demonstrated Julia's viability for high-performance computing in the Earth and climate sciences. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/V337P8/ Muschel — N3 Benedict Geihe PUBLISH QSV7XN@@pretalx.com -QSV7XN Strategies to Integrate Data and Biogeochemical Models: SINDBAD Julia Framework for Terrestrial Ecosystem Model Data Integration en en 20260812T162000 20260812T163000 001000 Strategies to Integrate Data and Biogeochemical Models: SINDBAD Julia Framework for Terrestrial Ecosystem Model Data Integration The Julia ecosystem continues to expand with powerful, composable tools for scientific computing, data analysis, and simulation. In this talk, we introduce the Strategies to Integrate Data and Biogeochemical Models (SINDBAD) model–data‑integration framework, which comprises five complementary packages that together form a lightweight but versatile foundation for the terrestrial ecosystem modeling community. The packages are intentionally designed to be user‑friendly for low‑tech, high Earth‑system domain expertise, while fully leveraging the computational excellence of the Julia programming language. This lowers the barrier of entry for the next generation of Earth‑system modellers. Sindbad.jl provides the umbrella framework for building and executing terrestrial ecosystem modeling experiments. It emphasizes modularity, reproducibility, and clarity, enabling users to carry out scientific analyses across spatial and temporal scales. SindbadTEM implements the core formulations for major ecosystem processes of the water and carbon cycles, and can be independently integrated into other Earth‑system modeling systems. OmniTools.jl complements this by offering a curated collection of general‑purpose utilities ranging from filesystem helpers to data‑structure conveniences and helper functions, that extend beyond modeling applications. TimeSamplers.jl implements allocation‑free resampling of N‑dimensional arrays using a date‑indexed view. ErrorMetrics.jl provides a small but robust and extensible set of performance and accuracy metrics commonly used in model–data‑integration approaches. Together, this set of SINDBAD packages enables the construction of modeling experiments that span spatial and temporal scales, especially benefiting from full differentiability enabled by Julia. Traditionally, such models have been limited to narrow ranges of scales; SINDBAD in Julia helps overcome this constraint. We use this opportunity to demonstrate how SINDBAD can be applied to understand interactions among vegetation, water, and carbon cycle processes across scales. To do so, we create different realizations of the framework with varying levels of process complexity and coupling. These realizations are parameterized with different assumptions that lead to distinct model formulations and responses, each constrained by observational data appropriate to its scale: - a global scale model focused on vegetation’s structural influence on the water cycle; - a regional scale model with physiological coupling of water and carbon cycles, emphasizing interannual variability of vegetation fraction; - an ecosystem scale model with a prognostic carbon cycle that allows additional constraints from Earth‑observation data; - a hybrid machine‑learning–physically‑based modeling approach toward a global parameterization that links local ecosystem properties to global parameter fields using neural‑network‑based prediction of spatial parameter variability in an end‑to‑end learning system. At the global scale, we find that incorporating observation‑based vegetation indices into a simple hydrological model improves simulations of monthly runoff and terrestrial water storage variations. At the regional scale, using vegetation‑fraction data from geostationary satellites in a photosynthetically coupled water–carbon model significantly improves simulations of gross primary productivity variability. At the ecosystem scale, a model linking C–H₂O fluxes and states, by prognostically coupling primary productivity, transpiration, and root allocation, benefits further from remote‑sensing observations of carbon states, even beyond eddy‑covariance constraints. These examples demonstrate that, with appropriate observational constraints, an across‑scale approach supports hypothesis testing for terrestrial C–H₂O processes. However, direct comparisons across scales reveal that model–observation discrepancies at a given scale are often quantitatively comparable to differences among observational products themselves. To address this, we implement the hybrid modeling experiment and show that such workflows perform comparably to in‑situ parameter inversions, though their ability to generalize parameters remains limited, in particular for ecosystem processes with sparse observational constraints. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/QSV7XN/ Muschel — N3 Sujan Koirala Fabian Gans Felix Cremer Lazaro Alonso Nuno Carvalhais PUBLISH AFFXGE@@pretalx.com -AFFXGE Multi-physics geophysical flow simulations using JustRelax.jl en en 20260812T163000 20260812T164000 001000 Multi-physics geophysical flow simulations using JustRelax.jl Simulating the solid Earth's thermo-mechanical evolution requires solving coupled, non-linear Stokes and heat-diffusion problems across large domains with sharp material contrasts,complex nonlinear visco-elasto-plastic rheologies, and long time scales. Traditionally, these simulations run on High-Performance Computing (HPC) machines due to their substantial memory and computational demands. As HPC centres transition away from CPU-only architectures toward GPU-accelerated systems, large legacy codes written originally for CPU architectures face extensive rewriting and optimisation efforts. Here, we present JustRelax.jl, an open-source, highly portable Julia package for geodynamic modelling. It employs the matrix-free Accelerated Pseudo-Transient (APT) method to solve the Stokes and heat-diffusion equations, making it well-suited to exploit modern GPU hardware while remaining fully functional on CPUs. JustRelax.jl exposes a high-level API while remaining highly modular, building upon a suite of packages developed within the (∂)[GPU4GEO project](https://gpu4geo.org). GeoParams.jl handles solver-agnostic rheology calculations, while JustPIC.jl manages advection via a multi-XPU Particles-in-Cell scheme specialised for staggered grids. Backend portability is achieved through ParallelStencil.jl's architecture-agnostic kernel abstractions, and distributed-memory communication is managed by ImplicitGlobalGrid.jl via MPI. JustRelax.jl demonstrates near-perfect algorithmic weak scaling in both 2D and 3D up to 512 GPUs, enabling us to perform large-scale geodynamic simulations on modern HPC machines. Recently, the code has been utilised for a domain specific benchmark of plastic shear band localization using 64 Nvidia Grace-Hopper GPUs achieving a global resolution of 41'000 x 41'000. This resolution opens the door to simulate a lithospheric scale geodynamic model at the metre scale. Reference de Montserrat et al., (2026). JustRelax.jl: A Julia package for geodynamic modeling with matrix-free solvers. Journal of Open Source Software, 11(118), 9365, https://doi.org/10.21105/joss.09365 PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/AFFXGE/ Muschel — N3 Pascal Aellig Christian Albert de Montserrat Navarro PUBLISH DTEEQC@@pretalx.com -DTEEQC Hybrid Flux Partitioning in Julia: Learning Temperature Sensitivity of Ecosystem Respiration with EasyHybrid.jl en en 20260812T164000 20260812T165000 001000 Hybrid Flux Partitioning in Julia: Learning Temperature Sensitivity of Ecosystem Respiration with EasyHybrid.jl The talk shows how to use EasyHybrid.jl to define a process-based model, turn it into a hybrid model, and train it end-to-end on eddy-covariance data. We start from typical tabular data (meteorology and fluxes) and show how EasyHybrid.jl connects predictors, mechanistic forcings, and targets using named variables, while relying on Lux.jl for the neural components. We then build a hybrid flux-partitioning model in which ecosystem respiration follows the mechanistic Q10 temperature response, but the base respiration term and radiation-use efficiency for photosynthesis are learned as functions of environmental drivers. The key design choice is explicit: which parameters are learned globally (one constant temperature-sensitivity parameter Q10), which are fixed, and which vary in time and/or space through neural networks. Training uses standard optimizers such as Adam or RMSProp. In an outlook we explore an LSTM-based variant of the hybrid model. Instead of predicting base respiration from instantaneous drivers only, the LSTM takes sequences of past environmental drivers to test whether ecosystem memory changes flux partitioning and the inferred temperature sensitivity. The research presented in this talk is the result of joint efforts by Lázaro Alonso, Kilian Hochholzer, Laura van der Poel, Lukas Schirren, Andrés Tangarife-Escobar, and Ritesh Moon. EasyHybrid.jl was started by Markus Reichstein. We thank Jake Nelson and the FLUXCOM team for providing access to curated FLUXNET data. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/DTEEQC/ Muschel — N3 Bernhard Ahrens RITESH MOON Lazaro Alonso PUBLISH Z8Y8GP@@pretalx.com -Z8Y8GP MovingBoundaryMinerals.jl: Modelling diffusion-limited growth in diffusion couples en en 20260812T165000 20260812T170000 001000 MovingBoundaryMinerals.jl: Modelling diffusion-limited growth in diffusion couples Compositional concentration profiles across individual crystals or diffusion couples are largely determined by diffusion and growth processes. These two processes are particularly important during the formation of high-temperature rocks such as igneous and metamorphic rocks. The numerical simulation of concentration profiles in crystals is a widely used technique in various fields such as geospeedometry or diffusion chronometry. Compared to single crystals, coupled diffusion pairs yield tighter constraints on the experienced temperature and pressure ranges and thus provide additional information for our models. However, the numerical description of concentration profiles within diffusion couples is challenging due to the sharp compositional gradients. Discontinuities in concentration, which are related to the different mineral properties, commonly occur at the interface of two minerals and lead to technical implementation issues. To address these issues, we have developed the Finite Element (FE) package [MovingBoundaryMinerals.jl](https://github.com/AnStroh/MovingBoundaryMinerals.jl) ([Stroh et al., 2025](https://gmd.copernicus.org/articles/18/10203/2025/)) that can calculate the evolution of concentration profiles in diffusion couples with moving interfaces. Within this package, we consider diffusion-limited growth. Grid refinement allows to resolve changes near the interface with a higher resolution. An adaptive grid enables the accurate reproduction of rapid concentration changes and discontinuities. Our code can be applied to various examples of single crystals or diffusion couples, integrating any combination of growth, diffusion, and temperature dependency. Additionally, it is possible to calculate concentration profiles based on the thermodynamically-constrained, Stefan-Interface condition. Our code is benchmarked against analytical solutions for limiting cases. Results from our models can be used in petrology and geodynamic applications to provide tighter constraints concerning the pressure and temperature evolution of magmatic and metamorphic mineral assemblages. Reference Stroh, A., Aellig, P. S., and Moulas, E.: Numerical modelling of diffusion-limited mineral growth for geospeedometry applications, EGUsphere, 1–37, https://doi.org/10.5194/egusphere-2025-2511, 2025. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/Z8Y8GP/ Muschel — N3 Annalena Stroh Pascal Aellig PUBLISH U9ZWXZ@@pretalx.com -U9ZWXZ A learned surface roughness scheme for climate prediction in SpeedyWeather.jl en en 20260812T170000 20260812T171000 001000 A learned surface roughness scheme for climate prediction in SpeedyWeather.jl In weather and climate models, momentum, heat, humidity and tracer fluxes between the Earth’s surface and atmosphere strongly depend on surface roughness. The roughness length depends on space and time-dependent surface properties over ocean, sea-ice and land. For example, surface winds impact wave height over sea-ice free oceans; vegetation and orography determine roughness length over land, where its effect on near-surface turbulence strongly impacts the surface fluxes. Here, we present a set of machine learning models trained on reanalysis data to predict surface roughness over both land and ocean grid cells in SpeedyWeather, a Julia-based climate model. More accurately representing the surface roughness has been shown to significantly improve model bias against observations over a range of variables such as surface air temperatures and near-surface wind speed. We explore the downstream impacts of using this parameterisation in the climate model, and test the generalisability of an offline-learned surface roughness scheme in future climates with reduced sea ice and land-use change. Spatial generalisation is implemented through surface roughness being a function of local variables only. We discuss efficient inference on CPU and GPU for every grid cell on each integration time-step, and use so-called model distillation via SymbolicRegression.jl which minimises the trade-off between speed versus accuracy. Neural networks are trained offline using PyTorch, but loaded in SpeedyWeather as Lux.jl networks, with opportunities to use the Reactant compiler for rapid inference. Separating the land and ocean surface roughness parameterisations, we use XAI techniques to interpret what the models have learned and evaluate their performance against baseline model types. We generally propose machine-learned schemes of individual climate processes towards interpretable, data-driven climate modelling. Authors: Gregory Munday (1), Laura Mansfield (1), Maximilian Gelbrecht (2, 3), Niklas Viebig (1, 4), and Milan Klöwer (1) 1. University of Oxford, UK 2. Potsdam Institute for Climate Impact Research, Germany 3. Technical University of Munich, Germany 4. ETH Zürich, Switzerland PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/U9ZWXZ/ Muschel — N3 Greg Munday Maximilian Gelbrecht Milan Klöwer Niklas Viebig PUBLISH WDZ3AN@@pretalx.com -WDZ3AN Amplitude Analysis of Exotic Multiquark States with Julia in the LHCb Experiment en en 20260812T100000 20260812T101500 001500 Amplitude Analysis of Exotic Multiquark States with Julia in the LHCb Experiment PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/WDZ3AN/ Alte Mensa — Audi Max Mikhail Mikhasenko Robert Hentges PUBLISH 3RXM3H@@pretalx.com -3RXM3H Experiences of Julia (versus other languages) as educational targets for undergraduate physicists en en 20260812T101500 20260812T103000 001500 Experiences of Julia (versus other languages) as educational targets for undergraduate physicists PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/3RXM3H/ Alte Mensa — Audi Max Sam Skipsey PUBLISH F3FBUY@@pretalx.com -F3FBUY Parallel Processing in JetReconstruction.jl en en 20260812T103000 20260812T110000 003000 Parallel Processing in JetReconstruction.jl The Julia JetReconstruction.jl package was released in 2024 and provides a high-performance native Julia implementation of serial jet reconstruction in high-energy physics, inspired by the FastJet C++ package. In serial mode the code outperforms FastJet by 14-40%, depending on the exact parameters used. Until now, no systematic testing and benchmarking of the code had been done when running in a parallel, multi-threaded, mode. In this paper we present the first results of doing this. The initial parallel performance of JetReconstruction.jl, compared to an equivalent multi-threaded version of FastJet, showed increasingly poor performance, with the advantage of JetReconstruction.jl quickly evaporating and becoming about a x10 deficit at high thread counts in the worst case. We performed an investigation of the underlying reasons for this poor performance, looking at thread scheduling parameters, physics code scaling, and memory allocations and garbage collection issues. We review this performance investigation, and the profiling tools which we used, and how we finally understood the source of the problem: memory allocations and garbage collection. We have now designed a new approach to reuse already allocated memory, with much better parallel scaling. We discuss ergonomics of this new interface, which now allows users to run in a highly parallel mode with excellent performance, tested up to 64 parallel threads, which consistently maintains the advantage of JetReconstruction.jl over FastJet. PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/F3FBUY/ Alte Mensa — Audi Max Unnamed speaker Graeme Stewart Unnamed speaker PUBLISH DAY8TS@@pretalx.com -DAY8TS Performance-Portable Random Sampling in Julia: Event Generation and Particle Transport on GPUs en en 20260812T110000 20260812T113000 003000 Performance-Portable Random Sampling in Julia: Event Generation and Particle Transport on GPUs Monte-Carlo techniques are central for many applications in physics simulations, such as event generation in high-energy physics or particle transport in matter. A common theme in these applications is the random sampling of complex probability distributions, often using techniques such as rejection sampling or multi-stage sampling schemes. While these algorithms are simple and robust, the inherent randomness poses challenges to modern accelerators. In applications such as Monte-Carlo event generation, the target distributions are usually high-dimensional and expensive to evaluate. Similarly, in Monte-Carlo particle transport, the involved sequence of stochastic events that determine the particle's propagation, interaction channels, and momentum updates within a spatially resolved geometry. Although both classes of algorithms are often described as embarrassingly parallel, since the events and particle histories are independent, the random nature of the execution path leads to highly heterogeneous workloads. This irregularity complicates the efficient scheduling on GPUs and significantly limits the achievable throughput. In the presented work. we highlight how Julia's GPU tooling can support stochastic simulation workflows and provides practical patterns for implementing scalable Monte-Carlo algorithms on heterogeneous systems. PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/DAY8TS/ Alte Mensa — Audi Max Uwe Hernandez Acosta PUBLISH AZM7B7@@pretalx.com -AZM7B7 Makie's new Raytracing backend en en 20260812T113000 20260812T114500 001500 Makie's new Raytracing backend PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/AZM7B7/ Alte Mensa — Audi Max Simon Danisch PUBLISH HXMUHB@@pretalx.com -HXMUHB Julia for Data Analysis in LHCb experiment en en 20260812T114500 20260812T120000 001500 Julia for Data Analysis in LHCb experiment PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/HXMUHB/ Alte Mensa — Audi Max Ilya Segal PUBLISH HVZZQM@@pretalx.com -HVZZQM The LEGEND Experiment: How to run an entire experiment in Julia en en 20260812T120000 20260812T123000 003000 The LEGEND Experiment: How to run an entire experiment in Julia PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/HVZZQM/ Alte Mensa — Audi Max Florian Henkes PUBLISH ZSLQ7J@@pretalx.com -ZSLQ7J Panel Discussion: What’s Next for JuliaHEP? From Wrappers to Community. en en 20260812T123000 20260812T130000 003000 Panel Discussion: What’s Next for JuliaHEP? From Wrappers to Community. Julia has demonstrated strong potential for high-performance scientific computing, and the JuliaHEP community is rapidly expanding across simulation and data analysis in high-energy, hadron, plasma, and nuclear physics. This moderated panel will discuss what comes next: how can we move beyond individual success stories and wrapping existing frameworks towards building a sustainable software ecosystem for these communities? The discussion will address scaling challenges, the balance between integrating existing tools and developing native solutions, and the role of interoperability in established scientific software landscapes. Beyond technical aspects, the panel will explore opportunities for collaboration, community growth, and lowering barriers to adoption. The goal is to identify concrete next steps to strengthen JuliaHEP and support the wider use of the Julia programming language. PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/ZSLQ7J/ Alte Mensa — Audi Max Uwe Hernandez Acosta PUBLISH N7CSPV@@pretalx.com -N7CSPV A purely numeric approach to the nonlinear coherent Thomson scattering by structured light. en en 20260812T143000 20260812T144500 001500 A purely numeric approach to the nonlinear coherent Thomson scattering by structured light. In our thin sheet model each electron interacts only with the incident radiation and its motion is described by the manifest covariant equations of motion (used here for accuracy and speed reasons) which is a system of 8 ODEs expressed in term of proper time. Thus, by taking advantage of _ModellingToolkit.jl_'s codegen we can readily construct a _DifferentialEquations.jl_ `EnsembleProblem` in order to perform the embarrassing parallelism of solving for the particles' trajectories. Since our goal is to compute the Fourier transform of the total radiated field with respect to laboratory time, it's necessary that for each pixel on our screen we accumulate the synchronized (for the sake of coherence) contribution. This is achieved by solving an implicit ODE relating the screen advanced time to the proper time of each particle. Finally, using the sampled screen electromagnetic field we approximate the continuous Fourier transform using _FFTW.jl_ in order to get the spatial profile and phase of the resulting harmonics of the Thomson scattered radiation, as well as evaluate how coherence is lost for increasingly more intense incident radiation. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/N7CSPV/ Alte Mensa — Audi Max Petru-Vlad TOMA Sebastian Micluța-Câmpeanu PUBLISH WKD3CN@@pretalx.com -WKD3CN Aquarium 2.0: Realizing Robotic Swimming with Differentiable Fluid-Structure Interaction Simulation en en 20260812T144500 20260812T150000 001500 Aquarium 2.0: Realizing Robotic Swimming with Differentiable Fluid-Structure Interaction Simulation PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/WKD3CN/ Alte Mensa — Audi Max JJ Lee PUBLISH LP7GLM@@pretalx.com -LP7GLM FewBodyToolkit.jl: Solving 2- and 3-body quantum systems in 1D–3D with general potentials en en 20260812T150000 20260812T151500 001500 FewBodyToolkit.jl: Solving 2- and 3-body quantum systems in 1D–3D with general potentials [FewBodyToolkit.jl](https://github.com/lhapp27/FewBodyToolkit.jl) is a Julia package for solving quantum few-body problems with two and three particles in one to three dimensions. It supports pair interactions of general shape, bound and resonant states, and on-the-fly calculation of observables. The package has been applied in research on ultracold atomic systems and hadron physics, providing a unified framework for diverse few-body applications. In this talk, I will give an overview of its main features, selected implementation aspects, and future development plans. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/LP7GLM/ Alte Mensa — Audi Max Lucas Happ PUBLISH VSZT9C@@pretalx.com -VSZT9C Implementing Lattice QCD to Multi-GPU Systems with JuliaQCD en en 20260812T151500 20260812T153000 001500 Implementing Lattice QCD to Multi-GPU Systems with JuliaQCD Background: Lattice Quantum Chromodynamics (LQCD), which stands as a foundational framework enabling first-principle non-perturbative study for the strong force in nature, is a grand challenge computational problem in high-energy physics. Due to the 4-dimensional nature of the spacetime grid, memory requirements grow with the lattice extent. Often, a single high-end GPU does not have enough VRAM to store the necessary gauge and fermion fields for physically relevant volumes. Therefore, multi-GPU parallelism in JuliaQCD is not only an optimization for speed but also a fundamental requirement for large-volume physics simulations. Technical Content: - Overcoming the Memory Wall: We discuss how JuliaQCD handles 4D lattice decomposition across multiple GPU nodes. This allows us to simulate larger volumes by pooling the memory of an entire cluster. - Performance Portability with JACC.jl: We highlight the use of JACC.jl to write kernels that are portable across NVIDIA, AMD, and other hardware. This ensures that JuliaQCD remains flexible as HPC centers transition to diverse GPU architectures. - Communication Overheads: We detail our implementation of halo (ghost zone) exchanges using MPI.jl. We explain how we minimize the latency penalties associated with moving data between GPUs to maintain efficiency as the number of nodes increases. The main goal of this talk is to demonstrate that the JuliaQCD suite provides a scalable, memory-efficient framework for modern lattice simulations. We aim to show that Julia is fully capable of handling the memory distribution of large-scale theoretical physics with multiple GPUs on various HPC architectures. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/VSZT9C/ Alte Mensa — Audi Max Ho Hsiao PUBLISH NDZHNQ@@pretalx.com -NDZHNQ JuliaQCD: A Pure Julia Framework for Lattice QCD and Its Extension with Compiler-Level Automatic Differentiation en en 20260812T153000 20260812T160000 003000 JuliaQCD: A Pure Julia Framework for Lattice QCD and Its Extension with Compiler-Level Automatic Differentiation PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/NDZHNQ/ Alte Mensa — Audi Max Yuki Nagai PUBLISH 9ARMTY@@pretalx.com -9ARMTY Multidimension raytracing with Julia en en 20260812T160000 20260812T161500 001500 Multidimension raytracing with Julia During my PhD I wrote MATLAB code to trace light rays around higher-dimensional black objects. The original implementation became difficult to extend and suffered from performance bottlenecks, which prevented me from exploring more complex geometries. In recent years I completely rebuilt the code in Julia, which not only removed long-standing numerical issues but also delivered large speedups and enabled us to image a wider range of higher-dimensional objects for the first time. I will show how the Julia ecosystem tremendously simplified the code. I will also highlight how the unique properties of the Julia language as a high level but also highly performant language allowed me to speed up the calculations by orders of magnitude. Rather than focusing on the underlying physics, this talk tells the computational story: how rewriting in Julia made it possible to make images of never before seen higher dimensional objects. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/9ARMTY/ Alte Mensa — Audi Max Tom Lemmens PUBLISH E7N39Z@@pretalx.com -E7N39Z Parameter optimization of domain-wall fermion based on machine-learning framework en en 20260812T161500 20260812T163000 001500 Parameter optimization of domain-wall fermion based on machine-learning framework PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/E7N39Z/ Alte Mensa — Audi Max Kenta Yoshimura PUBLISH UFKC3U@@pretalx.com -UFKC3U Testability-First Design for Few-Body Systems Physics en en 20260812T163000 20260812T170000 003000 Testability-First Design for Few-Body Systems Physics Few-body systems physics is an intersection of many subfields of physics and chemistry. Its targets are various few-body systems across various scales, from hadrons and nuclei to atoms, molecules, and quantum dots. Ideally, researchers would like to calculate physical observables for arbitrary particle numbers, arbitrary interactions, and arbitrary quantum states. In practice, no single software package can satisfy all of these requirements, and researchers often develop self-tailored codebases for their specific problems. To make this development culture scalable, we are building an open-source ecosystem as shared infrastructure that provides reusable building blocks and a flexible common interface in the Julia programming language. CI/CD with automated testing is a baseline requirement for maintainability and for accepting external contributions. Beyond its role in maintenance, testing also has a role in design, because the requirements for the system-level testability derive the architectural design. Differential testing based on cross-method comparisons has been used in [few-body calculations](https://doi.org/10.1103/PhysRevC.64.044001). For established benchmark problems, the final outputs can be validated using test oracles built from a database of results in the literature. However, for previously unexplored problems, there is no verified “correct answer”. This requirement motivates a common interface that allows multiple methods to operate on the same Hamiltonian. The Rayleigh–Ritz method using [explicitly correlated Gaussian (ECG)](https://doi.org/10.1103/RevModPhys.85.693) basis functions is widely used for solving the Schrödinger equation of quantum-mechanical few-body systems, while [variational Monte Carlo (VMC)]( https://doi.org/10.48550/arXiv.1508.02989 ) can calculate the energy for a given trial wave function. Currently, we are developing [FewBodyECG.jl](https://github.com/JuliaFewBody/FewBodyECG.jl) and [MetropolisAlgorithm.jl](https://github.com/JuliaFewBody/MetropolisAlgorithm.jl) (toward [FewBodyVMC.jl](https://github.com/JuliaFewBody/FewBodyVMC.jl)) for cross-checking multiple methods. [FewBodyHamiltonian.jl](https://github.com/JuliaFewBody/FewBodyHamiltonians.jl) supports flexible construction of Hamiltonians as a common input for multiple methods. [FewBodyDB.jl](https://github.com/JuliaFewBody/FewBodyDB.jl) works as a test oracle database, and [TwoBody.jl](https://github.com/JuliaFewBody/TwoBody.jl) works as a prototype of FewBody.jl, the common interface of this [JuliaFewBody](https://github.com/JuliaFewBody) ecosystem. While we don't necessarily practice test-first or test-driven development, we find testability to be a compass for our overall architectural design and long-term development roadmap. We hope this ecosystem will open the gate to a "trading port" of computational methods. PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/UFKC3U/ Alte Mensa — Audi Max Shuhei Ohno Martin Mikkelsen PUBLISH T9CVPT@@pretalx.com -T9CVPT VisualizingLQCD.jl: Visualization of quantum vacuum en en 20260812T170000 20260812T171500 001500 VisualizingLQCD.jl: Visualization of quantum vacuum Quantum chromodynamics (QCD) is the theory of the strong force that holds atomic nuclei together. It predicts that the "vacuum" is a fluctuating gluon field, so even empty space has structure, and those fluctuations shape protons and neutrons. Lattice QCD makes this computable by simulating QCD on a 4D grid and generating many snapshots of the gluon field, typically on supercomputers. Because the output is a large 4D dataset, visualization is a practical way to build intuition, compare runs, and explain results. Previous QCD outreach movies showed how compelling vacuum visualization can be, but they are fixed examples. When you develop algorithms or tune parameters, you want to visualize your own configurations from your own simulations. VisualizingQCD.jl, part of the JuliaQCD project, provides an open-source pipeline that reads ILDG configuration files, computes a 3D scalar field on each time slice, and renders iso-surfaces into MP4 videos with Makie. The workflow is plain Julia code, so it is reproducible and easy to extend. In this short talk I will demo the pipeline end to end, starting from an ILDG file and producing a movie in a few lines. Next I will explain what can be visualized, focusing on local observables such as plaquette-based activity (the smallest loop on the grid), action density after gradient flow (a standard smoothing procedure), a common probe of vacuum structure. I will close with performance notes and pointers for adding new observables within the JuliaQCD ecosystem. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/T9CVPT/ Alte Mensa — Audi Max Akio Tomiya PUBLISH MKW7DV@@pretalx.com -MKW7DV What's new in RayTraceHeatTransfer.jl since JuliaCon2024 en en 20260812T171500 20260812T173000 001500 What's new in RayTraceHeatTransfer.jl since JuliaCon2024 An early version of this package was presented at JuliaCon2024 Eindhoven. On the same day as the presentation in Eindhoven, the author invented a new method for solving general radiative transfer problems. This invention became the foundation which the new versions of the package builds upon. Since then, the package has evolved to adress most of the issues previously presented as future work. This talk will present the main new features: Applications to 1D, 2D and 3D, with parameter variation across both the spatial and wavelength dimensions of the domains. Furthermore, the talk will touch on some of the fundamental physics of radiation, to clarify the necessary inputs and the concepts of the package. The fundamental method which RayTraceHeatTransfer.jl is based on, is presented in the paper "A Radiation Exchange Factor Transformation with Proven Convergence, Non-Negativity, and Energy Conservation" (Bielefeld, 2025). In this paper, the method is proven to be mathematically and physically correct, under specified conditions. The paper is available at the arXiv preprint server, and more papers are under way, detailing currently unpublished features already available in the package. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/MKW7DV/ Alte Mensa — Audi Max Nikolaj Maack Bielefeld PUBLISH 7U7ERV@@pretalx.com -7U7ERV Reduction methods for Sum of Squares Programming applied to Quantum Control problems en en 20260812T100000 20260812T101500 001500 Reduction methods for Sum of Squares Programming applied to Quantum Control problems Many quantum control problems are posed as polynomial optimization problems. Sum of Squares programming is effective at utilizing symmetric self-dual solvers due to such solvers exhibiting polynomial-time convergence and achieving solutions to high precision. Despite this solving Semidefinite programs and moreover Sum of Squares programs remain challenging. First is the computational blowup in memory and runtime cost as the problem size increases, second is the ill conditioning of solving polynomial optimization problems using the monomial basis, third is the numerical struggle that solvers must deal with. Sum of squares programming is widely used in control (Lyapunov stability), robotics (trajectory optimization) and the validation and verification of safety critical systems. Global convergence and solution quality are becoming increasingly relevant in quantum control and quantum information sciences. Scaling quantum systems without compromising solution quality remains an ongoing challenge. This motivates the question; how can we adapt existing well established algebraic and computational tools in the quantum realm. In this talk we’ll focus on the fixed-time control problem of finding the control that achieves as close as possible a given target unitary at the end of a given evolution time. The QCPOP method popularized by Bondar et al., 2025 uses TSSOS.jl for solving the sum of squares programming problem. We take a different approach by proposing a computational pipeline based on the ideas discussed in Permenter, 2017 to apply face reduction on top of symmetry reduction as a preprocessing step before solving the SOS problem. This is attractive for several theoretical/practical reasons, it exploits problem structure without relaxing the original problem, these mathematical methods can act as additional layers to extend existing solvers, packages such as SymbolicWedderburn.jl (which we use) already exists for exploiting algebraic structure. An ongoing challenge with adopting these tools is a robust solver architecture. We’ll show the changes in ConicSolve.jl made to further reduce degeneracy and numerical ill-conditioning, particularly the use of matrix decompositions, equilibration and regularization methods. We hope this talk stimulates discussion and interest in further advancing Julia’s ecosystem to realize and explore new algebraic and computational methods. It is without many Julia packages like OperatorScaling.jl and SymbolicWedderburn.jl that this talk and exploration of these ideas would remain just that, a theoretical ideal. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/7U7ERV/ Alte Mensa — Atrium Maximum Alexander Leong PUBLISH XMMZE7@@pretalx.com -XMMZE7 Giac.jl: Bringing the Giac Computer Algebra System to Julia, from FFI Bindings to Interactive Pluto Notebooks en en 20260812T101500 20260812T103000 001500 Giac.jl: Bringing the Giac Computer Algebra System to Julia, from FFI Bindings to Interactive Pluto Notebooks Giac is a mature, open-source C++ computer algebra system developed by Bernard Parisse at Universite Grenoble Alpes. It powers the CAS engine in Xcas, GeoGebra and HP Prime calculators, and provides capabilities in symbolic algebra, calculus, polynomial arithmetic, Groebner bases, and more. Previous Julia interfaces to Giac exist (by Harald Hofstaetter and by Bernard Parisse himself), but they have seen limited maintenance and do not integrate well with the broader Julia ecosystem (notably notebooks and math interchange formats). **[Giac.jl](https://github.com/s-celles/Giac.jl)** is the core package of this work. It's trying to bring the full power of GIAC to Julia, offering a high-level, Julian API for symbolic computation. Under the hood, **[libgiac-julia-wrapper](https://github.com/s-celles/libgiac-julia-wrapper)** provides the low-level FFI bindings to the giac C++ library, handling memory management and type conversions between C++ and Julia. Around this core, I have developed companion packages that extend Giac.jl into the interactive notebook world: - _[MathJSON.jl](https://github.com/s-celles/MathJSON.jl)_ -- Parse, manipulate, and serialize MathJSON expressions in Julia. MathJSON is a lightweight JSON-based interchange format for mathematical expressions created by the CortexJS project. MathJSON.jl converts between the MathJSON tree format (e.g. `["Add", ["Power", "x", 2], 1]`) and Julia symbolic types. - _[PlutoMathInput.jl](https://github.com/s-celles/PlutoMathInput.jl)_ -- A Pluto notebook widget embedding a MathLive MathField (from Arno Gourdol), a WYSIWYG math editor. Using Pluto's `@bind` macro, users type expressions in a visual editor (rendered math, not raw LaTeX) that are converted to MathJSON and bound to a Julia variable reactively. - _[MathJSONComputeEngineBridge.jl](https://github.com/s-celles/MathJSONComputeEngineBridge.jl)_ -- The glue layer that connects the MathJSON representation to Giac.jl, coordinating the flow from visual input through parsing to symbolic evaluation and back. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/XMMZE7/ Alte Mensa — Atrium Maximum Sébastien Celles PUBLISH YJVVDR@@pretalx.com -YJVVDR Certified homotopy and monodromy computation in Julia en en 20260812T103000 20260812T104500 001500 Certified homotopy and monodromy computation in Julia Homotopy path tracking is widely used to solve systems of nonlinear equations in scientific computing and applied mathematics. The basic idea is to start from a system whose solutions are already known and continuously deform it into the system of interest, while tracking each solution along the deformation. This process defines smooth solution paths that connect the known solutions to the target solutions. In practice, solution paths are tracked using floating-point approximations step by step from the initial system to the target system. This approach may cause a jump to another solution path, resulting in an incorrect solution. Because detecting path jumping is generally hard, certifying only the final approximation in this case is insufficient. Certified homotopy tracking not only tracks the path but also proves that the entire path is uniquely contained within a rigorously validated compact region. It guarantees that the computed endpoint corresponds to the intended solution path. CertifiedHomotopyTracking.jl implements certified homotopy tracking using interval arithmetic to construct a rigorous compact region that uniquely contains a solution path. Systems of equations are defined using Symbolics.jl and compiled via straight-line programs, and interval arithmetic is handled through Nemo.jl. As a key feature, the package supports the certified computation of monodromy groups for parametrized systems. Such systems frequently arise in applied mathematics, particularly in data-driven problems. When one tracks a loop in parameter space, the system's solutions are permuted, thereby inducing correspondences among them. To prove these correspondences, certified tracking along the entire loop is essential. The package employs a homotopy graph approach to compute the resulting monodromy group, and automates group-theoretic analysis through GAP.jl. The talk consists of a brief review of backgrounds, an overview of the certified tracking algorithms, and a software demonstration. We emphasize how the package interoperates with other nonlinear algebra packages in Julia, such as HomotopyContinuation.jl and Pandora.jl, enabling users to invoke certified computation within existing workflows whenever rigorous guarantees are required. The value of the package lies in its integration and application of multiple Julia packages for nonlinear algebra. We expect the package to provide a unified framework that broadens the practical use of certified numerical methods. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/YJVVDR/ Alte Mensa — Atrium Maximum Kisun Lee PUBLISH S7ANGA@@pretalx.com -S7ANGA Serialization of Algebraic Data en en 20260812T104500 20260812T110000 001500 Serialization of Algebraic Data PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/S7ANGA/ Alte Mensa — Atrium Maximum Antony Della Vecchia PUBLISH ZPMNJZ@@pretalx.com -ZPMNJZ The OSCAR Computer Algebra System en en 20260812T111500 20260812T114500 003000 The OSCAR Computer Algebra System PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/ZPMNJZ/ Alte Mensa — Atrium Maximum Lars Göttgens PUBLISH NWDQSQ@@pretalx.com -NWDQSQ Graphical Modeling with Symbolic Algebra in OSCAR.jl en en 20260812T114500 20260812T120000 001500 Graphical Modeling with Symbolic Algebra in OSCAR.jl Graphical models represent dependencies between variables through graphs and are widely used in causal inference and statistics. In linear structural equation models, the implied covariance relations define polynomial equations, making these models naturally accessible to methods from algebraic statistics. In this talk, we present a [Julia workflow]([url](https://st-mardi.quarto.pub/gmci/chapters/notebook_gallery/notebooks/OscarID/notebook.html)) based on the computer algebra system [OSCAR]([url](https://docs.oscar-system.org/stable/)) to study parameter identifiability and causal effects in graphical models. Existing theory such as the [half-trek criterion]([url](https://doi.org/10.1214/12-AOS1012)) provides sufficient but not necessary conditions for identifiability. Using symbolic computation and Groebner basis methods, we can analyze specific models directly and determine whether parameters are generically identifiable. Building on recent implementations in [OSCAR]([url](https://docs.oscar-system.org/stable/Experimental/AlgebraicStatistics/introduction/)), we demonstrate how graphical models can be translated into polynomial systems, how elimination ideals can be computed, and how resulting identification formulas can be derived automatically. This allows us to resolve cases that classical criteria leave undetermined. The workflow is illustrated on a real data example and highlights how OSCAR.jl enables reproducible and extensible algebraic-statistical analysis for causal graphical models. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/NWDQSQ/ Alte Mensa — Atrium Maximum Leopold Mareis PUBLISH XKMGRR@@pretalx.com -XKMGRR Modeling algebraic curves with Oscar.jl en en 20260812T120000 20260812T121500 001500 Modeling algebraic curves with Oscar.jl Algebraic geometry is a mathematical field that is notoriously hard for computers, since its constructions often require exact computations. The price for this exactness requirement is often paid in performance degradation. Plane algebraic curves arise as the zero set of polynomials in two variables. Every such curve subdivides the plane into a certain number of regions. An M-curve is a plane algebraic curve that maximizes this number of regions. The 1987 article by Shustin contains an algebro-geometric description of how to assemble such an M-curve, but no actual polynomial. We want to translate this article into Julia code and encounter a multitude of obstacles: - The end result is a smooth curve, meaning that it has no singularities, i.e. there are no points in the zero set where partial derivatives vanish simultaneously. Such a curve is robust with respect to small errors in the coefficients. However the intermediate curves have singularities which are highly sensitive against such perturbations and require exact computations. - How can we verify that the end result is indeed a M-curve? - In Oscar.jl there are many different number types we can use for the coefficients. We can even switch to fields much larger than the rational numbers. However, computation in these fields is much slower than in the rationals. Is there a way to force certain polynomial systems to have rational solutions? - Since many of our computations are expensive, is there a way to store intermediate results? - Can we visualize our intermediate curves and the end result? What different visual models are there? PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/XKMGRR/ Alte Mensa — Atrium Maximum Lars Kastner PUBLISH 7CGFWE@@pretalx.com -7CGFWE Solving parametric LMIs via real root classification: A Julia approach to automated convergence analysis en en 20260812T121500 20260812T123000 001500 Solving parametric LMIs via real root classification: A Julia approach to automated convergence analysis PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/7CGFWE/ Alte Mensa — Atrium Maximum Weijia Wang PUBLISH SMBUHF@@pretalx.com -SMBUHF Using monodromy and representation theory to recover symmetries of polynomial systems en en 20260812T123000 20260812T130000 003000 Using monodromy and representation theory to recover symmetries of polynomial systems PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/SMBUHF/ Alte Mensa — Atrium Maximum Viktor Korotynskiy PUBLISH YX8CHD@@pretalx.com -YX8CHD An Offer you can't refuse: Corleone.jl - Flexible direct multiple shooting for optimal control and experimental design in Julia en en 20260812T143000 20260812T144500 001500 An Offer you can't refuse: Corleone.jl - Flexible direct multiple shooting for optimal control and experimental design in Julia At its core, Corleone is a package for direct shooting methods in Julia. Its main area of application is a) optimal control, b) parameter estimation, and c) optimal experimental design for dynamic processes. As opposed to similar packages, e.g. OptimalControl.jl, the ModelingToolkit Extensions, or the recently announced BoundaryValueDiffEq.jl, Corleone.jl models everything as a Lux Layer, as such offering natural support for scientific machine learning, which is used to build an Optimization.jl problem. As such, it offers full support for all ODE and DAE integrators and all sensitivity algorithms of SciML next to the flexible choice of optimization algorithms. Additionally, the block structure resulting from multiple shooting can be directly used by specialized algorithms, e.g. BlockSQP.jl. Next to these core functionalities, we also offer optimal experimental design as its own sublibrary CorleoneOED.jl. Here the focus lies on augmenting the system with its symbolically derived sensitivity equations and methods to calculate the Fisher information matrix. Through the talk we are planning to present: 1) A brief introduction into the topic of dynamic optimization, especially the aspect of multiple shooting. 2) Relate the structure of piecewise constant approximations in optimal control, multiple shooting (and possibly later on multi stage) problems to the computational graph of Corleone and hence to Lux.jl. 3) Show the API on a simple example (Lotka-Volterra Fishing) 4) Explain how optimal experimental design is an optimal control problem [1] 5) Showcase some recent work on OED with an industrial partner from the chemical process industry (as far as we are allowed to do :) ) 6) Showcase recent academic studies on how Corleone can be used in OED settings (see e.g. [2,3]) 7) Talk about the roadmap and planned directions of this package [1] C. J. Martensen, C. Plate, and S. Sager, “DynamicOED.jl: A Julia package for solving optimum experimental design problems,” JOSS, vol. 9, no. 98, p. 6605, Jun. 2024, doi: 10.21105/joss.06605. [2] C. Plate, C. J. Martensen, and S. Sager, “Optimal Experimental Design for Universal Differential Equations,” IEEE Trans. Automat. Contr., pp. 1–16, 2025, doi: 10.1109/TAC.2025.3609533. [3] L. Kaps et al., “Optimal Experiments for Hybrid Modeling of Methanol Synthesis Kinetics,” Feb. 07, 2025, Chemistry and Materials Science. doi: 10.20944/preprints202502.0422.v1. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/YX8CHD/ Alte Mensa — Atrium Maximum Carl Julius Martensen PUBLISH AHVQ3V@@pretalx.com -AHVQ3V Cross-Country Macroeconomic Forecasting Using Physics-Informed Neural Networks and Universal Differential Equations in Julia en en 20260812T144500 20260812T150000 001500 Cross-Country Macroeconomic Forecasting Using Physics-Informed Neural Networks and Universal Differential Equations in Julia This project investigates whether continuous-time scientific machine learning methods can better represent such evolving economic systems. Building on the idea of long-term debt cycles, the study moves beyond a single country setting to compare India, Sri Lanka, and Argentina. Three economies with distinct fiscal histories and crisis trajectories. By analyzing multiple countries, the research expands its horizon from local model fitting to cross-country structural comparison. The central question is not about which model predicts better, but how embedding economic structure into learning systems affects stability, interpretability, and long-term trajectory reconstruction. The methodology is based on Physics-Informed Neural Networks (PINNs) and Universal Differential Equations (UDEs). Unlike purely data-driven neural models, these approaches integrate differential equation structures and domain constraints directly into the learning process. This allows the model to respect economic relationships such as debt-growth feedback and dynamic fiscal adjustments while still learning unknown components from data. The implementation is carried out in Julia, leveraging its high-performance scientific computing ecosystem. In particular, the project utilizes the DifferentialEquations.jl suite for numerical ODE solving, DiffEqFlux.jl and SciMLSensitivity.jl for neural differential equation training and adjoint-based gradient computation, and NeuralPDE.jl for physics-informed learning. Optimization is handled using Optimization.jl with ADAM and second-order solvers, while data processing and evaluation rely on DataFrames.jl and Statistics. Julia’s amazing SciML framework enables tight coupling between symbolic differential equations and neural networks, allowing us to experiment with both structural constraints and hybrid modeling. Using annual macroeconomic indicators, the study evaluates how well these hybrid systems reconstruct historical trajectories under sparse sampling conditions. By comparing performance across three countries, the research explores how structural constraints influence validity, error accumulation, and generalization. Ultimately, this project aims to bridge macroeconomic modeling and scientific machine learning, advancing a more disciplined and interpretable approach to modeling national economic dynamics. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/AHVQ3V/ Alte Mensa — Atrium Maximum Vrishank Sai Anand PUBLISH HMSN8Q@@pretalx.com -HMSN8Q DecisionSystems.jl: Closing the Loop Between Physics and Decisions en en 20260812T150000 20260812T151500 001500 DecisionSystems.jl: Closing the Loop Between Physics and Decisions A vehicle braking system. A drug dosing schedule. A spacecraft attitude controller. What these share is a fundamental loop: physics evolves continuously, an agent decides discretely, and those decisions reshape the physics. DecisionSystems.jl provides an optimized API to design experiments to define these dynamics in Dyad (ModelingToolkit) and add decision parameters to iteratively update actions based on MDP, POMDP and RL environments. The library handles: state extraction, integrator stepping, action application, and belief tracking under uncertainty. Using examples, the talk walks through the core idea, its generalizations, and what it unlocks for hybrid physical-decision systems in Julia, covering both current features and what's planned. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/HMSN8Q/ Alte Mensa — Atrium Maximum Venkatesh-Prasad Bhat PUBLISH EYUQVV@@pretalx.com -EYUQVV Different Automatic Differentiation algorithms from `SciMLSensitivity.jl`, and when to use them. en en 20260812T151500 20260812T153000 001500 Different Automatic Differentiation algorithms from `SciMLSensitivity.jl`, and when to use them. The idea for this talk arose after implementing the Gauss–Kronrod adjoint. While there are many introductory talks on automatic differentiation (AD), there are few/none that focus on the practical differences between specific methods. Therefore, this talk is not intended as an introduction to AD. Instead, it will explore when and why to use forward- or reverse-mode AD, as well as when and why to choose different adjoint sensitivity algorithms. The topic contains enough material for a 30-minute talk. However, I believe focusing on the core insights would be more engaging and a better use of the audience’s time, making a 15-minute format ideal. Those interested in further details can follow Chris Rackauckas’s lecture [2], read the SciMLSensitivity documentation, or reach out to me after the talk. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/EYUQVV/ Alte Mensa — Atrium Maximum Marko Polic PUBLISH DG33PK@@pretalx.com -DG33PK Discovering Governing Equations for Neural Populations: PEM-UDE with Multiple Shooting for Chaotic Brain Dynamics en en 20260812T154500 20260812T160000 001500 Discovering Governing Equations for Neural Populations: PEM-UDE with Multiple Shooting for Chaotic Brain Dynamics Understanding how neural populations generate brain rhythms requires equations that bridge the biophysics of individual neurons with macroscopic network dynamics. Next-generation neural mass models (NGNMMs) achieve this analytically but rely on the assumption of all-to-all connectivity between neurons, a condition that holds only in deep brain structures like the hippocampus but fails badly in the cortex, where connectivity is typically 1-5%. Removing this assumption analytically has proven contentious, with competing approaches yielding inconsistent results. We sidestep the analytical difficulty entirely by learning the governing equations directly from data using scientific machine learning. Our PEM-UDE approach combines the prediction-error method with universal differential equations to discover equations from chaotic neural time series. The key insight is that the PEM correction removes the sensitive dependence on parameters that makes chaotic systems intractable for standard UDE training. This effectively smooths the loss landscape while preserving the correct solution. After training, we extract symbolic equations via sparse regression (STLSQ) or genetic algorithm methods. We already demonstrated PEM-UDE on benchmark chaotic systems (Roessler attractor, Petrzela-Polak circuit with 5x noise), and applied it to learn novel NGNMMs from populations of Izhikevich neurons with connectivity ranging from 5% to 100% (arXiv:2507.03631). The learned equations include correction terms that capture how sparsity modifies firing rate and voltage dynamics. Here, we extend the original method by combining PEM with multiple shooting (arXiv:2602.21588) to handle longer time series, regime transitions, and mixed excitatory-inhibitory populations with varying neuron parameters. We will present and discuss how neural network architecture, prediction error, and multiple-shooting parameters affect training performance (speed and accuracy). Our longer-term goal is to develop an automated tool chain for fitting data to UDEs. Finally, we will present progress on analytically flattening a more complex neural circuit (Nature Communications 17(390)2026) using UDEs. This work is motivated by the inability of large-scale neuron simulations to be used for parameter fitting of experimental data. By reducing the dimensionality of the system (going from 10,000s to 10s of states), we should be able to parameter-fit our models to individual patients. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/DG33PK/ Alte Mensa — Atrium Maximum Helmut Strey Chris Rackauckas Anthony Chesebro PUBLISH 3H7S3S@@pretalx.com -3H7S3S Efficient SciML BVP solvers: From differential equations to dynamic optimizations en en 20260812T160000 20260812T161500 001500 Efficient SciML BVP solvers: From differential equations to dynamic optimizations This talk provides an in-depth overview of recent methodological and software advances in efficient boundary value problem solving within the SciML ecosystem. Boundary value problems arise naturally across scientific computing, optimal control, inverse problems, and dynamical system analysis, yet their efficient numerical treatment remains challenging due to strong global coupling, nonlinear constraints, and large-scale discretizations. We focus on recent developments in BoundaryValueDiffEq.jl, emphasizing how modern collocation-based formulations can be systematically extended using the composable abstractions provided by SciML. A central theme of the talk is the reinterpretation of BVPs as structured nonlinear optimization problems. Instead of viewing collocation methods purely as discretizations of differential equations, we demonstrate how they naturally induce sparse and highly structured nonlinear programming formulations. This perspective enables direct interoperability with SciML’s differentiable programming infrastructure, allowing automatic differentiation, sensitivity analysis, and gradient-based optimization methods to be applied seamlessly. By leveraging tools such as ModelingToolkit.jl and Optimization.jl, BVP solvers become an important component in differentiable computational pipelines. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/3H7S3S/ Alte Mensa — Atrium Maximum Qingyu Qu PUBLISH YQXSKZ@@pretalx.com -YQXSKZ Optimizing race car track times in Dyad en en 20260812T161500 20260812T163000 001500 Optimizing race car track times in Dyad The support for optimal control problems in the SciML ecosystem has been expanding recently, with new additions for both external solvers like InfiniteOpt or CasADi and also the more recently added support for BoundaryValueDiffEq in ModelingToolkit. The new `BVPProblem` interface is allows users to specify constraints and cost functions symbolically, which are then internally used for the formulation of the problem in terms of generalized boundary value problems. Moreover, the parameters of the system can also be tuned while solving, by appending the tunable parameters to the mesh points that we are solving for, allowing us to find both the required trajectory and the optimal parameters at the same time. One of the advantages of using the generalized boundary problem solvers over usual collocation methods is that we can use an adaptive mesh instead of a discretization that uses a fixed time step. The boundary value problem is formulated internally using an optimization problem when tuning parameters. The BVP solvers expose an Optimization.jl compatible interface, where we can use solvers such as Ipopt (via OptimizationIpopt) or MadNLP (via OptimizationMadNLP). The OptimizationMadNLP package is also a more recent addition to the Optimziation ecosystem, exposing an advanced and high performance constrained optimization solver in pure julia. All of this describes the full julia stack that powers DyadModelOptimizer and we will show how this performs on a concrete problem by targeting the optimization of the race car track times. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/YQXSKZ/ Alte Mensa — Atrium Maximum Sebastian Micluța-Câmpeanu Rajeev Voleti PUBLISH UHMHQX@@pretalx.com -UHMHQX Scientific Machine Learning for Geophysical Modelling, Inversion and Uncertainty Quantification en en 20260812T164500 20260812T170000 001500 Scientific Machine Learning for Geophysical Modelling, Inversion and Uncertainty Quantification The first direction concerns neural networks trained as surrogates for geophysical forward problems. I will present a workflow in which a DeepONet is trained to emulate one-dimensional magnetotelluric responses and is then used within a transdimensional probabilistic inversion scheme. By replacing repeated evaluations of the full forward solver with a learned surrogate, the method makes large-scale posterior exploration and uncertainty analysis substantially more practical. The example shows how surrogate modelling can reduce computational cost while preserving the level of accuracy needed for probabilistic inversion. The second direction concerns the use of neural networks as the inversion model itself. In this setting, the subsurface is represented as an implicit neural field constrained by the governing physics rather than by a fixed voxel parameterisation. I will illustrate this with three-dimensional gravity inversion, where implicit neural representations recover both smooth variations and sharp contrasts while reducing the reliance on explicit depth weighting. The gravity examples show that neural-field parameterisations can produce geologically plausible models while remaining compact and flexible. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/UHMHQX/ Alte Mensa — Atrium Maximum Pankaj K Mishra PUBLISH 3GYGWQ@@pretalx.com -3GYGWQ Type-stable Symbolic Computation en en 20260812T170000 20260812T171500 001500 Type-stable Symbolic Computation There are various different approaches taken to represent programs. Data representations can vary from SSA-IR to expression-trees. Some tools may choose to specialize on very specific types of expressions - polynomial algebra, or real numbers. In contrast, SymbolicUtils.jl (the core of the Symbolics.jl CAS) aims to be a framework for representing arbitrary symbolic expressions in arbitrary algebras, where different parts of the expression can have different types. It even allows (in fact, requires) the ability to represent different types of expressions in different ways. For example, the expressions for associative-commutative `+` and `*` uses a completely different representation than the standard tree-based approach. So how is all this made possible, while retaining type-stability and precompiling common workflows? The answer lies in the recent SymbolicUtils version 4 release. Older versions had significant historical baggage, and were victims of the tooling available when they were written. Since then, the language and package ecosystem have grown in leaps and bounds. The new release rewrote most of the core package to use modern alternatives to many core packages, with an emphasis on benchmarking and performance. This talk walks through the design of SymbolicUtils today, contrasting it with older versions and illustrating how we solved the innumerable problems along the way. In doing so, it also highlights the idiosyncrasies of the language, the various useful tooling for debugging type-stability and precompilation, and pain-points that make such investigation difficult. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/3GYGWQ/ Alte Mensa — Atrium Maximum Aayush Sabharwal PUBLISH AHGR7C@@pretalx.com -AHGR7C What is the best ODE solver for your problem? A detailed walk through DifferentialEquations.jl en en 20260812T171500 20260812T173000 001500 What is the best ODE solver for your problem? A detailed walk through DifferentialEquations.jl For most people, you use the default solver solve(prob), and in most cases, this is pretty good. But in some cases, you may choose a solver. Some choices are generic: Tsit5(), FBDF(), etc. that tend to just do well in general. But then it can get detailed: * You know about stiff and non-stiff equations, but what about semi-stiffness where your eigenvalues are dominated by real parts? Try to ROCK methods. * What about stiff equations of 3-200 equations on multicore devices? Try the implicit extrapolation methods. * What about non-stiff equations which are smooth and able to be symbolically analyzed? Try the adaptive Taylor methods * What about highly stiff equations which are real valued and require very high precision? Try the adaptive Radau methods. Etc. etc. This will walk through the space with benchmarks, a high level intuition behind the method, and give an idea of how much these optimizations may give over using the generic methods. By the end you should feel more comfortable going into the details of the DifferentialEquations.jl library to further optimize the choices for your specific code. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/AHGR7C/ Alte Mensa — Atrium Maximum Chris Rackauckas PUBLISH PEZTQJ@@pretalx.com -PEZTQJ Sponsor Talk from Aeolus Labs en en 20260813T083000 20260813T084500 001500 Sponsor Talk from Aeolus Labs Aeolus Labs is a San Francisco-based weather intelligence startup and a Platinum Sponsor of JuliaCon Global 2026. PUBLIC CONFIRMED Platinum Sponsor Talk https://pretalx.com/juliacon-2026/talk/PEZTQJ/ Tent — RW1 PUBLISH YRYY9T@@pretalx.com -YRYY9T Julia For Quantum Software: Lessons from PauliPropagation.jl en en 20260813T084500 20260813T094500 010000 Julia For Quantum Software: Lessons from PauliPropagation.jl Quantum computing progress depends as much on software as on hardware. In this keynote, we’ll start with a practical view of how high-quality code supports the development and use of quantum devices—through simulation, compilation, verification, benchmarking, and control. We'll also stress the value of state of the art classical methods to delineate where a quantum computer is genuinely required, versus where well-designed classical software is the right (and often faster) choice. We will then zoom in on PauliPropagation.jl, a Julia package we have been developing for efficiently simulating quantum circuits. We will outline the core abstractions and implementation details in the package, and what problems it is meant to make easy. A central thread will be "why Julia". Beyond performance, Julia lets us offer a fully extensible package with custom gates, data structures, and evolving types. We’ll end with an honest account of building Julia tools as a scientist: what has worked well, what has been surprisingly hard, and what we have learned about presenting research software to a community that often defaults to Python expectations. PUBLIC CONFIRMED Keynote https://pretalx.com/juliacon-2026/talk/YRYY9T/ Tent — RW1 Zoë Holmes Manuel Rudolph PUBLISH BZEYUC@@pretalx.com -BZEYUC What's new in the Julia extension for VS Code en en 20260813T100000 20260813T103000 003000 What's new in the Julia extension for VS Code PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/BZEYUC/ Tent — RW1 Sebastian Pfitzner PUBLISH U39FKW@@pretalx.com -U39FKW JuliaLowering.jl: Provenance, automatic hygiene, and tooling en en 20260813T103000 20260813T110000 003000 JuliaLowering.jl: Provenance, automatic hygiene, and tooling JuliaLowering is an ongoing rewrite of macro expansion and lowering, the first few passes of the compiler that run immediately after parsing. Roughly, lowering analyzes and simplifies the symbolic structure of the code without referring to type information or global state. The JuliaCon 2024 talk, "Dude, where's my code?", provided motivation and sketched a plan for rewriting the Julia compiler frontend, along with demonstrating some early progress. This talk follows by discussing the outcomes of that work. Covered topics will include technical details of the new lowering implementation, project status, lessons learned, and all the current or planned tooling improvements that make such a nontrivial rewrite worth doing. PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/U39FKW/ Tent — RW1 Claire Foster Em Chu PUBLISH LJVPDR@@pretalx.com -LJVPDR Visualizing Uncertainty in EEG Topoplots: New Approaches in UnfoldMakie en en 20260813T111500 20260813T113000 001500 Visualizing Uncertainty in EEG Topoplots: New Approaches in UnfoldMakie PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/LJVPDR/ Tent — RW1 Vladimir Mikheev PUBLISH QLXWSB@@pretalx.com -QLXWSB Julia for VS Code: JETLS and beyond en en 20260813T113000 20260813T120000 003000 Julia for VS Code: JETLS and beyond This joint talk by Sebastian Pfitzner and Shuhei Kadowaki presents two major additions to the Julia VS Code experience. Sebastian covers recent improvements to the [julia-vscode extension](https://www.julia-vscode.org/), including automatic Julia installation for new user onboarding, and introduces how JETLS integrates into the extension architecture. Shuhei then presents [JETLS](https://github.com/aviatesk/JETLS.jl), a new language server built on [JET.jl](https://github.com/aviatesk/JET.jl)'s abstract interpretation based code analysis and [JuliaLowering.jl](https://github.com/JuliaLang/julia/tree/master/JuliaLowering)'s code lowering with source provenance tracking. JuliaLowering.jl performs macro expansion and lowering while preserving the mapping between source locations and lowered code, which enables JETLS to provide accurate go-to-definition, references, and rename that work correctly through macro expansions. Combined with JET.jl's type inference, this gives JETLS the level of code intelligence developers expect from modern language servers like [rust-analyzer](https://github.com/rust-lang/rust-analyzer) -- such as type on hover and inlay type hints -- unlike the existing [LanguageServer.jl](https://github.com/julia-vscode/LanguageServer.jl). We conclude with a live demo comparing JETLS and the existing language server on real-world Julia code. Time permitting, we also demonstrate JETLS's CLI, which exposes the same type-aware diagnostics outside the language server protocol, enabling CI pipelines and AI coding agents to leverage JETLS's analysis directly. PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/QLXWSB/ Tent — RW1 Shuhei Kadowaki Sebastian Pfitzner PUBLISH TNVVU8@@pretalx.com -TNVVU8 SmallCollections.jl: variable-length collections that don't allocate en en 20260813T120000 20260813T123000 003000 SmallCollections.jl: variable-length collections that don't allocate Many users are familiar with the package [StaticArrays.jl](https://github.com/JuliaArrays/StaticArrays.jl). It defines fixed-size arrays which in their immutable version don't allocate memory. [SmallCollections.jl](https://github.com/matthias314/SmallCollections.jl) provides vectors, sets and dictionaries with the same behavior, but whose length is variable up to some user-defined limit. The limit should be small enough for the data to fit into one or a few processor registers. Operations from `Base` have dedicated fast methods for the new types; this includes vector indexing and checked arithmetic. In this talk I will give an overview of the various types defined in the package and how to use them efficiently: - `SmallVector` and `MutableSmallVector` with variable length, - `FixedVector` and `MutableFixedVector` with fixed length (like `SVector` and `MVector`), - `PackedVector` with fewer than 8 bits per element, - `SmallBitSet` for sets based on bitmasks, - `SmallDict` and `SmallSet` plus their mutable versions. As an example application I will briefly discuss the package [SmallCombinatorics.jl](https://github.com/matthias314/SmallCombinatorics.jl), which is based on SmallCollections.jl. Compared to [Combinatorics.jl](https://github.com/JuliaMath/Combinatorics.jl), the functions in SmallCombinatorics.jl are often 1-3 orders of magnitude faster. PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/TNVVU8/ Tent — RW1 Matthias Franz PUBLISH 9WAZ7B@@pretalx.com -9WAZ7B Thermal-Fluid Modeling in Dyad en en 20260813T123000 20260813T130000 003000 Thermal-Fluid Modeling in Dyad We introduce Dyad as a feature-rich language for fluid system modeling that simplifies specification of distinct fluid circuits, enables hierarchical media and physical property modeling, and allows for combining declarative and imperative semantics. Next, we discuss approaches for translating existing fluid libraries. We present an experimental transpiler that allows automatic source-to-source conversion of Modelica models to Dyad. We present FluidComponents (a generic library for 1D thermal-fluid flow) and HVACComponents (a specialized high-performance library for refrigeration systems). We show the numerical techniques necessary to solve the challenges of modeling two-phase, compressible, viscous, turbulent flows with heat transfer. Lastly, we demonstrate industrial applications such as vapor compression cycles for refrigeration and battery chiller models in electric vehicles. PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/9WAZ7B/ Tent — RW1 Avinash Subramanian PUBLISH 7GNWCD@@pretalx.com -7GNWCD DynamicalSystems.jl in 2026: Successes and New Components en en 20260813T143000 20260813T150000 003000 DynamicalSystems.jl in 2026: Successes and New Components PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/7GNWCD/ Tent — RW1 George Datseris PUBLISH RUJHNQ@@pretalx.com -RUJHNQ CriticalTransitions.jl: A toolbox for noise- and rate-induced transitions in forced dynamical systems en en 20260813T150000 20260813T153000 003000 CriticalTransitions.jl: A toolbox for noise- and rate-induced transitions in forced dynamical systems Metastability and tipping phenomena are important features of nonlinear dynamical systems in the natural and human world. [CriticalTransitions.jl](https://github.com/JuliaDynamics/CriticalTransitions.jl) provides tools in a familiar user interface that allow to study such behavior. We discuss the structure, functionality and intuitive interface of the package, closely following the way dynamical systems theory would be written in textbooks. The code builds on, and naturally integrates with, the well-established packages DynamicalSystems.jl and DifferentialEquations.jl, ensuring proven long-term reliability and compatibility. By means of two example systems, we demonstrate the basic usage of CriticalTransitions.jl: 1. Noise-induced transitions - Set up a ‘CoupledSDEs’ (a system of stochastic differential equations) - Compute its minimum-action path (“instanton”) between two attractors - Efficiently sample ensembles of noise-induced transition paths; 2. Rate-induced transitions - Set up a ‘RateSystem’ by applying a time-dependent parametric forcing to a given system - Sample rate-induced transitions and calculate critical rates - Visualize the morphing stability landscape as a function of the forcing. PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/RUJHNQ/ Tent — RW1 Reyk Börner PUBLISH 78GRUZ@@pretalx.com -78GRUZ Automated Algorithm Analysis in Julia with AlgorithmAnalysis.jl en en 20260813T153000 20260813T154500 001500 Automated Algorithm Analysis in Julia with AlgorithmAnalysis.jl Algorithms are numerical recipes to solve problems. In some applications, such as large-scale or safety-critical scenarios, it is imperative that algorithms have both rigorous convergence guarantees and strong performance on practical problems of interest. The conventional approach to analyzing algorithm performance relies on deep insights by experts in the field along with tedious and error-prone calculations. Recent work from both the optimization and controls communities, however, has established a systematic methodology to analyze the worst-case performance of an algorithm over a broad class of problems. The systematic analysis methodology has been applied to various types of algorithms, from first-order accelerated methods to stochastic algorithms and operator splitting methods. Beyond analysis, the systematic methodology has also been used to *design* novel algorithms. This talk introduces `AlgorithmAnalysis.jl`, a Julia package that implements the automated approach to algorithm analysis. The talk will cover the basic use cases and structure of the package, including: - Modeling black-box algorithms using a high-level domain-specific language. - An overview of the analysis frameworks implemented: - The performance estimation problem (PEP) finds the worst-case performance of a black-box algorithm over a given finite number of iterations. - The control methodology interprets the algorithm as a dynamical system and searches for a Lyapunov function whose existence certifies convergence with a particular rate. - Results of the analysis applied to various first-order methods in optimization. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/78GRUZ/ Tent — RW1 Bryan Van Scoy Sam Skinner PUBLISH UCKDNF@@pretalx.com -UCKDNF Chaos and noise in evolutionary game dynamics en en 20260813T154500 20260813T160000 001500 Chaos and noise in evolutionary game dynamics PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/UCKDNF/ Tent — RW1 Alejandra Ramirez PUBLISH HXY7PF@@pretalx.com -HXY7PF Hydrodynamics of composable active structures with MicroSwimmers.jl en en 20260813T160000 20260813T161500 001500 Hydrodynamics of composable active structures with MicroSwimmers.jl Flagella (also known as cilia) are cellular appendages that beat with self-organised, large amplitude waves. Active, elastic and evolutionarily ancient structures, flagella perform a remarkable diversity of functions in modern-day organisms. They can be found driving fluid flow in our brains, respiratory tract, and reproductive systems, as well as allowing single-celled microorganisms to swim, navigate, feed, hunt and avoid predators. The multi-scale and multi-physics approaches needed to study these complex systems provide numerous computational challenges. MicroSwimmers.jl is designed to explore the functions of ciliated cells by combining rapid solutions to fluid dynamical problems using the boundary element-regularised stokeslet method with a composable framework for the design and variation of microswimmer morphologies and kinematics. The software connects with the existing Julia ecosystem (e.g. DifferentialEquations.jl for calculating trajectories and Makie.jl for a suite of visualisation tools). Work is ongoing to improve auto-differentiation compatibility to explore optimal behaviour patterns across fluid environments and geometries. The Julia implementation will enable biological and clinical research without knowledge of numerical methods or computational geometry, with the goal of rapid simulation and parameter variation on a laptop. I will demonstrate the accessible interface for adding new flagellar beating models and body geometries, and show a few examples of the pipeline from design to results visualisation, including a filter-feeding organism that generates a vortex ring inside a cavity, driving fluid flow over a ciliary band where nutrients are captured. The biophysics of diverse ciliated single-celled organisms is largely unexplored, and both the mechanistic origins of how cells control their flagella to exhibit diverse multi-stable patterns (in the absence of neural control) and the ecological significance of such patterns are highly debated. A better understanding has implications for health, the environment and bio-inspired technologies. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/HXY7PF/ Tent — RW1 James Cass PUBLISH EJVNCK@@pretalx.com -EJVNCK Sirens.jl: Hybrid and multiscale modeling in Julia en en 20260813T161500 20260813T164500 003000 Sirens.jl: Hybrid and multiscale modeling in Julia Sirens.jl is a new package aimed at simplifying the simulation of hybrid (continuous and discrete) and multiscale systems. It uses a component-based architecture where modular components are stepped forwards in time and synchronized through variables passed along user defined inter-connections. Components are simulated using other packages and controlled and connected by Sirens through a minimal interface. Sirens already has implementations of this interface for many common modeling paradigms covering agent-based systems and differential equations. Additionally, Sirens is designed to be highly user-extensible, allowing new packages to easily meet the Sirens interface. In this talk, we will present the core features of Sirens.jl using several examples as a guide. This will include the simulation of an engineered genetic oscillator in a growing population of cells that combines agent-based modelling with an SDE of gene regulatory network function and ODE of cell growth. We end by comparing Sirens.jl to other tools both inside and outside of the Julia ecosystem (e.g., Julia’s ModelingToolkit and Python’s Vivarium). We will demonstrate why these tools are limited for general hybrid and multiscale modeling, and the aspects of Julia that mean it could be a great language for these problems in future. PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/EJVNCK/ Tent — RW1 Matt Owen PUBLISH DXX7EW@@pretalx.com -DXX7EW StatsOP.jl: A Julia Package for Time Series Testing via Ordinal Patterns en en 20260813T164500 20260813T170000 001500 StatsOP.jl: A Julia Package for Time Series Testing via Ordinal Patterns PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/DXX7EW/ Tent — RW1 Philipp Adämmer PUBLISH LJB3ES@@pretalx.com -LJB3ES Simulate large-scale networked systems using NetworkDynamics.jl and PowerDynamics.jl en en 20260813T170000 20260813T171500 001500 Simulate large-scale networked systems using NetworkDynamics.jl and PowerDynamics.jl PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/LJB3ES/ Tent — RW1 Hans Würfel PUBLISH HMHAZL@@pretalx.com -HMHAZL Optimal control with an electrophysiology experiment in the loop en en 20260813T171500 20260813T173000 001500 Optimal control with an electrophysiology experiment in the loop PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/HMHAZL/ Tent — RW1 Melvyn Tyloo PUBLISH DVSBHX@@pretalx.com -DVSBHX Sustainability in Computational Science and Engineering en en 20260813T174500 20260813T184500 010000 Sustainability in Computational Science and Engineering PUBLIC CONFIRMED Keynote https://pretalx.com/juliacon-2026/talk/DVSBHX/ Tent — RW1 Julia Kowalski PUBLISH 3LGMBE@@pretalx.com -3LGMBE The State of BioJulia en en 20260813T100000 20260813T101500 001500 The State of BioJulia Computational biology has a rich history, and in many ways julia is an ideal language for working biologists, as it provides high-level interactivity, an excellent data stack, and the ability to optimize low-level performance. Yet growth of the Bio community has been slow. The purpose of this talk is threefold: 1. To provide a history of the organization, highlighting the unique aspects of julia for computational biology development, and the contributions that BioJulia community members have made to the broader julia ecosystem. 2. To describe recent and on-going efforts to improve the structure of the organization and community. 3. To share a vision for the future growth of BioJulia, and to solicit feedback from the community on priorities and opportunities for outreach. Kevin Bonham asked his first Stack Overflow question about dictionaries in julia in June of 2014, and has been an active contributor across the julia ecosystem for more than 10 years. He became an admin of BioJulia sometime around 2020. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/3LGMBE/ Muschel — N1 Kevin Bonham, PhD PUBLISH 7YBX7H@@pretalx.com -7YBX7H Julia for bioinformatics en en 20260813T101500 20260813T104500 003000 Julia for bioinformatics Bioinformatics is a perfect example of a discipline suffering under the two language problem: Our datasets are huge and our algorithms demanding, yet the majority of our code is written by scientists, not software engineers. Our code requires both performance, and also introspection and interactivity, and the line between exploratory data science and demanding production code is hazy. For this reason, myself and others have found Julia to be a good tool. The Julian bioinformaticians have created a selection of great packages, and several of us have been using Julia in our research for years. Yet Julia has never taken off in our field, and bioinformatics remains dominated by Python and increasingly Rust, neither of which make any attempt at solving the two language problem. In this talk, I will cover what particular requirements bioinformatics, as a discipline, demands from a programming language. What computational problems bioinformaticians tend to face, and why Julia is a good fit. I will briefly touch on the current, and possible future state of bioinformatics software in Julia. Finally, I will attempt to answer why Julia, despite its important advantages, have remained niche in the field, and speculate on how Julia can continue to provide value as a niche programming language. PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/7YBX7H/ Muschel — N1 Jakob Nybo Andersen PUBLISH 3NCLXU@@pretalx.com -3NCLXU Efficient, robust parsing with BufferIO.jl en en 20260813T104500 20260813T110000 001500 Efficient, robust parsing with BufferIO.jl Bioinformatics is rife with file formats, and as such, I/O and parsing is a bottleneck for bioinformatics workflows, and therefore a major concern for BioJulia. Unfortunately, Base Julia provides few functions for efficient I/O, and what functionality exists is severely underspecified. Historically, BioJulia packages has worked around this by reading data into a Vector{UInt8} in bulk, and then re-implementing various Base functionality by operating on the buffer using packages like TranscodingStreams, BufferedStreams and Automa. This ad hoc approach improved I/O performance over Base, but did not develop into any coherently designed buffered IO API, and many inefficiencies remained. Taking inspiration from Rust's BufRead APIs, BufferIO.jl provides a new, reimagined I/O interface. It uses a simple, low-level core set of methods, concrete types, and well-defined semantics in order to allow reliably high performance. Combined with StringViews.jl and MemoryViews.jl, performance in simple I/O benchmarks almost matches Rust's. The package has been used in a couple of BioJulia packages, and have proved a good foundational package to build abstractions on. Some problems remain: Because BufferIO.jl has not re-implemented basic functionality such as IOStream or Base Julia's file system operations, but wraps these Base I/O objects, BufferIO does not truly shield users from the inefficiency and unreliability of Base Julia. In this talk, I will motivate and demonstrate the new BufferIO.jl package, and showcase examples of how a new interface can improve the experience of writing high performance I/O code in Julia. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/3NCLXU/ Muschel — N1 Jakob Nybo Andersen PUBLISH QACULP@@pretalx.com -QACULP Modeling Indirect Readout through DNA Deformation Free Energies in Julia en en 20260813T110000 20260813T111500 001500 Modeling Indirect Readout through DNA Deformation Free Energies in Julia ### Biological motivation Protein recognition of DNA target sequences relies on two main mechanisms: direct and indirect readout. While direct readout arises from base-specific contacts between amino acids and DNA chemical groups, indirect readout depends on sequence-dependent DNA shape and deformability. This makes it subtler, but still highly influential in protein–DNA binding affinity. ### Modeling DNA deformation As a concrete example, we consider the Fis–DNA complex, whose binding affinity is sensitive to sequence changes even outside the protein–DNA contact region. Our work shows that a molecular dynamics (MD)-based protocol with modern force-field parameters can already capture these changes, with strong correlation to experiment. However, this approach is too computationally expensive for broad comparative studies or target-sequence optimization. To address this, we developed a Julia package to estimate DNA deformation free energies from simulation data using practical models with different accuracy tradeoffs. These models build on well-established features of DNA mechanics: local interactions along the chain, rigid-base descriptions in helical coordinates, and the influence of discrete backbone states on conformational preferences. Together, these ingredients make it possible to represent DNA deformation energetics with a reduced and tractable set of parameters. Using MD simulations as a data source, we introduce maximum-likelihood and pseudo-maximum-likelihood approaches that learn these reduced models while retaining the essential physics of DNA deformation. The resulting analytical framework enables rapid estimation of thermodynamic quantities such as deformation free energies, opening the door to larger-scale studies and sequence screening. ### Julia implementation Julia is a natural fit for this problem because it brings together statistical modeling, optimization, and high-performance scientific computing in a single expressive environment. The package is designed with abstractions that separate model definitions from implementation details, making it easier to extend, test, and compare new approaches. This talk will show how biologically motivated assumptions and Julia-based software design come together in a practical tool for lower-cost estimation of sequence-dependent DNA deformation effects. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/QACULP/ Muschel — N1 Christian Sustay Martinez PUBLISH BK783X@@pretalx.com -BK783X Modeling and Visualizing Late Embryogenesis in the Caenorhabditis elegans en en 20260813T111500 20260813T113000 001500 Modeling and Visualizing Late Embryogenesis in the Caenorhabditis elegans Authors: Mark Kittisopikul*, Ben Arthur, Ryan Christensen, Diyi Chen, Matthew Chaw, Stephen Xu, Alyssa Stark, John Walsh, Brie Yarbrough, Hari Shroff * Presenting Caenorhabditis elegans, a small roundworm, is widely used as a model for studying how cells and tissues develop and function. Using a form of light‑sheet imaging that records the embryo from two views (dual‑view selective plane illumination microscopy, diSPIM), we capture three‑dimensional movies of late embryogenesis. From these data, we build a smooth, time‑resolved anatomical model of the embryo’s surface and interior. We first mark a set of easily identifiable “seam” cells along the body wall and fit a flexible mesh to the organism’s surface. To ensure continuity and accuracy, we represent shapes and motions with smooth curves and periodic functions (natural cubic B‑splines and Fourier series), which provide robust interpolation across space and time. We also developed Julia‑based software that “untwists” each worm by transforming the 3D mesh into a cylindrical coordinate system centered on the embryo’s anterior–posterior axis. Individual models are then averaged over time and registered to a shared coordinate frame to create a common reference. Positions of tracked, fluorescently labeled cells can be mapped into this reference, yielding a four‑dimensional (3D + time) cellular atlas of C. elegans embryogenesis. When combined with single‑cell transcriptomics, the atlas can support spatially and temporally resolved maps of gene expression during development. Overall, these tools provide a flexible and accurate modeling framework with fast runtimes that enable rapid analysis and feedback. https://github.com/JaneliaSciComp/ShroffCelegansModels.jl (currently public) https://github.com/JaneliaSciComp/Transcriptome4D (currently private) PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/BK783X/ Muschel — N1 Mark Kittisopikul, Ph.D. PUBLISH 8Z8UFG@@pretalx.com -8Z8UFG ReproducibleJobs.jl enables practical and reproducible workflows in SingleCellProjections.jl en en 20260813T113000 20260813T114500 001500 ReproducibleJobs.jl enables practical and reproducible workflows in SingleCellProjections.jl In this talk, we will describe how ReproducibleJobs.jl is structured, and show how it is used in SingleCellProjections.jl to achieve reproducible and practical workflows for large single cell expression data. ReproducibleJobs.jl is a framework for reproducible analyses of scientific data, that is based on the following ideas: * The burden of reproducibility should be moved from the user to the packages they use for analysis, when possible. * Memoization/caching is a good strategy because while the raw data can be large, the computed results are in essence much smaller. * It is possible to create succinct specifications of how to perform analyses. Results in ReproducibleJobs.jl are lazy. Consider a simple but standard single cell workflow that look something like this: ``` counts = load_counts(["paths/to/large/files"]) transformed = sctransform(counts) normalized = normalize_matrix(transformed) reduced = pca(normalized; nsv=100) ``` To actually retrieve the result of the PCA (Principal Component Analysis) computation, the user then needs to call `fetch!(reduced)`. This is what enables ReproducibleJobs.jl to work under the hood. The lazy result is in fact a *specification*, a recipe, of what to compute. And if the computation was already memoized (cached), even in an earlier Julia session, ReproducibleJobs.jl can load the result from disk directly, without accessing any data for the earlier analysis steps. Importantly, several steps are taken to standardize the specifications, such that only changes that actually affect the results cause recomputations. The talk also describe some of the technical challenges and solutions relating to: * Specification design * Specification metaprogramming/preprocessing - going from "intent" to "implementation" * Hashing and caching * Canonical representations of specifications and why they are important * Strategies for handling high-level data types (such as tables, DataMatrices (matrix + variable & observation annotations)) in specifications * Stability across Julia sessions and package versions * How specification metaprogramming enables projections of one dataset onto another in SingleCellProjections.jl **SingleCellProjections.jl** is a package for analyzing Single Cell expression data in Julia, with support for loading, transforming, normalizing, filtering, doing dimension reduction, performing statistical tests and more. Internally, SingleCellProjections.jl uses matrix expressions built from sparse and low rank matrices, thus avoiding speed and memory problems that competing (R/python) packages face when using large dense matrices. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/8Z8UFG/ Muschel — N1 Rasmus Henningsson PUBLISH 8JFFSK@@pretalx.com -8JFFSK SpatialOmics.jl - Using the geo, image, and data stacks to analyze spatial transcriptomics data en en 20260813T114500 20260813T120000 001500 SpatialOmics.jl - Using the geo, image, and data stacks to analyze spatial transcriptomics data PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/8JFFSK/ Muschel — N1 Kevin Bonham, PhD PUBLISH ADYCYS@@pretalx.com -ADYCYS Geometric coembedding of complex interacting systems en en 20260813T120000 20260813T121500 001500 Geometric coembedding of complex interacting systems PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/ADYCYS/ Muschel — N1 Tim Holy PUBLISH QTDH38@@pretalx.com -QTDH38 PhyloHD.jl: Hyperdimensional Computing meets phylogenetic reconstruction en en 20260813T121500 20260813T123000 001500 PhyloHD.jl: Hyperdimensional Computing meets phylogenetic reconstruction The talk will be present: - **What is hyperdimensional computing?:** A brief primer on how to build your own brain and computing with concepts (hypervectors) + HyperdimensionalComputing.jl package introduction. - **Why is it useful for phylogenetic reconstruction and comparative analysis?:** A discussion of the properties of HDC that make it particularly well-suited for biological data analysis, and a review of recent applications in bioinformatics. - **How do we represent biological data as hypervectors?:** A presentation on a novel framework for representing biological data as hypervectors, including sequences, three-dimensional structures, and functional annotations, and how this can be combined to represent multimodal biological entities. - **Alignment-free phylogenetic reconstruction using HDC**: From biological data to hypervectors to phylogenetic tree, showcase of cvigilv/PhyloHD.jl - **Branch support calculation for HDC-based phylogenetics:** Showcase on hypervector perturbation, bootstrapping, jack-knifing, and other techniques for calculating branch support based on the HDC paradigm. - **Multimodal tree reconstruction using HDC:** A showcase of how to integrate multiple data sources at the time of reconstruction using HDC, showcasing 3 distinct Tree-of-Life based on data fusion to represent more complex biological entities. - **HDC learning techniques for family-based phylogenetic tree reconstruction and ancestral sequence reconstruction:** Preliminary results on using HDC learning techniques for family-based phylogenetic tree reconstruction. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/QTDH38/ Muschel — N1 Carlos Vigil-Vásquez PUBLISH 9MGLXG@@pretalx.com -9MGLXG GraphDynamicalSystems.jl: discrete, finite-state systems over graphs en en 20260813T123000 20260813T124500 001500 GraphDynamicalSystems.jl: discrete, finite-state systems over graphs PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/9MGLXG/ Muschel — N1 Reuben Gardos Reid PUBLISH UQN7WB@@pretalx.com -UQN7WB BayesInteractomics.jl: When One Bayes Factor Isn't Enough en en 20260813T124500 20260813T130000 001500 BayesInteractomics.jl: When One Bayes Factor Isn't Enough Mass spectrometry-based interactomics experiments produce lists of hundreds to thousands of candidate protein-protein interactions, but a large fraction of these are non-specific contaminants or experimental artifacts. Existing tools typically apply a single statistical test and threshold -- a t-test on fold changes, or a simple scoring scheme -- discarding the rich multi-dimensional structure of the data. A protein might be modestly enriched but detected with striking consistency, or show a clear dose-response trend that a fold-change filter would miss entirely. [BayesInteractomics.jl]([url](https://github.com/ma-seefelder/BayesInteractomics.jl)) takes a different approach. For each candidate interaction, the package computes Bayes factors from three independent statistical models that each capture a distinct aspect of the data: 1. A Beta-Bernoulli model that evaluates whether a protein is detected more consistently in bait samples than in controls. 2. A hierarchical Bayesian model (via RxInfer.jl) that estimates quantitative enrichment (log2 fold change) while sharing information across experimental protocols. 3. A Bayesian linear regression that tests for dose-response correlation between prey and bait abundance. Rather than multiplying these Bayes factors under a naive independence assumption, the package uses Copulas.jl to model the dependency structure between evidence sources. This matters because enrichment and detection evidence are positively correlated under both hypotheses -- a genuinely enriched protein is also more likely to be consistently detected -- so treating them as independent inflates the combined evidence and drives up false discovery rates. An EM algorithm fits a two-component copula mixture (H0 vs. H1) that accounts for this correlation, selecting among Clayton, Frank, Gumbel, Gaussian, and Joe copula families via model comparison. The result is a joint Bayes factor and calibrated posterior probability for every protein that properly reflects the shared information content across evidence types. This talk will cover the statistical design choices, how the Julia ecosystem made them practical, and lessons learned building a research-grade Bayesian analysis package. Specific topics include: - How RxInfer.jl's reactive message-passing enables fast variational inference for the hierarchical enrichment model, and why this matters when you need to fit the same model thousands of times. - Using Copulas.jl for method-of-moments fitting of Archimedean copulas, and how multiple dispatch made it straightforward to support six copula families through a single interface. - Automated data curation via the STRING database API, including protein group resolution and synonym mapping - Package extensions for optional functionality: a network analysis extension (Graphs.jl, GraphPlot.jl) for building and visualizing interaction networks, and an experimental structural docking extension (BioStructures.jl) -- both loaded only when the user imports the relevant packages. - Self-contained HTML reports (client-side Plotly.js and DataTables.js, no additional Julia dependencies) so that collaborators who do not have Julia installed can explore results interactively in a browser. The talk is aimed at Julia users interested in Bayesian statistics, scientific computing, or computational biology. No proteomics background is assumed and I will demonstrate a complete analysis from raw data to interactive report on a real dataset. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/UQN7WB/ Muschel — N1 Manuel Seefelder PUBLISH ELF3HR@@pretalx.com -ELF3HR InterfacialWaves.jl , a julia package for nonlinear interfacial waves. en en 20260813T143000 20260813T144500 001500 InterfacialWaves.jl , a julia package for nonlinear interfacial waves. # InterfacialWaves.jl **InterfacialWaves.jl** solves primarily for boundary-value and initial-value problems in travelling and standing interfacial wave equations. ### Key Capabilities The package enables users to numerically calculate waves to a very high accuracy. Features include: * **Wave Calculations:** * **[Stokes waves](https://en.wikipedia.org/wiki/Stokes_wave)** (travelling waves) * Gravity-Capillary waves (travelling as well as standing waves) * Viscous Gravity-Capillary waves (travelling waves) * **Standing Wave Solutions:** Functions to calculate nonlinear, non-trivial standing wave solutions in wall-bounded containers (in both cartesian and axisymmetric settings). For example the **[video here](https://www.youtube.com/watch?v=g2DojIPyxos)** demonstrates axisymmetric capillary standing waves . * **Linear Stability Analysis:** Available for both travelling and standing waves across arbitrary modes. * **Symbolic-Numeric Interface:** Allows solving initial-value problems for standing waves by programming standard perturbative methods. ### Documentation The package documentation is expected to be comprehensive description that covers: * Basics and preliminaries of nonlinear interfacial waves. * Examples showing the usage of methods exported by the package. * Descriptions of the important API. ### Dependencies The package is built upon several well-known, publicly available Julia packages, such as: `OrdinaryDiffEq.jl`, `NonlinearSolve.jl`, `FFTW.jl`, `ApproxFun.jl`, `BifurcationKit.jl`, `Symbolics.jl`, and `ForwardDiff.jl`. ### Talk Overview This talk is structured to showcase the package's abilities in simulating nonlinear interfacial waves, complete with validations against the known physics of interfacial waves. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/ELF3HR/ Muschel — N1 Nikhil Janardan Yewale PUBLISH QQ37LB@@pretalx.com -QQ37LB GeothermalWells.jl: GPU-Accelerated 3D Simulation of Deep Borehole Heat Exchanger Arrays en en 20260813T144500 20260813T150000 001500 GeothermalWells.jl: GPU-Accelerated 3D Simulation of Deep Borehole Heat Exchanger Arrays Deep borehole heat exchangers offer a low-risk path to geothermal energy, but simulating arrays of interacting wells over years to decades has been considered computationally prohibitive. This talk presents GeothermalWells.jl, developed during my time at MIT's Julia Lab in collaboration with Alan Edelman, Robert Metcalfe and Hendrik Ranocha. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/QQ37LB/ Muschel — N1 Collin Wittenstein PUBLISH WFVNXT@@pretalx.com -WFVNXT accelerating PDE timestepping with OrdinaryDiffEqOperatorSplitting en en 20260813T150000 20260813T153000 003000 accelerating PDE timestepping with OrdinaryDiffEqOperatorSplitting One aspect of partial differential equations that makes efficient solving difficult is that different parts of the equations may have different timescales which traditionally has led to scientists writing their own custom timestepping algorithms. A better solution to this problem is to have ODE solver libraries define an API by which the user can communicate the desired splitting of the problem to the solver, and then the solver can use appropriate algorithms to solve the individual pieces. This package uses a splitting technique where each component takes a timestep independent of the other components, and then the communicating the state updates between the components. This splitting of equations can lead to significant performance increases because the sub-problems can be chosen to have additional structure when compared to the full problem. Splitting can separate non-stiff components of the equations, linear or affine pieces, or simply separating loosely related components to reduce the size of the nonlinear problems that need to be solved. As such, splitting can significantly accelerate simulation. PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/WFVNXT/ Muschel — N1 Oscar Smith Dennis Ogiermann PUBLISH YQF7AE@@pretalx.com -YQF7AE TrixiAtmo.jl: An Entropy-Stable Discontinuous Galerkin Dynamical Core for Atmospheric Modeling en en 20260813T153000 20260813T154500 001500 TrixiAtmo.jl: An Entropy-Stable Discontinuous Galerkin Dynamical Core for Atmospheric Modeling PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/YQF7AE/ Muschel — N1 Marco Artiano PUBLISH YU8ZKN@@pretalx.com -YU8ZKN Macchiato.jl: a Freshly Brewed Meshless PDE Package en en 20260813T154500 20260813T161500 003000 Macchiato.jl: a Freshly Brewed Meshless PDE Package Established numerical methods such as the Finite Element Method (FEM) and Finite Volume Method (FVM) are routinely used to solve complex partial differential equation (PDE) problems. However, they require significant effort in mesh generation for complex geometries. Mesh generation is a significant bottleneck in practical engineering analysis and design, often becoming the single most time-intensive part of the process for the user. While recent advancements in deep-learning-based methods aim to address these limitations, they are not yet considered a reliable alternative to traditional mesh-based simulations. An alternative approach to solving spatio-temporal PDEs is offered by meshless methods, which do not require a mesh and simply rely on a collection of points. Neighboring points influence each other but no further geometrical construction is required and all of the complications attached to a traditional mesh are eradicated. These methods are well-suited to addressing common challenges of mesh-based approaches such as negative volumes, highly skewed elements, inefficiencies in discretization and moving boundaries undergoing large deformations. They are particularly advantageous for applications where the geometry was not produced using geometric modeling software. An example is patient-specific cardiovascular simulations, where the geometry is extracted from a medical image. Meshless methods are also well-suited for the integration of Graph Neural Networks (GNNs) within models, as the neighborhoods of influence are naturally represented as graphs. To this end, Macchiato.jl was created to fill a gap in the Julia PDE community of Eulerian meshless methods. Macchiato.jl is being actively developed alongside two other Julia packages which are the core dependencies - WhatsThePoint.jl and RadialBasisFunctions.jl. Macchiato.jl exposes the APIs relevant to scientists and engineers, while the other two packages are meant to provide the required numerical machinery. WhatsThePoint.jl is responsible for the initial phase of node generation - it contains a set of useful APIs to generate the node clouds necessary for subsequent discretization. RadialBasisFunctions.jl is a general package implementing anything related to Radial Basis Functions (RBF), designed to provide all the functionality required for implementing the Radial Basis Function-Finite Difference (RBF-FD) method - the meshless discretization scheme upon which Macchiato.jl relies. The scope of this presentation is to announce the package to the Julia community and look for collaboration. Our talk will focus on the high-level architecture of the ecosystem, showing examples, and discussing future directions of development and the challenges still ahead. PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/YU8ZKN/ Muschel — N1 Kyle Beggs Davide Miotti PUBLISH YXXEBL@@pretalx.com -YXXEBL Reproducible Parallel Adaptive Multisolver Coupling of Trixi.jl and deal.II en en 20260813T161500 20260813T163000 001500 Reproducible Parallel Adaptive Multisolver Coupling of Trixi.jl and deal.II We consider here specifically the dynamics of self-gravitating astrophysical flows, where the governing equations can be split into the hyperbolic hydrodynamic equations describing the flow and an elliptic Poisson equation describing the gravitational potential. For this problem we show that we can use already existing solvers for elliptic and hyperbolic equations, connect them through a joint hierarchical Cartesian mesh and couple them via their source terms depending on each other's state variables. By performing the coupling of these two systems in this way we obtain a multiphysics solver directly combining efficient solvers for their respective coupled governing equations. This coupling also allows indicators for adaptive mesh refinement to take all state variables of the coupled equations into account, which is also true for time step control. Here we couple Trixi.jl, a high-order discontinuous Galerkin framework for solving hyperbolic conservation laws featuring shock capturing and structure preserving methods, and deal.II, a finite-element library written in C++, on a shared adaptive mesh. We apply the resulting solver to some example problems, including a self-gravitating Sedov blast. Our approach is also extendable to other multiphysics systems following a common Eulerian formulation. By using BinaryBuilder.jl we can provide an accessible way to use and adapt this method and also make our results easily reproducible for other interested people. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/YXXEBL/ Muschel — N1 Vivienne Ehlert PUBLISH UX3K8A@@pretalx.com -UX3K8A WIAS-PDELib: Finite-Element and Finite-Volume based PDE solvers and tooling components. en en 20260813T163000 20260813T170000 003000 WIAS-PDELib: Finite-Element and Finite-Volume based PDE solvers and tooling components. PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/UX3K8A/ Muschel — N1 Jürgen Fuhrmann Patrick Jaap PUBLISH S9PVRR@@pretalx.com -S9PVRR Panel: What is missing for Julia for PDEs? en en 20260813T170000 20260813T173000 003000 Panel: What is missing for Julia for PDEs? PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/S9PVRR/ Muschel — N1 Jürgen Fuhrmann Arpit Babbar Marco Artiano Dennis Ogiermann PUBLISH LDEKJG@@pretalx.com -LDEKJG Building Playable Virtual Instruments in Julia: A Real-Time Saxophone Model Controlled by Sensors en en 20260813T100000 20260813T101500 001500 Building Playable Virtual Instruments in Julia: A Real-Time Saxophone Model Controlled by Sensors At JuliaCon 2024 we presented a small package for sound synthesis from ordinary differential equations, named `RealTimeAudioDiffEq.jl`. The aim was to render the solution of continuous dynamical systems audible –in addition to traditional visualization– and to explore the potential of dynamical systems for sound synthesis and virtual (musical) instrument design. Continuing this work, we present a use case using a custom hardware interface for controlling a saxophone model in real time. The model is composed of a system of ordinary differential equations of which we are interested in studying two parameters controlled by the player in the real instrument: blowing pressure and force applied to the reed. The interface consists of a regular saxophone mouthpiece instrumented with a pressure sensor, for measuring blowing pressure and a force sensor, for measuring force applied to the reed. The resulting signals are read by an ADC and sent to the computer through a serial port using an Arduino board. This stream is then read in Julia using `LibSerialPort.jl` and used to control those parameters in the saxophone model in real time. Because the model is explicitly dynamical and the performer controls physically meaningful parameters, this interface provides a direct way to investigate the dynamical origin of complex sonorities such as multiphonics (or bichords), where multiple oscillatory regimes may coexist or compete. In particular, the system offers a concrete experimental handle for exploring transitions between regimes as the control parameters vary, and for relating these transitions to candidate bifurcation scenarios, underlying mode onsets, octave jumps, and the emergence of simultaneous partials. We will show how the real-time loop is organized, how serial I/O and buffering are handled robustly, and how calibration and parameter mapping are implemented so that the model becomes a responsive musical interface. The intent is to provide a concrete template that generalizes beyond the saxophone model, illustrating how `RealTimeAudioDiffEq.jl` can support a broader family of playable dynamical instruments controlled by sensors in real time. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/LDEKJG/ Muschel — N2 Antonio Ortega Brook Manuel Camilo Eguia Martín Proscia Dario Ruiz PUBLISH CC37CQ@@pretalx.com -CC37CQ The Hidden Path to Turing.jl v1.0 en en 20260813T101500 20260813T103000 001500 The Hidden Path to Turing.jl v1.0 Turing.jl is a probabilistic programming language. Users can define probabilistic models with a simple macro, and then perform inference using a variety of modern techniques, including MCMC sampling, variational inference, and particle methods. Over the past two years, I and other developers have been redesigning Turing's modelling implementation (technically in the DynamicPPL.jl subpackage), almost completely from scratch. We have introduced completely new data structures, interfaces, and abstractions that can both be extended easily by users, and provide significant performance improvements. Many of these new features will have been visible to users and the Julia community via the newsletters that we publish regularly. Indeed, there are many software engineering intricacies which are nowadays covered in the DynamicPPL.jl documentation. However, in this talk I'd like to use Turing and DynamicPPL as the _context_, but to focus on all the things that nobody told me when I started working on this project. These include: - navigating the tension between a paid job and open-source development; - whether to trust old wisdom or to break things; - why Julia makes it easier and harder to work in open-source; - how to build a community of contributors and make development more sustainable. As I certainly don't have definitive answers to all of these, I also hope that this can spark some consideration and discussion amongst Julia developers. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/CC37CQ/ Muschel — N2 Penelope Yong PUBLISH L3QPFT@@pretalx.com -L3QPFT Neural Networks, Genetic Algorithms, and Neuroevolution en en 20260813T103000 20260813T110000 003000 Neural Networks, Genetic Algorithms, and Neuroevolution The talk will show many examples using the Julia REPL. All source code should be available under an open-source license at the time of the presentation. Presenters will be able to reproduce the demonstrations. PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/L3QPFT/ Muschel — N2 Alexandre Bergel PUBLISH C8UGPM@@pretalx.com -C8UGPM Missing derivative: the example of `beta_inc` and `beta_inc_inv` en en 20260813T111500 20260813T113000 001500 Missing derivative: the example of `beta_inc` and `beta_inc_inv` PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/C8UGPM/ Muschel — N2 Oskar Laverny PUBLISH W3Z3FB@@pretalx.com -W3Z3FB Real-time analysis of XFEL data en en 20260813T113000 20260813T120000 003000 Real-time analysis of XFEL data Light sources are facilities designed to create coherent x-ray radiation for scientific experiments. The majority of light sources around the world are synchrotrons, which use a circular particle accelerator to create radiation. X-ray Free Electron Lasers (XFELs) are the next generation of light sources that can produce orders of magnitude higher peak radiation intensity for experiments. Though compared to synchrotrons they can also produce orders of magnitudes more data to analyze, which presents a significant challenge. One of the most powerful XFELs today is the European XFEL in Hamburg, Germany. It's a user facility that invites external scientists to perform experiments in fields ranging from structural biology, to materials science, to attosecond physics. The scientists who come to the facility to do experiments typically get 1 week or less to setup the experiment and take data, so having fast feedback in real-time is critical to assess how the experiment is going. In this talk we will describe how Julia is used for doing such real-time analysis at the European XFEL. PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/W3Z3FB/ Muschel — N2 James Wrigley PUBLISH XZDBKL@@pretalx.com -XZDBKL StructuralEquationModels.jl: An Efficient and Extensible Framework for Structural Equation Modeling en en 20260813T120000 20260813T123000 003000 StructuralEquationModels.jl: An Efficient and Extensible Framework for Structural Equation Modeling Structural Equation Models (SEMs) are a class of statistical models applicable to a wide range of modeling tasks, such as time-series analysis, psychometric questionnaires, mediation models, multiple regression models, and multilevel models. This leads to applications across diverse scientific disciplines, including psychology, genetic epidemiology, social science, and neuroscience. StructuralEquationModels.jl implements SEMs leveraging the Julia package ecosystem, including advanced numerical optimization algorithms, symbolic algebra systems, and support for sparse matrices. This results in two primary benefits over existing open-source implementations in other languages: efficiency and extensibility. Efficiency refers to the significantly reduced computation time required to estimate SEM parameters compared to other SEM software packages. Improved efficiency allows using SEM for large networks of variables (such as in genetics) or for fitting many models in parallel (such as in neuroimaging or high-throughput experiments in general). Extensibility is achieved through a high degree of composability enabled by multiple dispatch. It allows users to easily add new features to the software to adapt SEMs to specific use cases, such as employing specialized numerical optimization algorithms for regularized estimation of high-dimensional problems. Together, these features make StructuralEquationModels.jl a valuable tool for rapid prototyping, integration with diverse optimization backends, analysis of large networks of thousands of variables, and high-performance computing applications involving millions of models. This presentation will * introduce the fundamentals of structural equation modeling and present selected use cases, * show how to use StructuralEquationModels.jl to specify models and analyze data, * explain how the package leverages the Julia ecosystem for efficiency and extensibility, * compare its computational efficiency to other SEM implementations, * and provide an outlook on planned additions to the package. PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/XZDBKL/ Muschel — N2 Maximilian Ernst Aaron Peiket PUBLISH VXYAQY@@pretalx.com -VXYAQY Symbolic post-hoc analysis with SolePostHoc.jl en en 20260813T123000 20260813T124500 001500 Symbolic post-hoc analysis with SolePostHoc.jl Symbolic learning studies algorithms that produce models expressible as logical rules. Common examples include decision trees and random forests, whose predictions can be traced back to human-readable conditions on the input data. This interpretability makes symbolic models particularly valuable in domains where understanding *why* a model makes a decision matters as much as the decision itself. This session is structured as a hands-on demo on the SolePostHoc.jl package, which serves as the post-hoc analysis layer of the SOLE ecosystem. Starting from training a decision tree on a real dataset, we walk through what SolePostHoc.jl allows from that point onward: - **Rule extraction**: deriving explicit logical rules from a symbolic model through a uniform interface, supporting multiple extraction algorithms; - **Rule simplification and manipulation**: collapsing redundant or overlapping rules into more succinct, equally expressive theories; for instance, reducing `IF A AND B THEN C; IF A AND NOT B THEN C` to the simpler (but equivalent) `IF A THEN C`; - **Surrogate methods and knowledge distillation**: approximating more complex models with interpretable surrogates, transferring knowledge into transparent representations; - **Model boosting and certification**: enhancing model capabilities boosting performance on a specified metric or ensuring the satisfiability of a desired feature or constraint. Arguably, post-hoc analysis is the stage where symbolic learning delivers on its core promise: turning a trained model into usable, understandable knowledge. SolePostHoc.jl aims to give this stage the attention it deserves, providing a reliable and extensible toolkit for anyone interested in interpretability and explainability, from newcomers to experts looking for a fully customizable system. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/VXYAQY/ Muschel — N2 Marco Perrotta PUBLISH HQJMLW@@pretalx.com -HQJMLW Bayesian Calibration using Turing.jl: A Flexible Framework for Experimental Data Assimilation en en 20260813T124500 20260813T130000 001500 Bayesian Calibration using Turing.jl: A Flexible Framework for Experimental Data Assimilation Data assimilation is an essential step in bridging the gap between simulation and experiment, playing a central role in iterative experimental design. Bayesian Calibration provides a statistically rigorous approach to infer simulation parameters. In experimental settings, i.e. accelerator physics, practitioners need inference frameworks that are not only adaptable but also fast enough to inform the next round of measurements. We present a Bayesian calibration framework built on `Turing.jl`, leveraging its composable and easily modifiable model specification to accommodate a wide range of experimental configurations and problem settings. The framework includes hierarchical modelling to capture the full parameter posterior over multiple experiments. To scale inference with Gaussian Processes, we employ a Bayesian Committee Machine approach, and we exploit parallelism across both CPU and GPU backends. Sampling is performed using NUTS and Metropolis-Hastings. We demonstrate the framework in both analytic test cases and real-world data from accelerator physics, highlighting achievable speedups, and discussing current limitations and roadblocks for GPU-accelerated sampling in `Turing.jl`. The result is a practical, flexible toolkit designed to sit inside the experimental iteration loop enabling rapid model updating and calibration. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/HQJMLW/ Muschel — N2 Sebastian Heinekamp PUBLISH THBSKY@@pretalx.com -THBSKY ElemCo.jl: A Julia Package for Electron Correlation in Molecules and Materials en en 20260813T143000 20260813T150000 003000 ElemCo.jl: A Julia Package for Electron Correlation in Molecules and Materials Efficiently obtaining high-accuracy data for molecules and materials is one of the major challenges in quantum chemistry. To address this challenge, we present the Julia package ElemCo.jl [1] for performing both established as well as novel electronic structure methods. The program enables mean-field as well as correlation energy calculations, with an emphasis on Coupled and Distinguishable [2] Cluster methods for ground and excited states. To capture the interest of a broader audience, the talk will be divided into two parts: In the first half, an introduction to the package will be given, including an overview of the program's structure, currently available methods, and compatibility with other quantum-chemical programs. In the second half, tensor decomposition will be introduced as a tool to substantially reduce the cost of various Distinguishable Cluster methods [3] for extended molecular systems. This is achieved through tensor decomposition of the amplitudes, resulting in a drastic compression of the amplitude space and a reduction in both computational scaling and prefactor, without compromising accuracy. In particular, the decomposition will be applied to DC-CCSDT [4] and EOM-DCSD [5]. [1] GitHub: https://github.com/fkfest/ElemCo.jl and website: https://elem.co.il/ [2] D. Kats and F. R. Manby, _J. Chem. Phys._ 139, 021102 (2013). [3] C. Rickert, D. Usvyat and D. Kats, _J. Chem. Phys._ 163, 064103 (2025). S. Lambie, C. Rickert, D. Usvyat, A. Alavi and D. Kats, J. Chem. Phys. 163, 111101 (2025). [4] D. Kats and A. Köhn, _J. Chem. Phys._ 150, 151101 (2019). [5] V. Rishi, A. Perera, M. Nooijen, R. Bartlett, _J. Chem. Phys._ 146, 144104 (2017). PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/THBSKY/ Muschel — N2 Charlotte Rickert Daniel Kats PUBLISH BLZJJW@@pretalx.com -BLZJJW ML-accelerated simulation of laser-driven hydrogen evolution with NQCDynamics.jl – Julia and Python in harmony? en en 20260813T150000 20260813T153000 003000 ML-accelerated simulation of laser-driven hydrogen evolution with NQCDynamics.jl – Julia and Python in harmony? **NQCDynamics.jl**² is a non-adiabatic molecular dynamics package our research group has built to facilitate development and large-scale simulations using new **mixed quantum classical dynamics methods** which go beyond the Born-Oppenheimer approximation. These methods are necessary to describe the **coupling between light, electrons and phonons at interfaces**, where ultrafast laser pulses can drive chemical reactivity by inducing mode-selective energy transfer more efficiently than comparable thermal heating.¹ However, computationally simulating the multitude of simultaneous processes occurring at different time scales *ab-initio* remains a challenge.³ Using interfaces to **Julia- and Python-based ML models working in tandem**⁴, I am able to simulate the effect of ultrafast laser pulses on hydrogen evolution from copper surfaces efficiently at a large scale. NQCDynamics.jl provides a framework for initialising dynamics simulations and propagating the equations of motion using DifferentialEquations.jl, with a number of **interfaces** to the wider Julia- and Python-based **molecular simulation ecosystem**. After sampling rare reactive dynamics from thousands of simulations, I can compare energy partitioning in desorbed hydrogen molecules, concluding that the choice of electronic friction approximation only determines the rate of energy transfer, while the energy distributions of desorbing molecules are governed by the potential energy surface. This suggests that **thermal and laser-driven desorption may yield similar outcomes at low coverage**. [1]: S. W. Lee, Appl. Surf. Sci. Adv. **16**, 100428 (2023). [2]: J. Gardner _et al._, J. Chem. Phys. **156**, 174801 (2022). [3]: C. Frischkorn and M. Wolf, Chem. Rev. **106**, 4207 (2006). [4]: W. G. Stark _et al._, Phys. Rev. B. **112**, 2 (2025). PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/BLZJJW/ Muschel — N2 Alexander Spears PUBLISH GXPBHY@@pretalx.com -GXPBHY Computing transport coefficients using Molly.jl en en 20260813T153000 20260813T160000 003000 Computing transport coefficients using Molly.jl #### Computing transport coefficients using Molly.jl Transport coefficients — diffusivity, shear viscosity, thermal conductivity — measure how molecular systems respond to small thermodynamic forcings driving them out of equilibrium. They enter as parameters in macroscopic models such as the Navier–Stokes equations and are essential for bridging atomistic simulations with continuum-scale predictions. Unfortunately, estimating these quantities from molecular dynamics simulations is notoriously expensive: standard methods suffer from large statistical errors and require very long simulation times. We present three algorithms to compute transport coefficients for systems governed by stochastic (Langevin) dynamics: - **Green–Kubo**: an equilibrium method based on integrated time-correlation functions. - **NEMD (non-equilibrium molecular dynamics)**: the standard approach of applying a fixed external forcing and measuring the average flux response. - **Constant-flux (Norton) method**: a recently proposed dual approach (Blassel & Stoltz, *J. Stat. Phys.*, 2024) that instead *fixes the flux* and measures the average forcing required to maintain it, inverting the usual NEMD philosophy. We implement the constant-flux method in `Molly.jl`, via a custom simulator type (`NortonSplitting`) that constructs flux-preserving splitting schemes, which also give natural estimates of the average forcing. The NEMD and Green–Kubo methods rely on custom interaction types and Molly's built-in logging capabilities. We discuss how [Molly.jl](https://juliamolsim.github.io/Molly.jl/stable/), with its modular design — user-definable simulators, interactions, and loggers — allows all three methods to be implemented with remarkably low overhead, enabling rapid prototyping and benchmarking of novel algorithms. On the test case of shear viscosity for a Lennard–Jones fluid, the constant-flux approach shows promising properties: faster decay of correlations and an anomalous variance concentration rate ( $N^{-5/3}$ vs. the standard $N^{-1}$ ), leading to lower asymptotic variance and better computational efficiency. These findings illustrate how Molly.jl's extensibility helps narrow the gap between mathematical ideas in statistical physics and practical applications in computational science. PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/GXPBHY/ Muschel — N2 Noé Blassel PUBLISH SEDPHP@@pretalx.com -SEDPHP BoltzTraP.jl: Thermoelectric transport for the Julia DFT ecosystem en en 20260813T160000 20260813T161500 001500 BoltzTraP.jl: Thermoelectric transport for the Julia DFT ecosystem Thermoelectric materials convert heat directly into electricity and vice versa, enabling applications in waste heat recovery, solid-state cooling, and remote power generation. The efficiency of thermoelectric devices depends on the figure of merit zT, which is determined by the Seebeck coefficient, electrical conductivity, and thermal conductivity. Accurate prediction of these transport coefficients from first-principles calculations is essential for discovering and optimizing new thermoelectric materials. [`BoltzTraP.jl`](https://github.com/hsugawa8651/BoltzTraP.jl) is a Julia implementation of the [BoltzTraP2 algorithm](https://dx.doi.org/10.1016/j.cpc.2018.05.010) for calculating semi-classical transport coefficients from density functional theory (DFT) band structures. The package interpolates band energies using a Fourier expansion in reciprocal space, reconstructs the bands on a dense k-point grid via FFT, and computes transport tensors using the Boltzmann transport equation in the constant relaxation time approximation. `BoltzTraP.jl` is a faithful Julia port that implements the exact same algorithm as BoltzTraP2, producing numerically equivalent results. The motivation for this port is integration with the growing Julia ecosystem for materials science: - **Julia ecosystem integration**: `BoltzTraP.jl` integrates natively with Julia packages like [DFTK.jl](https://doi.org/10.21105/jcon.00069), enabling direct transport calculations from DFTK self-consistent field results without intermediate files or language bridges. It also accepts output data from major DFT programs including VASP, Wien2K, Quantum Espresso, and ABinit. - **Pure Julia, no compilation**: BoltzTraP2 requires compiling a C++ extension, which can fail on some systems—particularly on HPC clusters with non-standard compiler configurations. `BoltzTraP.jl` has no external compiled dependencies. - **HPC-friendly**: Julia's package manager handles dependencies without conda/pip conflicts common on shared HPC systems. No C++ compilation means no compiler version mismatches. As pure Julia code, `BoltzTraP.jl` is designed to be highly portable and should run on any system where Julia is available, from personal laptops to high-performance computing (HPC) clusters. ## Validation, Performance, Future Directions `BoltzTraP.jl` was developed using reference testing against BoltzTraP2, the de facto standard for computing transport coefficients from DFT calculations, with over 2,000 citations. The accompanying figure compares transport coefficients computed by both codes for silicon at 300 K based on the DFT data calculated by VASP. All transport coefficients (electrical conductivity σ, Seebeck coefficient S, thermal conductivity κ) match within numerical precision (< 1e-6 relative error), demonstrating `BoltzTraP.jl` faithfully reproduces the original Python implementation. [Benchmarks on a MacBook Pro (Apple M2) show 1.8-3.4x speedup](https://github.com/hsugawa8651/BoltzTraP.jl/blob/main/paper/benchmark.png) in end-to-end calculation (interpolation + integration) for silicon (1102 equivalence classes, 6 bands), enabling rapid screening of thermoelectric properties. We are currently expanding the range of materials this package can handle to include collinear magnetic materials. Furthermore, we plan to integrate Wannier.jl to implement Wannier interpolation and reduce eigenvalue misidentification. [A Google Colab notebook](https://colab.research.google.com/gist/hsugawa8651/1bf32bb4cc3f38074f798fcac5c21d5a/d.ipynb) is available demonstrating the full workflow from band interpolation to transport coefficients, including an all-Julia pipeline with DFTK.jl. This package is open to contributions and designed for extensibility. ## Links - BoltzTraP.jl: https://github.com/hsugawa8651/BoltzTraP.jl, DOI: 10.5281/zenodo.18605978 - Docs: https://hsugawa8651.github.io/BoltzTraP.jl/dev/ - Colab: https://colab.research.google.com/gist/hsugawa8651/1bf32bb4cc3f38074f798fcac5c21d5a/d.ipynb PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/SEDPHP/ Muschel — N2 Hiroharu Sugawara PUBLISH ZLZ8FJ@@pretalx.com -ZLZ8FJ Algorithmic differentiation and error control with DFTK en en 20260813T161500 20260813T163000 001500 Algorithmic differentiation and error control with DFTK PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/ZLZ8FJ/ Muschel — N2 Bruno Ploumhans PUBLISH ZPDSRG@@pretalx.com -ZPDSRG Simulation of light-driven hot carrier dynamics & transport en en 20260813T163000 20260813T164500 001500 Simulation of light-driven hot carrier dynamics & transport 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. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/ZPDSRG/ Muschel — N2 Henry Snowden PUBLISH 7VLXGG@@pretalx.com -7VLXGG QCEngine.jl: Electronic Structure for Nonadiabatic Dynamics en en 20260813T170000 20260813T171500 001500 QCEngine.jl: Electronic Structure for Nonadiabatic Dynamics QCEngine.jl is coupled with NQCDynamics.jl to produce models of nonadiabatic energy dissipation during ultrafast molecular dynamics at surfaces. NQCDynamics.jl provides a flexible library of dynamics methods capable to modelling nonadiabatic effects during molecular dynamics in gas phase and at surfaces and in the both the strong and weak coupling regimes. Together with QCEngine.jl these codes are able to capture the resultant electron-hole pair excitation and highly inelastic scattering driven by the strong hybridisation between hydrogen and a metallic surface and the resultant phase transition in the hydrogenic spin polarisation. This kind of electronic phase transition leads to strong nonadiabatic effects and divergent energy transfer rates in traditional mean-field dynamics methods like molecular dynamics with electronic friction (MDEF). NQCDynamics.jl enables us to go beyond these methods and couple orbital surface hopping methods with on-the-fly Hartree-Fock calculations of the spin-transition performed by QCEngine.jl. Using these methods we are able to calculate non-adiabatic energy losses and spin survival probabilites during H/Cu(111) scattering in the presence of on-site correlation in the hydrogenic s-orbital. Gardner et al. J. Chem. Phys. (2022) [https://doi.org/10.1063/5.0089436](https://doi.org/10.1063/5.0089436) Box et al. J. Phys. Chem. Lett. (2024) [https://doi.org/10.1021/acs.jpclett.4c02468](https://doi.org/10.1021/acs.jpclett.4c02468) PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/7VLXGG/ Muschel — N2 Ash Baldwin PUBLISH ZKCBJY@@pretalx.com -ZKCBJY Extending DFTK.jl's features, but not its code complexity en en 20260813T171500 20260813T173000 001500 Extending DFTK.jl's features, but not its code complexity PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/ZKCBJY/ Muschel — N2 Michael F. Herbst PUBLISH PGGCJK@@pretalx.com -PGGCJK From Stencils to XLA: A Reactant Backend for ParallelStencil.jl en en 20260813T100000 20260813T103000 003000 From Stencils to XLA: A Reactant Backend for ParallelStencil.jl Stencil computations are a fundamental class of algorithms in scientific computing, with applications ranging from computational fluid dynamics to image processing. ParallelStencil is a Julia package that enables the conversion of architecture-agnostic, high-level stencil or stencil-like code into high-performance GPU, TPU, and CPU code. To achieve this, two distinct approaches have been developed to build corresponding backends: the first relies on generating hardware-specific low-level code (using CUDA.jl, AMDGPU.jl, Metal.jl, Polyester.jl, or Base.Threads); the second relies on generating generic code that is optimized as input for Reactant, and delegating the hardware-specific code generation to Reactant. Reactant is a Julia package that enables the optimization of Julia functions with MLIR and XLA for high-performance execution on CPUs, GPUs, TPUs and other hardware architectures. This contribution focuses on the second approach. We evaluate different approaches to integrate Reactant into ParallelStencil and describe solutions to challenges encountered in generating kernel code and data structures that are pre-optimized to serve as optimal input for Reactant to generate efficient and correct GPU, TPU, and CPU code. We evaluate the performance implications of different code patterns and data structures on the efficiency of the generated code. We report the performance of representative stencil mini-apps with ParallelStencil and Reactant combined on recent hardware platforms, including NVIDIA H100 GPUs at the Swiss National Supercomputing Centre (CSCS). The mini-apps include a 3D heat diffusion solver and a 3D Navier-Stokes solver using a staggered grid. We evaluate performance in absolute terms using the effective memory throughput metric, and in relative terms by comparing it with performance obtained with straightforward implementations using CUDA.jl, KernelAbstractions.jl, and other Julia packages that enable explicit GPU kernel programming. These results demonstrate the effectiveness of the approach used to build a backend with Reactant and provide insights into how to optimize code and data structures for efficient code generation with Reactant. Furthermore, this work shows how the powerful emerging MLIR- and XLA-based technologies can be integrated into existing domain-scientist-oriented high-performance computing frameworks such as ParallelStencil, providing a path toward broader adoption of these technologies in the HPC community. PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/PGGCJK/ Muschel — N3 Samuel Omlin William Moses PUBLISH LHPDZM@@pretalx.com -LHPDZM What's new in Chmy.jl: tensor expressions and automatic optimisation of finite-difference codes en en 20260813T103000 20260813T104500 001500 What's new in Chmy.jl: tensor expressions and automatic optimisation of finite-difference codes On modern hardware, most physics computations are memory-bound rather than compute-bound, making memory throughput the primary performance metric rather than the number of floating-point operations. While optimising for a specific architecture is challenging, we use effective memory throughput as a simple heuristic for assessing the performance of architecture-agnostic code. At the core of Chmy.jl is a domain-specific language (DSL) for expressing operations on structured grids. This allows users to write finite-difference approximations to PDEs in a math-like notation, which is then lowered to efficient Julia code executable on CPUs, GPUs, and distributed clusters. To maximise performance, we apply a constrained combinatorial optimisation algorithm that determines the ordering and grouping of Chmy.jl expressions into kernels that maximise effective memory throughput. The resulting kernels are generated using [KernelAbstractions.jl](https://github.com/JuliaGPU/KernelAbstractions.jl). With this approach, we achieve 80–95% of peak memory throughput for kernels implementing linear and nonlinear Poisson and Stokes equations, which are key building blocks in computational fluid mechanics. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/LHPDZM/ Muschel — N3 Ivan Utkin PUBLISH Y7LGHP@@pretalx.com -Y7LGHP TrixiParticles.jl on GPUs: A Deep Dive into Simulating Fluid Dynamics of Carbon Fiber Fins en en 20260813T104500 20260813T110000 001500 TrixiParticles.jl on GPUs: A Deep Dive into Simulating Fluid Dynamics of Carbon Fiber Fins [TrixiParticles.jl](https://github.com/trixi-framework/TrixiParticles.jl) is an open-source numerical simulation framework designed for accessible particle-based multiphysics simulations and implemented in Julia as part of the Trixi Framework. Two years after [introducing the package at JuliaCon 2024](https://youtu.be/ReLkKUV4kTw?is=aEQmXo9GWj3d36dI), we return to demonstrate how the framework leverages modern HPC hardware to support both rapid prototyping and complex applications. In the first part of the talk, we present the latest developments in GPU usability and performance. As modern clusters become increasingly GPU-centric, simulation software must adapt to utilize this hardware effectively. We show how TrixiParticles.jl allows users to seamlessly run simulations on GPUs with minimal code changes, and present benchmarks comparing modern dual-socket CPU nodes against various GPU architectures. In the second part, we take a "deep dive" into a challenging real-world application: the hydrodynamics of a carbon-fiber freediving fin. Simulating the propulsion generated by a foot-driven, extremely stiff, and thin blade presents significant numerical difficulties, particularly regarding Fluid-Structure Interaction (FSI). We will discuss numerical instabilities caused by the high stiffness and thin geometry of the carbon-fiber blade. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/Y7LGHP/ Muschel — N3 Erik Faulhaber PUBLISH 99LHV3@@pretalx.com -99LHV3 Scalable Agent-Based Modeling: Understanding and Addressing Partitioning Challenges en en 20260813T111500 20260813T113000 001500 Scalable Agent-Based Modeling: Understanding and Addressing Partitioning Challenges Agent-based models (ABMs) simulate complex systems through the interaction of individual agents. Scaling these simulations to millions of agents requires advanced parallel computing methods due to the highly flexible structure of ABMs and their interactions. Compared to static computational problems such as mesh-based finite element simulations, where the computational load and communication patterns remain the same throughout execution, ABMs present a special challenge for load balancing due to their dynamic nature and the complex interactions of the agents: - ABMs can involve heterogeneous agent types that act at different phases of the simulation. Even when the overall partitioning appears good, individual agent types may be severely imbalanced across processes, leading to idle computational resources during individual phases of the execution. - Communication between agents can also take place between agents who are spatially far apart. - Dynamic population changes alter the load distribution through addition and removal of agents. - Agent movement can create hotspots and ghost zones that were not present in the initial partitioning, Since standard partitioning algorithms do not take into account the dynamics and complex structure that are inherent in complex ABM scenarios, their results are not always satisfactory. **Talk structure**: 1. **Brief Vahana.jl introduction**: A brief overview of Vahana.jl, an HPC ABM framework based on graph dynamical systems, with a focus on the new features implemented since version 1.0, as presented at JuliaCon 2023. 2. **ABM-specific partitioning challenges**: Why general-purpose partitioning approaches fail for ABMs with heterogeneous agent types, dynamic populations, and complex agent behaviors/movement patterns 3. **Synthetic benchmarking model**: Presentation of a purpose-built synthetic ABM that systematically captures the partitioning challenges specific to ABMs. This model provides a flexible environment for evaluating and comparing different load balancing strategies and different HPC ABM frameworks in general. 4. **Outlook**: Overview of our ongoing early-stage work on developing novel partitioning algorithms specifically tailored to ABM characteristics. These algorithms will be released both as integrated Vahana.jl features and as independent Julia packages. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/99LHV3/ Muschel — N3 Steffen Fürst PUBLISH VFZ9X7@@pretalx.com -VFZ9X7 Asynchronous Field-Particle Coupling for Multiphase Cloud Simulation using Heterogeneous HPC en en 20260813T113000 20260813T114500 001500 Asynchronous Field-Particle Coupling for Multiphase Cloud Simulation using Heterogeneous HPC PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/VFZ9X7/ Muschel — N3 Henrik Rusche PUBLISH SHEA7J@@pretalx.com -SHEA7J PETSc.jl en en 20260813T114500 20260813T120000 001500 PETSc.jl PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/SHEA7J/ Muschel — N3 Boris Kaus PUBLISH BLDX9J@@pretalx.com -BLDX9J Spry.jl: Native High Performance Networking in Julia en en 20260813T120000 20260813T123000 003000 Spry.jl: Native High Performance Networking in Julia Spry.jl frees Julia HPC codes from the shackles of MPI, SHMEM, and other HPC abstractions built for a world where HPC used C and Fortran. These older codes enable scaling and portability but are increasingly limiters on performance. This is particularly true in Julia where our task based parallelism conflicts with MPI's strict serialization semantics and heavy interface. Spry.jl instead directly targets the networking libraries that MPI, SHMEM, and more rely on. Spry.jl is a metapackage which combines several different subpackages for different capabilities: 1. Bootstraps.jl manages processes, sets up and tears down network topologies, manages events between processes, and provides a key-value store for important metadata. 2. Fabrics.jl and UCX.jl are low-level networking libraries that expose user-friendly but direct access to the OpenFabricsInterface and UCX. These libraries provide extremely lightweight abstractions over vendor specific network hardware like HPE Slingshot, Mellanox Infiniband, AWS EFA, Infiniband Verbs, Omnipath, TCP, and more. 3. Swarms.jl enables (overlapping) groups of processes, the equivalent of communicators in MPI. Built on top of Bootstraps.jl 4. Specific subpackages for the high level interfaces: GlobalArrays.jl, RemoteChannels.jl, GlobalObjects.jl, and more... We also provide a strong benchmarking story, with comparisons against traditional libraries like MPI and SHMEM, Charm as well as newer libraries and languages like Chapel, LCI, HPX, etc. PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/BLDX9J/ Muschel — N3 Raye Kimmerer PUBLISH AUBUSN@@pretalx.com -AUBUSN Bridging the Gap between Dagger.jl and HPC Interconnects en en 20260813T123000 20260813T124500 001500 Bridging the Gap between Dagger.jl and HPC Interconnects Dagger's MPIAcceleration works seamlessly with the current scheduler, allowing task graphs to be executed across MPI ranks with minimal modifications. It only requires a single line of code: `Dagger.accelerate!(:mpi)`. When this feature is enabled, each MPI rank is integrated into Dagger's Processor/Memory Space model, which ensures that tasks are executed close to where their data resides. This rank-aware placement helps to minimize communication overhead. Additionally, remote data transfers happen transparently, providing handles on the appropriate ranks. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/AUBUSN/ Muschel — N3 Yan Guimarães Felipe Tomé PUBLISH YGSNMR@@pretalx.com -YGSNMR Sketch me an HPC program: Stencils with Dagger.jl en en 20260813T124500 20260813T130000 001500 Sketch me an HPC program: Stencils with Dagger.jl PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/YGSNMR/ Muschel — N3 Julian P Samaroo Felipe Tomé Rabab Alomairy PUBLISH VC7Q39@@pretalx.com -VC7Q39 Multi-GPU Algorithms with Dagger.jl en en 20260813T143000 20260813T144500 001500 Multi-GPU Algorithms with Dagger.jl PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/VC7Q39/ Muschel — N3 Julian P Samaroo Felipe Tomé PUBLISH WGCTSX@@pretalx.com -WGCTSX Hardware-agnostic linear programming on the GPU en en 20260813T144500 20260813T150000 001500 Hardware-agnostic linear programming on the GPU A linear program (LP) is an optimization problem whose objective and constraints are affine functions of the decision variables. While the simplex method is a very efficient way to solve LPs on the CPU, it is hard to parallelize efficiently, limiting its scalability. In recent years, first-order methods for LP have emerged, which require only matrix-vector multiplication. These primal-dual (PD) approaches allow practitioners to fully leverage advances in modern hardware accelerators such as GPUs and TPUs when tackling large-scale LPs. Their potential was first demonstrated by the PDLP algorithm [1] and its subsequent GPU translation [cuPDLP.jl](https://github.com/jinwen-yang/cuPDLP.jl) [2]. However, with the notable exception of [MPAX](https://github.com/MIT-Lu-Lab/MPAX) [3], existing implementations are usually written using CUDA, and thus limited to NVIDIA hardware. Furthermore, they seldom support batching, and do not allow custom matrix or number types. Thanks to the flexibility of the Julia ecosystem, we developed a new package called [CoolPDLP.jl](https://github.com/JuliaDecisionFocusedLearning/CoolPDLP.jl), which implements the PDLP algorithm in a backend-agnostic fashion. It supports arbitrary matrix and number types, which enables experiments with handrolled sparse matrix formats or reduced precision. It also provides default cross-platform sparse matrices built atop [KernelAbstractions.jl](https://github.com/JuliaGPU/KernelAbstractions.jl), for backends where sparse linear algebra is not sufficiently developed. Special care is given to minimizing allocations and preserving type stability. A [JuMP.jl](https://github.com/jump-dev/JuMP.jl) interface is also included. The JuliaCon talk will introduce the main features of our package, present a few benchmarks on different hardware families, and conclude with future perspectives such as batched solving. --- [1] D. Applegate et al., “PDLP: A Practical First-Order Method for Large-Scale Linear Programming,” Jan. 13, 2025, arXiv: arXiv:2501.07018. doi: 10.48550/arXiv.2501.07018. [2] H. Lu and J. Yang, “cuPDLP.jl: A GPU Implementation of Restarted Primal-Dual Hybrid Gradient for Linear Programming in Julia,” Operations Research, vol. 73, no. 6, pp. 3440–3452, Nov. 2025, doi: 10.1287/opre.2024.1069. [3] H. Lu, Z. Peng, and J. Yang, “MPAX: Mathematical Programming in JAX,” Dec. 12, 2024, arXiv: arXiv:2412.09734. doi: 10.48550/arXiv.2412.09734. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/WGCTSX/ Muschel — N3 Guillaume Dalle Michael Klamkin Simeon Schaub PUBLISH UFPKBT@@pretalx.com -UFPKBT Julia meets (again) the FPGA : Higher-level synthesis methodology for heterogeneous hardware and software architectures en en 20260813T150000 20260813T153000 003000 Julia meets (again) the FPGA : Higher-level synthesis methodology for heterogeneous hardware and software architectures Julia has achieved excellent results in non-standard compilation flows, notably because of the modularity of its toolchain. Flexible middle-end and back-end enables, for instance, automatic differenciation with Enzyme.jl or heteregeneous target with GPUCompiler.jl such as GPUs. Field Programmable Gate Arrays (FPGAs) are another interesting accelerator, as they are used in high-throughput and energy efficient contexts. Configurate FPGAs usually involves using a Hardware Description Language (HDL), but they require solid hardware knowledge. High Level Synthesis (HLS) has therefor been introduced to fill the gap between software paradigms and HDLs. Several HLS approaches have been developed in the Julia ecosystem [1,2,3]. State-of-the-art HLS tools, such as Vitis HLS, used a Domain-Specific Language (DSL) based on C++; it is handle by a custom Clang front-end to produce an LLVMIR which is used by the HLS engine. This IR is not ideal because of it low level nature: Multi-Layer IR (MLIR) [4] have been used instead. There are two classes of MLIR front-ends: - static ones, which translate JuliaIR to an MLIR representation, they work by matching semantics (type system, 1/0-indexing) between JuliaIR and MLIR dialects. Notably, only a subset of Julia programs can be handled, for instance, type stability is required. Based on Brutus.jl, both [2] and [3] develop a custom MLIR front-end for HLS purpose, they differ in the choosen HLS engine. [2] uses ScaleHLS [5] which is a framework build on top of VitisHLS. [3] uses a MLIR based HLS engine proposed by CIRCT [6]. - dynamic ones, the idea is to generate a MLIR program from an execution trace. This method targets higher-level dialect which handle tensor semantics. Reactant.jl [7] is an example of such a tracing approach. Unlike static methods, contraints on the Julia program are less strict, and this flexibily fit nicely to the Julia ecosystem. In a similar approach to Hardware.jl, we propose an HLS toolchain based on CIRCT HLS that takes advantage of the Reactant.jl tracing system. We use the flexibily of the Julia compiler to create mechanisms that enable high-level design-space exploration for HLS. In particular, this presentation focuses on numerical applications and their use by hardware accelerators, in particular, showing the interest of Julia for rapid prototyping. [1] B. Biggs, I. McInerney, E. C. Kerrigan, and G. A. Constantinides, High-level Synthesis using the Julia Language, Feb. 2022. arXiv: 2201.11522 [cs]. [2] G. Lounes, R. Gerzaguet, M. Gautier, Flexible front-end for high-level synthesis leveraging heterogeneous compilation, Jan. 2025. [3] B. Short, I. McInerney, J. Wickerson, A High-level Synthesis Toolchain for the Julia Language, Dec. 2025. arXiv: 2512.15679 [cs] [4] C. Lattner, M. Amini, U. Bondhugula, et al., MLIR: A Compiler Infrastructure for the End of Moore’s Law, Feb. 2020. arXiv: 2002.11054 [cs]. [5] H. Ye, C. Hao, J. Cheng, et al., ScaleHLS: A New Scalable High-Level Synthesis Framework on Multi-Level Intermediate Representation, Dec. 2021. arXiv: 2107.11673 [cs]. [6] https://github.com/llvm/circt [7] https://github.com/EnzymeAD/Reactant.jl PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/UFPKBT/ Muschel — N3 Gaëtan LOUNES PUBLISH TATRTG@@pretalx.com -TATRTG GPU acceleration in the QuantumKitHub ecosystem en en 20260813T153000 20260813T160000 003000 GPU acceleration in the QuantumKitHub ecosystem The tensor network algorithms we want to accelerate often involve large (100s of GB or more) objects on which we need to perform batched matmul, factorizations such as (randomized) SVD or QR, and permutations. Depending on the physical system, we may also be working with tensors that are extremely block-sparse, but with many irregularly sized blocks. These factors cause us to need robust and efficient multi-GPU primitives, and the various computing centers we work with generally support either NVIDIA or AMD hardware, but not both. For these reasons, we have been developing a cross-platform set of extensions to the existing packages which leverage the existing JuliaGPU implementations where possible, but because of the various and sometimes strange use-cases we are able to generate, also involve hand-written solutions. PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/TATRTG/ Muschel — N3 Katharine Hyatt Lukas Devos PUBLISH EFQ8YD@@pretalx.com -EFQ8YD KernelForge.jl: Fast, Flexible GPU Computing Toward Portability en en 20260813T160000 20260813T161500 001500 KernelForge.jl: Fast, Flexible GPU Computing Toward Portability This talk presents [KernelForge.jl](https://epilliat.github.io/KernelForge.jl), a Julia package for high-performance GPU computing. We first survey the current Julia GPU landscape—backend packages and abstraction layers—and identify what's missing for peak performance. We then introduce the intrinsics we developed in [KernelIntrinsics.jl](https://epilliat.github.io/KernelIntrinsics.jl) to fill these gaps. Finally, we show how KernelForge.jl uses these primitives to match or exceed vendor-optimized libraries like cuBLAS and CUB. ## I The Current Julia GPU Landscape The Julia GPU ecosystem is organized into two complementary layers: backend packages (CUDA.jl, AMDGPU.jl, oneAPI.jl) and abstraction packages (GPUArrays.jl, KernelAbstractions.jl, AcceleratedKernels.jl) that enable cross-architecture portability. On the backend side, CUDA.jl relies on `libcuda` for memory copies and cuBLAS for vector dot products or matrix multiplications—these are highly efficient. However, cuBLAS is proprietary, supports only a restricted set of types and operators, and is available only for NVIDIA GPUs. This raises a central question: is it possible to write open-source functions that are efficient, flexible, and portable? ### Abstraction Side KernelAbstractions.jl (KA.jl) provides tools to write kernels that can be compiled for multiple backends. This works through method overriding: each backend implements its own version of core methods (e.g., `_synchronize`) using the `@device_override` macro. At compile time, KA.jl specializes the kernel based on the backend context and argument types, following standard Julia dispatch. The code is then converted into an LLVM intermediate representation before being compiled into low-level asm (PTX for CUDA). GPUArrays.jl uses KA.jl notably for vector copy operations, which KA.jl makes straightforward to implement. AcceleratedKernels.jl provides reduction, scan, and sort functions built on KA.jl, achieving reasonable performance. Our goal with KernelForge.jl is to outperform current cross-architecture libraries (AcceleratedKernels, but also Kokkos and Raja in C++), as well as CUDA.jl and native proprietary CUDA libraries, and to demonstrate that it is possible to develop open-source code that is efficient, flexible, and portable at the same time. ## II Intrinsics Currently Missing from the Julia Ecosystem In practice, CUDA, AMD, and Intel GPUs share a similar architecture. Cores (called SMs in CUDA) schedule groups of threads. Each group is composed of warps which are set of 32 perfectly synchronized threads. Warp size varies in function of the architecture, but the principle is the same. Warps communicate through shared memory; blocks communicate through global memory. The relationship between threads and memory can be seen as a producer/consumer model: threads issue read or write requests to global memory, which returns data according to its bandwidth. For compute-bound workloads like matrix multiplication, performance bottlenecks lie in optimizing computation within threads, since memory has time to keep up. But for memory-bound workloads like copy or prefix scan, the bottleneck shifts to memory access optimization. Unfortunately, KA.jl does not currently expose the full set of intrinsics needed to achieve peak GPU performance, particularly on the memory access side. For KernelForge.jl, we have been developing these intrinsics in [KernelIntrinsics.jl](https://epilliat.github.io/KernelIntrinsics.jl) (currently available only for the CUDA backend, though extension to other backends is feasible): - **Warp operations with extended types:** GPUs execute threads in warps of 32 (CUDA) or similar groups (AMD, Intel). CUDA.jl does not support warp operations on extended types such as quaternions or NTuples. - **Vectorized loads/stores:** Loading multiple `Float32` values simultaneously enables faster memory bandwidth saturation, yielding substantial performance gains, especially when data fits within L2 cache. - **Fences and memory ordering:** Explicit control over memory ordering is essential for correct and efficient inter-group communication on GPUs. In particular, this avoids kernel relaunching and global synchronization between blocks. Performance gain is particularly noticeable for kernels such as prefix scan, for which we use a decoupled lookback algorithm. Our intrinsics design draws inspiration from UnsafeAtomics.jl (for its structural approach) and CUDA.jl. ## III KernelForge.jl and Our Objectives KernelForge.jl demonstrates that abstracted kernels built with KA.jl can achieve backend-level efficiency, at least on CUDA. We provide kernels for matrix-vector and vector-matrix products (supporting general operators and bitstype elements), mapreduce over 1D and 2D arrays, prefix scan, and copy operations that match libcuda-level bandwidth through vectorized loads/stores. Benchmarks available at [KernelForge.jl](https://epilliat.github.io/KernelForge.jl) show performance matching or exceeding proprietary CUDA functions and CUB. The package includes correctness tests and the kernels are stable, though views and strided arrays are not yet supported. KernelForge.jl builds on KA.jl and [KernelIntrinsics.jl](https://epilliat.github.io/KernelIntrinsics.jl) (CUDA-only for now). Each operation is implemented with a single kernel, using vectorized loads and stores to saturate memory bandwidth, warp-level reductions for faster intra-warp computations, and strong memory ordering to enable correct inter-workgroup communication. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/EFQ8YD/ Muschel — N3 Emmanuel Pilliat PUBLISH 7ZFWC8@@pretalx.com -7ZFWC8 SeparableFunctions.jl en en 20260813T161500 20260813T163000 001500 SeparableFunctions.jl PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/7ZFWC8/ Muschel — N3 Rainer Heintzmann PUBLISH W7FRKU@@pretalx.com -W7FRKU The GPU acceleration of SpeedyWeather.jl, the friendly and flexible climate model en en 20260813T163000 20260813T164500 001500 The GPU acceleration of SpeedyWeather.jl, the friendly and flexible climate model Climate modelling continues to rely widely on CPUs as large code bases are not adapted to run on GPUs. Yet, climate models require high-performance computing to reach societally relevant resolutions and increased accuracy in weather and climate prediction. Here, we present [SpeedyWeather.jl](https://github.com/SpeedyWeather/SpeedyWeather.jl) an atmospheric model with dynamic representations of ocean, land and sea ice allowing for global climate simulations. We rely on the Julia-stack for GPU accelerated computing to support Nvidia, AMD and Apple GPUs and report our experience: What works, what does not, what is easy, what is difficult. Our spherical harmonics transform library SpeedyTransforms.jl implements a multi-algorithm approach: Leveraging Fourier and Legendre transforms of varying lengths which remain difficult to scale at low and high resolution. Alternatively, we implemented custom LinearAlgebra kernels for complex-real matrix-matrix multiplies which are easier to optimize using Reactant.jl. Many custom kernels are written for other parts of SpeedyWeather. The so-called parameterizations, the representation of unresolved physical processes such as radiation, precipitation or surface fluxes required further attention: We leverage multiple dispatch on the GPU and a high level of kernel fusion to achieve both flexibility and performance. We employ hardware-specific optimizations with little additional code, for example, changing loop orders between CPU and GPU. The parameterizations contain many different components (one for each physical process) that a SpeedyWeather user would want to compose in many various ways, flexibly switching or modifying them. Our implementation yields both: Flexibility and performance, and new developers can easily write extensions while hiding by default much of the GPU specifics from them. Most parts of SpeedyWeather are easily accelerated by 100x or more on a single GPU compared to single CPU but some bottlenecks remain in the algorithmically complex transforms. Authors: Milan Klöwer (1), Maximilian Gelbrecht (2, 3), Niklas Viebig (1, 4) 1. University of Oxford, UK 2. Potsdam Institute for Climate Impact Research, Germany 3. Technical University of Munich, Germany 4. ETH Zürich, Switzerland PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/W7FRKU/ Muschel — N3 Milan Klöwer Niklas Viebig Maximilian Gelbrecht PUBLISH FX73BU@@pretalx.com -FX73BU Tile-Based GPU Programming with cuTile.jl en en 20260813T164500 20260813T170000 001500 Tile-Based GPU Programming with cuTile.jl CUDA Tile is a significant evolution in GPU programming, so it's important that Julia GPU developers have access to it. This talk will introduce the cuTile programming model, why it matters, and how cuTile.jl makes it possible to write tile-based GPU kernels directly in Julia. Specifically, the talk will cover: - The programming model: what tile-based programming is, how it abstracts over threads and warps, and how it enables automatic tensor core utilization. - The compiler pipeline: what the Tile IR bytecode is, and how we target it from Julia using a custom compiler. - Performance benchmarks: how cuTile.jl performs on Blackwell GPUs, and how it compares to Python's cuTile. - The relationship between cuTile.jl and CUDA.jl, and how they can complement each other for different types of GPU programming. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/FX73BU/ Muschel — N3 Tim Besard PUBLISH BPEJLA@@pretalx.com -BPEJLA What's new in CUDA.jl (besides CuTile)? en en 20260813T170000 20260813T171500 001500 What's new in CUDA.jl (besides CuTile)? PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/BPEJLA/ Muschel — N3 Katharine Hyatt PUBLISH X3GGMU@@pretalx.com -X3GGMU What's new in Metal.jl en en 20260813T171500 20260813T173000 001500 What's new in Metal.jl Many researchers use Apple silicon devices as their day-to-day computer. Metal has the potential to remove the need for a separate computer to run certain computations and analyses. We’ll cover improvements to support for the core metal API, potential showstopper issues that have been fixed, as well as well as some heavily requested features that were recently added that makes Metal.jl a viable option for an increasing number of use-cases. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/X3GGMU/ Muschel — N3 Christian Guinard PUBLISH BNPWFP@@pretalx.com -BNPWFP Jlpigraf.jl, a package for data retrieval and table merging with the Epigraf API en en 20260813T124500 20260813T130000 001500 Jlpigraf.jl, a package for data retrieval and table merging with the Epigraf API PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/BNPWFP/ Alte Mensa — Audi Max Georg Hertkorn PUBLISH JXMW8H@@pretalx.com -JXMW8H HyperLogLog Over RSA: Anonymously Counting Users en en 20260813T143000 20260813T150000 003000 HyperLogLog Over RSA: Anonymously Counting Users This talk walks through the problem of anonymous client counting, how having each client generate a unique random ID serves as a gold standard in terms of functionality but has terrible privacy properties. We introduce HyperLogLog, a brilliant technique for estimating cardinalities of unique values in small, fixed memory. It also provides a good first cut method for anonymous client counting, but has two major flaws: 1. HLL has good privacy _on average_ but some clients are uniquely identifiable—it is not uniformly anonymous. 2. HLL values are trivially forgeable: a malicious client can arbitrarily inflate estimates with a fixed amount of effort. We discuss how to address these two issues and incrementally arrive at a design where HyperLogLog values are randomly generated by each client in already encrypted form, so the client can neither decipher nor bias its HLL value. If this encrypted value were sent every time, it would uniquely identify a client, so a crucial trick of this protocol is that each client can randomize the value it sends in such a way that any two clients with the same HLL are indistinguishable, thereby preserving privacy. This is combined with "sharding" HLL values based `on` the package being requested, so that clients cannot be tracked across packages, and uniform anonymity is restored across packages. PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/JXMW8H/ Alte Mensa — Audi Max Stefan Karpinski PUBLISH LCUBGM@@pretalx.com -LCUBGM Making your Julia code compliant for usage in pharmaceutical industry en en 20260813T150000 20260813T151500 001500 Making your Julia code compliant for usage in pharmaceutical industry Non-compliant software cannot be used in the pharmaceutical industry because it directly compromises patient safety, data integrity, and product quality. In a highly regulated sector (e.g., FDA, EMA, WHO), software must undergo rigorous validation to prove it consistently operates as intended. Non-compliant, invalidated systems lead to legal, financial, and safety risks. Achieving compliance in a regulatory setting isn't about the language itself, but the processes wrapped around it. To make Julia code compliant for pharmaceutical use, developers must focus on following aspects 1. Reproducibility:- Software reproducibility in the pharmaceutical industry refers to the ability of a computerized system to consistently generate, process, and output the same results, data, or product quality metrics whenever it is used, regardless of who is operating it or when it is operated. This is a critical component of GAMP 5 and makes sure software used in GxP (Good Practice) environments consistently adheres to FDA 21 CFR Part 11 and EU GMP Annex 11 regulations. In this talk, we will show how to ensure reproducibility in your Julia program using Pkg.jl and other external Julia packages. 2. Documentation:- We will show how to use literate programming in Julia using Literate.jl or Weave.jl to generate reports where code, assumptions, and results live in a single document. 3. Validation:- Regulatory bodies require proof that the software performs its intended functions. These proofs are provided in form of following reports - Installation Qualification (IQ) report: Provides evidence that the Julia app and its dependent libraries are installed correctly in the production environment. - Operational Qualification (OQ) report: Provides evidence that your Julia app operates correctly according to specifications and functional requirements. - Performance Qualification (PQ) report: Provides evidence that your Julia app operates consistently and reproducibly under routine, real-world conditions to meet predefined specifications, this report also includes a conclusion confirming the Julia app is ready for performing its routine production tasks. In the talk, we will show you how to generate these pieces of evidence with respect to your Julia app and show an example of these reports. All the recommendations that will be discussed in this talk; stem from eight years of developing and maintaining Julia-based solutions which were deployed in regulated pharmaceutical environments. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/LCUBGM/ Alte Mensa — Audi Max Harsha Byadarahalli Mahesh PUBLISH R8VPMR@@pretalx.com -R8VPMR A new way of creating Julia web apps en en 20260813T151500 20260813T153000 001500 A new way of creating Julia web apps [Magic.jl](https://github.com/nidoro/Magic.jl) has a distinctive design that sets it apart from existing web app frameworks in the Julia ecosystem. Most current frameworks assume a traditional web architecture based on request–response cycles, declarative user interfaces, and reactive interactions. *Magic.jl*, by contrast, is built around direct execution of Julia code. A *Magic* web app is simply a Julia script that is rerun from top to bottom on every user interaction. This script-centered design makes the execution flow easy to reason about and aligns naturally with how scientists and researchers typically write and think about code. In this talk, we will: - Introduce Magic's core concepts and features - Discuss possible use cases - Demonstrate it with example web applications - Explain how it compares to other web app frameworks PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/R8VPMR/ Alte Mensa — Audi Max Davi Doro PUBLISH MQKGAM@@pretalx.com -MQKGAM SpeedRand.jl - How to (not?) Implement your own PRNG in Julia en en 20260813T154500 20260813T160000 001500 SpeedRand.jl - How to (not?) Implement your own PRNG in Julia PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/MQKGAM/ Alte Mensa — Audi Max Kevin Qing PUBLISH YWEB3Y@@pretalx.com -YWEB3Y How to teach an online Julia course en en 20260813T160000 20260813T161500 001500 How to teach an online Julia course The talk will give a background on the High Performance Computing in Julia course, its aims and a description of its structure. I will then dive into the technical details of how the course is put together, covering, but not limited to: - Producing and publishing online lecture notes - Creating animations and visual aids using code - Recording, editing and publishing videos - Distributing and marking assessments In each of these topics, I will provide the software and techniques used, as well as the alternatives considered that may be more applicable to other educators. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/YWEB3Y/ Alte Mensa — Audi Max Dr. Jamie Mair PUBLISH SZPFSX@@pretalx.com -SZPFSX JuliaCheck: Industrial-Grade Static Code Analysis for Julia en en 20260813T161500 20260813T163000 001500 JuliaCheck: Industrial-Grade Static Code Analysis for Julia As Julia matures and finds adoption in safety-critical and industrial environments, the need for rigorous, automated code quality tooling grows accordingly. While the ecosystem offers excellent tools like JET.jl and Aqua.jl, there remains a clear gap: configurable, rule-driven static analysis that integrates with enterprise software quality frameworks. A natural candidate for this role is semgrep, currently recommended by JuliaHub for Julia static analysis. However, semgrep relies on its own Julia parser, which is not always in sync with the latest JuliaSyntax developments, meaning it can silently fail or produce incorrect results on modern Julia code. [JuliaCheck.jl](https://github.com/tiobe/JuliaCheck.jl) takes a different approach: it is built entirely in Julia and uses JuliaSyntax.jl directly for AST traversal, ensuring it stays current with the language itself and benefits from the same parser that underpins Julia's own tooling ecosystem. JuliaCheck.jl provides a dynamic rule engine where each check is a self-contained, selectively enableable unit. Beyond detecting violations, it lets users filter results and generate comprehensive violation reports (consumable as highlighted terminal text, structured JSON, or plain text) making it a natural fit for CI/CD pipelines. The rule set at the core of JuliaCheck is being developed jointly by TIOBE and ASML. On top of this, users can define and load their own custom rules to enforce project-specific standards. What further distinguishes JuliaCheck is its integration with TIOBE's TiCS framework, one of the most widely adopted software quality platforms in enterprise environments. Julia projects can now be measured against ISO/IEC 25010-aligned quality metrics alongside C++, Java, and Python — enabling organizations with mixed-language codebases to maintain consistent quality standards across their entire portfolio. The talk will cover the architecture, the ASML/TIOBE rule catalog, custom rule authoring, violation filtering and reporting, TiCS integration, a live demo on a real Julia codebase, showing a roadmap for moving it to the Julia OpenSource registry and the upcoming features (e.g., bring JET.jl results directly into the TiCS dashboard). PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/SZPFSX/ Alte Mensa — Audi Max Evangelos Paradas Paul Jansen PUBLISH HTGCKD@@pretalx.com -HTGCKD (Directed) Hypergraph Structures for Complex Network Analysis in Julia en en 20260813T163000 20260813T164500 001500 (Directed) Hypergraph Structures for Complex Network Analysis in Julia Commonly, researchers and engineers represent various networks — ecological, social, computer, and more — as graphs. However, graphs can encode only binary relations (i.e., edges connect exactly two vertices), making them inappropriate to model many complex networks of technical and research significance. For these cases — including modeling relational databases, financial transfers, and chemical reaction networks — more general hypergraphs are essential tools. In hypergraphs, hyperedges can connect arbitrary numbers of vertices, bypassing the key binary restriction of graphs. In this talk, we will discuss efforts to represent and model hypergraphs, especially directed hypergraphs, in Julia. We will begin by introducing hypergraphs and their practical utility for network modeling before shifting to hypergraph representations and tools in Julia. We will briefly discuss SimpleHypergraphs.jl, developed by Przemysław Szufel and colleagues.[1] We will introduce the sparse representation of hypergraphs as matrices, the connection with Graphs.jl, and mention various features and analyses available for undirected hypergraphs. The bulk of the talk will focus on directed hypergraphs, implemented in the recently developed package SimpleDirectedHypergraphs.jl. We will demonstrate how to construct directed hypergraphs by-hand, from external data, and randomly. We will further introduce a number of algorithms included in SimpleDirectedHypergraphs.jl, in particular focusing on heuristic and exact pathfinding. Our discussion will conclude with a small application involving random and real-world chemical reaction networks. SimpleDirectedHypergraphs.jl is the first package for directed hypergraph construction and analysis in Julia. To the best of our knowledge, general-purpose directed hypergraph packages are also absent in many high-level programming languages used in mathematics and science (e.g., R, MATLAB), with most available packages focusing exclusively (e.g., hypernetx[2], [HyperG](https://cran.r-project.org/web/packages/HyperG/refman/HyperG.html)) or mainly on undirected hypergraphs (e.g., directed hypergraphs are, at the time of this writing, an "experimental feature" in the Python package [XGI](https://xgi.readthedocs.io/en/stable/api/core/xgi.core.dihypergraph.html)). Beyond being an addition to the Julia ecosystem, SimpleDirectedHypergraphs.jl is thus positioned to benefit network science and network scientists broadly. Notes: [1]: Antelmi et al., arXiv:2002.04654 2020, DOI: 10.48550/arXiv.2002.04654 [2]: Praggastis et al., arXiv:2310.11626 2023, DOI: 10.48550/arXiv.2310.11626 PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/HTGCKD/ Alte Mensa — Audi Max Evan Walter Clark Spotte-Smith (they/them) Zhenya Barannik PUBLISH M79AYW@@pretalx.com -M79AYW ORTools.jl: CP-SAT through JuMP en en 20260813T164500 20260813T170000 001500 ORTools.jl: CP-SAT through JuMP Building on the foundation of ORTools.jl, this session provides a practical dive into the integration of Google’s CP-SAT solver within the Julia ecosystem. While ORTools.jl provides a broad bridge to Google’s optimization suite via Google’s MathOpt & Julia’s MathOptInterface, the CP-SAT implementation warrants a closer look. [CP-SAT has won gold medals at the MiniZinc challenge for more than a decade](https://www.minizinc.org/challenge/) We will discuss the interface used to expose CP-SAT to JuMP users. A primary focus will be the data structure conversions required to map Julia-based constraints to the solver's Protocol Buffer interface and practical examples on how to model some problems and invoke CP-SAT through ORTools.jl as interfaced through JuMP. Because CP-SAT is natively a C++ engine, we will detail the technical hurdles of cross-language interoperability and the use of a specialized C API and JLL package to ensure a seamless installation for end users. Attendees will gain insight into: The specific mapping of discrete optimization problems to the CP-SAT through ORTools.jl. Lessons learned from bridging Julia with the C++ interface. The current state of CP-SAT features accessible to the Julia community for the first time. This talk serves as a practical follow-up for those interested in the implementation of ORTools-CP-SAT interface and the specific power of Google's CP-SAT availed in through Julia. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/M79AYW/ Alte Mensa — Audi Max Ochibobo Warren PUBLISH ZBQKTY@@pretalx.com -ZBQKTY What's new in Copulas.jl en en 20260813T170000 20260813T171500 001500 What's new in Copulas.jl PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/ZBQKTY/ Alte Mensa — Audi Max Oskar Laverny PUBLISH G7CLZ7@@pretalx.com -G7CLZ7 How to Extend Peridynamics.jl for Your Own Research en en 20260813T171500 20260813T173000 001500 How to Extend Peridynamics.jl for Your Own Research Peridynamics is a nonlocal continuum formulation that is particularly useful for simulating crack propagation, fragmentation, and similar discontinuous phenomena. We developed Peridynamics.jl with high-performance computing in mind, but for the peridynamics community it is just as important that the package can be adapted to specific research questions without too much effort. In this talk, we show how the extension interface of the package works in practice. To implement a new material model, users only need to define the routines that describe the constitutive behavior. Parallel execution, halo exchange between MPI ranks and threads, and output are handled by the package. The same approach can be used for custom contact laws, damage criteria, boundary conditions, and post-processing callbacks. Since extensions are ordinary Julia types and methods, they compose naturally with the models that are already available. For example, users can set up multi-material simulations that combine built-in and user-defined formulations without modifying the package itself. Users can also use the built-in methods for parameter studies and post-processing, allowing for a seamless workflow from model definition to results analysis. We go through specific examples and show how a constitutive formulation can be turned into a working parallel simulation with only a small amount of Julia code. We also discuss the design decisions behind this extensibility and how Julia helps make Peridynamics.jl a flexible research tool for the peridynamics community. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/G7CLZ7/ Alte Mensa — Audi Max Kai Partmann PUBLISH SRHZCN@@pretalx.com -SRHZCN Accuracy of Mathematical Functions in Julia en en 20260813T100000 20260813T103000 003000 Accuracy of Mathematical Functions in Julia PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/SRHZCN/ Alte Mensa — Atrium Maximum Mantas Mikaitis PUBLISH UZXK9Y@@pretalx.com -UZXK9Y Structured iterative approximations in numerical (multi-)linear algebra en en 20260813T103000 20260813T110000 003000 Structured iterative approximations in numerical (multi-)linear algebra PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/UZXK9Y/ Alte Mensa — Atrium Maximum Nicolas Venkovic PUBLISH SHTJ3F@@pretalx.com -SHTJ3F MatrixEquations.jl - a continuous effort to achieve performance and genericity en en 20260813T111500 20260813T114500 003000 MatrixEquations.jl - a continuous effort to achieve performance and genericity PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/SHTJ3F/ Alte Mensa — Atrium Maximum Andreas Varga PUBLISH AV3GA8@@pretalx.com -AV3GA8 DifferentialRiccatiEquations.jl: Solving matrix equations with low-rank solutions en en 20260813T114500 20260813T121500 003000 DifferentialRiccatiEquations.jl: Solving matrix equations with low-rank solutions The differential Riccati equation arises, for example, in optimal control of the linear-quadratic regulator. DifferentialRiccatiEquations.jl (DRE.jl) started as a port of some low-rank Rosenbrock methods written in MATLAB (with the aim to distribute the computations using the parareal method; but this is a story for another day). At every Rosenbrock step one has to solve an algebraic Lyapunov equation, which can be done using the Alternating-Direction Implicit (ADI) method. Therefore, the package quickly evolved into a test bed for improving the low-rank Lyapunov ADI method, from GPU support to mixed-precision low-rank factorizations. PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/AV3GA8/ Alte Mensa — Atrium Maximum Jonas Schulze PUBLISH NXU8WC@@pretalx.com -NXU8WC Hierarchical Precision and Recursion for Accelerating Symmetric Linear Solves on MXUs en en 20260813T121500 20260813T123000 001500 Hierarchical Precision and Recursion for Accelerating Symmetric Linear Solves on MXUs Symmetric linear solves are fundamental to a wide range of scientific and engineering applications, from climate modeling and structural analysis to machine learning and optimization. These workloads often rely on Cholesky (POTRF) decomposition and its supporting operations - triangular solves (TRSM) and symmetric rank-k updates (SYRK) - which together form the computational core for solving symmetric positive definite systems. To accelerate these kernels, we present a portable, mixed-precision solver designed for Matrix Processing Units (MXUs), including NVIDIA Tensor Cores (H200) and AMD Matrix Cores (MI300X). Our algorithm builds on a nested recursive formulation in which Cholesky exposes parallelism through recursive decomposition of its TRSM and SYRK subproblems, incorporating the first recursive GPU implementation of SYRK. This structure yields a hierarchical recursion that maximizes GEMM throughput while enabling fine-grained control over numerical precision. We introduce a custom recursive data structure that assigns low-precision FP16 arithmetic to large off-diagonal blocks, while preserving high precision on diagonal blocks to ensure numerical stability. To mitigate the limited dynamic range of FP16, we integrate a lightweight block-wise quantization scheme that prevents numerical overflow. The solver is implemented in Julia, leveraging array programming, multiple dispatch, and dynamic type inference to enable seamless expression of mixed-precision computation. This design provides a high-level, hardware-agnostic interface while efficiently interfacing with low-level vendor libraries for backend portability. On H200, our recursive FP64 SYRK achieves a 14x speedup over cuBLAS, while mixed-precision delivers up to 27.0x speedup in SYRK and 5.3x in TRSM over full-precision baselines. This results in a 5.32x overall speedup for Cholesky versus cuSOLVER FP64, with 100x better accuracy than pure FP16 while retaining 88% of its peak speedup. Comparable performance and accuracy trends are observed on MI300X, demonstrating broad applicability across GPUs. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/NXU8WC/ Alte Mensa — Atrium Maximum Vicki Carrica PUBLISH J3MRUE@@pretalx.com -J3MRUE Approximate Computing Community Panel en en 20260813T123000 20260813T130000 003000 Approximate Computing Community Panel PUBLIC CONFIRMED Birds of Feather (BoF) https://pretalx.com/juliacon-2026/talk/J3MRUE/ Alte Mensa — Atrium Maximum Jonas Schulze PUBLISH XS9BT7@@pretalx.com -XS9BT7 JuliaDecisionFocusedLearning: A Practical Introduction to Decision-Focused Learning in Julia en en 20260813T143000 20260813T150000 003000 JuliaDecisionFocusedLearning: A Practical Introduction to Decision-Focused Learning in Julia This talk provides a practical introduction to Decision-Focused Learning (DFL) in Julia. For a recent survey of the field, see https://arxiv.org/abs/2601.10583. Rather than focusing on theoretical details, the goal is to use a small example problem to showcase the capabilities of the **JuliaDecisionFocusedLearning** ecosystem. **JuliaDecisionFocusedLearning** started with `InferOpt.jl`, which provides the core building blocks for constructing differentiable combinatorial optimization layers and associated loss functions. We introduce two new higher-level packages: - [`DecisionFocusedLearningBenchmarks.jl`](https://github.com/JuliaDecisionFocusedLearning/DecisionFocusedLearningBenchmarks.jl) - Provides a growing collection of benchmark combinatorial decision problems. - Includes all necessary components to build and train a DFL policy for each problem. - Offers a general interface for defining custom problems. - Facilitates reproducibility and experimentation by allowing the same algorithm to be applied across multiple benchmarks with minimal changes. - [`DecisionFocusedLearningAlgorithms.jl`](https://github.com/JuliaDecisionFocusedLearning/DecisionFocusedLearningAlgorithms.jl) - Implements generic versions of state-of-the-art DFL training algorithms. - Provides compatibility with problems defined through the benchmarks interface. - While some classical DFL approaches can be implemented directly using the lower-level tools provided by InferOpt.jl, recent state-of-the-art methods have become increasingly complex. This package introduces higher-level implementations to make these advanced algorithms accessible without requiring users to master the technical details. The goal of the talk is to demonstrate how users can leverage these packages to define a problem, select a training strategy, and train a policy for their own problem in a few lines of code, without necessarily needing deep expertise in DFL. PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/XS9BT7/ Alte Mensa — Atrium Maximum Léo Baty PUBLISH HBY8MD@@pretalx.com -HBY8MD Teaching Opaque Machine Learning Models Plausible and Actionable Explanations en en 20260813T150000 20260813T153000 003000 Teaching Opaque Machine Learning Models Plausible and Actionable Explanations In our research [paper](https://arxiv.org/abs/2601.16205), we propose a novel training regime termed counterfactual training that leverages counterfactual explanations to increase the explanatory capacity of models. ## Counterfactual Explanations and Algorithmic Recourse Counterfactual explanations (CE) have emerged as a popular post-hoc explanation method for opaque machine learning models and artificial intelligence (AI): they inform how factual inputs would need to change in order for a model to produce some desired output. To be useful in real-world decision-making systems, counterfactuals should be plausible with respect to the underlying data and actionable with respect to the feature mutability constraints. This facilitates the use of CE for the purpose of algorithmic recourse (AR): helping individuals subject to opaque AI to turn negative outcomes into positive ones. Much existing research has therefore focused on developing post-hoc methods to generate counterfactuals that meet these desiderata. In Julia, CE and AR can be generated and benchmarked using Taija's [CounterfactualExplanations.jl](https://github.com/JuliaTrustworthyAI/CounterfactualExplanations.jl). ## Counterfactual Training In our latest research, we instead hold models directly accountable for the desired end goal: counterfactual training employs counterfactuals during the training phase to minimize the divergence between learned representations and plausible, actionable explanations. We demonstrate empirically and theoretically that our proposed method facilitates training models that deliver inherently desirable counterfactual explanations and additionally exhibit improved adversarial robustness. Our new [CounterfactualTraining.jl](https://github.com/JuliaTrustworthyAI/CounterfactualTraining.jl) package was developed during the research process. To run large-scale experiments, it leverages [CounterfactualExplanations.jl](https://github.com/JuliaTrustworthyAI/CounterfactualExplanations.jl)'s support for multi-processing CE. ## Real-World Impact Our approach and package enables researchers and practitioners to train more trustworthy models without changing their architecture. If, for example, a particular problem lends itself to using an artificial neural network, you can improve its trustworthiness through counterfactual training, instead of training it conventionally. ## Limitations Since this package was developed during the research process, it was designed to fit that purpose. While the package is fully functional, its user-facing API, documentation and performance have room for improvement. Through this talk, we hope to receive feedback and ideas from the community and attract contributors. ## Further Reading This work is the culmination of Patrick's PhD, from which he recently graduated. The development of Taija has played a key role in his PhD. If you're interested in getting a broader picture, you may find his [thesis](https://www.patalt.org/thesis/) and [defence talk](https://www.patalt.org/content/talks/posts/2026-defence/) useful. PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/HBY8MD/ Alte Mensa — Atrium Maximum Patrick Altmeyer PUBLISH JFXJHC@@pretalx.com -JFXJHC Handle your handles en en 20260813T154500 20260813T160000 001500 Handle your handles PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/JFXJHC/ Alte Mensa — Atrium Maximum Patrick Häcker PUBLISH 8H9T9C@@pretalx.com -8H9T9C District-scale energy system simulation with ReSiE en en 20260813T160000 20260813T163000 003000 District-scale energy system simulation with ReSiE The [ReSiE package](https://github.com/QuaSi-Software/resie) is the simulation engine of a larger collection of tools for the planning, modelling, simulation and analysis of sector-coupled energy systems on the scale of city districts. The typical use case of the package is the early planning stage of a project, when limited information is available, yet important decisions have to be made concerning which technologies to employ and how the energy system components are connected and controlled. As an "engine", its chief concern is the calculation of power, heat and other energy flows for each timestep, as well as the necessary post-processing to perform economical analysis of results, which is required for optimisation and parameter variation studies. Using the engine therefore does benefit from additional tools to create the necessary input configuration, but does not require the user to program any code. Comparable tools in the field of energy system modelling and simulation often make use of mathematical models of linear optimisation and mixed-integer linear programming (MILP). In contrast, ReSiE uses a different approach based on aspects of systems analysis, agent-based simulation and graph theory. This incurs several dis-/advantages compared to established tools: * Optimisation is separated from simulation, however only black-box optimisation is possible * No limitation on the complexity of the individual energy system component models. For example the ground-coupled heat storage model uses a finite-volume method to co-simulate heat transport into the ground. * Complex non-linear control mechanisms involving the interaction of multiple components are possible, however new strategies have to be implemented as code * Highly flexible system topology with no hard limitations on size and depth of the network, however edge cases can occur that require deliberation Development of the package was the first major project using Julia of all involved developers, which lead to several stumbling blocks along the way. The most severe of these are discussed alongside which Julia-specific considerations were observed. PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/8H9T9C/ Alte Mensa — Atrium Maximum Etienne Ott PUBLISH 7QZCDB@@pretalx.com -7QZCDB JuliaCon 2026 Poster Session en en 20260813T190000 20260813T210000 020000 JuliaCon 2026 Poster Session PUBLIC CONFIRMED Poster https://pretalx.com/juliacon-2026/talk/7QZCDB/ Alte Mensa — Atrium Maximum PUBLISH LCY7JK@@pretalx.com -LCY7JK Breaking The Non-Recurring Cost Curve Using Model Based Methodologies en en 20260814T084500 20260814T094500 010000 Breaking The Non-Recurring Cost Curve Using Model Based Methodologies Breaking the non-recurring cost curve requires a fundamental shift in how complex systems are designed, analyzed, verified, and integrated. Traditional development approaches often discover design defects late in the lifecycle, when correction is more expensive, schedules are more constrained, and integration risk is highest. Model Based Development (MBD) changes this dynamic by moving defect discovery earlier and extending the verification window through the use of high-fidelity design models, executable simulations, early functional prototyping, and model-driven validation. This presentation explores how model-based methodologies enable earlier requirements validation, improved design maturity, greater standardization, earlier verification test readiness, and higher-fidelity system integration. By placing detailed system design models at the center of the development process, organizations can reduce late-cycle rework, improve first-pass quality, accelerate integration maturity, and ultimately reduce non-recurring engineering cost while improving delivery confidence. Subsequently, this session will showcase Dyad, by Juliahub, demonstrating how Dyad enables easy and efficient model based development, leveraging and agentic UI and the Julia programming language. PUBLIC CONFIRMED Keynote https://pretalx.com/juliacon-2026/talk/LCY7JK/ Tent — RW1 Gary Mansouri Chris Rackauckas Viral B. Shah PUBLISH PAH3UZ@@pretalx.com -PAH3UZ Securing the Supply Chain: Vulnerability Scanning for Julia en en 20260814T100000 20260814T103000 003000 Securing the Supply Chain: Vulnerability Scanning for Julia This session demonstrates the technical integration of **Trivy** to provide vulnerability scanning for the Julia ecosystem. We outline how the **JuliaHub platform** automatically analyzes source code and dependencies to identify known risks, closing the **"vulnerability gap"** found in binary JLLs. The session covers the core concepts of vulnerability scanning and demonstrates how these platforms integrate directly into development workflows to catch threats before they reach production. We conclude with a **live demonstration** of a workflow that brings these industrial-grade protections to every Julia project. PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/PAH3UZ/ Tent — RW1 Mridul Ranjan Upadhyay Venkatesh Dayanand PUBLISH 7BTWVN@@pretalx.com -7BTWVN Solving the No Language Problem with Julia en en 20260814T103000 20260814T110000 003000 Solving the No Language Problem with Julia The practice of programming computers has seen more upheaval in the last year than any time since the introduction of the first "high level" languages like Fortran and Lisp. Many of the concerns, however, remain the same: How can we trust what the computer generates? Should a programmer have to understand everything their computer does? How can we be certain the outcome of running a program is deterministic? The battle lines in this dispute have been drawn, but in this talk we will explore how the emerging conflict is built upon a fundamental misunderstanding. If, as the famous quote goes, "programs must be written for people to read, and only incidentally for machines to execute", then the real problem is not that we're asking LLMs to generate code we aren't reading, but rather that programmers have been writing fundamentally unreadable code for a generation! Languages such as Python and Javascript have been developed for a decade or more with a such a focus on making machines execute that they've failed to develop the necessary features to enhance people's ability to read and understand code. Together we will explore the ways in which Julia, with its Lisp heritage, elegant type system, and focus on multiple dispatch, is the perfect language for the coming era of machines increasingly writing code on their own. This talk is not just a sales pitch for using Julia in your next Vibe-coding session, though. We will also look at how existing tools in both the Julia language itself and a handful of available packages can be combined to not only allay the concerns of those who worry about handing the reins over to the machines, but also to make coding Julia hand-in-hand with the machines more powerful than any of the alternatives. PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/7BTWVN/ Tent — RW1 Joshua Ballanco PUBLISH XXLRUE@@pretalx.com -XXLRUE From graphical block diagram to juliac executable en en 20260814T111500 20260814T113000 001500 From graphical block diagram to juliac executable PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/XXLRUE/ Tent — RW1 Fredrik Bagge Carlson Tim Besard Benjamin Chung Kiran Pamnany PUBLISH 3NCWH3@@pretalx.com -3NCWH3 Makie.jl Highlights: Raytracing, Compute Graphs and Complex Recipes en en 20260814T113000 20260814T120000 003000 Makie.jl Highlights: Raytracing, Compute Graphs and Complex Recipes Makie is Julia's most comprehensive native plotting ecosystem, with nearly all functionality implemented in Julia itself. In this talk we want to present the highlights of last year's development and take a take a look at what the future might hold for the project. With RayMakie and Hikari, Makie has gained a new photorealistic GPU-accelerated ray tracing backend. Compared to the existing RPRMakie backend which was based on the Radeon ProRender framework and never quite lived up to its potential, RayMakie and its dependencies Hikari and Raycore are written in Julia. This gives a much greater degree of flexibility, the opportunity to implement custom tracing passes, and it allows to target platforms that were unreliable or unusable with ProRender. Built as a Julia port of pbrt-v4, Hikari supports physically-based materials, volumetric media, and environment lighting, all running on different types of GPUs via KernelAbstractions.jl. RayMakie opens up a new world of visualizations for Makie users, where light can be used in a more technical way, like visualizing simulated clouds to verify algorithms, or in more artistic ways, rendering 3D data in a way that sparks curiosity. We'll present some beautiful renderings and give interested users ideas how to get started. Second, we'll cover v0.24's switch from Observables to compute graphs from ComputePipeline.jl. This fundamental refactor enabled synchronized multi-attribute updates and eliminated redundant intermediate computations. Many users are not yet aware how they can utilize the new features or how they might benefit from a rewrite of old Observables based code. We'll go over some typical patterns and also clarify in what situations Observables are still the way to go. Third, we want to introduce complex recipes, an upcoming feature that fills in longstanding gaps in Makie's API and should make it easier for most users to write themeable and composable plotting functions. The existing `@recipe` macro was designed as a low-level building block and never intended to handle multi-axis scenarios with automatic legends, colorbars, or even UI elements, which is nevertheless what people have tried to implement with it. The age-old question "how do I simply add an axis title to my recipe" might finally get some answers. We'll finish off with a brief outlook on the future of the Makie project and where we're headed next. PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/3NCWH3/ Tent — RW1 Julius Krumbiegel Simon Danisch PUBLISH RSTAHL@@pretalx.com -RSTAHL DyadAgentBench: An Agent Evaluation Framework for Dyad Agent en en 20260814T120000 20260814T121500 001500 DyadAgentBench: An Agent Evaluation Framework for Dyad Agent We will demonstrate the infrastructure that enables the evaluation of the agent's physical modelling capabilities and the correctness of its numerical simulations. In this talk, we will also demonstrate how we track incremental updates to the agent and measure their cumulative impact on the agent's capabilities. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/RSTAHL/ Tent — RW1 Ashutosh Bharambe PUBLISH AXUZ9V@@pretalx.com -AXUZ9V F16 Trim-to-Stabilize Workflow en en 20260814T121500 20260814T123000 001500 F16 Trim-to-Stabilize Workflow PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/AXUZ9V/ Tent — RW1 Rajeev Voleti PUBLISH BXSHUH@@pretalx.com -BXSHUH Data Center System Modeling with Dyad en en 20260814T123000 20260814T130000 003000 Data Center System Modeling with Dyad PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/BXSHUH/ Tent — RW1 John Batteh PUBLISH VQWV7R@@pretalx.com -VQWV7R Practical Perspectives on the Use of AI Agents in Engineering System Simulation en en 20260814T143000 20260814T150000 003000 Practical Perspectives on the Use of AI Agents in Engineering System Simulation PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/VQWV7R/ Tent — RW1 John Batteh PUBLISH 9QTK9V@@pretalx.com -9QTK9V The Julia ecosystem security advisory database en en 20260814T150000 20260814T153000 003000 The Julia ecosystem security advisory database The security advisory landscape is messy, complicated, and difficult to understand. Yet maintaining an ecosystem database in accordance with industry best practice is fundamental to powering security scanners. This talk will dive into the design, creation, data, automations, and work that powers SecurityAdvisories.jl at a level that is approachable to all Julia programmers. Like a CVE, the new JLSEC advisory is a mechanism to assign a unique identifier to a vulnerability in a Julia package — or relay information about an upstream vulnerability in one of its artifacts (commonly a JLL). There are many challenges with such a database, and this talk will discuss them. Key points to be covered will include: * The format and best ways to author a JLSEC advisory * How JLSEC advisories relate to CVEs and GitHub advisories * How artifacts and JLLs are linked with upstream projects and their published CVEs (and the myriad challenges therein) * How to get involved PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/9QTK9V/ Tent — RW1 Matt Bauman PUBLISH DSWTZG@@pretalx.com -DSWTZG Running tests in parallel with ParallelTestRunner.jl en en 20260814T154500 20260814T160000 001500 Running tests in parallel with ParallelTestRunner.jl Some packages have extensive and particularly compute-intensive test suites, which run for hours in continuous integration (CI) pipelines, with significant resources usage, and time spent for developers waiting for the results of the tests. This is for example the case for several GPU-related packages (CUDA.jl, AMDGPU.jl, Metal.jl, Enzyme.jl, etc...), and many of them rolled their own independent solutions to parallelise the run of the tests, to address this problem and speed up the development cycle. This eventually lead to the creation of [`ParallelTestRunner.jl`](https://github.com/JuliaTesting/ParallelTestRunner.jl), a reusable package for running tests of Julia packages in parallel that we'll present in this talk. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/DSWTZG/ Tent — RW1 Mosè Giordano PUBLISH VP8XK9@@pretalx.com -VP8XK9 Implementing AI Workloads on Ray in Julia en en 20260814T160000 20260814T161500 001500 Implementing AI Workloads on Ray in Julia PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/VP8XK9/ Tent — RW1 José Quenum PUBLISH QUVQMK@@pretalx.com -QUVQMK The making of Advanced Pluto - VSCode Extension en en 20260814T161500 20260814T163000 001500 The making of Advanced Pluto - VSCode Extension We present two fresh takes on the Pluto Project: 1. a [VSCode extension](https://marketplace.visualstudio.com/items?itemName=juliapluto-pankgeorg.advanced-vscode-extension) with ~700 installs already, built on top of native VSCode Notebook APIs (meaning all VSCode tools, like AI autocomplete, Julia Language Server and LSP already work 2. A TypeScript library ([Pluto Rainbow](https://www.npmjs.com/package/@plutojl/rainbow)) that natively connects to a Pluto Server, allowing developers to create experiences that leverage Pluto's native features, as first-class citizens in a javascript runtime (browsers or nodejs), on top of which the VSCode extension was also built. We will present a set of fresh features that the combination of VSCode Notebook and other native APIs make possible, such as the Pluto Advanced Terminal, Pluto Advanced MCP (for ai agent interaction) and reactivity (sliders and similar UI widgets), all inside VSCode, in a professional and familiar User Interface. Repository: https://github.com/JuliaPluto/advanced-vscode-extension PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/QUVQMK/ Tent — RW1 Panagiotis Georgakopoulos Dmitrij Rožděstvenský PUBLISH PMRJ7G@@pretalx.com -PMRJ7G TestPicker, bringing modernity to Julia testing in the terminal en en 20260814T163000 20260814T164500 001500 TestPicker, bringing modernity to Julia testing in the terminal The talk will be presenting the [`TestPicker.jl`](https://github.com/theogf/TestPicker.jl) tool and its different features including: - Identifying all test files of a package - Run any subset using an interactive picker (fzf) - Run any `@testset` block - Include any relevant context in evaluation - Analyze the results with the ability to parse the test results and stacktraces with view on the source code. I will also mention the [`TestPickerMCPServer.jl`](https://github.com/theogf/TestPickerMCPServer.jl) package which plugs the test interface of `TestPicker` to AI agents. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/PMRJ7G/ Tent — RW1 Théo Galy-Fajou PUBLISH XNCC8A@@pretalx.com -XNCC8A Jumbo Julia distribution en en 20260814T164500 20260814T170000 001500 Jumbo Julia distribution PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/XNCC8A/ Tent — RW1 Janis Erdmanis PUBLISH 3GSWV9@@pretalx.com -3GSWV9 Julia Gender Inclusive: Initiatives to create a more welcoming community en en 20260814T170000 20260814T171500 001500 Julia Gender Inclusive: Initiatives to create a more welcoming community The objective of our organization 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 gender diversity, increase awareness of our current initiatives, receive input on new actions we can take as Julia Gender Inclusive, and reach out to others who want to get involved. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/3GSWV9/ Tent — RW1 Julia Gender Inclusive Letícia Madureira Firoozeh Dastur PUBLISH HQDK3J@@pretalx.com -HQDK3J State of Julia keynote en en 20260814T173000 20260814T183000 010000 State of Julia keynote PUBLIC CONFIRMED Keynote https://pretalx.com/juliacon-2026/talk/HQDK3J/ Tent — RW1 Jeff Bezanson PUBLISH 7VVKFA@@pretalx.com -7VVKFA Closing Ceremony en en 20260814T183000 20260814T184500 001500 Closing Ceremony PUBLIC CONFIRMED Ceremony https://pretalx.com/juliacon-2026/talk/7VVKFA/ Tent — RW1 PUBLISH FLU7MM@@pretalx.com -FLU7MM Dyad Analyses: Designing Engineering Workflows with Julia en en 20260814T100000 20260814T101500 001500 Dyad Analyses: Designing Engineering Workflows with Julia Models of engineering systems can be used for many purposes. The most basic type of analysis is a "what if" scenario where you want to determine either the steady state behavior of the system or how the system responds in time to disturbances. While these steady-state and transient analyses are quite common, they are just the tip of the iceberg when it comes to engineering workflows. For example, when engineering products it is often useful to transform a given system model into an FMU for use in software-in-the-loop (SiL) or hardware-in-the-loop (HiL) applications. But unlike the steady-state and transient analyses, generation of an FMU requires a different set of steps. But the key is that it can be based on the same model. By introspecting the model it is possible to reconstitute it as an FMU. Another common application is to perform some kind of model optimization or model calibration. Having access to the symbolic representation of the system allows us to exploit automatic differentiation for efficient computation of gradients. Again, we wish to pass a model as "input" and then perform some transformation or computation which generates engineering results or artifacts for us. In this case, the result will be a design that has been optimized according to a provided objective and constraints. The list of these potential analyses is nearly endless. Not only that, every company in every industry has their own specific engineering processes so it is impossible to provide a fixed set of analyses that will satisfy everybody. This is exactly why we need an open ended framework for formulating these analyses. In this talk, we will talk about how we leverage the power and immense ecosystem of the Julia programming language to provide a structured way of constructing engineering workflows. Within this analyses framework, it is possible to create your own workflows described via Dyad models, parameters and even nested workflows and use Julia to map those inputs into engineering artifacts (time series data, reports, diagrams, etc). All of this works equally well on the desktop as well as in continuous integration (CI) pipelines. Once authored, these workflows can be extended and customized using the Dyad graphical user interface. This provides turnkey access to engineers across the organization without having to be experts in Julia. Those engineers provide the necessary inputs via the GUI and once the analysis is complete they can review the engineering artifacts in the same GUI. Finally, it isn't just humans who benefit from these analyses because they are also fully recognized and understood by the Dyad agent. This means that when you create your own analyses, they become part of the toolbox that our Dyad agent can use in helping you answer your most pressing engineering questions. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/FLU7MM/ Muschel — N1 Michael Tiller Sebastian Micluța-Câmpeanu PUBLISH E33UYZ@@pretalx.com -E33UYZ Designing the Amazonia 1B Space Mission with the Julia Ecosystem en en 20260814T101500 20260814T103000 001500 Designing the Amazonia 1B Space Mission with the Julia Ecosystem The Brazilian National Institute for Space Research (INPE) is currently developing a new Earth observation satellite named Amazonia 1B. The spacecraft bus is nearly identical to that of the previous mission, Amazonia 1, which was successfully launched in February 2021. However, Amazonia 1B utilizes a distinct payload, a camera with significantly enhanced spatial resolution, aimed at improving environmental monitoring capabilities for Brazil. Consequently, the satellite operates in a different orbit, necessitating the redesign of several critical aspects of the mission. The mission design phase of Amazonia 1B was carried out with the support of a comprehensive set of packages within the Julia programming ecosystem, enabling the execution of numerous essential engineering tasks. The core algorithms developed and employed throughout this process are encapsulated within the publicly available packages [SatelliteToolbox.jl](https://github.com/JuliaSpace/SatelliteToolbox.jl) and [SatelliteAnalysis.jl](https://github.com/JuliaSpace/SatelliteAnalysis.jl), both of which provide a robust framework for satellite mission analysis. The mission design of a new satellite requires a systematic approach encompassing several interdependent steps. In this presentation, we will delve into the intricacies of orbit design, a foundational aspect of the satellite's overall configuration. The selection of an appropriate orbit constitutes the initial and most fundamental step in the process, as it directly influences the functionality and performance of various satellite subsystems, including power generation, thermal control, and communication links. Within this context, we will demonstrate how the Julia ecosystem was leveraged to facilitate the efficient selection of an optimal orbit, compute the satellite's eclipse duration and beta angle profile, and estimate the access windows and revisit gaps for the designated ground stations. The results derived from these analyses were subsequently incorporated into the Amazonia 1B Critical Design Review (CDR), which occurred in November 2025. All findings underwent thorough validation by the review board, which did not identify any issues with the methodology or the results. This outcome demonstrates the maturity and reliability of the Julia ecosystem, confirming its suitability for application in the design phase of operational space missions. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/E33UYZ/ Muschel — N1 Ronan Arraes Jardim Chagas PUBLISH ZJ3D8Q@@pretalx.com -ZJ3D8Q Embedding Julia on Petoi Bittle and Raspberry PI en en 20260814T103000 20260814T104500 001500 Embedding Julia on Petoi Bittle and Raspberry PI Integrating software and hardware can be a huge pain. Incompatibilities, different communication protocols create a bottleneck for researchers. In this talk we will show listeners how Julia can be integrated with actual hardware. We show how we embed Julia on Raspberry PI and, as an example, we will be using state-of-the-art state estimation software RxInfer.jl. For communication we use the open-source library PetoiBittle.jl and as a hardware we use an open source programmable robotics platform called Petoi and their open-source high-performance Robot Dog called Bittle. This work has been conducted together with Wouter Kouw, assistant professor from BIASlab https://biaslab.github.io/author/wouter-kouw/ Links - https://rxinfer.com/ - RxInfer website - https://www.petoi.com/ - Petoi robots website - https://github.com/ReactiveBayes/RxInfer.jl - RxInfer official GitHub repository - https://github.com/bvdmitri/PetoiBittle.jl - Petoi Bittle communication library PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/ZJ3D8Q/ Muschel — N1 Dmitry Bagaev PUBLISH T79F7F@@pretalx.com -T79F7F Developing a custom FEM solver for the heat problem in the laser processing of metals en en 20260814T104500 20260814T110000 001500 Developing a custom FEM solver for the heat problem in the laser processing of metals In doing research on laser-based manufacturing techniques, particularly more recent ones such as directed energy deposition, when the cost of materials and time meets with the large parameter space of the problem, simulation becomes a necessity. While commercial solutions do exist, they typically abstract away the inner workings of the physics taking place. In consequence, building a custom solver can be a great way to understand both the physics and the computer science involved. Starting from first principles, I show how I implemented the transient heat equation into the _Ferrite.jl_ framework and how _DifferentialEquations.jl_ can be used to efficiently solve the ordinary differential equations required for temperature, while taking into consideration the non-linear boundary conditions including radiation. The solver is then validated against experimental results obtained in the laboratory. Finally, I show how exposing the inner workings of the solver makes the implementation of additional functionality, such as computing the hardness of the processed material much easier. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/T79F7F/ Muschel — N1 Petru-Vlad TOMA PUBLISH PG9DLH@@pretalx.com -PG9DLH Laminar Workflow, Turbulent Performance: XCALibre.jl - A Modern CFD Framework in Julia en en 20260814T110000 20260814T111500 001500 Laminar Workflow, Turbulent Performance: XCALibre.jl - A Modern CFD Framework in Julia XCALibre.jl achieves "Turbulent" performance by utilising Julia’s unique language features and composable ecosystem. The proposed structure for this talk is as follows (approximately 5 minutes per section): • **Motivation**: Why XCALibre.jl? We discuss the gap this framework fills and how it complements existing Julia CFD packages like Trixi.jl, WaterLily.jl, and Oceananigans.jl, highlighting how XCALibre.jl contributes to this ecosystem. • **Development History**: Released just over a year ago, XCALibre.jl has matured with surprising speed. We provide a brief timeline of its evolution, highlighting a key success story: much of the core development was driven by undergraduate and master’s students, a testament to the "Laminar" ease of prototyping in Julia. • **Technical Architecture**: We dive into the dependencies that underpin XCALibre.jl, specifically KernelAbstractions.jl and the broader GPU ecosystem. We explore how we use (and perhaps "abuse") Julia’s type system, multiple dispatch, macros, and generated functions to achieve high-performance and to build our Domain Specific Language (DSL) for defining new physics. • **Features & Benchmarks**: A showcase of current capabilities, performance benchmarks against legacy solvers, and CFD visualisations. • **Vision & Future Plans**: An honest look at current limitations, ongoing work, and our roadmap for industrial-scale simulation. **Target Audience**: This talk is for engineers, physicists, and HPC enthusiasts. Attendees will learn how Julia can modernize legacy engineering workflows without sacrificing efficiency. We hope to inspire developers in other scientific domains by sharing our experience and to foster new collaborations within the Julia CFD community. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/PG9DLH/ Muschel — N1 HMedina PUBLISH CHQSVY@@pretalx.com -CHQSVY MLThermoProperties.jl: Hybrid Models for Thermodynamic Property Prediction in Julia en en 20260814T111500 20260814T113000 001500 MLThermoProperties.jl: Hybrid Models for Thermodynamic Property Prediction in Julia Knowledge of thermodynamic properties of fluids is crucial in many fields of engineering and science, e.g., for developing new chemical and biotechnological processes, optimizing heat pumps, or designing carbon capture and storage technologies. However, experimental data on thermodynamic properties are notoriously scarce due to the high cost and effort of measurements, making reliable prediction models indispensable. In recent years, machine learning (ML) has emerged as a particularly promising approach to thermodynamic modeling [1]. In our research group, many state-of-the-art thermodynamic ML models are developed under the umbrella of MLPROP, a collection of open-source ML models for molecular property prediction. These models, despite being neural networks at their core, are thermodynamically consistent, i.e., they obey hard physical constraints. This consistency is either achieved by an appropriate architecture or by exploiting existing thermodynamic models to form new hybrid models. Based only on the SMILES code of a substance – a textual representation of the molecular structure – the MLPROP models predict multiple thermodynamic properties, outperforming established models in both accuracy and scope [2]. Among the covered properties are phase equilibria of pure substances and mixtures [2], which are central to chemical process design, as well as transport properties such as diffusion coefficients [3] that govern molecular mass transfer. The models utilize different ML architectures, including the chemical language model ChemBERTa [4] and molecular graph neural networks. In Julia, a rich ecosystem for thermodynamics and chemical engineering already exists. Clapeyron.jl [5], a mature and comprehensive thermodynamic package, is a central part of this ecosystem. It combines a large number of thermodynamic models (including equations of state (EoS) and Gibbs excess energy models) with advanced and efficient solvers. Leveraging Julia’s excellent extensibility, several packages extend Clapeyron.jl, e.g., EntropyScaling.jl for modeling transport properties, or Langmuir.jl for modeling adsorption. This talk introduces MLThermoProperties.jl, which provides Julia implementations of the thermodynamic models from MLPROP, based on Clapeyron.jl – enabling the prediction of thermodynamic properties for any substance in Julia. MLThermoProperties.jl not only provides implementations of existing models, but also serves as a central anchor point for the development of new models. Due to the excellent extensibility of Julia packages, MLThermoProperties.jl substantially broadens the capabilities for modeling chemical processes, based on state-of-the-art molecular property prediction. The individual models are presented and their integration into the existing thermodynamic ecosystem is explained. Additionally, illustrative applications of these models in chemical process simulations are showcased using packages from the wider scientific-modeling ecosystem in Julia, particularly from the SciML organization, e.g., ModelingToolkit.jl and DifferentialEquations.jl. **References** [1] H. Hasse, S. Schmitt, and F. Jirasek: Artificial Intelligence in Thermodynamics: Hybrid Modeling of Thermophysical Properties of Fluids, Current Opinion in Chemical Engineering 51 (2026) 101236, DOI: https://doi.org/10.1016/j.coche.2026.101236. [2] T. Specht, M. Nagda, S. Fellenz, S. Mandt, H. Hasse, and F. Jirasek: HANNA: Hard-Constraint Neural Network for Consistent Activity Coefficient Prediction, Chemical Science (2024), DOI: https://doi.org/10.1039/D4SC05115G. [3] J. Wagner, Z. Romero, K. Münnemann, S. Schmitt, T. Specht, H. Hasse, and F. Jirasek: Hybrid Machine Learning for Enhanced Prediction of Diffusion Coefficients in Liquids, to be published (2026). [4] W. Ahmad, E. Simon, S. Chithrananda, G. Grand, and B. Ramsundar: ChemBERTa-2: Towards Chemical Foundation Models, arXiv, DOI: https://doi.org/10.48550/arXiv.2209.01712. [5] P. J. Walker, H.-W. Yew, and A. Riedemann: Clapeyron.jl: An Extensible, Open-Source Fluid Thermodynamics Toolkit, Industrial & Engineering Chemistry Research 61 (2022) 7130–7153, DOI: https://doi.org/10.1021/acs.iecr.2c00326. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/CHQSVY/ Muschel — N1 Sebastian Schmitt PUBLISH WYZSFH@@pretalx.com -WYZSFH RailToolKit: Building an Open Ecosystem from TrainRuns.jl en en 20260814T113000 20260814T114500 001500 RailToolKit: Building an Open Ecosystem from TrainRuns.jl PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/WYZSFH/ Muschel — N1 Martin Scheidt Gregor Wehrle PUBLISH Z38XCK@@pretalx.com -Z38XCK Real-Time GNSS Positioning with JuliaGNSS: From SDR Signals to Your Location en en 20260814T114500 20260814T120000 001500 Real-Time GNSS Positioning with JuliaGNSS: From SDR Signals to Your Location This talk demonstrates that Julia can power a real-time GNSS receiver. Using recorded SDR captures, I walk through the complete signal processing chain—from raw radio samples to a position fix—showing acquisition, tracking, decoding, and positioning as they happen in real time. The talk centers on a demonstration of the full receiver pipeline: 1. SDR signal capture – Raw I/Q samples from GPS satellites received by commodity hardware 2. Satellite acquisition – The receiver detecting visible GPS satellites 3. Signal tracking – Correlation loops locking onto and following satellite signals 4. Position computation – Calculating position and time from the tracked signals Attendees will see the complete journey from radio waves to coordinates, processed entirely in Julia. Talk Structure (12 minutes) - Introduction (6 min) – Brief context: what GNSS signals are and why real-time processing is challenging, walking through the receiver processing real SDR data: acquisition, tracking, and position fix - Demonstration (4 min) – Demo (Either from live signals or recorded signals) - Ecosystem & Next Steps (2 min) – The 1.0 milestone, package overview, and how to get started with JuliaGNSS Live Demo If the venue permits line-of-sight to GPS satellites (e.g., near a window), I will run a fully live demonstration—connecting an SDR on stage and computing our position at the conference in real time. GPS signals are weak and do not penetrate buildings reliably, so recorded captures serve as the primary demonstration with live acquisition as a bonus if conditions allow. GNSS receivers are traditionally implemented in C/C++ or as dedicated hardware. A working real-time receiver in Julia demonstrates that the language is ready for demanding signal processing applications. Seeing satellites being acquired and tracked provides concrete evidence of Julia's performance in action. This talk expands Julia's presence in SDR and embedded signal processing—domains where C/C++ still dominates. The JuliaGNSS ecosystem (GNSSSignals.jl, Acquisition.jl, Tracking.jl, GNSSDecoder.jl, PositionVelocityTime.jl, and GNSSReceiver.jl) is open source and available for researchers, educators, and hobbyists to use and extend. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/Z38XCK/ Muschel — N1 Sören Schönbrod PUBLISH YWMTMA@@pretalx.com -YWMTMA Reliability Analysis of Underground Hydrogen Storage Under Limited Data en en 20260814T120000 20260814T121500 001500 Reliability Analysis of Underground Hydrogen Storage Under Limited Data PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/YWMTMA/ Muschel — N1 Jasper Behrensdorf Gergely Schmidt PUBLISH QZGFZP@@pretalx.com -QZGFZP Simulation and Modelling of Persistent High Altitude Solar Aircraft with Julia en en 20260814T121500 20260814T123000 001500 Simulation and Modelling of Persistent High Altitude Solar Aircraft with Julia The following aspects will be covered in the talk: - A brief overview of PHASA-35 and its capabilities. - Use of Julia in standalone PHASA-35 performance calculation tools. - Building of FMUs using JuliaC, which are used to perform whole-aircraft simulations. - Speeding up of simulations with JuliaGPU packages. - Continuous Integration with Julia. - General comments on the development experience with Julia. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/QZGFZP/ Muschel — N1 Nathanael West PUBLISH 7YNPXC@@pretalx.com -7YNPXC statFEM-EUCLID.jl: Data assimilation and constitutive model discovery en en 20260814T123000 20260814T124500 001500 statFEM-EUCLID.jl: Data assimilation and constitutive model discovery Starting point is a specific problem setting, e.g. a plate with a hole under tension. For this setting, a set of displacement and/or strain observations Y and global reaction forces must be available. The discovery loop starts with an initial guess for a constitutive model and its parameters, and goes as follows: 1) Sample traction forces from a distribution that reflects the uncertainties in reaction forces 2) Query the FEM black box through UMBridge and propagate uncertain traction onto forecasted displacements u_f using non-intrusive polynomial chaos expansion 3) Check if the distance between measurements Y and forecasted displacements is sufficiently small 3a) If yes, we have converged and the current material model is the best fit 3b) If not, continue 4) Bayesian updating of forecasted displacements u_f from given observations Y yields assimilated displacements u_a 5) Taking the mean of u_a, discover a new material model using the virtual field method VFM or EUCLID In the talk, the basic ideas of the statFEM-EUCLID framework, design decisions of the package and the flexibility in using different FEM solvers through UMBridge will be addressed. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/7YNPXC/ Muschel — N1 Jan Philipp Thiele PUBLISH XD88T7@@pretalx.com -XD88T7 TriShellFiniteElement.jl: A Mindlin triangular shell finite element formulation for use with Ferrite.jl en en 20260814T124500 20260814T130000 001500 TriShellFiniteElement.jl: A Mindlin triangular shell finite element formulation for use with Ferrite.jl PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/XD88T7/ Muschel — N1 Cris Moen PUBLISH CCVYAA@@pretalx.com -CCVYAA juTarget: A Julia-powered Pipeline built with a Hybrid Machine Learning method for M. tuberculosis Drug Resistance Prediction en en 20260814T144500 20260814T150000 001500 juTarget: A Julia-powered Pipeline built with a Hybrid Machine Learning method for M. tuberculosis Drug Resistance Prediction **The Structure of the Talk is as follows:** **Background:** (2 mins; Will brief clinical challenges, limitations of the existing tools) The emergence and persistence of drug resistant Mycobacterium tuberculosis has attracted researchers to come up with modern rapid diagnostic methods like tNGS. Nevertheless, the data analysis to extract the valuable information requires either cumbersome or costlier methodologies and so, we have developed juTarget, a dockerized browser based Linux application. **juTarget Pipeline:** (3 min; Will detail application architecture) We integrated the industry standard tools into Julia such as: minimap2 for long read alignment, samtools for BAM manipulation, bcftools for variant calling. A customized Julia-native module is then applied to standardize chromosome names and apply quality filters. SnpEff was then used to annotate the variants to identify the deleterious mutations. **The Hybrid ML Method:** (4 min; Will describe our novel two-tier classification method) The heart of this application is a hybrid machine learning method for classifying drug resistance. - **Catalogue-based Identification:** SnpEff-annotated variants are first compared with the extensively curated database of known resistance mutations, the WHO catalogue, prioritizing the clinical and biological relevance. - **Predictive Classification:** For novel uncatalogued variants, a Random Forest model classifies the mutations based on a feature set of 30 biophysical features of the amino acids. **Validation and Conclusion:** (3 min; Will conclude presenting the validation results) The application has been validated by the experts with the clinical samples at the National Institute for Research in Tuberculosis (NIRT), Chennai, The accuracy of the method was confirmed with high concordance between the drug resistance profiles generated by juTarget and camspred, a locally developed pipeline, on a shared dataset. This project demonstrates Julia’s applicability for developing complex, reproducible bioinformatics pipelines integrating the industry standard tools and custom scripts with ML models, providing a scientifically validated platform for Mycobacterium tuberculosis tNGS data analysis. **Technical Details:** The application runs on a local server and it is dockerized for portability. It is developed using Genei.jl framework in a user-friendly GUI ecosystem and the user does not have to be an expert Linux user. Parallel processing has been implemented considering that computer’s RAM capacity. Status bars indicating the process status has been incorporated for easy monitoring. The results are stored locally which can be retrieved through the application interface at any time. The code is available on https://github.com/drbenedictpaul/jutarget. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/CCVYAA/ Muschel — N1 Dr Benedict Christopher Paul PUBLISH KGR8N9@@pretalx.com -KGR8N9 What’s new with MEDYAN.jl: A Coarse-Grained Cytoskeleton Simulator en en 20260814T150000 20260814T151500 001500 What’s new with MEDYAN.jl: A Coarse-Grained Cytoskeleton Simulator I will describe the new collision detection system for accelerating force and distance calculations between point, line segment, and triangle objects, including data structures and algorithms in the reusable SimplexCellLists.jl package. I will also describe the new system for handling the dynamic mechanical and chemical links that can form and break between entities during a simulation. Users can write declarative rules for any custom force law, reaction rate, and reaction effect. These rules leverage Julia to generate efficient multi-threaded force kernels. The chemical reaction rules are accelerated with spatial data structures from SimplexCellLists.jl. Link topology is tracked using generational-index graphs via UniqueIDs.jl, enabling efficient creation and deletion of transient connections. This modular and extensible system is important for describing the variety of protein interactions and chemistry in the cell. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/KGR8N9/ Muschel — N1 Nathan Zimmerberg PUBLISH GJRCSK@@pretalx.com -GJRCSK Building a Coulomb explosion simulation on top of DifferentialEquations.jl en en 20260814T151500 20260814T153000 001500 Building a Coulomb explosion simulation on top of DifferentialEquations.jl One of the dreams of the molecular imaging community is to watch a chemical reaction while it is happening. To this end, various methods have been developed, trying to reach enough resolution in space and time to resolve molecular dynamics. One such promising method is x-ray-induced Coulomb explosion imaging. Short x-ray pulses are used to remove many electrons from a single molecule, resulting in its ultrafast fragmentation into the composing atoms. The velocities of the fragments are then measured in coincidence, providing a probe of the molecule. The interpretation of the post-explosion velocity data relies on simulations, to map features of the measured data to features of the molecule before its destruction. Therefore, simulations play a crucial role in this method and are expected to continue doing so as more advanced analysis techniques are being developed, including supervised deep learning of the molecular structure to reconstruct it from the experimental data. I implemented a semi-classical model for such simulation in Julia, building it on top of the DifferentialEquations.jl ecosystem. I will present the model and key properties of its Julia implementation, including - Coupling of continuous (positions and velocities) and discrete (electronic states) degrees of freedom of the atoms through JumpProcesses.jl - Flexible inputs and callbacks - Easy to update code, thanks to its short length (especially compared to the reference C implementation) While introducing the physics is necessary for context, the talk will focus as much as possible on the Julia implementation, also mentioning the challenges encountered, the benefits of relying on a mature ecosystem, and the possible future use for the code developed. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/GJRCSK/ Muschel — N1 Benoît Richard PUBLISH FDVTJJ@@pretalx.com -FDVTJJ RandomSequentialAdsorption.jl - Modeling Adsorbate Packing in Area-Selective Atomic Layer Deposition en en 20260814T154500 20260814T160000 001500 RandomSequentialAdsorption.jl - Modeling Adsorbate Packing in Area-Selective Atomic Layer Deposition ## The scientific background The continuous shrinking of building blocks in modern microchip production has led to steady improvements in material deposition processes. As atomic layer deposition (ALD) offers nearly atomic control over the thickness of the deposited material it has become a common tool within the lithography process. Within ALD, so-called precursors and co-reactants are alternately offered to a surface where they react and result in the desired material deposition. Current research is focusing on improving ALD by constraining the material deposition to a certain area, the so-called growth surface, while preventing deposition on other parts of the surface, the so-called non-growth surface. Consequently, this deposition technique is called area-selective ALD (AS-ALD). The most promising strategy to AS-ALD is to use small molecules, which selectively adsorb only on the non-growth surface and block all other incoming molecules. As material deposition is inhibited by these molecules on the non-growth surface, they are usually termed small molecule inhibitors (SMI). To understand the chemistry of SMIs different modelling approaches spanning density functional theory, molecular dynamics, kinetic Monte-Carlo or random sequential adsorption are used. ## The modeling approach The presented random sequential adsorption (RSA) approach targets to derive realistic SMI packing layers on the non-growth surface. This approach assumes that SMIs are only weakly interacting with each other and their behavior therefore best described by a random adsorption. The adsorption takes place on a grid representing all adsorption sites of the modeled surface. In addition to adsorption events, the present implementation also includes diffusion, rotation and conformer changes of the adsorbates. Here, the implementation follows a simplified kinetic Monte-Carlo as time evolution and chemically motivated rate constants are ignored while the common cycle of generating a list of possible events, selecting the event to execute and updating the event list is maintained. Convenience functions to run and evaluate thousands of RSA runs are provided to easily judge the packing and inhibition efficiency of studied SMIs. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/FDVTJJ/ Muschel — N1 Fabian Pieck PUBLISH KXDFUJ@@pretalx.com -KXDFUJ Modeling optical setups with BeamletOptics.jl en en 20260814T160000 20260814T163000 003000 Modeling optical setups with BeamletOptics.jl Designing optical setups featuring laser sources is a common task in many optical laboratories. The use of digital models for this purpose can allow for easier prototyping before committing to an experimental setup. Commercial and open-source software for this purpose already exists, for instance in Julia the OpticSim.jl and ABCDMatrixOptics.jl packages are referred to. These packages implement classic geometrical optics and matrix optics, respectively. An alternative modeling approach is the complex ray tracing or Gaussian beamlet tracing approach first proposed by J. Arnaud (1968) and later A. Greynolds (1985). This formalism uses a set of geometrical rays to represent the 0th order Gaussian mode (TEM00). By using a classical ray tracing approach, this model of the Gaussian beam can be efficiently propagated through optical systems. More recent improvements of this method have also introduced the ability to model polarization effects and astigmatism. The TEM00 Gaussian mode can also be used to coherently decompose and propagate arbitrary electrical fields. The goal of this package is to implement the mentioned approach with a focus on 3D volume-based optics modelling and easy manipulation of optics position and orientation. Therefore, we have opted for a solids-based geometry representation rather than the more established surface-based modelling approach. Our package features a hybrid sequential-non-sequential tracing solver and SDF-based representation of e.g. spherical and aspherical lenses. This talk will focus on an introduction into the application programming interface (API) of BMO by explaining the structure of the underlying solver (Intersect-Interact-Repeat-Loop), the options for the representation of optical geometries and the optical models for mirrors, lenses, beamsplitters and more that are provided as part of this package. In addition, the extension capabilities for the implementation of custom optical models will be featured. We will talk about the current and future development roadmap for this package and showcase examples for practical uses cases from our research group. PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/KXDFUJ/ Muschel — N1 Hugo Uittenbosch PUBLISH HYQWVR@@pretalx.com -HYQWVR Modelling repulsion beyond determinants — Sampling Pfaffian Point Processes en en 20260814T163000 20260814T164500 001500 Modelling repulsion beyond determinants — Sampling Pfaffian Point Processes While many sampling algorithms have been developed for determinantal point processes, much less is known about sampling from PfPPs. We introduce an exact sampling algorithm for discrete PfPPs based on a skew-symmetric variant of the Cholesky decomposition, as well as a variety of methods for sampling from continuous Pfaffian kernels based on Markov chain Monte Carlo. Pfaffian kernels are typically constructed from skew-orthogonal polynomials (SOPs), so we also introduce a new numerical method for constructing SOPs from arbitrary weight functions based on symplectic Arnoldi iteration. We present a Julia toolbox for Pfaffian point processes with the methods we developed. All of this wouldn't have been possible without Julia's rich ecosystem for numerical linear algebra, computational statistics and automatic differentiation. As such, we were able to reuse existing functionality from and extend packages such as SkewLinearAlgebra.jl, KrylovKit.jl, DynamicHMC.jl, and Mooncake.jl We investigate accuracy, as well as performance, of these methods on concrete examples and give an outlook on how these methods could be further improved upon. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/HYQWVR/ Muschel — N1 Simeon Schaub PUBLISH 7PQKQJ@@pretalx.com -7PQKQJ Neuroblox.jl -- New features and applications en en 20260814T164500 20260814T171500 003000 Neuroblox.jl -- New features and applications PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/7PQKQJ/ Muschel — N1 Mason Protter PUBLISH N7TFF3@@pretalx.com -N7TFF3 Visualizations for modeling and simulation with Makie en en 20260814T100000 20260814T101500 001500 Visualizations for modeling and simulation with Makie Visualization is the final product of most engineering workflows. Julia's ecosystem enables users to create fast, interactive and beautiful visualizations, now easier than ever with coding agents. The aim of this talk is to show folks some strategies and ways to create and think about both animations and "live" dashboards in the engineering context. Much of the focus will be on system simulation, ModelingToolkit,jl and Dyad, but there will be some examples outside of that as well. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/N7TFF3/ Muschel — N2 Anshul Singhvi PUBLISH NAPBCA@@pretalx.com -NAPBCA Modelling Cost-Sustainability Trade-offs in Maritime Logistics: EEDI-Driven Multi-Objective Optimization en en 20260814T101500 20260814T103000 001500 Modelling Cost-Sustainability Trade-offs in Maritime Logistics: EEDI-Driven Multi-Objective Optimization The maritime shipping industry is responsible for approximately 3% of global GHG emissions, and 90% of world trade. The International Maritime Organization (IMO) has established an ambitious strategy targeting a 20% reduction in greenhouse gas (GHG) emissions by 2030, 70% by 2040, and full decarbonisation by 2050, relative to 2008 emission levels . However, by 2023 only a 3.6% reduction had been achieved. This gap motivates the need for optimization frameworks jointly optimizing fuel choices , digitization adoption, regulatory compliance while maintaining cost and emissions feasibility. We present a Julia-based mixed-integer non-linear programming (MINLP) model which optimizes fuel mix, digitization adoption binary variables, EEDI/EEXI constraints and regional assignment variables. The model is formulated as a bi-objective optimization model, minimizing both total systems costs and fleet emissions under given regulatory,demand,fuel and operational constraints.Optimization modelling has been carried out using Julia packages such as JuMP.jl, with Ipopt.jl for non-linear optimization, HiGHS.jl for mixed-integer components and MathOptInterface.jl as the solver interface .Dataframes has been used for data handling, and visualization of Pareto frontiers was carried out using Plots.jl has been used for plotting.A custom implementation of the augmented ε-constraint (AUGMECON) method is used to generate discrete approximations of cost–emissions Pareto frontiers. The talk focuses on Julia-implementation challenges in solving large scale MINLPs, and reproducible modeling workflows. Our work is primarily based on demonstrating the applications of the Julia programming language in the context of decarbonization in the transportation sector, highlighting the use of mathematical computing to solve real-world challenges. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/NAPBCA/ Muschel — N2 Jia Bhanushali PUBLISH HMEGDF@@pretalx.com -HMEGDF Decoding radio time signals with RadioClock.jl en en 20260814T103000 20260814T104500 001500 Decoding radio time signals with RadioClock.jl About 60 km away from the venue of JuliaCon 26, there is an antenna broadcasting the radio signal [DCF77](https://en.wikipedia.org/wiki/DCF77), which is used to synchronize clocks, watches and other time-keeping devices all across Europe. In this talk we well present [`RadioClock.jl`](https://github.com/giordano/RadioClock.jl), a Julia package to encode and decode time signals such as the DCF77 one. We will also demonstrate (with a live demo!) how to build an Arduino-based system to receive the DCF77 radio signal, and decode it with Julia, with a submillisecond accuracy, PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/HMEGDF/ Muschel — N2 Mosè Giordano PUBLISH DPR3VJ@@pretalx.com -DPR3VJ Formal linear combinations in Julia with LinearCombinations.jl en en 20260814T104500 20260814T110000 001500 Formal linear combinations in Julia with LinearCombinations.jl Formal linear combinations (aka "vector spaces with a given basis" or "free modules") appear in many places in (Pure) Mathematics. For example, a polynomial is a formal linear combination of monomials. The package [LinearCombinations.jl](https://github.com/matthias314/LinearCombinations.jl) defines a type `Linear{T,R}` for formal linear combinations of terms of type `T` (arbitrary) with coefficients of type `R` (any commutative ring with unit). The type `DenseLinear{T,R}` automatically translates between linear combinations and coordinate vectors with respect to some chosen basis. Linear and multilinear functions can easily be defined with the macros `@linear` and `@multilinear`. Tensors are also supported, as is the Koszul sign rule in the graded setting. The overall aim of the package is to provide functions that are efficient and easy to use. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/DPR3VJ/ Muschel — N2 Matthias Franz PUBLISH HYN7DE@@pretalx.com -HYN7DE Introducing Contexts.jl: Context- and Role-Oriented Programming for Self-Adaptive Systems en en 20260814T111500 20260814T114500 003000 Introducing Contexts.jl: Context- and Role-Oriented Programming for Self-Adaptive Systems Technical systems, such as power grids and vehicles, grow increasingly complex as they optimize their processes by adapting to both environmental conditions and their internal states. These so-called self-adaptive systems (SAS) rely on software capable of dynamically adjusting their behavior to meet these demands. Context-Oriented Programming (COP) and Role-Oriented Programming (ROP) are programming paradigms designed to simplify the definition of such dynamic behavior. The Julia programming language, with its just-in-time compilation and multiple dispatch, is particularly well-suited for implementing and invoking dynamic behaviors. Furthermore, Julia’s simulation ecosystem, including tools like ModelingToolkit.jl, provides an ideal environment for simulating self-adaptive cyber-physical systems. This makes the implementation of COP and ROP in Julia a valuable contribution to the development of SAS. The Contexts.jl library offers a framework for leveraging these paradigms in Julia. This talk will introduce its structure and key features. The presentation will begin with an introduction to the concepts of COP and ROP, highlighting their role in the development of self-adaptive systems. The second part will focus on the implementation of COP in Contexts.jl, detailing its architecture and the use of Julia’s multiple dispatch and metaprogramming capabilities. A brief example will demonstrate how Contexts.jl allows specifying context-dependent behavior and contextual control mechanisms. The final section will introduce ROP, its implementation as an embedded domain-specific language, and a practical example showcasing its application. This talk will provide attendees with a comprehensive understanding of how COP and ROP paradigms, implemented in Julia, can advance the development and simulation of self-adaptive systems. PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/HYN7DE/ Muschel — N2 Christian Gutsche PUBLISH XT7QD8@@pretalx.com -XT7QD8 Reasoning with Many-Valued, Spatial and Temporal Logics with SOLE en en 20260814T114500 20260814T120000 001500 Reasoning with Many-Valued, Spatial and Temporal Logics with SOLE Many real-world applications make use of temporal and spatial data, and reasoning is among the most important tasks, allowing to solve problems spanning from scheduling, to monitoring, up to predicting future scenarios. However, this data is often characterized by uncertainty and unclear boundaries (e.g., due to sensoring and discretization), challenges usually tackled with the use of fuzzy logics. SoleLogics.jl offers a new submodule, namely ManyValuedLogics, allowing for the treatment of continuous fuzzy logics and finite many-valued logics, definable over their algebraic counterpart up to FLew-algebras. In this talk, we will see through practical examples how we can make use of this new machinery, together with multi-modal logics already offered by SoleLogics.jl to treat spatial and temporal information (e.g., Linear Temporal Logic, Compass Logic, Halpern and Shoham’s Interval Temporal Logic, Lutz and Wolter’s Logic of Topological Relations), to model real world scenarios with more accuracy. Icing on the cake, SoleReasoners.jl is a new package in the SOLE framework offering a reasoning tool, based on analytic tableau technique, to solve satisfiability and validity for many-valued spatial and temporal logics (the first specialized implementation at this level of generality that we know of!), and we will see how we can make use of it when dealing with logics carrying both a many-valued and a multi-modal component. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/XT7QD8/ Muschel — N2 Alberto Paparella PUBLISH F8L7TA@@pretalx.com -F8L7TA Big simulation models suddenly feel very small - with FMI.jl en en 20260814T120000 20260814T121500 001500 Big simulation models suddenly feel very small - with FMI.jl One of the biggest obstacles in the transition from demo application to the task that we actually want to solve is often the dimension of the simulation model. The bigger (and more complex) the system of equations becomes, the less handy it is. To tackle this issue, various modeling tools have been developed for different domains over time, and the multitude of tools has created a new problem: The exchange of models between the tools is not trivial – but definitely necessary! The _Functional Mock-Up Interface_ (FMI) was developed with the aim of eliminating this problem in the field of engineering industry. And because this worked out quite well, other domains beyond engineering adapted the standard. The idea was quite simple: Define an interface, that allows for the creation of simulation models that can be imported and exported by a variety of simulation tools. Models that implement this standard are known as _Functional Mock-Up Units_ (FMUs). So, anyone who works with large simulation models from industry has probably had contact with FMI at one time or another. And it seems only logical to integrate this standard into our favorite programming language. Our open-source journey of _FMI.jl_ started almost exactly 5 years ago with this goal in mind: Blur the boundaries between Julia and FMI. Since then, the core library opened up to many new and interesting application domains. In this talk, we want to give a broad overview over what is possible with FMUs in Julia today – with live programs that fit a single slide each. With the combined power of Julia and FMI, dealing with big simulation models becomes as easy as playing around with small demo systems. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/F8L7TA/ Muschel — N2 Tobias Thummerer PUBLISH 7AEJTQ@@pretalx.com -7AEJTQ StructuredIlluminationMicroscopy.jl en en 20260814T121500 20260814T123000 001500 StructuredIlluminationMicroscopy.jl PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/7AEJTQ/ Muschel — N2 Rainer Heintzmann PUBLISH XYMFMZ@@pretalx.com -XYMFMZ #~ This is a metaline announcing the release of `GoMeta` en en 20260814T124500 20260814T130000 001500 #~ This is a metaline announcing the release of `GoMeta` The primary aim of this talk is to motivate embedding formalized meaning into a Julia file's comments **by example.** The same principles are easily extended to other programming languages or project data in general. These illustrations go hand in hand with the introduction of `GoMeta`. `GoMeta` handles the metadata. However, before it can begin its work, `BLS` reads the file[s], extracts features of interest and records them in a tree-like structure based on the content at hand. The basic building block of the aforementioned structure consists of the `Component`. `Block`s, `Line`s and `Segment`s are all `Component`s at different levels in the hierarchy. The records include where a `Component` starts and ends, its *flavor* [to avoid the term `Type`] such as *code*, *metadata* or *text*, its place in the tree structure and **much, much more**. Next, `GoMeta` absorbs, i.e.: parses and interprets, the metadata stored in the corresponding `Component`s. The result can then be passed to a separate program or plug-in. At this point the question may arise: What would such a program or plug-in possibly use this for? What can actually be gained from embedding formalized metadata within comments? To address this question, before continuing with the technicalities of `GoMeta`, 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 desired, long forgotten poignant example, powerful code snippet, insightful explanatory statement or laboriously tweaked plot related to some task at hand? Adding **meaning** to content can change the game. On top of that, an instrument solving this problem might prove even more invaluable when collaborating in a group sharing a repository of documents and it is also not restricted to Julia files only. 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. Occasionally it could also be handy to swap entire sections of text / code of one file with alternate versions, depending on the circumstances. 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 blocks 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. **`GoMeta`'s own source code, available on `GitHub`, has been processed this way**. Another example is the ability to restrict execution to code blocks pertaining to a particular group only. Similar to `Literate` & Co., segments of code and text can live happily together, weaved into the same 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 **allows exerting precise control over these format's wide ranging capabilities from within the Julia source file** and provides the means to generalize `Literate`'s core idea and more. The concept extends well beyond Julia and **can be applied not only to other programming languages but to all sorts of text documents** such as lectures notes or any number of scripts concerning a project, research or otherwise. 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 block 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 appending additional `~`s to the head of a metablock's first metaline or, alternatively, adding there a digit representing the desired depth within the *metahierarchy*. All this is readily exemplified by a self-explanatory **toy** example. It is contained in the `GoMeta` folder together with **instructions** and **additional tools** revealing some insights into the package's inner workings. The first three lines in the code below form a `Block` of metadata at level 1. The **optional** `{}` following `hide` on line 1 allows the user to **specify conditions** under which `hide` **may** get applied. In this case, a `Block`, say `aBlock`, inheriting from it will be *hidden*, if it has been attributed `:label4` **or** is a *code* `Block` **provided** there is no opposing statement closer to `aBlock` overruling it. Analogously, `:label1` gets assigned to anything which inherits from this first meta `Block`, if it is *text* **and** *containsMeta* **or** is itself *meta*, **provided** there is no other statement closer by, overruling this. ``` #~ hide{ :label4 , isCode } ## This is a comment within a `Block` of meta. ## The above `Line` of meta initiated this `Block` of meta. #~ :label1{ (isText && containsMeta), isMeta } ## This meta `Block` ends here. # This `Line` of text starts a new `Block` of text. # This `Block` is NOT attached to metadata - it does NOT INHERIT metadata. # However, this `Line` will get discarded due to this: #~ discard #~2 :label5 show{ !:label5} ## This is line 9. It is a one-line meta `Block`. using Plots ## This `Line` starts a new `Block` of code. ## This code `Block` is ATTACHED to metadata - it inherits metadata from above. ## Therefore, this code `Block` receives label5. ## `show` from line 9 above does NOT get applied to this `Block` ## as this can only happen ## if label5 has NOT been applied. Note `{!:label5}` following `show`. ## Instead, this code `Block` inherits `hide` from line 1 above ## since this is a code `Block` satisfying the condition `{isCode}` following `hide`. println("!!! NOTE !!! Only Code and Text `Block`s may contain empty lines.") println("\t Whereas an empty line after a meta `Line` starts a new `Block`.") #~3 :label4 discard{:label3} :label3 # This `Block` of text receives label4 # plus label5 from further above # plus label1 since it `isText` AND `containsMeta` [see last statement of this `Block`]. # `discard{:label3}` has NO effect here # since label3 has NOT been applied yet, # it gets added only after `discard{:label3}` has been issued. # Instead, it gets "hidden" due to its label4 and `hide{:label4}` on line 1. # This `Line`, however, will NOT get hidden. #~ show #~2 :label5 ## This one-line meta `Block` is at level 2. ## Thus, this meta `Block` inherits only from the first meta `Block` at the top. md""" This is a `Block` of markdown text. #~ hide """ ``` The alert reader may have noticed that this example alludes to the possibility of a finer grained grammar. For instance, a `Segment` of metadata within a `Line` is applied to the `Segments` preceding it. This also applies within `Block`s which are not attached. However, a more thorough discussion of the matter is beyond the scope of this proposal. More importantly though, `GoMeta` does not execute the instructions inscribed in the metadata. Instead, it provides additional functions and other packages with the means to do so. The source code for `GoMeta` available on `GitHub` has been stripped of all tests and non-essential print statements as well as personal notes and metadata by applying one single, simple function using the output of `GoMeta`. Conversely, these *discarded* entities can easily and selectively be re-integrated if so desired. It is worth pointing out, that the vocabulary of instructions used in the example above has been restricted to a bare minimum for the purpose of illustrating the concept. Due to the **modular design of `GoMeta` it is easily altered, extended and enables future contributors to integrate their own types of metadata**. Moreover, `()` are used for **argument passing**. But again, a more thorough discussion of the matter is beyond the scope of this proposal. In the near future, AI will automate much of the labeling in the background. Crucially, if this black box is confined within a formalized framework of metadata, intermediary steps can be systematically recorded, making the process not only better traceable but allowing for subsequent adjustments, if necessary – potentially enabling the agent to improve over time. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/XYMFMZ/ Muschel — N2 Jerae Sieburgh PUBLISH TXMEAT@@pretalx.com -TXMEAT Let's run Julia everywhere from mobile to web en en 20260814T160000 20260814T161500 001500 Let's run Julia everywhere from mobile to web As shown on the [Supported platforms Julia](https://julialang.org/downloads/support/) page, Julia guarantees “Tier 1” support for common developer platforms such as Windows, macOS, and Linux. This satisfies most users. However, as shown on the [Why We Created Julia](https://julialang.org/blog/2012/02/why-we-created-julia/) page, `We are greedy: we want more`. We would like to run Julia in offline mobile environments such as airplanes, inside web browsers without long startup delays (TTFX), and even on older ARMv7 (32-bit) Raspberry Pi devices. Due to technical constraints, the official Julia runtime is difficult to use in these settings. In particular, platforms like iOS and iPadOS, where JIT compilation is restricted and app review is strict, are especially challenging. To address this, we implemented a virtual machine in Rust that accepts and executes a subset of Julia syntax: https://github.com/AtelierArith/julia-vm-oss Because Rust is designed for systems programming, it supports many platforms that Julia does not directly target. Since the VM does not rely on JIT compilation, it can be deployed as a native iOS and iPadOS application: https://apps.apple.com/us/app/subsetjuliavm/id6757257182 Rust can also be compiled to WebAssembly, allowing the VM to be integrated into browser-based applications: https://terasakisatoshi.github.io/subset_julia/ Actually, the VM itself is largely AI-generated using Claude Code, Codex, and Cursor. Human guidance was used to reference the official Julia implementation and to keep parts written in Julia whenever possible. We also explored transpiling Julia code into Rust. Initial experiments show that it is possible to generate programs such as Mandelbrot set visualizations and distribute them as standalone binaries. In principle, these binaries can run on any platform supported by Rust. Compared with approaches that implicitly depend on `libjulia`, this provides a more portable alternative. This short talk demonstrates these ideas through live demos. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/TXMEAT/ Muschel — N2 terasakisatoshi PUBLISH L7CKA7@@pretalx.com -L7CKA7 Every Bit Counts en en 20260814T161500 20260814T163000 001500 Every Bit Counts PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/L7CKA7/ Muschel — N2 Patrick Häcker PUBLISH URPF3H@@pretalx.com -URPF3H HyperHessians.jl -- Forward mode AD specialized for second order derivatives en en 20260814T164500 20260814T171500 003000 HyperHessians.jl -- Forward mode AD specialized for second order derivatives PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/URPF3H/ Muschel — N2 Kristoffer Carlsson PUBLISH H9MULV@@pretalx.com -H9MULV Optimising Quantum Control Systems: Application to NV Centres en en 20260814T100000 20260814T101500 001500 Optimising Quantum Control Systems: Application to NV Centres Nitrogen-vacancy (NV) centres, and more generally colour centres in diamond, are promising physical platforms for quantum sensing and quantum information processing, owing to the long coherence times of the associated spin degrees of freedom, even at room temperature, and to the ability to initialise and read out spin states optically. The results presented in this talk are grounded in real experimental activity at the Institut Carnot de Bourgogne (ICB, Université Bourgogne Europe), where colour centres in diamond are actively investigated. The minimal but physically meaningful model we consider consists of two coupled spin-1/2 particles — one electron spin and one nuclear spin — with microwave control acting exclusively on the electron spin. After applying the rotating wave approximation, the system reduces to a bilinear control system evolving on SU(4), with a two-dimensional control input constrained to a disc, $u_1^2(t) + u_2^2(t) \leq u^2_{\max}$. A controllability analysis carried out via Lie bracket computations and rank conditions on the Lie algebra generated by the drift and control vector fields reveals that, depending on the hyperfine coupling parameters, not every gate in SU(4) is reachable — a direct consequence of the indirect nature of the nuclear spin control. When the desired target gate lies outside the attainable set, the optimisation is reformulated as fidelity maximisation towards the closest reachable gate. For the evolution times of interest, the dynamics are sufficiently smooth that no specialised exponential integrators are required, and we test several standard numerical integration schemes within the direct transcription framework. The high-level problem modelling, including the specification of dynamics directly in terms of matrix Lie group structure and Kronecker products of complex matrices, is enabled by a new extension to LinearAlgebra within ExaModels.jl developed by the Exanauts team, which retains full compatibility with automatic differentiation. The resulting nonlinear programmes are solved by interior-point methods from the MadSuite (MadNLP.jl), both on CPU and on GPU via CUDSS.jl. The direct transcription solution additionally serves as a warm start for an indirect shooting method obtained by applying the Pontryagin Maximum Principle to the bilinear system on SU(4), allowing the qualitative structure of the optimal control to be captured first and then refined to arbitrary numerical precision. The talk will cover the formulation within OptimalControl.jl, a comparison of direct and indirect approaches, and GPU performance benchmarks. The joint project CONV (Control of NV-centres) between Université Côte d'Azur Math lab and Institut Carnot of Université Bourgogne Europe receives financial support from the CNRS through the MITI interdisciplinary program. J.-B. Caillau is also supported by a FACCTS grant of the France-Chicago center. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/H9MULV/ Muschel — N3 Jean-Baptiste Caillau David Tinoco PUBLISH 7PP38R@@pretalx.com -7PP38R Quantum many-body simulations with PauliStrings.jl en en 20260814T101500 20260814T103000 001500 Quantum many-body simulations with PauliStrings.jl PauliStrings.jl provides a competitive platform for studying quantum many-body dynamics by representing operators as sets of Pauli strings encoded in binary. We have shown that 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. In this talk I will focus on new features of PauliStrings.jl : symbolic calculations and exploitation of translation symmetries. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/7PP38R/ Muschel — N3 Nicolas Loizeau PUBLISH NHJH7G@@pretalx.com -NHJH7G Piccolo.jl 1.x: a unified, agent-enabled quantum control package en en 20260814T103000 20260814T110000 003000 Piccolo.jl 1.x: a unified, agent-enabled quantum control package [Piccolo.jl](https://github.com/harmoniqs/Piccolo.jl) is an open-source framework for quantum optimal control via direct trajectory optimization, developed by [Harmoniqs](https://harmoniqs.ai). **One package to rule them all.** Previously, Piccolo was a meta-package re-exporting QuantumCollocation.jl, PiccoloQuantumObjects.jl, PiccoloPlots.jl, NamedTrajectories.jl, and TrajectoryIndexingUtils.jl. Users had to navigate five repos, five sets of docs, and version compatibility across all of them. For 1.0, we pulled core functionality into Piccolo.jl itself, keeping only truly independent libraries ([NamedTrajectories.jl](https://github.com/harmoniqs/NamedTrajectories.jl), [DirectTrajOpt.jl](https://github.com/harmoniqs/DirectTrajOpt.jl)) as separate packages. The result: `using Piccolo` gives you everything from Hamiltonians to plotting. **Agent-enabled by design.** Julia's single-language stack -- where the high-level API and the performance-critical internals are the same language -- turns out to be a superpower for AI-assisted development. An LLM reading Piccolo source code doesn't need to context-switch between Python glue and C++/Fortran kernels. We leaned into this by shipping structured context files and building reusable agent skills for common quantum control workflows: problem setup, physics references, testing, and demo generation. On the development side, this accelerates feature implementation and performance optimization across the stack. On the user side, coding agents can go from a gate specification to an optimized pulse with minimal human steering -- making quantum optimal control more accessible to experimentalists who think in terms of physics, not software. **Real-world impact.** Piccolo's direct optimal control framework underpins two recent results. First, [Kamen et al.](https://arxiv.org/abs/2602.10349) position robustness as a first-class objective within direct, constrained optimal control, introducing a critical discretization correction to toggling-frame robustness estimators and demonstrating precise, physics-informed robust pulse design. Second, [Hu et al.](https://arxiv.org/abs/2508.19075) use the framework to experimentally demonstrate universal dynamics on Rydberg-atom arrays, synthesizing three-body interactions and topological dynamics under global control constraints. In this talk, we demo the unified package, show how agent skills accelerate research workflows, and discuss what we have learned about designing Julia packages for the age of AI-assisted scientific computing. - [Package](https://github.com/harmoniqs/Piccolo.jl) - [Documentation](https://docs.harmoniqs.co/Piccolo/dev/) PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/NHJH7G/ Muschel — N3 Aaron Trowbridge PUBLISH MJP9RJ@@pretalx.com -MJP9RJ qruise-toolset: differentiable quantum simulation toolbox en en 20260814T111500 20260814T114500 003000 qruise-toolset: differentiable quantum simulation toolbox `qruise-toolset` is a fully differentiable simulation toolbox for quantum simulation and the quantum optimal control problem. It enables fast prototyping and optimisation of the hardware of interest by building a digital twin of the system. The automatic differentiation framework in `qruise-toolset` is provided via LLVM intermediate representation of the quantum simulation problem, which is then ingested by `Enzyme.jl`. This allows the user to benefit from the performance Julia JIT compilation offers and still stick to the convenience that the Python programming language offers. This approach uplifts the requirement of using automatic differentiation packages such as PyTorch, TensorFlow or JAX that are mostly suited for deep learning neural network architectures. PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/MJP9RJ/ Muschel — N3 Yousof Mardoukhi PUBLISH M3HL7P@@pretalx.com -M3HL7P Quantum Hamlets: Distributed Compilation of Large Algorithmic Graph States en en 20260814T114500 20260814T121500 003000 Quantum Hamlets: Distributed Compilation of Large Algorithmic Graph States For people without quantum information science (QIS) background, and mainly interested in graph algorithms, we heuristically address the problem of balanced graph k partitioning with the objective of minimizing the sizes of the maximum matchings between partitions, rather than the number of edges cut. By this metric of minimizing matching sizes, we outperform nearly all existing algorithms for edge minimization k partition on most input graphs. For those with QIS background: We investigate the problem of compiling the generation of graph states to arbitrarily many distributed homogeneous quantum processing units (QPUs). To do so, we provide a protocol we term vertex cover grafting (VCG) for graph state generation, and design a heuristic algorithm we term BURY for the balanced partitioning of the graph state between the QPUs in order to reduce the number of required long-range Bell pairs utilized by VCG. In this effort, we consider the problem of balanced k graph partitioning with the objective of minimizing the sizes of the maximum matchings between partitions, rather than the number of edges cut. We show that our heuristic algorithm, BURY, requires fewer Bell pairs to generate most graph states than state-of-the-art k partition algorithms. Furthermore, we show that BURY reduces the cut-rank of the partitions, demonstrating that the partitioning found by our algorithm is likely to minimize the Bell pair utilization of any distributed graph state generation protocol. Additionally, we discuss how one could straightforwardly apply our methods to the dynamic case where the graph state generation and measurement are performed concurrently. Our study of the balanced minimum maximum matching k-partition problem and the heuristic algorithm we design provides a scalable foundation for reducing quantum network overhead for distributed measurement-based quantum computation (MBQC), as well as any scheme where distributed graph state generation is desired. Furthermore, this talk will attempt to introduce all QIS concepts needed for understanding, assuming the audience has a proper computer science background. Specifically, one goal of this talk is to explain graph states to the subset of the audience that is interested in graph algorithms but may be unaware of graph problems in QIS. We hope this can foster further development of algorithms for graph states. PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/M3HL7P/ Muschel — N3 Anthony Micciche PUBLISH F3RNYU@@pretalx.com -F3RNYU Multivariate Multicycle codes for Complete Single-shot decoding en en 20260814T121500 20260814T123000 001500 Multivariate Multicycle codes for Complete Single-shot decoding The property of single-shot decoding is a crucial requirement for low-overhead error correction and it is one of the hallmarks of fault-tolerant quantum error correction, however very few codes possess this property. The concept of single-shot decoding was recognized as important early in the history of our field [Bombin2015], but significant progress did not happen until recently [Campbell2019], with the introduction of “metachecks”, i.e. “checks on checks” that are solely meant to detect measurement errors in the syndrome itself. Only in 2020 [Quintavalle2020], a universal measure of the “single-shot” capability was well defined, namely “the confinement profile”, which can be used to compare the resilience of a code to measurement errors (the main impediment to single-shot performance). By the dawn of 2026, only a few families of “complete single-shot” QEC codes exist, namely abelian-multicycle codes (AMCs) and 4D homological product codes that include 4D toric and 4D surface codes. The code construction we present changes this by providing a very simple principled technique for generating metachecks and gives us instances of codes with record breaking confinement. Our Multivariate Multicycle codes are CSS codes defined from length-t chain complexes with t ≥ 4. The chief advantage of these codes is that they possess metachecks and high confinement that permit complete single-shot decoding, while also having additional algebraic structure that might enable logical non-Clifford gates. We offer a framework that facilitates the construction of long-length chain complexes through the use of Koszul complex. In particular, obtaining explicit boundary maps (parity check and metacheck matrices) is particularly straightforward in our approach. This simple but very general parameterization of codes permitted us to efficiently perform a numerical search, where we identify several MM code candidates that demonstrate these capabilities at high rates and high code distances. Moreover, many known families of codes can be expressed simply as special cases of the construction we have discovered. To put this into perspective, n-dimensional Toric, AMC, bivariate bicycle, trivariate tricycle, symmetric cyclic hypergraph product (C2), repeated cyclic hypergraph product (CxR), multivariate bicycle, generalized bicycle, abelian two-block group algebra, Haah’s cubic codes, and “square” La-Cross codes are easily recovered as subfamilies of our codes. Examples of new codes with parameters [[n, k, d]] include [[96, 12, 8]], [[96, 44, 4]] [[144, 40, 4]], [[216, 12, 12]], [[360, 30, 6]], [[384, 80, 4]], [[486, 24, 12]], [[486, 66, 9]] and [[648, 60, 9]]. Notably, our codes achieve confinement profiles that surpass all known single-shot decodable quantum CSS codes of practical blocksize. [Bombin2015]: Bombín, H., 2015. Single-shot fault-tolerant quantum error correction. Physical Review X, 5(3), p.031043. [Campbell2019]: Campbell, E.T., 2019. A theory of single-shot error correction for adversarial noise. Quantum Science and Technology, 4(2), p.025006. [Quintavalle2020]: Quintavalle, A.O., Vasmer, M., Roffe, J. and Campbell, E.T., 2021. Single-shot error correction of three-dimensional homological product codes. PRX Quantum, 2(2), p.020340. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/F3RNYU/ Muschel — N3 Feroz Ahmed Mian PUBLISH RN8YTY@@pretalx.com -RN8YTY Automated numerical verification of quantum physics papers using Julia and LLM agents en en 20260814T123000 20260814T124500 001500 Automated numerical verification of quantum physics papers using Julia and LLM agents PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/RN8YTY/ Muschel — N3 Tobias J. Osborne PUBLISH JA8JFE@@pretalx.com -JA8JFE Fast and reliable quantum state tomography in Julia en en 20260814T124500 20260814T130000 001500 Fast and reliable quantum state tomography in Julia In quantum mechanics, the full quantum state is represented by a density matrix. It cannot be directly measured. Only partial information, obtained through different measurement is accessible. Quantum state tomography (QST) reconstructs the complete state from these measurement that yield a measurement statistics. Quantum theory provides predicted statistics for any assumed state, and QST identifies the state whose predicted statistics best match the observed data by minimizing a suitable statistical distance. We present a Julia implementation of a QST pipeline that reconstructs density matrices while ensuring physicality: each density matrix must be positive semi-definite and have unit trace. Our approach minimizes a residual between predicted and measured statistics and supports both least-squares and log-likelihood formulations. Physical constraints are enforced through Cholesky parameterization or projection methods. We benchmark on simulated data several optimization strategies, like projected Gauss–Newton, L-BFGS, and trust-region solvers. The benchmarks evaluate reconstruction accuracy, scaling with the number of qubits, convergence speed, and stability, offering practical guidance for selecting optimizer in QST applications. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/JA8JFE/ Muschel — N3 Fabian Müller PUBLISH NEWC8H@@pretalx.com -NEWC8H Building a composable Julia ecosystem for infectious disease modelling: a roadmap, challenges, and questions en en 20260814T143000 20260814T144500 001500 Building a composable Julia ecosystem for infectious disease modelling: a roadmap, challenges, and questions PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/NEWC8H/ Muschel — N3 Sam Abbott PUBLISH ZUMSFD@@pretalx.com -ZUMSFD Estimating epidemiological delay distributions: from R/Stan to Julia en en 20260814T144500 20260814T150000 001500 Estimating epidemiological delay distributions: from R/Stan to Julia PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/ZUMSFD/ Muschel — N3 Sam Abbott PUBLISH 7VFDJF@@pretalx.com -7VFDJF Signature Tensors in OSCAR en en 20260814T150000 20260814T153000 003000 Signature Tensors in OSCAR Path signatures are fundamental objects in rough path theory and serve as a noncommutative feature that captures the essential geometry of sequential data. Their utility has expanded across diverse fields including mathematical finance, machine learning, or topological data analysis. Recently, a tangible link to algebraic geometry was established through the study of signature varieties associated with specific families of paths. This viewpoint proved particularly useful for studying the problem of learning paths from their signature tensors. For this purpose, a practical and easily extendable package within a modern computer algebra system is required, providing access to multivariate arrays, Lie theory, non-commutative polynomials, Gröbner bases, and other structures. We introduce SignatureTensors.jl, a new package that leverages the symbolic computation capabilities of OSCAR, a modern open source computer algebra system written in Julia. The package provides a general framework for computing and manipulating path signatures using algebraic and symbolic methods while seamlessly interacting with the OSCAR ecosystem. In this talk, we will provide a brief introduction to signatures and their implementation within our package. We present efficient algorithms to compute signatures for (piecewise) polynomial paths. Furthermore, we provide an implementation of the recently introduced two-parameter signature of membranes. The package supports several operations on signatures such as group multiplication, the logarithm, or the geometric group barycenter. A key advantage is that our constructions work over arbitrary OSCAR rings and thus combine with common symbolic computation techniques. We conclude with two illustrative examples of the package in action. First, we present efficient tensor learning arising in rough analysis, where recovering a path from its signature can be formalized by stabilizers with respect to congruence group actions. The second example focuses on understanding the image of the two-parameter signature, when restricted to piecewise bilinear and polynomial membranes. Our long-term goal is for SignatureTensors.jl to become a foundational tool for theoretical research on signature tensors, while providing a flexible base framework for interdisciplinary application, such as time series, image analysis, spatial data, and more. This is a joint work with Leonard Schmitz (TU Berlin) and the code is available at https://github.com/leonardSchmitz/signature-tensors-in-OSCAR PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/7VFDJF/ Muschel — N3 Gabriel Riffo PUBLISH 7YGMC3@@pretalx.com -7YGMC3 PhoXonic.jl: Unified interface for calculating photonic and phononic bandgaps with pure Julia en en 20260814T154500 20260814T160000 001500 PhoXonic.jl: Unified interface for calculating photonic and phononic bandgaps with pure Julia Photonic and phononic crystals are periodic structures that exhibit band gaps—frequency ranges where electromagnetic or elastic waves cannot propagate. These materials enable precise control over light and sound at the wavelength scale, with applications ranging from optical fibers and lasers to acoustic filters and vibration isolation. When a single structure simultaneously exhibits both photonic and phononic band gaps, it is called a phoxonic crystal, enabling coupled optomechanical interactions. Existing tools such as [`MPB`](https://mpb.readthedocs.io/en/latest/) focus on photonic crystals only and require C++/Scheme. [`PhoXonic.jl`](https://github.com/hsugawa8651/PhoXonic.jl) is the first pure Julia tool computing both photonic and phononic dispersion relations using plane wave expansion (PWE). It offers: - **Unified API across 1D, 2D, and 3D**: The same workflow for photonic and phononic crystals—define materials, geometry, and wave type, then compute band structures. - **Multiple solver backends**: Dense eigensolvers for small systems, Krylov methods for large-scale problems, and LOBPCG with warm-start acceleration for efficient band structure sweeps. - **Green's function method and supercell supports**: Density of states (DOS) and local density of states (LDOS) calculations for defect mode analysis. Point and line defect simulations via supercell construction. - **Transfer matrix method**: Exact solutions for 1D multilayer structures, including transmission/reflection spectra, oblique incidence with TE/TM polarization, and support for lossy materials. - **Topological Invariant Analysis**: The ability to compute the 2D Wilson loop spectrum and winding number enables its use as a research tool in topological photonics/phononics. ## Validation / Features / Future Directions The accompanying figure formation of phoxonic bandgap reproducing the paper by [Maldovan & Thomas (2006)](https://doi.org/10.1063/1.2216885). PhoXonic.jl has been validated against: - (Photonic bandgap) [MIT Photonic Bands](https://mpb.readthedocs.io/en/latest/) (MPB) and [textbook examples from Joannopoulos](http://ab-initio.mit.edu/book/). - (Phononic bandgap) Published results from [Kushwaha et al.] (https://doi.org/10.1103/PhysRevLett.71.2022) for phononic crystals - [Tanaka et al.](https://doi.org/10.1103/PhysRevB.62.7387) for phononic crystals with void inclusions - [Dobrzynski et al., "Phononics" textbook](https://doi.org/10.1016/C2015-0-06475-9) (2017, Elsevier, Ch.5) for Si/Epoxy and C/Epoxy phononic crystals (circular and square cross-section inclusions, examples 216--218) This package is open to contributions and designed for extensibility. ## Links - PhoXonic.jl: https://github.com/hsugawa8651/PhoXonic.jl, DOI: 10.5281/zenodo.18055170 - Docs: https://hsugawa8651.github.io/PhoXonic.jl/dev/ - Colab: https://colab.research.google.com/gist/hsugawa8651/6e19b5d1c083e925aa1642a2fab6f0fc/colab_demo.ipynb PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/7YGMC3/ Muschel — N3 Hiroharu Sugawara PUBLISH NMJBP9@@pretalx.com -NMJBP9 Microstructure Simulation in Pure Julia: Phase Fields with CALPHAD Coupling en en 20260814T160000 20260814T161500 001500 Microstructure Simulation in Pure Julia: Phase Fields with CALPHAD Coupling Understanding and predicting the internal structure of materials at the microscale (microstructure) is essential in materials science and engineering. The arrangement of different phases and their interfaces determines key material properties including mechanical strength and thermal conductivity. The phase field method simulates microstructure evolution during solidification and phase separation. It represents different phases (e.g., solid and liquid, matrix and precipitates) using a continuous field variable `phi` that varies smoothly across interfaces, avoiding explicit interface tracking. The value `phi = 1` represents the solid phase and `phi = 0` represents the liquid phase, with a diffuse interface region in between. The driving force of the field variable `phi` is based on the thermodynamic principle of Gibbs free energy minimization. In the Allen-Cahn model (interface motion) it drives the order parameter `phi`, while in the Cahn-Hilliard model (phase separation) it drives the composition `c`. We present how automatic differentiation with Julia is effectively utilized in phase field simulations. The accompanying figure shows 2D spinodal decomposition simulated by the Cahn-Hilliard equation. The color map represents the local composition `c` (mole fraction of component B in a binary A-B system). Starting from a nearly uniform mixture (left, `c` = 0.5 with small fluctuations), the system spontaneously separates into two coexisting phases: an A-rich phase (`c` = 0.3, blue) and a B-rich phase (`c` = 0.7, red). This phase separation is driven by a double-well free energy whose two minima correspond to the equilibrium compositions of the coexisting phases. The simulation uses `OrdinaryDiffEq.jl` for time integration via the unified `PhaseFields.solve` API. We have developed two pure Julia packages for phase field simulation. The first package [`PhaseFields.jl`](https://github.com/hsugawa8651/PhaseFields.jl) implements a framework for multiple phase field models. Each phase field model defines a set of equations governing the field variable `phi` and the associated physical fields such as concentration and temperature. These equations are spatially discretized using the built-in FDM or FEM (via `Gridap.jl`). Then, time evolution is solved using `DifferentialEquations.jl`, applying an appropriate time stepping method as needed. The second package, [`OpenCALPHAD.jl`](https://github.com/hsugawa8651/OpenCALPHAD.jl), predicts phase diagrams mapping the thermodynamically stable phases of materials as functions of temperature, pressure, and composition. It also evaluates Gibbs free energy from thermodynamic databases described in TDB format or as pure Julia functions. The driving force of the field variable `phi` is directly evaluated through automatic differentiation, eliminating the need for symbolic differentiation and hand-coded derivatives. Two packages integrate seamlessly with the Julia ecosystem, including `Plots.jl` for visualization of phase diagrams and phase field simulations. We attach [a Google Colab notebook](https://colab.research.google.com/gist/hsugawa8651/483b77d1526ee9a5fe370db159192275/colab_demo_ocpf.ipynb) that highlights several features of the two packages including Ag-Cu binary phase diagram (CALPHAD), Allen-Cahn 1D interface migration, 2D spinodal decomposition (Cahn-Hilliard), and the Stefan problem (thermal solidification). ## Validation / Features / Future Directions `OpenCALPHAD.jl` is a pure Julia port of openCALPHAD, an open-source CALPHAD software package developed by Bo Sundman, a co-developer of Thermo-Calc and one of the pioneers of computational thermodynamics. `OpenCALPHAD.jl` has been validated for binary phase diagram calculations against the reference Fortran implementation openCALPHAD v6.100, demonstrating numerical agreement within 0.02% for phase boundaries. `PhaseFields.jl` was validated by its ability to reproduce results from significant papers in this field including the Stefan problem (thermal solidification). CALPHAD-coupled phase field simulation has been demonstrated in 1D (Allen-Cahn with Ag-Cu driving force from TDB database via automatic differentiation). Extension to 2D CALPHAD-coupled Cahn-Hilliard (spinodal decomposition with real alloy thermodynamics) is in progress. The `CahnHilliardProblem` interface accepts any custom free energy function via duck typing, making it straightforward to plug in CALPHAD Gibbs energy as the driving force. We plan to implement the Kim-Kim-Suzuki (KKS) model, which resolves the driving force scaling mismatch between CALPHAD thermodynamics and the phase field double-well barrier by separating the concentration into phase-specific values at the interface. Since `OpenCALPHAD.jl` already provides ForwardDiff-compatible Gibbs energy functions, the chemical potentials required by the KKS equal-potential condition can be obtained directly via automatic differentiation. Both packages are freely available for academic and commercial use. They are designed with educational use in mind, featuring readable code that closely follows the mathematical formulation of the underlying theory. This makes them suitable for teaching computational thermodynamics and for researchers who wish to understand or extend the underlying algorithms. We aim to expand the range of material systems and phase field models that can be handled by both packages. Both packages are open to contributions and designed for extensibility. Contributions are welcome. ## Links - PhaseFields.jl: https://github.com/hsugawa8651/PhaseFields.jl, https://hsugawa8651.github.io/PhaseFields.jl - OpenCALPHAD.jl: https://github.com/hsugawa8651/OpenCALPHAD.jl, https://hsugawa8651.github.io/OpenCALPHAD.jl - Colab: https://colab.research.google.com/gist/hsugawa8651/483b77d1526ee9a5fe370db159192275/colab_demo_ocpf.ipynb PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/NMJBP9/ Muschel — N3 Hiroharu Sugawara PUBLISH 3MV3BW@@pretalx.com -3MV3BW KAPseudospectra.jl: GPU-Accelerated Pseudospectra via KernelAbstractions.jl en en 20260814T161500 20260814T163000 001500 KAPseudospectra.jl: GPU-Accelerated Pseudospectra via KernelAbstractions.jl PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/3MV3BW/ Muschel — N3 Dan Folescu PUBLISH 738AXH@@pretalx.com -738AXH Optimal Control of a Field Generator using JuMP.jl and IPOPT.jl en en 20260814T163000 20260814T164500 001500 Optimal Control of a Field Generator using JuMP.jl and IPOPT.jl This talk details the implementation of a constrained nonlinear optimization framework for controlling soft iron core magnetic field generators. Unlike linear air-core systems, these generators exhibit complex current-to-field relationships, necessitating robust nonlinear programming techniques. The control objective of minimizing power consumption subject to dynamic field constraints is formulated as a nonlinear algebraic problem within [JuMP.jl](https://github.com/jump-dev/JuMP.jl). Key technical aspects include: - Symbolic-Numeric Representation: Magnetic fields are represented using truncated spherical harmonic expansions (implemented via [SphericalHarmonicExpansions.jl](https://github.com/IBIResearch/SphericalHarmonicExpansions.jl) and [DynamicPolynomials.jl](https://github.com/JuliaAlgebra/DynamicPolynomials.jl)), providing polynomial field representations that satisfy the quasi-static Maxwell equations. - Nonlinear Constraint Algebra: Strict feasibility is enforced through hardware constraints, algebraic constraints on the magnetic field vector (polynomial inequalities), as well as constraints on the smallest singular value of the field Jacobian (ensuring gradient strength for spatial encoding), registered as user-defined nonlinear functions in JuMP. - Interior Point Solution: [IPOPT.jl](https://github.com/jump-dev/Ipopt.jl) solves the resulting Karush-Kuhn-Tucker (KKT) system, leveraging barrier methods to handle the bound and inequality constraints inherent to hardware current limits. Although neural networks ([Flux.jl](https://github.com/FluxML/Flux.jl)) provide the forward model surrogate for field coefficient prediction, the focus remains on the algebraic structure of the optimization problem and the numerical methods employed to solve it. The framework demonstrates how Julia’s algebraic modeling ecosystem enables real-time optimal control, achieving precise field generation with minimal power consumption. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/738AXH/ Muschel — N3 Philip Suskin PUBLISH AMFLYU@@pretalx.com -AMFLYU Composable probabilistic models can lower barriers to rigorous infectious disease modelling en en 20260814T164500 20260814T170000 001500 Composable probabilistic models can lower barriers to rigorous infectious disease modelling PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/AMFLYU/ Muschel — N3 Sam Abbott PUBLISH GQ8NM3@@pretalx.com -GQ8NM3 Zed support for Julia en en 20260814T170000 20260814T171500 001500 Zed support for Julia Zed is the hot new Rust-based editor in town that's fast and open soruce. We'll go over the basic architecture of Zed and its extension ecosystem, and tour through important working and missing items including * Debugger support * Test item runner integration * REPL integration * Notebook integration * Revise.jl integration * Profiler charts * Plotting support PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/GQ8NM3/ Muschel — N3 Miguel Raz Guzmán Macedo PUBLISH YNFSLT@@pretalx.com -YNFSLT How We Made Julia Make Microchips en en 20260814T100000 20260814T103000 003000 How We Made Julia Make Microchips Control algorithms inside a lithography system must satisfy demanding timing constraints. They are mathematically nontrivial, involve real‑time data flows, and are executed on machines that simply cannot miss a deadline. Bringing Julia into this environment required us to think carefully about compilation pipelines, memory behavior, determinism, integration boundaries, and observability. In this talk we will discuss: * **Our general approach to time‑critical Julia algorithms** How we design the algorithmic code, how we structure the surrounding Julia modules, and how we ensure that the core logic can be analyzed, tested, and optimized independently of the machine. * **Bridging production and testing environments** How we co‑develop algorithms in simulation and on‑machine setups, what kinds of differences matter, and how we keep Julia code consistent across both. * **Compilation and deployment challenges** A practical look at our experience with PackageCompiler and JuliaC, including: * latency considerations * binary portability * ABI boundaries * linking against a larger C/C++ ecosystem We will share the pitfalls that surprised us the most—especially those specific to embedding Julia in a non‑Julia control stack. * **What worked extraordinarily well** Where Julia exceeded our expectations in performance, productivity, or reliability, and which language features made the biggest difference. * **What to watch out for when bringing Julia to production** Realistic expectations, dos and don’ts, and general advice for teams embedding Julia into industrial systems. Our goal is to give the Julia community a realistic, experience-based look at using Julia for production-grade, time‑critical applications. We hope this will help others who are considering Julia for high‑performance or industrial workloads. PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/YNFSLT/ Alte Mensa — Audi Max Yury Nuzhdin Jorge Alberto Vieyra Salas PUBLISH TQMXFF@@pretalx.com -TQMXFF Five years of bringing Julia into industry en en 20260814T111500 20260814T113000 001500 Five years of bringing Julia into industry I have worked on a variety of different projects for several different customers, usually with a strong mathematical flavor to them. My first Julia experience was a challenging one. It seemed like a straightforward assignment but it quickly escalated beyond what I expected. I ended up maintaining several Julia packages in a closed-off ecosystem with a variety of users and supporting the rollout of Julia within the customer way of working. After this project ended I tried to get a few other Julia projects of the ground but it has been challenging so far to say the least. Never the less there has been an interest in learning Julia by some of my colleagues and it inspired me to setup a Julia course within my company. I want to share with you my experiences so far in using Julia in a professional setting. I have gathered some opinions from my a number of different colleagues, which have not always had a positive experience with Julia. I aim to provide an honest and practical picture of how Julia is received in a professional setting and to offer ideas for others trying to grow Julia adoption in their own settings. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/TQMXFF/ Alte Mensa — Audi Max Tom Lemmens PUBLISH CXRHSP@@pretalx.com -CXRHSP Building Production Desktop GUIs in Julia at NASA with Dear ImGui and Mirage.jl en en 20260814T113000 20260814T114500 001500 Building Production Desktop GUIs in Julia at NASA with Dear ImGui and Mirage.jl When our team needed an interactive planning tool for lunar surface missions, we started with what seemed like the obvious approach: a React web frontend backed by a Julia server. It worked, technically, but the developer experience was painful. Every piece of data had to be serialized over HTTP. UI bugs could live in JavaScript, Julia, or the communication layer between them. Adding a feature meant touching two codebases in two languages, as well as maintaining state in two different places using two different metaphors. Not to mention trying to do custom 2D / 3D rendering meant mixing React and HTML5 Canvas. For a small team, the overhead was eating us alive. So we tried something different: build the whole thing in Julia. The result is a standalone desktop application for planning rover routes on the lunar south pole. The GUI renders terrain maps with sun illumination overlays, lets users place and adjust waypoints, and visualizes time-varying data like solar exposure and communications windows. One language, one process, no server. The stack has two pieces: Dear ImGui (via CImGui.jl) handles all the UI: windows, sliders, buttons, menus, tables. It's an immediate-mode library, which means every frame your code says "draw a button here, a slider there," and ImGui handles interaction. If your state changes, the UI reflects it next frame. No widget trees, no callbacks, no syncing. This is a good match for scientific tools where the interface evolves constantly. Mirage.jl handles rendering. I wrote it because the available Julia OpenGL wrappers were too low-level for rapid prototyping. The API feels like HTML5 Canvas2D: draw_image(), fill_rect(), draw_circle(). It manages shaders and vertex buffers internally so you don't have to. I later added 3D mesh rendering following the same minimal, immediate-mode philosophy. The immediate-mode approach has a real benefit beyond simplicity: there's no retained state to go stale. Your render function is a pure function of your current application state, and your current application state are simply Julia variables. When we needed a new overlay or visualization, it was usually just a few draw calls in the right place, not a new component wired into a framework. But the biggest accelerator was the REPL workflow. Start the GUI from the Julia REPL, use it, close the window, change some code, reopen it. All application state persists in the session. This turns GUI development into the same fast iteration loop Julia developers already use for everything else, and it's something you really can't get with compiled GUI frameworks. It brings the fast-paced iteration of the web ecosystem (like React) into Julia. This stack is general-purpose. Any application that puts an interactive visual frontend on Julia computation could work this way: instrument control panels, geospatial viewers, simulation monitors, data exploration tools. The patterns are the same regardless of domain. In this talk I'll cover: - Why we moved away from a React/Julia split architecture and what we gained - How Dear ImGui and OpenGL compose into an application framework in Julia - How Mirage.jl maps Canvas2D-style calls to OpenGL - A live demo of the tools in action - Practical patterns for structuring a Julia GUI app, and the rough edges to watch for No graphics programming experience needed. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/CXRHSP/ Alte Mensa — Audi Max Zach Booth PUBLISH JNATTB@@pretalx.com -JNATTB Building a quantum control startup on Julia: Piccolo.jl, compiled sysimages, and AI agents en en 20260814T114500 20260814T120000 001500 Building a quantum control startup on Julia: Piccolo.jl, compiled sysimages, and AI agents [Harmoniqs](https://harmoniqs.ai) builds control software infrastructure for quantum computing. Our entire stack is Julia, from the open-source [Piccolo.jl](https://github.com/harmoniqs/Piccolo.jl) framework for quantum optimal control to Piccolissimo.jl, a private extension providing specialized integrators, operators, and constraints for production workloads. **Why Julia for a startup?** The conventional wisdom says startups should use Python for speed-to-market and C++ for speed-to-solution. Julia gives us both. The same code a researcher writes to prototype a new integrator is the code that ships to customers. No rewrite step, no glue layer, no second language. For a small team, this is existential -- we cannot afford to maintain two codebases. **Compiled delivery without source exposure.** Julia is traditionally distributed as source, which is a problem when your code contains trade secrets. We have developed a compilation pipeline that delivers Piccolissimo as prebuilt sysimages -- protecting proprietary code while giving customers instant startup and zero compilation wait. We will discuss the challenges and tradeoffs of shipping Julia as a compiled product. **HPC and GPU deployment.** Piccolissimo runs on HPC resources including GPU clusters, leveraging Julia's native GPU and parallelism ecosystem. The same single-language advantage applies here: the control code, the numerics, and the GPU kernels are all Julia -- no CUDA C++ side-channel to maintain. **AI agents as force multipliers.** A single-language codebase turns out to be a gift for AI coding agents. An LLM can read the entire stack without context-switching between languages. We ship structured context files and have built reusable agent skills for common workflows -- problem setup, physics references, testing, demo generation. These agents now accelerate both internal development (new features, performance tuning) and user workflows (going from a gate specification to an optimized pulse conversationally). For a small team competing with well-funded incumbents, this is a genuine competitive advantage. **Open core, open science.** Piccolo.jl remains fully open source and has been used in peer-reviewed research on robust quantum control ([Kamen et al., arXiv:2602.10349](https://arxiv.org/abs/2602.10349)) and experimental demonstrations of universal dynamics on Rydberg-atom arrays ([Hu et al., arXiv:2508.19075](https://arxiv.org/abs/2508.19075)). Piccolissimo extends this with production-grade integrators and compiled delivery, but the science stays open. In this talk, we share what we have learned building a quantum startup on Julia -- the wins, the workarounds, and why we would do it again. - [Harmoniqs](https://harmoniqs.ai) - [Piccolo.jl](https://github.com/harmoniqs/Piccolo.jl) - [Documentation](https://docs.harmoniqs.co/Piccolo/dev/) PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/JNATTB/ Alte Mensa — Audi Max Aaron Trowbridge PUBLISH TVG9AR@@pretalx.com -TVG9AR BI Engine in Julia en en 20260814T120000 20260814T121500 001500 BI Engine in Julia This talk presents JADE (Julia Analytics Decision Engine), a production system serving a wide variety of companies, that resolves BI development tension through rapid model development alongside dynamic Julia package generation, intelligent precompilation, and cache-first architecture. Key Takeaways: Attendees will learn proven patterns for dynamic Julia package generation, effective precompilation strategies, cache architecture designs, and practical advice for deploying Julia in enterprise environments. This talk provides evidence that Julia can power mission-critical business systems with production-grade reliability. Target Audience: Enterprise developers, performance engineers, code generation system builders, and organizations evaluating Julia for production analytics. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/TVG9AR/ Alte Mensa — Audi Max Matthew Muyres / Chase Cowart PUBLISH ARE8YL@@pretalx.com -ARE8YL Evolution and Application of Model-Based Design in Boeing Vertical Lift Vehicle Management Systems en en 20260814T121500 20260814T123000 001500 Evolution and Application of Model-Based Design in Boeing Vertical Lift Vehicle Management Systems PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/ARE8YL/ Alte Mensa — Audi Max Matt Yu Fernando Dones PUBLISH BR3CQM@@pretalx.com -BR3CQM Bringing Scientific Machine Learning to Industrial Digital Twins with Dyad and Ansys TwinAI en en 20260814T123000 20260814T124500 001500 Bringing Scientific Machine Learning to Industrial Digital Twins with Dyad and Ansys TwinAI Digital twins are increasingly expected to do more than replicate system behaviour—they must adapt to new data, improve over time, and remain trustworthy for engineering decision-making. Achieving this requires combining the predictive power of artificial intelligence with the robustness and explainability of physics-based models. In this session, we will introduce Ansys, now part of Synopsys, and provide a brief overview of Ansys TwinAI™, artificial intelligence-powered digital twin software designed to support validation, operation, and deployment of digital twins in cloud environments. We will then discuss the recently announced collaboration between Synopsys and JuliaHub to integrate Dyad, JuliaHub's next-generation simulation platform, into TwinAI. The core of the talk will focus on why bringing Julia and Dyad into the TwinAI ecosystem matters. Dyad combines component-based acausal modelling, automatic equation generation, Scientific Machine Learning (SciML), and differentiable programming, enabling the creation of hybrid digital twins that blend first-principles physics with data-driven learning. These capabilities create opportunities to improve model fidelity, accelerate model development, and continuously update digital twins as operational data becomes available. The session will provide a high-level overview of representative use cases, including: Adaptive asset monitoring and predictive maintenance, where physics-based models are enhanced using operational data to improve forecasting accuracy and fault detection. Engineering system optimisation and calibration, where differentiable models and SciML techniques enable efficient tuning of digital twins against measured data while preserving physical consistency. Attendees will gain an understanding of the strategic vision behind the TwinAI–Dyad integration, the role that Julia and SciML can play in next-generation digital twins, and how engineers can benefit from hybrid approaches that bridge simulation and real-world operation. This talk is intended for both Julia users interested in industrial deployment of SciML and engineers exploring the future of AI-powered digital twins. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/BR3CQM/ Alte Mensa — Audi Max Edward Carman PUBLISH RKVDD9@@pretalx.com -RKVDD9 From Design to Orbit: Julia-Powered GNC for GEO Satellites en en 20260814T124500 20260814T130000 001500 From Design to Orbit: Julia-Powered GNC for GEO Satellites Julia can be used for: - The plant and "truth" models for orbital and attitude dynamics - The GNC flight software module itself - The integrated simulation and requirement verification framework - The Monte Carlo engine (multi-process, multi-machine) - The driver for hardware-in-the-loop (HIL) testing PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/RKVDD9/ Alte Mensa — Audi Max Nik Descher PUBLISH TVKAZB@@pretalx.com -TVKAZB Dagger.jl Birds of a Feather en en 20260814T143000 20260814T153000 010000 Dagger.jl Birds of a Feather 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 2026. 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 2026, 2027, and beyond! We'll also cover some of the new features and benchmarks of Dagger so you can see what new things have dropped since 2025. We welcome past and current users of Dagger, and also those just interested in sitting in to learn more about Dagger. PUBLIC CONFIRMED Birds of Feather (BoF) https://pretalx.com/juliacon-2026/talk/TVKAZB/ Alte Mensa — Audi Max Julian P Samaroo Felipe Tomé PUBLISH EHEXV3@@pretalx.com -EHEXV3 Birds of a Feather: Julia for Biology en en 20260814T154500 20260814T164500 010000 Birds of a Feather: Julia for Biology Julia is especially well suited for computational biology, and BioJulia was one of the earliest Julia organizations. Due to the decentralized and ad hoc nature of Julia communities, we rarely have a chance to reflect and take stock of how the organization is doing, and whether we are serving our users and our own research needs to the best of our ability. In this Birds of Feather, we want to hear from users and developers about how and why they use Julia for computational biology, or what problems prevent them from doing so. We welcome feedback on the BioJulia organization, the ecosystem of Julia for computational biology, and the state of relevant packages. Although no one has the authority to delegate developer efforts, we encourage discussion about whether our collective programming effort is well spent, and how BioJulia and other Julia organizations can improve to better serve our users. This discussion is for everyone interested in Julia for computational biology; whether you are a BioJulia developer, a Julia developer in another field interested in biology, or someone interested in what Julia can bring to biology. PUBLIC CONFIRMED Birds of Feather (BoF) https://pretalx.com/juliacon-2026/talk/EHEXV3/ Alte Mensa — Audi Max Jakob Nybo Andersen PUBLISH 3KTAGM@@pretalx.com -3KTAGM Scalable Bayesian Spatial Modeling in Julia with GMRFs and INLA en en 20260814T164500 20260814T171500 003000 Scalable Bayesian Spatial Modeling in Julia with GMRFs and INLA Bayesian spatial modeling underpins research across epidemiology, ecology, climate science, and the social sciences. The dominant tool for this is R-INLA, an R package implementing Integrated Nested Laplace Approximation for fast approximate Bayesian inference in latent Gaussian models. Despite its success, R-INLA effectively locks researchers into the R ecosystem - there has been no equivalent in Julia or Python. This talk presents two packages that together bring this capability to Julia: **GaussianMarkovRandomFields.jl** provides the sparse precision foundation. It constructs Gaussian Markov random fields e.g. via finite element discretizations of stochastic partial differential equations (SPDEs), turning dense covariance matrices into sparse precision matrices that scale to large-scale inference problems. The package supports multiple solver backends via LinearSolve.jl, autodiff support, and integrates with Ferrite.jl for finite element assembly. **IntegratedNestedLaplace.jl** (in development) implements the full INLA methodology on top of this foundation: Gaussian approximation of the latent posterior, grid-based hyperparameter exploration with numerical integration, and Laplace-corrected marginals for the latent field, all in a formula-based interface familiar to R users. The talk will walk through the ecosystem from theory to practice, culminating in a live demonstration of a complete nontrivial spatial analysis: specifying the model via a formula, fitting with INLA, and visualizing the results - all in Julia. PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/3KTAGM/ Alte Mensa — Audi Max Tim Weiland PUBLISH TGC3ZM@@pretalx.com -TGC3ZM How implementing a differentiable model for Electron Microscopy (EPMA) accelerated the forward simulation en en 20260814T100000 20260814T101500 001500 How implementing a differentiable model for Electron Microscopy (EPMA) accelerated the forward simulation PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/TGC3ZM/ Alte Mensa — Atrium Maximum Tamme Claus PUBLISH YCXBKT@@pretalx.com -YCXBKT FluxOptics.jl: A Composable Framework for Optical Inverse Design in Julia en en 20260814T101500 20260814T103000 001500 FluxOptics.jl: A Composable Framework for Optical Inverse Design in Julia ## Context: optical systems and inverse design The laws of optics are expressed as a set of partial differential equations (PDEs) known as Maxwell's equations. Finite difference and finite element methods are the standard and most accurate methods to solve rigorously such equations at the nanoscale level, but are intractable to describe large optical systems made of traditional elements such as lenses, mirrors and spatial light modulators. Instead, some simplifying assumptions are commonly made to transform the original PDEs into simpler equations that can often be solved efficiently using Fourier methods, while remaining accurate enough for a large number of applications. An optical system can naturally be described as a cascade of optical elements through which light propagates. Recent work has drawn analogies with neural networks, employing the term Diffractive Optical Neural Networks (DONNs), where optical components act as trainable weights and physical propagation models replace traditional convolutions or matrix multiplications. This vision has led to using machine learning frameworks such as Tensorflow, Pytorch and more recently JAX, to optimize optical systems for specific functions like beam shaping and mode multiplexing, with applications ranging from telecommunications to optical computing. ## FluxOptics.jl architecture [FluxOptics.jl](https://github.com/anscoil/FluxOptics.jl) brings this composable approach to Julia with an architecture that allows selecting the trade-off between fast prototyping and performance when developing a new differentiable optical component. A key challenge in inverse design problems is memory management during the forward pass and gradient computation. One can easily achieve fast prototyping of differentiable programming in Julia by writing pure functions and using Zygote.jl. However, this often limits the performance of the forward model which could benefit from in-place mutable operations, and also leads to dynamic memory allocation which triggers the garbage collector and slows down the computation. To achieve the best efficiency, FluxOptics.jl implements algorithmic differentiation through manual gradient rules defined by extending an interface that leverages ChainRulesCore.jl. This enables controlled buffer management and reuse of intermediate computations during backpropagation. The framework distinguishes between `Pure` components for rapid prototyping using automatic differentiation and `Custom` components for production-level optimization where developers write efficient forward and backward passes with fine-grained control over memory allocation, while still relying on Zygote.jl for composing gradients across the system. Components can be marked `Static` for fixed geometry or `Trainable` for optimizable parameters. The `FieldProbe` component captures intermediate field states, and makes them accessible at the system output through a dictionary, which is useful for multi-objective optimization or visualization. Adjacent non-trainable components with compatible types can be automatically merged for efficiency, such as consecutive phase masks or propagation steps. The framework integrates naturally with Optimisers.jl and extends it with proximal operators for constrained optimization including Total-Variation regularization, sparsity-inducing penalties (Iterative Shrinkage-Thresholding Algorithm and its accelerated variant FISTA), and box constraints. ## Performance and validation To enable honest comparison with the Python ecosystem, [JaxOptics](https://github.com/anscoil/jaxoptics) was developed as a minimal JAX reimplementation covering the core free-space propagation methods and phase modulation. Preliminary benchmarks show better performance on isolated propagation tasks, while JAX's XLA compiler can show a slight advantage on certain optimization workflows. However, Julia's key strength lies in memory efficiency and the ability to handle larger problems. The framework has been published in JOSS and demonstrates its capabilities through real research applications including field retrieval, waveguide tomography, multimode intensity shaping, and 45-mode Hermite-Gaussian mode sorting. This talk presents FluxOptics.jl's architecture and demonstrates design patterns for composable differentiable systems that could extend to other domains of computational physics beyond optics. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/YCXBKT/ Alte Mensa — Atrium Maximum Nicolas Barré PUBLISH GFVKR3@@pretalx.com -GFVKR3 Automatic and fixed-point differentiation in tensor network algorithms en en 20260814T103000 20260814T110000 003000 Automatic and fixed-point differentiation in tensor network algorithms In recent years, AD-based optimization for tensor networks has become more popular. Using AD in these cases requires support for complex numbers, differentiation through linear algebra factorizations, and other features that are often not at the core of "traditional" AD frameworks such as JAX or PyTorch. For these reasons, the flexibility and extensibility of Julia's next generation AD tooling allows us to explore the use of AD in large scale simulation of quantum systems. In this talk we will discuss some of the challenges we have encountered integrating AD into the TN workflow, such as supporting rules for truncated SVD for complex double valued matrices, and some of the innovative techniques that AD allows us to explore, such as the ongoing research into the optimization of tensor network states based on performing AD around a fixed point of an operator. PUBLIC CONFIRMED Long talk https://pretalx.com/juliacon-2026/talk/GFVKR3/ Alte Mensa — Atrium Maximum Katharine Hyatt Lukas Devos PUBLISH EGUEJP@@pretalx.com -EGUEJP Differentiable Climate Modeling: Calibrating SpeedyWeather with Enzyme en en 20260814T111500 20260814T113000 001500 Differentiable Climate Modeling: Calibrating SpeedyWeather with Enzyme Climate models simulate many atmospheric processes such as radiation, convection, clouds, and turbulent fluxes. As these processes are not explicitly resolved, they are represented through so-called parameterizations, which fit hundreds of parameters. Traditionally, tuning these parameters is a manual, expert-driven process guided by physical intuition and iterative experimentation given the computational cost of climate models. In this talk, we present a different approach: With automatic differentiation via Enzyme.jl we calibrate the parameters in SpeedyWeather.jl towards the observed Earth’s global energy budget. We differentiate individual timesteps in reverse mode but batch to stabilise gradients across the chaotic weather time scales. Given a target energy budget, we train on data that is continuously simulated and therefore allow slow processes to adapt despite single timestep gradients, which bypasses the need for checkpointing. Exact gradients are computed of physical diagnostics, such as top-of-atmosphere radiation and surface fluxes, with respect to model parameters that we chose for tuning. Our work focuses on the shortwave radiation, including cloud and surface albedos as the primary source of energy in the Earth system. Enzyme propagates the loss back through the full atmospheric physics, including radiative transfer and surface processes. We use Julia's optimization ecosystem for systematic calibration. SpeedyWeather is a large code base with parameters placed in most branches of large nested structs. For this we implemented a parameter handling scheme that allows convenient parameter updates and model reconstruction despite a missing central model configuration interface. The result is not only improved agreement with observed energy balance, but a reproducible and extensible workflow for parameter optimization in Earth system models. Beyond climate science, this work demonstrates how Julia enables new paradigms for scientific model development leveraging automatic differentiation for objective calibration. Authors: Niklas Viebig (1,2), Milan Klöwer (1), Maximilian Gelbrecht (3,4) , Brian Groenke (3), Gregory Munday (1) 1. University of Oxford, UK 2. ETH Zürich, Switzerland 3. Potsdam Institute for Climate Impact Research, Germany 4. Technical University of Munich, Germany PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/EGUEJP/ Alte Mensa — Atrium Maximum Niklas Viebig Milan Klöwer Maximilian Gelbrecht Greg Munday Brian Groenke PUBLISH KKHD78@@pretalx.com -KKHD78 Differentiating Functional Mock-up Units (FMUs) with Enzyme: Fast AD for Black-Box Simulation Models en en 20260814T113000 20260814T114500 001500 Differentiating Functional Mock-up Units (FMUs) with Enzyme: Fast AD for Black-Box Simulation Models The Functional Mock-up Interface standard (FMI) is widely used for the exchange of dynamical system models, particularly in industry. Computing derivatives of these models is relevant for a variety of use-cases, including optimization, control, and building hybrid models that combine physics-based simulations with machine learning. The Julia ecosystem is already uniquely positioned in this space. Packages such as FMISensitivity.jl and FMIFlux.jl enable computation of various derivatives, for example with respect to solutions, even through discontinuities. This makes Julia the only currently viable platform for working with FMUs in a differentiable programming context. However, FMUs are generally distributed as black-box binaries, which makes them inaccessible to traditional automatic differentiation tools. The FMI standard does include some built-in mechanisms for providing derivatives. But these are limited: they do not cover all the kinds of derivatives one might want to compute (such as derivatives with respect to discontinuities or time). Often they are realized through finite differences internally, if present at all. There are active efforts to address this by enhancing the FMI specification [1], but this path requires tool vendors to implement additional functionality in their tools with FMI support. This talk presents a different approach that leverages the LLVM ecosystem and Enzyme.jl. By embedding the LLVM bitcode generated during compilation of the FMU into the binary itself, we can make the compiled code accessible to Enzyme, which can then generate fast, exact derivatives for virtually any function the FMU provides. These also integrate neatly with other code from the Julia ecosystem. In practice, this yields speedups of multiple orders of magnitude over finite differencing in some cases, while in the best case requiring only passing some additional compiler flags during the FMU's compilation from source code. The talk will cover the approach, discuss some challenges we encountered, and demonstrate performance gains. [1] T. Thummerer, H. Olsson, C. Song, J. Gundermann, T. Blochwitz, and L. Mikelsons, “LS-SA: Developing an FMI layered standard for holistic & efficient sensitivity analysis of FMUs,” Linköping Electronic Conference Proceedings, vol. 218. Linköping University Electronic Press, Oct. 24, 2025. doi: 10.3384/ecp218681. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/KKHD78/ Alte Mensa — Atrium Maximum Valentin Höpfner Lars Mikelsons PUBLISH 3RDRVU@@pretalx.com -3RDRVU DJ4Oceananigans: Differentiating an ocean general circulation model for gradient-based parameter calibration and online learning en en 20260814T114500 20260814T120000 001500 DJ4Oceananigans: Differentiating an ocean general circulation model for gradient-based parameter calibration and online learning Ocean general circulation models (GCMs) are used for operational forecasting and climate modeling. They simulate a wide range of physical processes, but suffer from biases and uncertainties due to inherent model limitations and inability to model under-resolved processes. These limitations motivate the use of inverse or machine learning methods to systematically constrain models with data from real world observations or high-resolution model runs, thereby reducing both structural and parametric uncertainties. Gradient-based approaches offer a way to “learn” high-dimensional model input spaces, such as physics-based parameters or neural network weights. Combining these methods leads to the notion of neural GCMs that are fully differentiable through automatic differentiation (AD). We have implemented such a capability in the open source ocean GCM Oceananigans.jl, resulting in DJ4Oceananigans (Differentiable Julia for Oceananigans). This required the enhancement of the AD tool Enzyme.jl in conjunction with the compiler tool Reactant.j, which produces a stable multi-level intermediate representation (MLIR) that renders robust, optimized derivative code executable on a wide range of devices including CPUs, TPUs, and GPUs. We demonstrate the computation of accurate gradients across several Oceananigans configurations, for use in sensitivity tests, parameter estimation, and embedded neural network layers. This work represents a significant milestone toward integrating gradient-based inverse methods and machine learning in ocean modeling in Julia, providing open source tools to improve model calibration, reduce persistent model biases, and characterize model uncertainty. It is useful and accessible for other researchers interested in ocean and climate modeling, as well as those interested in an example of differentiability being successfully applied and utilized within a complex scientific model implemented in Julia. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/3RDRVU/ Alte Mensa — Atrium Maximum Joseph Kump PUBLISH A79CZS@@pretalx.com -A79CZS GlissADe.jl: Differentiable Simulator for Geophysical Surface Flows en en 20260814T120000 20260814T121500 001500 GlissADe.jl: Differentiable Simulator for Geophysical Surface Flows PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/A79CZS/ Alte Mensa — Atrium Maximum Tanish Jain PUBLISH 97YU9L@@pretalx.com -97YU9L MemlsRetrieval.jl: Fast Snow and Sea-Ice Microwave Emission Modeling for Inversion en en 20260814T121500 20260814T123000 001500 MemlsRetrieval.jl: Fast Snow and Sea-Ice Microwave Emission Modeling for Inversion The Microwave Emission Model of Layered Snowpacks (MEMLS) is a widely used forward model for microwave emission from snow and sea ice, here we present a reimplementation in Julia as MemlsRetrieval.jl. While the original MATLAB package has been valuable for exploring the parameter space and comparisons to satellite observations, it was not designed for efficient inversion or large-scale application like satellite retrievals. Our Julia implementation shifts the focus toward performance, composability, and retrieval workflows. By leveraging Julia’s type system together with packages such as StaticArrays.jl and ForwardDiff.jl, MemlsRetrieval.jl supports fast forward-model evaluation and automatic differentiation for Jacobian computation. In typical use cases of up to 10 layers, both forward evaluations and Jacobian calculations run in the microsecond range with zero allocations on consumer hardware. This enables efficient parallel execution with small memory footprints which is especially useful for retrieval and data-assimilation applications. As a first application, we replaced a simplified sea-ice surface-emission parameterization in an ocean–sea-ice–atmosphere microwave emission model with MemlsRetrieval.jl. We then used this model within an optimal-estimation framework to retrieve multiple geophysical parameters, simultaneously from Advanced Microwave Scanning Radiometer 2 (AMSR2) satellite observations over the Arctic. The inclusion of our physical forward model allows us to exploit sensitivities that are often neglected because suitable empirical parameterizations are unavailable in practical retrieval systems. At the poster, we will present the package design, performance characteristics, and first retrieval results, and discuss how the model can support future cryospheric remote-sensing applications in Julia. PUBLIC CONFIRMED Short talk https://pretalx.com/juliacon-2026/talk/97YU9L/ Alte Mensa — Atrium Maximum Marcus Huntemann PUBLISH KLDKCP@@pretalx.com -KLDKCP Differentiable Modeling BoF: Discussion and Future Directions en en 20260814T123000 20260814T130000 003000 Differentiable Modeling BoF: Discussion and Future Directions This BoF is a roundtable discussion on differentiable computational models and their applications, open to anyone using or developing them in Julia or other languages. We'll discuss: Experiences, challenges, and solutions from working with differentiable models Whether existing differentiation packages provide straightforward explanations of their uses and how to implement them in real work Limitations in current differentiation packages that future development could address The potential for an org page to consolidate and showcase community efforts and best practices in this space PUBLIC CONFIRMED Birds of Feather (BoF) https://pretalx.com/juliacon-2026/talk/KLDKCP/ Alte Mensa — Atrium Maximum Sarah Williamson Alan Correa PUBLISH 3Z7LGC@@pretalx.com -3Z7LGC Makie.jl BoF en en 20260814T143000 20260814T153000 010000 Makie.jl BoF 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. We will also have updates from Makie devs on: - Ray tracing backend, fully native in Julia - Geospatial plotting on the 3D globe and more! This will keep changing as we get more features in :) PUBLIC CONFIRMED Birds of Feather (BoF) https://pretalx.com/juliacon-2026/talk/3Z7LGC/ Alte Mensa — Atrium Maximum Anshul Singhvi PUBLISH QS37VY@@pretalx.com -QS37VY Creating Tooling as Greedy as Julia Itself en en 20260814T154500 20260814T164500 010000 Creating Tooling as Greedy as Julia Itself Why they created Julia: ["In short, because we are greedy."](https://julialang.org/blog/2012/02/why-we-created-julia/) The goal of this bird of a feather is to explore concrete gaps and pain points across Julia’s tooling such as debugging, performance analysis, compilation visibility, and workflows. Topics we hope to talk about include: - What workflows feel harder than they should? - Where do current tools fall short? - What functionalities would significantly improve productivity, confidence in correctness and performance? - Which tooling issues become most visible in larger or production systems? - Where do current debugging workflows fail? The aim is to better understand community priorities and to connect contributors that are greedy in advancing Julia’s development experience. PUBLIC CONFIRMED Birds of Feather (BoF) https://pretalx.com/juliacon-2026/talk/QS37VY/ Alte Mensa — Atrium Maximum Tyrone Krieger Yury Nuzhdin