# Julia (programming language)

> Source: https://aiwiki.ai/wiki/julia
> Updated: 2026-06-24
> Categories: Machine Learning, Programming Languages
> From AI Wiki (https://aiwiki.ai), a free encyclopedia of artificial intelligence. Quote with attribution.

**Julia** is a high-level, high-performance, dynamically typed [programming language](/wiki/programming_language) built for [technical computing](/wiki/numerical_analysis), [scientific computing](/wiki/scientific_computing), [machine learning](/wiki/machine_learning), and numerical analysis. It pairs the speed of compiled languages such as C with the ease of dynamic languages such as [Python](/wiki/python), reaching that combination through [just-in-time compilation](/wiki/jit_compilation) on the [LLVM](/wiki/llvm) compiler framework and [multiple dispatch](/wiki/multiple_dispatch) as its central paradigm. Julia was first released publicly in February 2012 by [Jeff Bezanson](/wiki/jeff_bezanson), [Stefan Karpinski](/wiki/stefan_karpinski), [Viral B. Shah](/wiki/viral_shah), and [Alan Edelman](/wiki/alan_edelman), who began work on it at the [MIT Computer Science and Artificial Intelligence Laboratory](/wiki/mit_csail) in 2009 [1][2].

After six years of public development, the milestone Julia 1.0 release arrived on August 8, 2018, at the JuliaCon conference in London, freezing the core language and standard library for long-term stability [2][7]. As of 2025 the language had been downloaded more than 100 million times, its [JuliaLang/julia](https://github.com/JuliaLang/julia) GitHub repository had over 48,000 stars and contributions from more than 1,400 developers, and its package ecosystem had grown to over 12,000 registered packages [4][8].

Julia was created to resolve the long-standing trade-off in scientific computing between languages that are productive but slow (such as Python, [R](/wiki/r_programming_language), and [MATLAB](/wiki/matlab)) and languages that are fast but tedious for high-level work (such as C and [Fortran](/wiki/fortran)). To bridge that gap, Julia combines a dynamic, expressive syntax with type specialization, a rich type system that supports parametric polymorphism, and native code generation. The result is code that frequently runs within a small constant factor of hand-tuned C while looking close to mathematical pseudocode [1][3].

The language is distributed under the permissive [MIT License](/wiki/mit_license) and developed in the open on GitHub. Commercial stewardship is provided by [JuliaHub](/wiki/juliahub), founded in 2015 by Julia's four co-founders and originally known as [Julia Computing](/wiki/julia_computing) [4][5].

## Who created Julia and when was it released?

Work on Julia began in 2009 at MIT, in the research group of applied mathematics professor [Alan Edelman](/wiki/alan_edelman). Jeff Bezanson, then a graduate student at MIT, joined Edelman's lab and was soon joined by Stefan Karpinski, who had a PhD in computer science from UC Santa Barbara, and Viral B. Shah, who had also completed his PhD at UCSB on parallel sparse matrix algorithms. The four shared a frustration with the patchwork of tools that scientific computing required: MATLAB for prototypes, R for statistics, Python with [NumPy](/wiki/numpy) for glue, and C or Fortran wherever performance mattered. Each language was strong in one area and clumsy in others, and code routinely had to be rewritten when projects moved from prototype to production [2][6].

The public unveiling came on February 14, 2012, when the four authors published a blog post titled "Why We Created Julia" on the Julia website. The post is short, cheerful, and unusually candid in stating ambitions. It opens with the line "In short, because we are greedy," then lists what the authors wanted: "We want the speed of C with the dynamism of Ruby. We want a language that's homoiconic, with true macros like Lisp, but with obvious, familiar mathematical notation like Matlab. We want something as usable for general programming as Python, as easy for statistics as R, as natural for string processing as Perl, as powerful for linear algebra as Matlab, as good at gluing programs together as the shell. Something that is dirt simple to learn, yet keeps the most serious hackers happy. We want it interactive and we want it compiled" [2].

The origin of the name "Julia" itself has no satisfying answer. In a 2012 mailing list thread, Bezanson said the name had no specific source, just that it was short, easy to type, and had good vowel sounds.

Development proceeded through a long sequence of 0.x releases, each accompanied by lively discussions on a public mailing list and, later, on the Julia Discourse forum. By 2014 the first JuliaCon was held at MIT, and in 2017 Julia became the first dynamic high-level language to exceed one petaflop of sustained performance, when the Celeste astronomical image analysis project hit a peak of 1.54 petaflops on the Cori supercomputer at NERSC and produced a catalog of 188 million astronomical objects in 14.6 minutes [3][7][26]. Julia 1.0 was tagged on August 8, 2018, locking the core language and standard library API for long-term stability [3][7].

## What are the design goals of Julia?

The "Why We Created Julia" post enumerates five central goals that have continued to shape every release since.

First, the founders insisted on **open source** licensing using the [MIT License](/wiki/mit_license), so that academic users, commercial users, and contributors would have no friction adopting the language [2].

Second, they wanted **performance comparable to C and Fortran** without forcing users to write loops in another language. To make that possible, the design committed to type inference, type specialization, and native code generation through [LLVM](/wiki/llvm) wherever possible [1][3].

Third, they made **multiple dispatch** the language's central organizing principle, drawing on prior art in [Common Lisp](/wiki/common_lisp)'s [CLOS](/wiki/clos) and the [Dylan programming language](/wiki/dylan_programming_language). In Julia, function behavior is selected based on the runtime types of all arguments, not just the first one as in single-dispatch object-oriented languages. This turns out to be deeply suited to scientific code, where binary operations like matrix multiplication or interpolation have natural definitions that depend on the types of every operand [8].

Fourth, the language embraces **generic programming**: a single piece of code can be written to operate on any numeric type, and the compiler will specialize it at call time. This means that an algorithm written for ordinary 64-bit floats works identically on arbitrary-precision rationals, dual numbers used in [automatic differentiation](/wiki/automatic_differentiation), unitful quantities, GPU arrays, and types that did not exist when the algorithm was authored [1][9].

Fifth, Julia includes **first-class support for parallel and distributed computation**. Channels, tasks, distributed arrays, and the `@distributed` and `Threads.@spawn` macros are part of the standard library, reflecting the founders' shared background in parallel computing [3].

## Key language features

Julia's surface syntax resembles MATLAB and Python, but it differs in important ways. Variables are dynamically typed by default and can hold any value, yet optional type annotations on function arguments drive both dispatch and code specialization. Type annotations are not casts: a declaration like `f(x::Float64)` describes which method should be called rather than coercing the input.

The language is **homoiconic** in the Lisp tradition. Every expression has a representation as an `Expr` value, and Julia exposes this through quoting (`:(...)`) and macros that transform syntax at compile time. This [homoiconicity](/wiki/homoiconicity) gives macros, generated functions, and domain-specific languages much of their power, and it makes [metaprogramming](/wiki/metaprogramming) a routine tool rather than an exotic technique [1][8].

Numeric work is supported by a comprehensive **numeric tower** that includes arbitrary-precision integers and rationals, IEEE 754 floats of multiple widths, complex numbers, and user-defined extensions. [Linear algebra](/wiki/linear_algebra) primitives ship in the standard library and call out to high-quality [BLAS](/wiki/blas) and [LAPACK](/wiki/lapack) implementations, including vendor builds, OpenBLAS, and MKL.

Identifiers may use the full range of [Unicode](/wiki/unicode) letter characters, so mathematical code can use Greek letters and mathematical symbols directly. The Julia REPL, Jupyter, and most editor plugins translate LaTeX-style escapes such as `\alpha` and `\partial` into their Unicode characters, which lets numerical code closely mirror the formulas it implements.

Functions are first-class. Closures, higher-order functions, lazy generators, and broadcasting via the dot syntax (`f.(x)`) are idiomatic. The compiler's inlining and specialization are aggressive enough that broadcasting a small lambda over an array typically produces a tight fused loop without allocating intermediate temporaries.

Memory management is performed by a **non-moving generational** [garbage collector](/wiki/garbage_collection). Multithreading was added in Julia 1.3 (2019) and substantially improved in 1.7 and later releases. The **foreign function interface** allows direct calls to C and Fortran routines through the `ccall` and `@ccall` constructs without any glue code or compilation step, which makes wrapping legacy numerical libraries straightforward.

Reflection is built in. Macros like `@code_warntype`, `@code_typed`, `@code_llvm`, and `@code_native` show what the compiler infers and emits for any call, exposing performance issues at the language level.

## How fast is Julia?

The project maintains a microbenchmarks page at [julialang.org/benchmarks](https://julialang.org/benchmarks) that compares Julia to roughly a dozen other languages on tasks such as Mandelbrot iteration, recursion-heavy Fibonacci, matrix multiplication via BLAS, and simulated random walks. Julia consistently runs within roughly 1x to 3x of C on those benchmarks, well ahead of pure Python, R, and MATLAB and competitive with Java, Go, and LuaJIT. The methodology was published in the Julia team's 2017 *SIAM Review* paper, "Julia: A Fresh Approach to Numerical Computing" [1][10].

The single most discussed weakness of Julia is **first-call latency**, often shorthanded as "time to first plot" or TTFP. Because the language compiles methods on demand, the first call into a large package like `Plots.jl` historically took several seconds while LLVM lowered code for many specializations. Julia 1.6 (March 2021) introduced multithreaded precompilation; Julia 1.9 (May 9, 2023) shipped native code caching that allowed packages to store compiled native code on disk; and Julia 1.10, 1.11, and 1.12 extended these gains, reducing TTFP from many seconds to roughly the cost of loading the dynamic library [11][12].

## What is multiple dispatch in Julia?

Several languages have multiple dispatch as a feature. Julia is unusual in making it the **only** way to define methods. There are no instance methods attached to a class. Instead, all functions are open generic functions, and any module can add new methods for new combinations of types. This design choice has significant consequences for software composition.

In his JuliaCon 2019 keynote "The Unreasonable Effectiveness of Multiple Dispatch," Stefan Karpinski argued that the central payoff of multiple dispatch is **composability**: independently authored packages tend to work together without coordination. If package A defines a new numeric type that behaves like a real number, and package B defines a generic numerical algorithm, then code from B can be called on values from A without either author anticipating the other [13].

A closely related concept is **type stability**. A function is type-stable if, for any concrete combination of input types, the compiler can infer a single concrete output type. Type-stable code is the precondition for fast specialized native code in inner loops, so Julia programmers think carefully about types in performance-critical functions even though types are optional in casual code.

The combination of multiple dispatch, generic programming, and aggressive specialization is sometimes credited with solving the **two-language problem**: the workflow in which scientists prototype in a slow productive language, then rewrite hot loops in a fast tedious language for production. Julia aims to make rewriting unnecessary by being productive enough for prototyping and fast enough for production in the same source [1][2].

## Version history

| Version | Release date | Notable changes |
| --- | --- | --- |
| 0.1 | February 2013 | First public versioned release. |
| 0.2 | November 2013 | Improved package manager, more standard library coverage. |
| 0.3 | August 2014 | Mandatory inner constructors, faster code generation. |
| 0.4 | October 2015 | Function-call overhaul, generated functions. |
| 0.5 | October 2016 | Anonymous functions become as fast as named ones; closures, comprehensions overhaul. |
| 0.6 | June 2017 | Where syntax for type parameters, improved type system. |
| 0.7 / 1.0 | August 8, 2018 | API freeze; Julia 1.0 released at JuliaCon London. |
| 1.1 | January 2019 | Exception stack support. |
| 1.2 | August 2019 | Improved threading primitives. |
| 1.3 | November 2019 | Composable multithreading via partr. |
| 1.4 | March 2020 | Multithreaded I/O improvements. |
| 1.5 | August 2020 | Per-thread random number generators, struct field changes. |
| 1.6 | March 2021 | First long-term support release; faster precompilation. |
| 1.7 | November 2021 | New random number generator, improved package manager. |
| 1.8 | August 2022 | Mutable struct fields can be const, improved error messages. |
| 1.9 | May 9, 2023 | Native code caching for packages, large reduction in latency. |
| 1.10 | December 25, 2023 | New parser, more precompilation gains, LTS release. |
| 1.11 | October 7, 2024 | Public API keyword, GC improvements, faster startup. |
| 1.12 | October 7, 2025 | Redefinable types, experimental --trim for smaller binaries, interactive threadpool. |

Dates are drawn from the official release archive at julialang.org/downloads/ and the JuliaLang/julia GitHub release page [11][12].

## Package ecosystem

Julia ships with a built-in package manager called **Pkg.jl**, accessible from the REPL through a dedicated package mode (typed by pressing `]`). Packages are registered in the **General registry**, a Git repository that lists package names, versions, and dependencies. The registry has grown from roughly 2,000 packages at the Julia 1.0 release to more than 12,000 registered packages by 2024-2025, with new ones added daily. Julia uses semantic versioning and a Pkg-resolved manifest file so that environments are exactly reproducible across machines [14].

Several packages are widely used and have become defining for the ecosystem. In numerical work, [DifferentialEquations.jl](/wiki/differentialequations_julia) by [Chris Rackauckas](/wiki/chris_rackauckas) is regularly described as the most comprehensive differential equation solver in any language, with implementations of ordinary, stochastic, delay, and partial differential equation methods, plus stiff solvers and event handling. The package is the technical heart of the Pumas pharmacometrics platform and the wider SciML ecosystem [15][16].

[JuMP.jl](/wiki/jump_julia) is a domain-specific language for mathematical [optimization](/wiki/optimization), spanning linear, mixed-integer, conic, and nonlinear programming. It links to dozens of solvers including Gurobi, CPLEX, and the open-source HiGHS, GLPK, and Ipopt. JuMP is widely used in operations research courses and has been cited in thousands of papers [17].

For data and statistics, **DataFrames.jl** provides an in-memory tabular data structure similar to pandas, **Distributions.jl** implements probability distributions, and **StatsBase.jl** and **GLM.jl** cover descriptive and regression statistics. Visualization is split among **Plots.jl**, [Makie.jl](/wiki/makie_julia) for high-performance interactive figures, and **Gadfly.jl** for grammar-of-graphics style plotting.

For [GPU computing](/wiki/gpu_computing), [CUDA.jl](/wiki/cuda_julia), **AMDGPU.jl**, and **oneAPI.jl** allow Julia kernels to be compiled to NVIDIA, AMD, and Intel devices respectively. Reactive notebooks are provided by [Pluto.jl](/wiki/pluto_julia), which differs from Jupyter in that it tracks dependencies among cells and re-evaluates downstream cells automatically. **Genie.jl** is a full-stack web framework.

## JuliaHub

JuliaHub is the company that supports commercial use of Julia and employs many of its core developers. It was founded in 2015 in Boston by the four Julia co-founders under the name Julia Computing, and it renamed itself to [JuliaHub](/wiki/juliahub) in March 2022 to coincide with a new product strategy centered on its cloud platform of the same name [4][18].

JuliaHub raised a Series A round of $24 million in July 2021, led by Dorilton Ventures with participation from Menlo Ventures, General Catalyst, and HighSage Ventures; Bob Muglia, the former Snowflake chief executive, joined its board at the same time. Its products include **JuliaSim**, a simulation environment integrating differential equations, surrogate modeling, and the SciML stack, and **JuliaHub Cloud**, a hosted environment for running Julia code at scale on cloud GPUs and CPUs. The company also distributes a long-term-supported enterprise build of Julia [4][5].

[Viral B. Shah](/wiki/viral_shah) serves as CEO. [Jeff Bezanson](/wiki/jeff_bezanson) leads compiler engineering. [Stefan Karpinski](/wiki/stefan_karpinski) holds senior engineering and language design roles. [Alan Edelman](/wiki/alan_edelman) remains a professor at MIT and serves on the JuliaHub board.

## How is Julia used in AI and machine learning?

Julia has not become a mainstream language for training large foundation models, where Python plus [PyTorch](/wiki/pytorch) or [JAX](/wiki/jax) dominates. It has, however, established a distinct niche in [scientific machine learning](/wiki/scientific_machine_learning), differentiable programming, and probabilistic computing, where its multiple dispatch, composability, and native performance offer real advantages.

The most prominent deep learning library is [Flux.jl](/wiki/flux_julia), originated by [Mike Innes](/wiki/mike_innes) in 2017. Flux is unusual in that it is implemented entirely in Julia: there is no separate C++ runtime, layers are ordinary Julia functions, and the autodiff backend operates on Julia source code. This means a Flux model can include arbitrary control flow, custom numeric types, or domain-specific operators, and the compiler will still produce specialized native code [19].

[Lux.jl](/wiki/lux_julia), developed by Avik Pal, is a more recent deep learning library built around explicit state and immutable parameter structures, designed to fit cleanly into automatic differentiation pipelines. [MLJ.jl](/wiki/mlj_julia) is a unifying machine learning toolkit modeled in part on R's mlr3 and Python's scikit-learn, providing a consistent interface across decision trees, generalized linear models, and neural networks.

[Automatic differentiation](/wiki/automatic_differentiation) is a particular strength of the Julia ecosystem. **Zygote.jl** performs reverse-mode source-to-source differentiation on Julia code, **Diffractor.jl** explores higher-order and forward-mode differentiation, and **Enzyme.jl** is a Julia frontend to the Enzyme LLVM-level autodiff system that can differentiate code lowered to LLVM IR, including code originally written in C and Fortran. Together these tools allow gradients to be taken through differential equation solvers, GPU kernels, and other code that would be hard to differentiate in conventional ML frameworks.

The **SciML** ecosystem, organized largely by Chris Rackauckas, integrates differential equations, optimization, automatic differentiation, and neural networks under a coherent umbrella. A flagship concept is **universal differential equations**, in which a partly-known scientific model is augmented with a neural network that learns the unknown physics from data, blending mechanism and learning [16][20].

In [probabilistic programming](/wiki/probabilistic_programming), [Turing.jl](/wiki/turing_julia) provides a flexible Julia-native interface for Bayesian inference with Hamiltonian Monte Carlo, particle filters, and variational inference. **Gen.jl**, originated at MIT, takes a different approach focused on programmable inference. **Stan.jl** wraps the Stan modeling language for users coming from that community.

Natural language processing and large-language-model tooling exist in Julia but are less mature than in Python. **Transformers.jl** by [Peter Cheng](/wiki/peter_cheng) implements the transformer architecture and supports loading pretrained weights from Hugging Face checkpoints. **Llama2.jl** is a community port of the llama2.c reference implementation. These projects support inference and small-scale research but are not used for industrial-scale training.

## How does Julia compare to Python for AI and ML?

For the dominant deep learning workflow, training and serving large neural networks, Python is the de facto standard: PyTorch, JAX, TensorFlow, Hugging Face Transformers, and vLLM all assume a Python front end, and the talent pool and tutorials are overwhelmingly Python-centric. Julia's deep learning libraries (Flux.jl, Lux.jl) and its NLP tooling (Transformers.jl) are capable for research and small-scale work but are not used for industrial-scale model training, so teams that must integrate with that infrastructure typically stay in Python.

Julia's comparative advantage lies elsewhere. On the official microbenchmarks it runs roughly 1x to 3x the speed of C and far ahead of pure Python, which removes the need to drop into C extensions for hot loops, a workaround that defines much of the [NumPy](/wiki/numpy) and PyTorch design [1][10]. Because the same source is fast enough for production, Julia directly targets the **two-language problem** rather than papering over it. The language's multiple dispatch makes packages unusually composable, so a generic algorithm and a custom numeric type from different authors tend to work together unmodified [13]. And [automatic differentiation](/wiki/automatic_differentiation) in Julia can differentiate ordinary Julia code, including differential equation solvers and GPU kernels, which underpins the [scientific machine learning](/wiki/scientific_machine_learning) and differentiable programming use cases where Julia is strongest [16][20]. The main costs relative to Python are a smaller ecosystem and talent pool and residual first-call latency, though the latter has fallen sharply since native code caching landed in Julia 1.9 [11][12].

## Adoption

Julia has been adopted in academia and industry, particularly in fields where high-performance numerical and scientific computing are central.

In academia, Julia is used for teaching at MIT, Stanford, ETH Zurich, Caltech, and many other research universities. Alan Edelman's MIT course "Computational Thinking" is taught in Julia and uses Pluto notebooks [3].

In finance, Julia has been used at the **Federal Reserve Bank of New York** for the FRBNY DSGE macroeconomic model, by **BlackRock** for time-series analysis in its Aladdin platform, and by **Aviva** for Solvency II capital modeling. According to Tim Thornham, Aviva's director of financial modeling solutions, the insurer's Julia models ran "one thousand times faster" than its previous IBM Algorithmics system while using 93% fewer lines of code, and the server cluster needed to run its risk simulations shrank from about 100 machines to 5 [21].

In pharmaceuticals, [Pumas-AI](/wiki/pumas_ai) uses Julia for clinical pharmacometrics, with regulatory-grade tooling for population pharmacokinetic and pharmacodynamic modeling. Pfizer, AstraZeneca, and Moderna have publicly discussed using Pumas in clinical trial analysis [22].

In aerospace and defense, **NASA**, **MIT Lincoln Laboratory**, and the **Air Force Research Laboratory** have used Julia for simulation and data analysis. In climate science, the [Climate Modeling Alliance](/wiki/clima) (CliMA) is building a next-generation Earth system model in Julia, and its [Oceananigans.jl](/wiki/oceananigans) package is a high-performance ocean modeling library that runs on GPUs [23][24]. Google has used Julia in smaller research projects, including some early work in Google Brain.

## Strengths and trade-offs

Julia's principal strengths are speed, expressiveness, and composability. Code written for one type often works on a wide range of types without modification, library authors can build sophisticated abstractions on top of multiple dispatch, and the same source can be used for prototyping and production. The scientific library quality, especially for differential equations, optimization, automatic differentiation, and probabilistic modeling, is unusually deep for a language of Julia's size [1][8][13].

The language's main weaknesses are an ecosystem still smaller than Python's, residual first-call latency despite recent improvements, occasional package compatibility churn driven by rapid evolution of widely used packages, and a smaller talent pool. Julia's interoperation with the deep learning industry standard PyTorch is limited, and projects that need to integrate tightly with Hugging Face Transformers, vLLM, or other Python-centric infrastructure typically default to Python. For workloads that fit Julia's sweet spot of numerical and scientific computing, however, the trade-offs increasingly favor Julia.

## Conferences and community

The annual **JuliaCon** conference has been held since 2014, originally at MIT and later at venues including the University of Maryland, with online editions during the pandemic. Recordings of every talk are posted to the JuliaLang YouTube channel and have become a primary teaching resource for the community [25].

The primary online community gathering is the **Julia Discourse forum** at discourse.julialang.org, which is unusually active and has a reputation for thorough, technical answers. The community also maintains active Slack and Zulip workspaces. Core development is coordinated on the [JuliaLang/julia](https://github.com/JuliaLang/julia) GitHub repository, which has accumulated more than 48,000 stars and contributions from over 1,400 developers. The Julia Lab at MIT, led by Alan Edelman, continues to host academic research on the language [8].

## Code example

The following snippet illustrates Julia's syntax, including ternary expressions, type annotations, and multiple dispatch on the `greet` function. The two methods of `greet` differ only in the type of their argument, and Julia selects the correct one at every call site.

```julia
# Recursive factorial with a type annotation
function factorial(n::Int)
    n <= 1 ? 1 : n * factorial(n - 1)
end

factorial(5)  # returns 120

# Multiple dispatch on argument type
greet(x::String) = "Hello, $x"
greet(x::Int)    = "You are number $x"

greet("Alice")  # "Hello, Alice"
greet(42)       # "You are number 42"

# A generic function that works on any numeric type, including
# user-defined ones, GPU arrays, and dual numbers used in
# automatic differentiation.
rosenbrock(x, y) = (1 - x)^2 + 100 * (y - x^2)^2
```

The `rosenbrock` function above carries no type annotations. The compiler will specialize it independently for `Float64`, `BigFloat`, complex numbers, dual numbers used by ForwardDiff, and CUDA array elements, producing tight native code in each case.

## See also

- [Multiple dispatch](/wiki/multiple_dispatch)
- [Just-in-time compilation](/wiki/jit_compilation)
- [LLVM](/wiki/llvm)
- [Automatic differentiation](/wiki/automatic_differentiation)
- [Scientific machine learning](/wiki/scientific_machine_learning)
- [Flux.jl](/wiki/flux_julia)
- [DifferentialEquations.jl](/wiki/differentialequations_julia)
- [JuMP.jl](/wiki/jump_julia)
- [Turing.jl](/wiki/turing_julia)
- [JuliaHub](/wiki/juliahub)
- [JuliaCon](/wiki/juliacon)
- [Common Lisp](/wiki/common_lisp)
- [Python](/wiki/python)
- [MATLAB](/wiki/matlab)
- [Fortran](/wiki/fortran)
- [Climate Modeling Alliance](/wiki/clima)
- [Pumas-AI](/wiki/pumas_ai)

## References

1. Bezanson, J., Edelman, A., Karpinski, S., & Shah, V. B. (2017). "Julia: A Fresh Approach to Numerical Computing." *SIAM Review*, 59(1), 65-98. https://julialang.org/research/julia-fresh-approach-BEKS.pdf
2. Bezanson, J., Karpinski, S., Shah, V. B., & Edelman, A. (2012, February 14). "Why We Created Julia." *Julia Language Blog*. https://julialang.org/blog/2012/02/why-we-created-julia/
3. The Julia Language. "Julia Documentation." https://docs.julialang.org/
4. JuliaHub. "About JuliaHub." https://juliahub.com/company/about
5. JuliaHub blog. "Julia Computing is now JuliaHub." March 2022. https://juliahub.com/blog/julia-computing-is-now-juliahub
6. "Reinventing the Wheel." (2018). MIT News profile of Alan Edelman and the Julia project. https://news.mit.edu/
7. The Julia Language. "Julia 1.0 has been released." August 8, 2018. https://julialang.org/blog/2018/08/one-point-zero/
8. JuliaLang/julia. GitHub repository. https://github.com/JuliaLang/julia
9. Revels, J., Lubin, M., & Papamarkou, T. (2016). "Forward-Mode Automatic Differentiation in Julia." arXiv:1607.07892. https://arxiv.org/abs/1607.07892
10. The Julia Language. "Julia Microbenchmarks." https://julialang.org/benchmarks/
11. The Julia Language. "Downloads and release archive." https://julialang.org/downloads/
12. The Julia Language. "Announcing the release of Julia 1.9." May 9, 2023. https://julialang.org/blog/2023/04/julia-1.9-highlights/
13. Karpinski, S. (2019). "The Unreasonable Effectiveness of Multiple Dispatch." JuliaCon 2019 keynote. https://www.youtube.com/watch?v=kc9HwsxE1OY
14. JuliaRegistries/General. "General Julia package registry." https://github.com/JuliaRegistries/General
15. Rackauckas, C., & Nie, Q. (2017). "DifferentialEquations.jl: A Performant and Feature-Rich Ecosystem for Solving Differential Equations in Julia." *Journal of Open Research Software*, 5(1), 15. https://openresearchsoftware.metajnl.com/articles/10.5334/jors.151
16. SciML Open Source Scientific Machine Learning. https://sciml.ai/
17. Lubin, M., Dowson, O., Garcia, J. D., Huchette, J., Legat, B., & Vielma, J. P. (2023). "JuMP 1.0: Recent improvements to a modeling language for mathematical optimization." *Mathematical Programming Computation*, 15, 581-589. https://jump.dev/
18. The Information. (2022). "Julia Computing rebrands as JuliaHub." https://www.theinformation.com/
19. Innes, M. (2018). "Flux: Elegant machine learning with Julia." *Journal of Open Source Software*, 3(25), 602. https://fluxml.ai/
20. Rackauckas, C., et al. (2020). "Universal Differential Equations for Scientific Machine Learning." arXiv:2001.04385. https://arxiv.org/abs/2001.04385
21. JuliaHub case studies. "Aviva: Robust risk modeling with JuliaHub." https://juliahub.com/industries/case-studies/aviva
22. Pumas-AI. "Pharmacometrics on Julia." https://pumas.ai/
23. Climate Modeling Alliance. https://clima.caltech.edu/
24. Ramadhan, A., et al. (2020). "Oceananigans.jl: Fast and friendly geophysical fluid dynamics on GPUs." *Journal of Open Source Software*, 5(53), 2018. https://github.com/CliMA/Oceananigans.jl
25. JuliaCon. "Annual conference for the Julia programming language." https://juliacon.org/
26. NumFOCUS. "Julia Joins Petaflop Club." 2017. https://numfocus.org/blog/julia-joins-petaflop-club