This month in Julia world - 2026-02

Community Newsletter
1

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.

Current status: Julia release is 1.12.5, 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):

  • Julia now supports mutually recursive types. 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. The creation of the PR implementing it was mentioned in the December issue of this newsletter. That PR has been merged now.
  • Undefined behaviour (UB) in Julia is now documented better. UB occurs when a program does something which the programming language assumes never happens. This often leads to miscompilations and the resulting program behaving in unintended ways. Having explicit documentation of what constitutes UB in Julia helps both users avoid it and compiler developers reason about valid optimizations.
  • The compiler now better propagates type information from one variable to its aliases, a feature named MustAlias analysis. This means, for example, that it understands that loading a field of an immutable struct always results in a value of the same type. A recent PR extends this analysis inter-procedurally, enabling alias-aware union splitting when a base object and its field are both passed to a callee. This has been implemented over several PRs [1, 2, 3, 4, 5], with one of these PRs being in the works for more than three years.
  • Default constructor generation has been moved from C/flisp to Julia. When you define a struct in Julia, the compiler automatically generates default constructor methods. This code generation was previously handled in C and flisp (the Scheme dialect used in Julia’s bootstrap process), but has now been rewritten in Julia itself. This is preparatory work for a flisp-free bootstrap using JuliaLowering, which was covered in previous issues of this newsletter.
  • A work-in-progress PR enables running package precompilation as a background task with keyboard controls. Users would be able to detach from precompilation (letting it continue silently) and reattach later. Keyboard shortcuts include ‘c’ to cancel, ‘d’ to detach, ‘i’ for profile peeking, and ‘v’ for verbose worker stats. This would be a significant quality-of-life improvement for developers working with packages that have long precompilation times.
  • A PR refactors the shared memory API in the Mmap stdlib to provide a consistent cross-platform interface. The current implementation has long-standing issues on Windows, where SharedArray tests would sporadically fail due to handles not being closed promptly and name collisions from a reseeded RNG. The new Mmap.SharedMemory type provides a unified open/close interface across Linux and Windows, fixing these reliability issues.
  • Three new functions for the strided array interface have been proposed: try_strides (like strides but returns nothing for non-strided arrays instead of erroring), can_ptr_load, and can_ptr_store. These provide safer ways to query whether an array supports pointer-based access, which is important for writing generic code that works with both standard arrays and custom array types.
  • A new PR adds Test.test_call, an overloadable function that lets specific predicates provide extra context when @test fails. For example, @test success(cmd) would now report the exit code and termination signal of the failing process rather than just showing false.
  • A PR aims to improve the performance of depth-limited type printing, which matters for display of deeply nested types in error messages and the REPL.
  • A proposal for a generalized metadata system for function arguments would benefit non-native compilers like GPUCompiler.jl, which need to attach annotations to arguments for GPU code generation.
  • Documentation for control flow statements break, @label, and continue has been significantly expanded.

