Julia 1.13 Release Marks Major Milestone in Performance and Developer Productivity

The Julia programming language community has officially announced the release of Julia version 1.13, a significant update that introduces substantial performance optimizations, enhanced developer tools, and refined internal systems. This release represents the culmination of months of collaborative effort between core developers and the global contributor community, focusing on reducing latency, improving the package management experience, and streamlining the garbage collection process. The development team has expressed gratitude to the numerous contributors and testers whose feedback during the pre-release phase proved instrumental in identifying regressions and ensuring the stability of the final build.

Background and Development Context

Julia, originally developed at MIT and first released to the public in 2012, was designed to solve the "two-language problem"—the need to prototype in a high-level language like Python or R and then rewrite performance-critical sections in C++ or Fortran. Since its 1.0 release in 2018, the language has seen a steady cadence of updates within the 1.x stable series.

The path to version 1.13 has been defined by a data-driven approach to optimization. Developers utilized the "Julia-TTFX-Snippets" repository, a community-driven collection of real-world code examples, to measure and minimize "Time To First X" (TTFX). This metric tracks the duration from starting the Julia process to receiving the first result, encompassing precompilation, package loading, and initial code execution. Systematic monitoring of these costs became a formal part of the Julia development pipeline on September 7, 2026, with performance tracking now integrated into continuous integration (CI) jobs for every commit to the master branch.

Substantial Reductions in Latency and Startup Time

One of the most prominent achievements in Julia 1.13 is the marked reduction in latency. According to official benchmarks, version 1.13 requires approximately 30% less time to precompile packages compared to version 1.12. When compared to the Long-Term Support (LTS) version 1.10, the improvement ranges between 10% and 20%, depending on the hardware configuration.

Startup speeds have also seen a notable boost. Benchmarks using the hyperfine tool demonstrate that a fresh Julia 1.13 session (without loading startup files) initializes in approximately 56.7 milliseconds, compared to 69.1 milliseconds in version 1.12. This represents a roughly 20% improvement in responsiveness, which is particularly beneficial for command-line tools and short-lived scripts.

The development team achieved these gains by optimizing how Julia handles the three primary costs of execution. By utilizing geometric means across 39 different real-world workflows, the team was able to identify bottlenecks in the compiler and loader, leading to a more streamlined initialization sequence.

Revolutionary Changes to Garbage Collection

Julia 1.13 introduces a fundamental change to the Garbage Collector (GC) that significantly reduces overhead for large applications. Previously, every full garbage collection cycle required the system to "walk through" and mark every object in the heap to determine reachability. This included thousands of objects loaded from the system image (sysimage) and package images—such as method tables, type information, and compiled constants—which are almost never freed or mutated.

In version 1.13, objects within the sysimage and package images are loaded as "permanently marked." The GC mark phase now skips these objects entirely, tracking only the rare mutations that occur when a method is added to an existing function. This architectural shift ensures that the cost of a full collection scales with the size of the program’s active heap rather than the total volume of loaded code.

The impact of this change is stark. In a bare session on an Apple M4 Pro, a full collection that previously took 35 milliseconds now takes only 2 milliseconds. For complex environments, such as those using the GLMakie visualization library, the collection time dropped from 187 milliseconds to 68 milliseconds. In real-world workloads involving heavy memory allocation and promotion to the "old generation" of objects, total execution time for specific tasks was reduced by more than 60%, with GC time dropping from nearly 80% of total runtime to approximately 44%.

Enhancements to the REPL and Windows Support

The Read-Eval-Print Loop (REPL), Julia’s interactive environment, has received several highly requested features. For the first time, syntax highlighting is available natively within the REPL without requiring external packages like OhMyREPL.jl. While the default color scheme is conservative to ensure readability across various terminal types, it is fully customizable, supporting popular themes such as Monokai.

Additionally, the REPL history search (accessed via Ctrl-R) has been redesigned to mimic the behavior of fzf, the popular command-line fuzzy finder. This allows for more intuitive and flexible searching through previous commands.

