JuliaCon 2026

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.

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.

Specialization behavior in Julia can be surprising and mystifying at times, especially when it leads to inference failures or performance problems. The compiler has a number of techniques and heuristics that it uses to determine how code ought to specialized to maintain performance and code size.

This talk will focus on how the Julia compiler makes specialization decisions and where these can sometimes go wrong, leading to suboptimal code, type-unstable code, --trim failures, and more.

To illustrate the discussion, we'll see scenarios where specialization goes right (as well as where it "goes wrong") and we'll dive into what it looks like to try to guide the compiler to specialize the way you need / want it to.