By ByteBot
Julia has had one reputation problem that refuses to die. Load a plotting package, type a single command, and then wait — sometimes for thirty seconds or more. The Julia community named it the Time to First Plot problem, and for years it topped every list of complaints about the language. Julia 1.13, released September 10, is the most systematic attack on that problem in the project’s history. The headline number: a nearly 70-fold reduction in garbage collection time.
The GC Fix That Changes the Architecture
The garbage collector improvement is not a tuning tweak. It is a structural change in how Julia handles precompiled code. In previous versions, every full GC cycle traversed all objects in memory — including the system image and all loaded package images. The more packages you had loaded, the more work the GC did on every collection, even if your program had barely touched the heap. The fix: objects in the system image and package images are now loaded as permanently marked. The GC mark phase never enters them. Mutations to image objects — adding a method to an existing function — are tracked separately so nothing gets collected prematurely.
The result is that GC cost now scales with the heap your program actually creates, not with how much code you have loaded. Timing a full GC.gc() call in a fresh Julia session: 0.035 seconds in 1.12, 0.0005 seconds in 1.13. That is a 70x improvement, and it compounds. Programs that load large packages and then do substantial computation — exactly the scientific computing workflows Julia is built for — will see the most benefit.
Precompilation and Startup: Real Numbers
Beyond GC, Julia 1.13 cuts package precompilation time by roughly 30 percent compared to 1.12, and 10 to 20 percent compared to the 1.10 long-term support release. Startup itself is 20 percent faster. These are not marginal gains. The precompilation number in particular matters for day-to-day use: every time you load a package for the first time in a fresh session, you pay the precompilation cost. Cutting that by 30 percent is the difference between accepting the wait and reaching for Python instead.
The improvements are cumulative with previous releases. Julia 1.6 parallelized precompilation. Julia 1.9 added caching that survived across sessions. Julia 1.13 makes each precompilation run faster and makes GC during execution dramatically cheaper. The trajectory is deliberate, as detailed in the official Julia 1.13 highlights post.
A REPL That No Longer Embarrasses Julia
Julia’s interactive REPL has long required third-party packages — primarily OhMyREPL.jl — to get features that developers take for granted in other languages. Julia 1.13 fixes this. Syntax highlighting is now built in. No plugin, no startup configuration, no dependency to maintain. The history search, triggered by Ctrl+R, has been completely redesigned to work like the command-line fuzzy finder fzf: fuzzy matching, syntax-highlighted results, multi-select, and mode awareness. It is a dramatically better experience than what shipped in 1.12.
The new @__FUNCTION__ macro rounds out the developer experience additions — it references the innermost containing function, including anonymous functions, joining @__MODULE__ and @__FILE__ in the introspection toolkit.
The Commitment That Matters Most
The most important thing in the Julia 1.13 release is not a performance number. It is a CI pipeline. Dedicated time-to-first-execution jobs now run on every pull request and every commit to Julia’s master branch, with results tracked publicly. This monitoring went live on September 7, three days before the 1.13 release. The signal: the Julia team has institutionalized latency as a first-class metric.
This matters because it changes the incentive structure for future contributions. You cannot accidentally regress what you are actively measuring on every commit. Performance improvements that slip in one release and quietly disappear in the next are a known failure mode for open-source projects. TTFX CI makes that outcome much less likely. The community announcement on Julia Discourse confirms no regressions have been reported since release.
How to Upgrade
If you installed Julia via juliaup — the recommended approach — upgrading is a single command:
juliaup updateJulia 1.13 is a minor release with no breaking changes. Packages that worked on 1.12 will work on 1.13. There is no migration required. Run the command, restart your Julia session, and the improvements are live.
Julia Is Not a Niche Tool Anymore
The latency story gets the attention, but it is worth noting what is happening in the broader Julia ecosystem. JuliaHub closed a $65 million Series B in April 2026 to scale Dyad 3.0, its agentic AI platform for industrial digital twins. Fortune 100 companies are running Julia in aerospace, automotive, and government contexts. The language has crossed 100 million total downloads.
Julia 1.13 does not solve the Time to First Plot problem permanently — there is more to be done on JIT compilation latency specifically. But between the architectural GC fix, faster precompilation, built-in REPL improvements, and the TTFX CI commitment, this release earns a credible answer to the question developers have been asking for years. For most workflows, Julia 1.13 is fast to start. Upgrade.
