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.

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