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.
Current status: Julia release is 1.12.4, Julia LTS is 1.10.10. The feature freeze for 1.13 has passed and we are already at 1.13-alpha2. The dev branch is at 1.14-dev
Revise.jl 3.13 has been released, finally allowing automatic struct- and constant redefinition. This has been one of the most requested features for Revise, as it eliminates the need to restart Julia when changing type definitions during interactive development. It follows up on recent work (discussed in previous newsletters) that made redefinition of structs possible (by tracking and invalidating them similarly to how method invalidation happens). Now Revise.jl makes sure that the redefinition happens on the fly in the background (without requiring the user to manually trigger a re-evaluation), which is particularly useful if you are modifying an already loaded library.
Kristoffer Carlsson has created a script to find Core.Box instances, and made a series of PRs to fix the inference issues caused by such instances in Base and stdlibs [1, 2, 3, 4, 5, 6, 7, 8]. You can also use this script to improve your own packages. Core.Box-related issues happen when Julia wraps inside a function (a closure) a reference to an object that might be modified outside of the function (e.g. a global object). Thus, the function can not be compiled to inferred efficient machine code, because the type of the object can change at any time.
A prototype was PR'd to Base which allows users to give early feedback to a proposal for match statements in Julia. And a new syntax for declared exceptions. Declared exceptions have been discussed previously as chain-of-custody error handling. Both match statements and declared exceptions are highly experimental, and it's not certain in what final form they will land in Julia, if ever. Match statements would provide a more ergonomic way to handle pattern matching compared to nested if-elseif chains, while declared exceptions aim to make error handling more explicit and trackable through the call chain. If you like match statements, check out Moshi.jl.
Julia now has asymmetric memory fences, which split a full memory fence into a cheap compiler-only fence (Threads.atomic_fence_light) and a rare but expensive global fence (Threads.atomic_fence_heavy) that enforces hardware ordering across all CPUs. Using the light fence instead of a full fence may speed up hot code in multithreaded scenarios, where applicable. The asymmetric design allows most threads to pay only a compiler-level cost while occasional heavy operations ensure proper memory visibility across all processors.
Work continues on an architecture for robust cancellation in Julia. The proposal introduces explicit cancellation tokens and better scheduler integration, aiming to make Ctrl-C more reliable and give library authors a standard way to cancel long-running tasks without corrupting internal state. Unlike interpreted languages like Python/Ruby that have implicit safe points for interruption, compiled languages like Julia need buy-in from library developers to mark locations where cancellation can be safely handled.
Keno is prototyping syntax for labeled break syntax, i.e. breaking from a named loop. This improves ergonomics with complex control flow out of nested loops. The PR also proposes for-then and while-then constructs that execute code after a loop completes normally (but not when broken out of), similar to Python's for-else.
A recent PR may soon bring StringViews to Base Julia. StringViews provide a lightweight way to reference portions of strings without copying, similar to how array views work. This has been a feature of the external StringViews.jl package and its inclusion in Base would make it more widely available for performance-critical string processing.
Unsigned integers in Julia are shown in hexadecimal, which frequently has been a topic of discussion. A new PR optionally allows them to be shown in decimal.
Timothy is working on a deep, but backwards compatible overhaul of StyledStrings and AnnotatedString [1, 2], which is intended to solve some of the pain points of StyledStrings, such as poor inference. See the thread on Discourse. StyledStrings enables rich text formatting in Julia's REPL and other text interfaces, but the current implementation has some performance and usability issues that this overhaul addresses.
Julia's own CI now has a timing tracking page with breakdowns by job and workers and trend analysis. There's a badge link to it at the top of the Julia README. This transparency helps identify performance regressions in the CI pipeline itself and understand where testing time is spent.
Mutually recursive types have been a requested feature in Julia since the early days, and several implementations have been attempted [1, 2]. A third attempt is now underway. Mutually recursive types occur when two or more types reference each other, which is common in data structures like trees and graphs but has been challenging to express cleanly in Julia.
Claire has introduced a new compiler frontend API for include_string(), eval(), and other compiler frontend functions. This work introduces a TopLevelCodeIterator interface and AbstractCompilerFrontend type, paving the way for using JuliaSyntax and JuliaLowering throughout the compilation pipeline while maintaining backwards compatibility. The abstraction allows different syntax versions to coexist cleanly and brings Julia closer to having its entire frontend implemented in pure Julia rather than flisp. Most importantly, this will provide an unbreakable chain of provenance for compiled code, leading to much better error messages referencing the human-readable code where the error originated, especially inside nasty macros or for advanced dev tools that inspect LLVM or machine code.
Julia is getting initial support for LLVM 21, keeping pace with the latest LLVM releases. Regular LLVM updates bring performance improvements and new optimization capabilities to Julia's code generation.
A PR improves how keyword arguments interact with positional dispatch. Previously, calling f(100, y=1) could dispatch to a different method than f(100) even if both methods matched the same positional signature, which was counterintuitive. This change makes keyword calls respect positional method dispatch first, then handle keywords.
Test macros in Base.Test are becoming more consistent, with support for broken=, skip=, and context= keywords being added to @test_throws, @test_warn, @test_nowarn, @test_logs, and @test_deprecated. Previously only @test supported these helpful testing utilities.
Syntax versioning behavior in scripts and the REPL is being formalized. This work defines how Julia should handle different syntax versions when code is evaluated in different contexts, important for maintaining compatibility as the language evolves.
A low-level compiler optimization for setjmp is being explored using LLVM's preserve_none calling convention. This is deep compiler work that could improve exception handling performance.
JuliaSyntax received a performance optimization by forcing specialization on a key parsing function. This particular change is fairly in the weeds, but it is very small and well-explained, so pedagogically it is a good example from which to learn about Julia compiler specialization heuristics.
SymbolicIntegration.jl enables symbolic integration using Symbolics.jl, implementing both the Risch algorithm and a rule-based method with over 3,000 integration rules translated from Mathematica's Rubi collection. The developer substantially improved pattern matching performance in SymbolicUtils, reducing compilation time from 14 minutes to approximately 12 seconds. This package represents a significant achievement in bringing comprehensive symbolic integration capabilities to Julia.
BorrowChecker.jl has experimental SSA-form IR borrow checking that no longer requires annotations. Working on nightly Julia, it can detect aliasing issues at compile time, catching errors where mutable operations occur on aliased data—similar to Rust's borrow checker but adapted to Julia's dynamic nature.
Stefan Karpinski has been working on HyperLogLogOverRSA.jl, a Julia implementation demonstrating the HyperLogLog Over RSA protocol. This combines RSA cryptography with HyperLogLog cardinality estimation to enable secure counting of distinct elements in a dataset while maintaining privacy. The protocol allows clients to generate encoded values that decode to HyperLogLog estimates, enabling useful analytics while preserving data privacy. Full technical specifications are available on HackMD.
A helpful article on world age for beginners explains Julia's world age mechanism—how Julia achieves performance despite being dynamic by allowing the compiler to make assumptions about global constants and method definitions, with the world age counter tracking when these assumptions change and code needs recompilation.
Flexible Julia is a newly launched JetBrains plugin providing Julia language support across all JetBrains IDEs. It's a ground-up new implementation with code completion, syntax highlighting, runtime support with REPL access, inline documentation, and upcoming debugging capabilities. The plugin uses a tiered pricing model with discounts for open source, students, nonprofits, and startups.
JuliaHealth won a NumFOCUS Small Development Grant. They will be using the funds for several improvements across the JuliaHealth ecosystem. JuliaHealth will also be parceling out some of the funds through limited bounties. Feel free to reach out to @TheCedarPrince with questions here or on the Julia Slack.
JuliaHealth is looking for reviewers for their JuliaCon Proceedings extended abstract paper about their emerging ecosystem.
A discussion has emerged about potentially adopting the SciML Style Guide for Julia Base and standard library documentation. The conversation focuses on standardizing docstring formats with structured sections like Arguments, Keywords, Returns, and Throws. Community consensus appears to lean toward adoption as Julia has matured enough to benefit from standardized guidelines without being overly prescriptive.
Mongoose.jl v0.2 is a lightweight HTTP server library emphasizing performance and simplicity with just one dependency. The new version adds multi-instance capability (multiple servers on different ports) and multi-threading support. Benchmarks show it outperforms HTTP.jl and Oxygen.jl by 2-4x, though it trails leading Rust frameworks. Future plans include WebSocket support.
DocumenterTypst.jl is a new backend for Documenter.jl that generates PDFs using Typst instead of LaTeX. It achieves 10x faster PDF generation than LaTeX, completing the entire Julia documentation (2000+ pages) in under 60 seconds with zero setup required. The package includes automatic PDF compression reducing file sizes by 65% or more.
PkgTemplatesShikiPlugin.jl integrates Shiki syntax highlighting into new Julia packages created with PkgTemplates, providing VS Code-quality highlighting in documentation. It uses Shiki's TextMate grammars rather than regex-based highlight.js, offering superior highlighting quality with multi-line background coloring and better code structure visualization.
Desmos.jl bridges Julia with Desmos, the web-based graphing calculator, allowing programmatic graph generation from Julia with results displayed in VS Code, Pluto.jl, and Jupyter notebooks. The @desmos macro handles syntax differences between Julia and Desmos, supporting everything from basic plotting to advanced features like curve fitting and parametric equations.
Breakout.jl provides a Julia-based Breakout game designed for reinforcement learning research with CommonRLInterface compatibility. It offers multiple state representations (2D minimal, 5D brickless, 89D full, or 160×210 pixel-based) and requires no Python dependencies or GPU for training on internal game state.
A curated list of GitHub Actions for Julia package quality has sparked discussion, with the conversation highlighting BestieTemplate.jl as an emerging solution that can be applied to existing packages and reapplied to acquire updates. This represents a shift toward a unified, updateable approach to package quality standards.
A developer shared reflections on building a large Julia codebase, documenting experience rewriting an 80k-line Python simulator in Julia. While praising Julia's 100x performance improvement and excellent differential equation solvers, they noted challenges with refactoring, type parameter explosion causing long compilation times, and the benefits of stricter interfaces and optional static typing for large codebases.
Lit.jl is a Streamlit-inspired web application framework that enables building interactive applications purely in Julia without requiring HTML, CSS, or JavaScript knowledge. It targets scientists, researchers, and data practitioners who want accessible application development for dashboards and exploratory analysis. Currently limited to Linux x86_64 platforms.
NearestNeighbors.jl celebrates its 10-year anniversary with a summary of recent updates including periodic boundary conditions, self-queries (finding neighbor relationships within a single tree), parallel tree building (5x speedup with 10 threads), a tree traversal API compatible with AbstractTrees.jl, unit support via Unitful.jl, and numerous performance enhancements. A v1.0 release is planned.
CasualPlots.jl provides a GUI-based plotting package targeting casual Julia users—experimental scientists and engineers—who need an accessible alternative to spreadsheet software. Users can select data from Julia variables, DataFrames, CSV, or XLSX files and create plots through a graphical interface with live preview, aiming for 60-80% of commonly expected features.
A self-contained juliac demonstration provides a complete tutorial for using juliac, Julia's command-line compilation tool, to create standalone executables. The demonstration addresses a gap in comprehensive tutorials by automating the entire process of building executables, though discussions reveal concerns about bundle size optimization.
SolarPosition.jl provides a unified interface to multiple solar positioning algorithms (PSA, NOAA, Walraven, USNO, SPA), completely rewritten in pure Julia with no external dependencies. It's typically 1-2 orders of magnitude faster than Python equivalents and includes recent additions like sunrise/sunset calculations with polar day/night detection. Originally designed for solar photovoltaic engineering.
See also: JuliaHub corporate blog, French community newsletter, community calendar, Turing.jl newsletter
You can engage in the discussion of this newsletter on Discourse
Disclaimer: An LLM was used to convert the initial human-curated list of interesting links into narrative bullet points. The human editor then used these first bullet points drafts to flesh them out into their current state (occasionally with only minimal changes, sometimes with significant rewriting). Please be aware of the Julia Discourse policy on Generative AI content.