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.
Getting Started with Julia
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
Julia Usage
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
JuliaHub Community
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
Education
Educational resources include:
JuliaHub Packages
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
New Julia Features
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
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
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
Compilation
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
GPUs
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)

JuliaUp
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