From 520368ea35377bc29f4cbab841ef093461313d87 Mon Sep 17 00:00:00 2001 From: Stefan Krastanov Date: Thu, 8 Jan 2026 23:16:13 -0500 Subject: [PATCH 1/7] This Month in Julia World Dec 2025 (and fixes for Nov) --- blog/2025/12/this-month-in-julia-world.md | 121 +++++++--------------- blog/2026/01/this-month-in-julia-world.md | 66 ++++++++++++ 2 files changed, 105 insertions(+), 82 deletions(-) create mode 100644 blog/2026/01/this-month-in-julia-world.md diff --git a/blog/2025/12/this-month-in-julia-world.md b/blog/2025/12/this-month-in-julia-world.md index 4c4a6e256e..7acc381eb6 100644 --- a/blog/2025/12/this-month-in-julia-world.md +++ b/blog/2025/12/this-month-in-julia-world.md @@ -14,77 +14,77 @@ Current status: Julia release is 1.12.2, Julia LTS is 1.10.10. The feature freez “Internals” Fora and Core Repos (Slack/Zulip/Discourse/Github): -* Pkg’s resolver might start *preferring* versions of dependencies that are already loaded in the current session when you `Pkg.add` them, to avoid unnecessary re-precompilation and keep the active environment and new projects in sync. This is implemented as a weighted preference, not a hard constraint, so it should not introduce new resolver failures. ([GitHub][1]) +* Pkg’s resolver might start *preferring* versions of dependencies that are already loaded in the current session when you `Pkg.add` them, to avoid unnecessary re-precompilation and keep the active environment and new projects in sync. This is implemented as a weighted preference, not a hard constraint, so it should not introduce new resolver failures. ([GitHub](https://github.com/JuliaLang/Pkg.jl/pull/4507)) -* A proposed optional “strict mode” for Julia allows modules to opt into a more restrictive subset of the language to catch error-prone patterns in mature code (e.g. forbidding accidental global mutation, shadowing, or ambiguous constructs). The mode is configured per-module and is expected to land in 1.14. ([GitHub][2]) +* A proposed optional “strict mode” for Julia allows modules to opt into a more restrictive subset of the language to catch error-prone patterns in mature code (e.g. forbidding accidental global mutation, shadowing, or ambiguous constructs). The mode is configured per-module and is expected to land in 1.14. ([GitHub](https://github.com/JuliaLang/julia/pull/60180)) -* A design sketch for *cancellation* in Julia proposes explicit cancellation tokens and better integration with the scheduler, with the dual goal of making Ctrl-C more reliable and giving library authors a standard way to cancel long-running tasks without corrupting internal state. Interpreted languages like Python/Ruby have it a bit easier here, as they implicitly have many safe points for interruption. Languages like C++/Julia/Rust/C# need to be a bit more careful and require buy-in from the library developer marking locations where an interrupt can be handled. Check also this [related JuliaCon talk](https://www.youtube.com/watch?v=95TgXZ8Tn1M). ([GitHub][11]) +* A design sketch for *cancellation* in Julia proposes explicit cancellation tokens and better integration with the scheduler, with the dual goal of making Ctrl-C more reliable and giving library authors a standard way to cancel long-running tasks without corrupting internal state. Interpreted languages like Python/Ruby have it a bit easier here, as they implicitly have many safe points for interruption. Languages like C++/Julia/Rust/C# need to be a bit more careful and require buy-in from the library developer marking locations where an interrupt can be handled. Check also this [related JuliaCon talk](https://www.youtube.com/watch?v=95TgXZ8Tn1M). ([GitHub](https://github.com/JuliaLang/julia/pull/60281)) -* “Local names linking” is an overhaul of how LLVM IR objects are named (when generated by Julia during compilation). Instead of relying on global unique names, Julia now generates names local to each LLVM module, leading to much more deterministic IR and many opportunities for caching. ([GitHub][4]) +* “Local names linking” is an overhaul of how LLVM IR objects are named (when generated by Julia during compilation). Instead of relying on global unique names, Julia now generates names local to each LLVM module, leading to much more deterministic IR and many opportunities for caching. ([GitHub](https://github.com/JuliaLang/julia/pull/60031)) -* The internal `Core.@__doc__` macro is becoming a documented part of the public metaprogramming API. It is used to pass docstrings to functions defined by macros. ([GitHub][5]) +* The internal `Core.@__doc__` macro is becoming a documented part of the public metaprogramming API. It is used to pass docstrings to functions defined by macros. ([GitHub](https://github.com/JuliaLang/julia/pull/60059)) -* `show` supports "context flags" that change the way an object is printed. These flags have been used to great effect in enabling "short" output, e.g. when printing an array and its entries. A new flag (`:hexunsigned`) is suggested to control how unsigned integers should be printed -- e.g. in base 10 or in hexadecimal. ([GitHub][7]) +* `show` supports "context flags" that change the way an object is printed. These flags have been used to great effect in enabling "short" output, e.g. when printing an array and its entries. A new flag (`:hexunsigned`) is suggested to control how unsigned integers should be printed -- e.g. in base 10 or in hexadecimal. ([GitHub](https://github.com/JuliaLang/julia/pull/60267)) -* A new `getproperty`-like shorthand is suggested to make symbols usable as “property accessors”: e.g. you can broadcast `:.field` over arrays of objects rather than writing small anonymous functions. Related work explores a broader “property lenses” design for composable field access. Over the last few years there have been many similar suggestions around the idea of "function currying", but they have all ended up as libraries, not as a feature of Base. ([GitHub][8]) +* A new `getproperty`-like shorthand is suggested to make symbols usable as “property accessors”: e.g. you can broadcast `:.field` over arrays of objects rather than writing small anonymous functions. Related work explores a broader “property lenses” design for composable field access. Over the last few years there have been many similar suggestions around the idea of "function currying", but they have all ended up as libraries, not as a feature of Base. ([GitHub](https://github.com/JuliaLang/julia/pull/60271)) -* A long-awaited ABI for pointer-ful `Union` return types is under active development. More `Union` patterns might become stack-allocated and stop showing up as mysterious allocations in profiles. ([GitHub][10]) +* A long-awaited ABI for pointer-ful `Union` return types is under active development. More `Union` patterns might become stack-allocated and stop showing up as mysterious allocations in profiles. ([GitHub](https://github.com/JuliaLang/julia/pull/55045)) -* Precompilation is being extended so that closures can be precompiled more effectively when their types are known at precompile time. This reduces repeated compilation of the same anonymous functions (e.g. common closures passed to `map`, `sort!`, or task spawners) at runtime. ([GitHub][12]) +* Precompilation is being extended so that closures can be precompiled more effectively when their types are known at precompile time. This reduces repeated compilation of the same anonymous functions (e.g. common closures passed to `map`, `sort!`, or task spawners) at runtime. ([GitHub](https://github.com/JuliaLang/julia/pull/60259)) -* User-facing messages from the precompilation diagnostics for the native-code cache have been rewritten to be clearer to avoid user confusion. ([GitHub][6]) +* User-facing messages from the precompilation diagnostics for the native-code cache have been rewritten to be clearer to avoid user confusion. ([GitHub](https://github.com/JuliaLang/julia/pull/60012)) In search of contributors and new maintainers: -* **LLM test cases for Julia (novice–moderate, no internals required):** there is an open call to contribute small Julia snippets (and expected behavior) where LLMs currently struggle, to build a better test suite for Julia-aware models. You don’t need compiler knowledge—just the ability to write idiomatic Julia and articulate what the model should do. ([Discourse][13]) +* **LLM test cases for Julia (novice–moderate, no internals required):** there is an open call to contribute small Julia snippets (and expected behavior) where LLMs currently struggle, to build a better test suite for Julia-aware models. You don’t need compiler knowledge—just the ability to write idiomatic Julia and articulate what the model should do. ([Discourse](https://discourse.julialang.org/t/help-wanted-help-contribute-test-cases-to-improve-llm-performance-on-julia-code/132991/)) -* **Documenter.jl version-switch UX (moderate, JavaScript/Web tooling):** Documenter 1.16 introduced a feature where the version selector keeps you on the same *page* when switching manual versions, but not yet the same anchor/section. There is an issue + PR to preserve anchors when switching versions (including the “outdated version” banner link back to “latest stable”), and help is wanted from someone comfortable with front-end JS in a static-docs setting. ([GitHub][14]) +* **Documenter.jl version-switch UX (moderate, JavaScript/Web tooling):** Documenter 1.16 introduced a feature where the version selector keeps you on the same *page* when switching manual versions, but not yet the same anchor/section. There is an issue + PR to preserve anchors when switching versions (including the “outdated version” banner link back to “latest stable”), and help is wanted from someone comfortable with front-end JS in a static-docs setting. ([GitHub](https://github.com/JuliaDocs/Documenter.jl/issues/2799)) Ecosystem Fora, Maintenance, and Colab Promises (Slack/Zulip/Discourse/Github): -* **Dependabot gains Julia support:** a large PR against `dependabot-core` adds first-class handling for Julia projects, teaching Dependabot how to understand `Project.toml`/`Manifest.toml` and propose version bumps for Julia packages, similarly to other ecosystems. ([GitHub][16]) +* **Dependabot gains Julia support:** a large PR against `dependabot-core` adds first-class handling for Julia projects, teaching Dependabot how to understand `Project.toml`/`Manifest.toml` and propose version bumps for Julia packages, similarly to other ecosystems. ([GitHub](https://github.com/dependabot/dependabot-core/pull/12316/files)) -* The **Julia Security Working Group** has been launched as a new community working group, with a kickoff meeting and a blog post describing recent security-related efforts and future coordination across the ecosystem. ([Discourse][22]) +* The **Julia Security Working Group** has been launched as a new community working group, with a kickoff meeting and a blog post describing recent security-related efforts and future coordination across the ecosystem. ([Discourse](https://discourse.julialang.org/t/launching-the-julia-security-working-group/134116)) -* A “visual log” of loading and precompilation times for many packages across Julia versions provides a time-series view of TTFX behavior—essentially, “how does startup feel today versus a year ago?”—to make regressions and improvements in package load times visible to users and compiler developers. ([Discourse][18]) +* A “visual log” of loading and precompilation times for many packages across Julia versions provides a time-series view of TTFX behavior—essentially, “how does startup feel today versus a year ago?”—to make regressions and improvements in package load times visible to users and compiler developers. ([Discourse](https://discourse.julialang.org/t/a-visual-log-of-loading-and-precompilation-times-for-many-packages-over-a-variety-of-julia-versions/133887/7)) -* The ModelingToolkit developers are soliciting community feedback on a proposed **ModelingToolkit v11 library split and licensing** plan, where some functionality is moved into separate libraries with a copy-left license (open source but "viral" unlike MIT/BSD licenses that permit closed source derivative work). ([Discourse][27]) +* The ModelingToolkit developers are soliciting community feedback on a proposed **ModelingToolkit v11 library split and licensing** plan, where some functionality is moved into separate libraries with a copy-left license (open source but "viral" unlike MIT/BSD licenses that permit closed source derivative work). ([Discourse](https://discourse.julialang.org/t/modelingtoolkit-v11-library-split-and-licensing-community-feedback-requested/134396/19)) -* Jakob Nissen wrote a blog post, *“Review: Julia trimming for Advent of Code 2025”*, reviewing Julia’s experimental *trimming* ahead-of-time compiler as used in this year’s Advent of Code, and using that as a springboard for broader commentary on Julia’s development, tooling experiments (like JET LS), and their readiness for production use. ([Discourse][28]) +* Jakob Nissen wrote a blog post, *“Review: Julia trimming for Advent of Code 2025”*, reviewing Julia’s experimental *trimming* ahead-of-time compiler as used in this year’s Advent of Code, and using that as a springboard for broader commentary on Julia’s development, tooling experiments (like JET LS), and their readiness for production use. ([Discourse](https://discourse.julialang.org/t/blog-post-review-of-trimming-for-aoc-2025/134384)) -* **Ark.jl** is an archetype-based ECS (entity–component system) ported from a Go library, with a type-stable, well-documented API targeting both games and large agent-based simulations. It would be of great benefit to agent-based models and particle-type simulations. Algebraic data types (Sum Types) have been an alternative approach for this type of work, discussed at length in previous issues of the newsletter. ([Discourse][20]) +* **Ark.jl** is an archetype-based ECS (entity–component system) ported from a Go library, with a type-stable, well-documented API targeting both games and large agent-based simulations. It would be of great benefit to agent-based models and particle-type simulations. Algebraic data types (Sum Types) have been an alternative approach for this type of work, discussed at length in previous issues of the newsletter. ([Discourse](https://discourse.julialang.org/t/ann-ark-jl-archetype-based-entity-component-system-ecs-for-games-and-simulations/133851)) -* **World Age for beginners** is a long-form Discourse post explaining Julia’s “world age” mechanism in accessible terms: why methods defined later in a session aren’t immediately visible to already-compiled code, and how this design underpins Julia’s JIT compilation strategy while remaining mostly invisible to typical users. ([Discourse][32]) +* **World Age for beginners** is a long-form Discourse post explaining Julia’s “world age” mechanism in accessible terms: why methods defined later in a session aren’t immediately visible to already-compiled code, and how this design underpins Julia’s JIT compilation strategy while remaining mostly invisible to typical users. ([Discourse](https://discourse.julialang.org/t/world-age-for-beginners-one-way-to-compile-a-dynamic-language/134402)) -* **RayCore.jl** is a new high-performance ray–triangle intersection engine with bounded-volume-hierarchy acceleration, usable on both CPU and GPU via KernelAbstractions. It’s being positioned as the future raytracing backend for Makie, but is factored out as a standalone library with tutorials from basics to advanced GPU optimization. ([Discourse][15]) +* **RayCore.jl** is a new high-performance ray–triangle intersection engine with bounded-volume-hierarchy acceleration, usable on both CPU and GPU via KernelAbstractions. It’s being positioned as the future raytracing backend for Makie, but is factored out as a standalone library with tutorials from basics to advanced GPU optimization. ([Discourse](https://discourse.julialang.org/t/ann-raycore-jl-high-performance-ray-tracing-for-cpu-and-gpu/133776)) -* **PlutoSlides.jl** brings Beamer-like slide authoring to Pluto notebooks, marrying Pluto’s reactive interactivity with a more conventional slideshow experience for talks—e.g. per-slide layouts while retaining live code and interactivity. ([Discourse][24]) +* **PlutoSlides.jl** brings Beamer-like slide authoring to Pluto notebooks, marrying Pluto’s reactive interactivity with a more conventional slideshow experience for talks—e.g. per-slide layouts while retaining live code and interactivity. ([Discourse](https://discourse.julialang.org/t/plutoslides-jl-beamer-style-presentations-for-pluto-notebooks/133655)) -* **Jumbo** (formerly JuBox) is a Julia *distribution* bundling ~800 popular scientific packages (Makie, DifferentialEquations, ModelingToolkit, JuMP, etc.) precompiled on CI. It ships platform installers so newcomers and classrooms can avoid heavy precompilation on first use, while still allowing additional packages via Pkg without recompiling the bundled ones. ([Discourse][19]) +* **Jumbo** (formerly JuBox) is a Julia *distribution* bundling ~800 popular scientific packages (Makie, DifferentialEquations, ModelingToolkit, JuMP, etc.) precompiled on CI. It ships platform installers so newcomers and classrooms can avoid heavy precompilation on first use, while still allowing additional packages via Pkg without recompiling the bundled ones. ([Discourse](https://discourse.julialang.org/t/ann-jumbo-a-scientific-julia-distribution/133856)) -* A small **Breakout-style game** implemented in pure Julia + GLMakie is shared as a single-file example, with discussion about integrating it into Makie’s official example gallery—nice as a compact reference for game-like interactive graphics. ([Discourse][21]) +* A small **Breakout-style game** implemented in pure Julia + GLMakie is shared as a single-file example, with discussion about integrating it into Makie’s official example gallery—nice as a compact reference for game-like interactive graphics. ([Discourse](https://discourse.julialang.org/t/breakout-style-game-in-julia-glmakie-wip/133777)) -* **UFFFiles.jl** adds native read/write support for the Universal File Format (UFF) used in experimental/engineering data, avoiding the need to go through Python’s `pyuff` or MATLAB tooling and manually post-process `PyObject`s. ([Discourse][25]) +* **UFFFiles.jl** adds native read/write support for the Universal File Format (UFF) used in experimental/engineering data, avoiding the need to go through Python’s `pyuff` or MATLAB tooling and manually post-process `PyObject`s. ([Discourse](https://discourse.julialang.org/t/ann-ufffiles-jl/133671)) -* **LibImageQuant.jl** wraps the `libimagequant`/`pngquant` library and exposes an in-memory `quantize_image(figure_or_matrix)` API so Julia code (including Makie plots) can produce much smaller PNGs via color quantization without going through disk or external commands. ([Discourse][26]) +* **LibImageQuant.jl** wraps the `libimagequant`/`pngquant` library and exposes an in-memory `quantize_image(figure_or_matrix)` API so Julia code (including Makie plots) can produce much smaller PNGs via color quantization without going through disk or external commands. ([Discourse](https://discourse.julialang.org/t/ann-libimagequant-jl-smaller-pngs-via-color-quantization/134252)) -* A long thread on **Helix + LanguageServer.jl + JuliaFormatter.jl** documents real-world configuration and pain points when moving from VS Code to the Helix editor: language server integration works, but auto-formatting and some LSP behaviors are still rough, and the thread collects config snippets and troubleshooting notes. ([Discourse][23]) +* A long thread on **Helix + LanguageServer.jl + JuliaFormatter.jl** documents real-world configuration and pain points when moving from VS Code to the Helix editor: language server integration works, but auto-formatting and some LSP behaviors are still rough, and the thread collects config snippets and troubleshooting notes. ([Discourse](https://discourse.julialang.org/t/helix-languageserver-jl-juliaformatter-jl/133755)) -* **SolarPosition.jl** is a new package implementing a common Julia interface to several solar position algorithms, rewritten in Julia. It supports time zone–aware computations of sun positions for given observers and time ranges, with example workflows using TimeZones and DataFrames. ([Discourse][29]) +* **SolarPosition.jl** is a new package implementing a common Julia interface to several solar position algorithms, rewritten in Julia. It supports time zone–aware computations of sun positions for given observers and time ranges, with example workflows using TimeZones and DataFrames. ([Discourse](https://discourse.julialang.org/t/ann-solarposition-jl/134263)) -* A community project, **bitshogi.com**, showcases a mini-Shogi engine written in Julia using bitboards. The site exposes multiple bots (from random/greedy to a minimax bot and an LLM-backed opponent) and highlights Julia’s suitability for small game engines and bitboard-heavy logic. ([Discourse][31]) +* A community project, **bitshogi.com**, showcases a mini-Shogi engine written in Julia using bitboards. The site exposes multiple bots (from random/greedy to a minimax bot and an LLM-backed opponent) and highlights Julia’s suitability for small game engines and bitboard-heavy logic. ([Discourse](https://discourse.julialang.org/t/shogi-in-julia-chess-like-game-bitshogi-com/134399)) -* **TypstDocs.jl** proposes a workflow for writing Julia package documentation in Typst, leveraging Typst’s modern typesetting and evolving HTML backend, with a particular eye toward math-heavy packages whose authors already keep substantial notes in Typst. The post invites discussion around how such docs could integrate with existing Julia documentation tooling. ([Discourse][33]) +* **TypstDocs.jl** proposes a workflow for writing Julia package documentation in Typst, leveraging Typst’s modern typesetting and evolving HTML backend, with a particular eye toward math-heavy packages whose authors already keep substantial notes in Typst. The post invites discussion around how such docs could integrate with existing Julia documentation tooling. ([Discourse](https://discourse.julialang.org/t/rfc-typstdocs-jl-julia-package-documentation-in-typst/134422)) -* **DearDiary.jl** is a Julia-native alternative to MLflow for tracking experiments in machine learning. ([Discourse][17]) +* **DearDiary.jl** is a Julia-native alternative to MLflow for tracking experiments in machine learning. ([Discourse](https://discourse.julialang.org/t/deardiary-jl-a-lightweight-but-powerful-machine-learning-experiment-tracking-tool-for-julia/133666)) -* The Discourse **site guidelines** have been updated, especially around gen-AI usage: the top section is now explicitly anchored in the Julia Community Standards as the hard rules, with the rest framed as guidelines to support human judgment. There is also clearer guidance about AI-generated content and expectations on how it is used. ([Discourse][30]) +* The Discourse **site guidelines** have been updated, especially around gen-AI usage: the top section is now explicitly anchored in the Julia Community Standards as the hard rules, with the rest framed as guidelines to support human judgment. There is also clearer guidance about AI-generated content and expectations on how it is used. ([Discourse](https://discourse.julialang.org/t/updates-to-the-site-guidelines-especially-regarding-gen-ai/134315)) Numerical Math ecosystem: -* **FluxOptics.jl** provides differentiable scalar wave propagation for optical systems, with full AD support for gradient-based optimization. Optical components are modeled as composable, differentiable layers (inspired by Flux.jl), enabling tasks like tomography, field retrieval, and inverse design of multi-element, multi-wavelength optical systems. ([Discourse][35]) +* **FluxOptics.jl** provides differentiable scalar wave propagation for optical systems, with full AD support for gradient-based optimization. Optical components are modeled as composable, differentiable layers (inspired by Flux.jl), enabling tasks like tomography, field retrieval, and inverse design of multi-element, multi-wavelength optical systems. ([Discourse](https://discourse.julialang.org/t/ann-fluxoptics-jl-inverse-optical-design-with-automatic-differentiation/134285)) -* **ChenSignatures.jl** implements *path signatures* and log-signatures—iterated integrals of paths that uniquely characterize them up to tree-like equivalence—with applications in rough path theory, time-series ML, and mathematical finance. The package focuses on efficient computation of signatures/log-signatures at various truncation levels in Julia. ([Discourse][34]) +* **ChenSignatures.jl** implements *path signatures* and log-signatures—iterated integrals of paths that uniquely characterize them up to tree-like equivalence—with applications in rough path theory, time-series ML, and mathematical finance. The package focuses on efficient computation of signatures/log-signatures at various truncation levels in Julia. ([Discourse](https://discourse.julialang.org/t/ann-chensignatures-jl-path-signatures-in-julia/134361)) Mathematical Optimization ecosystem: @@ -92,17 +92,17 @@ Mathematical Optimization ecosystem: Autodiff ecosystem: -* **DifferentiationInterface.jl** received a French national “Open Science – Free Research Software” prize in the “Promising community” category, recognizing its role as a unified interface layer over multiple AD backends and its rapid adoption (roughly a thousand Julia packages depending on it directly or indirectly). ([Ouvrir la Science][36]) +* **DifferentiationInterface.jl** received a French national “Open Science – Free Research Software” prize in the “Promising community” category, recognizing its role as a unified interface layer over multiple AD backends and its rapid adoption (roughly a thousand Julia packages depending on it directly or indirectly). ([Ouvrir la Science](https://www.ouvrirlascience.fr/remise-des-prix-science-ouverte-du-logiciel-libre-de-recherche-edition-2025/)) Notes from other ecosystems: -* **Racket v9.0** was released. Given that Racket is **the** language for macro hackers that love creating domain specific languages, it seems like it would be of interest to the Julia crowd. ([Hacker News][37]) +* **Racket v9.0** was released. Given that Racket is **the** language for macro hackers that love creating domain specific languages, it seems like it would be of interest to the Julia crowd. ([Hacker News](https://news.ycombinator.com/item?id=46023460)) -* A short Discourse post links to **Go’s experimental “Green Tea” garbage collector** in Go 1.25, which operates on pages of objects rather than individual objects and comes with an interactive visualization of the GC phases—interesting context for anyone following GC design across languages. ([Discourse][38]) +* A short Discourse post links to **Go’s experimental “Green Tea” garbage collector** in Go 1.25, which operates on pages of objects rather than individual objects and comes with an interactive visualization of the GC phases—interesting context for anyone following GC design across languages. ([Discourse](https://discourse.julialang.org/t/the-new-green-tea-garbage-collector-in-go/133612)) -* LWN has an in-depth article on **Zig’s new plan for asynchronous programs**, centered on an explicit `Io` interface instead of `async/await` syntax. Asynchronous behavior is parameterized via an `Io` value rather than special language forms, which makes IO “coloring” explicit but keeps the language core simpler; the comment thread compares this with Rust, Go, Haskell, and different coroutine designs. Of interest to anyone excited about [`await` that might come to Julia](https://github.com/JuliaLang/julia/pull/58532). ([LWN.net][39]) +* LWN has an in-depth article on **Zig’s new plan for asynchronous programs**, centered on an explicit `Io` interface instead of `async/await` syntax. Asynchronous behavior is parameterized via an `Io` value rather than special language forms, which makes IO “coloring” explicit but keeps the language core simpler; the comment thread compares this with Rust, Go, Haskell, and different coroutine designs. Of interest to anyone excited about [`await` that might come to Julia](https://github.com/JuliaLang/julia/pull/58532). ([LWN.net](https://lwn.net/SubscriberLink/1046084/4c048ee008e1c70e/)) -* The **“Advent of Compiler Optimisations 2025”** series (with an HN thread attached) runs a daily article on a compiler optimization throughout December, aimed at explaining real optimizations rather than toy examples—relevant inspiration for people interested in Julia’s compiler pipeline. ([Hacker News][40]) +* The **“Advent of Compiler Optimisations 2025”** series (with an HN thread attached) runs a daily article on a compiler optimization throughout December, aimed at explaining real optimizations rather than toy examples—relevant inspiration for people interested in Julia’s compiler pipeline. ([Hacker News](https://news.ycombinator.com/item?id=46119500)) Events: @@ -112,47 +112,4 @@ See also: [JuliaHub corporate blog](https://juliahub.com/blog), [French communit You can engage in the discussion of this newsletter on [Discourse](https://discourse.julialang.org/c/community/news/66) -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, including significant rewriting. Please be aware of the [Julia Discourse policy on Generative AI content](https://discourse.julialang.org/t/updates-to-the-site-guidelines-especially-regarding-gen-ai/134315). - -[1]: https://github.com/JuliaLang/Pkg.jl/pull/4507 "Prefer adding already loaded dep versions by IanButterworth · Pull Request #4507 · JuliaLang/Pkg.jl · GitHub" -[2]: https://github.com/JuliaLang/julia/pull/60180 "Implement mechanism for `strict mode` by Keno · Pull Request #60180 · JuliaLang/julia · GitHub" -[3]: https://github.com/JuliaLang/julia/pull/59091 "Eliminate (almost) all invalidations by disabling world splitting by LilithHafner · Pull Request #59091 · JuliaLang/julia · GitHub" -[4]: https://github.com/JuliaLang/julia/pull/60031 "Local names linking by xal-0 · Pull Request #60031 · JuliaLang/julia · GitHub" -[5]: https://github.com/JuliaLang/julia/pull/60059 "Make `@__doc__` public by MasonProtter · Pull Request #60059 · JuliaLang/julia · GitHub" -[6]: https://github.com/JuliaLang/julia/pull/60012 "loading: improve precompilation cache reason messages by vtjnash · Pull Request #60012 · JuliaLang/julia · GitHub" -[7]: https://github.com/JuliaLang/julia/pull/60267 "Add support for printing unsigned integers as decimals by JamesWrigley · Pull Request #60267 · JuliaLang/julia · GitHub" -[8]: https://github.com/JuliaLang/julia/pull/60271 "WIP: Use (::Symbol) as curried getproperty by Keno · Pull Request #60271 · JuliaLang/julia · GitHub" -[9]: https://github.com/JuliaLang/julia/pull/60277 "JuliaSyntax: Disallow broadcasted getindex by Keno · Pull Request #60277 · JuliaLang/julia · GitHub" -[10]: https://github.com/JuliaLang/julia/pull/55045 "implement `sret_union` ABI for pointer-ful types by topolarity · Pull Request #55045 · JuliaLang/julia · GitHub" -[11]: https://github.com/JuliaLang/julia/pull/60281 "Very WIP: Architecture for robust cancellation by Keno · Pull Request #60281 · JuliaLang/julia · GitHub" -[12]: https://github.com/JuliaLang/julia/pull/60259 "Proactively compile lambdas when the type of the closure is known by xal-0 · Pull Request #60259 · JuliaLang/julia · GitHub" -[13]: https://discourse.julialang.org/t/help-wanted-help-contribute-test-cases-to-improve-llm-performance-on-julia-code/132991/ "[Help Wanted] Help contribute test cases to improve LLM performance on Julia code - Community - Julia Programming Language" -[14]: https://github.com/JuliaDocs/Documenter.jl/issues/2799 "Feature request: stay on page when changing version · Issue #2799 · JuliaDocs/Documenter.jl · GitHub" -[15]: https://discourse.julialang.org/t/ann-raycore-jl-high-performance-ray-tracing-for-cpu-and-gpu/133776 "[ANN] Raycore.jl: High-Performance Ray Tracing for CPU and GPU - Package Announcements - Julia Programming Language" -[16]: https://github.com/dependabot/dependabot-core/pull/12316/files "Add support for the Julia language by IanButterworth · Pull Request #12316 · dependabot/dependabot-core · GitHub" -[17]: https://discourse.julialang.org/t/deardiary-jl-a-lightweight-but-powerful-machine-learning-experiment-tracking-tool-for-julia/133666 "DearDiary.jl: A lightweight but powerful machine learning experiment tracking tool for Julia - Package Announcements - Julia Programming Language" -[18]: https://discourse.julialang.org/t/a-visual-log-of-loading-and-precompilation-times-for-many-packages-over-a-variety-of-julia-versions/133887/7 "A visual log of loading and precompilation times for many packages over a variety of julia versions - #7 by jling - Profiling - Julia Programming Language" -[19]: https://discourse.julialang.org/t/ann-jumbo-a-scientific-julia-distribution/133856 "[ANN] Jumbo - a scientific Julia distribution - Tooling - Julia Programming Language" -[20]: https://discourse.julialang.org/t/ann-ark-jl-archetype-based-entity-component-system-ecs-for-games-and-simulations/133851 "[ANN] Ark.jl: archetype-based entity component system (ECS) for games and simulations - Package Announcements - Julia Programming Language" -[21]: https://discourse.julialang.org/t/breakout-style-game-in-julia-glmakie-wip/133777 "Breakout-style game in Julia (GLMakie) — WIP - General Usage - Julia Programming Language" -[22]: https://discourse.julialang.org/t/launching-the-julia-security-working-group/134116 "Launching the Julia Security Working Group - Community - Julia Programming Language" -[23]: https://discourse.julialang.org/t/helix-languageserver-jl-juliaformatter-jl/133755 "Helix + LanguageServer.jl + JuliaFormatter.jl - New to Julia - Julia Programming Language" -[24]: https://discourse.julialang.org/t/plutoslides-jl-beamer-style-presentations-for-pluto-notebooks/133655 "PlutoSlides.jl — Beamer-style presentations for Pluto notebooks - Package Announcements - Julia Programming Language" -[25]: https://discourse.julialang.org/t/ann-ufffiles-jl/133671 "[ANN] UFFFiles.jl - Package Announcements - Julia Programming Language" -[26]: https://discourse.julialang.org/t/ann-libimagequant-jl-smaller-pngs-via-color-quantization/134252 "[ANN] LibImageQuant.jl - smaller PNGs via color quantization - Package Announcements - Julia Programming Language" -[27]: https://discourse.julialang.org/t/modelingtoolkit-v11-library-split-and-licensing-community-feedback-requested/134396/19 "ModelingToolkit V11 Library Split and Licensing, Community Feedback Requested - #19 by isaacsas - Community - Julia Programming Language" -[28]: https://discourse.julialang.org/t/blog-post-review-of-trimming-for-aoc-2025/134384 "Blog post: Review of trimming for AoC 2025 - Community - Julia Programming Language" -[29]: https://discourse.julialang.org/t/ann-solarposition-jl/134263 "[ANN] SolarPosition.jl - Package Announcements - Julia Programming Language" -[30]: https://discourse.julialang.org/t/updates-to-the-site-guidelines-especially-regarding-gen-ai/134315 "Updates to the site guidelines, especially regarding gen-AI - Meta Discussion - Julia Programming Language" -[31]: https://discourse.julialang.org/t/shogi-in-julia-chess-like-game-bitshogi-com/134399 "Shogi in Julia, Chess-like game bitshogi.com - Community - Julia Programming Language" -[32]: https://discourse.julialang.org/t/world-age-for-beginners-one-way-to-compile-a-dynamic-language/134402 "World Age for beginners: one way to compile a dynamic language - Internals & Design - Julia Programming Language" -[33]: https://discourse.julialang.org/t/rfc-typstdocs-jl-julia-package-documentation-in-typst/134422 "RFC: TypstDocs.jl (Julia package documentation in typst) - Package Announcements - Julia Programming Language" -[34]: https://discourse.julialang.org/t/ann-chensignatures-jl-path-signatures-in-julia/134361 "[ANN] ChenSignatures.jl — Path signatures in Julia - Package Announcements - Julia Programming Language" -[35]: https://discourse.julialang.org/t/ann-fluxoptics-jl-inverse-optical-design-with-automatic-differentiation/134285 "[ANN] FluxOptics.jl - Inverse optical design with automatic differentiation - Package Announcements - Julia Programming Language" -[36]: https://www.ouvrirlascience.fr/remise-des-prix-science-ouverte-du-logiciel-libre-de-recherche-edition-2025/ "Ouvrir la Science - Remise des prix science ouverte du logiciel libre de recherche, édition 2025" -[37]: https://news.ycombinator.com/item?id=46023460 "Racket v9.0 | Hacker News" -[38]: https://discourse.julialang.org/t/the-new-green-tea-garbage-collector-in-go/133612 "The new Green Tea Garbage Collector in Go - Offtopic - Julia Programming Language" -[39]: https://lwn.net/SubscriberLink/1046084/4c048ee008e1c70e/ "Zig's new plan for asynchronous programs [LWN.net]" -[40]: https://news.ycombinator.com/item?id=46119500 "Advent of Compiler Optimisations 2025 | Hacker News" -[41]: https://news.ycombinator.com/item?id=46120181 "Addressing the adding situation | Hacker News" -[42]: https://viralinstruction.com/posts/aoc2025/ "Review: Julia trimming for Advent of Code 2025" \ No newline at end of file +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, including significant rewriting. Please be aware of the [Julia Discourse policy on Generative AI content](https://discourse.julialang.org/t/updates-to-the-site-guidelines-especially-regarding-gen-ai/134315). \ No newline at end of file diff --git a/blog/2026/01/this-month-in-julia-world.md b/blog/2026/01/this-month-in-julia-world.md new file mode 100644 index 0000000000..34cb2985a2 --- /dev/null +++ b/blog/2026/01/this-month-in-julia-world.md @@ -0,0 +1,66 @@ +@def title = "This Month in Julia World (December) 2025)" +@def authors = "Stefan Krastanov" +@def published = "1 January 2026" +@def rss_pubdate = Date(2026, 1, 1) +@def rss = """Community Newsletter for December 2025""" + +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. + +If you want to receive the newsletter as an email, subscribe to the [Community--Newsletter category on Discourse](https://discourse.julialang.org/c/community/news/66). + +For recent news on Julia and interesting conversations with community members, check out the [JuliaDispatch](https://juliadispatch.fm/) podcast (on many platforms, including [youtube](https://www.youtube.com/@JuliaDispatch/) and [spotify](https://open.spotify.com/show/6Y1zWtFhjqPLsFQWRvZmws)). 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 + +"Internals" Fora and Core Repos (Slack/Zulip/Discourse/Github): +- [Revise.jl 3.13 has been released](https://discourse.julialang.org/t/ann-revise-jl-v3-13-struct-revision-support/134818), 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 permitted redefinition of structs (by tracking and invalidating them similarly to how method invalidation happens). +- Kristoffer Carlsson has [created a script to find Core.Box](https://github.com/JuliaLang/julia/pull/60478) instances, and made a series of PRs to fix the [inference issues caused by such instances](https://docs.julialang.org/en/v1/manual/performance-tips/#man-performance-captured) in Base and stdlibs \[[1](https://github.com/JuliaLang/julia/pull/60490), [2](https://github.com/JuliaLang/julia/pull/60514), [3](https://github.com/JuliaLang/julia/pull/60515), [4](https://github.com/JuliaLang/Pkg.jl/pull/4582), [5](https://github.com/JuliaLang/StyledStrings.jl/pull/130), [6](https://github.com/JuliaLang/Downloads.jl/pull/285), [7](https://github.com/JuliaIO/Tar.jl/pull/189), [8](https://github.com/JuliaLang/julia/pull/60547)\]. You [can also use this script](https://github.com/JuliaLang/julia/issues/60479) to improve your own packages. Core.Box 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 infered efficient machine code, because you never know when the type of the object might change. +- Unsigned integers in Julia are shown in hexadecimal, which frequently has been [a topic of discussion](https://github.com/JuliaLang/julia/issues/30167). [A new PR](https://github.com/JuliaLang/julia/pull/60267) optionally allows them to be shown in decimal. +- A [prototype was PR'd to Base](https://github.com/JuliaLang/julia/pull/60344) which allows users to give early feedback to [a proposal for `match` statements in Julia](https://gist.github.com/Keno/e08874a423e0f1df4d11a798c7ed147c). And a new syntax for [declared exceptions](https://gist.github.com/Keno/7d1fb27a003afba6de50686ccfbb6610). Declared exceptions have been discussed previously as [chain-of-custody error handling](https://github.com/JuliaLang/julia/issues/7026). 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](https://github.com/JuliaLang/julia/pull/60311), which split a [full memory fence](https://docs.julialang.org/en/v1/base/multi-threading/#Base.Threads.atomic_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. +- Keno is prototyping syntax for [labeled break syntax](https://github.com/JuliaLang/julia/pull/60481), 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](https://github.com/JuliaLang/julia/pull/60367) that execute code after a loop completes normally (but not when broken out of), similar to Python's `for-else`. +- Timothy is working on a deep, but backwards compatible overhaul of StyledStrings and `AnnotatedString` \[[1](https://github.com/JuliaLang/julia/pull/60527), [2](https://github.com/JuliaLang/StyledStrings.jl/pull/131)\], which is intended to solve some of the pain points of StyledStrings, such as poor inference. See [the thread on Discourse](https://discourse.julialang.org/t/prospective-changes-to-annotatedstring-and-styledstrings/134847). 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. +- A recent PR may soon bring [StringViews to Base Julia](https://github.com/JuliaLang/julia/pull/60526). 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. +- Julia's own CI now has a [timing tracking page](https://juliaci.github.io/julia-ci-timing/) 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](https://github.com/JuliaLang/julia/issues/269), and several implementations have been attempted \[[1](https://github.com/JuliaLang/julia/pull/32581), [2](https://github.com/JuliaLang/julia/pull/32658)\]. A [third attempt](https://github.com/JuliaLang/julia/pull/60569) 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](https://github.com/JuliaLang/julia/pull/60529) that makes `Expr` optional when implementing `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, leading to much better error messages, especially inside nasty macros or from advanced dev tools that inspect LLVM or machine code. +- Julia is getting initial support for [LLVM 21](https://github.com/JuliaLang/julia/pull/60356), 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](https://github.com/JuliaLang/julia/pull/60499). 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](https://github.com/JuliaLang/julia/pull/60543) 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](https://github.com/JuliaLang/julia/pull/60400) 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](https://github.com/JuliaLang/julia/pull/60320) 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](https://github.com/JuliaLang/julia/pull/60403) by forcing specialization on a key parsing function, demonstrating how careful attention to compiler specialization decisions can improve performance even in already-fast code. +- Work continues on [an architecture for robust cancellation](https://github.com/JuliaLang/julia/pull/60281) 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. + +Ecosystem Fora, Maintenance, and Colab Promises (Slack/Zulip/Discourse/Github): + +- [SymbolicIntegration.jl](https://discourse.julialang.org/t/ann-symbolicintegration-jl-indefinite-integration-with-symbolics-jl-symbols/134777) 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](https://github.com/MilesCranmer/BorrowChecker.jl/pull/34) 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](https://github.com/StefanKarpinski/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](https://hackmd.io/@HLLoverRSA). +- A helpful [article on world age for beginners](https://discourse.julialang.org/t/world-age-for-beginners-one-way-to-compile-a-dynamic-language/134402) 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. +- JuliaHealth won a [NumFOCUS Small Development Grant](https://numfocus.org/programs/small-development-grants). They will be using the funds for [several improvements across the JuliaHealth ecosystem](https://github.com/numfocus/small-development-grant-proposals/issues/59). 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](https://github.com/JuliaCon/proceedings-review/issues/193#issue-3731067441) for their JuliaCon Proceedings extended abstract paper about their emerging ecosystem. +- A [discussion has emerged](https://discourse.julialang.org/t/adopt-the-sciml-style-guide-for-julia-base-and-standard-library/134845) 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](https://discourse.julialang.org/t/ann-mongoose-jl-v0-2-x-a-fast-lightweight-http-server/134699) 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](https://discourse.julialang.org/t/ann-documentertypst-jl-fast-pdf-generation-for-documenter-jl-via-typst/134772) 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](https://discourse.julialang.org/t/ann-pkgtemplatesshikiplugin-jl-add-shikistyle-syntax-highlighting-presenting-at-julialang-japan-2025-dec-13/134487) 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](https://discourse.julialang.org/t/ann-desmos-jl/134734) 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](https://discourse.julialang.org/t/ann-breakout-jl-a-simple-breakout-clone-for-fun-and-reinforcement-learning-on-internal-game-state/134872) 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. +- [Flexible Julia](https://discourse.julialang.org/t/new-julia-for-jetbrains-ides-flexible-julia/134658) 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. +- A [curated list of GitHub Actions](https://discourse.julialang.org/t/a-curated-list-of-gh-actions-that-improve-the-quality-of-your-package/134466) 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](https://discourse.julialang.org/t/reflections-on-developer-experience-after-building-a-large-julia-codebase/134732), 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](https://discourse.julialang.org/t/ann-lit-jl-a-simple-data-centric-web-app-framework-for-julia/134855) 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](https://discourse.julialang.org/t/nearestneighbors-jl-10-year-anniversary-recent-updates-and-developments/134518) 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](https://discourse.julialang.org/t/ann-casualplots-jl-a-simple-gui-for-easy-plotting-with-julia/133891) 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](https://discourse.julialang.org/t/self-contained-juliac-demonstration/134366) 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](https://discourse.julialang.org/t/ann-solarposition-jl/134263) 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. + +Notes from other ecosystems: + +- A blog post discusses [how npm lacks a minimum release age security feature](https://www.pcloadletter.dev/blog/npm-min-release-age/) that other package managers like pnpm and yarn have implemented. The feature would delay installation of newly published packages, giving time for the community to identify malicious packages before they're widely adopted. While npm has a `--before` flag that technically allows filtering by relative dates, it lacks proper documentation as a security feature and misses allowlist mechanisms for trusted internal packages. This highlights an important security consideration for all package ecosystems. + +See also: [JuliaHub corporate blog](https://juliahub.com/blog), [French community newsletter](https://pnavaro.github.io/NouvellesJulia/), [community calendar](https://julialang.org/community/#events), [Turing.jl newsletter](https://github.com/TuringLang/Turing.jl/issues/2498) + +You can engage in the discussion of this newsletter on [Discourse](https://discourse.julialang.org/c/community/news/66) + +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 (occassionaly with only minimal changes, sometimes with significant rewriting). Please be aware of the [Julia Discourse policy on Generative AI content](https://discourse.julialang.org/t/updates-to-the-site-guidelines-especially-regarding-gen-ai/134315). \ No newline at end of file From 8778243a068dc38730472a77f9b4161e371b261e Mon Sep 17 00:00:00 2001 From: Stefan Krastanov Date: Sat, 10 Jan 2026 05:18:33 -0500 Subject: [PATCH 2/7] fixups --- blog/2026/01/this-month-in-julia-world.md | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/blog/2026/01/this-month-in-julia-world.md b/blog/2026/01/this-month-in-julia-world.md index 34cb2985a2..d000241e74 100644 --- a/blog/2026/01/this-month-in-julia-world.md +++ b/blog/2026/01/this-month-in-julia-world.md @@ -14,23 +14,23 @@ Current status: Julia release is 1.12.4, Julia LTS is 1.10.10. The feature freez "Internals" Fora and Core Repos (Slack/Zulip/Discourse/Github): - [Revise.jl 3.13 has been released](https://discourse.julialang.org/t/ann-revise-jl-v3-13-struct-revision-support/134818), 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 permitted redefinition of structs (by tracking and invalidating them similarly to how method invalidation happens). -- Kristoffer Carlsson has [created a script to find Core.Box](https://github.com/JuliaLang/julia/pull/60478) instances, and made a series of PRs to fix the [inference issues caused by such instances](https://docs.julialang.org/en/v1/manual/performance-tips/#man-performance-captured) in Base and stdlibs \[[1](https://github.com/JuliaLang/julia/pull/60490), [2](https://github.com/JuliaLang/julia/pull/60514), [3](https://github.com/JuliaLang/julia/pull/60515), [4](https://github.com/JuliaLang/Pkg.jl/pull/4582), [5](https://github.com/JuliaLang/StyledStrings.jl/pull/130), [6](https://github.com/JuliaLang/Downloads.jl/pull/285), [7](https://github.com/JuliaIO/Tar.jl/pull/189), [8](https://github.com/JuliaLang/julia/pull/60547)\]. You [can also use this script](https://github.com/JuliaLang/julia/issues/60479) to improve your own packages. Core.Box 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 infered efficient machine code, because you never know when the type of the object might change. -- Unsigned integers in Julia are shown in hexadecimal, which frequently has been [a topic of discussion](https://github.com/JuliaLang/julia/issues/30167). [A new PR](https://github.com/JuliaLang/julia/pull/60267) optionally allows them to be shown in decimal. +- Kristoffer Carlsson has [created a script to find Core.Box](https://github.com/JuliaLang/julia/pull/60478) instances, and made a series of PRs to fix the [inference issues caused by such instances](https://docs.julialang.org/en/v1/manual/performance-tips/#man-performance-captured) in Base and stdlibs [[1](https://github.com/JuliaLang/julia/pull/60490), [2](https://github.com/JuliaLang/julia/pull/60514), [3](https://github.com/JuliaLang/julia/pull/60515), [4](https://github.com/JuliaLang/Pkg.jl/pull/4582), [5](https://github.com/JuliaLang/StyledStrings.jl/pull/130), [6](https://github.com/JuliaLang/Downloads.jl/pull/285), [7](https://github.com/JuliaIO/Tar.jl/pull/189), [8](https://github.com/JuliaLang/julia/pull/60547)]. You [can also use this script](https://github.com/JuliaLang/julia/issues/60479) 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 you the type of the object can change at any time. - A [prototype was PR'd to Base](https://github.com/JuliaLang/julia/pull/60344) which allows users to give early feedback to [a proposal for `match` statements in Julia](https://gist.github.com/Keno/e08874a423e0f1df4d11a798c7ed147c). And a new syntax for [declared exceptions](https://gist.github.com/Keno/7d1fb27a003afba6de50686ccfbb6610). Declared exceptions have been discussed previously as [chain-of-custody error handling](https://github.com/JuliaLang/julia/issues/7026). 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](https://github.com/JuliaLang/julia/pull/60311), which split a [full memory fence](https://docs.julialang.org/en/v1/base/multi-threading/#Base.Threads.atomic_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](https://github.com/JuliaLang/julia/pull/60281) 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](https://github.com/JuliaLang/julia/pull/60481), 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](https://github.com/JuliaLang/julia/pull/60367) that execute code after a loop completes normally (but not when broken out of), similar to Python's `for-else`. -- Timothy is working on a deep, but backwards compatible overhaul of StyledStrings and `AnnotatedString` \[[1](https://github.com/JuliaLang/julia/pull/60527), [2](https://github.com/JuliaLang/StyledStrings.jl/pull/131)\], which is intended to solve some of the pain points of StyledStrings, such as poor inference. See [the thread on Discourse](https://discourse.julialang.org/t/prospective-changes-to-annotatedstring-and-styledstrings/134847). 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. - A recent PR may soon bring [StringViews to Base Julia](https://github.com/JuliaLang/julia/pull/60526). 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](https://github.com/JuliaLang/julia/issues/30167). [A new PR](https://github.com/JuliaLang/julia/pull/60267) optionally allows them to be shown in decimal. +- Timothy is working on a deep, but backwards compatible overhaul of StyledStrings and `AnnotatedString` [[1](https://github.com/JuliaLang/julia/pull/60527), [2](https://github.com/JuliaLang/StyledStrings.jl/pull/131)], which is intended to solve some of the pain points of StyledStrings, such as poor inference. See [the thread on Discourse](https://discourse.julialang.org/t/prospective-changes-to-annotatedstring-and-styledstrings/134847). 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](https://juliaci.github.io/julia-ci-timing/) 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](https://github.com/JuliaLang/julia/issues/269), and several implementations have been attempted \[[1](https://github.com/JuliaLang/julia/pull/32581), [2](https://github.com/JuliaLang/julia/pull/32658)\]. A [third attempt](https://github.com/JuliaLang/julia/pull/60569) 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](https://github.com/JuliaLang/julia/pull/60529) that makes `Expr` optional when implementing `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, leading to much better error messages, especially inside nasty macros or from advanced dev tools that inspect LLVM or machine code. +- Mutually recursive types have been [a requested feature in Julia since the early days](https://github.com/JuliaLang/julia/issues/269), and several implementations have been attempted [[1](https://github.com/JuliaLang/julia/pull/32581), [2](https://github.com/JuliaLang/julia/pull/32658)]. A [third attempt](https://github.com/JuliaLang/julia/pull/60569) 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](https://github.com/JuliaLang/julia/pull/60529) 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](https://github.com/JuliaLang/julia/pull/60356), 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](https://github.com/JuliaLang/julia/pull/60499). 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](https://github.com/JuliaLang/julia/pull/60543) 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](https://github.com/JuliaLang/julia/pull/60400) 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](https://github.com/JuliaLang/julia/pull/60320) 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](https://github.com/JuliaLang/julia/pull/60403) by forcing specialization on a key parsing function, demonstrating how careful attention to compiler specialization decisions can improve performance even in already-fast code. -- Work continues on [an architecture for robust cancellation](https://github.com/JuliaLang/julia/pull/60281) 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. Ecosystem Fora, Maintenance, and Colab Promises (Slack/Zulip/Discourse/Github): @@ -63,4 +63,4 @@ See also: [JuliaHub corporate blog](https://juliahub.com/blog), [French communit You can engage in the discussion of this newsletter on [Discourse](https://discourse.julialang.org/c/community/news/66) -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 (occassionaly with only minimal changes, sometimes with significant rewriting). Please be aware of the [Julia Discourse policy on Generative AI content](https://discourse.julialang.org/t/updates-to-the-site-guidelines-especially-regarding-gen-ai/134315). \ No newline at end of file +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 (occasionaly with only minimal changes, sometimes with significant rewriting). Please be aware of the [Julia Discourse policy on Generative AI content](https://discourse.julialang.org/t/updates-to-the-site-guidelines-especially-regarding-gen-ai/134315). \ No newline at end of file From fb259b3f9bd6a1d5412100a8c2f53d87ddd2f005 Mon Sep 17 00:00:00 2001 From: Stefan Krastanov Date: Sat, 10 Jan 2026 05:26:24 -0500 Subject: [PATCH 3/7] fixup --- blog/2026/01/this-month-in-julia-world.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/blog/2026/01/this-month-in-julia-world.md b/blog/2026/01/this-month-in-julia-world.md index d000241e74..9bc7caa0f1 100644 --- a/blog/2026/01/this-month-in-julia-world.md +++ b/blog/2026/01/this-month-in-julia-world.md @@ -63,4 +63,4 @@ See also: [JuliaHub corporate blog](https://juliahub.com/blog), [French communit You can engage in the discussion of this newsletter on [Discourse](https://discourse.julialang.org/c/community/news/66) -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 (occasionaly with only minimal changes, sometimes with significant rewriting). Please be aware of the [Julia Discourse policy on Generative AI content](https://discourse.julialang.org/t/updates-to-the-site-guidelines-especially-regarding-gen-ai/134315). \ No newline at end of file +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](https://discourse.julialang.org/t/updates-to-the-site-guidelines-especially-regarding-gen-ai/134315). \ No newline at end of file From 82078227a7c8ae46a1c84cf28480b05e24daa2ff Mon Sep 17 00:00:00 2001 From: Stefan Krastanov Date: Sat, 10 Jan 2026 05:30:16 -0500 Subject: [PATCH 4/7] fixup --- blog/2026/01/this-month-in-julia-world.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/blog/2026/01/this-month-in-julia-world.md b/blog/2026/01/this-month-in-julia-world.md index 9bc7caa0f1..93d16f606a 100644 --- a/blog/2026/01/this-month-in-julia-world.md +++ b/blog/2026/01/this-month-in-julia-world.md @@ -13,7 +13,7 @@ For recent news on Julia and interesting conversations with community members, c 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 "Internals" Fora and Core Repos (Slack/Zulip/Discourse/Github): -- [Revise.jl 3.13 has been released](https://discourse.julialang.org/t/ann-revise-jl-v3-13-struct-revision-support/134818), 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 permitted redefinition of structs (by tracking and invalidating them similarly to how method invalidation happens). +- [Revise.jl 3.13 has been released](https://discourse.julialang.org/t/ann-revise-jl-v3-13-struct-revision-support/134818), 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](https://github.com/JuliaLang/julia/pull/60478) instances, and made a series of PRs to fix the [inference issues caused by such instances](https://docs.julialang.org/en/v1/manual/performance-tips/#man-performance-captured) in Base and stdlibs [[1](https://github.com/JuliaLang/julia/pull/60490), [2](https://github.com/JuliaLang/julia/pull/60514), [3](https://github.com/JuliaLang/julia/pull/60515), [4](https://github.com/JuliaLang/Pkg.jl/pull/4582), [5](https://github.com/JuliaLang/StyledStrings.jl/pull/130), [6](https://github.com/JuliaLang/Downloads.jl/pull/285), [7](https://github.com/JuliaIO/Tar.jl/pull/189), [8](https://github.com/JuliaLang/julia/pull/60547)]. You [can also use this script](https://github.com/JuliaLang/julia/issues/60479) 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 you the type of the object can change at any time. - A [prototype was PR'd to Base](https://github.com/JuliaLang/julia/pull/60344) which allows users to give early feedback to [a proposal for `match` statements in Julia](https://gist.github.com/Keno/e08874a423e0f1df4d11a798c7ed147c). And a new syntax for [declared exceptions](https://gist.github.com/Keno/7d1fb27a003afba6de50686ccfbb6610). Declared exceptions have been discussed previously as [chain-of-custody error handling](https://github.com/JuliaLang/julia/issues/7026). 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](https://github.com/JuliaLang/julia/pull/60311), which split a [full memory fence](https://docs.julialang.org/en/v1/base/multi-threading/#Base.Threads.atomic_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. From 4b68755b26e6cc4008ceb18ddbe5807d0067e86d Mon Sep 17 00:00:00 2001 From: Stefan Krastanov Date: Sat, 10 Jan 2026 05:31:15 -0500 Subject: [PATCH 5/7] fixup --- blog/2026/01/this-month-in-julia-world.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/blog/2026/01/this-month-in-julia-world.md b/blog/2026/01/this-month-in-julia-world.md index 93d16f606a..752b6490cc 100644 --- a/blog/2026/01/this-month-in-julia-world.md +++ b/blog/2026/01/this-month-in-julia-world.md @@ -14,7 +14,7 @@ Current status: Julia release is 1.12.4, Julia LTS is 1.10.10. The feature freez "Internals" Fora and Core Repos (Slack/Zulip/Discourse/Github): - [Revise.jl 3.13 has been released](https://discourse.julialang.org/t/ann-revise-jl-v3-13-struct-revision-support/134818), 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](https://github.com/JuliaLang/julia/pull/60478) instances, and made a series of PRs to fix the [inference issues caused by such instances](https://docs.julialang.org/en/v1/manual/performance-tips/#man-performance-captured) in Base and stdlibs [[1](https://github.com/JuliaLang/julia/pull/60490), [2](https://github.com/JuliaLang/julia/pull/60514), [3](https://github.com/JuliaLang/julia/pull/60515), [4](https://github.com/JuliaLang/Pkg.jl/pull/4582), [5](https://github.com/JuliaLang/StyledStrings.jl/pull/130), [6](https://github.com/JuliaLang/Downloads.jl/pull/285), [7](https://github.com/JuliaIO/Tar.jl/pull/189), [8](https://github.com/JuliaLang/julia/pull/60547)]. You [can also use this script](https://github.com/JuliaLang/julia/issues/60479) 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 you the type of the object can change at any time. +- Kristoffer Carlsson has [created a script to find Core.Box](https://github.com/JuliaLang/julia/pull/60478) instances, and made a series of PRs to fix the [inference issues caused by such instances](https://docs.julialang.org/en/v1/manual/performance-tips/#man-performance-captured) in Base and stdlibs [[1](https://github.com/JuliaLang/julia/pull/60490), [2](https://github.com/JuliaLang/julia/pull/60514), [3](https://github.com/JuliaLang/julia/pull/60515), [4](https://github.com/JuliaLang/Pkg.jl/pull/4582), [5](https://github.com/JuliaLang/StyledStrings.jl/pull/130), [6](https://github.com/JuliaLang/Downloads.jl/pull/285), [7](https://github.com/JuliaIO/Tar.jl/pull/189), [8](https://github.com/JuliaLang/julia/pull/60547)]. You [can also use this script](https://github.com/JuliaLang/julia/issues/60479) 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](https://github.com/JuliaLang/julia/pull/60344) which allows users to give early feedback to [a proposal for `match` statements in Julia](https://gist.github.com/Keno/e08874a423e0f1df4d11a798c7ed147c). And a new syntax for [declared exceptions](https://gist.github.com/Keno/7d1fb27a003afba6de50686ccfbb6610). Declared exceptions have been discussed previously as [chain-of-custody error handling](https://github.com/JuliaLang/julia/issues/7026). 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](https://github.com/JuliaLang/julia/pull/60311), which split a [full memory fence](https://docs.julialang.org/en/v1/base/multi-threading/#Base.Threads.atomic_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](https://github.com/JuliaLang/julia/pull/60281) 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. From 95531060305889f0050afa3d6a06c9bd7b83a219 Mon Sep 17 00:00:00 2001 From: Stefan Krastanov Date: Sat, 10 Jan 2026 05:51:35 -0500 Subject: [PATCH 6/7] fixup --- blog/2026/01/this-month-in-julia-world.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/blog/2026/01/this-month-in-julia-world.md b/blog/2026/01/this-month-in-julia-world.md index 752b6490cc..cb5873cb57 100644 --- a/blog/2026/01/this-month-in-julia-world.md +++ b/blog/2026/01/this-month-in-julia-world.md @@ -30,7 +30,7 @@ Current status: Julia release is 1.12.4, Julia LTS is 1.10.10. The feature freez - Test macros in Base.Test are becoming more consistent, with [support for `broken=`, `skip=`, and `context=` keywords](https://github.com/JuliaLang/julia/pull/60543) 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](https://github.com/JuliaLang/julia/pull/60400) 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](https://github.com/JuliaLang/julia/pull/60320) 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](https://github.com/JuliaLang/julia/pull/60403) by forcing specialization on a key parsing function, demonstrating how careful attention to compiler specialization decisions can improve performance even in already-fast code. +- [JuliaSyntax received a performance optimization](https://github.com/JuliaLang/julia/pull/60403) 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. Ecosystem Fora, Maintenance, and Colab Promises (Slack/Zulip/Discourse/Github): From 9a5cb353d48657b7504849417b1345473b9e414c Mon Sep 17 00:00:00 2001 From: Stefan Krastanov Date: Sat, 10 Jan 2026 05:58:55 -0500 Subject: [PATCH 7/7] reorder --- blog/2026/01/this-month-in-julia-world.md | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/blog/2026/01/this-month-in-julia-world.md b/blog/2026/01/this-month-in-julia-world.md index cb5873cb57..0e9c3205dd 100644 --- a/blog/2026/01/this-month-in-julia-world.md +++ b/blog/2026/01/this-month-in-julia-world.md @@ -38,6 +38,7 @@ Ecosystem Fora, Maintenance, and Colab Promises (Slack/Zulip/Discourse/Github): - [BorrowChecker.jl](https://github.com/MilesCranmer/BorrowChecker.jl/pull/34) 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](https://github.com/StefanKarpinski/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](https://hackmd.io/@HLLoverRSA). - A helpful [article on world age for beginners](https://discourse.julialang.org/t/world-age-for-beginners-one-way-to-compile-a-dynamic-language/134402) 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](https://discourse.julialang.org/t/new-julia-for-jetbrains-ides-flexible-julia/134658) 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](https://numfocus.org/programs/small-development-grants). They will be using the funds for [several improvements across the JuliaHealth ecosystem](https://github.com/numfocus/small-development-grant-proposals/issues/59). 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](https://github.com/JuliaCon/proceedings-review/issues/193#issue-3731067441) for their JuliaCon Proceedings extended abstract paper about their emerging ecosystem. - A [discussion has emerged](https://discourse.julialang.org/t/adopt-the-sciml-style-guide-for-julia-base-and-standard-library/134845) 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. @@ -46,7 +47,6 @@ Ecosystem Fora, Maintenance, and Colab Promises (Slack/Zulip/Discourse/Github): - [PkgTemplatesShikiPlugin.jl](https://discourse.julialang.org/t/ann-pkgtemplatesshikiplugin-jl-add-shikistyle-syntax-highlighting-presenting-at-julialang-japan-2025-dec-13/134487) 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](https://discourse.julialang.org/t/ann-desmos-jl/134734) 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](https://discourse.julialang.org/t/ann-breakout-jl-a-simple-breakout-clone-for-fun-and-reinforcement-learning-on-internal-game-state/134872) 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. -- [Flexible Julia](https://discourse.julialang.org/t/new-julia-for-jetbrains-ides-flexible-julia/134658) 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. - A [curated list of GitHub Actions](https://discourse.julialang.org/t/a-curated-list-of-gh-actions-that-improve-the-quality-of-your-package/134466) 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](https://discourse.julialang.org/t/reflections-on-developer-experience-after-building-a-large-julia-codebase/134732), 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](https://discourse.julialang.org/t/ann-lit-jl-a-simple-data-centric-web-app-framework-for-julia/134855) 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. @@ -55,10 +55,6 @@ Ecosystem Fora, Maintenance, and Colab Promises (Slack/Zulip/Discourse/Github): - A [self-contained juliac demonstration](https://discourse.julialang.org/t/self-contained-juliac-demonstration/134366) 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](https://discourse.julialang.org/t/ann-solarposition-jl/134263) 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. -Notes from other ecosystems: - -- A blog post discusses [how npm lacks a minimum release age security feature](https://www.pcloadletter.dev/blog/npm-min-release-age/) that other package managers like pnpm and yarn have implemented. The feature would delay installation of newly published packages, giving time for the community to identify malicious packages before they're widely adopted. While npm has a `--before` flag that technically allows filtering by relative dates, it lacks proper documentation as a security feature and misses allowlist mechanisms for trusted internal packages. This highlights an important security consideration for all package ecosystems. - See also: [JuliaHub corporate blog](https://juliahub.com/blog), [French community newsletter](https://pnavaro.github.io/NouvellesJulia/), [community calendar](https://julialang.org/community/#events), [Turing.jl newsletter](https://github.com/TuringLang/Turing.jl/issues/2498) You can engage in the discussion of this newsletter on [Discourse](https://discourse.julialang.org/c/community/news/66)