For Windows users, version 1.13 brings "bracketed paste" support, a feature long available on Linux and macOS. Bracketed paste allows the terminal to signal to the application when text is being pasted rather than typed manually. This prevents the REPL from attempting to evaluate every line individually during a large paste operation, dramatically increasing the speed and reliability of pasting large code blocks or multi-line functions.

Hashing Performance and RapidhashNano

The internal hashing architecture has undergone a major overhaul. Julia 1.13 replaces its previous MurmurHash3-based implementation with RapidhashNano. This change affects AbstractString, BigInt, Rational, and other large numeric types.

The benefits of this transition are three-fold:

1. Performance: Hashing long strings is now significantly faster. Benchmarks using text from Project Gutenberg show a reduction in hashing time from 8.55 microseconds to 1.74 microseconds.
2. Maintainability: The algorithm has been moved from C to pure Julia, making it easier for developers to inspect and maintain.
3. Flexibility: It is now a streaming hash, meaning it does not require the total length of the input to be known upfront.

While the new implementation offers better performance and improved "avalanching" (where a small change in input leads to a large change in the hash), developers are reminded that the hash function remains non-cryptographic. Furthermore, the default seed has changed, necessitating that custom hash methods strictly follow the API by accepting a seed argument.

Advancements in Package Management (Pkg)

The Julia package manager, Pkg, has been optimized for speed and efficiency. A primary change is the shift in default compression from gzip to zstd for downloads from package servers. For typical package data, zstd offers superior compression ratios and faster decompression. Tests involving the download of popular packages like Plots.jl and Makie.jl showed a 22% reduction in download size and a 37% improvement in decompression speed.

Other Pkg improvements include:

• Registry Efficiency: Micro-optimizations in the resolver and registry processing have nearly halved the time required to add packages to an environment.
• Manifest Intelligence: The registry source for each package is now recorded in the manifest, allowing for automatic registry installation during environment instantiation.
• Smart Versioning: When adding a new package, Pkg now prefers versions that align with already-loaded dependencies to avoid redundant precompilation.
• Testing Defaults: Pkg.test no longer forces strict bounds checking by default. This allows tests to reuse existing precompile cache files, significantly reducing the "wait time" before tests begin.

New Tools for Introspection and Trimming

The release introduces the @__FUNCTION__ macro, providing a public API to reference the innermost containing function, including anonymous ones. This complements existing macros like @__MODULE__ and @__FILE__.

For debugging and CI monitoring, the new --trace-eval command-line flag allows users to see top-level evaluation progress in real-time. This is particularly useful for identifying where a script or test suite might be hanging.

The JuliaC project, aimed at producing smaller, "trimmed" binaries of Julia programs, has been formalized into the JuliaC.jl package. It now supports the trimming of more complex language features, such as finalizers and @cfunction, moving the ecosystem closer to efficient static compilation and deployment.

Accessibility via Juliaup GUI

To improve accessibility for users who prefer graphical interfaces over command-line tools, Juliaup (the Julia version manager) now includes a cross-platform GUI. Users can manage multiple Julia versions, install specific release channels (including nightlies and pull request builds), and configure global settings through a visual dashboard. This represents a strategic move to lower the barrier to entry for new users and scientists who may not be accustomed to terminal-based version management.

Implications and Future Outlook

The release of Julia 1.13 signals a maturing ecosystem that is increasingly focused on the "quality of life" for developers and the efficiency of large-scale deployments. By addressing long-standing issues like GC overhead and Windows terminal limitations, Julia is positioning itself as a more formidable competitor in the broader data science and engineering landscape.

The improvements in JuliaC and the reduction in binary "bloat" suggest a future where Julia applications can be more easily deployed in resource-constrained environments or as standalone executables. Meanwhile, the rigorous performance tracking established during this cycle sets a new standard for future releases. The community is already looking toward version 1.14, with work underway on a formal task cancellation mechanism to further improve the language’s multi-threading and scheduling capabilities.