This Month in Julia World

# This Month in Julia World # Directions on helping with contributions for the newsletter: - First, thanks for helping\! - Just follow the already existing formatting. Please do not paste raw links, rather use formatted text with hyperlinks (they will get automatically converted to markdown when posting). - When linking, do not use the style “you can register [here](#)” rather use “you [can register](#)”. Another example: Bad: “see the package [here](#)” | Good: “see the [package](#)” - If there are a ton of related links, just use a citation style like “\[[1](#), [2](#), [3](#)\]” or “\[[pr](#), [discourse](#), [slack](#)\]” - **Do not add links to package repositories unless there is something new happening.** If you want to post about your own package that has existed for a while, please first make a discourse post about it, and link to that discourse post, so that there is some context and a venue for discussion. --- # 2026-01 - DRAFT 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): - In search of contributors and new maintainers: - Ecosystem Fora, Maintenance, and Colab Promises (Slack/Zulip/Discourse/Github): - Numerical Math ecosystem: - Mathematical Optimization ecosystem: - Autodiff ecosystem: - Notes from other 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) Please feel free to post below with your own interesting finds, or in-depth explanations, or questions about these developments. If you would like to help with the draft for next month, please drop your **short**, **well formatted**, **linked** notes in [this shared document](https://hackmd.io/@stefan/Hk9CHPzMbe/edit). Some of it might survive by the time of posting 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). --- # 2025-12 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 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 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`. - 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) 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. 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): - [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. - [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. - [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. - 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. 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) Please feel free to post below with your own interesting finds, or in-depth explanations, or questions about these developments. If you would like to help with the draft for next month, please drop your **short**, **well formatted**, **linked** notes in [this shared document](https://hackmd.io/@stefan/Hk9CHPzMbe/edit). Some of it might survive by the time of posting 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). # 2025-11 skipped from this doc # 2025-10 A monthly newsletter, mostly on julia internals, digestible for casual observers. A biased, incomplete, editorialized list of what a clique of us found interesting this month, with contributions from the community. For recent news on Julia and interesting conversations with community members, check out the [JuliaDispatch](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. JuliaCon Global 2025 and JuliaCon Paris 2025 videos are continuously being released on the [Julia youtube channel](https://www.youtube.com/@TheJuliaLanguage/playlists). “Internals” Fora and Core Repos (Slack/Zulip/Discourse/Github): - [JET 0.11 is now released](https://discourse.julialang.org/t/ann-jet-v0-11/133366) – the main static analysis/testing tool in Julia. A lot of small niceties in the user facing API related to filtering analysis steps and reports, but also substantial internal work and simplification, providing momentum for future work. - A mechanism for introducing [breaking changes to Julia syntax without breaking old packages](https://github.com/JuliaLang/julia/pull/60018) is being discussed, not too dissimilar to Rust Editions. - Pkg now [supports the notion of a “deprecated” package](https://github.com/JuliaLang/Pkg.jl/pull/4433) (for which there will be a warning printed on installation). Such metadata is stored per registry. Here is an example of [use in the General package registry](https://github.com/JuliaRegistries/General/pull/141098). - Pkg will soon [support “portable scripts”](https://github.com/JuliaLang/Pkg.jl/pull/4479), i.e. Julia scripts that embed their Project.toml and Manifest.toml in comments. Here are the related changes in [Julia](https://github.com/JuliaLang/julia/pull/59982) itself. - Pkg will soon [support “downgrading”](https://github.com/JuliaLang/Pkg.jl/pull/4477), i.e. pushing the installed dependencies to the lowest compatible version. There have been various hacks to do this, but now with a much nicer user experience and stability. Relatedly, there is more and more work on integrating the new [SAT resolver in Pkg](https://github.com/JuliaLang/Pkg.jl/pull/4336), enabling even more sophisticated compat bound resolutions. - Pkg will soon be [usable as a command line app](https://github.com/JuliaLang/Pkg.jl/pull/4473), similarly to how pip/uv/cargo are used from the CLI, not from inside of a REPL. - [JuliaSyntax & JuliaLowering](https://github.com/JuliaLang/julia/pull/59870) are moving to the core julia repo to encourage more testing of these more more introspectable implementations of the julia parsing and lowering passes. JuliaSyntax has been in use for a while, but JuliaLowering is only now maturing. These are the passes that turn the text files of julia code into a clean datastructure that the compiler can understand, analyze, optimize, and finally compile into machine code. Much of the dev tooling like Cthulhu and Revise would become easier to use thanks to them. - Work on moving julia to [LLVM v21](https://github.com/JuliaLang/julia/pull/59950) has now started. - An incredibly powerful REPL history explorer was recently merged. Further work on [showing more metadata](https://github.com/JuliaLang/julia/pull/59953) is underway. In search of contributors and new maintainers (specify novice/moderate/expert and internals/domain background necessary): - [Contribute test cases to improve LLM performance on Julia code](https://discourse.julialang.org/t/help-wanted-help-contribute-test-cases-to-improve-llm-performance-on-julia-code/132991/) - [JuliaPackageComparisons](https://discourse.julialang.org/t/juliapackagecomparisons-is-looking-for-a-new-maintainer/130667) is a wiki-like resource comparing different julia tools. It is in search of a new maintainer. - [PyAMG.jl](https://github.com/cortner/PyAMG.jl) is looking for a new organisation or maintainer. Ecosystem Fora, Maintenance, and Colab Promises (Slack/Zulip/Discourse/Github): - [Swirl.jl](https://discourse.julialang.org/t/swirl-jl-interactive-julia-learning-in-the-repl/133705) is a fantastic “interactive lessons in the Julia REPL” package, inspired by the swirl package in R. - [SnakeBar.jl](https://discourse.julialang.org/t/ann-snakebar-jl-a-progress-bar-that-fills-your-terminal-with-space-filling-curves/133580) is the best progress bar you might want to use in your julia apps. - Julia-Rust interoperability is enabled by [jlrs](https://discourse.julialang.org/t/ann-jlrs-0-22-julia-version-autodetection-async-closure-support-and-more/133073) which had a recent new feature rich release. - [MuxDisplay.jl](https://discourse.julialang.org/t/ann-muxdisplay-using-multiplexer-panes-tmux-wezterm-to-show-graphics/132998) for multiplexing Julia REPL output in terminal multiplexer panes like tmux and western. - [BonitoBook.jl](https://discourse.julialang.org/t/ann-bonitobook-update-plugin-system-language-extensions-simplified-styling/133113), an alternative reactive notebook interface for Julia (and others), is getting a significant new release with many exciting features. BonitoBook is built around the same ecosystem that enables Makie plots in the browser. - [AdditionalDistributions.jl](https://discourse.julialang.org/t/ann-additionaldistributions-jl-extending-distributions-jl-with-advanced-probability-models/133531) provides a wide range of statistical distributions following the Distributions.jl API, but enabling much faster development and exploration for more esoteric distributions. - [MakieTypstEngine.jl](https://discourse.julialang.org/t/makietypstengine-jl-a-proof-of-concept-for-rendering-typst-strings-in-makie/133523) is a proof of concept for rendering Typst marked up strings in Makie. Typist is a recent alternative to the LaTeX ecosystem. - [TerminalPager.jl](https://discourse.julialang.org/t/ann-terminalpager-jl-repl-inline-help-added/133131) has a new release, enabling more pleasant use of the built-in help browser in the REPL. - Using Julia to [optimize and visualize a nuclear magnetic resonance control pulse](https://cncastillo.github.io/BlochHole/posts/julia-logo-rf-design/spins_draw_the_julia_logo.html), to draw Julia’s logo with an MRI machine. - A helpful “blog style” post on [common beginner misconceptions in Julia](https://discourse.julialang.org/t/clearing-up-common-beginner-misconceptions/133404). Notes from other ecosystems: - Rust has been working tirelessly on providing good [SIMD abstractions](https://shnatsel.medium.com/the-state-of-simd-in-rust-in-2025-32c263e5f53d) in the language. Events: - An independent [Julia conference is happening in Japan in December](https://discourse.julialang.org/t/julialang-japan-2025-sat-dec-13-2025-tokyo/133259). 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) Please feel free to post below with your own interesting finds, or in-depth explanations, or questions about these developments. If you would like to help with the draft for next month, please drop your **\*\*short\*\***, **\*\*well formatted\*\***, **\*\*linked\*\*** notes in [this shared document](https://hackmd.io/@stefan/Hk9CHPzMbe/edit). Some of it might survive by the time of posting # 2025-09 A monthly newsletter, mostly on julia internals, digestible for casual observers. A biased, incomplete, editorialized list of what a clique of us found interesting this month, with contributions from the community. For recent news on Julia and interesting conversations with community members, check out the [JuliaDispatch](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. [Properly cut JuliaCon 2025 videos are being released on youtube.](https://discourse.julialang.org/t/juliacon-global-2025-videos-will-start-releasing-today/132454) [JuliaCon 2026 will happen from August 10th to August 15th 2026 in Germany](https://discourse.julialang.org/t/juliacon-2026-save-the-date/132172). “Internals” Fora and Core Repos (Slack/Zulip/Discourse/Github): - [JuliaLowering.jl](http://github.com/c42f/JuliaLowering.jl/pull/93) has been seeing a flurry of activity in the last couple of months. Julia has a syntactic pass that parses text into an abstract syntax tree and a lowering pass that takes care of macros and desugaring. Historically this was done in lisp, leading to difficulty with introspection and tooling like Revise.jl, also making macros harder to debug. JuliaSyntax.jl reimplemented the parser in pure Julia and JuliaLowering.jl is the final piece of the puzzle, implementing all of the “lowering” in Julia itself. The link above is to one of many improvements from the last few weeks, this one in particular focusing on simplifying and more neatly organizing the lowering logic. - Julia is on track to have the fanciest REPL history search in the land with [recent proposed changes](https://github.com/JuliaLang/julia/pull/59819). - TypedCallable, is a [proposal](https://github.com/JuliaLang/julia/issues/59774) for better supporting optimized calls to runtime-known functions with compile-time known arguments. The underlying goal is to better support closures, especially with ahead-of-time compilation to binaries. - Julia supports [Unicode 17 now](https://github.com/JuliaLang/julia/pull/59534). Julia programmers have long lamented that Unicode does not support proper latin alphabet superscripts for all letters. [Small superscript q is supported now though](http://github.com/JuliaLang/julia/pull/59544). See [this wiki page](https://en.wikipedia.org/wiki/Unicode_subscripts_and_superscripts#Latin,_Greek,_Cyrillic,_and_IPA_tables) for a full list of unicode sub/super script characters. - `Base.Cartesian` is now a [public part of the Julia API](https://github.com/JuliaLang/julia/pull/59459). - PSA: Given that there is no type filtering capabilities in julia’s `try`, [it is important to not forget to use `rethrow()`](https://github.com/JuliaLang/julia/pull/59729/files). - The `:greedy` scheduler now [better prioritizes having work for all threads](https://github.com/JuliaLang/julia/pull/59515). - Do not use `Base.get\_extension` in library code, as it can wreak havoc on precompilation. Appropriate [solution discussed in this PR](https://github.com/JuliaLang/julia/pull/59593). - Cleaning up some (unsafe) [constructor functions](https://github.com/JuliaLang/julia/pull/59663) for strings and substrings. In search of contributors and new maintainers (specify novice/moderate/expert and internals/domain background necessary): - The [Graphs.jl](http://Graphs.jl) repo features a few bounties on [integrating external graph theory libraries](https://github.com/JuliaGraphs/Graphs.jl/issues?q=is%3Aissue%20state%3Aopen%20label%3Abounty) better with the rest of the Graphs ecosystem. - [JuliaPackageComparisons](https://discourse.julialang.org/t/juliapackagecomparisons-is-looking-for-a-new-maintainer/130667) is a wiki-like resource comparing different julia tools. It is in search of a new maintainer. - The Center for Quantum Networks is running [many bounties and minigrants](https://github.com/QuantumSavory/.github/blob/main/BUG_BOUNTIES.md) on a variety of support packages for quantum information science. - [SciML is running a large set of funded small projects](https://sciml.ai/small_grants/) – a great opportunity to contribute to the community and be paid for it. Ecosystem Fora, Maintenance, and Colab Promises (Slack/Zulip/Discourse/Github): - [Many improvements to the PythonCall ecosystem](https://discourse.julialang.org/t/pythoncall-ecosystem-updates/132500) for integration (in both directions) between Julia and Python. - JSON.jl had a breaking release with many improvements. It comes with [a fantastic migration guide](https://juliaio.github.io/JSON.jl/stable/migrate/#Migration-guides). - [Bonito.jl](https://discourse.julialang.org/t/ann-bonito-jl/132946) has existed for a while as a wonderful way to have reactive web pages written in Julia, but now there is a proper announcement after steady small improvements for many years. - [SymBoltz.jl](https://discourse.julialang.org/t/ann-symboltz-jl-a-symbolic-numeric-approximation-free-and-differentiable-linear-einstein-boltzmann-solver-for-cosmology/132819) – a very impressive showcase of the capabilities of ModelingToolkit.jl, a symbolic-numeric, approximation-free and differentiable linear Einstein-Boltzmann solver for cosmology - [AccessibleModels.jl](https://discourse.julialang.org/t/accessiblemodels-jl-automatic-ui-and-model-fitting-for-arbitrary-objects/132363): Automatic UI and Model Fitting for Arbitrary Objects - [MoleculeHub](https://discourse.julialang.org/t/ann-moleculehub-a-set-of-cheminformatics-tools-in-julia/132415): A set of cheminformatics tools in Julia - [Durbyn.jl](https://discourse.julialang.org/t/ann-durbyn-jl-time-series-forecasting-in-julia/132544): Time Series Forecasting in Julia - [PlutoBook.jl](https://discourse.julialang.org/t/ann-new-package-plutobook-jl/132641) wraps around the C++ library PlutoBook for lightweight converter between html and pdf. (no relationship to [Pluto.jl](http://Pluto.jl)) - [NoSleep.jl](https://discourse.julialang.org/t/nosleep-jl-keep-julia-awake-for-long-calculations/132911): Keep Julia awake for long calculations - [WebAuthn.jl](https://discourse.julialang.org/t/ann-webauthn-jl/132672): WebAuthn enables passwordless, phishing-resistant login using public-key cryptography. See also: [French community newsletter](https://pnavaro.github.io/NouvellesJulia/), [community calendar](https://julialang.org/community/#events), [minutes of triage meetings](https://hackmd.io/@LilithHafner/HJaw__uMp), [Turing.jl newsletter](https://github.com/TuringLang/Turing.jl/issues/2498) Please feel free to post below with your own interesting finds, or in-depth explanations, or questions about these developments. If you would like to help with the draft for next month, please drop your **\*\*short\*\***, **\*\*well formatted\*\***, **\*\*linked\*\*** notes in [this shared document](https://docs.google.com/document/d/1Np1deH_W1o0EO7_tZkScveCLA0XiYg538ceUJs0bFpE/edit). Some of it might survive by the time of posting # 2025-08 A monthly newsletter, mostly on julia internals, digestible for casual observers. A biased, incomplete, editorialized list of what a clique of us found interesting this month, with contributions from the community. For recent news on Julia and interesting conversations with community members, check out the [JuliaDispatch](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. [JuliaCon 2026 will happen from August 10th to August 15th 2026 in Germany](https://discourse.julialang.org/t/juliacon-2026-save-the-date/132172). “Internals” Fora and Core Repos (Slack/Zulip/Discourse/Github): - A fun little example of how to properly “cast” from one type to another type in Julia. Calling `Int(x)` is not guaranteed to convert the instance x of some arbitrary type into an `Int`. Of course, only a sociopath would create a method `Int(::MyEvilType)` that does not return an `Int`, but nonetheless, the trick to protect yourself from such evil is to add a type assert like `Int(x)::Int` – now instead of being at risk of bad behavior and stack overflows due to poorly written user code, you get an early type assertion error. See this being recently suggested as a guardrail in some low level Julia code in [\#59506](https://github.com/JuliaLang/julia/pull/59506/files). - JuliaC, the ahead-of-time julia compiler is now living in its own [repo](https://github.com/JuliaLang/JuliaC.jl) and will be available as a Julia app. - `--trace-compile` is a very useful flag to learn why your package loads slowly and what `precompile` statements to add. There is an interesting interplay between type inference and the compiler, where the compiler might need to run a function (with actual runtime dispatch) in order to learn something about it – an event that does not happen during actual use of the compiled code. This can cause unnecessary precompile statements to be logged. PR [\#59366](https://github.com/JuliaLang/julia/pull/59366) marks such precompile statements, but consider perusing the comments in that PR to learn more about these intricacies. - Since early this year, Sam has been contributing significant improvements to Julia ergonomics. Looking from the sidelines, it seems like they hit the ground running with their first ever contribution (my favorite): a drastic simplification of the [REPL auto-completion implementation from a few months ago](https://github.com/JuliaLang/julia/pull/57767). Now they have a PR on [significantly reducing memory pressure during heavy compilation loads](https://github.com/JuliaLang/julia/pull/59348) (and [another reduction here](https://github.com/JuliaLang/julia/pull/59329)), and on [compressing the sysimage (cache of compiled code)](https://github.com/JuliaLang/julia/pull/59227) which drastically reduces its size (leading to a \~70% size reduction for untrimmed apps produced by PackageCompiler). - They are also contributing a much faster way to [enable Memory/Thread/AddressSanitizer compile passes in Julia](https://github.com/JuliaLang/julia/pull/59035). These tools can be used to detect and debug common safety, correctness, and performance issues. - Who knew that segfaults can be “fake” triggered by a signal, as opposed to by… an actual segmentation fault due to accessing memory you do not own? [PR \#59275 will warn about such segfaults](https://github.com/JuliaLang/julia/pull/59275), hopefully simplifying the debugging of messy nesting of runtimes from different languages. - Interesting [discussion on the word “functor”](https://github.com/JuliaLang/julia/pull/59414) and its minor historic use in the julia docs. - A few months ago Julia gained the capability to redefine structs (not just methods). Due to how this interacts with worldage (the mechanism for tracking what is the most recent definition of methods and structs), subtle changes to the `@testset` and `@allocated` macros was needed. Short version is that `@allocated` has always been a bit of a heuristic test and there are better alternatives to it if you are going to test for allocations in your package’s tests. See comments in [\#58780](https://github.com/JuliaLang/julia/issues/58780) for details. Also [\#58057](https://github.com/JuliaLang/julia/pull/58057) and [\#59278](https://github.com/JuliaLang/julia/pull/59278). - A common performance pitfall in julia is iterating over diversely typed array where the innermost part of the loop can not be type stable, leading to runtime dispatch of which function to call (basically a dictionary lookup for the appropriate function to call). Frequently discussed solutions are Algebraic Data Types (ADT), as implemented in Moshi.jl, LightSumTypes.jl, or SumTypes.jl. The Julia compiler also does the extra work to “union split” if the diversely typed array does not contain instances of “too many” different types. Here is a neat manual example of how to solve this type of problem without relying on general frameworks like ADTs: Lilith sped up the [hashing of julia abstract syntax trees by implementing a manual union split](https://github.com/JuliaLang/julia/pull/59378) (tree structures are another place that frequently has this type of issues). - An in-depth high-quality discussion by Jakob on [when and why you should use ScopedValues (a better nestable alternative of global variables) vs task-local storage (dedicated semi-temporary storage within a task, simplifying multithreading algorithms)](https://discourse.julialang.org/t/task-local-storage-and-scoped-values-what-they-are-used-for/132045). - [ScopedThunk](https://github.com/JuliaLang/julia/pull/59402) now permits you to take a snapshot of the state of scoped values (a more structured way to deal with global variables defining a context) and use that snapshot at a later time. - [LazyScopedValue](https://github.com/JuliaLang/julia/pull/59372) can be used to create a scoped value which lazily computes the actual value the first time it is requested, thus supporting reading the initial state of a scoped value from the environment. - [TestSets now use ScopedValues](https://github.com/JuliaLang/julia/pull/53462) for storing results, showcasing the simplicity ScopedValues provide when dealing with multiple tasks reading and writing in global storage. - Julia uses the general purpose platform-independent high-performance [rapidhash](https://github.com/Nicoshev/rapidhash) algorithm in much of its hashing utilities. There are recent improvements to internals related to it in PRs [\#59177](https://github.com/JuliaLang/julia/pull/59177) and [\#59185](https://github.com/JuliaLang/julia/pull/59185). - Much of the precompile logic in the julia compiler was moved from C code to a [pure-julia implementation](https://github.com/JuliaLang/julia/pull/59361). - Now you can send a signal to the Julia runtime to [trigger `--trace-compile` at an arbitrary time](https://github.com/JuliaLang/julia/pull/59424) without having requested it at the start of the process. Just send `SIGUSR1/SIGINFO1` (`ctrl+T` on many systems). - `[Iterators.findeach](https://github.com/JuliaLang/julia/pull/54124)` is a lazy version of `findall` that avoids allocating an array. - Another one of Lilith’s surprising drive-by performance optimization – an order of magnitude faster `prod(::AbstractArray{BigInt})` by more intelligently pre-allocating buffers for `BigInt` instances and traversing the array in a more efficient order. In [\#59456](https://github.com/JuliaLang/julia/pull/59456). - Neven has been working for quite a while on simplifying unnecessarily complicated method dispatch in `Base` (which also lowers the potential for method invalidation). See [“eliminate some nongeneric methods of `length` and `size`”](https://github.com/JuliaLang/julia/pull/59442), [“generic `size`: avoid method static parameters and abstract type assert”](https://github.com/JuliaLang/julia/pull/59465), [“avoid method proliferation for Tuple functions”](https://github.com/JuliaLang/julia/pull/59421), and many more. - Work on making [`@threads` work on array comprehensions](https://github.com/JuliaLang/julia/pull/59019). - A fun question on [weird type queries with UnionAll](https://discourse.julialang.org/t/determining-if-unionall-corresponds-to-a-single-type-union/132088). In search of contributors and new maintainers (specify novice/moderate/expert and internals/domain background necessary): - The [Graphs.jl](http://Graphs.jl) repo features a few bounties on [integrating external graph theory libraries](https://github.com/JuliaGraphs/Graphs.jl/issues?q=is%3Aissue%20state%3Aopen%20label%3Abounty) better with the rest of the Graphs ecosystem. - [JuliaPackageComparisons](https://discourse.julialang.org/t/juliapackagecomparisons-is-looking-for-a-new-maintainer/130667) is a wiki-like resource comparing different julia tools. It is in search of a new maintainer. - The Center for Quantum Networks is running [many bounties and minigrants](https://github.com/QuantumSavory/.github/blob/main/BUG_BOUNTIES.md) on a variety of support packages for quantum information science. - [SciML is running a large set of funded small projects](https://sciml.ai/small_grants/) – a great opportunity to contribute to the community and be paid for it. Ecosystem Fora, Maintenance, and Colab Promises (Slack/Zulip/Discourse/Github): - [Julia for Research Software Engineering](https://discourse.julialang.org/t/julia-for-research-software-engineering/131528) is a recent talk by Mosè and Valentin in a larger series on scientific software. - [BufIO.jl is a new low-level abstraction for input/output interfaces in Julia](https://discourse.julialang.org/t/ann-bufio-new-i-o-interfaces-for-julia/132347), created by Jakob after he spent a few years documenting many of the frustrations of the current Base IO. This is a very valuable prototype that can lead to much more robust buffer and stream interface for Julia. - [BonitoBook.jl](https://discourse.julialang.org/t/ann-bonitobook-jl/131442) is an interesting new take on reactive notebooks in the Julia ecosystem, with deep integration with Makie. - A short tutorial on how sum types (think Moshi/SumTypes/LightSumTypes) can be used to define dynamic C APIs that can be compiled with `--trim`, for elegant C interfaces to your Julia libraries. - [Introduction to Julia for R users](https://nrennie.rbind.io/blog/introduction-julia-r-users/) - [IJulia.jl 1.30 is released](https://discourse.julialang.org/t/ann-ijulia-1-30-0/131811), with significant usability improvements when running julia notebooks in Jupyter. - [LuaNova.jl](https://discourse.julialang.org/t/ann-luanova-jl-easy-lua-julia-integration/132324) released, providing easy Lua-Julia integration. - [Eyeball.jl](https://github.com/tshort/Eyeball.jl) is an interactive introspection tool for objects and types in julia. - [OneTimePasswords.jl](https://discourse.julialang.org/t/ann-onetimepasswords-jl/131679) provides a number of standard algorithms for working with single-use confirmation codes like TOTPs. - PrettyTables releases version 3 with significant new features (see [discourse](https://discourse.julialang.org/t/current-state-and-the-future-of-prettytables-jl/118455/143), [github](https://github.com/ronisbr/PrettyTables.jl/pull/259)) Numerical Math ecosystem: - [Implicit ODE Solvers Are Not Universally More Robust than Explicit ODE Solvers](https://www.stochasticlifestyle.com/implicit-ode-solvers-are-not-universally-more-robust-than-explicit-ode-solvers-or-why-no-ode-solver-is-best/) Mathematical Optimization ecosystem: - A series of [textbooks on algorithms for optimization, decision making, and more](https://algorithmsbook.com/), with heavy use of Julia, by Stanford’s Prof. Mykel J. Kochenderfer. - Disciplined Convex Programming is a family of techniques for propagating convexity information about the functions you are optimizing over. A few past and future [developments related to DCP in julia are discussed here](https://discourse.julialang.org/t/state-of-dcp-disciplined-convex-programming/131743). Autodiff ecosystem: - A question about [autodiff of FFTs in the julia ecosystem](https://discourse.julialang.org/t/which-direction-differentiatoninterface-enzyme-zygote-with-cuda-and-ffts/132225) led to an informative discussion of a few of the autodiff frameworks we have. Notes from other ecosystems: - A discussion about monomorphisation (the process of creating brand new specialized compiled function behind the scenes for each concrete type your runtime might face, i.e. one of the main features that makes julia fast), its relationship to boxed types, and its great compilation time cost, if it was to be added to [OCaml](https://discourse.julialang.org/t/why-can-julia-be-better-about-boxing-types-than-ocaml/131628). - A great primer on [how GPUs work and how to think about them](https://jax-ml.github.io/scaling-book/gpus/) from the JAX community. See also: [French community newsletter](https://pnavaro.github.io/NouvellesJulia/), [community calendar](https://julialang.org/community/#events), [minutes of triage meetings](https://hackmd.io/@LilithHafner/HJaw__uMp), [Turing.jl newsletter](https://github.com/TuringLang/Turing.jl/issues/2498) Please feel free to post below with your own interesting finds, or in-depth explanations, or questions about these developments. If you would like to help with the draft for next month, please drop your **\*\*short\*\***, **\*\*well formatted\*\***, **\*\*linked\*\*** notes in [this shared document](https://hackmd.io/@stefan/Hk9CHPzMbe/edit). Some of it might survive by the time of posting # older entries See https://docs.google.com/document/d/1Np1deH_W1o0EO7_tZkScveCLA0XiYg538ceUJs0bFpE/edit?tab=t.0

Syntax	Example	Reference
# Header	Header	基本排版
- Unordered List	Unordered List
1. Ordered List	Ordered List
- [ ] Todo List	Todo List
> Blockquote	Blockquote
Bold font	Bold font
Italics font	Italics font
~~Strikethrough~~	~~Strikethrough~~
19^th^	19^th
H~2~O	H₂O
++Inserted text++	Inserted text
==Marked text==	Marked text
[link text](https:// "title")	Link
![image alt](https:// "title")	Image
`Code`	`Code`	在筆記中貼入程式碼
```javascript var i = 0; ```	`var i = 0;`
:smile:		Emoji list
{%youtube youtube_id %}	Externals
$L^aT_eX$	L^aT_eX
:::info This is a alert area. :::	This is a alert area.