Skip to content
JuliaHub Search Icon - Search Julia Packages

State of Julia 2024

Andrew Claster
JuliaHub Blog Home Icon Gray

Kristoffer Carlsson (JuliaHub Software Engineer), Lilith Hafner and Dr. Elliot Saba (JuliaHub Director of EDA Engineering) presented the State of Julia 2024 during JuliaCon on July 9, 2024 in Eindhoven, Netherlands.

The video is available on YouTube, and you can scroll ahead to the 1:00:45 mark (one hour, zero minutes, 45 seconds) to watch it.

Kristoffer Carlsson opened the talk with an example to represent a typical experience using Julia. The example involved modeling the gravitational force between planets to demonstrate the following characteristics of the Julia experience:

  • Useful packages
  • Generic code
  • High level abstractions
  • Little boilerplate - easy to find code

As Kristoffer explained, Julia users often want to be able to evaluate performance - they want to see that their program runs fast in Julia. Here, the benefits of Julia include:

  • Helpful package manager - identifies and installs packages
  • Convenient benchmark syntax
  • Zero-cost abstractions for runtime
  • Fast modify-benchmark iteration
  • Code inspection - LLVM and native code
  • Static checks

In this example, Kristoffer also demonstrated the process of deploying multiple threads using GPUs. This process includes:

  • Local installation of Julia using JuliaUp
  • Copying code and installing packages in under 2 minutes
  • Modifying code to leverage GPUs
  • Demonstrating the value of GPUs

But Julia is not only for numerical computing. Today, Julia is used to create graphic art, video games, Websites, and Web apps.

Elliot Saba followed Kristoffer with some statistics demonstrating Julia’s growth. 

  • 170 TBs through package server every month
  • 2.5 million unique IP addresses worldwide
  • New package registered and served every 7 hours
  • New package version every 24 minutes
  • 135 requests per second to check for new registries
  • 40,000+ GitHub stars for Julia and 400,000+ GitHub stars for Julia packages
  • Industrial adoption: ASML, Williams Racing, United Therapeutics, WhatsApp, NASA, Cisco, AstraZeneca, Federal Reserve Bank of New York, Pfizer, IBM, Boeing, BlackRock

Lilith Hafner continued the presentation with news about the growth of the Julia community.

Channels for communication and community building include:

  • Discourse
  • GitHub
  • Zulip
  • Slack
  • JuliaCon

Educational resources include:

Contributing to Julia packages and creating new Julia packages is a great way to participate in the Julia community.

  • Transition from personal code to reusable code - easy to register and share
  • 1,430 new packages registered in previous year
  • Package development scalable and low risk
  • Most users depend on Julia packages - key to the Julia experience
  • Almost anything can be accomplished in a package
  • Also encourage contributing to base Julia language
  • “If you want to be productive, you need good packages”
  • CUDA.jl, JuliaSyntax.jl, Pkg.jl are all Julia packages

Kristoffer continued the presentation with an update about new and improved Julia features and characteristics.

  • Julia is better than ever
  • Many users who tried Julia years ago reported that it took a long time to plot and it didn’t have the packages I needed
  • These are no longer major problems for most Julia users
  • Time to first plot has declined from 16 seconds to 1.4 seconds from Julia 1.0 to Julia 1.10
  • The number of packages has increased from 2,000 to 10,000+ over the same time period
  • Julia 1.10 will be the new long term support (LTS) version of Julia, replacing Julia 1.6
  • Moving standard libraries (stdlibs) out from system image (sysimage)
  • Faster Julia startup time
  • Allows for upgradable and versioned standard libraries
  • Standard libraries will no longer get an ‘unfair’ advantage (other than being bundled) compared with other packages
  • Some standard libraries will remain in the system image
Pkg improvements

[sources] (1.11)

  • Used to have to bundle a manifest to instantiate a project with unregistered dependencies
  • Can now specify URLs/paths to packages in project file

[workspace] (1.12)

  • Multiple project files can share a single manifest file (single source of truth)
  • Useful for monorepos or/and when using many private packages

Apps (upcoming)

  • Install command line tools with Julia package manager

Elliot Saba followed with an update on static compilation analysis.

At JuliaCon 2023, there were presentations about static compilation, including reducing reliance on just-in-time (JIT) compilation and loading libLLVM

This year, three JuliaCon presentations address progress that has been made in this area:

  • Writing Allocation-Free Julia Code with AllocCheck.jl (Gabriel Baraldi, Cody Tapscott)
  • Julia Compiler Secrets - Static Analysis (Keno Fischer, Shuhei Kadowaki)
  • New Ways to Compile Julia (Jeff Bezanson, Gabriel Baraldi)

Elliot explains:

  • Julia is a dynamic but compiled language
  • There are static subgraphs in most programs where there is no dynamic behavior
  • Used by inference to infer types to open up for optimizations
  • More and more interest in finding properties about the program without executing it
    • JET.jl bugs, type instabilities
    • AllocCheck.jl: allocations
  • juliac - what if the whole program is type stable?
    • No need for compiler (libLLVM), can ‘tree shake’ away most code

Furthermore, there have been significant improvements to the GPU stack.

  • CUDA.jl: Integrated performance profiler, simplified application porting (unified memory)
  • AMDGPU.jl: Improved GC integration, extended BLAS/LAPACK wrappers
  • oneAPI.jl: Support for Aurora supercomputer (with Ponte Vecchio GPUs)
  • Metal.jl: Greatly improved usability and maturity
  • GPUCompiler.jl: Integration with Julia’s precompilation cache -> latency improvements
  • JuliaCon 2024 presentations
    • JuliaGPU BoF (Valentin Churavy, Katharine Hyatt, Tim Besard)
    • Updates and Advances in CUDA.jl and oneAPI.jl (Tim Besard)

Lilith Hafner then presented JuliaUp, the recommended way to install Julia. Features include:

  • Prompts when there are new versions of Julia
  • Allows multiple different versions of Julia simultaneously
  • Support for long-term support (LTS) version, current release, pre-releases, nightly
  • Coming soon: Pull Request channel support

AnnotatedString and StyledStrings

  • A new type (AnnotatedString) and standard library (StyledStrings) provide reusable, composable, user-customizable styling
  • First-class support for styling to enable prettier experiences through the stdlib, ecosystem and beyond
    • Sidesteps printstyled pitfalls, like having to strip/parse escape sequences when operating printstyled-produced string
    • Also allows for arbitrary semantic information to be associated with regions of text
  • Work to make the most of this new capability has just started
    • Supported in Logging (1.11+)
    • Used in Markdown (1.12+)
    • Part of a project to introduce a next-generation REPL experience

REPL Improvements

  • Autocompletion - inline suggestions
  • Syntax highlighted code in help mode (StyledStrings + JuliaSyntaxHighlighting)
  • Better, more informative, error messages and suggestions
  • Parallel pre-compilation on package loading

Implementation of Julia lowering, in Julia

  • Julia 1.10 brought a new Julia parser (source code -> AST), written in Julia
  • Lowering (AST -> lowered code) is still written in scheme and mostly opaque to the compiler and tools
  • Compiler often doesn’t know which part of the code it is analyzing (e.g. ‘error in expression starting on line’
  • Tooling like Revise needs to reimplement or work around lack of support from Julia’s lowering compiler pass
  • Extra goodies for macro authors - no more esc() + more

Recent Posts

Learn More

Want to learn more about our capabilities? We are here to help.

Contact Sales