In search of contributors and new maintainers:

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

  • JETLS, a new language server for Julia built on top of the compiler’s own type inference, is generating significant excitement in the community. Unlike the existing LanguageServer.jl, JETLS provides compiler-powered diagnostics with real-time error detection. A core team member indicated it will become integrated by default in IDEs such as VS Code before JuliaCon. It currently requires Julia 1.12+ and has some false positives, but represents a major step forward for Julia’s developer tooling.
  • Flexible Julia is a new ground-up Julia plugin for JetBrains IDEs, providing Julia support across the entire JetBrains ecosystem (PyCharm, IntelliJ, CLion, etc.) via the Language Server Protocol.
  • RayMakie is a new Makie rendering backend that ports the pbrt-v4 ray tracer to pure Julia. It provides GPU-accelerated physically-based ray tracing with support for advanced effects like volumetric clouds, depth of field, and gravitational lensing. The developer noted how mature Julia’s GPU stack has become, making it possible to write a full ray tracer that reaches performance comparable to established tools. RayMakie replaces the earlier RPRMakie backend. RayMakie supports most GPU hardware, not just CUDA.
  • Tachikoma.jl is a terminal UI framework with an Elm-inspired architecture, 60fps event loop, and over 30 composable widgets including code editors with syntax highlighting, data tables, tree views, and chart components. It supports constraint-based layouts with draggable resizable panes, multiple rendering backends (Braille, quadrant blocks, Kitty/sixel pixel rendering), and built-in recording to SVG/GIF. Comparable to Python’s Textual, Rust’s Ratatui, or Go’s Bubbletea.
  • A discussion about the Julia development experience highlights pain points around breaking changes (in Julia internals) in minor releases, precompilation times, and developer tooling gaps. Worth reading for anyone interested in the practical challenges of maintaining Julia packages that depend on Julia internals.
  • RunBinary.jl is now compatible with Julia 1.12’s new “apps” feature. After installing it as a Julia app, you can run any JLL binary directly from your terminal (e.g., runbinary ImageMagick.convert input.png output.jpg), providing a convenient way to use the thousands of prebuilt binaries available through Yggdrasil without managing individual packages.
  • The Julia registry maintainers announced they consider no longer accepting manual JLL packages in the General registry. JLL packages distribute prebuilt binary artifacts (compiled libraries, executables, etc.), and going forward it would be nice if all are built through Yggdrasil, the community build tree, to centralize review and ensure traceability of binary provenance. Only about 11 manual JLLs currently exist, and exceptions for proprietary software are being discussed. The main reason behind these considerations is provenance tracking for reporting security issues.
  • Ark v0.4 has been released. Ark is an archetype-based Entity Component System (ECS) for Julia, a software pattern commonly used in game development and simulations. This release introduces GPU-accelerated simulations via GPUVector and GPUStructArray component storages (supporting CUDA, Metal, oneAPI, and OpenCL backends), user-defined component storage, and parallel query execution. Benchmarks show the GPU backend running approximately 20x faster than CPU counterparts on certain workloads.
  • Open Reality is a code-first game engine written entirely in Julia, inspired by Apple’s RealityKit. It features an ECS architecture, multiple rendering backends (OpenGL, Metal, Vulkan, WebGPU), physically-based rendering with deferred shading, skeletal animation, 3D positional audio, and physics collision detection. A key advantage over engines like Unity or Godot is zero marshaling overhead—since both game logic and engine are in Julia, there are no FFI performance penalties. WASM exports clock in at a compact 400 KB compared to Unity’s 200+ MB.
  • KernelForge.jl provides high-level GPU primitives (mapreduce, scan, matvec, search) with performance matching vendor-optimized libraries like cuBLAS and CUB. Unlike alternatives, it supports arbitrary isbitstype structs, custom operators, and non-contiguous array views rather than being limited to simple numeric types. Currently CUDA-only with plans for AMD and Intel GPU support.
  • PrettyTables.jl now has a Typst backend. When combined with Typstry.jl in VS Code, tables printed to stdout are rendered visually in real time. The backend supports multi-level column labels, row grouping, summary rows, footnotes, and custom highlighting.
  • CodeComplexity.jl measures cyclomatic complexity of Julia code—a metric that counts decision points (branches, loops, exception handling) to quantify code understandability. It can analyze expressions, files, directories, or entire packages, and includes a check_complexity() function for CI integration to enforce maximum complexity thresholds.
  • The MIT course book Parallel Computing and Scientific Machine Learning is freely available online. It covers the intersection of high-performance computing and scientific ML using Julia, including automatic differentiation, differential equations, GPU computing, and distributed programming.
  • HAdaptiveIntegration.jl v1.0.0 provides adaptive numerical integration over multidimensional domains including simplices (triangles, tetrahedra) and orthotopes (rectangles, cuboids) in any dimension. It improves upon HCubature.jl by supporting simplices of any dimension and using more efficient tabulated cubature rules for low-dimensional cases, while supporting arbitrary precision arithmetic.

See also: JuliaHub corporate blog, French community newsletter, community calendar, Turing.jl newsletter

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

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

Disclaimer: An LLM was used to convert the initial human-curated list of interesting links into narrative bullet points. I (the human editor) then used these first bullet point drafts to flesh them out into their current state, occasionally with significant rewriting, occasionally verbatim reusing them. Please be aware of the Julia Discourse policy on Generative AI content.

25 Likes
2

I think “via the Language Server Protocol” is misleading. While Flexible Julia can be used with JETLS or the old language server, it can also be used without them and still retain much of its functionality.

1 Like