A monthly newsletter, mostly on Julia internals: a biased, incomplete, editorialized list, with contributions from the community. Subscribe by email on Discourse.
For recent news on Julia and interesting conversations with community members, check out the JuliaDispatch podcast (on many platforms, including youtube and spotify). Highlights from the newsletter get discussed (with more context) during some episodes.
JuliaCon happened two weeks ago. Here is the full list of talks, well worth perusing. Here are some of my favorite highlights (well-formatted recordings will be uploaded to the Julia youtube channel over the next few weeks, but you can already immediately access the raw recordings of live streams and find the timestamp of each talk yourself):
State of Julia – great way to learn about the progress of the last year.
Past, present and future of the Julia Language Server – a talk on the tooling that made the Julia VSCode extension possible and why it is becoming difficult to evolve these tools (partially because they were working around the lack of more foundational tools like JuliaSyntax and JuliaLowering)
A new language server for Julia – building upon better static analysis tooling available in JET to make the language server more powerful, relying on JuliaSyntax and JuliaLowering for more faithful static analysis
Interpreting Julia code – informative about the distinction between compilation and interpretation for julia code and why interpretation can be slow right now
Parting ways with our Julia simulation after 100 million miles – a great success story of Julia in industry now ending as they transition to other tools. A discussion of why Julia was great for early prototyping but became difficult to scale for this particular team. Many lessons to be learnt for the ecosystem as a whole.
State of Continuous Integration in the SciML ecosystem – great talk on how to structure a large GitHub org more efficiently and reliably.
State of --trim – progress in static ahead-of-time compilation of julia code.
Can we achieve “invalidation freedom” for Julia? – a speculative talk on what hints the compiler might find useful when deciding what code to compile or invalidate.
An Intersection of Concerns: Extended Types for Julia – in what ways can the Julia type system be extended to make the lives of the developer and of the compiler easier, without breaking compatibility or leading to unbound complexity. Contains a comparison to Rust and TypeScript features.
Lead, follow, or get out of the way: Julia and threaded Python – the difficulties of interfacing multithreaded Julia and multithreaded Python.
Cancellation, AKA the big red button – going over why is it difficult to have well-behaved Ctrl-C behavior, i.e. interrupting your code gracefully.
Dagger 2025: Cool New Things – one of the best ways to seamlessly program diverse multi-node hardware in julia for numerics
Reactant: Optimize Julia functions with MLIR & XLA – pretty amazing library that takes human-readable pleasant numeric code and transforms it into high-performance less-allocating, distributed (over multiple accelerators), optimized magic
AcceleratedKernels.jl: Cross-Architecture Parallel Algorithms – another piece in the story being told by Dagger and Reactant, providing seamless multi-node CPU/GPU/xPU acceleration for numerics
Reviving OpenCL.jl for CPU glory – making the OpenCL julia ecosystem much more reliable and modernized, and also using it as a CPU backend for KernelAbstractions.
Fixing Julia’s task-local RNG: a bother, a bug, a breakthrough – very educational deep dive in the intricacies of reliable multithreaded/concurrent RNG
“Whats new in AMDGPU.jl” and “What is new and improved in CUDA.jl”
Pkg’s new SAT-based version resolver – soon-to-come improvements to how version resolving works in Pkg, permitting much more flexible configurations and goals (e.g. oldest possible package version that fulfills compat bounds)
And if JuliaCon Global left you wanting more, don’t forget to book your tickets for JuliaCon Local Paris (October 2nd & 3rd, right after PyData Paris). The early bird pricing expires in 10 days and they are starting to announce some very cool plenary speakers, including familiar faces. Ticket link: https://pretix.eu/pydata/juliaconparis25/
Just as @__MODULE__ refers to the enclosing module object, the internal variable var"#self#" can be used to refer to the enclosing function object. This PR creates an alias @__FUNCTION__ for this variable to match the naming conventions of existing reflection macros (@__MODULE__, @__FILE__, etc.). It had to deal with an interesting amount of edge cases as discussed in linked PRs and Issues.
A competition to create a faster sum and potentially have it included in Base.
About a year ago there was a proposal for cleaner printing of repetitions in stack traces (e.g. due to recursion). That proposal/implementation is now merged.
The garbage collector capabilities are now better documented.
Some work has gone into improving the compiler’s understanding of the effects of accessing [1, 2, 3, 4] and iterating Vector and Memory. Because almost all code uses these fundamental operations, even tiny improvements to the effects can lead to widespread performance benefits.
A new function has been added to get the n’th element of an iterable.
The Graphs.jl repo features a few bounties on integrating external graph theory libraries better with the rest of the Graphs ecosystem.
JuliaPackageComparisons is a wiki-like resource comparing different julia tools. It is in search of a new maintainer.
The Center for Quantum Networks is running many bounties and minigrants on a variety of support packages for quantum information science.
SciML is running a large set of funded small projects – a great opportunity to contribute to the community and be paid for it.
The foundational package DataStructures.jl had a breaking release, bringing in many new features from the last few years.
Dyad is a new language (Julia frontend?) with good GUI support for engineering modeling and controlling embedded hardware.
A few packages handling URLs or other user-provided input recently issued fixes for security vulnerabilities.
A very detailed discussion of how AI agents like Claude Code are successfully being used in the Julia/SciML ecosystem.
Discussion of tooling available for more advanced macro work, going over MacroTools, ExprTools, and MLStyle. The tooling behind Expronicon.jl and Moshi.jl might also deserve a tangential mention here.
MultipleInterfaces.jl is a sophisticated tool to enable trait-like interface-like multiple-inheritance capabilities in Julia. A very interesting addition to the long discussion on how to better implement interfaces and trait systems in julia. See also this older discussion and this proposal.
Discourse post on linter, formatters, and other static analyzers for julia code.
Gettext.jl is now much more lightweight of a dependency, making it very easy to provide translation and internalization for your packages.
Makie 0.24 is released – one of the important changes in it is moving to ComputeGraph (instead of Observable) for defining reactive graphics and user interfaces. The Observable approach lets you attach update rules to each piece of input data, so that your plot can react to changes in that date. ComputeGraph solves the issue of multiple Observables being changed at the same time (which usually resulted in redundant slow updates to the plot). Check out also the release blog post for 0.23.
A game engine is being developed in Julia. See Cruise.jl. It includes a window/input manager, an ECS (entity-component system for fast simulation of diverse inhomogeneous entities in the virtual world), and a physics engine.
A small but important part of that engine is Arceus.jl. It provides extremely fast “behavior resolution” for ECS (entity-component systems) used in games and agent simulations – it lets you call a particular update function for a given entity depending on an arbitrary combination of traits with very low overhead. It uses techniques originally developed for chess engines.
Relatedly, see RECS.jl, a reactive ECS framework for high-performance simulations in Julia. This type of ECS (entity-component systems) are a standard solution to the issue of slow dynamical dispatch when iterating over a diversly typed array (i.e. when you do not have type stability and suffer from boxing and runtime dispatch). They are an alternative to the more popular Algebraic Data Types approach popular in parts of the Julia ecosystem (see Moshi.jl, SumTypes.jl, and others).
A commercial game is being developed in Julia.
MPI (the standard tool for efficient communication during computation on supercomputing clusters) now has much faster integration into Dagger.jl
A story on how to build an e-ink dashboard powered by Julia.
Gaston.jl is a convenient way to access gnuplot from julia.
FixedSizeArrays: What Arrays should have been – providing the compiler with more size information and promising to not change size of an array, enables more optimizations.
DataInterpolationsND.jl, under the SciML umbrella, now provides the equivalent of DataInterpolations.jl for arbitrary dimensions.
Bringing the advanced sparse autodiff available in Julia to jax.
Colab notebook showcasing sparse autodiff on GPU.
An informative slack thread on the ArrayInterface.jl library and a github discussion that emerged from it. ArrayInterface is frequently necessary to write generic code over AbstractArrays (appropriately specializing for different type of arrays, e.g. CUDA arrays), and the discussion delves deeper on some edgecases.
An informative slack thread on the Mooncake autodiff toolkit.
FerriteCon 2025 is happening in Copenhagen, Denmark on August 28th and is currently open for registration.
See also: French community newsletter, community calendar, minutes of triage meetings, Turing.jl newsletter
You can engage in the discussion of this newsletter on Discourse