Uploaded October 2026 | Updated November 2026, 3 days ago
Spying into Julia’s Runtime. by Tyrone Krieger, Yury Nuzhdin, Jorge Alberto Vieyra Salas
PreTalx: pretalx.com/juliacon-2026/talk/3AZE7E
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.
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.
Spying into Julia’s Runtime. by Tyrone Krieger, Yury Nuzhdin, Jorge Alberto Vieyra Salas
PreTalx: pretalx.com/juliacon-2026/talk/3AZE7E
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.
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.


![ReproducibleJobs.jl enables practical and reproducible workflows in SingleCellProjections.jl
ReproducibleJobs.jl enables practical and reproducible workflows in SingleCellProjections.jl by Rasmus Henningsson
PreTalx: https://pretalx.com/juliacon-2026/talk/8Z8UFG/
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.
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. ReproducibleJobs.jl enables practical and reproducible workflows in SingleCellProjections.jl](https://i.ytimg.com/vi/pr-Qj2cVtcw/mqdefault.jpg)







