0.8 juliacon-2026 2026-08-10 2026-08-15 6 00:05 https://pretalx.com Europe/Berlin Muschel — N2 Workshop 2026-08-10T10:00:00+02:00 10:00 03:00 High-Performance Computing (HPC) empowers modern science and engineering by enabling the simulation and analysis of complex systems at unprecedented scales on cutting-edge supercomputers. Julia, as a dynamic programming language designed for scientific computing, uniquely combines the ease of high-level syntax with near C and Fortran execution speed, making it a compelling vehicle for performance engineering on supercomputers. This workshop offers a hands-on introduction to performance engineering with Julia on modern HPC systems, guiding participants through the workflow of analyzing, optimizing, and scaling Julia codes on a real HPC environment. Using interactive Jupyter notebooks backed by the [Otus system](https://pc2.uni-paderborn.de/systems-and-services/otus) at the [Paderborn Center for Parallel Computing (PC2)](https://pc2.uni-paderborn.de/), participants will experiment with live Julia code and performance analysis tools to gain practical proficiency in optimization techniques. The three parts of the workshop will first introduce the organization of modern HPC clusters that influences Julia code performance, then examine the performance engineering workflow that identifies and solves optimization problems and finally present a case study of the workflow applied to a real scientific application. Through the combination with hands-on exercises, participants will not only understand the core principles of performance engineering but also actively practice optimizing and scaling Julia programs on the Otus HPC system at PC2. juliacon-2026-92683-performance-engineering-with-julia-on-modern-supercomputers Julia for HPC Minisymposium /media/juliacon-2026/submissions/7JKGJU/image_DUSuhIr.webp Alex WiensXin WuChristian PlesslGerrit Pape en ## 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. false flyer-7JKGJU https://pretalx.com/juliacon-2026/talk/7JKGJU/ https://pretalx.com/juliacon-2026/talk/7JKGJU/feedback/ Muschel — N2 Workshop 2026-08-10T14:30:00+02:00 14:30 03:00 Julia offers the best of both worlds: high-level expressiveness combined with low-level performance, allowing developers to leverage modern hardware accelerators without needing expertise in hardware-specific languages. This workshop demonstrates how Julia makes high-performance computing (HPC) accessible by covering topics such as distributed GPU computing, GPU code optimization, and scalable workflows. juliacon-2026-93392-hands-on-with-julia-for-hpc-on-gpus General /media/juliacon-2026/submissions/MRFYNN/image_8qmT20l.webp Ludovic RässCollin WittensteinBoris KausIvan Utkin en ## 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._ false flyer-MRFYNN https://pretalx.com/juliacon-2026/talk/MRFYNN/ https://pretalx.com/juliacon-2026/talk/MRFYNN/feedback/ Muschel — N3 Workshop 2026-08-10T10:00:00+02:00 10:00 03:00 What if engineers could go from concept to validated simulation model through conversation alone? DyadAgent, built on Julia and Dyad, makes this possible by combining generative AI with the SciML ecosystem to construct, compile, and rigorously validate high-fidelity physical models from natural language. It handles planning models, creating them, validating them, debugging them and using them in downstream applications such as parameter estimation, model discovery and more. This workshop demonstrates how DyadAgent is reshaping the modeling workflow across engineering domains. juliacon-2026-92848-dyadagent-adding-intelligence-to-modeling-and-simulation General /media/juliacon-2026/submissions/83EN8J/image_TEOmWe4.webp Venkatesh-Prasad BhatAnas AbdelrehimAshutosh BharambeMarius Micluța-Câmpeanu en 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. false https://pretalx.com/juliacon-2026/talk/83EN8J/ https://pretalx.com/juliacon-2026/talk/83EN8J/feedback/ Muschel — N3 Workshop 2026-08-10T14:30:00+02:00 14:30 03:00 The Julia language is a proven technology for technical computing. So it is only natural for people to build engineering-related tools on top of it. In this workshop, we'll discuss our Dyad platform for system modeling and how this utilizes both Julia and ModelingToolkit to deliver Scientific Machine Learning (SciML) to engineers in industry. juliacon-2026-92707-dyad-sciml-tutorial-bringing-julia-to-engineers General /media/juliacon-2026/submissions/P39YQD/image_Mm6SiyU.webp Michael TillerJohn Batteh en 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. false https://pretalx.com/juliacon-2026/talk/P39YQD/ https://pretalx.com/juliacon-2026/talk/P39YQD/feedback/ Muschel — N2 Workshop 2026-08-11T10:00:00+02:00 10:00 03:00 Debugging performance and memory issues in Julia often requires combining multiple tools and correlating their outputs. Participants will learn how to use a runtime-level instrumentation approach to analyze and resolve performance issues in real code, including cases that are difficult to diagnose using existing tools. juliacon-2026-92573-finding-hidden-performance-costs-in-julia General /media/juliacon-2026/submissions/9FCTYW/image_N9iAiAF.webp Joost GodschalkYury NuzhdinTyrone Krieger en 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. false https://pretalx.com/juliacon-2026/talk/9FCTYW/ https://pretalx.com/juliacon-2026/talk/9FCTYW/feedback/ Muschel — N3 Workshop 2026-08-11T10:00:00+02:00 10:00 03:00 While strong in sciences and technical tasks, Julia has traditionally lacked the kinds of "application frameworks" many other languages offer for bundling and deploying applications as servers. The JuliaServices GitHub organization has steadily been building up just the kinds of utility/support packages that facilitate "productionalizing" your Julia code: - Servo.jl: Utility package providing auth middleware, JSON logging, background metric/observability tracking, and endpoint route-defining macros - OAuth.jl: full, pure-Julia implementation of OAuth 2.0; client and server functionality - Tempus.jl: cron-style scheduler/job executor with abstract storage options - Harbor.jl: powerful docker image/container managing from Julia; enables robust testing scenarios with precise "services" providers via docker containers. - CloudStore.jl: cloud-agnostic "object store" package, enabling easy CRUD operations across cloud storage locations This workshop will walk through building an entire Julia application from scratch, utilizing JuliaServices packages, resulting in a fully deployed, publicly accessible application. juliacon-2026-92834-juliaservices-packages-for-running-julia-application-servers-in-production General /media/juliacon-2026/submissions/MCXKBF/image_bnNtosZ.webp Jacob Quinn en false https://pretalx.com/juliacon-2026/talk/MCXKBF/ https://pretalx.com/juliacon-2026/talk/MCXKBF/feedback/ Tent — RW1 Ceremony 2026-08-12T08:30:00+02:00 08:30 00:15 Welcome to Mainz and JuliaCon Global 2026! We are here to provide an open, welcoming, and safe place for sharing knowledge, fostering collaborations, and binding people together. Let's enjoy! juliacon-2026-93046-opening-ceremony General /media/juliacon-2026/submissions/C7HJJD/image_CBrDgwF.webp en false https://pretalx.com/juliacon-2026/talk/C7HJJD/ https://pretalx.com/juliacon-2026/talk/C7HJJD/feedback/ Tent — RW1 Keynote 2026-08-12T08:45:00+02:00 08:45 01:00 Haskell is an unusual survivor in the Darwinian landscape of programming languages: it is long-lived (36 years old), yet not mainstream; it is both a research platform and a production tool; it pushes the boundaries of what you can do with static types; and (anecdotally) it inspires joy as well as offering utility. In this talk I'll describe how Haskell came to be, and what (in retrospect) I think are its most important contributions. I'll talk about how it has evolved, especially in response to the demands of companies using Haskell in production. juliacon-2026-93043-haskell-origins-evolution-and-future-by-simon-peyton-jones General /media/juliacon-2026/submissions/QWW3TE/image_fOb6hid.webp en false https://pretalx.com/juliacon-2026/talk/QWW3TE/ https://pretalx.com/juliacon-2026/talk/QWW3TE/feedback/ Tent — RW1 Long talk 2026-08-12T10:00:00+02:00 10:00 00:30 Compilation latency is one of top asks Julia users have and have had over the years. But why is it so hard to make significant leaps on that area. Or even keep the performance the same. Since 1.10 there have been significant regressions in (pre)compilation time. What caused those and can we recoup or even get better than 1.10 performance? The talk will go through why compiling Julia quickly is hard, what are we doing to improve that and what users can do to make their code compile faster. juliacon-2026-92365-why-is-compilation-as-slow-as-it-is General /media/juliacon-2026/submissions/PBYF33/image_ITtpWru.webp Gabriel Baraldi en false https://pretalx.com/juliacon-2026/talk/PBYF33/ https://pretalx.com/juliacon-2026/talk/PBYF33/feedback/ Tent — RW1 Long talk 2026-08-12T10:30:00+02:00 10:30 00:30 Julia aggressively transforms your code during compilation and execution, which can make it difficult to see what actually runs. This can introduce subtle performance and memory costs that are not directly visible in existing tools. In this talk, we show a compiler and runtime instrumentation approach that provides a runtime-level view of program execution, links runtime behavior back to source code, and show how hidden costs can be uncovered and performance assumptions validated. juliacon-2026-92377-spying-into-julia-s-runtime General /media/juliacon-2026/submissions/3AZE7E/image_y249Uc0.webp Tyrone KriegerYury NuzhdinJorge Alberto Vieyra Salas en 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. false https://pretalx.com/juliacon-2026/talk/3AZE7E/ https://pretalx.com/juliacon-2026/talk/3AZE7E/feedback/ Tent — RW1 Short talk 2026-08-12T11:15:00+02:00 11:15 00:15 The world of AI agents is changing constantly - every couple of weeks, it seems there is some new thing. In this talk, I'll try to sum up the current state of the art when using AI agents with Julia - from which agents to use, MCP servers, skills and whatever else comes up between now and then. If you have only dipped your toes into using AI with Julia so far, this talk is for you! juliacon-2026-93476-llms-agents-and-tools-for-julia-development General /media/juliacon-2026/submissions/CUVPA3/image_SrwSIka.webp Anshul Singhvi en 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. false https://pretalx.com/juliacon-2026/talk/CUVPA3/ https://pretalx.com/juliacon-2026/talk/CUVPA3/feedback/ Tent — RW1 Long talk 2026-08-12T11:30:00+02:00 11:30 00:30 Bundling applications into native installers such as MSIX, Snap, or DMG usually requires the target platform access and host system utilities. This creates a maintenance burden: each platform needs special setup, and compatibility must be preserved as operating systems evolve and utility behavior changes. AppBundler eliminates this burden by using cross-compiled, open-source utilities distributed through Julia’s Yggdrasil registry. From a single UNIX host (Linux, FreeBSD, or macOS)—with MSIX support on Windows—developers can generate native installers through a consistent, reproducible pipeline. In this talk, I will explain the architecture behind AppBundler and walk through each supported installer format. I’ll provide an overview of the open-source pipelines that replace host system utilities, then review the configuration files and common options that control application behavior after installation. I will then introduce the AppBundler API design and show how surgical customizations via native override files are supported. The session continues with a live demo showing how any application exposing @main can be bundled locally with minimal effort. We’ll add an icon, experiment with configuration options, and iterate on the bundle. I’ll then demonstrate how the same application can be packaged automatically on GitHub Actions, including a walkthrough of the Actions panel and release workflows that build installers across platforms with a single click. Next, I’ll showcase several larger applications that have been successfully bundled with AppBundler. We’ll discuss common pitfalls that make applications non-relocatable and how to resolve them. I’ll cover JuliaC integration, including a demo of a command-line application using the `--trim` option. I’ll also touch on asset inclusion and referencing via `pkgdir(@__MODULE__)`, and explain how calling `AppEnv.init()` in `@main` populates pkgorigins to enable relocation. The talk will conclude with future directions beyond the 1.0 release, including how AppBundler could evolve to package not only Julia applications, but software written in other programming languages. juliacon-2026-92404-appbundler-1-0-bundle-your-julia-application-and-beyond General /media/juliacon-2026/submissions/V9YEJL/image_YQB5QbO.webp Janis Erdmanis en false https://pretalx.com/juliacon-2026/talk/V9YEJL/ https://pretalx.com/juliacon-2026/talk/V9YEJL/feedback/ Tent — RW1 Short talk 2026-08-12T12:00:00+02:00 12:00 00:15 The Julia Registrator bot has been quietly running in the background, listening to registration comments and making PRs to the General registry. It is the de facto tool for Julia package registrations. Hi, my name is Nishanth. I am one of the core contributors to Registrator.jl and have been responsible for keeping the Registrator server operational ever since it was first deployed in 2019. In this talk, I would like to share with you all the internal details of Registrator server setup and configuration. The talk will cover: - Registrator deployment process - Configuration & GitHub settings - Logging, Troubleshooting & Debugging This talk will be useful for contributors interested in helping out with development and maintenance. I hope this talk motivates more members of the community to contribute to Registrator for the years to come! Thank you! juliacon-2026-93470-the-julia-registrator-setup-and-runtime-environment General /media/juliacon-2026/submissions/RQVGL3/image_wKx2AtS.webp Nishanth H. Kottary en false https://pretalx.com/juliacon-2026/talk/RQVGL3/ https://pretalx.com/juliacon-2026/talk/RQVGL3/feedback/ Tent — RW1 Long talk 2026-08-12T12:15:00+02:00 12:15 00:30 JuliaSubtyping is a new implementation of Julia's core subtyping (and intersection / type-subtraction) algorithms. This talk will motivate the new implementation and explore the theory behind its operation. Despite being built on complex theory (SAT solvers, QBF, and more), the new design attempts to be more performant and transparently correct than Julia's existing implementation, while also being straightforward to extend with new kinds of reasoning. At the heart of the design a "logical core" is combined with a "type logic" to form the basis of the algorithm and provides semantics rich enough to describe many interesting subtyping algorithms. You can of course expect many challenges along the way. Every theoretician's favorite enemy (undecidability) will rear its head along our journey, along with other practical engineering trade-offs. We'll investigate performance and demonstrate how the new algorithm stands with respect to the old. Finally we'll speculate about what new types of compiler reasoning this kind of typing algorithm may one day support. juliacon-2026-89210-juliasubtyping-a-logical-approach-to-types General /media/juliacon-2026/submissions/GBYL3S/image_t266Q9O.webp Cody Tapscott en false https://pretalx.com/juliacon-2026/talk/GBYL3S/ https://pretalx.com/juliacon-2026/talk/GBYL3S/feedback/ Tent — RW1 Long talk 2026-08-12T14:30:00+02:00 14:30 00:30 What if `using Plots, ModelingToolkit` was instantaneous, the first time on a fresh Julia installation? What if your students, users, and/or colleagues could run a command to install something and then everything "just worked"? `julia` was never really good at this; we optimized the vanilla distribution for flexibility, which is somewhat at odds with a smooth first-time experience. But this flexibility doesn't fit everyone. We'll present a set of tools to curate Julia distributions for your specific user base, replacing some flexibility with a more reasonable green-path experience. juliacon-2026-93353-building-and-shipping-omakase-julia-distributions General /media/juliacon-2026/submissions/NVEP3P/image_sO6EWvl.webp Panagiotis GeorgakopoulosJoris Kraak en 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. false https://pretalx.com/juliacon-2026/talk/NVEP3P/ https://pretalx.com/juliacon-2026/talk/NVEP3P/feedback/ Tent — RW1 Long talk 2026-08-12T15:00:00+02:00 15:00 00:30 How do you run Julia programs on a machine that is not your own, a machine that is not the one where program was originally developed on? This simple question leads to a surprising array of opinions and options. In this talk, I present some of the hard earned lessons from over a decade of deploying Julia applications to production services. juliacon-2026-93498-lessons-in-deploying-julia-to-productions-services General /media/juliacon-2026/submissions/37PYYA/image_3qbMqZG.webp Avik Sengupta en 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 false https://pretalx.com/juliacon-2026/talk/37PYYA/ https://pretalx.com/juliacon-2026/talk/37PYYA/feedback/ Tent — RW1 Long talk 2026-08-12T15:45:00+02:00 15:45 00:30 Type-piracy is often said to be "defining foreign behavior over foreign types". Sounds intuitive, but in practice things get complicated quickly: A basic type like `ForeignType{Float64}` may be "obviously foreign", but how do we extend that notion to Julia's full type language including `Union` and `where`? Are all forms of type-piracy equally bad, or is "type-privateering" a thing? Most importantly, how does this affect your code in practice? This talk will attempt to construct a mathematically precise definition for the "essence" of type-piracy. We'll discuss how determining type-piracy might be automated and what it would mean to make this a "first-class" restriction in Julia. Do we lose expressivity, gain performance? What designs would this affect in practice? Along the way, we'll examine cases of "type-piracy in the wild" in the community (and even in Julia's own standard libraries!). These controversial case studies will serve as a litmus test to see if we can conquer the type seas, or if the age of the type-privateer continues. juliacon-2026-93444-bringing-order-to-the-seas-defining-type-piracy-in-julia General /media/juliacon-2026/submissions/LYBBPW/image_Fo3Lhqp.webp Cody Tapscott en false https://pretalx.com/juliacon-2026/talk/LYBBPW/ https://pretalx.com/juliacon-2026/talk/LYBBPW/feedback/ Tent — RW1 Short talk 2026-08-12T16:15:00+02:00 16:15 00:15 The Carpentries is a nonprofit organization that teaches software engineering and data science skills to researchers worldwide through hands-on workshops. Since 2021, I have maintained a Carpentries Incubator lesson focused on teaching Julia, which I also integrate into my university courses. In this talk, I will talk about strengths and weaknesses of the current lesson design as well as presenting a new different lesson. I will also highlight opportunities for the Julia community to participate in collaborative lesson development. juliacon-2026-89319-julia-novices-about-the-carpentries-lessons-for-teaching-julia General /media/juliacon-2026/submissions/GDBGPJ/image_lw1B5Ab.webp Simon Christ en false https://pretalx.com/juliacon-2026/talk/GDBGPJ/ https://pretalx.com/juliacon-2026/talk/GDBGPJ/feedback/ Tent — RW1 Short talk 2026-08-12T16:30:00+02:00 16:30 00:15 This talk considers the features Julia includes, and more importantly, omits, in service of a speedier implementation, as well as how the language might grow in the future. juliacon-2026-92795-how-is-julia-both-dynamic-and-fast General /media/juliacon-2026/submissions/CZDYJF/image_1M7wo0b.webp Sam Schweigel en 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. false https://pretalx.com/juliacon-2026/talk/CZDYJF/ https://pretalx.com/juliacon-2026/talk/CZDYJF/feedback/ Tent — RW1 Short talk 2026-08-12T16:45:00+02:00 16:45 00:15 Static analysis for Julia is still an underdeveloped domain. The linting ecosystem is looking especially barren – practically one package is used for writing and running linting rules, [StaticLint](https://github.com/julia-vscode/StaticLint.jl), even though it is difficult to extend with new rules or features. [ReLint](https://github.com/RelationalAI-oss/ReLint.jl) was built to address some of StaticLint's limitations, improving upon extensibility and interoperability. However, it too suffers from shortcomings, especially in terms of flexibility. [Argus](https://github.com/iuliadmtru/Argus.jl), mainly a pattern matching framework for Julia syntax, offers a powerful and expressive language for writing code patterns and linting rules. This presentation shows the result of combining ReLint and Argus into a new version of ReLint that provides a built-in set of rules, a DSL for extending the default set with custom rules and CI/CD integration. juliacon-2026-93362-relint-jl-and-argus-jl-are-merging-into-a-powerful-julia-linter General /media/juliacon-2026/submissions/TBHR8T/image_obGhLxI.webp Iulia DumitruAlexandre Bergel en 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). false https://pretalx.com/juliacon-2026/talk/TBHR8T/ https://pretalx.com/juliacon-2026/talk/TBHR8T/feedback/ Tent — RW1 Long talk 2026-08-12T17:00:00+02:00 17:00 00:30 In order to improve the tooling around --trim, we've developed JuliaC.jl. It's a package similar to PackageCompiler, but with a focus on bundling trimming applications. It has features like bundling, setting rpaths and more interestingly. Privatization, allowing a JuliaC library to be loaded by Julia juliacon-2026-92841-juliac-jl-and-the-state-of-trim General /media/juliacon-2026/submissions/WVE37X/image_GUPRcf1.webp Gabriel BaraldiJeff BezansonCody Tapscott en false https://pretalx.com/juliacon-2026/talk/WVE37X/ https://pretalx.com/juliacon-2026/talk/WVE37X/feedback/ Tent — RW1 Keynote 2026-08-12T17:45:00+02:00 17:45 01:00 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. juliacon-2026-93042-resolving-the-edge-of-the-universe-imaging-black-holes-with-julia General /media/juliacon-2026/submissions/XSYZLV/image_EjuldP1.webp Paul Tiede en 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. false https://pretalx.com/juliacon-2026/talk/XSYZLV/ https://pretalx.com/juliacon-2026/talk/XSYZLV/feedback/ Muschel — N1 Long talk 2026-08-12T10:00:00+02:00 10:00 00:30 tbd juliacon-2026-91085-disrupt-drug-design Pharmaceutical Research in Julia /media/juliacon-2026/submissions/WGRWHS/image_4OybWXf.webp pato en true https://pretalx.com/juliacon-2026/talk/WGRWHS/ https://pretalx.com/juliacon-2026/talk/WGRWHS/feedback/ Muschel — N1 Short talk 2026-08-12T10:30:00+02:00 10:30 00:15 Quantitative Systems Pharmacology (QSP) is a fast-growing discipline in model informed drug development. We simulate virtual patients to enhance decisions across the pharmaceutical pipeline to get the right medicines to the right patients faster. QSP models are large and often stiff differential equation systems. Workflows include intensive simulations such as parameter optimization and sensitivity analyses. In this talk, we will discuss how we utilize Julia for QSP workflows. juliacon-2026-92821-julia-for-quantitative-systems-pharmacology Pharmaceutical Research in Julia /media/juliacon-2026/submissions/BXHNXX/image_h7JGUku.webp Elisabeth Roesch en 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 true https://pretalx.com/juliacon-2026/talk/BXHNXX/ https://pretalx.com/juliacon-2026/talk/BXHNXX/feedback/ Muschel — N1 Short talk 2026-08-12T10:45:00+02:00 10:45 00:15 The most popular modeling framework in pharmacometrics is nonlinear mixed-effects modeling. In the pharmacometric application of the model framework, the time dimension is typically a solution to a dynamical system. The combination of the nonlinearity of the statistical model and the computational costs of numerically solving differential equations has made the use of staged programming necessary in all available software packages. The staged programming requirement has historically been associated with a large maintenance burden, but staged programming is also what Julia was designed for. In this talk, I outline the modeling class most popular in pharmacometrics, give an overview of how historical solutions are used, and explain how Julia is well suited for pharmacometrics. juliacon-2026-93463-staged-programming-in-pharmacometrics Pharmaceutical Research in Julia /media/juliacon-2026/submissions/7B9YZJ/image_I2YjRcg.webp Andreas Noack en false https://pretalx.com/juliacon-2026/talk/7B9YZJ/ https://pretalx.com/juliacon-2026/talk/7B9YZJ/feedback/ Muschel — N1 Long talk 2026-08-12T11:00:00+02:00 11:00 00:30 NoLimits.jl is a flexible open-source Julia framework for nonlinear modeling and parameter estimation with random effects. It supports ODE-based mechanistic models, hidden Markov models, hybrid mechanistic-machine learning components, normalizing flows, and nested random-effect structures within a unified interface. By leveraging Julia’s composability, it enables scalable frequentist and Bayesian inference beyond the constraints of traditional open-source mixed-effects software. juliacon-2026-92691-nolimits-jl-a-flexible-julia-framework-for-nonlinear-neural-and-latent-state-mixed-effects-modeling Pharmaceutical Research in Julia /media/juliacon-2026/submissions/NEH3S3/image_QYYa8AC.webp Manuel Huth en 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. false flyer-NEH3S3 https://pretalx.com/juliacon-2026/talk/NEH3S3/ https://pretalx.com/juliacon-2026/talk/NEH3S3/feedback/ Muschel — N1 Short talk 2026-08-12T11:30:00+02:00 11:30 00:15 In this talk physics informed neural networks are presented to predict the plasma concentration time profiles of preclinical species and human after i.v. bolus administration. The predictions are based on the numerical representation of chemical structures or amino acid sequences and compartmental modeling is used as the physical part to describe the pharmacokinetic profiles. juliacon-2026-92727-feature-based-prediction-of-preclinical-pharmacokinetic-profiles-using-machine-learning-and-compartmental-modeling Pharmaceutical Research in Julia /media/juliacon-2026/submissions/VEWE33/image_7x2whCJ.webp Felix Jost en 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. false https://pretalx.com/juliacon-2026/talk/VEWE33/ https://pretalx.com/juliacon-2026/talk/VEWE33/feedback/ Muschel — N1 Short talk 2026-08-12T11:45:00+02:00 11:45 00:15 Virtual Populations (VPops) are widely used in Quantitative Systems Pharmacology (QSP) to represent variability in patient responses to therapy using parameterized dynamical models. Unlike traditional modeling approaches that focus on average treatment effects, VPop methods aim to reproduce the full distribution of clinical outcomes observed in trials. We introduce VPopMIP, a Julia package implementing a Mixed-Integer Programming (MIP) formulation for generating VPops that match clinical endpoints. In contrast to many existing approaches that require individual-level patient data, VPopMIP enables calibration to published clinical summary statistics (e.g., response rates, medians, and confidence intervals), which are more commonly available in practice. The method formulates virtual patient selection as a constrained optimization problem that enforces agreement with multiple outcome measures across therapies. We demonstrate the methodology using a solid tumor model with multiple efficacy endpoints across treatment regimens. The results illustrate how MIP-based selection provides an efficient way to construct clinically consistent virtual populations. juliacon-2026-92910-vpopmip-a-mixed-integer-programming-approach-to-virtual-population-generation Pharmaceutical Research in Julia /media/juliacon-2026/submissions/MGNSFV/image_ljpZPv3.webp Ivan BorisovEvgeny Metelkin en false https://pretalx.com/juliacon-2026/talk/MGNSFV/ https://pretalx.com/juliacon-2026/talk/MGNSFV/feedback/ Muschel — N1 Long talk 2026-08-12T12:00:00+02:00 12:00 00:30 I will present AlphaConformers, a Julia package to model alternative protein conformations using AlphaFold. This will showcase Julia as an incredible glue language for developing reproducible bioinformatics pipelines. In particular, we will focus on the use of JLL packages as a way to include versioned, cross-platform command-line tools. We will describe the current bioinformatics JLL ecosystem and show how developers in other languages can make their binaries available for Julia users. juliacon-2026-92934-reproducible-bioinformatics-pipelines-in-julia-lessons-from-alphaconformers Pharmaceutical Research in Julia /media/juliacon-2026/submissions/SA7F9J/image_3E3xDBb.webp Diego Javier Zea en 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. false https://pretalx.com/juliacon-2026/talk/SA7F9J/ https://pretalx.com/juliacon-2026/talk/SA7F9J/feedback/ Muschel — N1 Short talk 2026-08-12T12:30:00+02:00 12:30 00:15 Virtual Screening of phytocompounds in drug discovery has surged over the years. We present juDock, a ML-Driven dockerized Linux application built in Julia. juDock automates the pipeline from the preparation of ligands to the prediction of potential compounds for a specific protein integrating AutoDock Vina, RDKit and Scikit-Learn via PythonCall.jl and Genie.jl. Furthermore, juDock is an open source project attracting researchers to contribute using the established ML pipeline for various proteins. juliacon-2026-92758-judock-an-open-source-ml-driven-platform-for-virtual-screening-of-phytocompounds-in-drug-discovery Pharmaceutical Research in Julia /media/juliacon-2026/submissions/XYQJFH/image_EcKPmkM.webp Surya Sekaran en 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. false juDock_Demo flyer-XYQJFH juDock_main juDock_Results https://pretalx.com/juliacon-2026/talk/XYQJFH/ https://pretalx.com/juliacon-2026/talk/XYQJFH/feedback/ Muschel — N1 Short talk 2026-08-12T12:45:00+02:00 12:45 00:15 Protein structure minimization is a crucial step before running molecular pipelines with the aim to arrive at the lowest potential energy conformation. We introduce a mini-batching strategy for ML-based optimization algorithms. Leveraging the unified framework of Optimization.jl, we present a study to systematically assess the performance of different optimization algorithms with our molecular modeling framework [BiochemicalAlgorithms.jl](https://github.com/hildebrandtlab/BiochemicalAlgorithms.jl). This work provides the framework for identifying optimal algorithms for refinement of protein structures. juliacon-2026-92668-effects-of-stochasticity-on-molecular-minimization Pharmaceutical Research in Julia /media/juliacon-2026/submissions/NWQCHH/image_lRFgxpE.webp Jenny Leclaire en 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. false https://pretalx.com/juliacon-2026/talk/NWQCHH/ https://pretalx.com/juliacon-2026/talk/NWQCHH/feedback/ Muschel — N1 Long talk 2026-08-12T14:30:00+02:00 14:30 00:30 Heart rate time signals are one of the most readily available and cost effective biosignals for the study of human behavior. Their availability and ease of use make them ideal for open science. Many programming languages provide libraries that enable the manipulation of the time series generated by measuring the time in milliseconds between each heart beat: the Inter-Beat-Interval (IBI). However advanced functionality is only provided by private software, and many of opensource libraries seem to be designed as simple feature extraction libraries, and many have fallen into disuse. In this work we present the HeartRateLab: a new, powerful, and complete computational framework, written in julia, for the processing, analysis, modeling, and evaluation of human heart IBIs. The Julia language enables the ideal environment for explicit scientific management of operational, data-driven definitions of features used to define heart rate variability, and their physiological statistical relevance in several different domains. With the use of Julia's rich and interconnected scientific modeling environment, and the open scientific community, the HeartRateLab enables the most complete set of processing functions for IBI timeseries. Complete sets of features can be extracted from entire recordings, or using resampling or rolling window approaches with the overpowered capabilities of the language. Using Julia's DifferentialEquations.jl, Turing.jl, and other scientific libraries, the HeartRateLab provides the tools for modeling complex systems, including data-driven models for parameter recovery. The HeartRateLab showcases the stable complexity management environment that the Julia language and its community provide for scientific programming, while demonstrating intricate, applicable, but also very simple and embodied principles about the rhythms to which our hearts beat. juliacon-2026-92746-the-heartratelab-jl-a-toolkit-for-heart-beats-time-series General /media/juliacon-2026/submissions/VZUPJA/image_c40Z2nB.webp Alberto en 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. false https://pretalx.com/juliacon-2026/talk/VZUPJA/ https://pretalx.com/juliacon-2026/talk/VZUPJA/feedback/ Muschel — N1 Short talk 2026-08-12T15:00:00+02:00 15:00 00:15 Radiomic features extracted from medical images are fundamental for computer-aided diagnosis and treatment planning. Radiomics.jl is a new, pure-Julia open-source library for high-performance extraction of quantitative imaging biomarkers. Developed across multiple international institutions, it provides an efficient and scalable workflow by leveraging Julia’s speed. The library ensures seamless integration with machine learning pipelines for advanced clinical research and precision medicine. juliacon-2026-92553-radiomics-jl-a-library-for-high-performance-radiomic-features-extraction-from-medical-images Health Mini Symposium /media/juliacon-2026/submissions/WGZ9ZA/image_wchvKcf.webp ALDO GIULIANI en **_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 false flyer-WGZ9ZA https://pretalx.com/juliacon-2026/talk/WGZ9ZA/ https://pretalx.com/juliacon-2026/talk/WGZ9ZA/feedback/ Muschel — N1 Short talk 2026-08-12T15:15:00+02:00 15:15 00:15 Medical image reconstruction for modalities such as magnetic resonance imaging (MRI) and magnetic particle imaging (MPI) involves solving computationally intensive inverse problems. The MRIReco.jl and MPIReco.jl reconstruction packages feature a shared, modular optimisation backend that provides efficient and reusable solvers for various imaging modalities. In this talk, I will present how we extended this backend with vendor-agnostic GPU acceleration, which enables efficient reconstruction across both different imaging modalities and different GPU backends. juliacon-2026-92592-generic-gpu-acceleration-for-medical-image-reconstruction Health Mini Symposium /media/juliacon-2026/submissions/F8GRBR/image_JXiPbCF.webp Niklas Hackelberg en 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 false https://pretalx.com/juliacon-2026/talk/F8GRBR/ https://pretalx.com/juliacon-2026/talk/F8GRBR/feedback/ Muschel — N1 Short talk 2026-08-12T15:45:00+02:00 15:45 00:15 Magnetic fields are vital in numerous applications, including the medical imaging modality magnetic particle imaging, where field-related artifacts affect image quality. A good approximation of these fields is essential and can be done via spherical harmonic expansions derived from calibration measurements. The Julia package SphericalHarmonicExpansions.jl facilitates representation, transformations, and fast numerical evaluation, providing efficient tools for accurate magnetic field analysis. juliacon-2026-92587-application-of-sphericalharmonicexpansions-jl-representation-and-handling-of-magnetic-fields Health Mini Symposium /media/juliacon-2026/submissions/THM7WY/image_ZP51INP.webp Marija Boberg en 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 true flyer-THM7WY https://pretalx.com/juliacon-2026/talk/THM7WY/ https://pretalx.com/juliacon-2026/talk/THM7WY/feedback/ Muschel — N1 Long talk 2026-08-12T16:00:00+02:00 16:00 00:30 In MRI, radiofrequency (RF) pulses steer spins and shape the signal they produce. In this talk, I will show how we used RF pulses to “draw” the Julia logo inside a water bottle using a real MRI scanner. Behind this demo is a faster approach to RF-pulse design. By combining reverse-mode automatic differentiation (AD) with GPU-accelerated MRI simulations, we reduced a 2D RF-pulse optimization from ~10 minutes to ~1 second, making subject-specific RF design clinically feasible for applications such as imaging near metal and fat suppression. juliacon-2026-92539-how-i-drew-the-julia-logo-using-spins-in-an-mri-machine Health Mini Symposium /media/juliacon-2026/submissions/PZSLRD/image_mNayzIL.webp Carlos Castillo Passi en 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. false flyer-PZSLRD https://pretalx.com/juliacon-2026/talk/PZSLRD/ https://pretalx.com/juliacon-2026/talk/PZSLRD/feedback/ Muschel — N1 Long talk 2026-08-12T16:30:00+02:00 16:30 00:30 As JuliaHealth continues to expand, maintaining clarity and reliability across packages becomes essential. Supported by a NumFOCUS Small Development Grant, this project advances three goals: attracting new contributors, highlighting JuliaHealth workflows, and strengthening ecosystem robustness. A reproducible audit of documentation and CI pipelines led to repository improvements, website updates, structured workflow examples and modernized documentation deployment. juliacon-2026-92631-improving-juliahealth-documentation-accessibility-for-community-onboarding Health Mini Symposium /media/juliacon-2026/submissions/TDWGHB/image_KK4y4RB.webp Kosuri Lakshmi Indu en 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 false flyer-TDWGHB https://pretalx.com/juliacon-2026/talk/TDWGHB/ https://pretalx.com/juliacon-2026/talk/TDWGHB/feedback/ Muschel — N1 Long talk 2026-08-12T17:00:00+02:00 17:00 00:30 Since 2020, the JuliaHealth community has experienced steady growth. This talk will highlight the continued development of the JuliaHealth ecosystem, reflecting on where the community has been, where it is today, and where it is headed. juliacon-2026-92500-state-of-juliahealth Health Mini Symposium /media/juliacon-2026/submissions/FYD7SD/image_3RkXsL1.webp Hetarth ShahCarlos Castillo PassiJacob Zelko en 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 false flyer-FYD7SD https://pretalx.com/juliacon-2026/talk/FYD7SD/ https://pretalx.com/juliacon-2026/talk/FYD7SD/feedback/ Muschel — N2 Long talk 2026-08-12T10:00:00+02:00 10:00 00:30 The Julia SciML ecosystem is a collection of hundreds of packages. Keeping the whole system up to date can be quite the task, with dependencies releasing breaking versions weekly and having to track down CI failures. Over the last year a multi-agent system was developed to help with a lot of the maintenance burden. The goal of this talk is to share the details of this system so that other Julia package ecosystems can iterate on the idea and adopt similar mechanisms. juliacon-2026-89576-the-agentic-ai-maintenance-bots-of-the-sciml-organization General /media/juliacon-2026/submissions/FCV33L/image_JeewOV5.webp Chris Rackauckas en 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 false https://pretalx.com/juliacon-2026/talk/FCV33L/ https://pretalx.com/juliacon-2026/talk/FCV33L/feedback/ Muschel — N2 Long talk 2026-08-12T10:30:00+02:00 10:30 00:30 AI Agent software has proliferated in the last year. What started out as simple chatbots has evolved into deeply capable personal AI assistants and agent "swarms". Agentif.jl provides a set of agent "primitives" to enable building and configuring agent harnesses in pure Julia. - LLMProviders.jl: model provider abstraction; unifies Anthropic, OpenAI, OpenRouter, and other LLM providers under common models/"stream" functionality - Agentif.jl: core Agent, Tool, Channel, Session, Compaction, and middleware definitions that form the core "agent loop" functionality - LLMTools.jl: Sets of predefined tools that can be provided to agents, including: subagents, pty sessions, web search, Julia worker processes, and basic bash tools (ls, grep, read, write, edit, etc.) - Vo.jl: an example "personal assistant" setup using above primitives bundled together juliacon-2026-92836-agentif-jl-ai-agent-primitives-for-julia General /media/juliacon-2026/submissions/8CDNV9/image_Rcyb32S.webp Jacob Quinn en false https://pretalx.com/juliacon-2026/talk/8CDNV9/ https://pretalx.com/juliacon-2026/talk/8CDNV9/feedback/ Muschel — N2 Short talk 2026-08-12T11:15:00+02:00 11:15 00:15 The advent of convenient automatic differentiation has made gradient-based optimization the default strategy for many challenging problems and has revolutionized statistical practice. At the same time, MixedModels.jl uses a gradient-free approach to optimization and remains best in class for linear mixed models. Using MixedModels.jl as a case study, we will explore the tradeoffs of using the gradient and why gradient-free approaches remain relevant even in a world of easy autodiff. juliacon-2026-92920-gradients-aren-t-always-great-a-case-study-with-mixedmodels-jl General /media/juliacon-2026/submissions/RGVXMP/image_rLIRim5.webp Phillip Alday en 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. false https://pretalx.com/juliacon-2026/talk/RGVXMP/ https://pretalx.com/juliacon-2026/talk/RGVXMP/feedback/ Muschel — N2 Long talk 2026-08-12T11:30:00+02:00 11:30 00:30 Wouldn’t it be great if Julia could program itself? You simply tell it what you want, Julia magic happens, and you get correct-by-construction code. In this talk, we introduce `Herb.jl`, a unifying program synthesis library written in Julia, that gets us closer to this goal. While we are not fully there yet, we have significantly progressed since our last talk at JuliaCon 2024. juliacon-2026-92550-what-s-new-with-herb-jl-teaching-programs-how-to-program-with-program-synthesis General /media/juliacon-2026/submissions/RXG7AD/image_g7bqTfx.webp Tilman HinnerichsReuben Gardos Reid en `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. false flyer-RXG7AD https://pretalx.com/juliacon-2026/talk/RXG7AD/ https://pretalx.com/juliacon-2026/talk/RXG7AD/feedback/ Muschel — N2 Short talk 2026-08-12T12:00:00+02:00 12:00 00:15 Hyperparameter optimization is a core workflow in machine learning and scientific computing, yet the Julia ecosystem has lacked a mature, production-ready framework comparable to the robust, battle-tested tools available in other languages. In order to bridge this gap, we present `Optuna.jl` a package that brings the full functionality of `Optuna` (by Preferred Networks, Inc.), one of the most widely adopted hyperparameter optimization frameworks, into Julia. juliacon-2026-92636-optuna-jl-hyperparameter-optimization-with-optuna-in-julia General /media/juliacon-2026/submissions/A9PDA7/image_UzLLeCT.webp Julian TrommerLars Mikelsons en 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/ false Optuna.jl on GitHub OptunaDashboard.jl on GitHub https://pretalx.com/juliacon-2026/talk/A9PDA7/ https://pretalx.com/juliacon-2026/talk/A9PDA7/feedback/ Muschel — N2 Short talk 2026-08-12T12:15:00+02:00 12:15 00:15 BaseModelica is a subset of the Modelica standard that defines a simpler and more portable intermediate representation of full Modelica models. BaseModelica.jl brings this standard to Julia, enabling models from industry-standard Modelica tools to be imported into the SciML ecosystem and used with its rich set of solvers and analysis tools. juliacon-2026-92728-basemodelica-jl-a-julia-interface-for-basemodelica General /media/juliacon-2026/submissions/CYWCXK/image_5hy8DNr.webp Jadon Clugston en 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. false https://pretalx.com/juliacon-2026/talk/CYWCXK/ https://pretalx.com/juliacon-2026/talk/CYWCXK/feedback/ Muschel — N2 Long talk 2026-08-12T12:30:00+02:00 12:30 00:30 _Rigid registration_ seems like a simple task, on the first glance: If you have two objects, described as sets of points, how should you rotate and translate one to optimally match the other? However, it can be quite involved to do it reliably and efficiently. In this talk, I will present a new Julia package that provides a go-to solution to tackle not only rigid point cloud registration, but also _non-rigid registration_ and other typical point cloud tasks. juliacon-2026-92854-pointcloudregistration-jl-rigid-and-non-rigid-registration-of-point-clouds General /media/juliacon-2026/submissions/8ETRSY/image_nqDFGLK.webp Andreas Kröpelin en 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. false flyer-8ETRSY https://pretalx.com/juliacon-2026/talk/8ETRSY/ https://pretalx.com/juliacon-2026/talk/8ETRSY/feedback/ Muschel — N2 Long talk 2026-08-12T14:30:00+02:00 14:30 00:30 In this talk, we present the current state of our static DAG optimization and scheduling package [ComputableDAGs.jl](https://github.com/ComputableDAGs/ComputableDAGs.jl). The package allows to represent computations as static computational graphs. These graphs can be procedurally generated, automatically analyzed and optimized, and finally scheduled, and executed with no runtime overhead. The optimization can exploit domain specific knowledge about the computational problem, provided through meta information on the graph, without requiring an actual domain-specific language. Depending on available hardware, parts of the graph are automatically scheduled to accelerator devices if possible. We present the current capabilities and design of the package, using a high-energy physics application as a case study. Furthermore, we report about ongoing challenges, and invite discussions about usability and improvements. juliacon-2026-93342-computabledags-jl General /media/juliacon-2026/submissions/NJBNMC/image_0D9qiiS.webp Anton Reinhard en false https://pretalx.com/juliacon-2026/talk/NJBNMC/ https://pretalx.com/juliacon-2026/talk/NJBNMC/feedback/ Muschel — N2 Long talk 2026-08-12T15:00:00+02:00 15:00 00:30 Reseau.jl is a modern, pure Julia IO package that provides platform-native primitives for multithreaded event loops, unified socket interfaces, and TLS. It can be a drop-in replacement for the Sockets stdlib while providing a breadth of functionality and native platform integration (apple, linux, windows) for TLS mechanisms and trust stores. The async IO primitives can serve as foundational building blocks for a number of higher-layer application protocols, all in a multithread-friendly, performant package. juliacon-2026-92832-reseau-jl-platform-native-async-io-primitives-for-julia General /media/juliacon-2026/submissions/QJYSLE/image_Cjg7h96.webp Jacob Quinn en false https://pretalx.com/juliacon-2026/talk/QJYSLE/ https://pretalx.com/juliacon-2026/talk/QJYSLE/feedback/ Muschel — N2 Short talk 2026-08-12T15:45:00+02:00 15:45 00:15 The *cut norm* of a matrix measures the largest imbalance, given by the maximum absolute sum of its entries over any choice of row and column subsets. Computing this norm amounts to a combinatorial optimization problem that is *NP-hard*. It originates in graph theory and it plays a central role in the theory of graph limits, where it defines a notion of distance between large networks. We first present an integer program, modeled in *JuMP.jl*, and highlight the limitations in scalability. We then introduce a heuristic based on repeatedly solving a bilinear relaxation of the cut norm problem. Along the way, we utilize *NLPModels.jl* to efficiently represent the problem and solve the resulting nonlinear program using TRON from *JSOSolvers.jl*. To explore the solution space effectively, we employ a multi-start strategy initialized via a Sobol sequence generated with *Sobol.jl*. Through benchmarks, we show that the heuristic recovers optimal solutions on small instances and scales to significantly larger matrices than the exact formulation. We also illustrate how the algorithm can be used in the context of graph limit theory to measure the distance between large networks. juliacon-2026-92705-making-the-cut-norm-practical-a-julia-ecosystem-approach General /media/juliacon-2026/submissions/3W9MAF/image_O11oIFj.webp Martin Köhler en true https://pretalx.com/juliacon-2026/talk/3W9MAF/ https://pretalx.com/juliacon-2026/talk/3W9MAF/feedback/ Muschel — N2 Long talk 2026-08-12T16:00:00+02:00 16:00 00:30 ConvolutionInterpolations.jl offers methods for high-order interpolation, differentiation, integration and smoothing on discrete grids. Query times are similar to those of popular Julia packages for interpolation. Grids can be uniform, non-uniform, or a mixture. Supports mixed per-dimension interpolation, differentiation and integration. Extends naturally to multi-dimensional applications. juliacon-2026-92876-convolutioninterpolations-jl-high-order-interpolation-differentiation-integration-and-smoothing-on-discrete-grids-in-arbitrary-dimensions General /media/juliacon-2026/submissions/VAB77G/image_AFSDe5i.webp Nikolaj Maack Bielefeld en 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. false GitHub package repository flyer-VAB77G https://pretalx.com/juliacon-2026/talk/VAB77G/ https://pretalx.com/juliacon-2026/talk/VAB77G/feedback/ Muschel — N2 Long talk 2026-08-12T16:30:00+02:00 16:30 00:30 Real-time adaptive experimental design for ODE models is hard: each step requires costly posterior inference and optimization. We train a neural network policy offline to amortize this cost. The Julia SciML stack makes this practical: Enzyme.jl differentiates through ODEs, Lux.jl defines the policy network, and Reactant.jl compiles everything to a single GPU program. On a bioreactor benchmark, the learned adaptive policy beats Bayesian D-optimal static designs with a 99.5% win rate. juliacon-2026-92375-deep-adaptive-experimental-design-for-sciml General /media/juliacon-2026/submissions/SFWUKP/image_q6MaszL.webp Arno StrouwenSebastian Micluța-Câmpeanu en 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. false https://pretalx.com/juliacon-2026/talk/SFWUKP/ https://pretalx.com/juliacon-2026/talk/SFWUKP/feedback/ Muschel — N2 Short talk 2026-08-12T17:00:00+02:00 17:00 00:15 [BestieTemplate.jl](https://github.com/JuliaBesties/BestieTemplate.jl) is a template for creating packages following opinionated package development practices, first presented at [JuliaCon 2024](https://pretalx.com/juliacon2024/talk/9AMPUD/). This time, I'll talk about what has changed since then and try to attract some collaborators by talking about the process of adding a new question. juliacon-2026-93336-what-s-new-in-bestietemplate-jl General /media/juliacon-2026/submissions/D8SJCG/image_HYQ13dA.webp Abel Soares Siqueira en 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. false flyer-D8SJCG https://pretalx.com/juliacon-2026/talk/D8SJCG/ https://pretalx.com/juliacon-2026/talk/D8SJCG/feedback/ Muschel — N2 Short talk 2026-08-12T17:15:00+02:00 17:15 00:15 We’ll explore the interoperability of the Go programming language and Julia, from the angle of filling Julia’s capability gaps in Julia’s web and networking stacks by calling out to Go. The talk is based on the experience of leveraging Go’s gRPC client library within a Julia-based web server, and will focus on the nuances of the interoperability of the languages (e.g. how to pass data between the languages, handling Go’s asynchronous programming features, garbage collector). juliacon-2026-93462-leveraging-go-in-julia-a-story-of-interop General /media/juliacon-2026/submissions/8A73NK/image_ur6VD7k.webp Morten Piibeleht en 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. false https://pretalx.com/juliacon-2026/talk/8A73NK/ https://pretalx.com/juliacon-2026/talk/8A73NK/feedback/ Muschel — N3 Short talk 2026-08-12T10:00:00+02:00 10:00 00:15 Global grid systems (DGGS), or non-planar grids, are the new hotness - but how can you get data onto them and analyze? In this talk, we'll show the high-level way to do this, which packages you'll need, as well as how to handle issues like geometries on the boundaries of faces, regridding error, and more. In all likelihood you are familiar with DGGS already - in simulation, tripolar and cubed-sphere grids are common, as are HEALPIX and other formulations. juliacon-2026-88884-data-analysis-on-global-grid-systems Geospatial minisymposium /media/juliacon-2026/submissions/VMYLLT/image_WvO9gY7.webp Anshul Singhvi en 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. false https://pretalx.com/juliacon-2026/talk/VMYLLT/ https://pretalx.com/juliacon-2026/talk/VMYLLT/feedback/ Muschel — N3 Short talk 2026-08-12T10:15:00+02:00 10:15 00:15 Points on or near the Earth can be represented in many coordinate systems - e.g. LatLonAlt, ECEF Cartesian or WebMercator to name just three. Without careful design, the amount of code required to convert between these systems scales quadratically and therefore quickly becomes unmanageable. In this talk, I will show how MapMaths.jl leverages Julia's type system and metaprogramming features to eliminate this and related sources of combinatorial explosions in coordinate conversion libraries. juliacon-2026-92050-mapmaths-jl-leveraging-julia-for-flexible-and-fast-coordinate-transformations Geospatial minisymposium /media/juliacon-2026/submissions/XFLETV/image_gUIGjWb.webp Simon Etter en 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. false https://pretalx.com/juliacon-2026/talk/XFLETV/ https://pretalx.com/juliacon-2026/talk/XFLETV/feedback/ Muschel — N3 Short talk 2026-08-12T10:30:00+02:00 10:30 00:15 Discrete Global Grid Systems (DGGS) allow minimizing spatial distortions in geospatial image processing, among others. Here we present DGGS.jl, a Julia package to work with DGGS native data cubes using Zarr.jl and YAXArrays.jl. It transforms any raster image from a traditional projection into memory-efficient N-dimensional arrays, following one unified global coordinate system without overlapping tiles, e.g., for bounding box queries, spatial aggregation, or visualization in QGIS. juliacon-2026-92439-dggs-jl-discrete-global-grid-system-native-data-cubes Geospatial minisymposium /media/juliacon-2026/submissions/NEXMM8/image_QFZrcjH.webp Daniel Loos en 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. false flyer-NEXMM8 https://pretalx.com/juliacon-2026/talk/NEXMM8/ https://pretalx.com/juliacon-2026/talk/NEXMM8/feedback/ Muschel — N3 Short talk 2026-08-12T10:45:00+02:00 10:45 00:15 Earth system science needs user-friendly access to global observations. MetopDatasets.jl is a package to read native-format products from the Metop satellites, which play a key role in current global weather models through data assimilation. MetopDatasets.jl also demonstrates how the CommonDataModel.jl interface can be used to build a user-friendly reader for custom binary formats common in Earth sciences. juliacon-2026-92568-exploring-meteorological-satellite-observations-with-metopdatasets-jl Geospatial minisymposium /media/juliacon-2026/submissions/YKG9N9/image_fxJqkYP.webp Simon Kok Lupemba en false https://pretalx.com/juliacon-2026/talk/YKG9N9/ https://pretalx.com/juliacon-2026/talk/YKG9N9/feedback/ Muschel — N3 Short talk 2026-08-12T11:15:00+02:00 11:15 00:15 The SpatialTreeInterface defined in GeometryOps.jl provides an efficient way for geometrical queries of polygons that share a crs by relying on search trees whose branches are characterized by rectangular bounding boxes. However, when working across different projections, for example when trying to identify intersecting polygons from different projections on the sphere, rectangles in one projection do not translate into rectangles in another projection, so the tree traversal will not be accurate. To solve this problem, we extended the SpatialTreeInterface in SphericalSpatialTrees.jl by replacing rectangular bounding boxes with SphericalCaps, using these to characterize the extent of all branches in a spatial tree. This enables users to do combined tree searches across polygons based on different projections, as is common e.g. in Discrete Global Grid System. The presentation will demonstrate the basic concept of the SphericalSpatialTrees.jl package as well as a few downstream applications. I order to solve the problem of juliacon-2026-92667-fast-geospatial-lookups-across-projections-using-sphericalspatialtrees-jl Geospatial minisymposium /media/juliacon-2026/submissions/33JU7Y/image_xIyEkRY.webp Fabian Gans en false https://pretalx.com/juliacon-2026/talk/33JU7Y/ https://pretalx.com/juliacon-2026/talk/33JU7Y/feedback/ Muschel — N3 Short talk 2026-08-12T11:30:00+02:00 11:30 00:15 Spatial machine learning has become increasingly crucial for environmental prediction tasks. Yet, current workflows in R and Python face challenges when scaling to high‑resolution, national‑level mapping and when integrating modern uncertainty‑aware methods. In this talk, I present a new Julia‑based spatial machine learning framework for digital soil mapping, focusing on national soil organic carbon (SOC) prediction in Estonia. The approach combines Random Forest models, stacked meta‑learning, and conformal prediction through the MLJ ecosystem, while developing an integration port to Julia of the IGEO7 discrete global grid system (DGGS) to impose a hierarchical spatial structure. This approach targets persistent issues in spatial ML, such as autocorrelation, multi‑scale dependencies, and computational efficiency. It implements DGGS‑based multi‑resolution covariate aggregation, spatially aware cross‑validation, Shapley values, and area‑of‑applicability (AOA) assessment using the Dissimilarity Index method. Initial results demonstrate improved spatial fidelity, scalable high-resolution prediction, and more transparent communication of uncertainty. This work showcases how Julia’s speed and composability enable a modern, reproducible, and scalable approach to spatial machine learning in comparison to what conventional Python/R workflows currently offer. juliacon-2026-92743-spatial-machine-learning-for-digital-soil-mapping Geospatial minisymposium /media/juliacon-2026/submissions/8RGCRS/image_lj8c0IX.webp Alexander Kmoch en 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. false https://pretalx.com/juliacon-2026/talk/8RGCRS/ https://pretalx.com/juliacon-2026/talk/8RGCRS/feedback/ Muschel — N3 Short talk 2026-08-12T11:45:00+02:00 11:45 00:15 Reading and writing geospatial vector data is the bread and butter of any spatial ecosystem. In this short talk we present GeoDataFrames.jl, the default entrypoint for spatial vector data in the JuliaGeo organisation. We discuss recent and planned updates, such as support for native drivers and metadata passthrough, but also spatial indexing and lazy reading of datasets in the cloud. juliacon-2026-92781-state-of-geodataframes-jl Geospatial minisymposium /media/juliacon-2026/submissions/TRBDEP/image_jWLeT7P.webp Maarten Pronk en 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. false https://pretalx.com/juliacon-2026/talk/TRBDEP/ https://pretalx.com/juliacon-2026/talk/TRBDEP/feedback/ Muschel — N3 Short talk 2026-08-12T12:00:00+02:00 12:00 00:15 I've been talking about this for the last two years - but GeometryOps.jl is now finally on the sphere! This talk will give a brief update about GeometryOps with a focus on how the spherical capabilities have materialized, both in native Julia and by calling Google's s2 library. We'll also mention some new cool downstream applications, like ConservativeRegridding.jl and SphericalSpatialTrees.jl, and specifically how they relate to GeometryOps. juliacon-2026-93402-geometryops-jl-finally-on-the-sphere Geospatial minisymposium /media/juliacon-2026/submissions/9TXRNM/image_pO6hf4V.webp Anshul Singhvi en 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. false https://pretalx.com/juliacon-2026/talk/9TXRNM/ https://pretalx.com/juliacon-2026/talk/9TXRNM/feedback/ Muschel — N3 Short talk 2026-08-12T14:30:00+02:00 14:30 00:10 ATLAS is a global atmospheric chemistry and transport model with a focus on stratospheric chemistry, and in particular anthropogenic ozone depletion (the "ozone hole"). It was originally written in Matlab (starting in 2009) and has been rewritten in Julia in the last 5 years, resulting in a 10x speedup. We give an overview of the implementation and of the scientific results published in the last 15 years. juliacon-2026-92250-atlas-a-global-atmospheric-chemistry-and-transport-model-written-in-julia Earth system science in Julia /media/juliacon-2026/submissions/UVWQCA/image_0KddAud.webp Ingo Wohltmann en 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 false flyer-UVWQCA https://pretalx.com/juliacon-2026/talk/UVWQCA/ https://pretalx.com/juliacon-2026/talk/UVWQCA/feedback/ Muschel — N3 Short talk 2026-08-12T14:40:00+02:00 14:40 00:10 The snow cover plays a central role in many Earth system processes, for example influencing climate feed-back, the hydrological cycle, as well as glacier and ice sheet mass balance. Widely used snow cover models such as SNOWPACK (C++) and Crocus (Fortran) show strong performance in operational forecasting and scientific modeling. However, their still tightly entangled code bases make it difficult for the community to modify model components efficiently. This is due to technical dept as well as limitations of the programming languages itself. Recent advances in snow physics parameterizations have highlighted structural limitations in those models, underscoring the need for a more flexible modelling framework. To address these challenges, we present Helmut, a modular snow cover model implemented in Julia. Helmut combines a state‑of‑the‑art snow process equation solver within a design that emphasizes flexibility, and quick experimentation. Julia’s multiple dispatch allows Helmut users to extend or replace individual components—such as parameterizations, boundary‑conditions, or physical process formulations - efficiently. This enables domain scientists to contribute easily and test new advances with minimal friction. Helmut successfully reproduces simulations from existing snow models while offering a much more accessible framework for modifying model physics, testing new parameterizations, and experimenting with alternative numerical formulations. We further demonstrate how the structure enables exploration of the impacts of different parameterizations and physical configurations, making such investigations considerably easier. juliacon-2026-92549-helmut-a-modular-and-extensible-snow-cover-model Earth system science in Julia /media/juliacon-2026/submissions/LFPLJT/image_LzdsWdv.webp Patrick Leiberspergerde Fleurian Basile en 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. false flyer-LFPLJT https://pretalx.com/juliacon-2026/talk/LFPLJT/ https://pretalx.com/juliacon-2026/talk/LFPLJT/feedback/ Muschel — N3 Short talk 2026-08-12T14:50:00+02:00 14:50 00:10 [PinCFlow.jl](https://github.com/Atmospheric-Dynamics-GUF/PinCFlow.jl) is a fully Julia-based idealized atmospheric flow solver, primarily developed for gravity wave research. The model is highly efficient and integrates the Boussinesq, pseudo-incompressible, and compressible equations over arbitrary topography. Either high-resolution, wave-resolving simulations can be conducted, or simulations with parameterized gravity waves using the parameterization scheme MS-GWaM, where both transience and horizontal propagation of gravity waves are accounted for. juliacon-2026-92672-idealized-atmospheric-flow-and-gravity-wave-modeling-with-pincflow-jl Earth system science in Julia /media/juliacon-2026/submissions/VB7AEV/image_gBYDLwc.webp Irmgard Steiger en [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. false https://pretalx.com/juliacon-2026/talk/VB7AEV/ https://pretalx.com/juliacon-2026/talk/VB7AEV/feedback/ Muschel — N3 Short talk 2026-08-12T15:00:00+02:00 15:00 00:10 Physical effects in oceans span a vast range of both temporal and spatial scales, making it difficult to ensure that a single numerical model resolves all relevant processes within realistic computational limits. To capture effects that occur outside of the resolved scales, models need to include parameterizations that approximate the missing physics. In this work, we explore the use of online learning for parameterizations in a Julia based shallow water model. Here we use ShallowWaters.jl, a single layer ocean model, to test the capabilities of online learning for eddy backscatter parameterizations. Backscatter parameterizations represent the influence of geostrophic eddies, small-scale turbulent processes that play a large role in ocean energy dynamics. In particular, eddies facilitate the transfer of kinetic energy from small to large scales, an essential process for general ocean circulation. In the online learning framework our backscatter parameterization is given by a neural network (NN), converting ShallowWaters into a hybrid ocean model based on both physics and machine learning. To train the NN parameterization to capture sub-grid scale physics we use data assimilation techniques, and in particular this relies on the automatic differentiation (AD) tool Enzyme.jl to compute full-model gradients. This further expands ShallowWaters to be a fully differentiable shallow water model. Different loss functions are implemented, both spectral and state, to determine which most effectively improves the parameterization, and the resulting NN parameterizations are compared to an equation-discovery closure. This work expands on prior online learning research and further advances hybrid approaches for gradient-based model calibration in comprehensive, differentiable, ocean general circulation models. juliacon-2026-92693-online-calibration-of-a-neural-network-parameterization-in-shallowwaters-jl Earth system science in Julia /media/juliacon-2026/submissions/TGHPQ9/image_LBD4jKG.webp Sarah Williamson en true https://pretalx.com/juliacon-2026/talk/TGHPQ9/ https://pretalx.com/juliacon-2026/talk/TGHPQ9/feedback/ Muschel — N3 Short talk 2026-08-12T15:10:00+02:00 15:10 00:10 When snow falls, the landscape transforms into a sparkling white marvel. Beyond its beauty, snow is essential to human sustenance across large regions: it replenishes drinking water supplies, moderates our planet's temperature, drives hydropower production, and feeds irrigation systems. Yet snow also brings hazards. Avalanches pose a persistent threat in mountainous terrain, rapid snowmelt combined with heavy rainfall can trigger devastating floods, and intense snowfall events regularly disrupt road and air traffic at considerable economic cost. Preparing effectively for such events demands reliable forecasts of snow conditions. In Switzerland, where a substantial fraction of precipitation falls as snow, the WSL Institute for Snow and Avalanche Research (SLF) provides such forecasts using a physics-based snow modelling system recently implemented in the Julia programming language. These forecasts support avalanche and flood forecasting as well as weather-related hazard alerts. Our model is also used across a range of research projects, including efforts to improve inflow forecasts for Norwegian hydropower reservoirs and to better characterize snow dynamics on glaciers in high-mountain regions. Here, we present a brief overview of the operational use cases of this newly developed system alongside its research applications, together with a more detailed account of our technical implementation and the challenges encountered so far. We welcome feedback on our technical implementation and are eager to explore potential collaborations in which the model could be coupled with other Earth system models. juliacon-2026-92819-snow-modelling-for-operational-and-research-applications Earth system science in Julia /media/juliacon-2026/submissions/9RKTV9/image_UmKqooE.webp Jan Magnusson en true https://pretalx.com/juliacon-2026/talk/9RKTV9/ https://pretalx.com/juliacon-2026/talk/9RKTV9/feedback/ Muschel — N3 Short talk 2026-08-12T15:20:00+02:00 15:20 00:10 Traditionally, climate models are difficult to run for end users, and even harder to customize or interface with machine learning. We want to change that. Here, we present the ongoing development of SpeedyWeather.jl: A general circulation model that’s differentiable, GPU-capable and ready for machine learning integration. SpeedyWeather.jl is a spectral atmospheric general circulation model with an everything-flexible attitude. In this talk, we will give an overview of SpeedyWeather.jl’s development of the last year, in which we worked towards differentiability with Enzyme, GPU-capability with KernelAbstractions and Reactant and rewrote our parametrizations for better performance and more customisability. juliacon-2026-92721-speedyweather-jl-towards-a-differentiable-and-gpu-capable-general-circulation-model Earth system science in Julia /media/juliacon-2026/submissions/GB8WXW/image_9x34A1C.webp Maximilian GelbrechtMilan Klöwer en 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 false https://pretalx.com/juliacon-2026/talk/GB8WXW/ https://pretalx.com/juliacon-2026/talk/GB8WXW/feedback/ Muschel — N3 Short talk 2026-08-12T15:50:00+02:00 15:50 00:10 The Antarctic and Greenland Ice Sheets have experienced significant volume loss over the last decades, with a contribution of 0.1 m to sea-level rise that is bound to become significantly larger over the coming millennia. Under high-emission scenarios, they could contribute by as much as 18 mSLE by the year 3000, with dramatic consequences for coastal livelihood. Ice-sheet models are the central tool to produce such projections but generally present many limitations: they are not easily extensible by the user, they are difficult to couple to other Earth System model components, they lack interactivity and easy visualisation, they are sparsely documented, and they are often incompatible with modern software and hardware advancements, like automatic differentiation and GPU computing. To address this, we develop Pagos.jl, a continental ice-sheet model written in Julia that follows the philosophy paved by Oceananigans.jl and SpeedyWeather.jl: running simulations should be as easy and fun as playing Lego. Besides reducing the time to first plot compared to traditional models, this also offers a privileged framework to develop and test new physics and parameterisations. The user-friendliness of Pagos.jl allows a simple coupling to other Earth System model components and goes hand in hand with its computational efficiency. This allows the user to run simulations at the continental scale with resolutions of a few kilometres and address important scientific questions around grounding-line dynamics. juliacon-2026-90426-pagos-jl-play-ice-sheet-modelling-like-it-s-lego Earth system science in Julia /media/juliacon-2026/submissions/D8AMAJ/image_FG9KQz1.webp Jan Swierczek-Jereczek en false https://pretalx.com/juliacon-2026/talk/D8AMAJ/ https://pretalx.com/juliacon-2026/talk/D8AMAJ/feedback/ Muschel — N3 Short talk 2026-08-12T16:00:00+02:00 16:00 00:10 Global land surface and hydrological models are crucial components of Earth System Models (ESMs). In addition to providing realistic boundary conditions for the atmosphere and ocean components, they also play a key role in understanding Earth’s changing energy imbalance and the response of the terrestrial carbon and water cycles to anthropogenic climate change. Unlike atmosphere and ocean models, however, land models lack a fluid dynamical core and rely heavily on empirical parameterizations to represent many key processes. As such, there is a continued need for a new generation of land models which can facilitate the incorporation of data-driven components. Here we present Terrarium.jl, a Julia-based land modeling framework for GPU-accelerated and automatically differentiable simulations of soil, snow, and vegetation dynamics, along with their corresponding land-atmosphere exchange fluxes. We highlight how Julia’s key features enable unprecedented modularity in the model design and seamless GPU parallelization through KernelAbstractions.jl. We further demonstrate the value of GPU acceleration and differentiability through a series of performance benchmarks and sensitivity analyses. We also detail our initial experiments in achieving stable coupling to a reduced-complexity atmosphere model, SpeedyWeather.jl. juliacon-2026-92845-terrarium-jl-fully-differentiable-and-gpu-accelerated-land-modeling-at-all-scales-in-julia Earth system science in Julia /media/juliacon-2026/submissions/UETBSG/image_Mt0eKNC.webp Brian GroenkeMaximilian Gelbrecht en false https://pretalx.com/juliacon-2026/talk/UETBSG/ https://pretalx.com/juliacon-2026/talk/UETBSG/feedback/ Muschel — N3 Short talk 2026-08-12T16:10:00+02:00 16:10 00:10 `TrixiAtmo.jl` is there: a `Trixi.jl` spin-off, bringing Discontinuous Galerkin methods and Adaptive Mesh Refinement to Earth system modeling. We aim at kilometer-scale resolutions to resolve key physical processes and address historical stability concerns using entropy-conserving split-forms. Currently, we are on our way to extend `TrixiAtmo.jl` to handle realistic applications, and integrate with Julia's rich geoscience ecosystem. juliacon-2026-92633-trixiatmo-jl-advanced-numerical-schemes-for-atmospheric-flows Earth system science in Julia /media/juliacon-2026/submissions/V337P8/image_MwtMunb.webp Benedict Geihe en 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. false TrixiAtmo.jl https://pretalx.com/juliacon-2026/talk/V337P8/ https://pretalx.com/juliacon-2026/talk/V337P8/feedback/ Muschel — N3 Short talk 2026-08-12T16:20:00+02:00 16:20 00:10 The SINDBAD framework, with Sindbad.jl, SindbadTEM, OmniTools.jl, TimeSamplers.jl, and ErrorMetrics.jl packages offers a user‑friendly, Julia‑based system for terrestrial model–data integration. It enables scalable, differentiable experiments across spatial and temporal scales, supporting next‑generation understanding of vegetation–water–carbon interactions. juliacon-2026-92788-strategies-to-integrate-data-and-biogeochemical-models-sindbad-julia-framework-for-terrestrial-ecosystem-model-data-integration Earth system science in Julia /media/juliacon-2026/submissions/QSV7XN/image_yDXIJ9o.webp Sujan KoiralaFabian GansFelix CremerLazaro AlonsoNuno Carvalhais en 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. false flyer-QSV7XN https://pretalx.com/juliacon-2026/talk/QSV7XN/ https://pretalx.com/juliacon-2026/talk/QSV7XN/feedback/ Muschel — N3 Short talk 2026-08-12T16:30:00+02:00 16:30 00:10 [JustRelax.jl](https://github.com/PTsolvers/JustRelax.jl) ([de Montserrat et al., (2026)](https://joss.theoj.org/papers/10.21105/joss.09365)) is an open-source, highly portable, and high-performance package designed for geodynamic modeling. It employs the Accelerated Pseudo-Transient (APT) method to solve the Stokes and diffusion equations, making it well-suited to exploit Graphics Processing Units (GPUs). It incorporates a wide range of features critical to computational geodynamics, including complex and highly non-linear rheologies, free surface, and a particle-in-cell method to advect material information. juliacon-2026-93334-multi-physics-geophysical-flow-simulations-using-justrelax-jl Earth system science in Julia /media/juliacon-2026/submissions/AFFXGE/image_78bUETj.webp Pascal AelligChristianAlbert de Montserrat Navarro en 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 false https://pretalx.com/juliacon-2026/talk/AFFXGE/ https://pretalx.com/juliacon-2026/talk/AFFXGE/feedback/ Muschel — N3 Short talk 2026-08-12T16:40:00+02:00 16:40 00:10 Scientific modeling often forces a choice between flexible but opaque neural networks and interpretable process-based models that can be too rigid for real-world data. Hybrid modeling bridges this gap by combining mechanistic structure with machine-learning flexibility. In this talk we introduce EasyHybrid.jl, a user-friendly Julia package that makes hybrid modeling accessible across disciplines. We demonstrate the approach on a concrete problem: partitioning eddy-covariance net carbon fluxes into photosynthesis (a CO₂ sink) and ecosystem respiration (a CO₂ source), while estimating how strongly respiration responds to temperature. Temperature sensitivity is summarized by Q10, the factor by which respiration changes for a 10 K warming (e.g., Q10 = 2 means doubles per 10 K). We present cross-site results across hundreds of FLUXNET eddy covariance towers and show that, even when inferred jointly with hybrid flux partitioning, the learned temperature sensitivity exhibits a relatively narrow convergence across ecosystems. juliacon-2026-92606-hybrid-flux-partitioning-in-julia-learning-temperature-sensitivity-of-ecosystem-respiration-with-easyhybrid-jl Earth system science in Julia /media/juliacon-2026/submissions/DTEEQC/image_AcI5RD8.webp Bernhard AhrensRITESH MOONLazaro Alonso en 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. false https://pretalx.com/juliacon-2026/talk/DTEEQC/ https://pretalx.com/juliacon-2026/talk/DTEEQC/feedback/ Muschel — N3 Short talk 2026-08-12T16:50:00+02:00 16:50 00:10 [MovingBoundaryMinerals.jl](https://github.com/AnStroh/MovingBoundaryMinerals.jl) ([Stroh et al., 2025](https://gmd.copernicus.org/articles/18/10203/2025/)) is a Finite Element package to model diffusion-limited growth. The package combines grid refinement together with a moving boundary in order to resolve sharp gradients next to the interface of growing crystals. The moving boundary is treated via a thermodynamically-consistent diffusion solver. We provide benchmarks and examples that can be used in petrology and materials science. juliacon-2026-91954-movingboundaryminerals-jl-modelling-diffusion-limited-growth-in-diffusion-couples Earth system science in Julia /media/juliacon-2026/submissions/Z8Y8GP/image_y4hzT5A.webp Annalena StrohPascal Aellig en 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. false https://pretalx.com/juliacon-2026/talk/Z8Y8GP/ https://pretalx.com/juliacon-2026/talk/Z8Y8GP/feedback/ Muschel — N3 Short talk 2026-08-12T17:00:00+02:00 17:00 00:10 Hybrid climate modelling combines numerical models with machine-learned components. We present the development of multiple machine-learned surface climate processes and their integration into the climate model SpeedyWeather.jl using PyTorch and Lux.jl. Despite the offline training, the hybrid model is designed to generalise in space and to different climates. We address speed vs. accuracy tradeoffs using SymbolicRegression.jl and discuss online learning with Enzyme.jl. juliacon-2026-92837-a-learned-surface-roughness-scheme-for-climate-prediction-in-speedyweather-jl Earth system science in Julia /media/juliacon-2026/submissions/U9ZWXZ/image_oun3O91.webp Greg MundayMaximilian GelbrechtMilan KlöwerNiklas Viebig en 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 false flyer-U9ZWXZ https://pretalx.com/juliacon-2026/talk/U9ZWXZ/ https://pretalx.com/juliacon-2026/talk/U9ZWXZ/feedback/ Alte Mensa — Audi Max Short talk 2026-08-12T10:00:00+02:00 10:00 00:15 The spectroscopy of exotic hadrons enables probing the dynamics of the strong interaction beyond the conventional quark–antiquark and three–quark picture. Measurements at the LHCb experiment revealed the doubly charmed tetraquark Tcc⁺ and provided new high-precision data relevant for understanding the structure of the X(3872). Interpreting such near-threshold systems requires accurate modeling of threshold effects, multi-body dynamics, and technically advanced statistical inference. We present a Julia-based analysis ecosystem developed for studies of these states using LHCb data. The workflow combines established Julia packages for statistical modeling and minimization with specialized tools tailored for hadron spectroscopy. Core functionality relies on packages such as Distributions.jl, NumericalDistributions.jl and Minuit2.jl, extended by domain-specific probability distributions implemented in DistributionsHEP.jl. Several dedicated physics packages provide modular building blocks for amplitude models and line-shape calculations. These include X3872Flatte.jl, X3872ThreeBodyLineshape.jl, and xDDPhaseSpace.jl, implementing threshold line shapes, three-body kinematics, and phase-space constructions relevant for near-threshold charm systems. Complete analyses are developed in separate private repositories operating on collaboration-internal data and likelihood models; the software is released publicly once the corresponding analyses are published. A key component of the workflow is BuildConstructors.jl, a framework providing long-awaited granular control over complex fitting strategies. It enables structured construction of likelihood fits with systematic parameter management, including controlled fixing and releasing of parameters during iterative block likelihood fits. Together these packages support complex spectroscopy analyses while extending the Julia ecosystem with tools for amplitude modeling and likelihood-based inference. They simplify the development of advanced analysis strategies and make Julia more accessible for future analyses in experimental particle physics. juliacon-2026-93316-amplitude-analysis-of-exotic-multiquark-states-with-julia-in-the-lhcb-experiment JuliaHEP Mini 2026 - Julia for Nuclear and Elementary Particle Physics /media/juliacon-2026/submissions/WDZ3AN/image_dPEFqEz.webp Mikhail MikhasenkoRobert Hentges en false https://pretalx.com/juliacon-2026/talk/WDZ3AN/ https://pretalx.com/juliacon-2026/talk/WDZ3AN/feedback/ Alte Mensa — Audi Max Short talk 2026-08-12T10:15:00+02:00 10:15 00:15 Whilst the majority of Universities have pivoted increasingly to Python as the primary (and in some cases, only) teaching language for Undergraduate Physics, there are compelling reasons to introduce Julia as a target language. This is not without precedent: Engineering departments in multiple countries (Germany, USA...) have used Julia as a teaching language for some years, due to the ease of porting mathematical expressions to it, and its similarity to MATLAB. I discuss the motivations for doing so in Physics, and some experiences of introducing Julia in a structured way to undergraduate students at the University of Glasgow (although not in a formal course). juliacon-2026-93472-experiences-of-julia-versus-other-languages-as-educational-targets-for-undergraduate-physicists JuliaHEP Mini 2026 - Julia for Nuclear and Elementary Particle Physics /media/juliacon-2026/submissions/3RXM3H/image_aVOnvbt.webp Sam Skipsey en false https://pretalx.com/juliacon-2026/talk/3RXM3H/ https://pretalx.com/juliacon-2026/talk/3RXM3H/feedback/ Alte Mensa — Audi Max Long talk 2026-08-12T10:30:00+02:00 10:30 00:30 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. juliacon-2026-93442-parallel-processing-in-jetreconstruction-jl JuliaHEP Mini 2026 - Julia for Nuclear and Elementary Particle Physics /media/juliacon-2026/submissions/F3FBUY/image_kKBgaEk.webp Unnamed speakerGraeme StewartUnnamed speaker en 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. false https://pretalx.com/juliacon-2026/talk/F3FBUY/ https://pretalx.com/juliacon-2026/talk/F3FBUY/feedback/ Alte Mensa — Audi Max Long talk 2026-08-12T11:00:00+02:00 11:00 00:30 In this talk, we present techniques for implementing efficient GPU-based random sampling algorithms, including rejection sampling and multi-stage sampling pipelines using KernelAbstractions.jl. We discuss strategies to avoid costly synchronizations between host and device, manage divergent execution flows, and schedule heterogeneous workloads entirely on device. Particular attention is given to structuring rejection sampling and sequential transport algorithms in ways that preserve GPU occupancy while maintaining statistical correctness. To demonstrate the applicability of these techniques, we present results from two Julia packages developed for plasma and high-energy physics applications. The first, QEDevents.jl, focuses on Monte-Carlo event generation for high-multiplicity scattering processes in quantum electrodynamics, building on the generic sampling framework RejectionSamplers.jl and the QuantumElectrodynamics.jl ecosystem. The second, PhotonTransport.jl implements a Monte-Carlo photon transport code for warm-dense matter. Together, these case studies illustrate how Julia enables both the expressive implementation of parallel sampling algorithms and near-peak accelerator performance, while maintaining portability across hardware backends. juliacon-2026-93465-performance-portable-random-sampling-in-julia-event-generation-and-particle-transport-on-gpus JuliaHEP Mini 2026 - Julia for Nuclear and Elementary Particle Physics /media/juliacon-2026/submissions/DAY8TS/image_teg3OpC.webp Uwe Hernandez Acosta en 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. false https://pretalx.com/juliacon-2026/talk/DAY8TS/ https://pretalx.com/juliacon-2026/talk/DAY8TS/feedback/ Alte Mensa — Audi Max Short talk 2026-08-12T11:30:00+02:00 11:30 00:15 A quick overview of the new Raytracing backend, with live demos, technical insights and how it can be used for JuliaHEP. juliacon-2026-93396-makie-s-new-raytracing-backend JuliaHEP Mini 2026 - Julia for Nuclear and Elementary Particle Physics /media/juliacon-2026/submissions/AZM7B7/image_PknlVvw.webp Simon Danisch en false https://pretalx.com/juliacon-2026/talk/AZM7B7/ https://pretalx.com/juliacon-2026/talk/AZM7B7/feedback/ Alte Mensa — Audi Max Short talk 2026-08-12T11:45:00+02:00 11:45 00:15 We present a Julia-based workflow for the analysis of exclusive multibody processes in collider data with the LHCb experiment. The pipeline covers ROOT I/O with UnROOT.jl, transformation of event data into tabular representations, construction of physics-motivated kinematic variables for multibody final states such as invariant masses and helicity angles, and statistical fitting. We also demonstrate reproducible analysis infrastructure in Julia, including composable scripts, environment and dependency management, artifact handling, and systematic reruns of the full analysis chain. juliacon-2026-93481-julia-for-data-analysis-in-lhcb-experiment JuliaHEP Mini 2026 - Julia for Nuclear and Elementary Particle Physics /media/juliacon-2026/submissions/HXMUHB/image_0U8rLHX.webp Ilya Segal en false flyer-HXMUHB https://pretalx.com/juliacon-2026/talk/HXMUHB/ https://pretalx.com/juliacon-2026/talk/HXMUHB/feedback/ Alte Mensa — Audi Max Long talk 2026-08-12T12:00:00+02:00 12:00 00:30 The **L**arge **E**nriched **Ge**rmanium Experiment for **N**eutrinoless $\beta\beta$ **D**ecay (LEGEND) experimental program is dedicated to the search for the neutrinoless double-beta ($0\nu\beta\beta$) decay of $^{76}\mathrm{Ge}$ with isotopically enriched high-purity germanium (HPGe) detectors and a discovery sensitivity beyond a half-life of $10^{28}$ years. The project's first phase, LEGEND-200, has stably accumulated physics data at the Laboratori Nazionali del Gran Sasso (LNGS). The first unblinding revealed a new best global limit of $T_{0\nu}^{1/2}>1.9\cdot{10}^{26}\, \mathrm{yr}$ (90% confidence level). We present an update on our ongoing end-to-end analysis of the experiment with the Julia LEGEND Software (JuLeS). This session will focus on the advancements of JuLeAna (Julia LEGEND Analysis) and its application to the current LEGEND data. Key subjects will include performance evaluation, data management, the GPU-accelerated Digital Signal Processing (DSP) framework, calibration and spectral fitting routines, event reconstruction, as well as IO performance. Additionally, we will provide a brief demonstration highlighting the enhancements within our customized SLURM-based parallel processing environment. This work is supported by the U.S. DOE, and the NSF, the LANL, ORNL and LBNL LDRD programs; the European ERC and Horizon programs; the German DFG, BMBF, and MPG; the Italian INFN; the Polish NCN and MNiSW; the Czech MEYS; the Slovak RDA; the Swiss SNF; the UK STFC; the Canadian NSERC and CFI; the LNGS and SURF facilities. juliacon-2026-93474-the-legend-experiment-how-to-run-an-entire-experiment-in-julia JuliaHEP Mini 2026 - Julia for Nuclear and Elementary Particle Physics /media/juliacon-2026/submissions/HVZZQM/image_b27DZq0.webp Florian Henkes en false https://pretalx.com/juliacon-2026/talk/HVZZQM/ https://pretalx.com/juliacon-2026/talk/HVZZQM/feedback/ Alte Mensa — Audi Max Long talk 2026-08-12T12:30:00+02:00 12:30 00:30 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. juliacon-2026-103854-panel-discussion-what-s-next-for-juliahep-from-wrappers-to-community JuliaHEP Mini 2026 - Julia for Nuclear and Elementary Particle Physics /media/juliacon-2026/submissions/ZSLQ7J/image_lLJi5Or.webp Uwe Hernandez Acosta en 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. false https://pretalx.com/juliacon-2026/talk/ZSLQ7J/ https://pretalx.com/juliacon-2026/talk/ZSLQ7J/feedback/ Alte Mensa — Audi Max Short talk 2026-08-12T14:30:00+02:00 14:30 00:15 Structured light in interaction with matter has been of interest, particularly as it relates to the production of high intensity gamma beams. In our package, [ElectronDynamicsModels.jl]([url](https://github.com/SebastianM-C/ElectronDynamicsModels.jl)), we developed a way to efficiently compute the radiated field resulting from the scattering of a Laguerre-Gauss laser beam off a thin sheet of electrons. The electrons are represented as relativistic classical particles whose motion is integrated using _DifferentialEquations.jl_. _ModellingToolkit.jl_ was used to formulate the model, allowing us to take advantage of its compiler to generate efficient _Julia_ code. Moreover, this also enables an easy scaling to parallel ensemble simulations on the CPU and GPU. Besides performance, this approach is also useful for enabling higher precision computations, which naturally leverage _Julia_'s multiple dispatch. Once the trajectories are known, the far electromagnetic field can be computed over a grid of pixels from the Lienardt-Wiechert potentials, and finally we compute their Fourier transform. juliacon-2026-92770-a-purely-numeric-approach-to-the-nonlinear-coherent-thomson-scattering-by-structured-light Computational Physics Minisymposium /media/juliacon-2026/submissions/N7CSPV/image_jFVNVAM.webp Petru-Vlad TOMASebastian Micluța-Câmpeanu en 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. false flyer-N7CSPV https://pretalx.com/juliacon-2026/talk/N7CSPV/ https://pretalx.com/juliacon-2026/talk/N7CSPV/feedback/ Alte Mensa — Audi Max Short talk 2026-08-12T14:45:00+02:00 14:45 00:15 Matching the swimming efficiency and agility of fish has remained an elusive goal in underwater robotics — one that demands accurate simulation of complex vortex interactions between a robot's body and the surrounding fluid. These dynamics, governed by coupled ordinary and partial differential equations, pose far greater computational challenges than the multi-body dynamics of classical rigid robotic systems. We present Aquarium 2.0, a Julia framework for simulating strongly coupled fluid-robot multiphysics as a unified optimization problem. The coupled manipulator and incompressible Navier-Stokes equations are derived together from a single Lagrangian using the principle of least action, and we employ discrete variational mechanics to obtain a stable, well-conditioned, and physically accurate scheme for jointly simulating articulated bodies and their surrounding fluid. Derivatives of the fully coupled dynamics are computed via the implicit function theorem, making the simulator directly amenable to gradient-based optimization within Julia's scientific computing ecosystem. We showcase various swimming demonstrations of a bioinspired swimming robot, including forward undulation and a highly dynamic, optimized C-start escape maneuver. Both gaits are validated on physical hardware, demonstrating successful sim-to-real transfer. juliacon-2026-93475-aquarium-2-0-realizing-robotic-swimming-with-differentiable-fluid-structure-interaction-simulation Computational Physics Minisymposium /media/juliacon-2026/submissions/WKD3CN/image_eZh2HUe.webp JJ Lee en false https://pretalx.com/juliacon-2026/talk/WKD3CN/ https://pretalx.com/juliacon-2026/talk/WKD3CN/feedback/ Alte Mensa — Audi Max Short talk 2026-08-12T15:00:00+02:00 15:00 00:15 [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. juliacon-2026-92531-fewbodytoolkit-jl-solving-2-and-3-body-quantum-systems-in-1d-3d-with-general-potentials Computational Physics Minisymposium /media/juliacon-2026/submissions/LP7GLM/image_d2X195U.webp Lucas Happ en [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. false https://pretalx.com/juliacon-2026/talk/LP7GLM/ https://pretalx.com/juliacon-2026/talk/LP7GLM/feedback/ Alte Mensa — Audi Max Short talk 2026-08-12T15:15:00+02:00 15:15 00:15 Lattice QCD simulations are restricted by both massive computational costs and high memory requirements. To simulate large physical volumes, distributing the lattice across multiple GPUs is essential. We present JuliaQCD, a native Julia ecosystem designed for computations on HPCs. By integrating JACC.jl for vendor-neutral GPU kernels and MPI.jl for lattice decomposition, we enable simulations on lattices that exceed the memory capacity of a single device while maintaining high performance. juliacon-2026-92632-implementing-lattice-qcd-to-multi-gpu-systems-with-juliaqcd Computational Physics Minisymposium /media/juliacon-2026/submissions/VSZT9C/image_95rWkMF.webp Ho Hsiao en 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. false https://pretalx.com/juliacon-2026/talk/VSZT9C/ https://pretalx.com/juliacon-2026/talk/VSZT9C/feedback/ Alte Mensa — Audi Max Long talk 2026-08-12T15:30:00+02:00 15:30 00:30 Lattice Quantum Chromodynamics (Lattice QCD) is a first-principles approach to strongly interacting gauge theories and requires large-scale high-performance computing. Production codes in this field have traditionally been written in C, C++, or Fortran. JuliaQCD is a Lattice QCD simulation framework written entirely in Julia, developed to explore whether a high-level language can support both rapid development and large-scale HPC simulations. The framework provides distributed-memory parallelism via MPI and achieves competitive performance on modern CPUs and GPUs while keeping lattice field operations and data structures modular and expressive through multiple dispatch. In our recent work [1], we extend JuliaQCD by introducing compiler-level reverse-mode automatic differentiation for the first time. Using LLVM-based AD, Hybrid Monte Carlo (HMC) force terms are generated directly from the action code, removing the need for separately derived and manually maintained force implementations. We validate the correctness of the automatically generated forces and examine their performance relative to conventional hand-written implementations. This work demonstrates how Julia can support both conventional HPC-style implementations and more modern compiler-based techniques within a single, coherent framework for large-scale scientific computing. [1] Yuki Nagai, Akio Tomiya, Hiroshi Ohno, "Lattice Gauge Theory via LLVM-Level Automatic Differentiation", arXiv:2602.20516 juliacon-2026-92621-juliaqcd-a-pure-julia-framework-for-lattice-qcd-and-its-extension-with-compiler-level-automatic-differentiation Computational Physics Minisymposium /media/juliacon-2026/submissions/NDZHNQ/image_1ufvRw7.webp Yuki Nagai en false https://pretalx.com/juliacon-2026/talk/NDZHNQ/ https://pretalx.com/juliacon-2026/talk/NDZHNQ/feedback/ Alte Mensa — Audi Max Short talk 2026-08-12T16:00:00+02:00 16:00 00:15 I rebuilt my PhD ray-tracing code for higher-dimensional black objects from MATLAB to Julia, resolving numerical issues and achieving major performance gains. Julia’s language features and ecosystem let me simplify the architecture, improve performance, and achieve previously inaccessible results. I’ll show key techniques and performance tricks that made the rewrite both faster and cleaner. juliacon-2026-92881-multidimension-raytracing-with-julia Computational Physics Minisymposium /media/juliacon-2026/submissions/9ARMTY/image_LdSk6BS.webp Tom Lemmens en 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. false https://pretalx.com/juliacon-2026/talk/9ARMTY/ https://pretalx.com/juliacon-2026/talk/9ARMTY/feedback/ Alte Mensa — Audi Max Short talk 2026-08-12T16:15:00+02:00 16:15 00:15 Lattice QCD is one of the most computationally demanding problems in theoretical physics, requiring large-scale parallel computation and sophisticated numerical algorithms. JuliaQCD is an open-source project that implements lattice QCD simulations in Julia, with an emphasis on performance portability across different computer architectures. By leveraging Julia’s abstraction mechanisms and multiple dispatch, the framework enables rapid prototyping, flexible algorithm development, and high-performance execution on a wide range of computing platforms. In this project, we focus on the domain-wall fermion formulation and construct a numerical optimization framework to tune its free parameters by minimizing selected physical observables, such as the effective mass. We discuss how this approach can be implemented efficiently within the JuliaQCD code base while maintaining readability and flexibility of the code. To enable large-scale simulations, we employ MPI-based parallelization and demonstrate production runs on the Fugaku supercomputer, where Julia is not pre-installed. We address practical challenges of deploying Julia on such systems, including building the Julia runtime, integrating with the system MPI libraries, and preparing job scripts and execution environments. We will present the physical motivation, software architecture, implementation strategies on Fugaku and related HPC systems, scaling and performance results for domain-wall fermions, and plans for the open-source release of these developments within JuliaQCD. juliacon-2026-92571-parameter-optimization-of-domain-wall-fermion-based-on-machine-learning-framework Computational Physics Minisymposium /media/juliacon-2026/submissions/E7N39Z/image_LhAwfW0.webp Kenta Yoshimura en false https://pretalx.com/juliacon-2026/talk/E7N39Z/ https://pretalx.com/juliacon-2026/talk/E7N39Z/feedback/ Alte Mensa — Audi Max Long talk 2026-08-12T16:30:00+02:00 16:30 00:30 Open-source software (OSS) is a practical way to ensure reproducibility and avoid reinventing the wheel in computational physics. In particular, few-body systems physics has various targets and various software requirements, so we are building an open-source ecosystem in Julia as a shared infrastructure with reusability and extensibility. In this talk, we introduce the architectural design and development roadmap derived from system-level testability and report the current development status. juliacon-2026-92546-testability-first-design-for-few-body-systems-physics Computational Physics Minisymposium /media/juliacon-2026/submissions/UFKC3U/image_p0oTYlV.webp Shuhei OhnoMartin Mikkelsen en 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. false flyer-UFKC3U https://pretalx.com/juliacon-2026/talk/UFKC3U/ https://pretalx.com/juliacon-2026/talk/UFKC3U/feedback/ Alte Mensa — Audi Max Short talk 2026-08-12T17:00:00+02:00 17:00 00:15 Inside atomic nuclei, "empty space" is not empty: the strong force comes from a gluon field that fluctuates and binds quarks into protons and neutrons. Lattice QCD computes this by simulating QCD on a grid in space and time, usually on supercomputers. VisualizingQCD.jl, a JuliaQCD package, turns your own configuration files into 3D movies of local observables, so Julia users can see, debug, and share the quantum vacuum. juliacon-2026-92665-visualizinglqcd-jl-visualization-of-quantum-vacuum Computational Physics Minisymposium /media/juliacon-2026/submissions/T9CVPT/image_3h6vw7d.webp Akio Tomiya en 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. false flyer-T9CVPT https://pretalx.com/juliacon-2026/talk/T9CVPT/ https://pretalx.com/juliacon-2026/talk/T9CVPT/feedback/ Alte Mensa — Audi Max Short talk 2026-08-12T17:15:00+02:00 17:15 00:15 RayTraceHeatTransfer.jl is a package for thermal radiation heat transfer calculations in Julia. The package features new methods which guarantee energy conservation and physically correct results, across the wavelength spectrum and for user-specified domains. In 1D and 2D the package handles volumetric radiation, relevant in combustion, climate sciences and astrophysics and in 3D it handles surface radiation, relevant in engineering design. juliacon-2026-92179-what-s-new-in-raytraceheattransfer-jl-since-juliacon2024 Computational Physics Minisymposium /media/juliacon-2026/submissions/MKW7DV/image_F9rvI8A.webp Nikolaj Maack Bielefeld en 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. false ArXiv article presenting the fundamental method and guarantees GitHub package repository JuliaCon2024 Eindhoven presentation flyer-MKW7DV https://pretalx.com/juliacon-2026/talk/MKW7DV/ https://pretalx.com/juliacon-2026/talk/MKW7DV/feedback/ Alte Mensa — Atrium Maximum Short talk 2026-08-12T10:00:00+02:00 10:00 00:15 This talk explores algebraic methods for quantum control polynomial optimization problems. We show how degeneracy, numerical stability and scalability are central issues in quantum control and how ConicSolve.jl has been extended to use face reduction and symmetry reduction (via the Wedderburn decomposition). We close with open questions and further work so such tools may become a practical reality. We hope that this work acts as a foundation for further research, new tools and methods for realizing quantum control systems where certification and high precision are paramount. juliacon-2026-92359-reduction-methods-for-sum-of-squares-programming-applied-to-quantum-control-problems Symbolic and Numerical Methods in (Nonlinear) Algebra /media/juliacon-2026/submissions/7U7ERV/image_T4GpVhJ.webp Alexander Leong en 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. false https://pretalx.com/juliacon-2026/talk/7U7ERV/ https://pretalx.com/juliacon-2026/talk/7U7ERV/feedback/ Alte Mensa — Atrium Maximum Short talk 2026-08-12T10:15:00+02:00 10:15 00:15 I present Giac.jl, a Julia interface to Giac, the open-source computer algebra system behind Xcas, GeoGebra and HP Prime. Giac.jl relies on libgiac-julia-wrapper for FFI (ie foreign function interface) bindings to the C++ library. Around it, companion packages extend Giac into the notebook world: MathJSON.jl handles the MathJSON interchange format, PlutoMathInput.jl provides a WYSIWYG MathField widget for Pluto, and MathJSONComputeEngineBridge.jl connects them. I demonstrate this workflow live in a reactive Pluto notebook. juliacon-2026-92466-giac-jl-bringing-the-giac-computer-algebra-system-to-julia-from-ffi-bindings-to-interactive-pluto-notebooks Symbolic and Numerical Methods in (Nonlinear) Algebra /media/juliacon-2026/submissions/XMMZE7/image_aCNgeB7.webp Sébastien Celles en 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. false https://pretalx.com/juliacon-2026/talk/XMMZE7/ https://pretalx.com/juliacon-2026/talk/XMMZE7/feedback/ Alte Mensa — Atrium Maximum Short talk 2026-08-12T10:30:00+02:00 10:30 00:15 We present CertifiedHomotopyTracking.jl, a Julia package for certified homotopy tracking. Homotopy path tracking has been used as an effective method across diverse fields, but its outputs are not certified. Our package ensures correctness using interval arithmetic (via Nemo.jl). The package uses Symbolics.jl to construct systems via SLPs. Based on this, it automates monodromy group analysis through GAP integration. Finally, we discuss interaction with HomotopyContinuation.jl and Pandora.jl. juliacon-2026-92532-certified-homotopy-and-monodromy-computation-in-julia Symbolic and Numerical Methods in (Nonlinear) Algebra /media/juliacon-2026/submissions/YJVVDR/image_oegQ0pH.webp Kisun Lee en 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. false GitHub repo for the package (under development) https://pretalx.com/juliacon-2026/talk/YJVVDR/ https://pretalx.com/juliacon-2026/talk/YJVVDR/feedback/ Alte Mensa — Atrium Maximum Short talk 2026-08-12T10:45:00+02:00 10:45 00:15 Due to the nature of data in computer algebra, the storage of such data requires a more sophisticated format. The mrdi file format is a JSON based file format with the necessary structure for saving and loading common types among computer algebra software. The first implementation for serializing mrdi files has been written in the computer algebra system Oscar.jl. We present the format as well as some design decisions for the implementation in Oscar.lj juliacon-2026-92576-serialization-of-algebraic-data Symbolic and Numerical Methods in (Nonlinear) Algebra /media/juliacon-2026/submissions/S7ANGA/image_0TAv2RE.webp Antony Della Vecchia en false https://pretalx.com/juliacon-2026/talk/S7ANGA/ https://pretalx.com/juliacon-2026/talk/S7ANGA/feedback/ Alte Mensa — Atrium Maximum Long talk 2026-08-12T11:15:00+02:00 11:15 00:30 [OSCAR](https://www.oscar-system.org/) is a general-purpose computer algebra system written in julia that builds on the four cornerstones GAP, polymake, Singular, and Antic (Hecke, Nemo) and has capabilities for dealing with problems in number theory, group and representation theory, tropical and polyhedral geometry, algebraic geometry, commutative algebra, non-commutative algebra, and many more areas of computer algebra. It is being developed as part of the [SFB-TRR 195 "Symbolic Tools in Mathematics and their Application"](https://www.computeralgebra.de/sfb/), which is supported by the German Research Foundation (DFG). In the first part of the talk, we will give an introduction to the philosophy behind OSCAR and discuss questions like "What is computer algebra and why do I need it?", "Why yet another computer algebra system?", "Why did you choose julia?", and "How does OSCAR compare to other similar tools like [Symbolics.jl](https://github.com/JuliaSymbolics/Symbolics.jl) and [HomotopyContinuation.jl](https://www.juliahomotopycontinuation.org/)?" In the second part, we show some very introductory examples of how to use OSCAR. These are not intended to be mathematically interesting at all. Instead, any listener with an introductory course of algebra should be able to easily follow the mathematics involved, so that we can put more emphasis on the key usage principles and syntax. juliacon-2026-92701-the-oscar-computer-algebra-system Symbolic and Numerical Methods in (Nonlinear) Algebra /media/juliacon-2026/submissions/ZPMNJZ/image_PhpHhF3.webp Lars Göttgens en false https://pretalx.com/juliacon-2026/talk/ZPMNJZ/ https://pretalx.com/juliacon-2026/talk/ZPMNJZ/feedback/ Alte Mensa — Atrium Maximum Short talk 2026-08-12T11:45:00+02:00 11:45 00:15 Graphical models encode dependencies between variables through graphs whose implied statistical models obey algebraic constraints. We show how symbolic computation in the Julia package OSCAR enables causal effect estimation in such models. Using Groebner basis elimination, we resolve linear parameter identification beyond classical criteria and demonstrate a reproducible Julia workflow on a real data example. juliacon-2026-93415-graphical-modeling-with-symbolic-algebra-in-oscar-jl Symbolic and Numerical Methods in (Nonlinear) Algebra /media/juliacon-2026/submissions/NWDQSQ/image_q7yuvdi.webp Leopold Mareis en 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. false https://pretalx.com/juliacon-2026/talk/NWDQSQ/ https://pretalx.com/juliacon-2026/talk/NWDQSQ/feedback/ Alte Mensa — Atrium Maximum Short talk 2026-08-12T12:00:00+02:00 12:00 00:15 In 1987, Eugenii Shustin published an article titled "A New M-Curve of Degree 8". This article contains the construction of a polynomial in two variables, whose set of zeros forms a so-called M-curve. In this talk, we will go into detail of the problems we encountered, when attempting to reproduce this construction using Oscar.jl in Julia. juliacon-2026-92760-modeling-algebraic-curves-with-oscar-jl Symbolic and Numerical Methods in (Nonlinear) Algebra /media/juliacon-2026/submissions/XKMGRR/image_lOb951d.webp Lars Kastner en 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? false flyer-XKMGRR https://pretalx.com/juliacon-2026/talk/XKMGRR/ https://pretalx.com/juliacon-2026/talk/XKMGRR/feedback/ Alte Mensa — Atrium Maximum Short talk 2026-08-12T12:15:00+02:00 12:15 00:15 Parametric linear matrix inequalities (LMIs) arise in optimization and control. A key question, motivated by the automation of convergence analysis of numerical optimization schemes, is to understand how their feasibility depends on parameters. In this talk, I present an approach that turns parametric LMI feasibility into parametric polynomial equations with constraints. The resulting parameter space can then be analyzed using real root classification based on Hermite's quadratic forms. I will show how this approach is implemented in Julia (notably Nemo.jl and AlgebraicSolving.jl, with real-geometry backends where appropriate), with efficient techniques such as multivariate rational interpolation. Finally, I will show that our implementation cleanly detects regions of parameter space where convergence properties change, for parametric LMIs arising from convergence analyses of first-order optimization methods. juliacon-2026-92890-solving-parametric-lmis-via-real-root-classification-a-julia-approach-to-automated-convergence-analysis Symbolic and Numerical Methods in (Nonlinear) Algebra /media/juliacon-2026/submissions/7CGFWE/image_L8MjbBg.webp Weijia Wang en false https://pretalx.com/juliacon-2026/talk/7CGFWE/ https://pretalx.com/juliacon-2026/talk/7CGFWE/feedback/ Alte Mensa — Atrium Maximum Long talk 2026-08-12T12:30:00+02:00 12:30 00:30 Parametric polynomial systems can be represented as dominant maps between irreducible algebraic varieties of the same dimension, where symmetries correspond to automorphisms of these maps. Galois, or monodromy, groups provide a numerical tool for detecting the existence of such symmetries in solution sets. A central computational challenge, however, is to recover explicit formulas for these automorphisms in order to better understand and more efficiently solve the systems. We combine numerical homotopy continuation with multivariate rational function interpolation to compute candidate symmetries, implemented in the Julia package [DecomposingPolynomialSystems.jl](https://github.com/MultivariatePolynomialSystems/DecomposingPolynomialSystems.jl). For structured systems with many variables, such as minimal problems in computer vision, the resulting Vandermonde-like interpolation matrices become prohibitively large, leading to expensive nullspace computations and numerical instability. We address this by exploiting equivariance of minimal problems with respect to matrix Lie group actions. The interpolation space of bounded-degree polynomials decomposes into isotypic components as a representation of the Lie symmetry group, allowing a substantial reduction of the problem size. This representation-theoretic decomposition is implemented in the Julia package [DecomposingGroupRepresentations.jl](https://github.com/MultivariatePolynomialSystems/DecomposingGroupRepresentations.jl). Together, these tools provide a scalable Julia-based framework that integrates monodromy and computational representation theory to recover closed-form symmetries of polynomial systems. juliacon-2026-92763-using-monodromy-and-representation-theory-to-recover-symmetries-of-polynomial-systems Symbolic and Numerical Methods in (Nonlinear) Algebra /media/juliacon-2026/submissions/SMBUHF/image_T8HJxx1.webp Viktor Korotynskiy en false https://pretalx.com/juliacon-2026/talk/SMBUHF/ https://pretalx.com/juliacon-2026/talk/SMBUHF/feedback/ Alte Mensa — Atrium Maximum Short talk 2026-08-12T14:30:00+02:00 14:30 00:15 We introduce Corleone.jl, a package for solving optimization problems related to dynamic processes. It aims at leveraging the full SciML ecosystem to model, integrate, and solve the resulting nonlinear optimization problem. We showcase Corleone's integration inside scientific machine learning, how it can be used via ModelingToolkit, and recent results from academic and industrial use cases. juliacon-2026-92843-an-offer-you-can-t-refuse-corleone-jl-flexible-direct-multiple-shooting-for-optimal-control-and-experimental-design-in-julia Methods and Applications of Scientific Machine Learning (SciML) /media/juliacon-2026/submissions/YX8CHD/image_bhYXNco.webp Carl Julius Martensen en 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. false flyer-YX8CHD https://pretalx.com/juliacon-2026/talk/YX8CHD/ https://pretalx.com/juliacon-2026/talk/YX8CHD/feedback/ Alte Mensa — Atrium Maximum Short talk 2026-08-12T14:45:00+02:00 14:45 00:15 Macroeconomic debt cycles evolve over time through interacting growth, inflation, and fiscal pressures. This study compares India, Sri Lanka, and Argentina using Physics-Informed Neural Networks (PINNs) and Universal Differential Equations (UDEs) to model continuous economic dynamics. By embedding economic structure into neural differential systems, we evaluate their ability to reconstruct national macroeconomic trajectories under sparse annual data conditions. juliacon-2026-92030-cross-country-macroeconomic-forecasting-using-physics-informed-neural-networks-and-universal-differential-equations-in-julia Methods and Applications of Scientific Machine Learning (SciML) /media/juliacon-2026/submissions/AHVQ3V/image_101xnDh.webp Vrishank Sai Anand en 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. false https://pretalx.com/juliacon-2026/talk/AHVQ3V/ https://pretalx.com/juliacon-2026/talk/AHVQ3V/feedback/ Alte Mensa — Atrium Maximum Short talk 2026-08-12T15:00:00+02:00 15:00 00:15 Decisions often affect the dynamics of a system. DecisionSystem is a unified way of capturing both dynamics and decisions of complex systems. Real systems don't just evolve, they respond. DecisionSystems is a unified way of capturing physics simulation and decision-making, letting you model the full cycle: simulate dynamics, observe state, decide, act, repeat. juliacon-2026-92704-decisionsystems-jl-closing-the-loop-between-physics-and-decisions Methods and Applications of Scientific Machine Learning (SciML) /media/juliacon-2026/submissions/HMSN8Q/image_ErCQu2Z.webp Venkatesh-Prasad Bhat en 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. false https://pretalx.com/juliacon-2026/talk/HMSN8Q/ https://pretalx.com/juliacon-2026/talk/HMSN8Q/feedback/ Alte Mensa — Atrium Maximum Short talk 2026-08-12T15:15:00+02:00 15:15 00:15 Automatic Differentiation (AD) methods present an efficient way for computing function derivatives, however the sheer amount of the implemented methods can be overwhelming. Chosing the correct method for the task can have crucial impact on the performance[1], hence understanding the differences between them and their use cases is beneficial. juliacon-2026-92925-different-automatic-differentiation-algorithms-from-scimlsensitivity-jl-and-when-to-use-them Methods and Applications of Scientific Machine Learning (SciML) /media/juliacon-2026/submissions/EYUQVV/image_yfDRxYe.webp Marko Polic en 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. false https://pretalx.com/juliacon-2026/talk/EYUQVV/ https://pretalx.com/juliacon-2026/talk/EYUQVV/feedback/ Alte Mensa — Atrium Maximum Short talk 2026-08-12T15:45:00+02:00 15:45 00:15 Chaotic neural dynamics resist equation discovery because parameter sensitivity creates intractable optimization landscapes. Using the SciML ecosystem, we combine prediction-error methods with universal differential equations (PEM-UDE) and multiple shooting to tame chaos during learning. In spiking networks, we derive novel mean-field equations for sparse cortical connectivity that predict frequency shifts and synchrony patterns, validated by intracranial recordings. juliacon-2026-92735-discovering-governing-equations-for-neural-populations-pem-ude-with-multiple-shooting-for-chaotic-brain-dynamics Methods and Applications of Scientific Machine Learning (SciML) /media/juliacon-2026/submissions/DG33PK/image_qVkoxSA.webp Helmut StreyChris RackauckasAnthony Chesebro en 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. false flyer-DG33PK https://pretalx.com/juliacon-2026/talk/DG33PK/ https://pretalx.com/juliacon-2026/talk/DG33PK/feedback/ Alte Mensa — Atrium Maximum Short talk 2026-08-12T16:00:00+02:00 16:00 00:15 This talk presents recent advances in efficient boundary value problem solving within the SciML ecosystem, focusing on extending collocation-based and nonlinear programming formulations implemented in BoundaryValueDiffEq.jl. We demonstrate how BVPs can be reformulated as structured optimization problems, enabling seamless integration with SciML’s differentiable programming stack and modern optimization tools. Building on this perspective, we introduce strategies for improving performance and scalability, including structure-aware discretizations, GPU-parallel ensemble solving, and algorithmic techniques that bridge differential equation solvers with optimal control and dynamical optimization pipelines. We further show how these methods enable new application workflows, where differential equations, parameter estimation, and optimal control problems are solved within a unified composable framework. juliacon-2026-92033-efficient-sciml-bvp-solvers-from-differential-equations-to-dynamic-optimizations Methods and Applications of Scientific Machine Learning (SciML) /media/juliacon-2026/submissions/3H7S3S/image_ora0Eb2.webp Qingyu Qu en 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. false https://pretalx.com/juliacon-2026/talk/3H7S3S/ https://pretalx.com/juliacon-2026/talk/3H7S3S/feedback/ Alte Mensa — Atrium Maximum Short talk 2026-08-12T16:15:00+02:00 16:15 00:15 In this talk we will present how DyadModelOptimizer is solving free final time problems using ModelingToolkit, BoundaryValueDiffEq and OptimizationMadNLP, showing the full julia stack that powers the Dyad analyses. Specifically we examine the solution in the context of minimum lap time optimization for a race car. The solution assumes a continuous lap optimizing throttle and braking under dynamical constraints.  We formulate the problem as a nonlinear optimal control problem with free terminal time, where the objective is to minimize total lap time subject to coupled vehicle dynamics, tire force limits, and path constraints along a prescribed track centerline. The vehicle model captures longitudinal and lateral dynamics, load transfer effects, and tire saturation through nonlinear algebraic relationships, resulting in a differential-algebraic system expressed symbolically. The talk walks through the entire process end to end: building the symbolic model, converting it into a boundary value formulation, choosing a discretization strategy, assembling the nonlinear program, and configuring the solver. We will also share practical lessons on mesh refinement, scaling for numerical stability, and what solve times and convergence actually look like in practice. juliacon-2026-92521-optimizing-race-car-track-times-in-dyad Methods and Applications of Scientific Machine Learning (SciML) /media/juliacon-2026/submissions/YQXSKZ/image_GbMOOzB.webp Sebastian Micluța-CâmpeanuRajeev Voleti en 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. false https://pretalx.com/juliacon-2026/talk/YQXSKZ/ https://pretalx.com/juliacon-2026/talk/YQXSKZ/feedback/ Alte Mensa — Atrium Maximum Short talk 2026-08-12T16:45:00+02:00 16:45 00:15 This talk discusses two complementary directions in scientific machine learning for geophysics. The first uses DeepONet surrogates to accelerate magnetotelluric forward modelling and transdimensional probabilistic inversion, making uncertainty analysis more practical. The second uses implicit neural representations for three-dimensional gravity inversion, where the subsurface model is learned under physics-based machine learning. juliacon-2026-93467-scientific-machine-learning-for-geophysical-modelling-inversion-and-uncertainty-quantification Methods and Applications of Scientific Machine Learning (SciML) /media/juliacon-2026/submissions/UHMHQX/image_vFJSeKv.webp Pankaj K Mishra en 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. true https://pretalx.com/juliacon-2026/talk/UHMHQX/ https://pretalx.com/juliacon-2026/talk/UHMHQX/feedback/ Alte Mensa — Atrium Maximum Short talk 2026-08-12T17:00:00+02:00 17:00 00:15 Symbolic computation is inherently very dynamic. It needs to support representing arbitrary function calls, on arbitrary symbolic types. Older versions of Symbolics.jl and SymbolicUtils.jl were notoriously type-unstable. This talk goes over the methods used and challenges involved in making the latest major versions of those packages type-stable and precompilation-friendly. The techniques and insights discussed are generally applicable to other packages as well. juliacon-2026-92388-type-stable-symbolic-computation Methods and Applications of Scientific Machine Learning (SciML) /media/juliacon-2026/submissions/3GYGWQ/image_oTPCZBP.webp Aayush Sabharwal en 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. false https://pretalx.com/juliacon-2026/talk/3GYGWQ/ https://pretalx.com/juliacon-2026/talk/3GYGWQ/feedback/ Alte Mensa — Atrium Maximum Short talk 2026-08-12T17:15:00+02:00 17:15 00:15 There are hundreds of ODE solvers in DifferentialEquations.jl. Which is the best one for your problem? In this talk we go through the many classes and types of solvers and build a map to help you understand when to use various choices. We start by highlighting the basics, the core solvers that tend to do well for all problems, and then start to showcase more specialized methods and detail when they are likely to be improvements. juliacon-2026-89579-what-is-the-best-ode-solver-for-your-problem-a-detailed-walk-through-differentialequations-jl Methods and Applications of Scientific Machine Learning (SciML) /media/juliacon-2026/submissions/AHGR7C/image_1SzKukc.webp Chris Rackauckas en 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. false https://pretalx.com/juliacon-2026/talk/AHGR7C/ https://pretalx.com/juliacon-2026/talk/AHGR7C/feedback/ Tent — RW1 Platinum Sponsor Talk 2026-08-13T08:30:00+02:00 08:30 00:15 Sponsor Talk from Aeolus Labs by Mason Lee from Aeolus Labs. juliacon-2026-93210-sponsor-talk-from-aeolus-labs General en Aeolus Labs is a San Francisco-based weather intelligence startup and a Platinum Sponsor of JuliaCon Global 2026. false https://pretalx.com/juliacon-2026/talk/PEZTQJ/ https://pretalx.com/juliacon-2026/talk/PEZTQJ/feedback/ Tent — RW1 Keynote 2026-08-13T08:45:00+02:00 08:45 01:00 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. juliacon-2026-93045-julia-for-quantum-software-lessons-from-paulipropagation-jl General /media/juliacon-2026/submissions/YRYY9T/image_1daakdZ.webp Zoë HolmesManuel Rudolph en 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. false https://pretalx.com/juliacon-2026/talk/YRYY9T/ https://pretalx.com/juliacon-2026/talk/YRYY9T/feedback/ Tent — RW1 Long talk 2026-08-13T10:00:00+02:00 10:00 00:30 We will do a deep dive how we modernized the core of the language server with an incremental computation engine, multi environment support and runtime analysis features. We will also highlight how these features are now easily exposed to command line and other users. Furthermore, we will introduce the new test item runner system that supports efficient parallel test execution and integrates into various workflows. juliacon-2026-93355-what-s-new-in-the-julia-extension-for-vs-code General /media/juliacon-2026/submissions/BZEYUC/image_IPFUKpJ.webp Sebastian Pfitzner en false https://pretalx.com/juliacon-2026/talk/BZEYUC/ https://pretalx.com/juliacon-2026/talk/BZEYUC/feedback/ Tent — RW1 Long talk 2026-08-13T10:30:00+02:00 10:30 00:30 The first time you implement lowering, it takes parsed code, expands macros, and compiles it to linear, untyped IR. But then you get users. Users have questions like "can I figure out what code this IR came from so I can make essential tools like Revise.jl?" and "can we write macros without so much manual escaping?" and "why are errors after lowering so cryptic?" and "not a question, but Revise works now because I've written a program that correctly reverses lowering about 80% of the time." This talk is about the second time you implement lowering. juliacon-2026-92793-julialowering-jl-provenance-automatic-hygiene-and-tooling General /media/juliacon-2026/submissions/U39FKW/image_rPiUll7.webp Claire FosterEm Chu en 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. false https://pretalx.com/juliacon-2026/talk/U39FKW/ https://pretalx.com/juliacon-2026/talk/U39FKW/feedback/ Tent — RW1 Short talk 2026-08-13T11:15:00+02:00 11:15 00:15 EEG topoplots are a central visualization tool in computational neuroscience and biological signal analysis. However, they typically display only mean effects while omitting uncertainty arising from subjects, trials, and model variability. Our qualitative user study with domain experts shows that researchers consider uncertainty visualization essential for interpretation, yet report lacking appropriate tools and established methods to implement it in practice. In this talk, I present ten uncertainty visualization prototypes developed in UnfoldMakie, a Julia-based ecosystem for regression-based EEG analysis. Several approaches, such as bivariate and value-suppressing topoplots, introduce entirely new visualization strategies. Some are already available, while others are in active development. We are currently conducting a quantitative user study to systematically assess which of these plots most effectively support accuracy and interpretability in typical EEG analysis tasks. By empirically comparing these designs, we aim to identify best practices rather than proposing yet another visualization variant. As tool developers, we argue that enabling appropriate uncertainty representations is a responsibility: without accessible methods, researchers lack the means to communicate variability, which directly impacts research integrity and reproducibility in computational biology. juliacon-2026-92585-visualizing-uncertainty-in-eeg-topoplots-new-approaches-in-unfoldmakie General /media/juliacon-2026/submissions/LJVPDR/image_4OSqBkZ.webp Vladimir Mikheev en false flyer-LJVPDR https://pretalx.com/juliacon-2026/talk/LJVPDR/ https://pretalx.com/juliacon-2026/talk/LJVPDR/feedback/ Tent — RW1 Long talk 2026-08-13T11:30:00+02:00 11:30 00:30 Julia for VSCode now offers automatic Julia installation for seamless onboarding and integrates JETLS -- a new language server powered by JET.jl and JuliaLowering.jl. JETLS brings type-aware diagnostics, macro-aware go-to-definition, enhanced completions, and a CLI for AI agent and CI integration. We demonstrate how these features improve everyday Julia development through live comparisons with the existing language server. juliacon-2026-92702-julia-for-vs-code-jetls-and-beyond General /media/juliacon-2026/submissions/QLXWSB/image_SOQUyk0.webp Shuhei KadowakiSebastian Pfitzner en 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. false https://pretalx.com/juliacon-2026/talk/QLXWSB/ https://pretalx.com/juliacon-2026/talk/QLXWSB/feedback/ Tent — RW1 Long talk 2026-08-13T12:00:00+02:00 12:00 00:30 [SmallCollections.jl](https://github.com/matthias314/SmallCollections.jl) provides variable-length vectors, sets and dictionaries which in their immutable versions don't allocate memory. Using these types often results in significant speed-ups for performance-critical code. I will illustrate this with the package [SmallCombinatorics.jl](https://github.com/matthias314/SmallCombinatorics.jl). juliacon-2026-92620-smallcollections-jl-variable-length-collections-that-don-t-allocate General /media/juliacon-2026/submissions/TNVVU8/image_zIqeKpE.webp Matthias Franz en 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. false GitHub repository Documentation https://pretalx.com/juliacon-2026/talk/TNVVU8/ https://pretalx.com/juliacon-2026/talk/TNVVU8/feedback/ Tent — RW1 Long talk 2026-08-13T12:30:00+02:00 12:30 00:30 The Dyad language and ecosystem provides a modern approach to model-based systems engineering leveraging the symbolic-numeric advances of ModelingToolkit.jl. This talk presents the Dyad FluidComponents and HVACComponents libraries which are a suite of pre-built models for 1D thermal-fluid flow. We present unique features of Dyad such as path variables that simplify modeling, discuss approaches to translating existing libraries and conclude by providing industrial examples. juliacon-2026-92748-thermal-fluid-modeling-in-dyad General /media/juliacon-2026/submissions/9WAZ7B/image_2fvGzGQ.webp Avinash Subramanian en 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. false flyer-9WAZ7B https://pretalx.com/juliacon-2026/talk/9WAZ7B/ https://pretalx.com/juliacon-2026/talk/9WAZ7B/feedback/ Tent — RW1 Long talk 2026-08-13T14:30:00+02:00 14:30 00:30 DynamicalSystems.jl is an internationally acclaimed general purpose library for nonlinear dynamics and nonlinear timeseries analysis. It encompasses a vast array of features that, despite the established age of dynamical systems theory, no other software has attempted so far. In this talk I will review the state of the DynamicalSystems.jl library in 2026: what's there, what's new, what is going well, what parts need more love, and what is planned for the future, and what you can do to help. I will then highlight recent successes and additions to the library, based primarily on ComplexityMeasures.jl and Attractors.jl, while also highlighting recent additions to the library: CriticalTransitions.jl, TransitionsInTimeseries.jl, and RecurrenceMicrostatesAnalysis.jl. juliacon-2026-92313-dynamicalsystems-jl-in-2026-successes-and-new-components Nonlinear and complex systems analysis with Julia /media/juliacon-2026/submissions/7GNWCD/image_Bx9ZEEF.webp George Datseris en false flyer-7GNWCD https://pretalx.com/juliacon-2026/talk/7GNWCD/ https://pretalx.com/juliacon-2026/talk/7GNWCD/feedback/ Tent — RW1 Long talk 2026-08-13T15:00:00+02:00 15:00 00:30 The DynamicalSystems.jl library allows analyzing nonlinear dynamical systems in Julia. However, functionality for systems with random or time-dependent forcing has been limited. Extending the existing interface to include coupled stochastic differential equations and nonautonomous systems, we introduce [CriticalTransitions.jl](https://github.com/JuliaDynamics/CriticalTransitions.jl): a user-friendly, well-documented package of numerical methods from large deviations and dynamical systems theory to simulate and understand critical behavior, e.g. tipping. juliacon-2026-92917-criticaltransitions-jl-a-toolbox-for-noise-and-rate-induced-transitions-in-forced-dynamical-systems Nonlinear and complex systems analysis with Julia /media/juliacon-2026/submissions/RUJHNQ/image_fHMGV1h.webp Reyk Börner en 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. false flyer-RUJHNQ https://pretalx.com/juliacon-2026/talk/RUJHNQ/ https://pretalx.com/juliacon-2026/talk/RUJHNQ/feedback/ Tent — RW1 Short talk 2026-08-13T15:30:00+02:00 15:30 00:15 This talk introduces `AlgorithmAnalysis.jl`, a Julia package that automates the worst-case analysis of black-box algorithms. Analyzing the performance of an algorithm by hand is both tedious and error prone. This package enables users to express algorithms in a natural way using a high-level domain-specific language. This symbolic description is then transformed behind the scenes into a semidefinite program that is solved numerically to construct tight numerical bounds on the worst-case performance. The package implements the performance estimation problem (PEP) and control theoretic frameworks, both of which have been used to analyze a wide variety of first-order methods in optimization. juliacon-2026-92767-automated-algorithm-analysis-in-julia-with-algorithmanalysis-jl Nonlinear and complex systems analysis with Julia /media/juliacon-2026/submissions/78GRUZ/image_D9SsLpa.webp Bryan Van ScoySam Skinner en 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. false flyer-78GRUZ https://pretalx.com/juliacon-2026/talk/78GRUZ/ https://pretalx.com/juliacon-2026/talk/78GRUZ/feedback/ Tent — RW1 Short talk 2026-08-13T15:45:00+02:00 15:45 00:15 Evolutionary game theory has traditionally employed deterministic models to describe population dynamics. These models, due to their inherent nonlinearities, can exhibit deterministic chaos, where population fluctuations follow complex, aperiodic patterns. Recently, the focus has shifted towards stochastic models, quantifying fixation probabilities and analysing systems with constants of motion. Yet, the role of stochastic effects in systems with chaotic dynamics remains largely unexplored within evolutionary game theory. This study addresses how demographic noise -- arising from probabilistic birth and death events -- impacts chaotic dynamics in finite populations. We show that despite stochasticity, large populations retain a signature of chaotic dynamics, as evidenced by comparing a chaotic deterministic system with its stochastic counterpart. More concretely, the strange attractor observed in the deterministic model is qualitatively recovered in the stochastic model, where the term deterministic chaos loses its meaning. We employ tools from nonlinear dynamics using Julia to quantify how the population size influences the dynamics. We observe that for small populations, stochasticity dominates, overshadowing deterministic selection effects. However, as population size increases, the dynamics increasingly reflect the underlying chaotic structure. This resilience to demographic noise can be essential for maintaining diversity in populations, even in non-equilibrium dynamics. Overall, our results broaden our understanding of population dynamics, and revisit the boundaries between chaos and noise, showing how they maintain structure when considering finite populations in systems that are chaotic in the deterministic limit. juliacon-2026-92440-chaos-and-noise-in-evolutionary-game-dynamics Nonlinear and complex systems analysis with Julia /media/juliacon-2026/submissions/UCKDNF/image_If2mQkN.webp Alejandra Ramirez en false https://pretalx.com/juliacon-2026/talk/UCKDNF/ https://pretalx.com/juliacon-2026/talk/UCKDNF/feedback/ Tent — RW1 Short talk 2026-08-13T16:00:00+02:00 16:00 00:15 MicroSwimmers.jl is a package for simulating the dynamics of flagellated microswimmers in low-Reynolds-number fluid environments where geometry and actuation determine global behaviour. Built on the boundary-element regularised Stokeslet method, it provides a composable framework for constructing time-dependent swimmer morphologies and exploring parameter-driven transitions in trajectories and flow fields, integrated with the Julia scientific computing ecosystem. juliacon-2026-92554-hydrodynamics-of-composable-active-structures-with-microswimmers-jl Nonlinear and complex systems analysis with Julia /media/juliacon-2026/submissions/HXY7PF/image_ojo5JZL.webp James Cass en 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. false https://pretalx.com/juliacon-2026/talk/HXY7PF/ https://pretalx.com/juliacon-2026/talk/HXY7PF/feedback/ Tent — RW1 Long talk 2026-08-13T16:15:00+02:00 16:15 00:30 Hybrid and multiscale modeling gives rise to complex systems that are often difficult to simulate. Such models are integral to many areas of biology, where simple mechanisms can induce complex emergent phenomena across scales. We have developed Sirens.jl, in which complex systems can be treated as components (models) and connections between them. We demonstrate the power of this approach through a range of examples, from the scale of single proteins to entire populations. juliacon-2026-92369-sirens-jl-hybrid-and-multiscale-modeling-in-julia Nonlinear and complex systems analysis with Julia /media/juliacon-2026/submissions/EJVNCK/image_iWweRQk.webp Matt Owen en 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. false https://pretalx.com/juliacon-2026/talk/EJVNCK/ https://pretalx.com/juliacon-2026/talk/EJVNCK/feedback/ Tent — RW1 Short talk 2026-08-13T16:45:00+02:00 16:45 00:15 StatsOP.jl is a Julia package for (sequential) hypothesis testing in time series using ordinal pattern analysis. The methodology builds on the seminal work of Christoph Bandt and Bernd Pompe (2002), who introduced complexity measures for time series derived from ordinal comparisons of neighboring values. Designed with usability in mind, the package provides a streamlined interface for extracting ordinal patterns and conducting statistical inference. A central goal of StatsOP.jl is full compatibility with ComplexityMeasures.jl. juliacon-2026-92177-statsop-jl-a-julia-package-for-time-series-testing-via-ordinal-patterns Nonlinear and complex systems analysis with Julia /media/juliacon-2026/submissions/DXX7EW/image_BMJVZsn.webp Philipp Adämmer en true https://pretalx.com/juliacon-2026/talk/DXX7EW/ https://pretalx.com/juliacon-2026/talk/DXX7EW/feedback/ Tent — RW1 Short talk 2026-08-13T17:00:00+02:00 17:00 00:15 From power grids to hydrogen pipelines and diffusion processes, dynamic flow networks are ubiquitous in science and engineering. In this talk, we present NetworkDynamics.jl, a Julia package for modelling such systems, along with PowerDynamics.jl, a domain-specific library for power grid simulations built on top of it. Both packages have been around for many years. However, over the last 1-2 years we have essentially rewritten both from the ground up, fully embracing ModelingToolkit.jl as the primary way to define component models and deepening our integration with the broader SciML ecosystem. NetworkDynamics.jl enables users to model inhomogeneous network systems in terms of components: dynamical systems on nodes (e.g. generators or pumps) and on edges (e.g. power lines or pipelines). Component models can be defined using ModelingToolkit.jl and are then placed on a graph. The interconnection between components is handled by our performance-oriented backend. This clear separation between dynamic models and network topology enables efficient scaling for large networks. Rather than symbolically analyzing the entire system—which may contain hundreds of thousands of equations—we compile each component type once and reuse it across all instances. The resulting system is simply a right-hand side function for a differential equation, making it fully compatible with the SciML ecosystem: OrdinaryDiffEq.jl for time integration, SymbolicIndexingInterface.jl for accessing network states and observables, and SciMLSensitivity.jl for parameter optimisation. We will present the underlying mathematical model, demonstrate applications in hydrogen networks and power grids, and show how Makie.jl, Bonito.jl, and GraphMakie.jl can be used to build interactive dashboards for exploring simulation results. juliacon-2026-88773-simulate-large-scale-networked-systems-using-networkdynamics-jl-and-powerdynamics-jl Nonlinear and complex systems analysis with Julia /media/juliacon-2026/submissions/LJB3ES/logo_v877fH5.svg Hans Würfel en false flyer-LJB3ES https://pretalx.com/juliacon-2026/talk/LJB3ES/ https://pretalx.com/juliacon-2026/talk/LJB3ES/feedback/ Tent — RW1 Short talk 2026-08-13T17:15:00+02:00 17:15 00:15 Predicting the response of a system to a specific input is a very important task in engineering and nature in general. To accurately predict the response, we developed a closed-loop algorithm to perform model selection based on the output of a reference system obtained following a known input. We applied our algorithm to identify the most accurate model to predict the output of a lab experiment, which consists of light sensitive cells. Using light signals, one can control the output current of the cell. We integrated the experiment in a closed-loop framework, which brought up a constraint on the computation time. Indeed, the recordings of the output current is limited in time, meaning that the model selection has to be performed as fast as possible. To do that, we leveraged the Julia package Sockets.jl and the high speed intranet to export the computation on a server, where the required code had been precompiled. This allowed us to efficiently identify the most accurate model to use for our experiment. juliacon-2026-91936-optimal-control-with-an-electrophysiology-experiment-in-the-loop Nonlinear and complex systems analysis with Julia /media/juliacon-2026/submissions/HMHAZL/image_tRUUeHY.webp Melvyn Tyloo en false https://pretalx.com/juliacon-2026/talk/HMHAZL/ https://pretalx.com/juliacon-2026/talk/HMHAZL/feedback/ Tent — RW1 Keynote 2026-08-13T17:45:00+02:00 17:45 01:00 Computational Science and Engineering (CSE) integrates engineering, applied mathematics, and computer science to enable model-based design, knowledge generation, and decision support. While CSE has become a key enabler of sustainable products and operations, sustainability is still often treated as an afterthought in computational method development. This talk reflects on sustainability as a core design principle for CSE—one that aligns naturally with scientific relevance, long-term usability, and enduring research value. Drawing on representative examples, we present a holistic perspective spanning resource consumption, digital infrastructure, and organizational practices. We examine how these aspects interact in modern computational research and conclude with directions for impact through sustainable CSE. juliacon-2026-93041-sustainability-in-computational-science-and-engineering General /media/juliacon-2026/submissions/DVSBHX/image_pvxYhNh.webp Julia Kowalski en false https://pretalx.com/juliacon-2026/talk/DVSBHX/ https://pretalx.com/juliacon-2026/talk/DVSBHX/feedback/ Muschel — N1 Short talk 2026-08-13T10:00:00+02:00 10:00 00:15 The BioJulia organization began as `Bio.jl` circa January 2014 (julia v0.2 era) and has grown into a loosely organized collection of packages for computational biology, from plotting protein structures (`BioMakie.jl`) to performing matrix manipulations on single-cell RNA sequencing data (`SingleCellProjections.jl`) to low-level biological file type I/O (`Automa.jl`, `FASTX.jl`, `XAM.jl`). Here, we will provide a brief history of the Org and recent efforts to provide more structure for the community, as well as growth areas and a vision for the future. juliacon-2026-92708-the-state-of-biojulia Julia for Biology and Biology for Julia /media/juliacon-2026/submissions/3LGMBE/image_qhFZIyo.webp Kevin Bonham, PhD en 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. false https://pretalx.com/juliacon-2026/talk/3LGMBE/ https://pretalx.com/juliacon-2026/talk/3LGMBE/feedback/ Muschel — N1 Long talk 2026-08-13T10:15:00+02:00 10:15 00:30 Julia is a fantastic language for bioinformatics. But why? What about bioinformatics makes Julia so suitable? On which bioinformatics problems have Julians focused their efforts to far? And if Julia is so useful for bioinformatics, why isn't it more popular? This talk presents the state of affairs of programming in modern bioinformatics and where Julia fits into that. juliacon-2026-92684-julia-for-bioinformatics Julia for Biology and Biology for Julia /media/juliacon-2026/submissions/7YBX7H/image_pvUwuPa.webp Jakob Nybo Andersen en 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. false https://pretalx.com/juliacon-2026/talk/7YBX7H/ https://pretalx.com/juliacon-2026/talk/7YBX7H/feedback/ Muschel — N1 Short talk 2026-08-13T10:45:00+02:00 10:45 00:15 Despite being a high-performance language, Julia's I/O functionality has been designed for convenience, and is neither robust nor efficient. I present an alternate I/O interface in BufferIO.jl, which has more well-defined semantics, and permits low level, high performance I/O operations. juliacon-2026-92680-efficient-robust-parsing-with-bufferio-jl Julia for Biology and Biology for Julia /media/juliacon-2026/submissions/3NCLXU/image_Ne9euqa.webp Jakob Nybo Andersen en 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. false https://pretalx.com/juliacon-2026/talk/3NCLXU/ https://pretalx.com/juliacon-2026/talk/3NCLXU/feedback/ Muschel — N1 Short talk 2026-08-13T11:00:00+02:00 11:00 00:15 Protein-DNA binding can depend on sequence changes even outside direct complex contact regions. While an MD-based protocol can capture this indirect readout with high correlation to experiment, its cost limits large-scale use. We present a Julia package to estimate DNA deformation free energies with practical analytical models optimized from simulation trajectories. These models aim to explain these affinity differences at much lower cost, enabling broader screening or sequence optimization. juliacon-2026-93466-modeling-indirect-readout-through-dna-deformation-free-energies-in-julia Julia for Biology and Biology for Julia /media/juliacon-2026/submissions/QACULP/image_5yrnkye.webp Christian Sustay Martinez en ### 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. false https://pretalx.com/juliacon-2026/talk/QACULP/ https://pretalx.com/juliacon-2026/talk/QACULP/feedback/ Muschel — N1 Short talk 2026-08-13T11:15:00+02:00 11:15 00:15 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) juliacon-2026-93393-modeling-and-visualizing-late-embryogenesis-in-the-caenorhabditis-elegans Julia for Biology and Biology for Julia /media/juliacon-2026/submissions/BK783X/image_aSphoB1.webp Mark Kittisopikul, Ph.D. en 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) false https://pretalx.com/juliacon-2026/talk/BK783X/ https://pretalx.com/juliacon-2026/talk/BK783X/feedback/ Muschel — N1 Short talk 2026-08-13T11:30:00+02:00 11:30 00:15 Reproducibility in scientific analyses is often hampered by insufficient tooling. Large data and slow computations force users to save partial results to disk, and the actual steps to reproduce the entire chain from raw data to end results are lost. Here we present ReproducibleJobs.jl - a computational framework that enables natural workflows and fast turnaround, while still achieving reproducibility and show how it works in practice for single cell expression data in SingleCellProjections.jl. juliacon-2026-93117-reproduciblejobs-jl-enables-practical-and-reproducible-workflows-in-singlecellprojections-jl Julia for Biology and Biology for Julia /media/juliacon-2026/submissions/8Z8UFG/image_FeB9BPf.webp Rasmus Henningsson en 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. false https://pretalx.com/juliacon-2026/talk/8Z8UFG/ https://pretalx.com/juliacon-2026/talk/8Z8UFG/feedback/ Muschel — N1 Short talk 2026-08-13T11:45:00+02:00 11:45 00:15 Spatial transcriptomics (sTx) is a cutting edge technology combining microscopy and high-throughput sequencing or molecular probes to measure transcription in the context of cells within their tissue context, enabling researchers to achieve single-cell resolution and identify spatial relationships between cell types. While this technology opens up many new avenues for investigation, proprietary analysis applications provided by the manufacturers of sTx machines are typically slow (often requiring cloud-based compute), feature-poor, and do not generalize across technologies. `SpatialOmics.jl` is a new package that combines functionality from JuliaImages, JuliaGeo, and JuliaData to offer open source and extensible end-to-end analysis tools for spatial 'omics applications. juliacon-2026-92711-spatialomics-jl-using-the-geo-image-and-data-stacks-to-analyze-spatial-transcriptomics-data Julia for Biology and Biology for Julia /media/juliacon-2026/submissions/8JFFSK/image_11T4orY.webp Kevin Bonham, PhD en false https://pretalx.com/juliacon-2026/talk/8JFFSK/ https://pretalx.com/juliacon-2026/talk/8JFFSK/feedback/ Muschel — N1 Short talk 2026-08-13T12:00:00+02:00 12:00 00:15 Biology is driven by interactions: between transcription factors and genes, receptors and ligands, and pre- and post-synaptic neurons. To gain insights about complex systems, embedding methods are commonly used to represent pairwise similarity relationships; however, we lack tools for *coembedding* two or more classes of interacting objects. I will present new machine learning tools for coembedding interacting systems. A distinguishing feature is the representation of entities by Gaussian probability distributions rather than points, which results in a quadratic compression of dimensionality, enabling quantiatively-accurate visualization of more complex systems than is possible by traditional techniques. juliacon-2026-93500-geometric-coembedding-of-complex-interacting-systems Julia for Biology and Biology for Julia /media/juliacon-2026/submissions/ADYCYS/image_YjCQxyD.webp Tim Holy en false https://pretalx.com/juliacon-2026/talk/ADYCYS/ https://pretalx.com/juliacon-2026/talk/ADYCYS/feedback/ Muschel — N1 Short talk 2026-08-13T12:15:00+02:00 12:15 00:15 Phylogenetic reconstruction and comparative analysis are fundamental to understanding evolutionary relationships and biological diversity. Traditional algorithms rely heavily on multiple sequence alignments and statistical modelling, which face significant computational challenges with large-scale datasets. Furthermore, integrating information from multiple data sources, such as sequences, structures, and functional annotations, at the time of reconstruction, remains technically challenging, limiting the feasibility of phylogenetic reconstruction using today’s diversity of biological annotations. Hyperdimensional computing (HDC) is a novel computational paradigm that employs high-dimensional representations of atomic entities (e.g., amino acids) and combines them via algebraic operations to represent more complex data structures (e.g., proteins). This paradigm, parallel to connectionist modelling, is characterised by modelling the brain's distributed memory and the operations underlying its processing. HDC exhibits several properties advantageous for biological data analysis: robustness to noise, holographic information distribution, and the ability to integrate heterogeneous data sources seamlessly. Recent applications in DNA sequencing, pattern matching, and molecular classification have demonstrated HDC's potential in bioinformatics, where its computational efficiency, interpretability, and natural capacity for multimodal data fusion make it particularly well suited to complex phylogenetic analyses. In this talk, we showcase the potential of HDC for phylogenetic reconstruction and comparative analysis. Here, we present PhyloHD.jl, a Julia package for representing biological data as hypervectors and reconstructing phylogenetic trees from these representations. We will showcase how to calculate branch support using the HDC paradigm and present a multimodal tree reconstruction approach that integrates multiple heterogeneous data sources, including sequences, structures, and functional annotations. Finally, we will showcase how HDC learning techniques can be used for family-based phylogenetic tree reconstruction and ancestral sequence reconstruction. This work represents the first attempt to use hyperdimensional computing as a computational paradigm for phylogenetics and opens new avenues for research in this field. juliacon-2026-92309-phylohd-jl-hyperdimensional-computing-meets-phylogenetic-reconstruction Julia for Biology and Biology for Julia /media/juliacon-2026/submissions/QTDH38/image_RhE0oBo.webp Carlos Vigil-Vásquez en 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. false https://pretalx.com/juliacon-2026/talk/QTDH38/ https://pretalx.com/juliacon-2026/talk/QTDH38/feedback/ Muschel — N1 Short talk 2026-08-13T12:30:00+02:00 12:30 00:15 Julia has great tools for simulating and analyzing many kinds of dynamical systems. However, discrete, finite-state systems, i.e., systems made of many interacting parts that each have a small number of possible states, are less well supported. The class of GDS includes many well-known formalisms, such as Boolean networks, cellular automata, and sequential dynamical systems. These models have a long history of use in the biological setting. Boolean networks, for example, were originally introduced to model genetic regulatory networks. More recent generalizations of Boolean networks, _qualitative_ networks, have allowed experts to build and reason about large, complex models of signaling pathways. `GraphDynamicalSystems.jl` provides a common backbone for constructing, learning, executing, and analyzing GDS. As these models are 1) dynamical systems, 2) graphs, and 3) compositional in their behavior, they make for a great use case for recombining different packages and ecosystems to create something new—something Julia excels at. In this case, the package hooks into the `JuliaDynamics`, `JuliaGraphs`, and soon, the `AlgebraicJulia`, `JuliaReach`, and `SciML` ecosystems. With this package, we hope to stimulate the implementation and development of new methods for learning and analysis of this broad class of systems. juliacon-2026-92905-graphdynamicalsystems-jl-discrete-finite-state-systems-over-graphs Julia for Biology and Biology for Julia /media/juliacon-2026/submissions/9MGLXG/image_7tkc9Tc.webp Reuben Gardos Reid en false https://pretalx.com/juliacon-2026/talk/9MGLXG/ https://pretalx.com/juliacon-2026/talk/9MGLXG/feedback/ Muschel — N1 Short talk 2026-08-13T12:45:00+02:00 12:45 00:15 Identifying genuine protein-protein interactions from mass spectrometry data requires disentangling real biology from experimental noise. [BayesInteractomics.jl]([url](https://github.com/ma-seefelder/BayesInteractomics.jl)) tackles this by fitting three complementary Bayesian models (detection, enrichment, and dose-response) and combining their evidence through copula mixture models. Built on RxInfer.jl and Copulas.jl, it leverages Julia's type system, multiple dispatch, and threading to analyze thousands of proteins in minutes. juliacon-2026-92682-bayesinteractomics-jl-when-one-bayes-factor-isn-t-enough Julia for Biology and Biology for Julia /media/juliacon-2026/submissions/UQN7WB/image_eugf1tw.webp Manuel Seefelder en 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. false GitHub Repository https://pretalx.com/juliacon-2026/talk/UQN7WB/ https://pretalx.com/juliacon-2026/talk/UQN7WB/feedback/ Muschel — N1 Short talk 2026-08-13T14:30:00+02:00 14:30 00:15 Interfacial water waves are governed by complex Euler equations, that satisfy non-trivial nonlinear travelling and standing wave solutions. Analyzing these solutions and their stability is important for understanding oceanic dynamics, from coastal impacts to mysteries like rogue waves. To streamline this, we introduce **InterfacialWaves.jl**, a Julia package that enables researchers to easily generate nonlinear wave equilibriums and analyze their stability to decode the secrets of breaking and rogue waves juliacon-2026-92604-interfacialwaves-jl-a-julia-package-for-nonlinear-interfacial-waves Julia for Partial Differential Equations and its Applications /media/juliacon-2026/submissions/ELF3HR/image_XxHRF0G.webp Nikhil Janardan Yewale en # 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. false https://pretalx.com/juliacon-2026/talk/ELF3HR/ https://pretalx.com/juliacon-2026/talk/ELF3HR/feedback/ Muschel — N1 Short talk 2026-08-13T14:45:00+02:00 14:45 00:15 I present GeothermalWells.jl, an open-source Julia package for full three-dimensional simulation of deep borehole heat exchangers (DBHEs) and well arrays. Through an operator splitting strategy combining ROCK2, ADI, and semi-Lagrangian methods with vendor-agnostic GPU acceleration, making multi-year well array simulations computationally tractable on a single GPU. Previously considered prohibitively expensive, these simulations open new possibilities for systematic design optimization of geothermal well systems. juliacon-2026-90573-geothermalwells-jl-gpu-accelerated-3d-simulation-of-deep-borehole-heat-exchanger-arrays Julia for Partial Differential Equations and its Applications /media/juliacon-2026/submissions/QQ37LB/image_0YTpoFX.svg Collin Wittenstein en 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. false flyer-QQ37LB https://pretalx.com/juliacon-2026/talk/QQ37LB/ https://pretalx.com/juliacon-2026/talk/QQ37LB/feedback/ Muschel — N1 Long talk 2026-08-13T15:00:00+02:00 15:00 00:30 For specific classes of time-dependent PDEs it can become handy to split the full problem up into simpler to handle subproblems, such that we can exploit the specific structure of each subproblem during time integration. To achieve this goal we introduce https://github.com/SciML/OrdinaryDiffEqOperatorSplitting.jl  a library that allows user to split ODEs and DAEs into sub-problems, where we allow problems to be recursively split. The library coordinates in which order the sub-problems need to be integrated, while each of the sub-problems can be solved which a suitable solver from OrdinaryDiffEq.jl . juliacon-2026-92472-accelerating-pde-timestepping-with-ordinarydiffeqoperatorsplitting Julia for Partial Differential Equations and its Applications /media/juliacon-2026/submissions/WFVNXT/image_nb3REW3.webp Oscar SmithDennis Ogiermann en 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. false https://pretalx.com/juliacon-2026/talk/WFVNXT/ https://pretalx.com/juliacon-2026/talk/WFVNXT/feedback/ Muschel — N1 Short talk 2026-08-13T15:30:00+02:00 15:30 00:15 TrixiAtmo.jl is a numerical simulation package for atmospheric flows, implementing modern discontinuous Galerkin methods in a composable and unified Julia framework. Users can set up complex simulations, from idealized benchmarks to global circulation models, with minimal boilerplate, and easily integrate new formulations, tracers, or microphysics. The package supports multiple formulations of the compressible Euler equations, including the effects of rain and clouds. I present efficient and high-performance implementations and highlight challenges and solutions from both the discretization and coding perspectives. juliacon-2026-92778-trixiatmo-jl-an-entropy-stable-discontinuous-galerkin-dynamical-core-for-atmospheric-modeling Julia for Partial Differential Equations and its Applications /media/juliacon-2026/submissions/YQF7AE/image_jAtqmbm.webp Marco Artiano en false https://pretalx.com/juliacon-2026/talk/YQF7AE/ https://pretalx.com/juliacon-2026/talk/YQF7AE/feedback/ Muschel — N1 Long talk 2026-08-13T15:45:00+02:00 15:45 00:30 Macchiato.jl is designed to eliminate the need for traditional meshes in physics simulations. Instead, it operates on unstructured point clouds, which define the boundary of the region of interest. The package aims to provide a user-friendly yet robust environment enabling scientists and engineers to conduct meaningful simulations with minimal pre-processing effort. By bypassing the complexities of mesh generation, users are free to focus on their research and applications. juliacon-2026-92609-macchiato-jl-a-freshly-brewed-meshless-pde-package Julia for Partial Differential Equations and its Applications /media/juliacon-2026/submissions/YU8ZKN/image_4uXCzC0.webp Kyle BeggsDavide Miotti en 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. false https://pretalx.com/juliacon-2026/talk/YU8ZKN/ https://pretalx.com/juliacon-2026/talk/YU8ZKN/feedback/ Muschel — N1 Short talk 2026-08-13T16:15:00+02:00 16:15 00:15 We couple Trixi.jl and deal.II in parallel and adaptively on a shared p4est mesh for simulating multiphysics systems that allow a splitting into two (or more) PDEs coupled via source terms depending on each other's state variables following a common Eulerian formulation. juliacon-2026-93203-reproducible-parallel-adaptive-multisolver-coupling-of-trixi-jl-and-deal-ii Julia for Partial Differential Equations and its Applications /media/juliacon-2026/submissions/YXXEBL/image_lZMhj1O.webp Vivienne Ehlert en 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. false https://pretalx.com/juliacon-2026/talk/YXXEBL/ https://pretalx.com/juliacon-2026/talk/YXXEBL/feedback/ Muschel — N1 Long talk 2026-08-13T16:30:00+02:00 16:30 00:30 This talk will give an overview on WIAS-PDELib, a github organization which emerged from the development of the finite volume solver [VoronoiFVM.jl](https://github.com/WIAS-PDELib/VoronoiFVM.jl) and the finite element solver [ExtendableFEM.jl](https://github.com/WIAS-PDELib/ExtendableFEM.jl). These "top level" packages depend on a number of infrastructure packages which have been moved to WIAS-PDELib in order to allow for sustainable joint maintenance. The talk will focus on the main features and usage examples of [VoronoiFVM.jl](https://github.com/WIAS-PDELib/VoronoiFVM.jl) and [ExtendableFEM.jl](https://github.com/WIAS-PDELib/ExtendableFEM.jl). It will introduce common infrastructure packages, focusing on [ExtendableGrids.jl](https://github.com/WIAS-PDELib/ExtendableGrids.jl) for grid management, [SimplexGridFactory.jl](https://github.com/WIAS-PDELib/SimplexGridFactory.jl) for mesh generation via [Triangulate.jl](https://github.com/JuliaGeometry/Triangulate.jl) and [TetGen.jl](https://github.com/JuliaGeometry/TetGen.jl) backends, [ExtendableSparse.jl](https://github.com/WIAS-PDELib/ExtendableSparse.jl) for straightforward and efficient sparse matrix assembly, and [GridVisualize.jl](https://github.com/WIAS-PDELib/GridVisualize.jl) for grid function visualization with backends for [Makie.jl](https://github.com/MakieOrg/Makie.jl), [PythonPlot.jl](https://github.com/JuliaPy/PythonPlot.jl), [PlutoVista.jl](https://github.com/j-fu/PlutoVista.jl) and others. Particular emphasis will be given on the level of integration with the SciML ecosystem ([CommonSolve.jl](https://github.com/SciML/CommonSolve.jl), [LinearSolve](https://github.com/SciML/LinearSolve.jl), [OrdinaryDiffEq](https://github.com/SciML/OrdinaryDiffEq.jl)). Options for interoperability with other PDE relevant packages will be discussed. juliacon-2026-92921-wias-pdelib-finite-element-and-finite-volume-based-pde-solvers-and-tooling-components Julia for Partial Differential Equations and its Applications /media/juliacon-2026/submissions/UX3K8A/image_Yp15awR.webp Jürgen FuhrmannPatrick Jaap en false https://pretalx.com/juliacon-2026/talk/UX3K8A/ https://pretalx.com/juliacon-2026/talk/UX3K8A/feedback/ Muschel — N1 Long talk 2026-08-13T17:00:00+02:00 17:00 00:30 This is a panel/podium discussion on the general topic of what is missing the Julia PDEs ecosystem. Questions covered: - Performance - Tooling - Joint infrastructure, interfaces between PDE packages - Multitude of PDE and visualization packages - Recent developments Panelists: [Kristoffer Carlsson](https://kristofferc.github.io/#about), [Christopher Rackauckas](https://chrisrackauckas.com/), [Hendrik Ranocha](https://ranocha.de/), and [Gregory Wagner](https://glwagner.github.io/) Moderation: Dennis Ogiermann, Jürgen Fuhrmann juliacon-2026-95390-panel-what-is-missing-for-julia-for-pdes Julia for Partial Differential Equations and its Applications /media/juliacon-2026/submissions/S9PVRR/image_pT23enR.webp Jürgen FuhrmannArpit BabbarMarco ArtianoDennis Ogiermann en false https://pretalx.com/juliacon-2026/talk/S9PVRR/ https://pretalx.com/juliacon-2026/talk/S9PVRR/feedback/ Muschel — N2 Short talk 2026-08-13T10:00:00+02:00 10:00 00:15 Following the initial presentation of the package `RealTimeAudioDiffEq.jl`, we present a use case demonstrating how the package is used to control a saxophone model in real time with a custom interface. This interface consists of a regular saxophone mouthpiece instrumented with sensors, and the whole setup serves as a basis for virtual instrument design in Julia, as well as for studying instrument behavior and/or player actions in performance situations. juliacon-2026-92615-building-playable-virtual-instruments-in-julia-a-real-time-saxophone-model-controlled-by-sensors General /media/juliacon-2026/submissions/LDEKJG/image_rhsLwwz.webp Antonio Ortega BrookManuel Camilo EguiaMartín ProsciaDario Ruiz en 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. false The `RealTimeAudioDiffEq` package https://pretalx.com/juliacon-2026/talk/LDEKJG/ https://pretalx.com/juliacon-2026/talk/LDEKJG/feedback/ Muschel — N2 Short talk 2026-08-13T10:15:00+02:00 10:15 00:15 Turing.jl, a probabilistic programming language, has been undergoing rapid development towards a v1.0 release. Many new features, fixes, and improvements will have been visible to users — but arguably the most important things I've learnt are not about code! In this talk I'll reflect on what it’s really like to work on open source software, contextualised throughout with recent examples from Turing.jl’s codebase. juliacon-2026-92483-the-hidden-path-to-turing-jl-v1-0 General /media/juliacon-2026/submissions/CC37CQ/image_P8HGSqT.webp Penelope Yong en 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. false https://pretalx.com/juliacon-2026/talk/CC37CQ/ https://pretalx.com/juliacon-2026/talk/CC37CQ/feedback/ Muschel — N2 Long talk 2026-08-13T10:30:00+02:00 10:30 00:30 **"Practical Artificial Intelligence in Julia: Build Neural Networks, Genetic Algorithms, and Neuroevolution From Scratch"** is a new book published by APress and Springer. The book is divided into three parts: - _Neural networks_ are a technique inspired by a simplification of neurons in the brain. Neural networks are useful for identifying complex patterns, classifying data, and predicting outcomes. - _Genetic Algorithms_ are a computational metaphor for the biological evolution of species, inspired by the Darwinian principles. Genetic algorithms are useful for finding near-optimal solutions to complex, large-scale, and non-linear optimization and search problems. - _Neuroevolution_ is a combination of the two previous parts: a genetic algorithm evolves a neural network. Neural networks produced by Neuroevolution can solve complex problems without being trained using gradient-based methods. This talk gives a highlight of these techniques and will demonstrate several applications using the Julia REPL, in particular: - evolution of an artificial organism able to walk and climb; - building an artificial player for a Mario Bros-like game; The talk aims to showcase innovative machine learning techniques and applications within the Julia ecosystem. juliacon-2026-91750-neural-networks-genetic-algorithms-and-neuroevolution General /media/juliacon-2026/submissions/L3QPFT/image_9YkCYwC.webp Alexandre Bergel en 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. false https://pretalx.com/juliacon-2026/talk/L3QPFT/ https://pretalx.com/juliacon-2026/talk/L3QPFT/feedback/ Muschel — N2 Short talk 2026-08-13T11:15:00+02:00 11:15 00:15 Automatic differentiation (AD) is deeply embedded in the Julia ecosystem. Thanks to dual numbers and generic programming, derivatives often “just work” across packages. However, this is not always the case. In certain situations (e.g., when transcendental functions are evaluated via partial fraction expansions) propagating dual numbers through the implementation may fail, and for good numerical reasons. In this talk, we present the case of `beta_inc` and `beta_inc_inv` from `SpecialFunctions.jl`. Their original implementations relied on partial fraction expansions carefully designed for `Float64` evaluation. While this approach yields numerically stable function values, it does not automatically provide correct derivatives under AD. Crucially, differentiating the partial fraction expansion is not equivalent to computing the partial fraction expansion of the derivative — the latter being significantly more involved. Drawing from the numerical analysis literature (this challenge is not Julia-specific), we implemented exact derivatives for these functions, as proposed in pull request #506. This work enables the standard automatic differentiation tools to handle these functions seemlessly. These derivatives are central to e.g. statistical computing: they are used in the Beta cumulative distribution and quantile functions, the Student’s t cumulative distribution and quantile functions, and most importantly for us the multivariate Student’s t distribution, which has been asked about several time on discourse. Prior to this work, fully differentiable implementations of these models were not available in Distributions.jl. This talk goes through the story of `SpecialFunctions.jl`'s pull request #506 titled “Exact chainrules derivatives for beta_inc and beta_inc_inv”, which solves all these issues and will hopefully be merged by Juliacon. juliacon-2026-92875-missing-derivative-the-example-of-betainc-and-betaincinv General /media/juliacon-2026/submissions/C8UGPM/image_SK3H2DW.webp Oskar Laverny en false https://pretalx.com/juliacon-2026/talk/C8UGPM/ https://pretalx.com/juliacon-2026/talk/C8UGPM/feedback/ Muschel — N2 Long talk 2026-08-13T11:30:00+02:00 11:30 00:30 X-ray Free Electron Lasers (XFELs) are the latest generation of light sources, designed specifically to create coherent x-ray radiation for scientific experiments. During these experiments it's critical to get feedback in real-time to assess how the experiment is proceeding. In this talk we will describe how Julia is used for doing such real-time analysis at the European XFEL. juliacon-2026-93394-real-time-analysis-of-xfel-data General /media/juliacon-2026/submissions/W3Z3FB/image_V2K2RFK.webp James Wrigley en 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. false https://pretalx.com/juliacon-2026/talk/W3Z3FB/ https://pretalx.com/juliacon-2026/talk/W3Z3FB/feedback/ Muschel — N2 Long talk 2026-08-13T12:00:00+02:00 12:00 00:30 Structural Equation Models (SEMs) are a powerful statistical framework for disentangling complex relationships between multiple factors that affect empirical data. StructuralEquationModels.jl implements SEMs in Julia, offering greater efficiency and extensibility compared to implementations in other languages. Improved efficiency enables the application of SEM to large networks of variables (such as in genetics) and to fit many models in parallel (such as in neuroimaging). Improved extensibility permits adapting SEMs to specific use cases by modifying loss functions or integrating with various numerical optimization backends. juliacon-2026-92688-structuralequationmodels-jl-an-efficient-and-extensible-framework-for-structural-equation-modeling General /media/juliacon-2026/submissions/XZDBKL/image_GE0vRux.webp Maximilian ErnstAaron Peiket en 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. false GitHub Preprint flyer-XZDBKL https://pretalx.com/juliacon-2026/talk/XZDBKL/ https://pretalx.com/juliacon-2026/talk/XZDBKL/feedback/ Muschel — N2 Short talk 2026-08-13T12:30:00+02:00 12:30 00:15 Symbolic learning is a branch of machine learning focused on building classifiers that can be translated into logical rules, making them far more readable than neural networks or other statistical models. While training a symbolic model is a necessary first step, it is the post-processing stage that yields the most relevant insights. We present a live walkthrough of SolePostHoc.jl, a SOLE package dedicated to post-processing, allowing for rule extraction, boosting and model simplification. juliacon-2026-92569-symbolic-post-hoc-analysis-with-soleposthoc-jl General /media/juliacon-2026/submissions/VXYAQY/image_C1KRiLj.webp Marco Perrotta en 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. false https://pretalx.com/juliacon-2026/talk/VXYAQY/ https://pretalx.com/juliacon-2026/talk/VXYAQY/feedback/ Muschel — N2 Short talk 2026-08-13T12:45:00+02:00 12:45 00:15 We present a Bayesian calibration framework built on `Turing.jl` for statistically rigorous data assimilation. To scale inference with Gaussian Processes, we employ a Bayesian Committee Machine approach, and exploit parallelism across both CPU and GPU backends. We demonstrate the framework on both analytical and real-world data from accelerator physics, highlighting speedups. The result is a practical, flexible toolkit designed for rapid model updating and calibration. juliacon-2026-92726-bayesian-calibration-using-turing-jl-a-flexible-framework-for-experimental-data-assimilation General /media/juliacon-2026/submissions/HQJMLW/image_EGote9y.webp Sebastian Heinekamp en 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. false https://pretalx.com/juliacon-2026/talk/HQJMLW/ https://pretalx.com/juliacon-2026/talk/HQJMLW/feedback/ Muschel — N2 Long talk 2026-08-13T14:30:00+02:00 14:30 00:30 Efficiently obtaining high-accuracy data for molecules and materials is one of the major challenges in quantum chemistry. We present ElemCo.jl, an efficient, user-friendly, modular, open-source Julia package for performing quantum-chemical calculations, including Hartree-Fock (HF) and post-HF methods, with a focus on Coupled Cluster theory. Particular emphasis will be placed on tensor-decomposed Distinguishable Cluster methods to treat extended systems at substantially reduced computational cost. juliacon-2026-92698-elemco-jl-a-julia-package-for-electron-correlation-in-molecules-and-materials JuliaMolSim Minisymposium /media/juliacon-2026/submissions/THBSKY/image_bEY4tWx.webp Charlotte RickertDaniel Kats en 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). false flyer-THBSKY https://pretalx.com/juliacon-2026/talk/THBSKY/ https://pretalx.com/juliacon-2026/talk/THBSKY/feedback/ Muschel — N2 Long talk 2026-08-13T15:00:00+02:00 15:00 00:30 I would like to show you how I combine Python- and Julia-based machine learning models into a scalable molecular dynamics (MD) simulation workflow using the NQCDynamics.jl package. My research focuses on simulating light-driven chemistry on metal surfaces, where non-adiabatic coupling between electronic and nuclear motion requires custom MD methods. If you are in the field of non-adiabatic / excited state dynamics, I hope I can show you why this might be interesting for your own simulations. juliacon-2026-91943-ml-accelerated-simulation-of-laser-driven-hydrogen-evolution-with-nqcdynamics-jl-julia-and-python-in-harmony JuliaMolSim Minisymposium /media/juliacon-2026/submissions/BLZJJW/image_3vla3dU.webp Alexander Spears en **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). false https://pretalx.com/juliacon-2026/talk/BLZJJW/ https://pretalx.com/juliacon-2026/talk/BLZJJW/feedback/ Muschel — N2 Long talk 2026-08-13T15:30:00+02:00 15:30 00:30 Transport coefficients are quantities measuring sensitivities in various fluxes for equilibrium molecular systems subject to thermodynamic forcings driving them out of equilibrium. Typical examples are diffusivity, shear viscosity or thermal conductivity, which enter as parameters in macroscopic models of fluids and materials. Unfortunately, these are notoriously difficult to compute, and there is still a need to develop more efficient algorithms. We will present three algorithms to compute transport coefficients in stochastic MD: the Green-Kubo method, the nonequilibrium molecular dynamics (NEMD) method, and the constant-flux approach recently proposed in [this work](https://doi.org/10.1007/s10955-024-03230-x). We discuss how [Molly.jl](https://juliamolsim.github.io/Molly.jl/stable/), with its highly extensible design, allows to rapidly implement these methods and assess their relative performance. This leads in particular to discover promising properties of the constant-flux approach, narrowing the gap between mathematical ideas in statistical physics and applications in computational science. This is joint work with Gabriel Stoltz. juliacon-2026-92699-computing-transport-coefficients-using-molly-jl JuliaMolSim Minisymposium /media/juliacon-2026/submissions/GXPBHY/image_04TX30m.webp Noé Blassel en #### 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. false https://pretalx.com/juliacon-2026/talk/GXPBHY/ https://pretalx.com/juliacon-2026/talk/GXPBHY/feedback/ Muschel — N2 Short talk 2026-08-13T16:00:00+02:00 16:00 00:15 Seebeck coefficient, electrical conductivity, and thermal conductivity are key parameters for thermoelectric design. `BoltzTraP.jl` is a Julia port of BoltzTraP2, the standard tool for computing these via the Boltzmann transport equation, ensuring numerical equivalence with Julia-native optimizations. It accepts input from major DFT codes and `DFTK.jl`, enabling an all-Julia workflow from electronic structure to transport properties. In-memory calculations show over 2x speedup over BoltzTraP2. juliacon-2026-92638-boltztrap-jl-thermoelectric-transport-for-the-julia-dft-ecosystem JuliaMolSim Minisymposium /media/juliacon-2026/submissions/SEDPHP/image_JTWVVoX.webp Hiroharu Sugawara en 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 false flyer-SEDPHP https://pretalx.com/juliacon-2026/talk/SEDPHP/ https://pretalx.com/juliacon-2026/talk/SEDPHP/feedback/ Muschel — N2 Short talk 2026-08-13T16:15:00+02:00 16:15 00:15 The Density-Functional ToolKit (DFTK) is a Julia package providing routines to compute the electronic structure of a bulk material and related properties, using plane-wave density functional theory (DFT). Many material properties of interest can be expressed as derivatives of simulation outputs wrt. input parameters, and typically only specific combinations are implemented by DFT codes, as a result of great programming effort to hand-implement all the required derivative terms. In DFTK however, derivatives of **any** output quantity wrt. **any** input parameter can be computed, using algorithmic differentiation (AD) combined with density-functional perturbation theory (DFPT). This results in a general AD-DFPT framework [1] that can only be used to compute both standard and novel derivatives, with promising applications including gradient-based optimization and error propagation. In the first part of this talk, I will discuss the key ideas behind this implementation, showing how we offload tedious derivative computations to the AD framework, while keeping the numerics under control thanks to the underlying DFPT solver. The overall strategy is quite general, and should be applicable in other fields as well. In the second part of this talk, I will present new research directions enabled by AD-DFPT. In particular, I will focus on the propagation of model parameter uncertainty and estimated numerical errors all the way to predicted physical quantities. juliacon-2026-92722-algorithmic-differentiation-and-error-control-with-dftk JuliaMolSim Minisymposium /media/juliacon-2026/submissions/ZLZ8FJ/image_VXXqtRO.webp Bruno Ploumhans en false https://pretalx.com/juliacon-2026/talk/ZLZ8FJ/ https://pretalx.com/juliacon-2026/talk/ZLZ8FJ/feedback/ Muschel — N2 Short talk 2026-08-13T16:30:00+02:00 16:30 00:15 Here we present, LightMatter.jl, a flexible and efficient framework for simulations of nonequilibrium electron dynamics triggered by light. By leveraging Julia’s powerful metaprogramming capabilities, it dynamically assembles and propagates scattering equations for different physical processes, offering fine control over accuracy and computational cost. Herein, I present its application in the study of laser-driven electron and phonon equilibration in metals showcasing it's power to model complex nanoscale materials. juliacon-2026-92889-simulation-of-light-driven-hot-carrier-dynamics-transport JuliaMolSim Minisymposium /media/juliacon-2026/submissions/ZPDSRG/image_fBwVqkq.webp Henry Snowden en Light-matter interactions are fundamental to a wide range of natural and technological processes, from photosynthesis and vision to photovoltaics and photocatalysis. Understanding how light drives matter out of thermodynamic equilibrium and leads to electronic and phononic transport phenomena is crucial for developing efficient optical sensors, nanolithography, and quantum technologies. These interactions govern key phenomena such as plasmonic excitations, energy transfer, and non-radiative relaxation, all of which play a critical role in spectroscopy, materials science, and nanophotonics. LightMatter.jl provides a framework for the simulation of the time-dependent evolution of the electronic energy distribution due to laser excitation in metals. The aim of the package is to enable users to design simulations that capture the physics of interest to their required level of theory. LightMatter.jl uses metaprogramming within Julia to construct a custom coupled set of ordinary differential equations which can then be propagated using DiffEq.jl. The metaprogramming also enables users to develop their own methodologies by exchanging components of the expression that describe different physical phenomena for custom functions or approximations. Currently the package contains capabilities to perform energy-resolved Boltzmann equations (B. Y. Mueller \& B. Rethfeld, Phys. Rev. B 2013) , the Two-Temperature Model (S. I. Anisimov et al., Sov. Phys. JETP 1974), the Athermal Electron Model, and time-dependent Schrödinger equation (TDSE) for a given Hamiltonian in the dipole approximation. The package is designed in such a way that components of the theories such as lifetimes, parameters and matrix elements can easily be implemented and tested while accessing all the other features. false https://pretalx.com/juliacon-2026/talk/ZPDSRG/ https://pretalx.com/juliacon-2026/talk/ZPDSRG/feedback/ Muschel — N2 Short talk 2026-08-13T17:00:00+02:00 17:00 00:15 I will present QCEngine.jl, an extension to the NQCDynamics.jl ecosystem that enables on-the-fly electronic structure theory calculations that couple to a library of efficient non-adiabatic dynamics methods. QCEngine.jl integrates with NQCModels.jl to enable the evaluation of molecular dynamics on electronic potential energy surfaces of interacting many-body Hamiltonians. I will highlight its use-case by presenting its applications to my research on spin-resolved surface scattering. juliacon-2026-92687-qcengine-jl-electronic-structure-for-nonadiabatic-dynamics JuliaMolSim Minisymposium /media/juliacon-2026/submissions/7VLXGG/image_annSsgW.webp Ash Baldwin en 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) false https://pretalx.com/juliacon-2026/talk/7VLXGG/ https://pretalx.com/juliacon-2026/talk/7VLXGG/feedback/ Muschel — N2 Short talk 2026-08-13T17:15:00+02:00 17:15 00:15 Plane-wave density-functional theory (DFT) is one of the most widely employed simulation approaches for modelling materials atomistically, taking an accurate quantum-mechanical description of electrons. Since 2019 we develop the Density-Functional ToolKit (DFTK, https://dftk.org), a Julia-based code for plane-wave DFT. Right now, with about 10k lines of code, the code remains tractable, despite we recently managed to considerably expand its features. Noteworthy recent extensions is the scaling to multiple GPUs as well as advanced and expensive electronic structure models, such as Hybrid DFT or DFT with Hubbard corrections. I will sketch the challenges with respect to keeping code concise despite the feature extension and why we believe this is the right direction in the age of differentiable scientific computing. Despite our goal to avoid hand-optimised code and custom kernels, our code has state-of-the-art performance, which I will illustrate with some recent benchmarks. This talk reports on work that has been conducted over the past two years jointly with many DFTK contributors, including Augustin Bussy (ETH Zürich), Bruno Ploumhans (EPFL), Antoine Levitt (Université Paris-Saclay), Tobias Schäfer (TU Vienna), Niklas Schmitz (EPFL), Francesco Sicignano (Scuola Normale Superiore, Pisa). juliacon-2026-93057-extending-dftk-jl-s-features-but-not-its-code-complexity JuliaMolSim Minisymposium /media/juliacon-2026/submissions/ZKCBJY/image_ScYakuu.webp Michael F. Herbst en false flyer-ZKCBJY https://pretalx.com/juliacon-2026/talk/ZKCBJY/ https://pretalx.com/juliacon-2026/talk/ZKCBJY/feedback/ Muschel — N3 Long talk 2026-08-13T10:00:00+02:00 10:00 00:30 We present an approach for building a Reactant backend for ParallelStencil, a Julia package for high-performance stencil computations. The approach includes the generation of kernel code and data structures that are pre-optimized to serve as optimal input for Reactant to generate efficient and correct GPU, TPU, and CPU code. We report performance of representative stencil mini-apps on recent hardware platforms, including NVIDIA H100 GPUs, evaluate it in absolute terms, and compare it with performance obtained with straightforward implementations using CUDA.jl, KernelAbstractions.jl, and other Julia packages that enable explicit GPU kernel programming. juliacon-2026-92714-from-stencils-to-xla-a-reactant-backend-for-parallelstencil-jl Julia for HPC Minisymposium /media/juliacon-2026/submissions/PGGCJK/image_9tKtFm8.webp Samuel OmlinWilliam Moses en 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. false flyer-PGGCJK https://pretalx.com/juliacon-2026/talk/PGGCJK/ https://pretalx.com/juliacon-2026/talk/PGGCJK/feedback/ Muschel — N3 Short talk 2026-08-13T10:30:00+02:00 10:30 00:15 [Chmy.jl](https://github.com/PTsolvers/Chmy.jl) is a Julia package for developing scalable, architecture-agnostic finite-difference codes. It provides modules for structured staggered grids, differential and interpolation operators, and boundary conditions. Chmy.jl v0.2 introduces functionality for expressing equations in a coordinate-independent tensor form and automatically generating kernels from lists of expressions, with kernel reordering and fusion to maximise memory throughput. juliacon-2026-93446-what-s-new-in-chmy-jl-tensor-expressions-and-automatic-optimisation-of-finite-difference-codes Julia for HPC Minisymposium /media/juliacon-2026/submissions/LHPDZM/image_NLvZhiq.webp Ivan Utkin en 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. false https://pretalx.com/juliacon-2026/talk/LHPDZM/ https://pretalx.com/juliacon-2026/talk/LHPDZM/feedback/ Muschel — N3 Short talk 2026-08-13T10:45:00+02:00 10:45 00:15 [TrixiParticles.jl](https://github.com/trixi-framework/TrixiParticles.jl) is an open-source framework for accessible particle-based multiphysics. In this talk, we demonstrate how to leverage modern, GPU-centric HPC hardware for complex fluid–structure interaction (FSI) simulations. Using a carbon-fiber freediving fin as a case study, we discuss the numerical challenges of extremely stiff and thin blades, and present performance benchmarks across different CPU and GPU architectures to showcase cross-platform efficiency. juliacon-2026-92894-trixiparticles-jl-on-gpus-a-deep-dive-into-simulating-fluid-dynamics-of-carbon-fiber-fins Julia for HPC Minisymposium /media/juliacon-2026/submissions/Y7LGHP/image_wGIaTTK.webp Erik Faulhaber en [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. false flyer-Y7LGHP https://pretalx.com/juliacon-2026/talk/Y7LGHP/ https://pretalx.com/juliacon-2026/talk/Y7LGHP/feedback/ Muschel — N3 Short talk 2026-08-13T11:15:00+02:00 11:15 00:15 Effective partitioning is important for the scalability of agent-based modeling (ABM) on HPC systems, but existing methods do not meet the specific challenges of complex ABMs. These usually involve heterogeneous agent types with phase-based execution, dynamic population changes, and moving agents. This talk presents ongoing research developing specialized partitioning algorithms for distributed ABMs, including a benchmark framework and the development of specialized Julia packages. juliacon-2026-92880-scalable-agent-based-modeling-understanding-and-addressing-partitioning-challenges Julia for HPC Minisymposium /media/juliacon-2026/submissions/99LHV3/image_onKjUgH.webp Steffen Fürst en 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. true https://pretalx.com/juliacon-2026/talk/99LHV3/ https://pretalx.com/juliacon-2026/talk/99LHV3/feedback/ Muschel — N3 Short talk 2026-08-13T11:30:00+02:00 11:30 00:15 Efficient simulation of multiphase flows remains a major challenge, particularly for cloud microphysical processes in which interactions between turbulent airflow and suspended droplets must be resolved in detail. We present a novel asynchronous two-way coupled Euler–Lagrange simulation framework that exploits heterogeneous computing architectures to achieve unprecedented scalability. The proposed method executes Eulerian field calculations on CPUs using the OpenFOAM software package, coupled asynchronously to Lagrangian particle tracking on GPUs implemented in Julia, minimizing computational idling times and synchronization barriers. Data transfers are initiated immediately upon data availability, with Eulerian source terms predicted from previous time steps and subsequently corrected to ensure conservation of mass and momentum. Particles are organized into cache-friendly chunks with maintained bounding boxes, enabling dynamic load balancing across GPUs and optimized CPU-GPU data transfers. Comprehensive testing on a local workstation and on a EuroHPC JU supercomputer revealed dramatic improvements: the algorithm achieves excellent scalability up to 256 billion droplets. The overall time-to-solution improved by a factor of 4.5, while energy efficiency improved 3.4 times compared to established methods. Weak and strong scaling tests demonstrated very good efficiency and speedup using up to 2500 cores paired with 256 GPUs. The software is available in a public GIT repository at https://github.com/Wikki-GmbH/SCALE-TRACK juliacon-2026-90798-asynchronous-field-particle-coupling-for-multiphase-cloud-simulation-using-heterogeneous-hpc Julia for HPC Minisymposium /media/juliacon-2026/submissions/VFZ9X7/image_rUjWsOV.webp Henrik Rusche en false public GIT repository flyer-VFZ9X7 Schematic execution timeline for one GPU driven by a host CPU and a slave CPU. Asynchronous overlap of Eulerian and Lagrangian calculations is clearly visible. Snapshot of droplets in the 81m³ cloud chamber. Two side walls and the top are removed for illustration purposes and only a selection of droplets is shown. The size of the droplets is scaled up proportional to their diameter, but with an additional scaling factor to make them visible. https://pretalx.com/juliacon-2026/talk/VFZ9X7/ https://pretalx.com/juliacon-2026/talk/VFZ9X7/feedback/ Muschel — N3 Short talk 2026-08-13T11:45:00+02:00 11:45 00:15 [PETSc](https://petsc.org/release/) is a widely used scientific computing library that allows you to write software that runs on massively parallel supercomputers. PETSc is written in C but provides interfaces for Fortran and Python. Its Julia interface, [PETSc.jl ](https://github.com/JuliaParallel/PETSc.jl), has been around for some time but only ported a small part of the library. Recently, this has changed and since version 0.4.0 it provides an interface to (nearly) the full PETSc library. There are a number of advantages compared to other attempts: - It can be very easily installed by typing "add PETSc" in the Julia package manager and is distributed with both precompiled PETSc binaries ` PETSc_jll ` (for linux and Mac) and MPI. - We provide both a high-level and a low-level interface. The low-level interface automatically wraps nearly the full PETSc library with over 3000 functions, whereas the high-level interface gives a more Julia-like experience but is currently limited to part of the library. - Automatic testing and CI/CD is performed with currently >50’000 tests. - Users can combine features from Julia, the Julia ecosystem, such as automatic differentiation and plotting with PETSc solvers. The resulting codes are much more compact than their counterparts in lower-level languages; yet, users still have access to all PETSc features, such as multigrid solvers for DMDA or DMStag grids. - It allows running code on both a local workstation and on a large HPC system. In the presentation, I will summarise some of the work done to achieve this and show scalability results of typical codes. I will also compare the timing with native compiled code. juliacon-2026-92914-petsc-jl Julia for HPC Minisymposium /media/juliacon-2026/submissions/SHEA7J/image_Azu0a7x.webp Boris Kaus en false https://pretalx.com/juliacon-2026/talk/SHEA7J/ https://pretalx.com/juliacon-2026/talk/SHEA7J/feedback/ Muschel — N3 Long talk 2026-08-13T12:00:00+02:00 12:00 00:30 We present Spry.jl, a package for high performance networking natively in Julia. Traditional HPC has long used abstractions like MPI or SHMEM to manage communication. Spry.jl directly interfaces with the low level Libfabrics and UCX libraries enabling fast, scalable networking that complements Julia's dynamism, performance, and workflow flexibility rather than limiting it. We also provide an overview of the high level interfaces of Spry like distributed arrays, channels, and object stores. juliacon-2026-93478-spry-jl-native-high-performance-networking-in-julia Julia for HPC Minisymposium /media/juliacon-2026/submissions/BLDX9J/image_ysARU79.webp Raye Kimmerer en 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. false https://pretalx.com/juliacon-2026/talk/BLDX9J/ https://pretalx.com/juliacon-2026/talk/BLDX9J/feedback/ Muschel — N3 Short talk 2026-08-13T12:30:00+02:00 12:30 00:15 While Julia’s `Dagger.jl` provides a productive framework for task-based parallelism using Directed Acyclic Graphs (DAGs), its default reliance on TCP-based `Distributed.jl` limits performance on low-latency HPC interconnects. To bridge this gap, we developed `MPIAcceleration`, a strategic extension that replaces standard transport with an MPI-aware backend. By leveraging `MPI.jl` and non-blocking communication, we enable Dagger to use specialized hardware such as InfiniBand and Slingshot while maintaining a simple, high-level API. juliacon-2026-92943-bridging-the-gap-between-dagger-jl-and-hpc-interconnects Julia for HPC Minisymposium /media/juliacon-2026/submissions/AUBUSN/image_KGjbqSS.webp Yan GuimarãesFelipe Tomé en 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. false https://pretalx.com/juliacon-2026/talk/AUBUSN/ https://pretalx.com/juliacon-2026/talk/AUBUSN/feedback/ Muschel — N3 Short talk 2026-08-13T12:45:00+02:00 12:45 00:15 Stencil operations are a cornerstone in many fields, including fluid and gas flow simulations, machine learning/AI, computer graphics, image processing, and many more. Stencil operations (also known as windowed operations) allow a normal elementwise operation to additionally access neighboring elements, instead of just the currently-selected element. The are a number of stencil computation libraries in Julia, such as ImageFiltering.jl, ParallelStencil.jl, Stencils.jl, and now Dagger.jl (the focus of this talk). Dagger in particular makes it easy to define stencil operations that run across multiple CPUs, multiple GPUs, and across multiple nodes, and supports many kinds of boundary conditions, arbitrary numbers of dimensions, and flexible neighborhood sizing. We will discuss and compare the differences between the various stencil libraries, and see how easy it is to write parallel stencils in each library. We will also look at Dagger’s stencil performance in a variety of microbenchmarks. juliacon-2026-93151-sketch-me-an-hpc-program-stencils-with-dagger-jl Julia for HPC Minisymposium /media/juliacon-2026/submissions/YGSNMR/image_FD9bhid.webp Julian P SamarooFelipe ToméRabab Alomairy en false https://pretalx.com/juliacon-2026/talk/YGSNMR/ https://pretalx.com/juliacon-2026/talk/YGSNMR/feedback/ Muschel — N3 Short talk 2026-08-13T14:30:00+02:00 14:30 00:15 Multi-GPU execution is the future - as data sizes grow, and as more work is pushed to the GPU, a single GPU no longer suffices. Unfortunately, programming an algorithm for multi-GPU is more complicated than single-GPU - you now have to deal with the complexity of multi-device data movement and multi-stream synchronization, which puts more burden on the algorithm author and takes away from just writing the algorithm in the simplest, most readable manner. Thankfully, Dagger.jl makes programming multi-GPU algorithms much easier with its Datadeps framework, which lets you focus on writing the algorithm at a high level while Dagger handles the details of managing multiple GPUs. This talk will explain the problems around multi-GPU programming, and show how Dagger handles them. We will show how the Datadeps framework makes it much easier to write algorithms which naturally support multi-GPU execution, and show the tools that Dagger and Datadeps provide to make algorithm design a breeze. juliacon-2026-92800-multi-gpu-algorithms-with-dagger-jl Julia, GPUs, and Accelerators /media/juliacon-2026/submissions/VC7Q39/image_4Ooz3Cq.webp Julian P SamarooFelipe Tomé en false https://pretalx.com/juliacon-2026/talk/VC7Q39/ https://pretalx.com/juliacon-2026/talk/VC7Q39/feedback/ Muschel — N3 Short talk 2026-08-13T14:45:00+02:00 14:45 00:15 This talk introduces a new package called CoolPDLP.jl, which implements state-of-the-art parallel algorithms for large-scale linear programming. Thanks to Julia's flexible GPU ecosystem, these algorithms run on various kinds of accelerators, accepting arbitrary matrix and number types. juliacon-2026-92455-hardware-agnostic-linear-programming-on-the-gpu Julia, GPUs, and Accelerators /media/juliacon-2026/submissions/WGCTSX/image_BFZFAyZ.webp Guillaume DalleMichael KlamkinSimeon Schaub en 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. false Package repository https://pretalx.com/juliacon-2026/talk/WGCTSX/ https://pretalx.com/juliacon-2026/talk/WGCTSX/feedback/ Muschel — N3 Long talk 2026-08-13T15:00:00+02:00 15:00 00:30 The modular compiler of Julia allows non-standard compilation flows and heteregeneous targets. Field Programmable Gate Array (FPGAs) are one of them, and Julia is an excellent fit for High-Level Synthesis (HLS). We present an HLS toolchain that takes advantage of the MLIR tracing system Reactant.jl and CIRCT HLS flow. This approach enables flexible design-space exploration and rapid prototyping of FPGA designs. juliacon-2026-93407-julia-meets-again-the-fpga-higher-level-synthesis-methodology-for-heterogeneous-hardware-and-software-architectures Julia, GPUs, and Accelerators /media/juliacon-2026/submissions/UFPKBT/image_Sfw4WWt.webp Gaëtan LOUNES en 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 false https://pretalx.com/juliacon-2026/talk/UFPKBT/ https://pretalx.com/juliacon-2026/talk/UFPKBT/feedback/ Muschel — N3 Long talk 2026-08-13T15:30:00+02:00 15:30 00:30 QuantumKitHub's various packages provide low- and high-level tooling for the implementation of (among other things) tensor network algorithms. These algorithms are highly amenable to GPU-based acceleration, but there are many stumbling blocks along the way. In the past year we have been actively working to add GPU support to the whole stack of TN-related packages, and in this talk we will discuss the performance benefits and challenges thus far, our roadmap, and how this work can benefit the wider JuliaGPU developer and user community. juliacon-2026-93411-gpu-acceleration-in-the-quantumkithub-ecosystem Julia, GPUs, and Accelerators /media/juliacon-2026/submissions/TATRTG/image_ulWeWXl.webp Katharine HyattLukas Devos en 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. false https://pretalx.com/juliacon-2026/talk/TATRTG/ https://pretalx.com/juliacon-2026/talk/TATRTG/feedback/ Muschel — N3 Short talk 2026-08-13T16:00:00+02:00 16:00 00:15 GPU vendor libraries like cuBLAS deliver excellent performance but come with hard constraints: limited type support, fixed operators, and single-vendor hardware. The Julia GPU ecosystem addresses portability through an abstraction layer: KernelAbstractions.jl lets developers write kernels that compile across CUDA, AMD, Intel, and Apple backends. But abstraction currently comes at a cost: KA.jl lacks the intrinsics needed for fully optimized performance. Warp operations on extended types, vectorized memory access, and explicit memory ordering for inter-workgroup communication are missing. We introduce [KernelForge.jl](https://epilliat.github.io/KernelForge.jl), a Julia package proving that portable GPU code can match vendor-optimized performance. To make this possible, we developed [KernelIntrinsics.jl](https://epilliat.github.io/KernelIntrinsics.jl), which exposes the missing primitives (currently CUDA-only, though the approach extends to other backends). KernelForge.jl provides kernels for matrix-vector and vector-matrix products with arbitrary operators and bitstype elements, mapreduce over 1D and 2D arrays, prefix scan, and copy operations. Each is implemented as a single kernel using vectorized loads/stores to saturate memory bandwidth as much as possible, warp-level reductions, and strong memory ordering for correct inter-workgroup synchronization. Benchmarks show that KernelForge.jl matches or exceeds both proprietary CUDA functions and NVIDIA's CUB library. The kernels are stable and tested, though views and strided arrays are not yet supported. The goal is straightforward: open-source GPU code that is efficient, flexible, and eventually portable. juliacon-2026-90359-kernelforge-jl-fast-flexible-gpu-computing-toward-portability Julia, GPUs, and Accelerators /media/juliacon-2026/submissions/EFQ8YD/image_zM99p2S.webp Emmanuel Pilliat en 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. false https://pretalx.com/juliacon-2026/talk/EFQ8YD/ https://pretalx.com/juliacon-2026/talk/EFQ8YD/feedback/ Muschel — N3 Short talk 2026-08-13T16:15:00+02:00 16:15 00:15 This package provides a collection of functions which can be written in a form separated by coordinates. An example is a multidimensional Gaussian, a parabolic potential or a complex valued plane wave. Typically the separable functions are combined by a multiplication but there are also examples using other operators to combine them. Upon construction the separable parts are pre-calculated and a Julia-generic `Base.Broadcast.Broadcasted` object, which behaves a bit like a lazy array. It seamlessly merges with other broadcasting operations. The package, albeit being CUDA-agnostic, is fully capable of working with `CuArray` objects, creating a pre-calculated 1-dimensional `CuArray` for each dimension which then takes part in the broadcasting. The use of `SeparableFuctions.jl` significantly speeds up calculations and saves on-board memory. It is currently used in a number of other packages, for example `StructuredIlluminationMicroscopy.jl` which reconstructs optical images supported by acceleration via `CUDA.jl`(See also the Computational Physics Minisymposium). juliacon-2026-89345-separablefunctions-jl Julia, GPUs, and Accelerators /media/juliacon-2026/submissions/7ZFWC8/image_5a0riXq.webp Rainer Heintzmann en false https://pretalx.com/juliacon-2026/talk/7ZFWC8/ https://pretalx.com/juliacon-2026/talk/7ZFWC8/feedback/ Muschel — N3 Short talk 2026-08-13T16:30:00+02:00 16:30 00:15 Fortran climate models are being adapted to GPUs by automatically translating loop-by-loop into a kernel. In Julia, we have more flexibility to develop the climate model [SpeedyWeather.jl](https://github.com/SpeedyWeather/SpeedyWeather.jl) for the GPU. Many parts are easy to accelerate, leverage multiple dispatch on the GPU and a high level of kernel fusion for modularity and performance, while being optionally hardware-specific. The spherical harmonic transforms remain a complex bottleneck but we employ a multi-algorithm approach with custom linear algebra kernels using Reactant, Fourier and Legendre transforms. juliacon-2026-92661-the-gpu-acceleration-of-speedyweather-jl-the-friendly-and-flexible-climate-model Julia, GPUs, and Accelerators /media/juliacon-2026/submissions/W7FRKU/image_a9z5UJp.webp Milan KlöwerNiklas ViebigMaximilian Gelbrecht en 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 false flyer-W7FRKU https://pretalx.com/juliacon-2026/talk/W7FRKU/ https://pretalx.com/juliacon-2026/talk/W7FRKU/feedback/ Muschel — N3 Short talk 2026-08-13T16:45:00+02:00 16:45 00:15 CUDA is well known for its SIMT programming model, available in Julia through CUDA.jl. This year, NVIDIA introduces cuTile, a new tile-based programming model for writing high-performance GPU kernels, with automatic tensor core utilization. cuTile.jl brings this model to Julia, compiling Julia kernels through a custom pipeline to Tile IR bytecode. In this talk, we'll cover the programming model, the compiler design, and performance benchmarks on Blackwell GPUs. juliacon-2026-92428-tile-based-gpu-programming-with-cutile-jl Julia, GPUs, and Accelerators /media/juliacon-2026/submissions/FX73BU/image_chXO3Qz.webp Tim Besard en 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. false https://pretalx.com/juliacon-2026/talk/FX73BU/ https://pretalx.com/juliacon-2026/talk/FX73BU/feedback/ Muschel — N3 Short talk 2026-08-13T17:00:00+02:00 17:00 00:15 Even more improvements and features have been since this package was discussed last year at JuliacCon 2025. This talk will highlight some of the more meaningful user-facing feature additions, performance and quality of life improvements, as well as significant bug fixes. juliacon-2026-93460-what-s-new-in-cuda-jl-besides-cutile Julia, GPUs, and Accelerators /media/juliacon-2026/submissions/BPEJLA/image_ZtMdx4H.webp Katharine Hyatt en false https://pretalx.com/juliacon-2026/talk/BPEJLA/ https://pretalx.com/juliacon-2026/talk/BPEJLA/feedback/ Muschel — N3 Short talk 2026-08-13T17:15:00+02:00 17:15 00:15 Major improvements and features have been implemented in Metal.jl since this package was last discussed at JuliaCon. This talk will highlight some of the more meaningful user-facing feature additions, performance and quality of life improvements, as well as significant bug fixes. juliacon-2026-93448-what-s-new-in-metal-jl Julia, GPUs, and Accelerators /media/juliacon-2026/submissions/X3GGMU/image_5c58HBl.webp Christian Guinard en 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. false Metal.jl Github https://pretalx.com/juliacon-2026/talk/X3GGMU/ https://pretalx.com/juliacon-2026/talk/X3GGMU/feedback/ Alte Mensa — Audi Max Short talk 2026-08-13T12:45:00+02:00 12:45 00:15 We present the Jlpigraf package for interacting with the Epigraf API. [Epigraf ](https://github.com/digicademy/epigraf) is an open-source research platform designed for the collection, annotation, linking, and publication of multimodal text data. Its data model supports research databases ranging from epistolary editions to social media corpora. Currently, Epigraf is primarily used for editing epigraphic data — inscriptions in connection with the objects to which they are attached. The platform includes a publication system for various document formats, such as Word and TEI, as well as structured JSON, XML, and CSV data and triples in TTL, JSON-LD, and RDF/XML. Thus, Epigraf is building a bridge between traditional editorial work and computational humanities. Until now, the [Rpigraf](https://github.com/datavana/rpigraf) R package is provided to interact with the Epigraf API. The Jlpigraf package brings a significant portion of Rpigraf's functionality to the Julia programming language. The goal is twofold. Firstly, implementing the package leverages the performance and syntax advantages of Julia for data analysis and processing in the humanities. Secondly, Epigraf originated in a specific humanities research context, and we are working to open the platform up to other disciplines and research communities. Epigraf uses the [Relational Article Model](https://epigraf.inschriften.net/help/coreconcepts/model) (RAM) to internally manage the database content. The basic building blocks are articles grouped into projects and subdivided into sections that contain items. Items hold the specific data such as text, image file names or references to categories. Articles are linked to category systems directly via tagging them in items or via in-text annotations. Examples of category systems include bibliographic references, persons and locations, authority data, and in-text annotation vocabularies. The RAM's building blocks are then mapped to the specific research domain. The Jlpigraf package has the following core tasks (work in progress): 1. Interacting with the Epigraf API, including authentication, data fetching, and data manipulation. 2. Extracting, joining and transforming RAM data. 3. Handling hierarchical data and tree structures. Thus, the package relieves users of frequently recurring tasks. It provides easy access to the corpora stored in Epigraf. A basic understanding of the Relational Article Model's structure is sufficient to work with the data. In the proposed talk, we will provide a brief introduction to the topic and the Relational Article Model. Then, we will explain the objectives of the package using application examples. Finally, we will discuss the process of translating from R to Julia, emphasizing relevant language features and the Julia package ecosystem. juliacon-2026-93441-jlpigraf-jl-a-package-for-data-retrieval-and-table-merging-with-the-epigraf-api Bringing Julia to the Computational Humanities and Social Sciences /media/juliacon-2026/submissions/BNPWFP/image_c9TIiVL.webp Georg Hertkorn en false Jlpigraf package repository https://pretalx.com/juliacon-2026/talk/BNPWFP/ https://pretalx.com/juliacon-2026/talk/BNPWFP/feedback/ Alte Mensa — Audi Max Long talk 2026-08-13T14:30:00+02:00 14:30 00:30 We have long wanted to be able to count unique clients using Julia and various packages, but privacy concerns have prevented us from doing so. A new protocol combining two magical technologies—HyperLogLog cardinality estimation and RSA public key encryption—allows accurate estimation of client counts while provably preserving anonymity. This protocol, dubbed "HyperLogLog Over RSA" is now built into Julia's Pkg client, allowing us to finally get reliable client counts. juliacon-2026-90998-hyperloglog-over-rsa-anonymously-counting-users General /media/juliacon-2026/submissions/JXMW8H/image_KP8ZbNz.webp Stefan Karpinski en 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. false https://pretalx.com/juliacon-2026/talk/JXMW8H/ https://pretalx.com/juliacon-2026/talk/JXMW8H/feedback/ Alte Mensa — Audi Max Short talk 2026-08-13T15:00:00+02:00 15:00 00:15 As the pharmaceutical industry shifts toward Model-Informed Drug Development (MIDD) and complex pharmacometric simulations, the Julia programming language has emerged as a frontrunner due to the availability of specialized ecosystem for Pharmacometrics (Through Pumas, SciML and JuliaDiff packages) and support for High Performance Computing, and interoperability. However, deploying Julia in a GxP-regulated environment requires more than just efficient algorithms; it demands strict adherence to software validation, reproducibility, and data integrity standards such as FDA 21 CFR Part 11 and GAMP 5. This talk outlines a strategic framework for making Julia code "pharma-ready." We explore the use of Julia’s native packages to maintain Reproducibility, the implementation of testing suites for the generation of validation reports and we will also explore how to use literate programming in Julia to generate documentation and reports . By leveraging Julia’s unique features, we show how developers can create high-performance workflows that satisfy both computational demands and regulatory scrutiny. juliacon-2026-92885-making-your-julia-code-compliant-for-usage-in-pharmaceutical-industry General /media/juliacon-2026/submissions/LCUBGM/image_QDY2U4M.webp Harsha Byadarahalli Mahesh en 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. false https://pretalx.com/juliacon-2026/talk/LCUBGM/ https://pretalx.com/juliacon-2026/talk/LCUBGM/feedback/ Alte Mensa — Audi Max Short talk 2026-08-13T15:15:00+02:00 15:15 00:15 For better or worse, we live in a world where being online is essential for being known. This applies not only to people, but also to ideas, algorithms, and software created by Julia programmers. Your research may be groundbreaking and your algorithms elegant, but if they are not accessible online, they are unlikely to be seen or used. Many researchers recognize this and try to publicize their work through papers, talks, and blog posts. However, the most effective way to communicate a computational idea is not just to describe it, but to let people *interact* with it. A web app allows users to explore a model, test an algorithm, or visualize results directly, making the value of the work immediately clear. The problem is that most scientists and researchers lack the time or expertise to build web applications. Traditional web frameworks lower the barrier somewhat, but they still require knowledge of web development concepts and introduce friction when all you want is a simple, interactive interface to your Julia code. [Magic.jl](https://github.com/nidoro/Magic.jl) is designed to remove this friction. Aimed at scientists and researchers, it provides a simple, Julia-native way to turn algorithms and solutions into interactive web apps, in the same spirit that Streamlit does for Python. juliacon-2026-88939-a-new-way-of-creating-julia-web-apps General /media/juliacon-2026/submissions/R8VPMR/magic-logo-and-text_EWL3sc6.svg Davi Doro en [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 false flyer-R8VPMR https://pretalx.com/juliacon-2026/talk/R8VPMR/ https://pretalx.com/juliacon-2026/talk/R8VPMR/feedback/ Alte Mensa — Audi Max Short talk 2026-08-13T15:45:00+02:00 15:45 00:15 SpeedRand.jl is a fully-implemented alternative toy PRNG that implements (more or less) the full suite of Julia's informally-documented AbstractRNG interface, with a terrible, humorous twist. juliacon-2026-92537-speedrand-jl-how-to-not-implement-your-own-prng-in-julia General /media/juliacon-2026/submissions/MQKGAM/image_nB2VU1V.webp Kevin Qing en false https://pretalx.com/juliacon-2026/talk/MQKGAM/ https://pretalx.com/juliacon-2026/talk/MQKGAM/feedback/ Alte Mensa — Audi Max Short talk 2026-08-13T16:00:00+02:00 16:00 00:15 In this talk, I reflect on my experience designing, delivering, and openly releasing a university course - High Performance Computing in Julia - whose materials have since found an audience beyond my own students. I will begin with the story behind the course: why Julia was the natural choice for teaching high performance computing, and how the course developed over the years of teaching. From there, I will offer a practical account of what it takes to build an online course, the software choices considered and used, along with alternative approaches that other educators may prefer. Whether you are an educator considering Julia for your own teaching, or a community member thinking about sharing your expertise through educational material online, this talk should have something interesting for you. juliacon-2026-92831-how-to-teach-an-online-julia-course General /media/juliacon-2026/submissions/YWEB3Y/image_OZ7iyXH.webp Dr. Jamie Mair en 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. false https://pretalx.com/juliacon-2026/talk/YWEB3Y/ https://pretalx.com/juliacon-2026/talk/YWEB3Y/feedback/ Alte Mensa — Audi Max Short talk 2026-08-13T16:15:00+02:00 16:15 00:15 JuliaCheck.jl is an extensible, rule-based static code analyzer for Julia, developed by [TIOBE ](www.tiobe.com)(in collaboration with [ASML](www.asml.com)). Built on JuliaSyntax.jl, it enforces configurable coding standards (from style and structure to security) and integrates with TIOBE's TiCS quality framework, bringing enterprise-grade code quality measurement to Julia for the first time. juliacon-2026-92489-juliacheck-industrial-grade-static-code-analysis-for-julia General /media/juliacon-2026/submissions/SZPFSX/image_45OSqgd.webp Evangelos ParadasPaul Jansen en 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). false https://pretalx.com/juliacon-2026/talk/SZPFSX/ https://pretalx.com/juliacon-2026/talk/SZPFSX/feedback/ Alte Mensa — Audi Max Short talk 2026-08-13T16:30:00+02:00 16:30 00:15 Many important networks have beyond-binary relations that make graph structures inefficient or insufficient representations. Hypergraphs, the generalizations of traditional graphs, are needed to study such complex networks. In this talk, we will discuss hypergraph modeling in Julia, primarily focusing on SimpleDirectedHypergraphs.jl, a recently developed package for complex networks with n-ary directional relations. juliacon-2026-89941-directed-hypergraph-structures-for-complex-network-analysis-in-julia General /media/juliacon-2026/submissions/HTGCKD/image_gbwTOVQ.webp Evan Walter Clark Spotte-Smith (they/them)Zhenya Barannik en 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 false https://pretalx.com/juliacon-2026/talk/HTGCKD/ https://pretalx.com/juliacon-2026/talk/HTGCKD/feedback/ Alte Mensa — Audi Max Short talk 2026-08-13T16:45:00+02:00 16:45 00:15 Following our introduction of ORTools.jl, this session focuses on the specialized integration of Google’s CP-SAT solver within the JuMP ecosystem. We move beyond the general package overview to examine the specific implementation of CP-SAT for Julia users. The talk covers the technical mapping of constraints to the solver’s interface and discusses the development challenges encountered when bridging CP-SAT with Julia. juliacon-2026-93439-ortools-jl-cp-sat-through-jump General /media/juliacon-2026/submissions/M79AYW/image_hi5w4fd.webp Ochibobo Warren en 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. false https://pretalx.com/juliacon-2026/talk/M79AYW/ https://pretalx.com/juliacon-2026/talk/M79AYW/feedback/ Alte Mensa — Audi Max Short talk 2026-08-13T17:00:00+02:00 17:00 00:15 Since 2022, Copulas.jl has provided native support for dependence modeling in Julia. Copulas are multivariate distribution functions on the unit hypercube that allow practitioners to model dependence structures separately from marginal behavior. By building on the Distributions.jl framework, Copulas.jl integrates seamlessly with Julia’s probabilistic and statistical ecosystem. In this talk, we review the major design improvements and new features introduced since the first public releases of Copulas.jl. The package now offers a broad collection of classical parametric copula families, along with tools for evaluating distribution functions and densities, computing dependence measures such as Kendall’s tau and Spearman’s rho, estimating parameters via inversion of moments or maximum likelihood, and fitting models to data. A key feature of the package is the Sklar type, inspired by Sklar’s Theorem, which enables users to construct full multivariate models by combining copulas with arbitrary marginal distributions. These composite models are fully compatible with the Distributions.jl API, making them directly usable in downstream tools such as Turing.jl for Bayesian inference. We conclude with practical examples showcasing how the new features of Copulas.jl enable advanced dependence modeling workflows entirely in native Julia. juliacon-2026-92867-what-s-new-in-copulas-jl General /media/juliacon-2026/submissions/ZBQKTY/image_ZFVfxXM.webp Oskar Laverny en false https://pretalx.com/juliacon-2026/talk/ZBQKTY/ https://pretalx.com/juliacon-2026/talk/ZBQKTY/feedback/ Alte Mensa — Audi Max Short talk 2026-08-13T17:15:00+02:00 17:15 00:15 Peridynamics.jl is a Julia package for dynamic fracture simulations that supports multithreading and MPI for high-performance computing. This talk focuses on how researchers in peridynamics can adapt the package to their own models rather than on the internal development of the code base. We show how Julia's multiple dispatch and type system make it straightforward to implement custom material models, damage criteria, and boundary conditions, while the package handles parallelism and I/O. The goal is to give researchers a practical starting point for their own extensions, attracting more users to the package and to the Julia ecosystem in general. juliacon-2026-93667-how-to-extend-peridynamics-jl-for-your-own-research General /media/juliacon-2026/submissions/G7CLZ7/image_XSGLfh9.webp Kai Partmann en 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. false flyer-G7CLZ7 https://pretalx.com/juliacon-2026/talk/G7CLZ7/ https://pretalx.com/juliacon-2026/talk/G7CLZ7/feedback/ Alte Mensa — Atrium Maximum Long talk 2026-08-13T10:00:00+02:00 10:00 00:30 Basic computer arithmetic operations, such as +, ×, or ÷ are correctly rounded, whilst mathematical functions such as ex, ln(x), or sin(x) in general are not, meaning that separate implementations may provide different results when presented with an exact same input, and that their accuracy may differ. We present a methodology and a software tool that is suited for exhaustive and non-exhaustive testing of mathematical functions of Julia in various floating-point formats. The software tool is useful to the users of Julia, to quantise the level of accuracy of the mathematical functions and interpret possible effects of errors on their scientific computation codes that depend on these functions. It is also useful to the developers and maintainers of the functions in Julia Base, to test the modifications to existing functions and to test the accuracy of new functions. The software (a test bench) is designed to be easy to set up for running the accuracy tests in automatic regression testing. Our focus is to provide software that is user friendly and allows to avoid the need for specialised knowledge of floating-point arithmetic or the workings of mathematical functions; users only need to supply a list of formats, choose the rounding modes, and specify the input space search strategies based on how long they can afford the testing to run. We have utilized the test bench to determine the errors of a subset of mathematical functions in the latest version of Julia, for binary16, binary32, and binary64 IEEE 754 floating-point formats, and found 0.49 to 0.51ULPs in binary16, and 0.5 to 2.4ULPs of error in binary32 and binary64. The functions that may be correctly rounded (error of 0.5ULP) in all the three formats are sqrt and cbrt. The following functions may be correctly rounded only for binary16: sinh, asin, cospi, sinpi, atanh, log2, tanh. juliacon-2026-92449-accuracy-of-mathematical-functions-in-julia Approximate Computing in Numerical Linear Algebra /media/juliacon-2026/submissions/SRHZCN/image_5imq4T0.webp Mantas Mikaitis en false https://pretalx.com/juliacon-2026/talk/SRHZCN/ https://pretalx.com/juliacon-2026/talk/SRHZCN/feedback/ Alte Mensa — Atrium Maximum Long talk 2026-08-13T10:30:00+02:00 10:30 00:30 We present recently developed iterative methods for approximating matrices and tensors with structural constraints such as rank and sparsity level and pattern, extending to settings where data is incomplete or indirectly observed, with or without noise. These methods aim to solve canonical problems of numerical (multi-)linear algebra, namely approximate matrix inversion and low-rank matrix and tensor approximation, when structural constraints are imposed on the approximation. While the presented results revolve around aspects of sparsity, if time permits, we extend the presentation to other structural features such as non-negativity. We also present how this work contributes to the ongoing development of the repositories ApproximateMatrixInverses.jl, StructuredLowRankMatrices.jl, and StructuredLowRankTensors.jl. juliacon-2026-92860-structured-iterative-approximations-in-numerical-multi-linear-algebra Approximate Computing in Numerical Linear Algebra /media/juliacon-2026/submissions/UZXK9Y/image_94m8VBp.webp Nicolas Venkovic en false https://pretalx.com/juliacon-2026/talk/UZXK9Y/ https://pretalx.com/juliacon-2026/talk/UZXK9Y/feedback/ Alte Mensa — Atrium Maximum Long talk 2026-08-13T11:15:00+02:00 11:15 00:30 This presentation discusses the development of [MatrixEquations.jl](https://github.com/andreasvarga/MatrixEquations.jl), a comprehensive Julia package for solving specialized matrix equations, including Lyapunov, Sylvester, and Riccati types. While these equations are fundamental to control systems analysis and synthesis, their utility extends across numerous scientific domains. The package’s impact is substantial: it serves as a critical dependency for over 60 packages within the Julia ecosystem and averages over 2,000 monthly downloads. Reflecting on its status as my most successful software project to date, I look forward to sharing insights into its development—specifically regarding two distinct implementation challenges: achieving peak numerical performance by leveraging optimized, hardware-specific libraries, and providing generic functionality that supports Julia’s abstract type system to work seamlessly with arbitrary-precision and non-standard number types. juliacon-2026-91337-matrixequations-jl-a-continuous-effort-to-achieve-performance-and-genericity Approximate Computing in Numerical Linear Algebra /media/juliacon-2026/submissions/SHTJ3F/image_NswkzZx.webp Andreas Varga en false https://pretalx.com/juliacon-2026/talk/SHTJ3F/ https://pretalx.com/juliacon-2026/talk/SHTJ3F/feedback/ Alte Mensa — Atrium Maximum Long talk 2026-08-13T11:45:00+02:00 11:45 00:30 Solving large matrix equations can be very expensive. For many applications, however, the dense solutions can be well approximated by low-rank factorizations: products of two or three matrices with a substantially smaller inner dimension. And certain quantities can yet again be computed as a linear function of the solution, meaning one does not even need to assemble the low-rank factors. DifferentialRiccatiEquations.jl is a package to cater all these use cases for differential and (continuous-time) algebraic Riccati and Lyapunov equations. juliacon-2026-92072-differentialriccatiequations-jl-solving-matrix-equations-with-low-rank-solutions Approximate Computing in Numerical Linear Algebra /media/juliacon-2026/submissions/AV3GA8/image_w0v6aHY.webp Jonas Schulze en 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. false https://pretalx.com/juliacon-2026/talk/AV3GA8/ https://pretalx.com/juliacon-2026/talk/AV3GA8/feedback/ Alte Mensa — Atrium Maximum Short talk 2026-08-13T12:15:00+02:00 12:15 00:15 We implemented a mixed-precision, nested recursive Cholesky algorithm for GPU Matrix Processing Units (NVIDIA H200, AMD MI300X) using Julia. With a hierarchical precision method, we maximize throughput while maintaining numerical stability. Our recursive SYRK achieves a 14x speedup over cuBLAS, leading to a 5.32x overall speedup for Cholesky over cuSOLVER FP64. The solver leverages Julia’s multiple dispatch to provide a portable interface for HPC. juliacon-2026-92412-hierarchical-precision-and-recursion-for-accelerating-symmetric-linear-solves-on-mxus Approximate Computing in Numerical Linear Algebra /media/juliacon-2026/submissions/NXU8WC/image_lBtxVPX.webp Vicki Carrica en 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. false https://pretalx.com/juliacon-2026/talk/NXU8WC/ https://pretalx.com/juliacon-2026/talk/NXU8WC/feedback/ Alte Mensa — Atrium Maximum Birds of Feather (BoF) 2026-08-13T12:30:00+02:00 12:30 00:30 Open discussion for the community attending the mini, not to be recorded. juliacon-2026-104401-approximate-computing-community-panel Approximate Computing in Numerical Linear Algebra /media/juliacon-2026/submissions/J3MRUE/image_MolMA1h.webp Jonas Schulze en false https://pretalx.com/juliacon-2026/talk/J3MRUE/ https://pretalx.com/juliacon-2026/talk/J3MRUE/feedback/ Alte Mensa — Atrium Maximum Long talk 2026-08-13T14:30:00+02:00 14:30 00:30 Decision-Focused Learning (DFL) is a field at the intersection of machine learning and combinatorial optimization. It integrates prediction with combinatorial decision-making by embedding optimization algorithms directly into machine learning pipelines. This talk presents the **JuliaDecisionFocusedLearning** ecosystem, focusing on `DecisionFocusedLearningBenchmarks.jl` and `DecisionFocusedLearningAlgorithms.jl`, two new packages that provide a high-level and generic interface for using state-of-the-art DFL methods. juliacon-2026-92712-juliadecisionfocusedlearning-a-practical-introduction-to-decision-focused-learning-in-julia General /media/juliacon-2026/submissions/XS9BT7/image_n2m34mC.webp Léo Baty en 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. false https://pretalx.com/juliacon-2026/talk/XS9BT7/ https://pretalx.com/juliacon-2026/talk/XS9BT7/feedback/ Alte Mensa — Atrium Maximum Long talk 2026-08-13T15:00:00+02:00 15:00 00:30 [CounterfactualTraining.jl](https://github.com/JuliaTrustworthyAI/CounterfactualTraining.jl) leverages [CounterfactualExplanations.jl](https://github.com/JuliaTrustworthyAI/CounterfactualExplanations.jl) to make opaque machine learning models like artificial neural networks more 1) explainable, 2) sensitive to actionability constraints and 3) adversarially robust. The package is part of the [Taija](https://www.taija.org/) ecosystem for Trustworthy AI in Julia and the engine behind our [IEEE SaTML 2026](https://satml.org/accepted-papers/) paper titled *[Counterfactual Training: Teaching Models Plausible and Actionable Explanations](https://arxiv.org/abs/2601.16205)*. juliacon-2026-92822-teaching-opaque-machine-learning-models-plausible-and-actionable-explanations General /media/juliacon-2026/submissions/HBY8MD/image_820CSft.webp Patrick Altmeyer en 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. false flyer-HBY8MD https://pretalx.com/juliacon-2026/talk/HBY8MD/ https://pretalx.com/juliacon-2026/talk/HBY8MD/feedback/ Alte Mensa — Atrium Maximum Short talk 2026-08-13T15:45:00+02:00 15:45 00:15 Handles can be used instead of explicitly using pointers or references to access objects. This is done by storing the objects of a given type in a `Memory` or `Vector` and using the handle as an index. With a suitable abstraction, which Handles.jl provides, it turns out that this combines attractive properties like being faster than object references in certain situations and being safer than regular indexing for a static set of objects. Therefore, handles provide a pattern which might be interesting to use in large parts of the Julia ecosystem where efficiency matters and certain constraints hold. juliacon-2026-92827-handle-your-handles General /media/juliacon-2026/submissions/JFXJHC/image_wv8vpuI.webp Patrick Häcker en false https://pretalx.com/juliacon-2026/talk/JFXJHC/ https://pretalx.com/juliacon-2026/talk/JFXJHC/feedback/ Alte Mensa — Atrium Maximum Long talk 2026-08-13T16:00:00+02:00 16:00 00:30 We introduce the inner workings and use of ReSiE, a new package for the simulation of sector-coupled energy systems with complex non-linear control schemes on the scale of city districts. The package is based on a different mathematical approach than comparable tools in the field of energy system modelling, which typically use MILP. The strengths and weaknesses of this approach are discussed. Furthermore we present some "lessons learned" and how Julia was leveraged to implement the package. juliacon-2026-91885-district-scale-energy-system-simulation-with-resie General /media/juliacon-2026/submissions/8H9T9C/image_6KkJFCS.webp Etienne Ott en 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. false https://pretalx.com/juliacon-2026/talk/8H9T9C/ https://pretalx.com/juliacon-2026/talk/8H9T9C/feedback/ Alte Mensa — Atrium Maximum Poster 2026-08-13T19:00:00+02:00 19:00 02:00 This is the poster session for all posters! It will take place at 19:00 13 August 2026. Come see all the great posters we have this year and enjoy some refreshments. juliacon-2026-102516-juliacon-2026-poster-session General /media/juliacon-2026/submissions/7QZCDB/image_CMCoVjK.webp en false https://pretalx.com/juliacon-2026/talk/7QZCDB/ https://pretalx.com/juliacon-2026/talk/7QZCDB/feedback/ Tent — RW1 Keynote 2026-08-14T08:45:00+02:00 08:45 01:00 Sponsor Keynote: Boeing and JuliaHub. Breaking the non-recurring cost curve requires a fundamental shift in how complex systems are designed, analyzed, verified, and integrated. Traditional development approaches often discover design defects late in the lifecycle, when correction is more expensive, schedules are more constrained, and integration risk is highest. Model Based Development (MBD) changes this dynamic by moving defect discovery earlier and extending the verification window through the use of high-fidelity design models, executable simulations, early functional prototyping, and model-driven validation. This presentation explores how model-based methodologies enable earlier requirements validation, improved design maturity, greater standardization, earlier verification test readiness, and higher-fidelity system integration. By placing detailed system design models at the center of the development process, organizations can reduce late-cycle rework, improve first-pass quality, accelerate integration maturity, and ultimately reduce non-recurring engineering cost while improving delivery confidence. Subsequently, this session will showcase Dyad, by Juliahub, demonstrating how Dyad enables easy and efficient model based development, leveraging and agentic UI and the Julia programming language. juliacon-2026-93941-breaking-the-non-recurring-cost-curve-using-model-based-methodologies General /media/juliacon-2026/submissions/LCY7JK/image_d9UzDhk.webp Gary MansouriChris RackauckasViral B. Shah en 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. false https://pretalx.com/juliacon-2026/talk/LCY7JK/ https://pretalx.com/juliacon-2026/talk/LCY7JK/feedback/ Tent — RW1 Long talk 2026-08-14T10:00:00+02:00 10:00 00:30 Professional Julia use requires industrial security. This challenge is unique because risks often hide in binary dependencies (JLLs) that standard tools ignore. This talk, following the launch of the J**ulia Security Working Group**, shows how **Trivy** was adapted to scan the entire Julia dependency graph. We explore the implementation of this workflow within **JuliaHub** to provide automated security auditing and **SBOM generation** for any Julia project, ensuring safety for all. juliacon-2026-93447-securing-the-supply-chain-vulnerability-scanning-for-julia General /media/juliacon-2026/submissions/PAH3UZ/image_xSVQfrq.webp Mridul Ranjan UpadhyayVenkatesh Dayanand en 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. false https://pretalx.com/juliacon-2026/talk/PAH3UZ/ https://pretalx.com/juliacon-2026/talk/PAH3UZ/feedback/ Tent — RW1 Long talk 2026-08-14T10:30:00+02:00 10:30 00:30 When Julia was first introduced, its creators aimed to directly address the "two language" problem where coders were forced to switch between a programming language that is performant and one that can be easily understood. In this talk, we'll explore how they accidentally created the perfect language for the emerging "no language" problem where code is increasingly not being written by humans at all! juliacon-2026-91312-solving-the-no-language-problem-with-julia General /media/juliacon-2026/submissions/7BTWVN/image_dnyJH6e.webp Joshua Ballanco en 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. false https://pretalx.com/juliacon-2026/talk/7BTWVN/ https://pretalx.com/juliacon-2026/talk/7BTWVN/feedback/ Tent — RW1 Short talk 2026-08-14T11:15:00+02:00 11:15 00:15 We present an update on the synchronous programming capabilities in the Dyad modeling language. A synchronous program (discrete-time dynamical system), can now be implemented in a graphical block-diagram editor together with an acausal model of a continuous-time system, simulated, and code generated to a juliac/trim executable or C code. Under the hood, Dyad compiles to ModelingToolkit, which in turn lowers the synchronous program to the new domain-specific language SynchJulia.jl, which in turn generates C code or executable julia code compiled with JuliaC. juliacon-2026-92697-from-graphical-block-diagram-to-juliac-executable General /media/juliacon-2026/submissions/XXLRUE/image_zNkLnNr.webp Fredrik Bagge CarlsonTim BesardBenjamin ChungKiran Pamnany en false https://pretalx.com/juliacon-2026/talk/XXLRUE/ https://pretalx.com/juliacon-2026/talk/XXLRUE/feedback/ Tent — RW1 Long talk 2026-08-14T11:30:00+02:00 11:30 00:30 We want to show off the most exciting developments in Makie over the past year: a new GPU-enabled ray tracing system for beautiful renderings written entirely in Julia, the compute pipeline refactor that replaced Observables in many internals and fixed the age-old multiple updates conundrum, and the upcoming complex recipe system that could change how most users write plotting functions in Makie. juliacon-2026-93300-makie-jl-highlights-raytracing-compute-graphs-and-complex-recipes General /media/juliacon-2026/submissions/3NCWH3/image_Op9wjcM.webp Julius KrumbiegelSimon Danisch en 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. false https://pretalx.com/juliacon-2026/talk/3NCWH3/ https://pretalx.com/juliacon-2026/talk/3NCWH3/feedback/ Tent — RW1 Short talk 2026-08-14T12:00:00+02:00 12:00 00:15 DyadAgent is an AI coding assistant for generating and debugging Dyad code across modelling and simulation workflows, enabling engineers to express complex model requirements in natural language. Evaluating the performance of such an agent requires verification of generated simulation results against standards of physical correctness and numerical accuracy. DyadAgentBench is an evaluation infrastructure designed to measure the agent's modelling and simulation capabilities in a systematic and reproducible manner. In this talk, we present the infrastructure and evaluation framework developed for DyadAgent, covering how agent performance is assessed and how the resulting insights are used to benchmark and guide iterative improvements. juliacon-2026-92874-dyadagentbench-an-agent-evaluation-framework-for-dyad-agent General /media/juliacon-2026/submissions/RSTAHL/image_TfFE5JZ.webp Ashutosh Bharambe en 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. false https://pretalx.com/juliacon-2026/talk/RSTAHL/ https://pretalx.com/juliacon-2026/talk/RSTAHL/feedback/ Tent — RW1 Short talk 2026-08-14T12:15:00+02:00 12:15 00:15 We aim to illustrate the initialization features of Dyad by trimming the Nonlinear F-16 model dynamics using NLSQ for desired altitude and cruise speed. We will then use the analysis features of Dyad by designing an LQR for longitudinal stabilization under trim and demonstrate a dashboard that enables real time tuning and response behavior visualization. The plant model is written in Dyad, a new declarative acausal modeling language. The F-16 model encodes full six-degree-of-freedom rigid-body dynamics: translational and rotational equations of motion with coupled aerodynamic force and moment coefficients, ISA atmosphere density, and Euler angle kinematics. Dyad's `RealInput`/`RealOutput` connectors and `analysis_point` annotations expose the model's control and measurement interfaces for downstream analysis without modifying the physics.. Controller design uses DyadControlSystems' `LQGAnalysis`, which automatically linearizes the closed-loop Dyad model at the trim operating point and solves the dual Riccati equations. The 12-measurement, 5-control, 8-controlled-output problem yields a 12-state observer-based feedback controller. An interactive GLMakie GUI with a plugin architecture (Gang of Four, Nyquist, step response, pole-zero map) allows real-time tuning of LQR weights and Kalman filter covariances. A GLMakie animation engine renders the 3D trajectory alongside user-selected state and control variable time histories. The key contribution is demonstrating that Dyad's declarative syntax unifies what are traditionally separate modeling, analysis, and design stages into a single reproducible project. The same `.dyad` files that define the physics also declare the trim analysis, the LQG synthesis problem, and the simulation scenarios. Julia's composability: ModelingToolkit for symbolic-numeric transformations, DyadControlSystems for control theory and GLMakie for visualization eliminates the toolchain fragmentation typical of aerospace control workflows. juliacon-2026-92625-f16-trim-to-stabilize-workflow General /media/juliacon-2026/submissions/AXUZ9V/image_IlGgZ2K.webp Rajeev Voleti en false https://pretalx.com/juliacon-2026/talk/AXUZ9V/ https://pretalx.com/juliacon-2026/talk/AXUZ9V/feedback/ Tent — RW1 Long talk 2026-08-14T12:30:00+02:00 12:30 00:30 The rapid spread of AI into all aspects of society has led to a corresponding surge in data centers to support the exploding computing demand. Data centers are complex interconnected physical systems with thermal power generation, electrical power conversion, and cooling systems for the compute chips. The compute load that the data center can effectively deliver is a function of the complex response of these systems including the associated controls for the load dispatch strategy and cascaded controls of the various subsystems. System modeling with representation of the physical systems and key controls is a critical tool for understanding the physical response and operation of data centers. This talk presents two different uses cases for system modeling in data centers. The first case focuses on data center operation. High level transient models in Dyad, Julia, and ModelingToolkit of the data center load, power generation, and electrical system are shown focusing primarily on power demand and supply and high-level control and dispatch. These models are meant to capture the critical interactions between the total power demand from the compute side of the data center and the required power generation provided by the turbines and generators. Different operational strategies for turbine scheduling will be demonstrated to assess their impact on system performance and robustness over different load profiles. These models can address questions regarding the optimal dispatch strategy for the turbines and the impact of different load management strategies on system performance. Models including the effects of battery energy storage systems are developed to assess the impact of battery sizing and control strategies on the data center operation. The impacts of various failures can also be simulated with these models. These system models are suitable for simulations over multiple time scales. Shorter simulations are shown to focus on load planning and the resulting transient power dynamics. Long time horizon simulations (hours, weeks, months) support operational and economic optimization of data centers with SciML techniques. The second use case focuses on multi-physics models for data center cooling. Transient models for data center cooling are demonstrated that capture the thermal interactions between the CPU and GPU and the resulting cooling system. Built from reusable components in Dyad, these models are full physical models that capture the lumped thermal dynamics of the chips and cooling system at the server and rack level. They can provide temperature predictions at the lumped chip level to support a higher level of fidelity in the system simulations and for load planning. These models are still suitable for long time horizon simulations as they are lumped but discretized. juliacon-2026-92911-data-center-system-modeling-with-dyad General /media/juliacon-2026/submissions/BXSHUH/image_QysFAp1.webp John Batteh en false flyer-BXSHUH https://pretalx.com/juliacon-2026/talk/BXSHUH/ https://pretalx.com/juliacon-2026/talk/BXSHUH/feedback/ Tent — RW1 Long talk 2026-08-14T14:30:00+02:00 14:30 00:30 There has been a rapid spread of AI agents into all aspects of society. The exponential increase in capabilities of these agents has led to new ways of working across nearly every profession. While the adoption of LLMs and agentic workflows has been more common in computer science and software development, the integration of these technologies into engineering system simulation tools is at its infancy. As an engineer with over 25 years of experience in model-based systems engineering across different engineering domains, I have had no previous experience with agentic workflows in my daily work prior to the last few months. Speaking with engineering simulation colleagues in different fields, many of them are in the same situation given that their traditional tools did not offer these capabilities but are now ready and interested to explore possibilities of these emerging technologies. This talk will offer practical perspectives on agentic workflows focused on engineering system simulation use cases. Using the Dyad AI agent, these use cases will be explored using Dyad, Julia, and ModelingToolkit. The focus of this talk is to provide practical perspectives on agentic workflows in model creation, system model assembly, debugging, testing, and simulation and analysis. The examples will also explore different methods for providing resources to the agent to support the tasks required. Examples in different engineering domains will be presented. Various workflows are critically evaluated to assess effectiveness and accuracy. The focus of this talk is to provide practical perspectives demonstrating use cases that work well, those that are still developing or not yet mature (though certainly might be in future versions of the underlying LLMs), and effective prompting techniques based on personal experience. This talk will be presented via slides documenting the workflows along with live demonstrations within the time constraints of the talk. The capabilities of engineering simulation tools are rapidly changing and are fundamentally redefining the human and machine interface. Engineers need to quickly adapt to utilize new technologies effectively and responsibly. Though it is certainly impossible to gain a deep understanding of agentic workflows within the duration of a single talk, the hope is that this talk demystifies the use of agentic workflows in system simulation within the Julia ecosystem, inspires critical thinking within the context of an engineer’s unique workflows and simulation needs, and provides practical perspectives that can lead to more effective usage as engineers start to adopt these new technologies. juliacon-2026-92912-practical-perspectives-on-the-use-of-ai-agents-in-engineering-system-simulation General /media/juliacon-2026/submissions/VQWV7R/image_rowMizO.webp John Batteh en false https://pretalx.com/juliacon-2026/talk/VQWV7R/ https://pretalx.com/juliacon-2026/talk/VQWV7R/feedback/ Tent — RW1 Long talk 2026-08-14T15:00:00+02:00 15:00 00:30 Tracking active security advisories (like CVEs) is a critical requirement for many orgs to use and deploy code... but it can't work without the advisories themselves! The new SecurityAdvisories.jl database enables exactly that for Julia packages and their upstream artifacts (like JLLs). Building such a system in a manner that is both sustainable and manageable for thousands of packages is not trivial; I'll be discussing key factors in how it works and how package maintainers and users alike can make use of it. juliacon-2026-92796-the-julia-ecosystem-security-advisory-database General /media/juliacon-2026/submissions/9QTK9V/image_WknoL0y.webp Matt Bauman en 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 false https://pretalx.com/juliacon-2026/talk/9QTK9V/ https://pretalx.com/juliacon-2026/talk/9QTK9V/feedback/ Tent — RW1 Short talk 2026-08-14T15:45:00+02:00 15:45 00:15 In this talk we will introduce [`ParallelTestRunner.jl`](https://github.com/JuliaTesting/ParallelTestRunner.jl), a package for running in parallel the tests of Julia packages, using a very simple infrastructure, well integrated with Julia's `Test`'s standard library. We will showcase `ParallelTestRunner.jl`'s features, which include filtering of test files, and provide practical dos and don'ts when using this package. juliacon-2026-91832-running-tests-in-parallel-with-paralleltestrunner-jl General /media/juliacon-2026/submissions/DSWTZG/image_Smop86y.webp Mosè Giordano en 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. false https://pretalx.com/juliacon-2026/talk/DSWTZG/ https://pretalx.com/juliacon-2026/talk/DSWTZG/feedback/ Tent — RW1 Short talk 2026-08-14T16:00:00+02:00 16:00 00:15 This talk discusses our efforts to implement artificial intelligence (AI) workloads on a [**Ray**]([url](https://www.ray.io/#why-ray)) commodity cluster using the Julia programming language. Similar to Apache Spark, Ray is a cluster computing environment for data analytics and AI workloads, mainly in Python. First, we present the configurations and setup steps for a Ray cluster. Next, we discuss the implementation of three distributed clustering algorithms in Ray: **_partition-based_** (a variant of distributed KMeans), **_hierarchical_** (the PACk algorithm), and **_graph_** (filtered graphs with a distributed hierarchical bubble tree). Specifically, we emphasise the integration of Julia and Python within Ray. Finally, we contrast the Ray environment to Apache Spark and highlight the lessons learned (limitations and advantages) throughout this experiment. juliacon-2026-92671-implementing-ai-workloads-on-ray-in-julia General /media/juliacon-2026/submissions/VP8XK9/image_i883LxR.webp José Quenum en false https://pretalx.com/juliacon-2026/talk/VP8XK9/ https://pretalx.com/juliacon-2026/talk/VP8XK9/feedback/ Tent — RW1 Short talk 2026-08-14T16:15:00+02:00 16:15 00:15 Pluto is a fun-to-use teaching tool. But in order to allow for this seamless experience, it needs to be so much more! It's a **reactive execution engine**, that works over a **robust** remote websocket, **analyses** code, communicates **logs**, **status** and rich MIME **results**! Sounds familiar? This is more than what a notebook does. So why should we limit ourselves in the HTML world when, for example AI Agents can't really -natively- see? In this talk we present the VSCode Extension we made for Pluto, where we wrap Pluto's backend functionalities with a native VSCode Notebook UI. juliacon-2026-93315-the-making-of-advanced-pluto-vscode-extension General /media/juliacon-2026/submissions/QUVQMK/image_v6m9bwu.webp Panagiotis GeorgakopoulosDmitrij Rožděstvenský en 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 false Pluto · Advanced VSCode Extension https://pretalx.com/juliacon-2026/talk/QUVQMK/ https://pretalx.com/juliacon-2026/talk/QUVQMK/feedback/ Tent — RW1 Short talk 2026-08-14T16:30:00+02:00 16:30 00:15 The Julia standard testing experience can feel quite frustrating. No interface to run a specific test, difference of project environment, keeping the right context etc... [`TestPicker`](https://github.com/theogf/TestPicker.jl) provides a simple REPL mode to run any specific testfile or testset with the same conditions as `Pkg.test()` without introducing a new testing framework. It provides on top some nice bonuses like inspection of the results or quick reruns of the same tests. juliacon-2026-89367-testpicker-bringing-modernity-to-julia-testing-in-the-terminal General /media/juliacon-2026/submissions/PMRJ7G/image_crZrhXr.webp Théo Galy-Fajou en 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. false flyer-PMRJ7G https://pretalx.com/juliacon-2026/talk/PMRJ7G/ https://pretalx.com/juliacon-2026/talk/PMRJ7G/feedback/ Tent — RW1 Short talk 2026-08-14T16:45:00+02:00 16:45 00:15 Have you ever tried sharing Julia code that computes the Lorenz attractor using DifferentialEquations and visualises it in Makie? I haven't—because the TTFX is unbearable. Users often wait 5+ minutes for compilation during project instantiation, creating an unacceptable first-time experience. What if we could ship precompiled dependencies just like Julia's standard libraries? This is what Jumbo Julia does. In this talk, I'll explain how Julia distributions work and what's included in Jumbo Julia, including the tradeoffs imposed by package compatibility constraints that can force older versions. I'll demonstrate common workflows and project instantiations to illustrate both capabilities and limitations. Then I'll show you how to create custom distributions for your own package sets. I'll conclude by speculating on how Julia distributions could solve the PkgImage distribution problem in the short term within Pkg itself. juliacon-2026-92405-jumbo-julia-distribution General /media/juliacon-2026/submissions/XNCC8A/image_SRxuZmW.webp Janis Erdmanis en false https://pretalx.com/juliacon-2026/talk/XNCC8A/ https://pretalx.com/juliacon-2026/talk/XNCC8A/feedback/ Tent — RW1 Short talk 2026-08-14T17:00:00+02:00 17:00 00:15 Julia Gender Inclusive is an initiative dedicated to strengthening gender diversity and inclusion within the Julia community. We are a group of people whose gender is underrepresented in the community and aim to provide a supportive space for all gender minorities in the Julia community. Over the last year, we have worked toward increasing participation in our community by creating and organizing more virtual events, such as regular coffee meetings and hackathons. In this talk, we will share our recent outcomes, lessons learned, and concrete ways the broader Julia community can support and engage with our efforts. juliacon-2026-92461-julia-gender-inclusive-initiatives-to-create-a-more-welcoming-community General /media/juliacon-2026/submissions/3GSWV9/image_gscuZox.webp Julia Gender InclusiveLetícia MadureiraFiroozeh Dastur en 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. false https://pretalx.com/juliacon-2026/talk/3GSWV9/ https://pretalx.com/juliacon-2026/talk/3GSWV9/feedback/ Tent — RW1 Keynote 2026-08-14T17:30:00+02:00 17:30 01:00 It is time again to take a look at what new exciting things have happened with Julia; the language, the package ecosystem and the community. Join us as we explore these advancements and celebrate the progress of Julia in in the past year. juliacon-2026-93044-state-of-julia-keynote General /media/juliacon-2026/submissions/HQDK3J/image_8zzSZ3k.webp Jeff Bezanson en false https://pretalx.com/juliacon-2026/talk/HQDK3J/ https://pretalx.com/juliacon-2026/talk/HQDK3J/feedback/ Tent — RW1 Ceremony 2026-08-14T18:30:00+02:00 18:30 00:15 Thank you all for joining us in Mainz! Safe travels, and see you all next year! juliacon-2026-93047-closing-ceremony General /media/juliacon-2026/submissions/7VVKFA/image_5nxcQyo.webp en false https://pretalx.com/juliacon-2026/talk/7VVKFA/ https://pretalx.com/juliacon-2026/talk/7VVKFA/feedback/ Muschel — N1 Short talk 2026-08-14T10:00:00+02:00 10:00 00:15 The Dyad platform allows engineers to leverage the power of Julia and SciML via a graphical system modeling environment. The models created by engineers are translated into Julia and harness Julia's just-in-time compilation along with ModelingToolkit's symbolic manipulation capabilities to provide world class simulation performance. But what happens when you want to integrate these models into engineering workflows or wish to leverage the symbolic representations in different ways? In this talk, we'll describe Dyad analyses and how they provide a gateway to the expansive Julia ecosystem. juliacon-2026-92706-dyad-analyses-designing-engineering-workflows-with-julia Engineering with Julia /media/juliacon-2026/submissions/FLU7MM/image_rGnm1uE.webp Michael TillerSebastian Micluța-Câmpeanu en 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. false https://pretalx.com/juliacon-2026/talk/FLU7MM/ https://pretalx.com/juliacon-2026/talk/FLU7MM/feedback/ Muschel — N1 Short talk 2026-08-14T10:15:00+02:00 10:15 00:15 The Brazilian National Institute for Space Research (INPE) is developing Amazonia 1B, an Earth observation satellite with an enhanced-resolution camera for environmental monitoring. Although its bus is nearly identical to Amazonia 1, launched in 2021, the new payload requires a different orbit, demanding the redesign of several mission aspects. The mission design phase was conducted using the Julia ecosystem, with core algorithms encapsulated in the public packages [SatelliteToolbox.jl](https://github.com/JuliaSpace/SatelliteToolbox.jl) and [SatelliteAnalysis.jl](https://github.com/JuliaSpace/SatelliteAnalysis.jl). This presentation covers how Julia was leveraged for orbit selection, eclipse duration and beta angle computation, and ground station access and gap estimation. The results were incorporated into the Amazonia-1B Critical Design Review (CDR), which occurred in November 2025, and validated by the review board without issues, demonstrating the maturity and reliability of the Julia ecosystem for operational space mission design. juliacon-2026-92140-designing-the-amazonia-1b-space-mission-with-the-julia-ecosystem Engineering with Julia /media/juliacon-2026/submissions/E33UYZ/image_1K3AfBE.webp Ronan Arraes Jardim Chagas en 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. false flyer-E33UYZ https://pretalx.com/juliacon-2026/talk/E33UYZ/ https://pretalx.com/juliacon-2026/talk/E33UYZ/feedback/ Muschel — N1 Short talk 2026-08-14T10:30:00+02:00 10:30 00:15 This talks will demonstrate Julia in an embedding setting with Petoi Bittle robots. We show how to run a state estimation using adaptive kalman filter implemented with RxInfer.jl and communicate with Petoi Bittle Dog robot using PetoiBittle.jl, all of this autonomously on Raspberry PI. juliacon-2026-92454-embedding-julia-on-petoi-bittle-and-raspberry-pi Engineering with Julia /media/juliacon-2026/submissions/ZJ3D8Q/image_hkNNqmZ.webp Dmitry Bagaev en 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 false RxInfer official GitHub repository Petoi Bittle communication library RxInfer website Petoi robots website flyer-ZJ3D8Q https://pretalx.com/juliacon-2026/talk/ZJ3D8Q/ https://pretalx.com/juliacon-2026/talk/ZJ3D8Q/feedback/ Muschel — N1 Short talk 2026-08-14T10:45:00+02:00 10:45 00:15 Many modern manufacturing techniques rely heavily on lasers and more often than not, the behavior of heat in these systems plays a key role in determining whether a finished product is of acceptable quality. In this talk, I present how it's possible to construct a bespoke finite-element method solver for the heat equation, starting from first principles and building on the work of _Ferrite.jl_ and _DifferentialEquations.jl_. The solver is then validated against experimental results and I show how access to the inner workings facilitates the extension of the code base to tackle related problems such as computing surface hardness after laser processing. juliacon-2026-92898-developing-a-custom-fem-solver-for-the-heat-problem-in-the-laser-processing-of-metals Engineering with Julia /media/juliacon-2026/submissions/T79F7F/image_Z2NfHpC.webp Petru-Vlad TOMA en 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. false https://pretalx.com/juliacon-2026/talk/T79F7F/ https://pretalx.com/juliacon-2026/talk/T79F7F/feedback/ Muschel — N1 Short talk 2026-08-14T11:00:00+02:00 11:00 00:15 Computational Fluid Dynamics (CFD) has traditionally suffered from the "Two-Language Problem": researchers develop new physical models in high-level environments like Python or MATLAB, only to face an extensive rewrite in C++ or Fortran for production-scale runs. This "viscous" development cycle slows down innovation across the aerospace, automotive, and energy industries. In this talk, we present XCALibre.jl: a new Julia package designed to eliminate this friction. XCALibre.jl provides a "Laminar" workflow, allowing for rapid prototyping of complex Multiphysics, and a "Turbulent" runtime performance with native GPU acceleration. XCALibre.jl handles industry-relevant geometries and complex physical solvers, proving that in the Julia ecosystem, developer productivity and fast simulation runtime are not mutually exclusive. juliacon-2026-92907-laminar-workflow-turbulent-performance-xcalibre-jl-a-modern-cfd-framework-in-julia Engineering with Julia /media/juliacon-2026/submissions/PG9DLH/image_UJcQ8L2.webp HMedina en 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. false flyer-PG9DLH https://pretalx.com/juliacon-2026/talk/PG9DLH/ https://pretalx.com/juliacon-2026/talk/PG9DLH/feedback/ Muschel — N1 Short talk 2026-08-14T11:15:00+02:00 11:15 00:15 We present MLThermoProperties.jl, a Julia package that provides a variety of state-of-the-art thermodynamic models that combine modern machine learning methods with physical knowledge. These hybrid models obey hard physical constraints while being more accurate and applicable to a wider scope of substances than established models. MLThermoProperties.jl is built upon the Clapeyron.jl package, leveraging its rich thermodynamic solver ecosystem. The MLThermoProperties.jl models significantly improve molecular property prediction in various applications in science and engineering, e.g., chemical process engineering. Exemplary applications will be demonstrated in the talk by coupling MLThermoProperties.jl with Julia's rich ecosystem for scientific modelling and simulation. juliacon-2026-92676-mlthermoproperties-jl-hybrid-models-for-thermodynamic-property-prediction-in-julia Engineering with Julia /media/juliacon-2026/submissions/CHQSVY/image_Na5aBTd.webp Sebastian Schmitt en 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. false https://pretalx.com/juliacon-2026/talk/CHQSVY/ https://pretalx.com/juliacon-2026/talk/CHQSVY/feedback/ Muschel — N1 Short talk 2026-08-14T11:30:00+02:00 11:30 00:15 RailToolKit is an emerging ecosystem for open railway research. TrainRuns.jl is our showcase package for running time calculations. Today, railway studies often rely on siloed spreadsheets, proprietary tools, and non-reproducible workflows. We have built TrainRuns.jl as the first component. Now we are designing interfaces to enable data exchange and reproducible workflows across packages. Share your workflows and use cases to help shape this ecosystem! juliacon-2026-92071-railtoolkit-building-an-open-ecosystem-from-trainruns-jl Engineering with Julia /media/juliacon-2026/submissions/WYZSFH/image_2ffShCa.webp Martin ScheidtGregor Wehrle en false https://pretalx.com/juliacon-2026/talk/WYZSFH/ https://pretalx.com/juliacon-2026/talk/WYZSFH/feedback/ Muschel — N1 Short talk 2026-08-14T11:45:00+02:00 11:45 00:15 JuliaGNSS is an open-source software stack for processing Global Navigation Satellite System signals entirely in Julia. With all core packages now at version 1.0, the ecosystem has reached production readiness. This talk demonstrates real-time GNSS positioning by connecting JuliaGNSS to a Software Defined Radio, acquiring satellite signals, and computing position and time live. I show how Julia's performance and composability enable a complete GNSS receiver that rivals traditional C/C++ implementations. juliacon-2026-92710-real-time-gnss-positioning-with-juliagnss-from-sdr-signals-to-your-location Engineering with Julia /media/juliacon-2026/submissions/Z38XCK/image_ARL3oXy.webp Sören Schönbrod en 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. false flyer-Z38XCK https://pretalx.com/juliacon-2026/talk/Z38XCK/ https://pretalx.com/juliacon-2026/talk/Z38XCK/feedback/ Muschel — N1 Short talk 2026-08-14T12:00:00+02:00 12:00 00:15 It is estimated that by 2030 Germany will produce around 20 _TWh_ of green hydrogen per year, highlighting the need for suitable storage. One possible solution is storing the hydrogen in porous underground media. In this work we analyse the reliability of such a potential storage site. Reliability analyses typically require tens to hundreds of thousands of model evaluations for accurate results, especially when imprecise probabilities are involved due to limited data availability and input variables are modelled as intervals or probability boxes. The true model in this study has an associated runtime of around three days rendering a direct reliability analysis virtually impossible. We use Julia to train an accurate surrogate model on which we are then able to perform our analyses. Propagating the imprecise input quantities through the surrogate model we obtain bounds on the probability of failure of the system. All algorithms used in this study are implemented in the _UncertaintyQuantification_ package. juliacon-2026-92896-reliability-analysis-of-underground-hydrogen-storage-under-limited-data Engineering with Julia /media/juliacon-2026/submissions/YWMTMA/image_gzrCWaJ.webp Jasper BehrensdorfGergely Schmidt en false https://pretalx.com/juliacon-2026/talk/YWMTMA/ https://pretalx.com/juliacon-2026/talk/YWMTMA/feedback/ Muschel — N1 Short talk 2026-08-14T12:15:00+02:00 12:15 00:15 The talk details how Julia is used for the simulation and modelling of PHASA-35, an unmanned persistent stratospheric solar-powered aircraft developed by Prismatic Ltd, a subsidiary of BAE Systems plc. PHASA-35 can stay airborne year-round to provide communications services, wildfire detection, or ISR. Julia is used both in standalone simulation tools as well as in FMUs, which are built using JuliaC to perform system-level Software-in-the-Loop simulations. juliacon-2026-92578-simulation-and-modelling-of-persistent-high-altitude-solar-aircraft-with-julia Engineering with Julia /media/juliacon-2026/submissions/QZGFZP/image_KIXW6ZK.webp Nathanael West en 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. false flyer-QZGFZP https://pretalx.com/juliacon-2026/talk/QZGFZP/ https://pretalx.com/juliacon-2026/talk/QZGFZP/feedback/ Muschel — N1 Short talk 2026-08-14T12:30:00+02:00 12:30 00:15 A common task in solid mechanics is to select and calibrate a constitutive model for a specific material. Constitutive model discovery seeks to automate this task. The framework statFEM-EUCLID.jl provides an unsupervised approach for constitutive model discovery from sparse and noisy measurements and global reaction forces. Using UMBridge.jl, the framework treats the finite element solution as a black box, such that any finite element solver can, in principle, be linked to it. juliacon-2026-92902-statfem-euclid-jl-data-assimilation-and-constitutive-model-discovery Engineering with Julia /media/juliacon-2026/submissions/7YNPXC/image_kV2j2P0.webp Jan Philipp Thiele en 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. false flyer-7YNPXC https://pretalx.com/juliacon-2026/talk/7YNPXC/ https://pretalx.com/juliacon-2026/talk/7YNPXC/feedback/ Muschel — N1 Short talk 2026-08-14T12:45:00+02:00 12:45 00:15 A triangular shell finite element formulation is implemented in for use with the popular open-source finite element software package Ferrite.jl. Both elastic and geometric stiffness matrices are available, allowing for the calculation of elastic deformations, stresses, and buckling in thin-walled structures. The shell element formulation utilizes linear shape functions to interpolate for membrane deformations, and considers additional quadratic shape functions to predict bending deformation while avoiding shear locking. The triangular shell element is shown to perform accurately when compared to Abaqus shell element and analytical solutions in a series of thin and thick plate examples which consider elastic deformation and elastic buckling. juliacon-2026-93201-trishellfiniteelement-jl-a-mindlin-triangular-shell-finite-element-formulation-for-use-with-ferrite-jl Engineering with Julia /media/juliacon-2026/submissions/XD88T7/image_9EpfaB5.webp Cris Moen en false https://pretalx.com/juliacon-2026/talk/XD88T7/ https://pretalx.com/juliacon-2026/talk/XD88T7/feedback/ Muschel — N1 Short talk 2026-08-14T14:45:00+02:00 14:45 00:15 juTarget is a browser based Linux application for M. tuberculosis tNGS data analysis that applies a hybrid ML method for predicting drug resistance. Industry standard toolkit has been used to identify the variants compared against the WHO catalogue. Furthermore, the resistance profile for novel variants is predicted by Random Forest using a feature set of 30 biophysical properties of amino acids. Molecular Drug Susceptibility Report is generated which can be used as a clinical decision-making tool. juliacon-2026-92729-jutarget-a-julia-powered-pipeline-built-with-a-hybrid-machine-learning-method-for-m-tuberculosis-drug-resistance-prediction General /media/juliacon-2026/submissions/CCVYAA/image_dHeXfzi.webp Dr Benedict Christopher Paul en **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. false juTarget_Demo flyer-CCVYAA juTarget_ViewResults_WHO juTarget_ViewResults_AI https://pretalx.com/juliacon-2026/talk/CCVYAA/ https://pretalx.com/juliacon-2026/talk/CCVYAA/feedback/ Muschel — N1 Short talk 2026-08-14T15:00:00+02:00 15:00 00:15 MEDYAN.jl is a framework for modeling the cytoskeletal filaments and associated proteins that shape and move cells. New declarative rules for dynamic mechanical and chemical bonds, accelerated by new spatial data structures, enable simulations as large as a whole T-cell or as detailed as the individual reactions in a motor protein step. These improvements help bridge the gap between single molecules and cell behavior on timescales of minutes and length scales of micrometers. juliacon-2026-93034-what-s-new-with-medyan-jl-a-coarse-grained-cytoskeleton-simulator General /media/juliacon-2026/submissions/KGR8N9/image_fjtDBJU.webp Nathan Zimmerberg en 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. false flyer-KGR8N9 https://pretalx.com/juliacon-2026/talk/KGR8N9/ https://pretalx.com/juliacon-2026/talk/KGR8N9/feedback/ Muschel — N1 Short talk 2026-08-14T15:15:00+02:00 15:15 00:15 Coulomb Explosion Imaging is a booming method to image small molecules. Its principle is relatively straightforward: remove as many electrons as possible as fast as possible from a molecule to induce its explosion into atomic fragments. Simulating this process is crucial to interpret the experimental data. In this talk I will briefly describe the concept of an x-ray induced Coulomb explosion, introduce a semi-classical model to simulate it and present how I implemented it. juliacon-2026-92082-building-a-coulomb-explosion-simulation-on-top-of-differentialequations-jl General /media/juliacon-2026/submissions/GJRCSK/image_pRYG9k2.webp Benoît Richard en 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. false https://pretalx.com/juliacon-2026/talk/GJRCSK/ https://pretalx.com/juliacon-2026/talk/GJRCSK/feedback/ Muschel — N1 Short talk 2026-08-14T15:45:00+02:00 15:45 00:15 A precise material deposition is nowadays a key component of any microchip production. A prominent deposition technique offering the required level of control is area-selective atomic layer deposition. To improve this technique the chemical reactions of the adsorbates at the substrate surface are modeled. Here, the presented random sequential adsorption approach targets to model the adsorption and packing of the first adsorbate layer. Implementation of the key assumptions as well as first results are part of this contribution. juliacon-2026-92879-randomsequentialadsorption-jl-modeling-adsorbate-packing-in-area-selective-atomic-layer-deposition General /media/juliacon-2026/submissions/FDVTJJ/image_Un8pbsC.webp Fabian Pieck en ## 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. false https://pretalx.com/juliacon-2026/talk/FDVTJJ/ https://pretalx.com/juliacon-2026/talk/FDVTJJ/feedback/ Muschel — N1 Long talk 2026-08-14T16:00:00+02:00 16:00 00:30 **BeamletOptics.jl** (BMO) is a Gaussian beamlet tracing package built on top of a geometrical ray tracing solver. It can be used to prototype laboratory optical setups featuring laser sources. BMO features a signed distance function (SDF) based geometry representation which allows for the accurate modeling of surface normals. It offers a variety of optical models for common components, like mirrors, lenses, beamsplitters and detectors. In addition, the API allows for the easy implementation of custom optical elements. This talk will focus on the current state of the package, feature several showcases and outline future development goals. juliacon-2026-88736-modeling-optical-setups-with-beamletoptics-jl General /media/juliacon-2026/submissions/KXDFUJ/mi_intro_fig_3s9ZCeM__dxGrTxd.webp Hugo Uittenbosch en 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. false flyer-KXDFUJ https://pretalx.com/juliacon-2026/talk/KXDFUJ/ https://pretalx.com/juliacon-2026/talk/KXDFUJ/feedback/ Muschel — N1 Short talk 2026-08-14T16:30:00+02:00 16:30 00:15 Pfaffian point processes (PfPPs) most famously arise in the eigenvalue distributions of random orthogonal or symplectic matrices, but also appear in the description of other stochastic processes, such as annihilating and coalescing random walks, random involutions, or symmetric corner growth. We introduce novel sampling algorithms for discrete and continuous PfPPs, as well as a method for constructing skew-symmetric kernels based on skew-orthogonal polynomials derived from arbitrary weights. juliacon-2026-93440-modelling-repulsion-beyond-determinants-sampling-pfaffian-point-processes General /media/juliacon-2026/submissions/HYQWVR/image_XhOYqfq.webp Simeon Schaub en 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. false https://pretalx.com/juliacon-2026/talk/HYQWVR/ https://pretalx.com/juliacon-2026/talk/HYQWVR/feedback/ Muschel — N1 Long talk 2026-08-14T16:45:00+02:00 16:45 00:30 Neuroblox.jl is designed for computational neuroscience, pharmaceutical, and psychiatric applications. Our tools range from control circuit system identification to brain circuit simulations bridging scales from spiking neurons to fMRI-derived circuits, parameter-fitting models to neuroimaging data, interactions between the brain and other physiological systems, experimental optimization, and scientific machine learning. In this talk we will give an update on the new features we added in the last year, including a new DSL for interacting with Neuroblox, a rich library of pharmacologically relevant receptors, and new GUI features. We'll also discuss our progress on running Neuroblox on various accelerators, and algorithmic improvements we've made to our solving infrastructure. juliacon-2026-92871-neuroblox-jl-new-features-and-applications General /media/juliacon-2026/submissions/7PQKQJ/image_DJyqsDw.webp Mason Protter en false flyer-7PQKQJ https://pretalx.com/juliacon-2026/talk/7PQKQJ/ https://pretalx.com/juliacon-2026/talk/7PQKQJ/feedback/ Muschel — N2 Short talk 2026-08-14T10:00:00+02:00 10:00 00:15 Building and understanding complex models is easier when you can see them come to life. At JuliaHub, we have been creating interactive dashboards that show simulation results, allow live, interactive analysis, and some which even show real world data, for quite some time now. In this talk, I will go through some of the paradigms we've developed and how those have played out, as well as showing some cool examples for inspiration. juliacon-2026-93745-visualizations-for-modeling-and-simulation-with-makie General /media/juliacon-2026/submissions/N7TFF3/image_KJvLtMr.webp Anshul Singhvi en 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. false https://pretalx.com/juliacon-2026/talk/N7TFF3/ https://pretalx.com/juliacon-2026/talk/N7TFF3/feedback/ Muschel — N2 Short talk 2026-08-14T10:15:00+02:00 10:15 00:15 Our paper develops a nonlinear bi-objective optimization model to analyze cost-emission trade-offs in maritime fleet operations. The model minimizes total fleet cost and total fleet emissions through interactions between fuel share choices, digitization adoption, regulatory frameworks, and operational decisions. We implement the model using the Julia program- ming language with the JuMP modeling framework, employing the ε-constraint method to generate a discrete approximation of the Pareto frontier. Results demonstrate that cost- effective maritime decarbonization emerges from coordinated fuel transition, universal adop- tion of digitization technologies, and regulatory-driven fleet reallocation, rather than from isolated interventions. Sensitivity analysis across different digitization adoption modes re- veals that unconstrained digitization serves as a low-cost enabler of emissions reduction. juliacon-2026-89648-modelling-cost-sustainability-trade-offs-in-maritime-logistics-eedi-driven-multi-objective-optimization General /media/juliacon-2026/submissions/NAPBCA/image_1o7hNEK.webp Jia Bhanushali en 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. false https://pretalx.com/juliacon-2026/talk/NAPBCA/ https://pretalx.com/juliacon-2026/talk/NAPBCA/feedback/ Muschel — N2 Short talk 2026-08-14T10:30:00+02:00 10:30 00:15 This talk is about [`RadioClock.jl`](https://github.com/giordano/RadioClock.jl), a Julia package to encode and decode time signals such as the [DCF77](https://en.wikipedia.org/wiki/DCF77). juliacon-2026-88670-decoding-radio-time-signals-with-radioclock-jl General /media/juliacon-2026/submissions/HMEGDF/image_UAfFXXu.webp Mosè Giordano en 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, false https://pretalx.com/juliacon-2026/talk/HMEGDF/ https://pretalx.com/juliacon-2026/talk/HMEGDF/feedback/ Muschel — N2 Short talk 2026-08-14T10:45:00+02:00 10:45 00:15 Formal linear combinations are ubiquitous in Mathematics. The package [LinearCombinations.jl](https://github.com/matthias314/LinearCombinations.jl) provides an easy and efficient way to deal with them, as well as with linear and multilinear maps. juliacon-2026-93065-formal-linear-combinations-in-julia-with-linearcombinations-jl General /media/juliacon-2026/submissions/DPR3VJ/image_PMZvMQT.webp Matthias Franz en 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. false GitHub repository Documentation https://pretalx.com/juliacon-2026/talk/DPR3VJ/ https://pretalx.com/juliacon-2026/talk/DPR3VJ/feedback/ Muschel — N2 Long talk 2026-08-14T11:15:00+02:00 11:15 00:30 Technical systems become increasingly complex, optimizing their processes by adapting to external conditions. Such self-adaptive systems (SAS) need software that dynamically adapts its behavior. Context-Oriented and Role-Oriented Programming simplify defining dynamic behavior. Hence, implementing these concepts in Julia is beneficial for SAS development. The library Contexts.jl provides infrastructure for using these paradigms in Julia. This talk introduces its structure and key features. juliacon-2026-92635-introducing-contexts-jl-context-and-role-oriented-programming-for-self-adaptive-systems General /media/juliacon-2026/submissions/HYN7DE/image_tYivuCq.webp Christian Gutsche en 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. false https://pretalx.com/juliacon-2026/talk/HYN7DE/ https://pretalx.com/juliacon-2026/talk/HYN7DE/feedback/ Muschel — N2 Short talk 2026-08-14T11:45:00+02:00 11:45 00:15 Reasoning with temporal and spatial data is crucial in many real-world applications; however, this data is often characterized by uncertainty and unclear boundaries. In this talk, we will see how we can extend spatial and temporal modal logics offered by SOLE through a new submodule, namely ManyValuedLogics, offering support for fuzzy and many-valued logics. Moreover, we will explore a new package called SoleReasoners.jl, offering a reasoning tool for many-valued spatial and temporal logics. juliacon-2026-92452-reasoning-with-many-valued-spatial-and-temporal-logics-with-sole General /media/juliacon-2026/submissions/XT7QD8/image_PWbLlty.webp Alberto Paparella en 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. false https://pretalx.com/juliacon-2026/talk/XT7QD8/ https://pretalx.com/juliacon-2026/talk/XT7QD8/feedback/ Muschel — N2 Short talk 2026-08-14T12:00:00+02:00 12:00 00:15 Using the _Functional Mock-Up Interface_ (FMI), we can handle and exchange big simulation models. It seems only logical to integrate this standard into our favorite programming language. Our open-source journey of _FMI.jl_ started almost exactly 5 years ago with this goal in mind: Blur the boundaries between Julia and FMI. In this talk, we want to give a broad overview over what is possible with FMUs in Julia today – with live programs that fit a single slide each. juliacon-2026-93445-big-simulation-models-suddenly-feel-very-small-with-fmi-jl General /media/juliacon-2026/submissions/F8L7TA/image_WP5wyqI.webp Tobias Thummerer en 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. false flyer-F8L7TA https://pretalx.com/juliacon-2026/talk/F8L7TA/ https://pretalx.com/juliacon-2026/talk/F8L7TA/feedback/ Muschel — N2 Short talk 2026-08-14T12:15:00+02:00 12:15 00:15 Structured Illumination Microscopy is a method in which a fluorescent sample is illuminated with a number of patterns containing high spatial frequencies. This encodes super-resolution information into the classical light microscopy image which is the successively recovered by Fourier-space based reconstruction methods. This talk will introduce into the topic and then highlight some of the concepts behind `StructuredIlluminationMicroscopy.jl`, which supports some of the fastest algorithms for reconstructing images measured by structured illumination. The package features Fourier-space reconstruction approaches including upsampling, reconstruction and noise-reduction steps. It exploits `rFFT`s and `SeparableFunctions.jl`, wherever possible, minimizes the memory footprint by working on pre-allocated arrays and fully supports GPU acceleration via `CUDA.jl`. juliacon-2026-89346-structuredilluminationmicroscopy-jl General /media/juliacon-2026/submissions/7AEJTQ/image_NF9i8hL.webp Rainer Heintzmann en false https://pretalx.com/juliacon-2026/talk/7AEJTQ/ https://pretalx.com/juliacon-2026/talk/7AEJTQ/feedback/ Muschel — N2 Short talk 2026-08-14T12:45:00+02:00 12:45 00:15 With this talk, `GoMeta` will be released. This package finally implements a vastly matured offspring of a [my] half-baked idea proposed at *JuliaCon2025*. The core concept remains the same: Add interpretable meaning to comments within a Julia file by means of brief, simple, expressive and extendable metadata. The crux of the idea lies in its potential to serve a wider variety of different packages and even facilitating interactions between them. However, in order to truly fulfill what had been promised, in particular to allow for the desired expressiveness and extensibility, language-like features had to be incorporated in the proposed schema. Moreover, metadata needs to be absorbed, i.e.: parsed and interpreted, from *somewhere* before it can be applied *somewhere*. Thus far, both tasks had been executed on a `Block`-level [a section of consecutive lines]. `BLS` now provides a distinctly finer granularity by introducing `Component`s such as `Block`, `Line` and `Segment`. This not only necessitated a complete overhaul of `GoMeta`'s implementation but also of the grammar being used. juliacon-2026-92542-this-is-a-metaline-announcing-the-release-of-gometa General /media/juliacon-2026/submissions/XYMFMZ/image_nkxb5vn.webp Jerae Sieburgh en 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. false Source Code https://pretalx.com/juliacon-2026/talk/XYMFMZ/ https://pretalx.com/juliacon-2026/talk/XYMFMZ/feedback/ Muschel — N2 Short talk 2026-08-14T16:00:00+02:00 16:00 00:15 We implemented a Rust-based virtual machine that accepts and executes a subset of Julia syntax. This enables Julia code to run in environments where the official runtime is difficult to deploy. By compiling the VM to WebAssembly, Julia can run web apps for educational purposes, and static linking with Swift or Flutter allows mobile applications. This short talk demonstrates these capabilities through live demos. juliacon-2026-92629-let-s-run-julia-everywhere-from-mobile-to-web General /media/juliacon-2026/submissions/TXMEAT/image_uLoAjwS.webp terasakisatoshi en 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. false flyer-TXMEAT https://pretalx.com/juliacon-2026/talk/TXMEAT/ https://pretalx.com/juliacon-2026/talk/TXMEAT/feedback/ Muschel — N2 Short talk 2026-08-14T16:15:00+02:00 16:15 00:15 Julia supports defining new integer types. However, they are currently limited to byte size. Until this restriction is lifted, we can emulate arbitrary bit-sized integers with larger byte-sized ones which should behave identical to future native bit-sized integers. This is what EmulatedBitIntegers.jl does as a generalization of BitIntegers.jl to non-byte-sized integers. This emulation produces unused bits. Often, structs can be used to combine such types with other emulated integers, making use of the unused bits of one emulated integer to store the content of another emulated integer. This is done with PackedStructs.jl which allows annotating structs to have their fields packed on bit-level to not waste a single bit, because: Every Bit Counts! juliacon-2026-92824-every-bit-counts General /media/juliacon-2026/submissions/L7CKA7/image_HTzIEXf.webp Patrick Häcker en false https://pretalx.com/juliacon-2026/talk/L7CKA7/ https://pretalx.com/juliacon-2026/talk/L7CKA7/feedback/ Muschel — N2 Long talk 2026-08-14T16:45:00+02:00 16:45 00:30 Information about the sensitivity (the derivative) of a function is of great use in, among many other things, non-linear optimization and root-finding algorithms. In particular, second-order derivative information (curvature) can be used to accelerate such solvers, for example, the Newton method for optimization and [Halley's method](https://en.wikipedia.org/wiki/Halley%27s_method) for root finding. *Automatic Differentiation* (AD), where these sensitivities are effectively available "for free" (in terms of developer time investment), is therefore attractive since it can significantly reduce the time of an implementation. In addition, the performance cost of the AD may either be close to a hand-optimized implementation or not be significant compared to other parts of the full problem, making AD attractive even from a performance standpoint. In Julia, there are many packages for AD, each with different trade-offs. They might use forward mode AD or reverse mode AD, they might be implemented using operator overloading or by using code inspection, or they might focus on a certain application like machine learning, etc. HyperHessians.jl is a Julia package for forward mode AD that specializes in taking second-order derivatives (Hessians). It does this by using [*HyperDual* numbers](https://www.mdpi.com/2227-7390/13/24/3909), which is an extension of [Dual numbers](https://en.wikipedia.org/wiki/Dual_number). By adopting hyperdual numbers, we can show performance gains over traditional nested dual numbers for second-order derivatives, which is employed by, e.g., ForwardDiff.jl. In addition, HyperHessians.jl supports computing Hessian-vector products (Hvp) and quadratic forms (v'Hvp) at a much lower cost than computing the full Hessian, which is not available with straightforward usage of ForwardDiff. In this presentation, I will go through some of the theory behind hyperdual numbers, how this theory is implemented in the HyperHessians.jl package, some of the implementation considerations, and present some benchmarks (both micro and real-world benchmarks) that show HyperHessians.jl has value as yet another AD package in the Julia AD ecosystem. juliacon-2026-93268-hyperhessians-jl-forward-mode-ad-specialized-for-second-order-derivatives General /media/juliacon-2026/submissions/URPF3H/image_7IoZ3VT.webp Kristoffer Carlsson en false https://pretalx.com/juliacon-2026/talk/URPF3H/ https://pretalx.com/juliacon-2026/talk/URPF3H/feedback/ Muschel — N3 Short talk 2026-08-14T10:00:00+02:00 10:00 00:15 We report on recent progress in the numerical optimisation of quantum control systems using [OptimalControl.jl](https://github.com/control-toolbox/OptimalControl.jl). Although the package is designed to optimise general control systems governed by ordinary differential equations, it naturally accommodates quantum problems described by finite-dimensional Schrödinger equations evolving on Lie groups — specifically, bilinear dynamical systems whose state trajectories lie on unitary groups and are expressed compactly in terms of tensor products of complex matrices. A well-established Julia ecosystem for quantum optimal control already exists, with packages such as `QuantumControl.jl`, `Krotov.jl`, and `GRAPE.jl` providing mature, quantum-tailored implementations of the GRAPE and Krotov algorithms. These methods are effective for a broad class of problems and can accommodate extensions such as free final time or path constraints on controls and states, typically via penalisation of the cost functional. However, penalisation-based approaches offer no rigorous guarantee of constraint satisfaction and can introduce significant ill-conditioning. Our motivation is complementary: to leverage state-of-the-art nonlinear programming solvers that treat such constraints directly, as genuine algebraic equalities and inequalities arising from the transcription of the continuous-time optimal control problem — including additional optimisation variables such as free final time or parameters of the system. `OptimalControl.jl` offers a high-level, expressive modelling interface that allows users to specify dynamics, objectives, and constraints in a form close to mathematical notation, with no compromise on performance. Problems are transcribed via direct methods into large-scale sparse nonlinear programmes, which are solved using interior-point methods on both CPU and GPU, exploiting automatic differentiation through `ExaModels.jl` and `MadNLP.jl`. Crucially, the framework also supports the combination of direct and indirect methods: direct transcription is used first to identify the qualitative structure of the optimal solution, after which indirect shooting methods — based on the Pontryagin Maximum Principle — can be applied to refine the solution to arbitrary numerical precision. We present preliminary results on the optimisation of small quantum systems modelling nitrogen-vacancy (NV) centres in diamond. These systems, comprising an electron spin coupled to one or more nuclear spins via hyperfine interaction, are naturally described with bilinear dynamics driven by bounded microwave controls. The combination of hard amplitude constraints, partial controllability (nuclear spins are driven only indirectly through the electron spin), and the need for various costs functionals for gate synthesis makes NV centres a compelling benchmark for our approach. We discuss the formulation of these problems within `OptimalControl.jl`, and compare the results and computational performance against existing quantum-specific methods. juliacon-2026-92878-optimising-quantum-control-systems-application-to-nv-centres Quantum Mini /media/juliacon-2026/submissions/H9MULV/image_5rHV6li.webp Jean-Baptiste CaillauDavid Tinoco en 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. false Tinoco, D.; Babin, C.; Beschastnyi, I.; Caillau, J.-B.; Sugny, D. Control of an NV center as a two-qubit system (2026). HAL preprint no. 05404999 flyer-H9MULV https://pretalx.com/juliacon-2026/talk/H9MULV/ https://pretalx.com/juliacon-2026/talk/H9MULV/feedback/ Muschel — N3 Short talk 2026-08-14T10:15:00+02:00 10:15 00:15 I will present PauliStrings.jl, a package for quantum many-body simulations, which performs fast operations on the Pauli group by encoding Pauli strings in binary. When combined with various truncation methods, this representation provides performance advantages for solving certain kinds of problems. PauliStrings.jl also allows for symbolic calculations, is a natural platform to take advantage of symmetries and is a fun and pedagogical tool to visualize quantum algebra. juliacon-2026-92937-quantum-many-body-simulations-with-paulistrings-jl Quantum Mini /media/juliacon-2026/submissions/7PP38R/image_BvRVfS5.webp Nicolas Loizeau en PauliStrings.jl provides a competitive platform for studying quantum many-body dynamics by representing operators as sets of Pauli strings encoded in binary. We 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. false flyer-7PP38R https://pretalx.com/juliacon-2026/talk/7PP38R/ https://pretalx.com/juliacon-2026/talk/7PP38R/feedback/ Muschel — N3 Long talk 2026-08-14T10:30:00+02:00 10:30 00:30 The name means small, so we made it smaller. Piccolo.jl 1.0 consolidates five quantum optimal control packages into one -- one language, one package, just `using Piccolo`. A unified Julia codebase that AI coding agents can thrive in -- accelerating feature development, performance work, and letting users go from system parameters to optimized pulses naturally. We demonstrate real-world impact through robust control theory (arXiv:2602.10349) and experimental studies of universal dynamics in Rydberg arrays (arXiv:2508.19075). juliacon-2026-93479-piccolo-jl-1-x-a-unified-agent-enabled-quantum-control-package Quantum Mini /media/juliacon-2026/submissions/NHJH7G/image_inrJ0aZ.webp Aaron Trowbridge en [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/) false https://pretalx.com/juliacon-2026/talk/NHJH7G/ https://pretalx.com/juliacon-2026/talk/NHJH7G/feedback/ Muschel — N3 Long talk 2026-08-14T11:15:00+02:00 11:15 00:30 We introduce `qruise-toolset`, a differentiable quantum simulation toolbox with a Python interface and a Julia simulation backend. The toolbox enables researchers and companies to build faithful digital twin models of their hardware for fast calibration and prototyping via closed-loop quantum optimal control strategies at the pulse level. Moreover, the realistic behaviour of the control stack and the pulse delivery via the signal chain is an indispensable part of the toolbox, allowing the user to explore the limitations of the control stack components. juliacon-2026-92557-qruise-toolset-differentiable-quantum-simulation-toolbox Quantum Mini /media/juliacon-2026/submissions/MJP9RJ/image_3wwnJHY.webp Yousof Mardoukhi en `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. false https://pretalx.com/juliacon-2026/talk/MJP9RJ/ https://pretalx.com/juliacon-2026/talk/MJP9RJ/feedback/ Muschel — N3 Long talk 2026-08-14T11:45:00+02:00 11:45 00:30 We investigate the problem of partitioning graph states for distributed quantum computing. Graph states are a way of representing certain quantum entangled states as graphs. Due to the nature of entanglement, it's far better to partition graphs to minimize the size of the maximum matchings between partitions rather than the number of edges, as traditional algorithms do. We provide an algorithm for this in our Julia software package for graph state partitioning evaluation, QuantumHamlets.jl. juliacon-2026-92868-quantum-hamlets-distributed-compilation-of-large-algorithmic-graph-states Quantum Mini /media/juliacon-2026/submissions/M3HL7P/image_l5S43Dt.webp Anthony Micciche en 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. false https://pretalx.com/juliacon-2026/talk/M3HL7P/ https://pretalx.com/juliacon-2026/talk/M3HL7P/feedback/ Muschel — N3 Short talk 2026-08-14T12:15:00+02:00 12:15 00:15 We introduce multivariate multicycle (MM) codes, a new family of quantum error correcting (QEC) codes that unifies and generalizes many of the established families of QEC codes and possess record-breaking capabilities by measure of confinement for single-shot decoding. Our work is enabled by Open Source Computer Algebra Research (OSCAR.jl) which provides capabilities for computations in commutative and homological algebra and QuantumClifford.jl, an open source package for stabilizer tableaux algebra which provides tools for working with graph states and vast array of error correction codes and capabilities. juliacon-2026-92121-multivariate-multicycle-codes-for-complete-single-shot-decoding Quantum Mini /media/juliacon-2026/submissions/F3RNYU/image_9SppyGD.webp Feroz Ahmed Mian en 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. false https://pretalx.com/juliacon-2026/talk/F3RNYU/ https://pretalx.com/juliacon-2026/talk/F3RNYU/feedback/ Muschel — N3 Short talk 2026-08-14T12:30:00+02:00 12:30 00:15 The explosion in the number of submitted quantum physics papers is placing the scientific publication system under extreme stress. In an effort to address this challenge, I have been experimenting with end-to-end pipelines for the automated numerical verification of claims in quantum physics papers. Given an arXiv preprint, LLM coding agents extract mathematical assertions into a structured knowledge graph, then generate Julia code to numerically check each claim. I will demonstrate this pipeline across three domains: topologically ordered many-body quantum systems (using, e.g., TensorCategories.jl), quantum information theory, and quantum optics (using QuantumOptics.jl). In practice, this system routinely catches small sign errors and gaps in every paper I have studied. LLM coding agents enable automation of workflows that previously would have involved much yak shaving and frustration. As a consequence, time-poor persons with little software engineering expertise (such as myself!) can now employ the amazing cutting-edge tools the Julia community have developed. I will directly address practical challenges including LLM hallucinations in mathematical reasoning, ensuring correctness of generated code, and the gap between symbolic assertions and finite-dimensional numerics. juliacon-2026-92817-automated-numerical-verification-of-quantum-physics-papers-using-julia-and-llm-agents Quantum Mini /media/juliacon-2026/submissions/RN8YTY/image_TVxUGBP.webp Tobias J. Osborne en false https://pretalx.com/juliacon-2026/talk/RN8YTY/ https://pretalx.com/juliacon-2026/talk/RN8YTY/feedback/ Muschel — N3 Short talk 2026-08-14T12:45:00+02:00 12:45 00:15 Quantum computing, communication, and sensing technologies rely on precise knowledge of quantum states. Quantum states cannot be directly measured. Quantum state tomography (QST) reconstructs these states from indirect measurements, similar to how CT imaging combines multiple 2D projections into a 3D model. In QST, the goal is to minimize the statistical discrepancy between experimentally observed data and predictions from quantum theory. This optimization problem is nonlinear and subject to physical constraints on the states. We present a Julia implementation that efficiently and robustly minimizes this statistical distance while enforcing these constraints. Our work provides a practical, extensible toolkit for QST and a comparative guide to choosing optimizer based on accuracy, speed, and robustness. juliacon-2026-92924-fast-and-reliable-quantum-state-tomography-in-julia Quantum Mini /media/juliacon-2026/submissions/JA8JFE/image_DPHzEeS.webp Fabian Müller en 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. false https://pretalx.com/juliacon-2026/talk/JA8JFE/ https://pretalx.com/juliacon-2026/talk/JA8JFE/feedback/ Muschel — N3 Short talk 2026-08-14T14:30:00+02:00 14:30 00:15 Infectious disease models that integrate multiple data sources provide better evidence for outbreak response than chains of separate models, but building them is slow and requires expertise across domains. Composable modelling, where validated components combine into joint models that properly propagate uncertainty, addresses this but requires an ecosystem of reusable infectious disease model components. We believe Julia is the best language for this ecosystem due to its type system, multiple dispatch, automatic differentiation support, and existing scientific computing infrastructure ([SciML](https://sciml.ai), [Turing.jl](https://turinglang.org), [Distributions.jl](https://github.com/JuliaStats/Distributions.jl)), which provide the foundations composable modelling needs. In this talk, we present the [EpiAware](https://github.com/EpiAware) roadmap for creating and sustaining that ecosystem, our current progress, and our questions for the Julia community. In R, we have built the [epinowcast](https://github.com/epinowcast) ecosystem (packages, community forum, seminar series) and developed several other widely used packages including [EpiNow2](https://github.com/epiforecasts/EpiNow2) and [scoringutils](https://github.com/epiforecasts/scoringutils). We want to create something equivalent in Julia: a domain-focused ecosystem in the mould of [SciML](https://sciml.ai) or [Turing.jl](https://turinglang.org), with the community infrastructure of [rOpenSci](https://ropensci.org) and the domain specificity of [SpeedyWeather.jl](https://github.com/SpeedyWeather/SpeedyWeather.jl). So far, we have [CensoredDistributions.jl](https://github.com/EpiAware/CensoredDistributions.jl), which handles common biases in epidemiological delay distributions, and an R interface prototype ([EpiAwareR](https://github.com/sbfnk/EpiAwareR)). We initially plan to implement packages covering distribution extensions for epidemiological use, delay and generation time estimation, disease dynamics components, and forecast evaluation, alongside a centralised documentation site. At the package level, we need to answer questions about what makes a good Julia package in our ecosystem: consistent documentation via [DocStringExtensions](https://github.com/JuliaDocs/DocStringExtensions.jl) and [DocumenterCiterepress](https://github.com/JuliaDocs/DocumenterCitations.jl), robust testing with [Aqua.jl](https://github.com/JuliaTesting/Aqua.jl) and [JET.jl](https://github.com/aviatesk/JET.jl), automatic differentiation backend testing via [DifferentiationInterfaceTest](https://github.com/gdalle/DifferentiationInterface.jl), and where we need package extensions (e.g. for [Turing.jl](https://turinglang.org) integration). At the ecosystem level, we need to understand how to manage releases so that package versions work together, how to run reverse dependency checks before publishing, how to set up shared CI and centralised documentation across many packages, and how to help users understand which automatic differentiation backends are compatible when they combine multiple packages. juliacon-2026-92864-building-a-composable-julia-ecosystem-for-infectious-disease-modelling-a-roadmap-challenges-and-questions General /media/juliacon-2026/submissions/NEWC8H/image_Emedxrb.webp Sam Abbott en false https://pretalx.com/juliacon-2026/talk/NEWC8H/ https://pretalx.com/juliacon-2026/talk/NEWC8H/feedback/ Muschel — N3 Short talk 2026-08-14T14:45:00+02:00 14:45 00:15 Delay distributions describe the time between epidemiological events, such as infection to symptom onset or symptom onset to hospitalisation. Estimating these distributions from outbreak data is difficult because both the primary event (e.g. infection) and the secondary event (e.g. symptom onset) are usually only known to have occurred within a time window, such as a day. Real-time outbreak data is also often right-truncated as longer delays have not yet been observed. Ignoring double interval censoring and truncation biases parameter estimates which are then used for forecasting and transmission modelling. Adjusting distributions for primary event censoring addresses this by integrating the delay CDF over the primary event window, weighted by the density of when, within the window, the event occurred. This can then be combined with truncation and secondary interval-censoring adjustments to produce a double-interval-censored and right-truncation-adjusted distribution. In this talk, we present [CensoredDistributions.jl](https://censoreddistributions.epiaware.org), which implements these adjustments as `primary_censored`, `interval_censored`, and `double_interval_censored`, composable [Distributions.jl](https://github.com/JuliaStats/Distributions.jl) wrappers. Multiple dispatch selects closed-form CDFs for delay and primary event distribution pairs where these are available, and falls back to numerical integration otherwise. We demo the package standalone and with [Turing.jl](https://turinglang.org/) for parameter estimation. We then compare to [primarycensored](https://primarycensored.epinowcast.org), our equivalent R package, which also ships a duplicate set of [Stan](https://mc-stan.org/) functions so users can fit models in either language. Maintaining two parallel implementations required reimplementing distribution functions in Stan, building tooling to vendor Stan code into downstream projects, and replacing types with integer distribution identifiers. Stan's integral solver was also unstable for this problem, so we had to recast it as an ODE. Julia's multiple dispatch and ecosystem composability eliminates all of this. We then summarise our plans to build a composed Julia version of our [epidist](https://epidist.epinowcast.org) R package, using CensoredDistributions.jl as a foundation with Turing.jl submodels for partially pooled and flexible delay estimation. juliacon-2026-92853-estimating-epidemiological-delay-distributions-from-r-stan-to-julia General /media/juliacon-2026/submissions/ZUMSFD/image_1MIM8cY.webp Sam Abbott en false https://pretalx.com/juliacon-2026/talk/ZUMSFD/ https://pretalx.com/juliacon-2026/talk/ZUMSFD/feedback/ Muschel — N3 Long talk 2026-08-14T15:00:00+02:00 15:00 00:30 We introduce SignatureTensors.jl, a new package for computing signature tensors of paths and membranes. By leveraging the symbolic computation framework provided by OSCAR, the package implements flexible algebraic structures for truncated tensor signatures, and provides efficient constructors for path signatures. Furthermore, it features implementations of Lie group barycenters and optimized algorithms for learning from signature tensors. We illustrate the package’s versatility with practical applications in geometric statistics, feature extraction, spline interpolation, and computational algebraic geometry. juliacon-2026-92283-signature-tensors-in-oscar General /media/juliacon-2026/submissions/7VFDJF/image_6fgn8zB.webp Gabriel Riffo en 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 false https://pretalx.com/juliacon-2026/talk/7VFDJF/ https://pretalx.com/juliacon-2026/talk/7VFDJF/feedback/ Muschel — N3 Short talk 2026-08-14T15:45:00+02:00 15:45 00:15 Periodic structures create band gaps that restrict electromagnetic and elastic wave propagation. These gaps enable control of light and sound at the wavelength scale. `PhoXonic.jl` is the first pure Julia tool computing both photonic and phononic dispersion relations through a unified interface using plane wave expansion. It supports 1D, 2D, and 3D with dense and sparse solvers, and includes topological invariant analysis. Results reproduce published literature. juliacon-2026-92689-phoxonic-jl-unified-interface-for-calculating-photonic-and-phononic-bandgaps-with-pure-julia General /media/juliacon-2026/submissions/7YGMC3/image_RoHV0Xt.webp Hiroharu Sugawara en 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 false flyer-7YGMC3 https://pretalx.com/juliacon-2026/talk/7YGMC3/ https://pretalx.com/juliacon-2026/talk/7YGMC3/feedback/ Muschel — N3 Short talk 2026-08-14T16:00:00+02:00 16:00 00:15 The phase field method simulates microstructure evolution and phase transitions. `PhaseFields.jl` is the first pure Julia package providing major phase field models with built-in FDM and FEM (via Gridap.jl) and adaptive time stepping (DifferentialEquations.jl). It couples with `OpenCALPHAD.jl` for chemical potentials via automatic differentiation from CALPHAD databases. We demonstrate spinodal decomposition, CALPHAD-driven solidification, and Stefan problem validation. juliacon-2026-92804-microstructure-simulation-in-pure-julia-phase-fields-with-calphad-coupling General /media/juliacon-2026/submissions/NMJBP9/image_lE37fwN.webp Hiroharu Sugawara en 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 false flyer-NMJBP9 https://pretalx.com/juliacon-2026/talk/NMJBP9/ https://pretalx.com/juliacon-2026/talk/NMJBP9/feedback/ Muschel — N3 Short talk 2026-08-14T16:15:00+02:00 16:15 00:15 Pseudospectra generalize eigenvalue analysis by characterizing how the resolvent norm of (zB - A)^{-1} varies over the complex plane, revealing transient behavior and stability properties that eigenvalues alone miss. Growing demand from non-Hermitian physics, power systems, and data-driven robust control necessitates large-scale pseudospectral computations that existing CPU-based tools cannot efficiently handle for large dense matrices. In this talk, we present KAPseudospectra.jl, the first GPU-accelerated pseudospectra package, built on KernelAbstractions.jl for vendor-neutral execution across supported backends. The package implements a batched Inverse Hermitian Lanczos (IHL) iteration that approximates the smallest singular value at each grid point in only a few steps, requiring O(N^2) operations at each grid point after a single O(N^3) CPU-only Schur decomposition. Central to the IHL iteration is KATRSM.jl, a submodule providing batched triangular solvers that keep the pencil (zB - A) factored on-device, largely eliminating host-device data movement. Multi-device parallelism is achieved by partitioning the complex grid across available GPUs with automatic memory-aware batching. We demonstrate the package on matrices up to dimension 2^14, and discuss the design decisions that enable this codebase to target multiple compute backends through Julia's package extension system and KernelAbstractions.jl. juliacon-2026-92762-kapseudospectra-jl-gpu-accelerated-pseudospectra-via-kernelabstractions-jl General /media/juliacon-2026/submissions/3MV3BW/image_fmCRbwE.webp Dan Folescu en false KAPseudospectra.jl flyer-3MV3BW https://pretalx.com/juliacon-2026/talk/3MV3BW/ https://pretalx.com/juliacon-2026/talk/3MV3BW/feedback/ Muschel — N3 Short talk 2026-08-14T16:30:00+02:00 16:30 00:15 Dynamic magnetic field generation is essential for numerous applications but grows power-intensive with system scale. Non-linear current-to-field relationships in soft iron core designs complicate the inverse current problem. This work formulates power-efficient control as a nonlinear program with algebraic constraints on field and gradient strength, solved using JuMP.jl and IPOPT.jl. Spherical harmonic expansions provide the polynomial field representation for efficient optimization on consumer hardware. juliacon-2026-90685-optimal-control-of-a-field-generator-using-jump-jl-and-ipopt-jl General /media/juliacon-2026/submissions/738AXH/image_1Dwcy26.webp Philip Suskin en 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. false SphericalHarmonicExpansions.jl flyer-738AXH Master's thesis: "Optimal Control of a Field-Free-Point Using a Multi-Coil Magnetic Field Generator" Visualization of optimized field trajectory with associated power consumption IPOPT Constraints https://pretalx.com/juliacon-2026/talk/738AXH/ https://pretalx.com/juliacon-2026/talk/738AXH/feedback/ Muschel — N3 Short talk 2026-08-14T16:45:00+02:00 16:45 00:15 Recent outbreaks of Ebola, COVID-19 and mpox, alongside routine surveillance of endemic pathogens, have demonstrated the value of modelling for synthesising data to inform decision making. For modelling evidence to effectively inform policy it must be timely, rigorous, and collaborative, yet current approaches struggle to be all three. Methods broadly fall into approaches that chain separate models together, offering flexibility but losing information and introducing bias, or approaches that rigorously analyse all data together but cannot be separated into reusable parts. Composable models, where components can be reused across contexts, can be both rigorous and flexible, enabling rapid collaborative model development. We outline design considerations for a composable infectious disease modelling framework and present a proof of concept domain-specific language built on the Turing.jl probabilistic programming language in Julia with an R interface. We demonstrate our approach conceptually using models from published epidemiological analyses, and in practice through a worked autoregressive example. We replicate three published analyses, composing elements of our autoregressive example with shared and novel components: a COVID-19 analysis for South Korea using a renewal process, adding components for reporting delays and day-of-week effects to replicate EpiNow2 for real-time nowcasting, and an ordinary differential equation analysis of influenza outbreak data. We then discuss strengths, limitations, and alternative approaches. We find that our proof of concept can address the tension between rigour and flexibility, though work remains to realise this potential. Our approach enables interdisciplinary collaboration by lowering technical barriers for domain experts to contribute specialised components, supporting both routine surveillance and outbreak response. For multi-model efforts, common components enable attribution of differences to assumptions rather than implementation. Our approach is also well suited for large language model assisted model construction. This study demonstrates that a composable modelling approach has the potential to incorporate diverse modelling approaches and domain knowledge across different infectious disease contexts. juliacon-2026-92844-composable-probabilistic-models-can-lower-barriers-to-rigorous-infectious-disease-modelling General /media/juliacon-2026/submissions/AMFLYU/image_9m418rj.webp Sam Abbott en false https://pretalx.com/juliacon-2026/talk/AMFLYU/ https://pretalx.com/juliacon-2026/talk/AMFLYU/feedback/ Muschel — N3 Short talk 2026-08-14T17:00:00+02:00 17:00 00:15 Zed support for Julia is growing! We'll talk about working and missing features and how Zed today against other Julia supporting editors. juliacon-2026-92716-zed-support-for-julia General /media/juliacon-2026/submissions/GQ8NM3/image_erDgnKV.webp Miguel Raz Guzmán Macedo en 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 false https://pretalx.com/juliacon-2026/talk/GQ8NM3/ https://pretalx.com/juliacon-2026/talk/GQ8NM3/feedback/ Alte Mensa — Audi Max Long talk 2026-08-14T10:00:00+02:00 10:00 00:30 ASML builds the lithography machines that enable the world’s most advanced microchips. For our newest DUV systems, Julia has become part of the control software stack—directly participating in algorithms that influence wafer quality and overall system performance. At JuliaCon 2025 we shared our early exploration and our intention to use Julia in production. One year later, we are excited to report concrete results: we successfully exposed wafers on a prototype machine using a Julia library built with juliac/PackageCompiler, and the performance, stability, and developer experience were all very promising. In this talk, we will share how we designed, optimized, and deployed time‑critical Julia code in an environment where algorithms must complete within strict millisecond‑level deadlines, remain predictable, and integrate with a large, safety‑critical control system written in multiple languages. We will highlight the architecture patterns we adopted, the trade‑offs we had to make, and a collection of “unexpected lessons” from working with Julia in a real industrial setting. juliacon-2026-92639-how-we-made-julia-make-microchips Julia in Industry /media/juliacon-2026/submissions/YNFSLT/image_pCdkn1O.webp Yury NuzhdinJorge Alberto Vieyra Salas en 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. false https://pretalx.com/juliacon-2026/talk/YNFSLT/ https://pretalx.com/juliacon-2026/talk/YNFSLT/feedback/ Alte Mensa — Audi Max Short talk 2026-08-14T11:15:00+02:00 11:15 00:15 Over five years of professional projects, I introduced and supported Julia across a variety of different projects. I have maintained closed-ecosystem packages, and taught a variety of colleagues. I’ll share what worked, what didn’t, and what surprised me most about adopting and promoting Julia in a professional setting. juliacon-2026-92861-five-years-of-bringing-julia-into-industry Julia in Industry /media/juliacon-2026/submissions/TQMXFF/image_4N88igF.webp Tom Lemmens en 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. false https://pretalx.com/juliacon-2026/talk/TQMXFF/ https://pretalx.com/juliacon-2026/talk/TQMXFF/feedback/ Alte Mensa — Audi Max Short talk 2026-08-14T11:30:00+02:00 11:30 00:15 Julia has great tools for computation, but if you want to build an interactive desktop application with maps, real-time overlays, and custom visualizations, your options are limited. The usual answer is to reach for a web framework or Electron, which means maintaining a split codebase with a server layer in between. That's what we did initially for SHERPA, a mission planning tool for NASA's lunar surface operations. We had a React frontend talking to a Julia backend over a local server, and it was clunky. Two languages, constant serialization, and every UI change meant context-switching between JavaScript and Julia. So we scrapped it and rebuilt the entire GUI in Julia using Dear ImGui (via CImGui.jl) for the interface and Mirage.jl, a custom OpenGL wrapper I wrote that gives you an HTML5 Canvas2D-style API for 2D and 3D rendering. No shader code or buffer management, just draw_image() and fill_rect() calls. The real win is how this integrates with Julia's REPL. Our workflow is: start the GUI, use it, close the window, edit a function, reopen the GUI with all your state intact. Maps stay loaded, camera position is preserved, your scenario is right where you left it. This made it possible for a small team to go from nothing to a production tool in a few months, iterating on the GUI the same way you'd iterate on any Julia code. This approach isn't specific to aerospace. Anything that needs interactive visualization on top of a Julia computation backend (lab instruments, geospatial tools, simulation dashboards, data exploration) could use the same stack. This talk covers how it all fits together, a live demo of the tools, and practical advice for building your own. juliacon-2026-92058-building-production-desktop-guis-in-julia-at-nasa-with-dear-imgui-and-mirage-jl Julia in Industry /media/juliacon-2026/submissions/CXRHSP/image_dsDnZtV.webp grob en 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. false https://pretalx.com/juliacon-2026/talk/CXRHSP/ https://pretalx.com/juliacon-2026/talk/CXRHSP/feedback/ Alte Mensa — Audi Max Short talk 2026-08-14T11:45:00+02:00 11:45 00:15 Harmoniqs is a startup building quantum control infrastructure entirely in Julia. Our open-source stack, Piccolo.jl, and its private extension Piccolissimo.jl share one language from API to numerics. We discuss compiling and delivering Julia without exposing source code, deploying on HPC resources including GPU clusters, and how Julia's single-language design makes AI coding agents unusually effective for a small team. A case study in why Julia is ready for startups. juliacon-2026-93485-building-a-quantum-control-startup-on-julia-piccolo-jl-compiled-sysimages-and-ai-agents Julia in Industry /media/juliacon-2026/submissions/JNATTB/image_54LnlCf.webp Aaron Trowbridge en [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/) false https://pretalx.com/juliacon-2026/talk/JNATTB/ https://pretalx.com/juliacon-2026/talk/JNATTB/feedback/ Alte Mensa — Audi Max Short talk 2026-08-14T12:00:00+02:00 12:00 00:15 This talk presents JADE (Julia Analytics Decision Engine), a production system serving a wide variety of companies, that resolves BI development tension through rapid model development alongside dynamic Julia package generation, intelligent precompilation, and cache-first architecture. JADE generates complete Julia packages at runtime from domain-specific analytical models. Each generated package contains 10K+ lines of Julia code implementing hundreds of analytical functions, multi-dimensional data structures, dependency graphs, and model-specific formula chains. The system currently serves enterprise clients with production models processing gigs of data and supporting thousands of function calls per evaluation with minimal query latency for warm queries. The core innovation is our three-stage precompilation strategy that balances compilation overhead against runtime performance. First, we precompile reusable function templates once and distribute them via a shared depot, covering hundreds of analytical functions relevant to financial modeling, statistical analysis, and multi-dimensional array operations. Second, when models change, we generate model-specific code and combine it with precompiled templates without triggering full recompilation. Third, we maintain a hash-based cache of compiled packages that delivers instant results for cache hits while compiling updated packages in the background. We support two deployment patterns with different performance characteristics. In local mode, Julia processes run on workstations or servers, achieving fast cold starts and near instant warm queries. In Hub mode, distributed Julia processes use shared Registries and caches, delivering low latency queries with horizontal scaling. Performance optimization is central to JADE's architecture. We employ automatic multi-threading for large array operations with custom chunking strategies, coordinate remapping systems that precompute dimension maps to avoid allocations in hot loops, smart dirty state tracking via dependency graphs that reduces recomputation, and union splitting macros to limit reliance on type dispatch while maintaining flexibility for heterogeneous data. The talk will cover practical engineering challenges we solved: managing Julia depot paths across deployment environments, implementing intelligent cache invalidation strategies, optimizing precompilation workloads with custom compile statements, handling package versioning and upgrades in production, along with debugging performance issues in generated code. We'll share performance measurements, code examples, and lessons learned from a year of production deployment. This work demonstrates Julia's readiness for enterprise-critical systems and provides an inspiration for organizations building dynamic code generation platforms and formula chain engines. The techniques we present—precompilation strategies, caching architectures, and performance optimization patterns—are broadly applicable to any domain requiring flexible, high-performance analytics. Our experience shows that Julia's combination of performance, metaprogramming capabilities, and ecosystem maturity enables production systems that were previously impractical. Target audiences include enterprise developers integrating Julia into business intelligence platforms, developers building code generation systems for domain-specific languages, performance-focused Julia users, and organizations evaluating Julia for production analytics workloads. juliacon-2026-90858-bi-engine-in-julia Julia in Industry /media/juliacon-2026/submissions/TVG9AR/image_GtoLVeb.webp Matthew Muyres / Chase Cowart en 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. false https://pretalx.com/juliacon-2026/talk/TVG9AR/ https://pretalx.com/juliacon-2026/talk/TVG9AR/feedback/ Alte Mensa — Audi Max Short talk 2026-08-14T12:15:00+02:00 12:15 00:15 This presentation reviews the evolution and application of model-based design in Boeing’s Vertical Lift Vehicle Management Systems (VMS). It highlights the long-standing use of MATLAB/Simulink for requirements development, built-in test implementation, component modeling, and software/hardware-in-the-loop testing, while also exploring the emerging potential of Julia/Dyad for acausal physics-based modeling, reusable libraries, and faster execution. The presentation includes a recent IRAD effort demonstrating parallel modeling in Simulink and Dyad and discusses how these tools may support future aircraft development processes aligned with ARP-4754B. juliacon-2026-95483-evolution-and-application-of-model-based-design-in-boeing-vertical-lift-vehicle-management-systems Julia in Industry /media/juliacon-2026/submissions/ARE8YL/image_hI036qj.webp Matt YuFernando Dones en true https://pretalx.com/juliacon-2026/talk/ARE8YL/ https://pretalx.com/juliacon-2026/talk/ARE8YL/feedback/ Alte Mensa — Audi Max Short talk 2026-08-14T12:30:00+02:00 12:30 00:15 Digital twins are evolving from simulation models into adaptive, continuously improving representations of real systems. This talk introduces Ansys TwinAI™, part of the Synopsys portfolio, and outlines how the integration of JuliaHub's Dyad brings Scientific Machine Learning (SciML), differentiable programming, and physics-informed artificial intelligence into digital twin workflows. We will highlight the value of hybrid digital twins and present representative engineering use cases. juliacon-2026-95485-bringing-scientific-machine-learning-to-industrial-digital-twins-with-dyad-and-ansys-twinai Julia in Industry /media/juliacon-2026/submissions/BR3CQM/image_g8HgNKo.webp Edward Carman en 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. false https://pretalx.com/juliacon-2026/talk/BR3CQM/ https://pretalx.com/juliacon-2026/talk/BR3CQM/feedback/ Alte Mensa — Audi Max Short talk 2026-08-14T12:45:00+02:00 12:45 00:15 Guidance, Navigation, and Control (GNC) for geostationary satellites is traditionally built with a patchwork of tools: MATLAB for analysis, C/C++ for flight software, and custom scripts for simulation and verification. This session details a case study in replacing those various toolsets with a single Julia-based workflow that runs from early design to orbit. juliacon-2026-95484-from-design-to-orbit-julia-powered-gnc-for-geo-satellites Julia in Industry /media/juliacon-2026/submissions/RKVDD9/image_wiPM7Ir.webp Nik Descher en 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 false https://pretalx.com/juliacon-2026/talk/RKVDD9/ https://pretalx.com/juliacon-2026/talk/RKVDD9/feedback/ Alte Mensa — Audi Max Birds of Feather (BoF) 2026-08-14T14:30:00+02:00 14:30 01:00 Round-table open discussion of everything about Dagger.jl. Success or failure stories, gripes and joys, ideas for new features, discussion of existing bugs or missing documentation, and more! juliacon-2026-93152-dagger-jl-birds-of-a-feather General /media/juliacon-2026/submissions/TVKAZB/image_9ViEcZz.webp Julian P SamarooFelipe Tomé en Dagger.jl is a rising star in the landscape of High Performance Computing, striving to make parallel computing easy and productive for everyone. Dagger has grown significantly over the last few years, and many more improvements are already planned for 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. false flyer-TVKAZB https://pretalx.com/juliacon-2026/talk/TVKAZB/ https://pretalx.com/juliacon-2026/talk/TVKAZB/feedback/ Alte Mensa — Audi Max Birds of Feather (BoF) 2026-08-14T15:45:00+02:00 15:45 01:00 Round table discussion on using Julia for computational biology: Use cases, limitations and concerns we should address, and where to focus our collective efforts. juliacon-2026-92654-birds-of-a-feather-julia-for-biology General /media/juliacon-2026/submissions/EHEXV3/image_ERLkkX8.webp Jakob Nybo Andersen en 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. true https://pretalx.com/juliacon-2026/talk/EHEXV3/ https://pretalx.com/juliacon-2026/talk/EHEXV3/feedback/ Alte Mensa — Audi Max Long talk 2026-08-14T16:45:00+02:00 16:45 00:30 Bayesian spatial modeling is critical across science, yet most practitioners are locked into R due to R-INLA. We present a Julia ecosystem to change this: **GaussianMarkovRandomFields.jl** provides fast sparse precision-based inference via SPDE discretizations & more, while **IntegratedNestedLaplace.jl** brings the full INLA methodology to Julia with a familiar formula interface. We demonstrate the ecosystem on spatial disease mapping, showing competitive results with R-INLA and native Julia advantages. juliacon-2026-92942-scalable-bayesian-spatial-modeling-in-julia-with-gmrfs-and-inla General /media/juliacon-2026/submissions/3KTAGM/image_IzWxQZC.webp Tim Weiland en 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. false https://pretalx.com/juliacon-2026/talk/3KTAGM/ https://pretalx.com/juliacon-2026/talk/3KTAGM/feedback/ Alte Mensa — Atrium Maximum Short talk 2026-08-14T10:00:00+02:00 10:00 00:15 Electron Probe Microanalysis (EPMA) is an imaging technique for the quantitative analysis of solid material samples relying on measurements of characteristic X-ray emission induced by electron irradiation. The determination of the material constitutes an inverse problem, hence an efficient reconstruction requires differentiability of the forward model. The mathematical model employed in EPMA is governed by a linear transport equation that for heterogeneous materials is commonly approximated using Monte Carlo simulation, where statistical noise complicates the computation of gradients. For reconstruction, there exist surrogate models that are well tested in practice, but are very restrictive in the parametrization of the material, allowing only homogeneous or depth-layered materials, which ultimately limits the spatial resolution of quantitative analysis in EPMA. In this short talk, we present an implementation of a deterministic, heterogeneous, and differentiable model for EPMA in Julia. Reconstruction can then be implemented as a gradient-based optimization using the model as a PDE constraint. Compatibility with algorithmic differentiation allows us to tailor the material parametrization to a set of quantities of interest, depending on the requirements of a specific sample. Reconstruction results using realistic as well as synthetic measurements demonstrate potential for further development. Additionally, we briefly discuss a structural similarity of the forward model in EPMA to the structure in which adjoint methods can be effectively applied for gradient computation. It allows us to "apply adjoints twice" leading also to a more efficient computation of the forward problem, ultimately accelerating reconstruction approaches. juliacon-2026-93375-how-implementing-a-differentiable-model-for-electron-microscopy-epma-accelerated-the-forward-simulation Differentiable Computational Models and their Applications /media/juliacon-2026/submissions/TGC3ZM/image_WgMAbUs.webp Tamme Claus en false https://pretalx.com/juliacon-2026/talk/TGC3ZM/ https://pretalx.com/juliacon-2026/talk/TGC3ZM/feedback/ Alte Mensa — Atrium Maximum Short talk 2026-08-14T10:15:00+02:00 10:15 00:15 [FluxOptics.jl](https://github.com/anscoil/FluxOptics.jl) is a Julia framework for differentiable optical inverse design. It enables both rapid prototyping relying on automatic differentiation with Zygote.jl and production performance through algorithmic differentiation and custom gradient rules. The framework provides memory-efficient optimization through controlled buffer management, while maintaining a composable architecture. Benchmarks against JAX show competitive performance while handling larger problems, demonstrating Julia's strengths for computational physics applications. juliacon-2026-92046-fluxoptics-jl-a-composable-framework-for-optical-inverse-design-in-julia Differentiable Computational Models and their Applications /media/juliacon-2026/submissions/YCXBKT/image_AvW0U8P.webp Nicolas Barré en ## 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. true Github repository JOSS article https://pretalx.com/juliacon-2026/talk/YCXBKT/ https://pretalx.com/juliacon-2026/talk/YCXBKT/feedback/ Alte Mensa — Atrium Maximum Long talk 2026-08-14T10:30:00+02:00 10:30 00:30 Automatic differentiation (AD) is gaining ground as a technique for optimization of tensor networks (TN), which are widely used simulation tools in quantum computing, condensed matter, and high energy physics. In this talk we will provide an overview of the ongoing work to add support for end-to-end AD in our large, complex set of physics simulation packages at the "QuantumKitHub". Efficient AD of these networks involves differentiation through complex linear algebra, complicated tensor operations, and other constructs that push the boundaries of what Julia's AD frameworks are capable of. juliacon-2026-93426-automatic-and-fixed-point-differentiation-in-tensor-network-algorithms Differentiable Computational Models and their Applications /media/juliacon-2026/submissions/GFVKR3/image_2FkzCzx.webp Katharine HyattLukas Devos en 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. false https://pretalx.com/juliacon-2026/talk/GFVKR3/ https://pretalx.com/juliacon-2026/talk/GFVKR3/feedback/ Alte Mensa — Atrium Maximum Short talk 2026-08-14T11:15:00+02:00 11:15 00:15 Climate models rely on parameterizations that are traditionally tuned manually. We present a differentiable calibration framework using Enzyme.jl to compute exact reverse mode gradients of energy-balance diagnostics in SpeedyWeather.jl. By batching single- timestep gradients across chaotic dynamics, we enable systematic, reproducible optimization of shortwave radiation parameters, establishing an extensible workflow for objective calibration in Earth system models. juliacon-2026-92718-differentiable-climate-modeling-calibrating-speedyweather-with-enzyme Differentiable Computational Models and their Applications /media/juliacon-2026/submissions/EGUEJP/image_Q4N6AaH.webp Niklas ViebigMilan KlöwerMaximilian GelbrechtGreg MundayBrian Groenke en 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 false https://pretalx.com/juliacon-2026/talk/EGUEJP/ https://pretalx.com/juliacon-2026/talk/EGUEJP/feedback/ Alte Mensa — Atrium Maximum Short talk 2026-08-14T11:30:00+02:00 11:30 00:15 Functional Mock-up Units (FMUs) are widely used in industry for exchanging dynamical system models, but their black-box binary nature makes them inaccessible to traditional AD tools. Built-in derivative support in the FMI standard is limited in scope and often relies on slow finite differences. We present a novel approach: by embedding LLVM bitcode into FMU binaries during compilation, we make them accessible to Enzyme.jl, enabling fast, automatic differentiation of virtually any FMU function. juliacon-2026-92562-differentiating-functional-mock-up-units-fmus-with-enzyme-fast-ad-for-black-box-simulation-models Differentiable Computational Models and their Applications /media/juliacon-2026/submissions/KKHD78/image_yyQXWFC.webp Valentin HöpfnerLars Mikelsons en 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. false https://pretalx.com/juliacon-2026/talk/KKHD78/ https://pretalx.com/juliacon-2026/talk/KKHD78/feedback/ Alte Mensa — Atrium Maximum Short talk 2026-08-14T11:45:00+02:00 11:45 00:15 Ocean models simulate complex physics, but struggle from inherent limitations and under-resolved phenomena. This motivates the use of inverse and machine learning methods to inform models with data. We have implemented automatic differentiation in the Ocean modeling package Oceananigans.jl, through the use and enhancement of compiler tools Enzyme.jl and Reactant.jl. Using these open-source packages, we generate gradients for applications like parameter estimation and embedded ML techniques. juliacon-2026-92664-dj4oceananigans-differentiating-an-ocean-general-circulation-model-for-gradient-based-parameter-calibration-and-online-learning Differentiable Computational Models and their Applications /media/juliacon-2026/submissions/3RDRVU/image_Dlvdlgq.webp Joseph Kump en 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. false https://pretalx.com/juliacon-2026/talk/3RDRVU/ https://pretalx.com/juliacon-2026/talk/3RDRVU/feedback/ Alte Mensa — Atrium Maximum Short talk 2026-08-14T12:00:00+02:00 12:00 00:15 Geophysical surface flow phenomena such as avalanches, landslides, and floods pose significant risks to infrastructure and human safety. Recently, surface flow simulators are used to predict flow dynamics, inundation zones and develop hazard maps, allowing for effective disaster management strategies and safer engineering designs. While existing simulators (e.g. Openfoam-Avalanche, Avaframe, and r.Avaflow) are robust; they lack the differentiability required to efficiently perform uncertainty quantification tasks like sensitivity analysis, parameter calibration, etc., or discover new constitutive relations from observed data. We introduce GlissADe.jl, developed for differentiable Finite-Area-Method (FAM) simulations, which enables the integration of physical simulations into gradient-based workflows and scientific machine learning. It is built upon the mathematical framework of surface-aligned depth-integrated shallow water equations [1]. By leveraging Julia’s automatic differentiation (AD) ecosystem, including ForwardDiff.jl and Enzyme.jl, GlissADe.jl enables the direct computation of gradients across all model inputs. This allows for sensitivity analysis with respect to geometry, initial conditions (e.g., release height), and physical process parameters (e.g., friction coefficients and bulk density). This talk explores the software architecture of GlissADe.jl, addressing the challenges of maintaining numerical stability while ensuring compatibility with operations that typically pose difficulties for AD, but are essential for geophysical simulators. These operations include differentiating through iterative time-stepping schemes, handling non-smooth flux limiters, and managing in-place memory mutations. We demonstrate how this framework is used for topographic uncertainty quantification. Finally, we discuss the potential application of such differentiable simulators to solve inverse problems in geophysical flow. [1] [M. Rauter, Ž. Tuković, A finite area scheme for shallow granular flows on three-dimensional surfaces, Computers & Fluids, Volume 166, 2018, Pages 184-199, ISSN 0045-7930,](https://doi.org/10.1016/j.compfluid.2018.02.017). juliacon-2026-92656-glissade-jl-differentiable-simulator-for-geophysical-surface-flows Differentiable Computational Models and their Applications /media/juliacon-2026/submissions/A79CZS/image_zFQYTEt.webp Tanish Jain en false https://pretalx.com/juliacon-2026/talk/A79CZS/ https://pretalx.com/juliacon-2026/talk/A79CZS/feedback/ Alte Mensa — Atrium Maximum Short talk 2026-08-14T12:15:00+02:00 12:15 00:15 MemlsRetrieval.jl is a Julia reimplementation of the Microwave Emission Model of Layered Snowpacks (MEMLS). It leverages Julia’s type system and generic input types to evaluate typical forward simulations in microseconds with zero allocations while remaining fully differentiable. MemlsRetrieval.jl has been successfully combined with other models in an optimal estimation framework for the retrieval of geophysical parameters from satellite observations. juliacon-2026-93457-memlsretrieval-jl-fast-snow-and-sea-ice-microwave-emission-modeling-for-inversion Differentiable Computational Models and their Applications /media/juliacon-2026/submissions/97YU9L/image_A74c9Bv.webp Marcus Huntemann en 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. false https://pretalx.com/juliacon-2026/talk/97YU9L/ https://pretalx.com/juliacon-2026/talk/97YU9L/feedback/ Alte Mensa — Atrium Maximum Birds of Feather (BoF) 2026-08-14T12:30:00+02:00 12:30 00:30 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 juliacon-2026-104397-differentiable-modeling-bof-discussion-and-future-directions Differentiable Computational Models and their Applications /media/juliacon-2026/submissions/KLDKCP/image_q1TZdBm.webp Sarah WilliamsonAlan Correa en 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 false https://pretalx.com/juliacon-2026/talk/KLDKCP/ https://pretalx.com/juliacon-2026/talk/KLDKCP/feedback/ Alte Mensa — Atrium Maximum Birds of Feather (BoF) 2026-08-14T14:30:00+02:00 14:30 01:00 An hour for users of Makie.jl to gather, show off cool plots, and talk about the state of the Makie ecosystem! juliacon-2026-88586-makie-jl-bof General /media/juliacon-2026/submissions/3Z7LGC/image_BtrTSAL.webp Anshul Singhvi en Will be pretty free-form - starting out with a 10-minute recap of what's happened in Makie world since last year, and then going to free-form discussion. I'll also ask around if people would like to show off their own packages or plots. 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 :) false flyer-3Z7LGC https://pretalx.com/juliacon-2026/talk/3Z7LGC/ https://pretalx.com/juliacon-2026/talk/3Z7LGC/feedback/ Alte Mensa — Atrium Maximum Birds of Feather (BoF) 2026-08-14T15:45:00+02:00 15:45 01:00 Julia was created by greedy programmers who wanted it all. What if we are equally greedy about tooling? This session invites discussion on missing capabilities in Julia’s development tools. What tools or workflows still fall short? Where should future efforts be made to improve productivity and insight? juliacon-2026-92572-creating-tooling-as-greedy-as-julia-itself General /media/juliacon-2026/submissions/QS37VY/image_nZcjRnv.webp Tyrone KriegerYury Nuzhdin en 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. false https://pretalx.com/juliacon-2026/talk/QS37VY/ https://pretalx.com/juliacon-2026/talk/QS37VY/feedback/