This month in Julia world - 2025-06&07

A monthly newsletter, mostly on julia internals, digestible for casual observers. A biased, incomplete, editorialized list of what a clique of us found interesting this month, with contributions from the community.

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):

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/

“Internals” Fora and Core Repos (Slack/Zulip/Discourse/Github):

  • 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.

In search of contributors and new maintainers (specify novice/moderate/expert and internals/domain background necessary):

Ecosystem Fora, Maintenance, and Colab Promises (Slack/Zulip/Discourse/Github):

  • 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.

Numerical Math ecosystem:

  • DataInterpolationsND.jl, under the SciML umbrella, now provides the equivalent of DataInterpolations.jl for arbitrary dimensions.

Autodiff ecosystem:

Events:

  • 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

Please feel free to post below with your own interesting finds, or in-depth explanations, or questions about these developments.

If you would like to help with the draft for next month, please drop your short, well formatted, linked notes in this shared document. Some of it might survive by the time of posting

35 Likes

Great news for Julia and Dagger.jl!

The “minutes of triage meetings” link seems to have no updates for a year? Just fyi

I’ll duplicate a comment I made on another post but I think it’s worth sharing, here is a table of the JuliaCon 2025 livestreams organized by day and room for those interested in finding specific talks before they’ve been uploaded individually.

JuliaCon Global 2025 Livestreams

Room Day 1
2025-07-23
Day 2
2025-07-24
Day 3
2025-07-25
REPL Main Stage Recording Recording Recording
Else Room Recording Recording Recording
Function Room Recording Recording Recording
Struct Room Recording Recording Recording
Method Room Recording Recording Recording
If Room Recording Recording Recording
Let Room Recording
17 Likes

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 we’re starting to announce some very cool plenary speakers, including familiar faces :star_struck:
Ticket link: https://pretix.eu/pydata/juliaconparis25/



8 Likes

I think the wrong link was used here for DataInterpolationsND.jl :slight_smile:

1 Like